avoid converting to Rule to collect rule codes

restore Rule in output

Author: ntBre

crates/ruff/src/printer.rs

@@ -6,7 +6,7 @@ use anyhow::Result;
 use bitflags::bitflags;
 use colored::Colorize;
 use itertools::{Itertools, iterate};
-use ruff_linter::codes::NoqaCode;
+use ruff_linter::codes::{NoqaCode, Rule};
 use serde::Serialize;
 
 use ruff_linter::fs::relativize_path;
@@ -498,12 +498,13 @@ fn print_fix_summary(writer: &mut dyn Write, fixed: &FixMap) -> Result<()> {
             relativize_path(filename).bold(),
             ":".cyan()
         )?;
-        for (rule, count) in table.iter().sorted_by_key(|(.., count)| Reverse(*count)) {
+        for (code, count) in table.iter().sorted_by_key(|(.., count)| Reverse(*count)) {
+            let code = code.to_string();
             writeln!(
                 writer,
                 "    {count:>num_digits$} × {} ({})",
-                rule.noqa_code().to_string().red().bold(),
-                rule.as_ref(),
+                code.red().bold(),
+                Rule::from_code(&code).map_or(code, |rule| rule.to_string()),
             )?;
         }
     }

crates/ruff_linter/src/codes.rs

