Merge remote-tracking branch 'origin/main' into dcreager/special-class

* origin/main:
  [red-knot] Add `Type::TypeVar` variant (#17102)
  [red-knot] update to latest Salsa with fixpoint caching fix (#17179)
  Upgrade to Rust 1.86 and bump MSRV to 1.84 (#17171)
  [red-knot] Avoid unresolved-reference in unreachable code (#17169)
  Fix relative import resolution in `site-packages` packages when the `site-packages` search path is a subdirectory of the first-party search path (#17178)
  [DO NOT LAND] bump Salsa version (#17176)
  [syntax-errors] Detect duplicate keys in `match` mapping patterns (#17129)

Author: dcreager

Cargo.lock

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-rust-version = "1.83"
+rust-version = "1.84"
 homepage = "https://docs.astral.sh/ruff"
 documentation = "https://docs.astral.sh/ruff"
 repository = "https://github.com/astral-sh/ruff"
@@ -124,7 +124,7 @@ rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
 # When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "d758691ba17ee1a60c5356ea90888d529e1782ad" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "296a8c78da1b54c76ff5795eb4c1e3fe2467e9fc"}
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -209,6 +209,7 @@ must_use_candidate = "allow"
 similar_names = "allow"
 single_match_else = "allow"
 too_many_lines = "allow"
+needless_continue = "allow"       # An explicit continue can be more readable, especially if the alternative is an empty block.
 # Without the hashes we run into a `rustfmt` bug in some snapshot tests, see #13250
 needless_raw_string_hashes = "allow"
 # Disallowed restriction lints
@@ -227,6 +228,10 @@ redundant_clone = "warn"
 debug_assert_with_mut_call = "warn"
 unused_peekable = "warn"
 
+# Has false positives
+# https://github.com/rust-lang/rust-clippy/issues/14275
+doc_overindented_list_items = "allow"
+
 # Diagnostics are not actionable: Enable once https://github.com/rust-lang/rust-clippy/issues/13774 is resolved.
 large_stack_arrays = "allow"
 

Cargo.toml

@@ -159,7 +159,7 @@ impl salsa::Database for ProjectDatabase {
         }
 
         let event = event();
-        if matches!(event.kind, salsa::EventKind::WillCheckCancellation { .. }) {
+        if matches!(event.kind, salsa::EventKind::WillCheckCancellation) {
             return;
         }
 

crates/red_knot_project/src/db.rs

@@ -187,7 +187,7 @@ impl ProjectDatabase {
                     let program = Program::get(self);
                     if let Err(error) = program.update_from_settings(self, program_settings) {
                         tracing::error!("Failed to update the program settings, keeping the old program settings: {error}");
-                    };
+                    }
 
                     if metadata.root() == project.root(self) {
                         tracing::debug!("Reloading project after structural change");

crates/red_knot_project/src/db/changes.rs

@@ -97,15 +97,19 @@ class Unrelated: ...
 def unbounded_unconstrained[T, U](t: list[T], u: list[U]) -> None:
     static_assert(is_assignable_to(T, T))
     static_assert(is_assignable_to(T, object))
+    static_assert(not is_assignable_to(T, Super))
     static_assert(is_assignable_to(U, U))
     static_assert(is_assignable_to(U, object))
+    static_assert(not is_assignable_to(U, Super))
     static_assert(not is_assignable_to(T, U))
     static_assert(not is_assignable_to(U, T))
 
     static_assert(is_subtype_of(T, T))
     static_assert(is_subtype_of(T, object))
+    static_assert(not is_subtype_of(T, Super))
     static_assert(is_subtype_of(U, U))
     static_assert(is_subtype_of(U, object))
+    static_assert(not is_subtype_of(U, Super))
     static_assert(not is_subtype_of(T, U))
     static_assert(not is_subtype_of(U, T))
 ```
@@ -180,8 +184,7 @@ def two_final_bounded[T: FinalClass, U: FinalClass](t: list[T], u: list[U]) -> N
 
 A constrained fully static typevar is assignable to the union of its constraints, but not to any of
 the constraints individually. None of the constraints are subtypes of the typevar, though the
-intersection of all of its contraints is a subtype of the typevar. (Though that intersection is
-likely to be `Never` in practice.)
+intersection of all of its constraints is a subtype of the typevar.
 
 ```py
 from knot_extensions import Intersection
@@ -287,10 +290,11 @@ def unbounded_unconstrained[T](t: list[T]) -> None:
     static_assert(not is_single_valued(T))
 ```
 
-A bounded typevar is not a singleton, since it can still be specialized to `Never`.
+A bounded typevar is not a singleton, even if its bound is a singleton, since it can still be
+specialized to `Never`.
 
 ```py
-def bounded[T: int](t: list[T]) -> None:
+def bounded[T: None](t: list[T]) -> None:
     static_assert(not is_singleton(T))
     static_assert(not is_single_valued(T))
 ```
@@ -448,7 +452,7 @@ since that would allow the typevar to take on values from _multiple_ constraints
 `OneOf` connector would not be a “type” according to a strict reading of the typing spec, since it
 would not represent a single set of runtime objects; it would instead represent a _set of_ sets of
 runtime objects. This is one reason we have not actually added this connector to our data model yet.
-Nevertheless, describing constrained typevars this ways helps explain how we simplify intersections
+Nevertheless, describing constrained typevars this way helps explain how we simplify intersections
 involving them.
 
 This means that when intersecting a constrained typevar with a type `T`, constraints that are
@@ -487,6 +491,7 @@ def remove_constraint[T: (int, str, bool)](t: T) -> None:
         reveal_type(x)  # revealed: str
 
     def _(x: Intersection[T, Not[str]]) -> None:
+        # With OneOf this would be OneOf[int, bool]
         reveal_type(x)  # revealed: T & ~str
 
     def _(x: Intersection[T, Not[bool]]) -> None:

crates/red_knot_python_semantic/resources/mdtest/generics/pep695.md

@@ -654,9 +654,7 @@ def f(cond: bool) -> str:
         reveal_type(x)  # revealed: Literal["before"]
         return "a"
         x = "after-return"
-        # TODO: no unresolved-reference error
-        # error: [unresolved-reference]
-        reveal_type(x)  # revealed: Unknown
+        reveal_type(x)  # revealed: Never
     else:
         x = "else"
     return reveal_type(x)  # revealed: Literal["else"]

crates/red_knot_python_semantic/resources/mdtest/terminal_statements.md

@@ -211,9 +211,6 @@ def f():
 
     print("unreachable")
 
-    # TODO: we should not emit an error here; we currently do, since there is no control flow path from this
-    # use of 'x' to any definition of 'x'.
-    # error: [unresolved-reference]
     print(x)
 ```
 
@@ -228,8 +225,6 @@ def outer():
     x = 1
 
     def inner():
-        # TODO: we should not emit an error here
-        # error: [unresolved-reference]
         return x  # Name `x` used when not defined
     while True:
         pass

crates/red_knot_python_semantic/resources/mdtest/unreachable.md

@@ -19,14 +19,14 @@ pub(crate) mod tests {
     use std::sync::Arc;
 
     use crate::program::{Program, SearchPathSettings};
-    use crate::{default_lint_registry, ProgramSettings, PythonPlatform};
+    use crate::{default_lint_registry, ProgramSettings, PythonPath, PythonPlatform};
 
     use super::Db;
     use crate::lint::{LintRegistry, RuleSelection};
     use anyhow::Context;
     use ruff_db::files::{File, Files};
     use ruff_db::system::{
-        DbWithTestSystem, DbWithWritableSystem as _, System, SystemPathBuf, TestSystem,
+        DbWithTestSystem, DbWithWritableSystem as _, System, SystemPath, SystemPathBuf, TestSystem,
     };
     use ruff_db::vendored::VendoredFileSystem;
     use ruff_db::{Db as SourceDb, Upcast};
@@ -139,8 +139,8 @@ pub(crate) mod tests {
         python_version: PythonVersion,
         /// Target Python platform
         python_platform: PythonPlatform,
-        /// Path to a custom typeshed directory
-        custom_typeshed: Option<SystemPathBuf>,
+        /// Paths to the directory to use for `site-packages`
+        site_packages: Vec<SystemPathBuf>,
         /// Path and content pairs for files that should be present
         files: Vec<(&'a str, &'a str)>,
     }
@@ -150,7 +150,7 @@ pub(crate) mod tests {
             Self {
                 python_version: PythonVersion::default(),
                 python_platform: PythonPlatform::default(),
-                custom_typeshed: None,
+                site_packages: vec![],
                 files: vec![],
             }
         }
@@ -160,8 +160,20 @@ pub(crate) mod tests {
             self
         }
 
-        pub(crate) fn with_file(mut self, path: &'a str, content: &'a str) -> Self {
-            self.files.push((path, content));
+        pub(crate) fn with_file(
+            mut self,
+            path: &'a (impl AsRef<SystemPath> + ?Sized),
+            content: &'a str,
+        ) -> Self {
+            self.files.push((path.as_ref().as_str(), content));
+            self
+        }
+
+        pub(crate) fn with_site_packages_search_path(
+            mut self,
+            path: &(impl AsRef<SystemPath> + ?Sized),
+        ) -> Self {
+            self.site_packages.push(path.as_ref().to_path_buf());
             self
         }
 
@@ -175,7 +187,7 @@ pub(crate) mod tests {
                 .context("Failed to write test files")?;
 
             let mut search_paths = SearchPathSettings::new(vec![src_root]);
-            search_paths.custom_typeshed = self.custom_typeshed;
+            search_paths.python_path = PythonPath::KnownSitePackages(self.site_packages);
 
             Program::from_settings(
                 &db,

crates/red_knot_python_semantic/src/db.rs

@@ -96,26 +96,21 @@ pub(crate) fn file_to_module(db: &dyn Db, file: File) -> Option<Module> {
         FilePath::SystemVirtual(_) => return None,
     };
 
-    let mut search_paths = search_paths(db);
-
-    let module_name = loop {
-        let candidate = search_paths.next()?;
+    let module_name = search_paths(db).find_map(|candidate| {
         let relative_path = match path {
             SystemOrVendoredPathRef::System(path) => candidate.relativize_system_path(path),
             SystemOrVendoredPathRef::Vendored(path) => candidate.relativize_vendored_path(path),
-        };
-        if let Some(relative_path) = relative_path {
-            break relative_path.to_module_name()?;
-        }
-    };
+        }?;
+        relative_path.to_module_name()
+    })?;
 
     // Resolve the module name to see if Python would resolve the name to the same path.
     // If it doesn't, then that means that multiple modules have the same name in different
     // root paths, but that the module corresponding to `path` is in a lower priority search path,
     // in which case we ignore it.
     let module = resolve_module(db, &module_name)?;
 
-    if file == module.file() {
+    if file.path(db) == module.file().path(db) {
         Some(module)
     } else {
         // This path is for a module with the same name but with a different precedence. For example:
@@ -1969,4 +1964,33 @@ not_a_directory
 
         Ok(())
     }
+
+    #[test]
+    fn file_to_module_where_one_search_path_is_subdirectory_of_other() {
+        let project_directory = SystemPathBuf::from("/project");
+        let site_packages = project_directory.join(".venv/lib/python3.13/site-packages");
+        let installed_foo_module = site_packages.join("foo/__init__.py");
+
+        let mut db = TestDb::new();
+        db.write_file(&installed_foo_module, "").unwrap();
+
+        Program::from_settings(
+            &db,
+            ProgramSettings {
+                python_version: PythonVersion::default(),
+                python_platform: PythonPlatform::default(),
+                search_paths: SearchPathSettings {
+                    extra_paths: vec![],
+                    src_roots: vec![project_directory],
+                    custom_typeshed: None,
+                    python_path: PythonPath::KnownSitePackages(vec![site_packages.clone()]),
+                },
+            },
+        )
+        .unwrap();
+
+        let foo_module_file = File::new(&db, FilePath::System(installed_foo_module));
+        let module = file_to_module(&db, foo_module_file).unwrap();
+        assert_eq!(module.search_path(), &site_packages);
+    }
 }

crates/red_knot_python_semantic/src/module_resolver/resolver.rs

@@ -322,6 +322,7 @@ fn python_version_from_versions_file_string(
 
 #[cfg(test)]
 mod tests {
+    use std::fmt::Write as _;
     use std::num::{IntErrorKind, NonZeroU16};
     use std::path::Path;
 
@@ -333,8 +334,7 @@ mod tests {
 
     const TYPESHED_STDLIB_DIR: &str = "stdlib";
 
-    #[allow(unsafe_code)]
-    const ONE: Option<NonZeroU16> = Some(unsafe { NonZeroU16::new_unchecked(1) });
+    const ONE: Option<NonZeroU16> = Some(NonZeroU16::new(1).unwrap());
 
     impl TypeshedVersions {
         #[must_use]
@@ -571,7 +571,7 @@ foo: 3.8-   # trailing comment
 
         let mut massive_versions_file = String::new();
         for i in 0..too_many {
-            massive_versions_file.push_str(&format!("x{i}: 3.8-\n"));
+            let _ = writeln!(&mut massive_versions_file, "x{i}: 3.8-");
         }
 
         assert_eq!(

crates/red_knot_python_semantic/src/module_resolver/typeshed.rs

@@ -1448,7 +1448,7 @@ where
                 self.visit_expr(subject);
                 if cases.is_empty() {
                     return;
-                };
+                }
 
                 let after_subject = self.flow_snapshot();
                 let mut vis_constraints = vec![];

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -145,7 +145,7 @@ pub(crate) fn check_suppressions(db: &dyn Db, file: File, diagnostics: &mut Type
 fn check_unknown_rule(context: &mut CheckSuppressionsContext) {
     if context.is_lint_disabled(&UNKNOWN_RULE) {
         return;
-    };
+    }
 
     for unknown in &context.suppressions.unknown {
         match &unknown.reason {
@@ -174,7 +174,7 @@ fn check_unknown_rule(context: &mut CheckSuppressionsContext) {
                     format_args!("Unknown rule `{prefixed}`. Did you mean `{suggestion}`?"),
                 );
             }
-        };
+        }
     }
 }
 
@@ -267,7 +267,7 @@ fn check_unused_suppressions(context: &mut CheckSuppressionsContext) {
                 suppression.range,
                 format_args!("Unused `{kind}` without a code", kind = suppression.kind),
             ),
-        };
+        }
     }
 }