Report diagnostics for invalid/unmatched range suppression comments

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

@@ -86,3 +86,19 @@ def f():
     # Multiple codes but none are used
     # ruff: disable[E741, F401, F841]
     print("hello")
+
+
+def f():
+    # Unknown rule codes
+    # ruff: disable[YF829]
+    # ruff: disable[F841, RQW320]
+    value = 0
+    # ruff: enable[F841, RQW320]
+    # ruff: enable[YF829]
+
+
+def f():
+    # External rule codes should be ignored
+    # ruff: disable[TK421]
+    print("hello")
+    # ruff: enable[TK421]

crates/ruff_linter/src/codes.rs

@@ -1063,6 +1063,8 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "100") => rules::ruff::rules::UnusedNOQA,
         (Ruff, "101") => rules::ruff::rules::RedirectedNOQA,
         (Ruff, "102") => rules::ruff::rules::InvalidRuleCode,
+        (Ruff, "103") => rules::ruff::rules::InvalidSuppressionComment,
+        (Ruff, "104") => rules::ruff::rules::UnmatchedSuppressionComment,
 
         (Ruff, "200") => rules::ruff::rules::InvalidPyprojectToml,
         #[cfg(any(feature = "test-rules", test))]

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

@@ -313,12 +313,20 @@ mod tests {
                 Rule::UnusedVariable,
                 Rule::AmbiguousVariableName,
                 Rule::UnusedNOQA,
-            ]),
+                Rule::InvalidRuleCode,
+                Rule::InvalidSuppressionComment,
+                Rule::UnmatchedSuppressionComment,
+            ])
+            .with_external_rules(&["TK421"]),
             &settings::LinterSettings::for_rules(vec![
                 Rule::UnusedVariable,
                 Rule::AmbiguousVariableName,
                 Rule::UnusedNOQA,
+                Rule::InvalidRuleCode,
+                Rule::InvalidSuppressionComment,
+                Rule::UnmatchedSuppressionComment,
             ])
+            .with_external_rules(&["TK421"])
             .with_preview_mode(),
         );
         Ok(())

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

@@ -9,6 +9,21 @@ use crate::registry::Rule;
 use crate::rule_redirects::get_redirect_target;
 use crate::{AlwaysFixableViolation, Edit, Fix};
 
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum InvalidRuleCodeKind {
+    Noqa,
+    Suppression,
+}
+
+impl InvalidRuleCodeKind {
+    fn as_str(&self) -> &str {
+        match self {
+            InvalidRuleCodeKind::Noqa => "`# noqa`",
+            InvalidRuleCodeKind::Suppression => "suppression",
+        }
+    }
+}
+
 /// ## What it does
 /// Checks for `noqa` codes that are invalid.
 ///
