Implement Invalid rule provided as rule RUF102 with --fix

crates/ruff_linter/resources/test/fixtures/ruff/RUF102.py

@@ -0,0 +1,9 @@
+# Invalid code
+import os  # noqa: XYZ111
+# Valid noqa
+import sys  # noqa: E402
+# Mixed valid and invalid
+from typing import List  # noqa: F401, INVALID123
+
+# Multiple invalid codes
+# noqa: XYZ222, XYZ333

crates/ruff_linter/src/checkers/noqa.rs

@@ -227,6 +227,13 @@ pub(crate) fn check_noqa(
         );
     }
 
+    if settings.rules.enabled(Rule::InvalidRuleCode)
+        && !per_file_ignores.contains(Rule::InvalidRuleCode)
+        && !exemption.enumerates(Rule::InvalidRuleCode)
+    {
+        ruff::rules::invalid_noqa_code(diagnostics, &noqa_directives, &locator);
+    };
+
     ignored_diagnostics.sort_unstable();
     ignored_diagnostics
 }

crates/ruff_linter/src/codes.rs

@@ -1016,6 +1016,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "059") => (RuleGroup::Preview, rules::ruff::rules::UnusedUnpackedVariable),
         (Ruff, "100") => (RuleGroup::Stable, rules::ruff::rules::UnusedNOQA),
         (Ruff, "101") => (RuleGroup::Stable, rules::ruff::rules::RedirectedNOQA),
+        (Ruff, "102") => (RuleGroup::Preview, rules::ruff::rules::InvalidRuleCode),
 
         (Ruff, "200") => (RuleGroup::Stable, rules::ruff::rules::InvalidPyprojectToml),
         #[cfg(any(feature = "test-rules", test))]

crates/ruff_linter/src/rules/ruff/mod.rs

