Use Rule for FileNoqaDirectives (#18966)

Summary
--

See #18946 (comment).

Test Plan
--

Existing tests

Author: ntBre

crates/ruff_linter/src/checkers/noqa.rs

@@ -35,12 +35,17 @@ pub(crate) fn check_noqa(
     // Identify any codes that are globally exempted (within the current file).
     let file_noqa_directives =
         FileNoqaDirectives::extract(locator, comment_ranges, &settings.external, path);
-    let exemption = FileExemption::from(&file_noqa_directives);
 
     // Extract all `noqa` directives.
     let mut noqa_directives =
         NoqaDirectives::from_commented_ranges(comment_ranges, &settings.external, path, locator);
 
+    if file_noqa_directives.is_empty() && noqa_directives.is_empty() {
+        return Vec::new();
+    }
+
+    let exemption = FileExemption::from(&file_noqa_directives);
+
     // Indices of diagnostics that were ignored by a `noqa` directive.
     let mut ignored_diagnostics = vec![];
 
@@ -55,7 +60,7 @@ pub(crate) fn check_noqa(
             continue;
         }
 
-        if exemption.contains(code) {
+        if exemption.contains_secondary_code(code) {
             ignored_diagnostics.push(index);
             continue;
         }
@@ -72,13 +77,21 @@ pub(crate) fn check_noqa(
             {
                 let suppressed = match &directive_line.directive {
                     Directive::All(_) => {
-                        directive_line.matches.push(code.clone());
+                        let Ok(rule) = Rule::from_code(code) else {
+                            debug_assert!(false, "Invalid secondary code `{code}`");
+                            continue;
+                        };
+                        directive_line.matches.push(rule);
                         ignored_diagnostics.push(index);
                         true
                     }
                     Directive::Codes(directive) => {
                         if directive.includes(code) {
-                            directive_line.matches.push(code.clone());
+                            let Ok(rule) = Rule::from_code(code) else {
+                                debug_assert!(false, "Invalid secondary code `{code}`");
+                                continue;
+                            };
+                            directive_line.matches.push(rule);
                             ignored_diagnostics.push(index);
                             true
                         } else {
@@ -141,7 +154,7 @@ pub(crate) fn check_noqa(
                                     diag.secondary_code().is_some_and(|noqa| *noqa == code)
                                 })
                             } else {
-                                matches.iter().any(|match_| *match_ == code)
+                                matches.iter().any(|match_| match_.noqa_code() == code)
                             } || settings
                                 .external
                                 .iter()

crates/ruff_linter/src/noqa.rs

@@ -146,45 +146,48 @@ pub(crate) fn rule_is_ignored(
 
 /// A summary of the file-level exemption as extracted from [`FileNoqaDirectives`].
 #[derive(Debug)]
-pub(crate) enum FileExemption<'a> {
+pub(crate) enum FileExemption {
     /// The file is exempt from all rules.
-    All(Vec<&'a SecondaryCode>),
+    All(Vec<Rule>),
     /// The file is exempt from the given rules.
-    Codes(Vec<&'a SecondaryCode>),
+    Codes(Vec<Rule>),
 }
 
-impl FileExemption<'_> {
+impl FileExemption {
     /// Returns `true` if the file is exempt from the given rule, as identified by its noqa code.
-    pub(crate) fn contains<T: for<'a> PartialEq<&'a str>>(&self, needle: &T) -> bool {
+    pub(crate) fn contains_secondary_code(&self, needle: &SecondaryCode) -> bool {
         match self {
             FileExemption::All(_) => true,
-            FileExemption::Codes(codes) => codes.iter().any(|code| *needle == code),
+            FileExemption::Codes(codes) => codes.iter().any(|code| *needle == code.noqa_code()),
         }
     }
 
     /// Returns `true` if the file is exempt from the given rule.
     pub(crate) fn includes(&self, needle: Rule) -> bool {
-        self.contains(&needle.noqa_code())
+        match self {
+            FileExemption::All(_) => true,
+            FileExemption::Codes(codes) => codes.contains(&needle),
+        }
     }
 
     /// Returns `true` if the file exemption lists the rule directly, rather than via a blanket
     /// exemption.
     pub(crate) fn enumerates(&self, needle: Rule) -> bool {
-        let needle = needle.noqa_code();
         let codes = match self {
             FileExemption::All(codes) => codes,
             FileExemption::Codes(codes) => codes,
         };
-        codes.iter().any(|code| needle == **code)
+        codes.contains(&needle)
     }
 }
 
-impl<'a> From<&'a FileNoqaDirectives<'a>> for FileExemption<'a> {
+impl<'a> From<&'a FileNoqaDirectives<'a>> for FileExemption {
     fn from(directives: &'a FileNoqaDirectives) -> Self {
         let codes = directives
             .lines()
             .iter()
             .flat_map(|line| &line.matches)
+            .copied()
             .collect();
         if directives
             .lines()
@@ -206,7 +209,7 @@ pub(crate) struct FileNoqaDirectiveLine<'a> {
     /// The blanket noqa directive.
     pub(crate) parsed_file_exemption: Directive<'a>,
     /// The codes that are ignored by the parsed exemptions.
-    pub(crate) matches: Vec<SecondaryCode>,
+    pub(crate) matches: Vec<Rule>,
 }
 
 impl Ranged for FileNoqaDirectiveLine<'_> {
@@ -271,9 +274,9 @@ impl<'a> FileNoqaDirectives<'a> {
                                     return None;
                                 }
 
-                                if  Rule::from_code(get_redirect_target(code).unwrap_or(code)).is_ok()
+                                if let Ok(rule) = Rule::from_code(get_redirect_target(code).unwrap_or(code))
                                 {
-                                    Some(SecondaryCode::new(code.to_string()))
+                                    Some(rule)
                                 } else {
                                     #[expect(deprecated)]
                                     let line = locator.compute_line_index(range.start());
@@ -306,6 +309,10 @@ impl<'a> FileNoqaDirectives<'a> {
     pub(crate) fn lines(&self) -> &[FileNoqaDirectiveLine] {
         &self.0
     }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
 }
 
 /// Output of lexing a `noqa` directive.
@@ -854,7 +861,7 @@ fn find_noqa_comments<'a>(
             continue;
         };
 
-        if exemption.contains(code) {
+        if exemption.contains_secondary_code(code) {
             comments_by_line.push(None);
             continue;
         }
@@ -1010,7 +1017,7 @@ pub(crate) struct NoqaDirectiveLine<'a> {
     /// The noqa directive.
     pub(crate) directive: Directive<'a>,
     /// The codes that are ignored by the directive.
-    pub(crate) matches: Vec<SecondaryCode>,
+    pub(crate) matches: Vec<Rule>,
     /// Whether the directive applies to `range.end`.
     pub(crate) includes_end: bool,
 }
@@ -1135,6 +1142,10 @@ impl<'a> NoqaDirectives<'a> {
     pub(crate) fn lines(&self) -> &[NoqaDirectiveLine] {
         &self.inner
     }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
 }
 
 /// Remaps offsets falling into one of the ranges to instead check for a noqa comment on the