Initial type: ignore support

Author: MichaReiser

crates/red_knot_python_semantic/resources/mdtest/suppressions/type-ignore.md

@@ -0,0 +1,80 @@
+# Suppressing errors with `type: ignore`
+
+Type check errors can be suppressed by a `type: ignore` comment on the same line as the violation.
+
+## Simple `type: ignore`
+
+```py
+a = 4 + test  # type: ignore
+```
+
+## In parenthesized expression
+
+```py
+a = (
+    4 + test  # type: ignore
+)
+```
+
+## Before opening parentheses
+
+A suppression that applies to all errors before the openign parentheses.
+
+```py
+a: Test = (  # type: ignore
+  5
+)
+```
+
+## Multiline string
+
+```py
+a: int = 4
+a = """
+  This is a multiline string and the suppression is at its end
+"""  # type: ignore
+```
+
+## Line continuations
+
+Suppressions after a line continuation apply to all previous lines.
+
+```py
+a = test \
+  + 2  # type: ignore
+
+a = test \
+  + a \
+  + 2  # type: ignore
+```
+
+## Nested comments
+
+TODO: We should support this for better interopability with other suppression comments.
+
+```py
+# error: [unresolved-reference]
+a = test \
+  + 2  # fmt: skip # type: ignore
+
+a = test \
+  + 2  # type: ignore # fmt: skip
+```
+
+## Misspelled `type: ignore`
+```py
+# error: [unresolved-reference]
+a = test + 2  # type: ignoree
+```
+
+## Invalid - ignore on opening parentheses
+
+`type: ignore` comments after an opening parentheses suppress any
+type errors inside the parentheses in Pyright. Neither Ruff, nor
+mypy support this and neither does Red Knot.
+
+```py
+a = (  # type: ignore
+    test + 4  # error: [unresolved-reference]
+)
+```

crates/red_knot_python_semantic/src/lib.rs

@@ -22,6 +22,7 @@ pub mod semantic_index;
 mod semantic_model;
 pub(crate) mod site_packages;
 mod stdlib;
+mod suppression;
 pub(crate) mod symbol;
 pub mod types;
 mod unpack;

crates/red_knot_python_semantic/src/suppression.rs

@@ -1,34 +1,93 @@
-use salsa;
+use std::cmp::Ordering;
 
-use ruff_db::{files::File, parsed::comment_ranges, source::source_text};
+use ruff_python_parser::TokenKind;
+use ruff_source_file::LineRanges;
+use ruff_text_size::{Ranged, TextRange, TextSize};
+
+use ruff_db::{files::File, parsed::parsed_module, source::source_text};
 use ruff_index::{newtype_index, IndexVec};
 
 use crate::{lint::LintId, Db};
 
 #[salsa::tracked(return_ref)]