@@ -314,6 +314,16 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn ruf102() -> Result<()> {
+        let diagnostics = test_path(
+            Path::new("ruff/RUF102.py"),
+            &settings::LinterSettings::for_rule(Rule::InvalidRuleCode),
+        )?;
+        assert_messages!(diagnostics);
+        Ok(())
+    }
+
     #[test]
     fn ruff_per_file_ignores() -> Result<()> {
         let diagnostics = test_path(

crates/ruff_linter/src/rules/ruff/rules/invalid_rule_code.rs

@@ -0,0 +1,154 @@
+use crate::noqa::{Code, Directive};
+use crate::registry::Rule;
+use crate::Locator;
+use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
+use ruff_macros::{derive_message_formats, ViolationMetadata};
+use ruff_text_size::Ranged;
+
+use crate::noqa::{Codes, NoqaDirectiveLine, NoqaDirectives};
+
+/// ### What it does
+/// Checks for `noqa` codes that are invalid.
+///
+/// ## Why is this bad?
+/// Invalid rule codes serve no purpose and may indicate outdated code suppressions.
+///
+/// ## Example
+/// ```python
+/// import os  # noqa: XYZ999
+/// ```
+///
+/// Use instead:
+/// ```python
+/// import os
+/// ```
+///
+/// Or if there are still valid codes needed:
+/// ```python
+/// import os  # noqa: E402
+/// ```
+
+#[derive(ViolationMetadata)]
+pub(crate) struct InvalidRuleCode {
+    pub(crate) rule_code: String,
+}
+
+impl AlwaysFixableViolation for InvalidRuleCode {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        format!("Invalid rule code in `# noqa`: {}", self.rule_code)
+    }
+
+    fn fix_title(&self) -> String {
+        "Remove the rule code".to_string()
+    }
+}
+
+/// RUF102 for invalid noqa codes
+pub(crate) fn invalid_noqa_code(
+    diagnostics: &mut Vec<Diagnostic>,
+    noqa_directives: &NoqaDirectives,
+    locator: &Locator,
+) {
+    for line in noqa_directives.lines() {
+        let Directive::Codes(directive) = &line.directive else {
+            continue;
+        };
+
+        let mut invalid_code_refs = vec![];
+        let mut valid_codes = vec![];
+
+        for code in directive.iter() {
+            let code_str = code.as_str();
+            if Rule::from_code(code.as_str()).is_err() {
+                invalid_code_refs.push(code);
+            } else {
+                valid_codes.push(code_str);
+            }
+        }
+
+        if invalid_code_refs.is_empty() {
+            continue;
+        } else if valid_codes.is_empty() {
+            handle_all_codes_invalid(diagnostics, directive, line, locator);
+        } else {
+            handle_some_codes_invalid(diagnostics, &invalid_code_refs, &valid_codes, line, locator);
+        }
+    }
+}
+
+fn handle_all_codes_invalid(
+    diagnostics: &mut Vec<Diagnostic>,
+    directive: &Codes<'_>,
+    line: &NoqaDirectiveLine<'_>,
+    locator: &Locator,
+) {
+    let invalid_codes = directive
+        .iter()
+        .map(|code| code.as_str())
+        .collect::<Vec<_>>()
+        .join(", ");
+
+    let mut diagnostic = Diagnostic::new(
+        InvalidRuleCode {
+            rule_code: invalid_codes,
+        },
+        directive.range(),
+    );
+
+    let original_text = locator.slice(line.range());
+    if let Some(comment_start) = original_text.find('#') {
+        let comment_range = ruff_text_size::TextRange::new(
+            line.range().start() + ruff_text_size::TextSize::from(comment_start as u32),
+            line.range().end(),
+        );
+        diagnostic.set_fix(Fix::safe_edit(Edit::range_deletion(comment_range)));
+    } else {
+        diagnostic.set_fix(Fix::safe_edit(Edit::range_deletion(line.range())));
+    }
+    diagnostics.push(diagnostic);
+}
+
+fn handle_some_codes_invalid(
+    diagnostics: &mut Vec<Diagnostic>,
+    invalid_codes: &[&Code<'_>],
+    valid_codes: &[&str],
+    line: &NoqaDirectiveLine<'_>,
+    locator: &Locator,
+) {
+    let updated_noqa = update_noqa(line, valid_codes, locator);
+    let fix = Fix::safe_edit(Edit::range_replacement(updated_noqa, line.range()));
+
+    for invalid_code in invalid_codes {
+        let mut diagnostic = Diagnostic::new(
+            InvalidRuleCode {
+                rule_code: invalid_code.as_str().to_string(),
+            },
+            invalid_code.range(),
+        );
+
+        diagnostic.set_fix(fix.clone());
+        diagnostics.push(diagnostic);
+    }
+}
+
+fn update_noqa(line: &NoqaDirectiveLine<'_>, valid_codes: &[&str], locator: &Locator) -> String {
+    let noqa_slice = "noqa:";
+    let formatted_codes = valid_codes.join(", ");
+    let original_text = locator.slice(line.range());
+
+    if let Some(noqa_idx) = original_text.find(noqa_slice) {
+        let prefix_end = noqa_idx + noqa_slice.len();
+        let prefix = &original_text[..prefix_end];
+        let codes_part = &original_text[prefix_end..];
+        let whitespace_len = codes_part.chars().take_while(|c| c.is_whitespace()).count();
+        format!(
+            "{}{}{}",
+            prefix,
+            &codes_part[..whitespace_len],
+            formatted_codes
+        )
+    } else {
+        format!("# noqa: {}", formatted_codes)
+    }
+}

crates/ruff_linter/src/rules/ruff/rules/mod.rs

@@ -19,6 +19,7 @@ pub(crate) use invalid_assert_message_literal_argument::*;
 pub(crate) use invalid_formatter_suppression_comment::*;
 pub(crate) use invalid_index_type::*;
 pub(crate) use invalid_pyproject_toml::*;
+pub(crate) use invalid_rule_code::*;
 pub(crate) use map_int_version_parsing::*;
 pub(crate) use missing_fstring_syntax::*;
 pub(crate) use mutable_class_default::*;
@@ -78,6 +79,7 @@ mod invalid_assert_message_literal_argument;
 mod invalid_formatter_suppression_comment;
 mod invalid_index_type;
 mod invalid_pyproject_toml;
+mod invalid_rule_code;
 mod map_int_version_parsing;
 mod missing_fstring_syntax;
 mod mutable_class_default;

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__ruf102.snap

@@ -0,0 +1,56 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+RUF102.py:2:12: RUF102 [*] Invalid rule code in `# noqa`: XYZ111
+  |
+1 | # Invalid code
+2 | import os  # noqa: XYZ111
+  |            ^^^^^^^^^^^^^^ RUF102
+3 | # Valid noqa
+4 | import sys  # noqa: E402
+  |
+  = help: Remove the rule code
+
+ℹ Safe fix
+1 1 | # Invalid code
+2   |-import os  # noqa: XYZ111
+  2 |+import os  
+3 3 | # Valid noqa
+4 4 | import sys  # noqa: E402
+5 5 | # Mixed valid and invalid
+
+RUF102.py:6:40: RUF102 [*] Invalid rule code in `# noqa`: INVALID123
+  |
+4 | import sys  # noqa: E402
+5 | # Mixed valid and invalid
+6 | from typing import List  # noqa: F401, INVALID123
+  |                                        ^^^^^^^^^^ RUF102
+7 |
+8 | # Multiple invalid codes
+  |
+  = help: Remove the rule code
+
+ℹ Safe fix
+3 3 | # Valid noqa
+4 4 | import sys  # noqa: E402
+5 5 | # Mixed valid and invalid
+6   |-from typing import List  # noqa: F401, INVALID123
+  6 |+from typing import List  # noqa: F401
+7 7 | 
+8 8 | # Multiple invalid codes
+9 9 | # noqa: XYZ222, XYZ333
+
+RUF102.py:9:1: RUF102 [*] Invalid rule code in `# noqa`: XYZ222, XYZ333
+  |
+8 | # Multiple invalid codes
+9 | # noqa: XYZ222, XYZ333
+  | ^^^^^^^^^^^^^^^^^^^^^^ RUF102
+  |
+  = help: Remove the rule code
+
+ℹ Safe fix
+6 6 | from typing import List  # noqa: F401, INVALID123
+7 7 | 
+8 8 | # Multiple invalid codes
+9   |-# noqa: XYZ222, XYZ333
+  9 |+