Merge remote-tracking branch 'origin/main' into dcreager/typevar-type

* origin/main: (35 commits)
  [red-knot] Callable types are disjoint from literals (#17160)
  [red-knot] Fix inference for `pow` between two literal integers (#17161)
  [red-knot] Add GitHub PR annotations when mdtests fail in CI (#17150)
  [red-knot] Fix equivalence of differently ordered unions that contain `Callable` types (#17145)
  [red-knot] Add initial set of tests for unreachable code (#17159)
  [`airflow`] Move `AIR302` to `AIR301` and `AIR303` to `AIR302` (#17151)
  ruff_db: simplify lifetimes on `DiagnosticDisplay`
  [red-knot] Detect division-by-zero in unions and intersections (#17157)
  [`airflow`] Add autofix infrastructure to `AIR302` name checks (#16965)
  [`flake8-bandit`] Mark `str` and `list[str]` literals as trusted input (`S603`) (#17136)
  [`airflow`] Add autofix for `AIR302` attribute checks (#16977)
  [`airflow`] Extend `AIR302` with additional symbols (#17085)
  [`airflow`] Move `AIR301` to `AIR002` (#16978)
  [`airflow`] Add autofix for `AIR302` method checks (#16976)
  ruff_db: switch diagnostic rendering over to `std::fmt::Display`
  [red-knot] Add 'Goto type definition' to the playground (#17055)
  red_knot_ide: update snapshots
  red_knot_python_semantic: remove comment about `TypeCheckDiagnostic`
  ruff_db: delete most of the old diagnostic code
  red_knot: use `Diagnostic` inside of red knot
  ...

Author: dcreager

.github/workflows/ci.yaml

@@ -36,6 +36,8 @@ jobs:
       code: ${{ steps.check_code.outputs.changed }}
       # Flag that is raised when any code that affects the fuzzer is changed
       fuzz: ${{ steps.check_fuzzer.outputs.changed }}
+      # Flag that is set to "true" when code related to red-knot changes.
+      red_knot: ${{ steps.check_red_knot.outputs.changed }}
 
       # Flag that is set to "true" when code related to the playground changes.
       playground: ${{ steps.check_playground.outputs.changed }}
@@ -166,6 +168,29 @@ jobs:
               echo "changed=true" >> "$GITHUB_OUTPUT"
           fi
 
+      - name: Check if the red-knot code changed
+        id: check_red_knot
+        env:
+          MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
+        run: |
+          if git diff --quiet "${MERGE_BASE}...HEAD" -- \
+            ':Cargo.toml' \
+            ':Cargo.lock' \
+            ':crates/red_knot*/**' \
+            ':crates/ruff_db/**' \
+            ':crates/ruff_annotate_snippets/**' \
+            ':crates/ruff_python_ast/**' \
+            ':crates/ruff_python_parser/**' \
+            ':crates/ruff_python_trivia/**' \
+            ':crates/ruff_source_file/**' \
+            ':crates/ruff_text_size/**' \
+            ':.github/workflows/ci.yaml' \
+          ; then
+              echo "changed=false" >> "$GITHUB_OUTPUT"
+          else
+              echo "changed=true" >> "$GITHUB_OUTPUT"
+          fi
+
   cargo-fmt:
     name: "cargo fmt"
     runs-on: ubuntu-latest
@@ -221,6 +246,14 @@ jobs:
         uses: taiki-e/install-action@6aca1cfa12ef3a6b98ee8c70e0171bfa067604f5 # v2
         with:
           tool: cargo-insta
+      - name: Red-knot mdtests (GitHub annotations)
+        if: ${{ needs.determine_changes.outputs.red_knot == 'true' }}
+        env:
+          NO_COLOR: 1
+          MDTEST_GITHUB_ANNOTATIONS_FORMAT: 1
+        # Ignore errors if this step fails; we want to continue to later steps in the workflow anyway.
+        # This step is just to get nice GitHub annotations on the PR diff in the files-changed tab.
+        run: cargo test -p red_knot_python_semantic --test mdtest || true
       - name: "Run tests"
         shell: bash
         env:

Cargo.lock

@@ -15,7 +15,7 @@ use red_knot_project::watch::ProjectWatcher;
 use red_knot_project::{watch, Db};
 use red_knot_project::{ProjectDatabase, ProjectMetadata};
 use red_knot_server::run_server;
-use ruff_db::diagnostic::{DisplayDiagnosticConfig, OldDiagnosticTrait, Severity};
+use ruff_db::diagnostic::{Diagnostic, DisplayDiagnosticConfig, Severity};
 use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
 use salsa::plumbing::ZalsaDatabase;
 
@@ -288,7 +288,7 @@ impl MainLoop {
                             let diagnostics_count = result.len();
 
                             for diagnostic in result {
-                                writeln!(stdout, "{}", diagnostic.display(db, &display_config))?;
+                                write!(stdout, "{}", diagnostic.display(db, &display_config))?;
 
                                 failed |= diagnostic.severity() >= min_error_severity;
                             }
@@ -359,7 +359,7 @@ enum MainLoopMessage {
     CheckWorkspace,
     CheckCompleted {
         /// The diagnostics that were found during the check.
-        result: Vec<Box<dyn OldDiagnosticTrait>>,
+        result: Vec<Diagnostic>,
         revision: u64,
     },
     ApplyChanges(Vec<watch::ChangeEvent>),

crates/red_knot/src/main.rs

@@ -1125,11 +1125,11 @@ print(sys.last_exc, os.getegid())
 
     assert_eq!(diagnostics.len(), 2);
     assert_eq!(
-        diagnostics[0].message(),
+        diagnostics[0].primary_message(),
         "Type `<module 'sys'>` has no attribute `last_exc`"
     );
     assert_eq!(
-        diagnostics[1].message(),
+        diagnostics[1].primary_message(),
         "Type `<module 'os'>` has no attribute `getegid`"
     );
 

crates/red_knot/tests/file_watching.rs

@@ -12,13 +12,19 @@ license = { workspace = true }
 
 [dependencies]
 ruff_db = { workspace = true }
+ruff_python_ast = { workspace = true }
+ruff_python_parser = { workspace = true }
+ruff_text_size = { workspace = true }
 red_knot_python_semantic = { workspace = true }
 
 salsa = { workspace = true }
+smallvec = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
 red_knot_vendored = { workspace = true }
 
+insta = { workspace = true, features = ["filters"] }
+
 [lints]
 workspace = true

crates/red_knot_ide/Cargo.toml

@@ -2,7 +2,7 @@ use red_knot_python_semantic::Db as SemanticDb;
 use ruff_db::{Db as SourceDb, Upcast};
 
 #[salsa::db]
-pub trait Db: SemanticDb + Upcast<dyn SourceDb> {}
+pub trait Db: SemanticDb + Upcast<dyn SemanticDb> + Upcast<dyn SourceDb> {}
 
 #[cfg(test)]
 pub(crate) mod tests {
@@ -94,6 +94,16 @@ pub(crate) mod tests {
         }
     }
 
+    impl Upcast<dyn SemanticDb> for TestDb {
+        fn upcast(&self) -> &(dyn SemanticDb + 'static) {
+            self
+        }
+
+        fn upcast_mut(&mut self) -> &mut dyn SemanticDb {
+            self
+        }
+    }
+
     #[salsa::db]
     impl SemanticDb for TestDb {
         fn is_file_open(&self, file: File) -> bool {

crates/red_knot_ide/src/db.rs

@@ -0,0 +1,106 @@
+use ruff_python_ast::visitor::source_order::{SourceOrderVisitor, TraversalSignal};
+use ruff_python_ast::AnyNodeRef;
+use ruff_text_size::{Ranged, TextRange};
+use std::fmt;
+use std::fmt::Formatter;
+
+/// Returns the node with a minimal range that fully contains `range`.
+///
+/// If `range` is empty and falls within a parser *synthesized* node generated during error recovery,
+/// then the first node with the given range is returned.
+///
+/// ## Panics
+/// Panics if `range` is not contained within `root`.
+pub(crate) fn covering_node(root: AnyNodeRef, range: TextRange) -> CoveringNode {
+    struct Visitor<'a> {
+        range: TextRange,
+        found: bool,
+        ancestors: Vec<AnyNodeRef<'a>>,
+    }
+
+    impl<'a> SourceOrderVisitor<'a> for Visitor<'a> {
+        fn enter_node(&mut self, node: AnyNodeRef<'a>) -> TraversalSignal {
+            // If the node fully contains the range, than it is a possible match but traverse into its children
+            // to see if there's a node with a narrower range.
+            if !self.found && node.range().contains_range(self.range) {
+                self.ancestors.push(node);
+                TraversalSignal::Traverse
+            } else {
+                TraversalSignal::Skip
+            }
+        }
+
+        fn leave_node(&mut self, node: AnyNodeRef<'a>) {
+            if !self.found && self.ancestors.last() == Some(&node) {
+                self.found = true;
+            }
+        }
+    }
+
+    assert!(
+        root.range().contains_range(range),
+        "Range is not contained within root"
+    );
+
+    let mut visitor = Visitor {
+        range,
+        found: false,
+        ancestors: Vec::new(),
+    };
+
+    root.visit_source_order(&mut visitor);
+
+    let minimal = visitor.ancestors.pop().unwrap_or(root);
+    CoveringNode {
+        node: minimal,
+        ancestors: visitor.ancestors,
+    }
+}
+
+/// The node with a minimal range that fully contains the search range.
+pub(crate) struct CoveringNode<'a> {
+    /// The node with a minimal range that fully contains the search range.
+    node: AnyNodeRef<'a>,
+
+    /// The node's ancestor (the spine up to the root).
+    ancestors: Vec<AnyNodeRef<'a>>,
+}
+
+impl<'a> CoveringNode<'a> {
+    pub(crate) fn node(&self) -> AnyNodeRef<'a> {
+        self.node
+    }
+
+    /// Returns the node's parent.
+    pub(crate) fn parent(&self) -> Option<AnyNodeRef<'a>> {
+        self.ancestors.last().copied()
+    }
+
+    /// Finds the minimal node that fully covers the range and fulfills the given predicate.
+    pub(crate) fn find(mut self, f: impl Fn(AnyNodeRef<'a>) -> bool) -> Result<Self, Self> {
+        if f(self.node) {
+            return Ok(self);
+        }
+
+        match self.ancestors.iter().rposition(|node| f(*node)) {
+            Some(index) => {
+                let node = self.ancestors[index];
+                self.ancestors.truncate(index);
+
+                Ok(Self {
+                    node,
+                    ancestors: self.ancestors,
+                })
+            }
+            None => Err(self),
+        }
+    }
+}
+
+impl fmt::Debug for CoveringNode<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("NodeWithAncestors")
+            .field(&self.node)
+            .finish()
+    }
+}