@@ -36,12 +51,17 @@ use crate::{AlwaysFixableViolation, Edit, Fix};
 #[violation_metadata(preview_since = "0.11.4")]
 pub(crate) struct InvalidRuleCode {
     pub(crate) rule_code: String,
+    pub(crate) kind: InvalidRuleCodeKind,
 }
 
 impl AlwaysFixableViolation for InvalidRuleCode {
     #[derive_message_formats]
     fn message(&self) -> String {
-        format!("Invalid rule code in `# noqa`: {}", self.rule_code)
+        format!(
+            "Invalid rule code in {}: {}",
+            self.kind.as_str(),
+            self.rule_code
+        )
     }
 
     fn fix_title(&self) -> String {
@@ -61,15 +81,17 @@ pub(crate) fn invalid_noqa_code(
             continue;
         };
 
-        let all_valid = directive.iter().all(|code| code_is_valid(code, external));
+        let all_valid = directive
+            .iter()
+            .all(|code| code_is_valid(code.as_str(), external));
 
         if all_valid {
             continue;
         }
 
         let (valid_codes, invalid_codes): (Vec<_>, Vec<_>) = directive
             .iter()
-            .partition(|&code| code_is_valid(code, external));
+            .partition(|&code| code_is_valid(code.as_str(), external));
 
         if valid_codes.is_empty() {
             all_codes_invalid_diagnostic(directive, invalid_codes, context);
@@ -81,10 +103,9 @@ pub(crate) fn invalid_noqa_code(
     }
 }
 
-fn code_is_valid(code: &Code, external: &[String]) -> bool {
-    let code_str = code.as_str();
-    Rule::from_code(get_redirect_target(code_str).unwrap_or(code_str)).is_ok()
-        || external.iter().any(|ext| code_str.starts_with(ext))
+pub(crate) fn code_is_valid(code: &str, external: &[String]) -> bool {
+    Rule::from_code(get_redirect_target(code).unwrap_or(code)).is_ok()
+        || external.iter().any(|ext| code.starts_with(ext))
 }
 
 fn all_codes_invalid_diagnostic(
@@ -100,6 +121,7 @@ fn all_codes_invalid_diagnostic(
                     .map(Code::as_str)
                     .collect::<Vec<_>>()
                     .join(", "),
+                kind: InvalidRuleCodeKind::Noqa,
             },
             directive.range(),
         )
@@ -116,6 +138,7 @@ fn some_codes_are_invalid_diagnostic(
         .report_diagnostic(
             InvalidRuleCode {
                 rule_code: invalid_code.to_string(),
+                kind: InvalidRuleCodeKind::Noqa,
             },
             invalid_code.range(),
         )

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

@@ -0,0 +1,59 @@
+use ruff_macros::{ViolationMetadata, derive_message_formats};
+
+use crate::AlwaysFixableViolation;
+use crate::suppression::{InvalidSuppressionKind, ParseErrorKind};
+
+/// ## What it does
+/// Checks for invalid suppression comments
+///
+/// ## Why is this bad?
+/// Invalid suppression comments are ignored by Ruff, and should either
+/// be fixed or removed to avoid confusion.
+///
+/// ## Example
+/// ```python
+/// ruff: disable  # missing codes
+/// ```
+///
+/// Use instead:
+/// ```python
+/// # ruff: disable[E501]
+/// ```
+///
+/// Or delete the invalid suppression comment.
+///
+/// ## References
+/// - [Ruff error suppression](https://docs.astral.sh/ruff/linter/#error-suppression)
+#[derive(ViolationMetadata)]
+#[violation_metadata(preview_since = "0.14.9")]
+pub(crate) struct InvalidSuppressionComment {
+    pub(crate) kind: InvalidSuppressionCommentKind,
+}
+
+impl AlwaysFixableViolation for InvalidSuppressionComment {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        let msg = match self.kind {
+            InvalidSuppressionCommentKind::Invalid(InvalidSuppressionKind::Indentation) => {
+                "unexpected indentation".to_string()
+            }
+            InvalidSuppressionCommentKind::Invalid(InvalidSuppressionKind::Trailing) => {
+                "trailing comments are not supported".to_string()
+            }
+            InvalidSuppressionCommentKind::Invalid(InvalidSuppressionKind::Unmatched) => {
+                "no matching 'disable' comment".to_string()
+            }
+            InvalidSuppressionCommentKind::Error(error) => format!("{error}"),
+        };
+        format!("Invalid suppression comment: {msg}")
+    }
+
+    fn fix_title(&self) -> String {
+        "Remove invalid suppression comment".to_string()
+    }
+}
+
+pub(crate) enum InvalidSuppressionCommentKind {
+    Invalid(InvalidSuppressionKind),
+    Error(ParseErrorKind),
+}

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

@@ -22,6 +22,7 @@ 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 invalid_suppression_comment::*;
 pub(crate) use legacy_form_pytest_raises::*;
 pub(crate) use logging_eager_conversion::*;
 pub(crate) use map_int_version_parsing::*;
@@ -46,6 +47,7 @@ pub(crate) use starmap_zip::*;
 pub(crate) use static_key_dict_comprehension::*;
 #[cfg(any(feature = "test-rules", test))]
 pub(crate) use test_rules::*;
+pub(crate) use unmatched_suppression_comment::*;
 pub(crate) use unnecessary_cast_to_int::*;
 pub(crate) use unnecessary_iterable_allocation_for_first_element::*;
 pub(crate) use unnecessary_key_check::*;
@@ -87,6 +89,7 @@ mod invalid_formatter_suppression_comment;
 mod invalid_index_type;
 mod invalid_pyproject_toml;
 mod invalid_rule_code;
+mod invalid_suppression_comment;
 mod legacy_form_pytest_raises;
 mod logging_eager_conversion;
 mod map_int_version_parsing;
@@ -113,6 +116,7 @@ mod static_key_dict_comprehension;
 mod suppression_comment_visitor;
 #[cfg(any(feature = "test-rules", test))]
 pub(crate) mod test_rules;
+mod unmatched_suppression_comment;
 mod unnecessary_cast_to_int;
 mod unnecessary_iterable_allocation_for_first_element;
 mod unnecessary_key_check;

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

@@ -0,0 +1,42 @@
+use ruff_macros::{ViolationMetadata, derive_message_formats};
+
+use crate::Violation;
+
+/// ## What it does
+/// Checks for unmatched range suppression comments
+///
+/// ## Why is this bad?
+/// Unmatched range suppression comments can inadvertently suppress violations
+/// over larger sections of code than intended, particularly at module scope.
+///
+/// ## Example
+/// ```python
+/// def foo():
+///     # ruff: disable[E501]  # unmatched
+///     REALLY_LONG_VALUES = [...]
+///
+///     print(REALLY_LONG_VALUES)
+/// ```
+///
+/// Use instead:
+/// ```python
+/// def foo():
+///     # ruff: disable[E501]
+///     REALLY_LONG_VALUES = [...]
+///     # ruff: enable[E501]
+///
+///     print(REALLY_LONG_VALUES)
+/// ```
+///
+/// ## References
+/// - [Ruff error suppression](https://docs.astral.sh/ruff/linter/#error-suppression)
+#[derive(ViolationMetadata)]
+#[violation_metadata(preview_since = "0.14.9")]
+pub(crate) struct UnmatchedSuppressionComment;
+
+impl Violation for UnmatchedSuppressionComment {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        "Suppression comment without matching `#ruff:enable` comment".to_string()
+    }
+}