@@ -10,7 +10,7 @@ use crate::registry::Linter;
 use crate::rule_selector::is_single_rule_selector;
 use crate::rules;
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct NoqaCode(&'static str, &'static str);
 
 impl NoqaCode {

crates/ruff_linter/src/fix/mod.rs

@@ -7,6 +7,7 @@ use ruff_diagnostics::{IsolationLevel, SourceMap};
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 
 use crate::Locator;
+use crate::codes::NoqaCode;
 use crate::linter::FixTable;
 use crate::message::OldDiagnostic;
 use crate::registry::Rule;
@@ -63,7 +64,7 @@ fn apply_fixes<'a>(
     let mut source_map = SourceMap::default();
 
     for (rule, fix) in diagnostics
-        .filter_map(|msg| msg.to_rule().map(|rule| (rule, msg)))
+        .filter_map(|msg| msg.to_noqa_code().map(|rule| (rule, msg)))
         .filter_map(|(rule, diagnostic)| diagnostic.fix().map(|fix| (rule, fix)))
         .sorted_by(|(rule1, fix1), (rule2, fix2)| cmp_fix(*rule1, *rule2, fix1, fix2))
     {
@@ -125,34 +126,44 @@ fn apply_fixes<'a>(
 }
 
 /// Compare two fixes.
-fn cmp_fix(rule1: Rule, rule2: Rule, fix1: &Fix, fix2: &Fix) -> std::cmp::Ordering {
+fn cmp_fix(rule1: NoqaCode, rule2: NoqaCode, fix1: &Fix, fix2: &Fix) -> std::cmp::Ordering {
     // Always apply `RedefinedWhileUnused` before `UnusedImport`, as the latter can end up fixing
     // the former. But we can't apply this just for `RedefinedWhileUnused` and `UnusedImport` because it violates
     // `< is transitive: a < b and b < c implies a < c. The same must hold for both == and >.`
     // See https://github.com/astral-sh/ruff/issues/12469#issuecomment-2244392085
-    match (rule1, rule2) {
-        (Rule::RedefinedWhileUnused, Rule::RedefinedWhileUnused) => std::cmp::Ordering::Equal,
-        (Rule::RedefinedWhileUnused, _) => std::cmp::Ordering::Less,
-        (_, Rule::RedefinedWhileUnused) => std::cmp::Ordering::Greater,
-        _ => std::cmp::Ordering::Equal,
+    let redefined_while_unused = Rule::RedefinedWhileUnused.noqa_code();
+    if (rule1, rule2) == (redefined_while_unused, redefined_while_unused) {
+        std::cmp::Ordering::Equal
+    } else if rule1 == redefined_while_unused {
+        std::cmp::Ordering::Less
+    } else if rule2 == redefined_while_unused {
+        std::cmp::Ordering::Greater
+    } else {
+        std::cmp::Ordering::Equal
     }
     // Apply fixes in order of their start position.
     .then_with(|| fix1.min_start().cmp(&fix2.min_start()))
     // Break ties in the event of overlapping rules, for some specific combinations.
-    .then_with(|| match (&rule1, &rule2) {
+    .then_with(|| {
+        let rules = (rule1, rule2);
         // Apply `MissingTrailingPeriod` fixes before `NewLineAfterLastParagraph` fixes.
-        (Rule::MissingTrailingPeriod, Rule::NewLineAfterLastParagraph) => std::cmp::Ordering::Less,
-        (Rule::NewLineAfterLastParagraph, Rule::MissingTrailingPeriod) => {
+        let missing_trailing_period = Rule::MissingTrailingPeriod.noqa_code();
+        let newline_after_last_paragraph = Rule::NewLineAfterLastParagraph.noqa_code();
+        let if_else_instead_of_dict_get = Rule::IfElseBlockInsteadOfDictGet.noqa_code();
+        let if_else_instead_of_if_exp = Rule::IfElseBlockInsteadOfIfExp.noqa_code();
+        if rules == (missing_trailing_period, newline_after_last_paragraph) {
+            std::cmp::Ordering::Less
+        } else if rules == (newline_after_last_paragraph, missing_trailing_period) {
             std::cmp::Ordering::Greater
         }
         // Apply `IfElseBlockInsteadOfDictGet` fixes before `IfElseBlockInsteadOfIfExp` fixes.
-        (Rule::IfElseBlockInsteadOfDictGet, Rule::IfElseBlockInsteadOfIfExp) => {
+        else if rules == (if_else_instead_of_dict_get, if_else_instead_of_if_exp) {
             std::cmp::Ordering::Less
-        }
-        (Rule::IfElseBlockInsteadOfIfExp, Rule::IfElseBlockInsteadOfDictGet) => {
+        } else if rules == (if_else_instead_of_if_exp, if_else_instead_of_dict_get) {
             std::cmp::Ordering::Greater
+        } else {
+            std::cmp::Ordering::Equal
         }
-        _ => std::cmp::Ordering::Equal,
     })
 }
 

crates/ruff_linter/src/linter.rs

@@ -22,6 +22,7 @@ use crate::checkers::imports::check_imports;
 use crate::checkers::noqa::check_noqa;
 use crate::checkers::physical_lines::check_physical_lines;
 use crate::checkers::tokens::check_tokens;
+use crate::codes::NoqaCode;
 use crate::directives::Directives;
 use crate::doc_lines::{doc_lines_from_ast, doc_lines_from_tokens};
 use crate::fix::{FixResult, fix_file};
@@ -83,7 +84,7 @@ impl LinterResult {
     }
 }
 
-pub type FixTable = FxHashMap<Rule, usize>;
+pub type FixTable = FxHashMap<NoqaCode, usize>;
 
 pub struct FixerResult<'a> {
     /// The result returned by the linter, after applying any fixes.
@@ -707,18 +708,18 @@ pub fn lint_fix<'a>(
     }
 }
 
-fn collect_rule_codes(rules: impl IntoIterator<Item = Rule>) -> String {
+fn collect_rule_codes(rules: impl IntoIterator<Item = NoqaCode>) -> String {
     rules
         .into_iter()
-        .map(|rule| rule.noqa_code().to_string())
+        .map(|rule| rule.to_string())
         .sorted_unstable()
         .dedup()
         .join(", ")
 }
 
 #[expect(clippy::print_stderr)]
 fn report_failed_to_converge_error(path: &Path, transformed: &str, diagnostics: &[OldDiagnostic]) {
-    let codes = collect_rule_codes(diagnostics.iter().filter_map(OldDiagnostic::to_rule));
+    let codes = collect_rule_codes(diagnostics.iter().filter_map(OldDiagnostic::to_noqa_code));
     if cfg!(debug_assertions) {
         eprintln!(
             "{}{} Failed to converge after {} iterations in `{}` with rule codes {}:---\n{}\n---",
@@ -754,7 +755,7 @@ fn report_fix_syntax_error(
     path: &Path,
     transformed: &str,
     error: &ParseError,
-    rules: impl IntoIterator<Item = Rule>,
+    rules: impl IntoIterator<Item = NoqaCode>,
 ) {
     let codes = collect_rule_codes(rules);
     if cfg!(debug_assertions) {