-pub(crate) fn suppressions(db: &dyn Db, file: File) -> IndexVec<SuppressionIndex, Suppression> {
-    let comments = comment_ranges(db.upcast(), file);
+pub(crate) fn suppressions(db: &dyn Db, file: File) -> Suppressions {
     let source = source_text(db.upcast(), file);
+    let parsed = parsed_module(db.upcast(), file);
 
     let mut suppressions = IndexVec::default();
+    let mut line_start = source.bom_start_offset();
+
+    for token in parsed.tokens() {
+        match token.kind() {
+            TokenKind::Comment => {
+                let text = &source[token.range()];
+
+                let suppressed_range = TextRange::new(line_start, token.end());
 
-    for range in comments {
-        let text = &source[range];
-
-        if text.starts_with("# type: ignore") {
-            suppressions.push(Suppression {
-                target: None,
-                kind: SuppressionKind::TypeIgnore,
-            });
-        } else if text.starts_with("# knot: ignore") {
-            suppressions.push(Suppression {
-                target: None,
-                kind: SuppressionKind::KnotIgnore,
-            });
+                if text.strip_prefix("# type: ignore").is_some_and(|suffix| {
+                    suffix.is_empty() || suffix.starts_with(char::is_whitespace)
+                }) {
+                    suppressions.push(Suppression {
+                        target: None,
+                        comment_range: token.range(),
+                        suppressed_range,
+                    });
+                }
+            }
+            TokenKind::Newline | TokenKind::NonLogicalNewline => {
+                line_start = token.range().end();
+            }
+            _ => {}
         }
     }
 
-    suppressions
+    Suppressions { file, suppressions }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Suppressions {
+    file: File,
+    suppressions: IndexVec<SuppressionIndex, Suppression>,
+}
+
+impl Suppressions {
+    pub(crate) fn find_suppression(
+        &self,
+        range: TextRange,
+        id: LintId,
+    ) -> Option<SuppressionIndex> {
+        let enclosing_index = self.enclosing_suppression(range.end())?;
+        let enclosed_suppression = &self.suppressions[enclosing_index];
+
+        // Ignore the suppression if it doesn't suppress the current lint.
+        if !enclosed_suppression.suppresses(id) {
+            return None;
+        }
+
+        Some(enclosing_index)
+    }
+
+    fn enclosing_suppression(&self, offset: TextSize) -> Option<SuppressionIndex> {
+        self.suppressions
+            .binary_search_by(|suppression| {
+                if suppression.suppressed_range.contains(offset) {
+                    Ordering::Equal
+                } else if suppression.suppressed_range.end() < offset {
+                    Ordering::Less
+                } else {
+                    Ordering::Greater
+                }
+            })
+            .ok()
+    }
+}
+
+impl std::ops::Index<SuppressionIndex> for Suppressions {
+    type Output = Suppression;
+
+    fn index(&self, index: SuppressionIndex) -> &Self::Output {
+        &self.suppressions[index]
+    }
 }
 
 #[newtype_index]
@@ -37,14 +96,13 @@ pub(crate) struct SuppressionIndex;
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub(crate) struct Suppression {
     target: Option<LintId>,
-    kind: SuppressionKind,
+    comment_range: TextRange,
+    suppressed_range: TextRange,
 }
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub(crate) enum SuppressionKind {
-    /// A `type: ignore` comment
-    TypeIgnore,
-
-    /// A `knot: ignore` comment
-    KnotIgnore,
+impl Suppression {
+    pub(crate) fn suppresses(&self, tested_id: LintId) -> bool {
+        // Use `is_none_or` when the MSRV gets updated to 1.82
+        self.target.is_none() || self.target == Some(tested_id)
+    }
 }

crates/red_knot_python_semantic/src/types/context.rs

@@ -10,6 +10,7 @@ use ruff_text_size::Ranged;
 
 use crate::{
     lint::{LintId, LintMetadata},
+    suppression::suppressions,
     Db,
 };
 
@@ -74,6 +75,15 @@ impl<'db> InferContext<'db> {
             return;
         };
 
+        let suppressions = suppressions(self.db, self.file);
+
+        if suppressions
+            .find_suppression(node.range(), LintId::of(lint))
+            .is_some()
+        {
+            return;
+        }
+
         self.report_diagnostic(node, DiagnosticId::Lint(lint.name()), severity, message);
     }
 

crates/ruff_index/src/slice.rs

@@ -1,5 +1,6 @@
 use crate::vec::IndexVec;
 use crate::Idx;
+use std::cmp::Ordering;
 use std::fmt::{Debug, Formatter};
 use std::marker::PhantomData;
 use std::ops::{Index, IndexMut, Range};
@@ -117,6 +118,29 @@ impl<I: Idx, T> IndexSlice<I, T> {
             Err(i) => Err(Idx::new(i)),
         }
     }
+
+    #[inline]
+    pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<I, I>
+    where
+        F: FnMut(&'a T) -> Ordering,
+    {
+        match self.raw.binary_search_by(f) {
+            Ok(i) => Ok(Idx::new(i)),
+            Err(i) => Err(Idx::new(i)),
+        }
+    }
+
+    #[inline]
+    pub fn binary_search_by_key<'a, B, F>(&'a self, key: &B, f: F) -> Result<I, I>
+    where
+        F: FnMut(&'a T) -> B,
+        B: Ord,
+    {
+        match self.raw.binary_search_by_key(key, f) {
+            Ok(i) => Ok(Idx::new(i)),
+            Err(i) => Err(Idx::new(i)),
+        }
+    }
 }
 
 impl<I, T> Debug for IndexSlice<I, T>

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

@@ -1641,6 +1641,15 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     );
                 }
             }
+            if checker.enabled(Rule::HardcodedPasswordString) {
+                if let Some(value) = value.as_deref() {
+                    flake8_bandit::rules::assign_hardcoded_password_string(
+                        checker,
+                        value,
+                        std::slice::from_ref(target),
+                    );
+                }
+            }
             if checker.enabled(Rule::SelfOrClsAssignment) {
                 pylint::rules::self_or_cls_assignment(checker, target);
             }

crates/ruff_python_trivia/src/comment_ranges.rs

@@ -9,7 +9,7 @@ use ruff_text_size::{Ranged, TextRange, TextSize};
 use crate::{has_leading_content, has_trailing_content, is_python_whitespace};
 
 /// Stores the ranges of comments sorted by [`TextRange::start`] in increasing order. No two ranges are overlapping.
-#[derive(Clone, Default)]
+#[derive(Clone, Default, PartialEq, Eq)]
 pub struct CommentRanges {
     raw: Vec<TextRange>,
 }