Make tracing aware that walkdir threads run as part of request

## Summary

Ref: https://github.com/astral-sh/ruff/pull/15387#discussion_r1917796907

This PR updates `F722` to show syntax error message instead of the
string content.

I think it's more useful to show the syntax error message than the
string content. In the future, when the diagnostics renderer is more
capable, we could even highlight the exact location of the syntax error
along with the annotation string.

This is also in line with how we show the diagnostic in red knot.

## Test Plan

Update existing test snapshots.

.github/CODEOWNERS

@@ -9,6 +9,7 @@
 /crates/ruff_formatter/ @MichaReiser
 /crates/ruff_python_formatter/ @MichaReiser
 /crates/ruff_python_parser/ @MichaReiser @dhruvmanila
+/crates/ruff_annotate_snippets/ @BurntSushi
 
 # flake8-pyi
 /crates/ruff_linter/src/rules/flake8_pyi/ @AlexWaygood

.github/ISSUE_TEMPLATE.md

@@ -1,12 +0,0 @@
-<!--
-Thank you for taking the time to report an issue! We're glad to have you involved with Ruff.
-
-If you're filing a bug report, please consider including the following information:
-
-* List of keywords you searched for before creating this issue. Write them down here so that others can find this issue more easily and help provide feedback.
-  e.g. "RUF001", "unused variable", "Jupyter notebook"
-* A minimal code snippet that reproduces the bug.
-* The command you invoked (e.g., `ruff /path/to/file.py --fix`), ideally including the `--isolated` flag.
-* The current Ruff settings (any relevant sections from your `pyproject.toml`).
-* The current Ruff version (`ruff --version`).
--->

.github/workflows/sync_typeshed.yaml

@@ -78,5 +78,6 @@ jobs:
               owner: "astral-sh",
               repo: "ruff",
               title: `Automated typeshed sync failed on ${new Date().toDateString()}`,
-              body: "Runs are listed here: https://github.com/astral-sh/ruff/actions/workflows/sync_typeshed.yaml",
+              body: "Run listed here: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}",
+              labels: ["bug", "red-knot"],
             })

.pre-commit-config.yaml

@@ -73,7 +73,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.6
+    rev: v0.9.1
     hooks:
       - id: ruff-format
       - id: ruff
@@ -91,12 +91,12 @@ repos:
   # zizmor detects security vulnerabilities in GitHub Actions workflows.
   # Additional configuration for the tool is found in `.github/zizmor.yml`
   - repo: https://github.com/woodruffw/zizmor-pre-commit
-    rev: v1.0.0
+    rev: v1.0.1
     hooks:
       - id: zizmor
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.30.0
+    rev: 0.31.0
     hooks:
       - id: check-github-workflows
 

CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.9.1
+
+### Preview features
+
+- \[`pycodestyle`\] Run `too-many-newlines-at-end-of-file` on each cell in notebooks (`W391`) ([#15308](https://github.com/astral-sh/ruff/pull/15308))
+- \[`ruff`\] Omit diagnostic for shadowed private function parameters in `used-dummy-variable` (`RUF052`) ([#15376](https://github.com/astral-sh/ruff/pull/15376))
+
+### Rule changes
+
+- \[`flake8-bugbear`\] Improve `assert-raises-exception` message (`B017`) ([#15389](https://github.com/astral-sh/ruff/pull/15389))
+
+### Formatter
+
+- Preserve trailing end-of line comments for the last string literal in implicitly concatenated strings ([#15378](https://github.com/astral-sh/ruff/pull/15378))
+
+### Server
+
+- Fix a bug where the server and client notebooks were out of sync after reordering cells ([#15398](https://github.com/astral-sh/ruff/pull/15398))
+
+### Bug fixes
+
+- \[`flake8-pie`\] Correctly remove wrapping parentheses (`PIE800`) ([#15394](https://github.com/astral-sh/ruff/pull/15394))
+- \[`pyupgrade`\] Handle comments and multiline expressions correctly (`UP037`) ([#15337](https://github.com/astral-sh/ruff/pull/15337))
+
 ## 0.9.0
 
 Check out the [blog post](https://astral.sh/blog/ruff-v0.9.0) for a migration guide and overview of the changes!

Cargo.toml

@@ -13,6 +13,7 @@ license = "MIT"
 
 [workspace.dependencies]
 ruff = { path = "crates/ruff" }
+ruff_annotate_snippets = { path = "crates/ruff_annotate_snippets" }
 ruff_cache = { path = "crates/ruff_cache" }
 ruff_db = { path = "crates/ruff_db", default-features = false }
 ruff_diagnostics = { path = "crates/ruff_diagnostics" }
@@ -43,7 +44,8 @@ red_knot_test = { path = "crates/red_knot_test" }
 red_knot_workspace = { path = "crates/red_knot_workspace", default-features = false }
 
 aho-corasick = { version = "1.1.3" }
-annotate-snippets = { version = "0.9.2", features = ["color"] }
+anstream = { version = "0.6.18" }
+anstyle = { version = "1.0.10" }
 anyhow = { version = "1.0.80" }
 assert_fs = { version = "1.1.0" }
 argfile = { version = "0.2.0" }
@@ -57,7 +59,7 @@ clap = { version = "4.5.3", features = ["derive"] }
 clap_complete_command = { version = "0.6.0" }
 clearscreen = { version = "4.0.0" }
 codspeed-criterion-compat = { version = "2.6.0", default-features = false }
-colored = { version = "2.1.0" }
+colored = { version = "3.0.0" }
 console_error_panic_hook = { version = "0.1.7" }
 console_log = { version = "1.0.0" }
 countme = { version = "3.0.1" }
@@ -132,6 +134,7 @@ serde_with = { version = "3.6.0", default-features = false, features = [
 shellexpand = { version = "3.0.0" }
 similar = { version = "2.4.0", features = ["inline"] }
 smallvec = { version = "1.13.2" }
+snapbox = { version = "0.6.0", features = ["diff", "term-svg", "cmd", "examples"] }
 static_assertions = "1.1.0"
 strum = { version = "0.26.0", features = ["strum_macros"] }
 strum_macros = { version = "0.26.0" }
@@ -149,6 +152,7 @@ tracing-subscriber = { version = "0.3.18", default-features = false, features =
     "fmt",
 ] }
 tracing-tree = { version = "0.4.0" }
+tryfn = { version = "0.2.1" }
 typed-arena = { version = "2.0.2" }
 unic-ucd-category = { version = "0.9" }
 unicode-ident = { version = "1.0.12" }
@@ -211,6 +215,9 @@ redundant_clone = "warn"
 debug_assert_with_mut_call = "warn"
 unused_peekable = "warn"
 
+# Diagnostics are not actionable: Enable once https://github.com/rust-lang/rust-clippy/issues/13774 is resolved.
+large_stack_arrays = "allow"
+
 [profile.release]
 # Note that we set these explicitly, and these values
 # were chosen based on a trade-off between compile times

README.md

@@ -149,8 +149,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.9.0/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.9.0/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.9.1/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.9.1/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -183,7 +183,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.9.0
+  rev: v0.9.1
   hooks:
     # Run the linter.
     - id: ruff

_typos.toml

@@ -1,10 +1,9 @@
 [files]
 # https://github.com/crate-ci/typos/issues/868
 extend-exclude = [
-  "crates/red_knot_vendored/vendor/**/*",
-  "**/resources/**/*",
-  "**/snapshots/**/*",
-  "crates/red_knot_workspace/src/workspace/pyproject/package_name.rs"
+    "crates/red_knot_vendored/vendor/**/*",
+    "**/resources/**/*",
+    "**/snapshots/**/*",
 ]
 
 [default.extend-words]
@@ -21,7 +20,10 @@ Numer = "Numer" # Library name 'NumerBlox' in "Who's Using Ruff?"
 
 [default]
 extend-ignore-re = [
-  # Line ignore with trailing "spellchecker:disable-line"
-  "(?Rm)^.*#\\s*spellchecker:disable-line$",
-  "LICENSEs",
+    # Line ignore with trailing "spellchecker:disable-line"
+    "(?Rm)^.*#\\s*spellchecker:disable-line$",
+    "LICENSEs",
 ]
+
+[default.extend-identifiers]
+"FrIeNdLy" = "FrIeNdLy"

crates/red_knot/src/main.rs

@@ -8,11 +8,11 @@ use crossbeam::channel as crossbeam_channel;
 use python_version::PythonVersion;
 use red_knot_python_semantic::SitePackages;
 use red_knot_server::run_server;
-use red_knot_workspace::db::RootDatabase;
+use red_knot_workspace::db::ProjectDatabase;
+use red_knot_workspace::project::settings::Configuration;
+use red_knot_workspace::project::ProjectMetadata;
 use red_knot_workspace::watch;
-use red_knot_workspace::watch::WorkspaceWatcher;
-use red_knot_workspace::workspace::settings::Configuration;
-use red_knot_workspace::workspace::WorkspaceMetadata;
+use red_knot_workspace::watch::ProjectWatcher;
 use ruff_db::diagnostic::Diagnostic;
 use ruff_db::system::{OsSystem, System, SystemPath, SystemPathBuf};
 use salsa::plumbing::ZalsaDatabase;
@@ -165,7 +165,7 @@ fn run() -> anyhow::Result<ExitStatus> {
 
     let system = OsSystem::new(cwd.clone());
     let cli_configuration = args.to_configuration(&cwd);
-    let workspace_metadata = WorkspaceMetadata::discover(
+    let workspace_metadata = ProjectMetadata::discover(
         system.current_directory(),
         &system,
         Some(&cli_configuration),
@@ -173,7 +173,7 @@ fn run() -> anyhow::Result<ExitStatus> {
 
     // TODO: Use the `program_settings` to compute the key for the database's persistent
     //   cache and load the cache if it exists.
-    let mut db = RootDatabase::new(workspace_metadata, system)?;
+    let mut db = ProjectDatabase::new(workspace_metadata, system)?;
 
     let (main_loop, main_loop_cancellation_token) = MainLoop::new(cli_configuration);
 
@@ -226,7 +226,7 @@ struct MainLoop {
     receiver: crossbeam_channel::Receiver<MainLoopMessage>,
 
     /// The file system watcher, if running in watch mode.
-    watcher: Option<WorkspaceWatcher>,
+    watcher: Option<ProjectWatcher>,
 
     cli_configuration: Configuration,
 }
@@ -246,21 +246,21 @@ impl MainLoop {
         )
     }
 
-    fn watch(mut self, db: &mut RootDatabase) -> anyhow::Result<ExitStatus> {
+    fn watch(mut self, db: &mut ProjectDatabase) -> anyhow::Result<ExitStatus> {
         tracing::debug!("Starting watch mode");
         let sender = self.sender.clone();
         let watcher = watch::directory_watcher(move |event| {
             sender.send(MainLoopMessage::ApplyChanges(event)).unwrap();
         })?;
 
-        self.watcher = Some(WorkspaceWatcher::new(watcher, db));
+        self.watcher = Some(ProjectWatcher::new(watcher, db));
 
         self.run(db);
 
         Ok(ExitStatus::Success)
     }
 
-    fn run(mut self, db: &mut RootDatabase) -> ExitStatus {
+    fn run(mut self, db: &mut ProjectDatabase) -> ExitStatus {
         self.sender.send(MainLoopMessage::CheckWorkspace).unwrap();
 
         let result = self.main_loop(db);
@@ -270,7 +270,7 @@ impl MainLoop {
         result
     }
 
-    fn main_loop(&mut self, db: &mut RootDatabase) -> ExitStatus {
+    fn main_loop(&mut self, db: &mut ProjectDatabase) -> ExitStatus {
         // Schedule the first check.
         tracing::debug!("Starting main loop");
 
@@ -282,7 +282,7 @@ impl MainLoop {
                     let db = db.clone();
                     let sender = self.sender.clone();
 
-                    // Spawn a new task that checks the workspace. This needs to be done in a separate thread
+                    // Spawn a new task that checks the project. This needs to be done in a separate thread
                     // to prevent blocking the main loop here.
                     rayon::spawn(move || {
                         if let Ok(result) = db.check() {

crates/red_knot/tests/file_watching.rs

@@ -5,18 +5,18 @@ use std::time::{Duration, Instant};
 
 use anyhow::{anyhow, Context};
 use red_knot_python_semantic::{resolve_module, ModuleName, Program, PythonVersion, SitePackages};
-use red_knot_workspace::db::{Db, RootDatabase};
-use red_knot_workspace::watch::{directory_watcher, ChangeEvent, WorkspaceWatcher};
-use red_knot_workspace::workspace::settings::{Configuration, SearchPathConfiguration};
-use red_knot_workspace::workspace::WorkspaceMetadata;
+use red_knot_workspace::db::{Db, ProjectDatabase};
+use red_knot_workspace::project::settings::{Configuration, SearchPathConfiguration};
+use red_knot_workspace::project::ProjectMetadata;
+use red_knot_workspace::watch::{directory_watcher, ChangeEvent, ProjectWatcher};
 use ruff_db::files::{system_path_to_file, File, FileError};
 use ruff_db::source::source_text;
 use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
 use ruff_db::Upcast;
 
 struct TestCase {
-    db: RootDatabase,
-    watcher: Option<WorkspaceWatcher>,
+    db: ProjectDatabase,
+    watcher: Option<ProjectWatcher>,
     changes_receiver: crossbeam::channel::Receiver<Vec<ChangeEvent>>,
     /// The temporary directory that contains the test files.
     /// We need to hold on to it in the test case or the temp files get deleted.
@@ -26,15 +26,15 @@ struct TestCase {
 }
 
 impl TestCase {
-    fn workspace_path(&self, relative: impl AsRef<SystemPath>) -> SystemPathBuf {
-        SystemPath::absolute(relative, self.db.workspace().root(&self.db))
+    fn project_path(&self, relative: impl AsRef<SystemPath>) -> SystemPathBuf {
+        SystemPath::absolute(relative, self.db.project().root(&self.db))
     }
 
     fn root_path(&self) -> &SystemPath {
         &self.root_dir
     }
 
-    fn db(&self) -> &RootDatabase {
+    fn db(&self) -> &ProjectDatabase {
         &self.db
     }
 
@@ -150,7 +150,7 @@ impl TestCase {
     ) -> anyhow::Result<()> {
         let program = Program::get(self.db());
 
-        let new_settings = configuration.to_settings(self.db.workspace().root(&self.db));
+        let new_settings = configuration.to_settings(self.db.project().root(&self.db));
         self.configuration.search_paths = configuration;
 
         program.update_search_paths(&mut self.db, &new_settings)?;
@@ -163,9 +163,8 @@ impl TestCase {
         Ok(())
     }
 
-    fn collect_package_files(&self, path: &SystemPath) -> Vec<File> {
-        let package = self.db().workspace().package(self.db(), path).unwrap();
-        let files = package.files(self.db());
+    fn collect_project_files(&self) -> Vec<File> {
+        let files = self.db().project().files(self.db());
         let mut collected: Vec<_> = files.into_iter().collect();
         collected.sort_unstable_by_key(|file| file.path(self.db()).as_system_path().unwrap());
         collected
@@ -194,17 +193,17 @@ where
 }
 
 trait SetupFiles {
-    fn setup(self, root_path: &SystemPath, workspace_path: &SystemPath) -> anyhow::Result<()>;
+    fn setup(self, root_path: &SystemPath, project_path: &SystemPath) -> anyhow::Result<()>;
 }
 
 impl<const N: usize, P> SetupFiles for [(P, &'static str); N]
 where
     P: AsRef<SystemPath>,
 {
-    fn setup(self, _root_path: &SystemPath, workspace_path: &SystemPath) -> anyhow::Result<()> {
+    fn setup(self, _root_path: &SystemPath, project_path: &SystemPath) -> anyhow::Result<()> {
         for (relative_path, content) in self {
             let relative_path = relative_path.as_ref();
-            let absolute_path = workspace_path.join(relative_path);
+            let absolute_path = project_path.join(relative_path);
             if let Some(parent) = absolute_path.parent() {
                 std::fs::create_dir_all(parent).with_context(|| {
                     format!("Failed to create parent directory for file `{relative_path}`")
@@ -226,8 +225,8 @@ impl<F> SetupFiles for F
 where
     F: FnOnce(&SystemPath, &SystemPath) -> anyhow::Result<()>,
 {
-    fn setup(self, root_path: &SystemPath, workspace_path: &SystemPath) -> anyhow::Result<()> {
-        self(root_path, workspace_path)
+    fn setup(self, root_path: &SystemPath, project_path: &SystemPath) -> anyhow::Result<()> {
+        self(root_path, project_path)
     }
 }
 
@@ -235,7 +234,7 @@ fn setup<F>(setup_files: F) -> anyhow::Result<TestCase>
 where
     F: SetupFiles,
 {
-    setup_with_search_paths(setup_files, |_root, _workspace_path| {
+    setup_with_search_paths(setup_files, |_root, _project_path| {
         SearchPathConfiguration::default()
     })
 }
@@ -265,18 +264,18 @@ where
     .simplified()
     .to_path_buf();
 
-    let workspace_path = root_path.join("workspace");
+    let project_path = root_path.join("project");
 
-    std::fs::create_dir_all(workspace_path.as_std_path())
-        .with_context(|| format!("Failed to create workspace directory `{workspace_path}`"))?;
+    std::fs::create_dir_all(project_path.as_std_path())
+        .with_context(|| format!("Failed to create project directory `{project_path}`"))?;
 
     setup_files
-        .setup(&root_path, &workspace_path)
+        .setup(&root_path, &project_path)
         .context("Failed to setup test files")?;
 
-    let system = OsSystem::new(&workspace_path);
+    let system = OsSystem::new(&project_path);
 
-    let search_paths = create_search_paths(&root_path, &workspace_path);
+    let search_paths = create_search_paths(&root_path, &project_path);
 
     for path in search_paths
         .extra_paths
@@ -300,15 +299,15 @@ where
         search_paths,
     };
 
-    let workspace = WorkspaceMetadata::discover(&workspace_path, &system, Some(&configuration))?;
+    let project = ProjectMetadata::discover(&project_path, &system, Some(&configuration))?;
 
-    let db = RootDatabase::new(workspace, system)?;
+    let db = ProjectDatabase::new(project, system)?;
 
     let (sender, receiver) = crossbeam::channel::unbounded();
     let watcher = directory_watcher(move |events| sender.send(events).unwrap())
         .with_context(|| "Failed to create directory watcher")?;
 
-    let watcher = WorkspaceWatcher::new(watcher, &db);
+    let watcher = ProjectWatcher::new(watcher, &db);
     assert!(!watcher.has_errored_paths());
 
     let test_case = TestCase {
@@ -359,12 +358,12 @@ fn update_file(path: impl AsRef<SystemPath>, content: &str) -> anyhow::Result<()
 #[test]
 fn new_file() -> anyhow::Result<()> {
     let mut case = setup([("bar.py", "")])?;
-    let bar_path = case.workspace_path("bar.py");
+    let bar_path = case.project_path("bar.py");
     let bar_file = case.system_file(&bar_path).unwrap();
-    let foo_path = case.workspace_path("foo.py");
+    let foo_path = case.project_path("foo.py");
 
     assert_eq!(case.system_file(&foo_path), Err(FileError::NotFound));
-    assert_eq!(&case.collect_package_files(&bar_path), &[bar_file]);
+    assert_eq!(&case.collect_project_files(), &[bar_file]);
 
     std::fs::write(foo_path.as_std_path(), "print('Hello')")?;
 
@@ -374,7 +373,7 @@ fn new_file() -> anyhow::Result<()> {
 
     let foo = case.system_file(&foo_path).expect("foo.py to exist.");
 
-    assert_eq!(&case.collect_package_files(&bar_path), &[bar_file, foo]);
+    assert_eq!(&case.collect_project_files(), &[bar_file, foo]);
 
     Ok(())
 }
@@ -382,12 +381,12 @@ fn new_file() -> anyhow::Result<()> {
 #[test]
 fn new_ignored_file() -> anyhow::Result<()> {
     let mut case = setup([("bar.py", ""), (".ignore", "foo.py")])?;
-    let bar_path = case.workspace_path("bar.py");
+    let bar_path = case.project_path("bar.py");
     let bar_file = case.system_file(&bar_path).unwrap();
-    let foo_path = case.workspace_path("foo.py");
+    let foo_path = case.project_path("foo.py");
 
     assert_eq!(case.system_file(&foo_path), Err(FileError::NotFound));
-    assert_eq!(&case.collect_package_files(&bar_path), &[bar_file]);
+    assert_eq!(&case.collect_project_files(), &[bar_file]);
 
     std::fs::write(foo_path.as_std_path(), "print('Hello')")?;
 
@@ -396,7 +395,7 @@ fn new_ignored_file() -> anyhow::Result<()> {
     case.apply_changes(changes);
 
     assert!(case.system_file(&foo_path).is_ok());
-    assert_eq!(&case.collect_package_files(&bar_path), &[bar_file]);
+    assert_eq!(&case.collect_project_files(), &[bar_file]);
 
     Ok(())
 }
@@ -405,11 +404,11 @@ fn new_ignored_file() -> anyhow::Result<()> {
 fn changed_file() -> anyhow::Result<()> {
     let foo_source = "print('Hello, world!')";
     let mut case = setup([("foo.py", foo_source)])?;
-    let foo_path = case.workspace_path("foo.py");
+    let foo_path = case.project_path("foo.py");
 
     let foo = case.system_file(&foo_path)?;
     assert_eq!(source_text(case.db(), foo).as_str(), foo_source);
-    assert_eq!(&case.collect_package_files(&foo_path), &[foo]);
+    assert_eq!(&case.collect_project_files(), &[foo]);
 
     update_file(&foo_path, "print('Version 2')")?;
 
@@ -420,7 +419,7 @@ fn changed_file() -> anyhow::Result<()> {
     case.apply_changes(changes);
 
     assert_eq!(source_text(case.db(), foo).as_str(), "print('Version 2')");
-    assert_eq!(&case.collect_package_files(&foo_path), &[foo]);
+    assert_eq!(&case.collect_project_files(), &[foo]);
 
     Ok(())
 }
@@ -429,12 +428,12 @@ fn changed_file() -> anyhow::Result<()> {
 fn deleted_file() -> anyhow::Result<()> {
     let foo_source = "print('Hello, world!')";
     let mut case = setup([("foo.py", foo_source)])?;
-    let foo_path = case.workspace_path("foo.py");
+    let foo_path = case.project_path("foo.py");
 
     let foo = case.system_file(&foo_path)?;
 
     assert!(foo.exists(case.db()));
-    assert_eq!(&case.collect_package_files(&foo_path), &[foo]);
+    assert_eq!(&case.collect_project_files(), &[foo]);
 
     std::fs::remove_file(foo_path.as_std_path())?;
 
@@ -443,7 +442,7 @@ fn deleted_file() -> anyhow::Result<()> {
     case.apply_changes(changes);
 
     assert!(!foo.exists(case.db()));
-    assert_eq!(&case.collect_package_files(&foo_path), &[] as &[File]);
+    assert_eq!(&case.collect_project_files(), &[] as &[File]);
 
     Ok(())
 }
@@ -455,7 +454,7 @@ fn deleted_file() -> anyhow::Result<()> {
 fn move_file_to_trash() -> anyhow::Result<()> {
     let foo_source = "print('Hello, world!')";
     let mut case = setup([("foo.py", foo_source)])?;
-    let foo_path = case.workspace_path("foo.py");
+    let foo_path = case.project_path("foo.py");
 
     let trash_path = case.root_path().join(".trash");
     std::fs::create_dir_all(trash_path.as_std_path())?;
@@ -463,7 +462,7 @@ fn move_file_to_trash() -> anyhow::Result<()> {
     let foo = case.system_file(&foo_path)?;
 
     assert!(foo.exists(case.db()));
-    assert_eq!(&case.collect_package_files(&foo_path), &[foo]);
+    assert_eq!(&case.collect_project_files(), &[foo]);
 
     std::fs::rename(
         foo_path.as_std_path(),
@@ -475,58 +474,50 @@ fn move_file_to_trash() -> anyhow::Result<()> {
     case.apply_changes(changes);
 
     assert!(!foo.exists(case.db()));
-    assert_eq!(&case.collect_package_files(&foo_path), &[] as &[File]);
+    assert_eq!(&case.collect_project_files(), &[] as &[File]);
 
     Ok(())
 }
 
-/// Move a file from a non-workspace (non-watched) location into the workspace.
+/// Move a file from a non-project (non-watched) location into the project.
 #[test]
-fn move_file_to_workspace() -> anyhow::Result<()> {
+fn move_file_to_project() -> anyhow::Result<()> {
     let mut case = setup([("bar.py", "")])?;
-    let bar_path = case.workspace_path("bar.py");
+    let bar_path = case.project_path("bar.py");
     let bar = case.system_file(&bar_path).unwrap();
 
     let foo_path = case.root_path().join("foo.py");
     std::fs::write(foo_path.as_std_path(), "")?;
 
-    let foo_in_workspace_path = case.workspace_path("foo.py");
+    let foo_in_project = case.project_path("foo.py");
 
     assert!(case.system_file(&foo_path).is_ok());
-    assert_eq!(&case.collect_package_files(&bar_path), &[bar]);
-    assert!(case
-        .db()
-        .workspace()
-        .package(case.db(), &foo_path)
-        .is_none());
+    assert_eq!(&case.collect_project_files(), &[bar]);
 
-    std::fs::rename(foo_path.as_std_path(), foo_in_workspace_path.as_std_path())?;
+    std::fs::rename(foo_path.as_std_path(), foo_in_project.as_std_path())?;
 
     let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
-    let foo_in_workspace = case.system_file(&foo_in_workspace_path)?;
+    let foo_in_project = case.system_file(&foo_in_project)?;
 
-    assert!(foo_in_workspace.exists(case.db()));
-    assert_eq!(
-        &case.collect_package_files(&foo_in_workspace_path),
-        &[bar, foo_in_workspace]
-    );
+    assert!(foo_in_project.exists(case.db()));
+    assert_eq!(&case.collect_project_files(), &[bar, foo_in_project]);
 
     Ok(())
 }
 
-/// Rename a workspace file.
+/// Rename a project file.
 #[test]
 fn rename_file() -> anyhow::Result<()> {
     let mut case = setup([("foo.py", "")])?;
-    let foo_path = case.workspace_path("foo.py");
-    let bar_path = case.workspace_path("bar.py");
+    let foo_path = case.project_path("foo.py");
+    let bar_path = case.project_path("bar.py");
 
     let foo = case.system_file(&foo_path)?;
 
-    assert_eq!(case.collect_package_files(&foo_path), [foo]);
+    assert_eq!(case.collect_project_files(), [foo]);
 
     std::fs::rename(foo_path.as_std_path(), bar_path.as_std_path())?;
 
@@ -539,15 +530,15 @@ fn rename_file() -> anyhow::Result<()> {
     let bar = case.system_file(&bar_path)?;
 
     assert!(bar.exists(case.db()));
-    assert_eq!(case.collect_package_files(&foo_path), [bar]);
+    assert_eq!(case.collect_project_files(), [bar]);
 
     Ok(())
 }
 
 #[test]
-fn directory_moved_to_workspace() -> anyhow::Result<()> {
+fn directory_moved_to_project() -> anyhow::Result<()> {
     let mut case = setup([("bar.py", "import sub.a")])?;
-    let bar = case.system_file(case.workspace_path("bar.py")).unwrap();
+    let bar = case.system_file(case.project_path("bar.py")).unwrap();
 
     let sub_original_path = case.root_path().join("sub");
     let init_original_path = sub_original_path.join("__init__.py");
@@ -565,12 +556,9 @@ fn directory_moved_to_workspace() -> anyhow::Result<()> {
     );
 
     assert_eq!(sub_a_module, None);
-    assert_eq!(
-        case.collect_package_files(&case.workspace_path("bar.py")),
-        &[bar]
-    );
+    assert_eq!(case.collect_project_files(), &[bar]);
 
-    let sub_new_path = case.workspace_path("sub");
+    let sub_new_path = case.project_path("sub");
     std::fs::rename(sub_original_path.as_std_path(), sub_new_path.as_std_path())
         .with_context(|| "Failed to move sub directory")?;
 
@@ -592,10 +580,7 @@ fn directory_moved_to_workspace() -> anyhow::Result<()> {
     )
     .is_some());
 
-    assert_eq!(
-        case.collect_package_files(&case.workspace_path("bar.py")),
-        &[bar, init_file, a_file]
-    );
+    assert_eq!(case.collect_project_files(), &[bar, init_file, a_file]);
 
     Ok(())
 }
@@ -607,7 +592,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
         ("sub/__init__.py", ""),
         ("sub/a.py", ""),
     ])?;
-    let bar = case.system_file(case.workspace_path("bar.py")).unwrap();
+    let bar = case.system_file(case.project_path("bar.py")).unwrap();
 
     assert!(resolve_module(
         case.db().upcast(),
@@ -615,7 +600,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
     )
     .is_some());
 
-    let sub_path = case.workspace_path("sub");
+    let sub_path = case.project_path("sub");
     let init_file = case
         .system_file(sub_path.join("__init__.py"))
         .expect("__init__.py to exist");
@@ -623,10 +608,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
         .system_file(sub_path.join("a.py"))
         .expect("a.py to exist");
 
-    assert_eq!(
-        case.collect_package_files(&case.workspace_path("bar.py")),
-        &[bar, init_file, a_file]
-    );
+    assert_eq!(case.collect_project_files(), &[bar, init_file, a_file]);
 
     std::fs::create_dir(case.root_path().join(".trash").as_std_path())?;
     let trashed_sub = case.root_path().join(".trash/sub");
@@ -647,10 +629,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
     assert!(!init_file.exists(case.db()));
     assert!(!a_file.exists(case.db()));
 
-    assert_eq!(
-        case.collect_package_files(&case.workspace_path("bar.py")),
-        &[bar]
-    );
+    assert_eq!(case.collect_project_files(), &[bar]);
 
     Ok(())
 }
@@ -663,7 +642,7 @@ fn directory_renamed() -> anyhow::Result<()> {
         ("sub/a.py", ""),
     ])?;
 
-    let bar = case.system_file(case.workspace_path("bar.py")).unwrap();
+    let bar = case.system_file(case.project_path("bar.py")).unwrap();
 
     assert!(resolve_module(
         case.db().upcast(),
@@ -676,7 +655,7 @@ fn directory_renamed() -> anyhow::Result<()> {
     )
     .is_none());
 
-    let sub_path = case.workspace_path("sub");
+    let sub_path = case.project_path("sub");
     let sub_init = case
         .system_file(sub_path.join("__init__.py"))
         .expect("__init__.py to exist");
@@ -684,14 +663,11 @@ fn directory_renamed() -> anyhow::Result<()> {
         .system_file(sub_path.join("a.py"))
         .expect("a.py to exist");
 
-    assert_eq!(
-        case.collect_package_files(&sub_path),
-        &[bar, sub_init, sub_a]
-    );
+    assert_eq!(case.collect_project_files(), &[bar, sub_init, sub_a]);
 
-    let foo_baz = case.workspace_path("foo/baz");
+    let foo_baz = case.project_path("foo/baz");
 
-    std::fs::create_dir(case.workspace_path("foo").as_std_path())?;
+    std::fs::create_dir(case.project_path("foo").as_std_path())?;
     std::fs::rename(sub_path.as_std_path(), foo_baz.as_std_path())
         .with_context(|| "Failed to move the sub directory")?;
 
@@ -730,7 +706,7 @@ fn directory_renamed() -> anyhow::Result<()> {
     assert!(foo_baz_a.exists(case.db()));
 
     assert_eq!(
-        case.collect_package_files(&sub_path),
+        case.collect_project_files(),
         &[bar, foo_baz_init, foo_baz_a]
     );
 
@@ -745,7 +721,7 @@ fn directory_deleted() -> anyhow::Result<()> {
         ("sub/a.py", ""),
     ])?;
 
-    let bar = case.system_file(case.workspace_path("bar.py")).unwrap();
+    let bar = case.system_file(case.project_path("bar.py")).unwrap();
 
     assert!(resolve_module(
         case.db().upcast(),
@@ -753,7 +729,7 @@ fn directory_deleted() -> anyhow::Result<()> {
     )
     .is_some());
 
-    let sub_path = case.workspace_path("sub");
+    let sub_path = case.project_path("sub");
 
     let init_file = case
         .system_file(sub_path.join("__init__.py"))
@@ -761,10 +737,7 @@ fn directory_deleted() -> anyhow::Result<()> {
     let a_file = case
         .system_file(sub_path.join("a.py"))
         .expect("a.py to exist");
-    assert_eq!(
-        case.collect_package_files(&sub_path),
-        &[bar, init_file, a_file]
-    );
+    assert_eq!(case.collect_project_files(), &[bar, init_file, a_file]);
 
     std::fs::remove_dir_all(sub_path.as_std_path())
         .with_context(|| "Failed to remove the sub directory")?;
@@ -782,20 +755,20 @@ fn directory_deleted() -> anyhow::Result<()> {
 
     assert!(!init_file.exists(case.db()));
     assert!(!a_file.exists(case.db()));
-    assert_eq!(case.collect_package_files(&sub_path), &[bar]);
+    assert_eq!(case.collect_project_files(), &[bar]);
 
     Ok(())
 }
 
 #[test]
 fn search_path() -> anyhow::Result<()> {
-    let mut case = setup_with_search_paths(
-        [("bar.py", "import sub.a")],
-        |root_path, _workspace_path| SearchPathConfiguration {
-            site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
-            ..SearchPathConfiguration::default()
-        },
-    )?;
+    let mut case =
+        setup_with_search_paths([("bar.py", "import sub.a")], |root_path, _project_path| {
+            SearchPathConfiguration {
+                site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
+                ..SearchPathConfiguration::default()
+            }
+        })?;
 
     let site_packages = case.root_path().join("site_packages");
 
@@ -812,8 +785,8 @@ fn search_path() -> anyhow::Result<()> {
 
     assert!(resolve_module(case.db().upcast(), &ModuleName::new_static("a").unwrap()).is_some());
     assert_eq!(
-        case.collect_package_files(&case.workspace_path("bar.py")),
-        &[case.system_file(case.workspace_path("bar.py")).unwrap()]
+        case.collect_project_files(),
+        &[case.system_file(case.project_path("bar.py")).unwrap()]
     );
 
     Ok(())
@@ -823,7 +796,7 @@ fn search_path() -> anyhow::Result<()> {
 fn add_search_path() -> anyhow::Result<()> {
     let mut case = setup([("bar.py", "import sub.a")])?;
 
-    let site_packages = case.workspace_path("site_packages");
+    let site_packages = case.project_path("site_packages");
     std::fs::create_dir_all(site_packages.as_std_path())?;
 
     assert!(resolve_module(case.db().upcast(), &ModuleName::new_static("a").unwrap()).is_none());
@@ -848,13 +821,13 @@ fn add_search_path() -> anyhow::Result<()> {
 
 #[test]
 fn remove_search_path() -> anyhow::Result<()> {
-    let mut case = setup_with_search_paths(
-        [("bar.py", "import sub.a")],
-        |root_path, _workspace_path| SearchPathConfiguration {
-            site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
-            ..SearchPathConfiguration::default()
-        },
-    )?;
+    let mut case =
+        setup_with_search_paths([("bar.py", "import sub.a")], |root_path, _project_path| {
+            SearchPathConfiguration {
+                site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
+                ..SearchPathConfiguration::default()
+            }
+        })?;
 
     // Remove site packages from the search path settings.
     let site_packages = case.root_path().join("site_packages");
@@ -876,8 +849,8 @@ fn remove_search_path() -> anyhow::Result<()> {
 #[test]
 fn changed_versions_file() -> anyhow::Result<()> {
     let mut case = setup_with_search_paths(
-        |root_path: &SystemPath, workspace_path: &SystemPath| {
-            std::fs::write(workspace_path.join("bar.py").as_std_path(), "import sub.a")?;
+        |root_path: &SystemPath, project_path: &SystemPath| {
+            std::fs::write(project_path.join("bar.py").as_std_path(), "import sub.a")?;
             std::fs::create_dir_all(root_path.join("typeshed/stdlib").as_std_path())?;
             std::fs::write(root_path.join("typeshed/stdlib/VERSIONS").as_std_path(), "")?;
             std::fs::write(
@@ -887,7 +860,7 @@ fn changed_versions_file() -> anyhow::Result<()> {
 
             Ok(())
         },
-        |root_path, _workspace_path| SearchPathConfiguration {
+        |root_path, _project_path| SearchPathConfiguration {
             typeshed: Some(root_path.join("typeshed")),
             ..SearchPathConfiguration::default()
         },
@@ -915,11 +888,11 @@ fn changed_versions_file() -> anyhow::Result<()> {
     Ok(())
 }
 
-/// Watch a workspace that contains two files where one file is a hardlink to another.
+/// Watch a project that contains two files where one file is a hardlink to another.
 ///
 /// Setup:
 /// ```text
-/// - workspace
+/// - project
 ///   |- foo.py
 ///   |- bar.py (hard link to foo.py)
 /// ```
@@ -935,22 +908,22 @@ fn changed_versions_file() -> anyhow::Result<()> {
 /// I haven't found any documentation that states the notification behavior on Windows but what
 /// we're seeing is that Windows only emits a single event, similar to Linux.
 #[test]
-fn hard_links_in_workspace() -> anyhow::Result<()> {
-    let mut case = setup(|_root: &SystemPath, workspace: &SystemPath| {
-        let foo_path = workspace.join("foo.py");
+fn hard_links_in_project() -> anyhow::Result<()> {
+    let mut case = setup(|_root: &SystemPath, project: &SystemPath| {
+        let foo_path = project.join("foo.py");
         std::fs::write(foo_path.as_std_path(), "print('Version 1')")?;
 
         // Create a hardlink to `foo`
-        let bar_path = workspace.join("bar.py");
+        let bar_path = project.join("bar.py");
         std::fs::hard_link(foo_path.as_std_path(), bar_path.as_std_path())
             .context("Failed to create hard link from foo.py -> bar.py")?;
 
         Ok(())
     })?;
 
-    let foo_path = case.workspace_path("foo.py");
+    let foo_path = case.project_path("foo.py");
     let foo = case.system_file(&foo_path).unwrap();
-    let bar_path = case.workspace_path("bar.py");
+    let bar_path = case.project_path("bar.py");
     let bar = case.system_file(&bar_path).unwrap();
 
     assert_eq!(source_text(case.db(), foo).as_str(), "print('Version 1')");
@@ -973,12 +946,12 @@ fn hard_links_in_workspace() -> anyhow::Result<()> {
     Ok(())
 }
 
-/// Watch a workspace that contains one file that is a hardlink to a file outside the workspace.
+/// Watch a project that contains one file that is a hardlink to a file outside the project.
 ///
 /// Setup:
 /// ```text
 /// - foo.py
-/// - workspace
+/// - project
 ///   |- bar.py (hard link to /foo.py)
 /// ```
 ///
@@ -996,7 +969,7 @@ fn hard_links_in_workspace() -> anyhow::Result<()> {
 /// [source](https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-readdirectorychangesw)
 ///
 /// My interpretation of this is that Windows doesn't support observing changes made to
-/// hard linked files outside the workspace.
+/// hard linked files outside the project.
 #[test]
 #[cfg_attr(
     target_os = "linux",
@@ -1006,13 +979,13 @@ fn hard_links_in_workspace() -> anyhow::Result<()> {
     target_os = "windows",
     ignore = "windows doesn't support observing changes to hard linked files."
 )]
-fn hard_links_to_target_outside_workspace() -> anyhow::Result<()> {
-    let mut case = setup(|root: &SystemPath, workspace: &SystemPath| {
+fn hard_links_to_target_outside_project() -> anyhow::Result<()> {
+    let mut case = setup(|root: &SystemPath, project: &SystemPath| {
         let foo_path = root.join("foo.py");
         std::fs::write(foo_path.as_std_path(), "print('Version 1')")?;
 
         // Create a hardlink to `foo`
-        let bar_path = workspace.join("bar.py");
+        let bar_path = project.join("bar.py");
         std::fs::hard_link(foo_path.as_std_path(), bar_path.as_std_path())
             .context("Failed to create hard link from foo.py -> bar.py")?;
 
@@ -1021,7 +994,7 @@ fn hard_links_to_target_outside_workspace() -> anyhow::Result<()> {
 
     let foo_path = case.root_path().join("foo.py");
     let foo = case.system_file(&foo_path).unwrap();
-    let bar_path = case.workspace_path("bar.py");
+    let bar_path = case.project_path("bar.py");
     let bar = case.system_file(&bar_path).unwrap();
 
     assert_eq!(source_text(case.db(), foo).as_str(), "print('Version 1')");
@@ -1044,13 +1017,13 @@ mod unix {
     //! Tests that make use of unix specific file-system features.
     use super::*;
 
-    /// Changes the metadata of the only file in the workspace.
+    /// Changes the metadata of the only file in the project.
     #[test]
     fn changed_metadata() -> anyhow::Result<()> {
         use std::os::unix::fs::PermissionsExt;
 
         let mut case = setup([("foo.py", "")])?;
-        let foo_path = case.workspace_path("foo.py");
+        let foo_path = case.project_path("foo.py");
 
         let foo = case.system_file(&foo_path)?;
         assert_eq!(
@@ -1086,14 +1059,14 @@ mod unix {
         Ok(())
     }
 
-    /// A workspace path is a symlink to a file outside the workspace.
+    /// A project path is a symlink to a file outside the project.
     ///
     /// Setup:
     /// ```text
     /// - bar
     ///   |- baz.py
     ///
-    /// - workspace
+    /// - project
     ///   |- bar -> /bar
     /// ```
     ///
@@ -1115,7 +1088,7 @@ mod unix {
         ignore = "FSEvents doesn't emit change events for symlinked directories outside of the watched paths."
     )]
     fn symlink_target_outside_watched_paths() -> anyhow::Result<()> {
-        let mut case = setup(|root: &SystemPath, workspace: &SystemPath| {
+        let mut case = setup(|root: &SystemPath, project: &SystemPath| {
             // Set up the symlink target.
             let link_target = root.join("bar");
             std::fs::create_dir_all(link_target.as_std_path())
@@ -1124,8 +1097,8 @@ mod unix {
             std::fs::write(baz_original.as_std_path(), "def baz(): ...")
                 .context("Failed to write link target file")?;
 
-            // Create a symlink inside the workspace
-            let bar = workspace.join("bar");
+            // Create a symlink inside the project
+            let bar = project.join("bar");
             std::os::unix::fs::symlink(link_target.as_std_path(), bar.as_std_path())
                 .context("Failed to create symlink to bar package")?;
 
@@ -1137,7 +1110,7 @@ mod unix {
             &ModuleName::new_static("bar.baz").unwrap(),
         )
         .expect("Expected bar.baz to exist in site-packages.");
-        let baz_workspace = case.workspace_path("bar/baz.py");
+        let baz_project = case.project_path("bar/baz.py");
 
         assert_eq!(
             source_text(case.db(), baz.file()).as_str(),
@@ -1145,7 +1118,7 @@ mod unix {
         );
         assert_eq!(
             baz.file().path(case.db()).as_system_path(),
-            Some(&*baz_workspace)
+            Some(&*baz_project)
         );
 
         let baz_original = case.root_path().join("bar/baz.py");
@@ -1164,7 +1137,7 @@ mod unix {
         );
 
         // Write to the symlink source.
-        update_file(baz_workspace, "def baz(): print('Version 3')")
+        update_file(baz_project, "def baz(): print('Version 3')")
             .context("Failed to update bar/baz.py")?;
 
         let changes = case.stop_watch(event_for_file("baz.py"));
@@ -1179,14 +1152,14 @@ mod unix {
         Ok(())
     }
 
-    /// Workspace contains a symlink to another directory inside the workspace.
+    /// Project contains a symlink to another directory inside the project.
     /// Changes to files in the symlinked directory should be reflected
     /// to all files.
     ///
     /// Setup:
     /// ```text
-    /// - workspace
-    ///   | - bar -> /workspace/patched/bar
+    /// - project
+    ///   | - bar -> /project/patched/bar
     ///   |
     ///   | - patched
     ///   |   |-- bar
@@ -1195,10 +1168,10 @@ mod unix {
     ///   |-- foo.py
     /// ```
     #[test]
-    fn symlink_inside_workspace() -> anyhow::Result<()> {
-        let mut case = setup(|_root: &SystemPath, workspace: &SystemPath| {
+    fn symlink_inside_project() -> anyhow::Result<()> {
+        let mut case = setup(|_root: &SystemPath, project: &SystemPath| {
             // Set up the symlink target.
-            let link_target = workspace.join("patched/bar");
+            let link_target = project.join("patched/bar");
             std::fs::create_dir_all(link_target.as_std_path())
                 .context("Failed to create link target directory")?;
             let baz_original = link_target.join("baz.py");
@@ -1206,8 +1179,8 @@ mod unix {
                 .context("Failed to write link target file")?;
 
             // Create a symlink inside site-packages
-            let bar_in_workspace = workspace.join("bar");
-            std::os::unix::fs::symlink(link_target.as_std_path(), bar_in_workspace.as_std_path())
+            let bar_in_project = project.join("bar");
+            std::os::unix::fs::symlink(link_target.as_std_path(), bar_in_project.as_std_path())
                 .context("Failed to create symlink to bar package")?;
 
             Ok(())
@@ -1218,9 +1191,9 @@ mod unix {
             &ModuleName::new_static("bar.baz").unwrap(),
         )
         .expect("Expected bar.baz to exist in site-packages.");
-        let bar_baz = case.workspace_path("bar/baz.py");
+        let bar_baz = case.project_path("bar/baz.py");
 
-        let patched_bar_baz = case.workspace_path("patched/bar/baz.py");
+        let patched_bar_baz = case.project_path("patched/bar/baz.py");
         let patched_bar_baz_file = case.system_file(&patched_bar_baz).unwrap();
 
         assert_eq!(
@@ -1279,7 +1252,7 @@ mod unix {
     /// - site-packages
     ///   | - bar/baz.py
     ///
-    /// - workspace
+    /// - project
     ///   |-- .venv/lib/python3.12/site-packages -> /site-packages
     ///   |
     ///   |-- foo.py
@@ -1287,7 +1260,7 @@ mod unix {
     #[test]
     fn symlinked_module_search_path() -> anyhow::Result<()> {
         let mut case = setup_with_search_paths(
-            |root: &SystemPath, workspace: &SystemPath| {
+            |root: &SystemPath, project: &SystemPath| {
                 // Set up the symlink target.
                 let site_packages = root.join("site-packages");
                 let bar = site_packages.join("bar");
@@ -1298,7 +1271,7 @@ mod unix {
                     .context("Failed to write baz.py")?;
 
                 // Symlink the site packages in the venv to the global site packages
-                let venv_site_packages = workspace.join(".venv/lib/python3.12/site-packages");
+                let venv_site_packages = project.join(".venv/lib/python3.12/site-packages");
                 std::fs::create_dir_all(venv_site_packages.parent().unwrap())
                     .context("Failed to create .venv directory")?;
                 std::os::unix::fs::symlink(
@@ -1309,9 +1282,9 @@ mod unix {
 
                 Ok(())
             },
-            |_root, workspace| SearchPathConfiguration {
+            |_root, project| SearchPathConfiguration {
                 site_packages: Some(SitePackages::Known(vec![
-                    workspace.join(".venv/lib/python3.12/site-packages")
+                    project.join(".venv/lib/python3.12/site-packages")
                 ])),
                 ..SearchPathConfiguration::default()
             },
@@ -1323,7 +1296,7 @@ mod unix {
         )
         .expect("Expected bar.baz to exist in site-packages.");
         let baz_site_packages_path =
-            case.workspace_path(".venv/lib/python3.12/site-packages/bar/baz.py");
+            case.project_path(".venv/lib/python3.12/site-packages/bar/baz.py");
         let baz_site_packages = case.system_file(&baz_site_packages_path).unwrap();
         let baz_original = case.root_path().join("site-packages/bar/baz.py");
         let baz_original_file = case.system_file(&baz_original).unwrap();
@@ -1372,13 +1345,15 @@ mod unix {
 }
 
 #[test]
-fn nested_packages_delete_root() -> anyhow::Result<()> {
-    let mut case = setup(|root: &SystemPath, workspace_root: &SystemPath| {
+fn nested_projects_delete_root() -> anyhow::Result<()> {
+    let mut case = setup(|root: &SystemPath, project_root: &SystemPath| {
         std::fs::write(
-            workspace_root.join("pyproject.toml").as_std_path(),
+            project_root.join("pyproject.toml").as_std_path(),
             r#"
             [project]
             name = "inner"
+
+            [tool.knot]
             "#,
         )?;
 
@@ -1387,120 +1362,24 @@ fn nested_packages_delete_root() -> anyhow::Result<()> {
             r#"
             [project]
             name = "outer"
+
+            [tool.knot]
             "#,
         )?;
 
         Ok(())
     })?;
 
-    assert_eq!(
-        case.db().workspace().root(case.db()),
-        &*case.workspace_path("")
-    );
+    assert_eq!(case.db().project().root(case.db()), &*case.project_path(""));
 
-    std::fs::remove_file(case.workspace_path("pyproject.toml").as_std_path())?;
+    std::fs::remove_file(case.project_path("pyproject.toml").as_std_path())?;
 
     let changes = case.stop_watch(ChangeEvent::is_deleted);
 
     case.apply_changes(changes);
 
-    // It should now pick up the outer workspace.
-    assert_eq!(case.db().workspace().root(case.db()), case.root_path());
-
-    Ok(())
-}
-
-#[test]
-fn added_package() -> anyhow::Result<()> {
-    let mut case = setup([
-        (
-            "pyproject.toml",
-            r#"
-            [project]
-            name = "inner"
-
-            [tool.knot.workspace]
-            members = ["packages/*"]
-            "#,
-        ),
-        (
-            "packages/a/pyproject.toml",
-            r#"
-            [project]
-            name = "a"
-            "#,
-        ),
-    ])?;
-
-    assert_eq!(case.db().workspace().packages(case.db()).len(), 2);
-
-    std::fs::create_dir(case.workspace_path("packages/b").as_std_path())
-        .context("failed to create folder for package 'b'")?;
-
-    // It seems that the file watcher won't pick up on file changes shortly after the folder
-    // was created... I suspect this is because most file watchers don't support recursive
-    // file watching. Instead, file-watching libraries manually implement recursive file watching
-    // by setting a watcher for each directory. But doing this obviously "lags" behind.
-    case.take_watch_changes();
-
-    std::fs::write(
-        case.workspace_path("packages/b/pyproject.toml")
-            .as_std_path(),
-        r#"
-            [project]
-            name = "b"
-            "#,
-    )
-    .context("failed to write pyproject.toml for package b")?;
-
-    let changes = case.stop_watch(event_for_file("pyproject.toml"));
-
-    case.apply_changes(changes);
-
-    assert_eq!(case.db().workspace().packages(case.db()).len(), 3);
-
-    Ok(())
-}
-
-#[test]
-fn removed_package() -> anyhow::Result<()> {
-    let mut case = setup([
-        (
-            "pyproject.toml",
-            r#"
-            [project]
-            name = "inner"
-
-            [tool.knot.workspace]
-            members = ["packages/*"]
-            "#,
-        ),
-        (
-            "packages/a/pyproject.toml",
-            r#"
-            [project]
-            name = "a"
-            "#,
-        ),
-        (
-            "packages/b/pyproject.toml",
-            r#"
-            [project]
-            name = "b"
-            "#,
-        ),
-    ])?;
-
-    assert_eq!(case.db().workspace().packages(case.db()).len(), 3);
-
-    std::fs::remove_dir_all(case.workspace_path("packages/b").as_std_path())
-        .context("failed to remove package 'b'")?;
-
-    let changes = case.stop_watch(ChangeEvent::is_deleted);
-
-    case.apply_changes(changes);
-
-    assert_eq!(case.db().workspace().packages(case.db()).len(), 2);
+    // It should now pick up the outer project.
+    assert_eq!(case.db().project().root(case.db()), case.root_path());
 
     Ok(())
 }

crates/red_knot_python_semantic/resources/mdtest/annotations/string.md

@@ -173,3 +173,40 @@ p: "call()"
 r: "[1, 2]"
 s: "(1, 2)"
 ```
+
+## Multi line annotation
+
+Quoted type annotations should be parsed as if surrounded by parentheses.
+
+```py
+def valid(
+    a1: """(
+      int |
+      str
+  )
+  """,
+    a2: """
+     int |
+       str
+  """,
+):
+    reveal_type(a1)  # revealed: int | str
+    reveal_type(a2)  # revealed: int | str
+
+def invalid(
+    # error: [invalid-syntax-in-forward-annotation]
+    a1: """
+  int |
+str)
+""",
+    # error: [invalid-syntax-in-forward-annotation]
+    a2: """
+  int) |
+str
+""",
+    # error: [invalid-syntax-in-forward-annotation]
+    a3: """
+      (int)) """,
+):
+    pass
+```

crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_type_qualifiers.md

@@ -6,14 +6,11 @@ Several type qualifiers are unsupported by red-knot currently. However, we also
 false-positive errors if you use one in an annotation:
 
 ```py
-from typing_extensions import Final, ClassVar, Required, NotRequired, ReadOnly, TypedDict
+from typing_extensions import Final, Required, NotRequired, ReadOnly, TypedDict
 
 X: Final = 42
 Y: Final[int] = 42
 
-class Foo:
-    A: ClassVar[int] = 42
-
 # TODO: `TypedDict` is actually valid as a base
 # error: [invalid-base]
 class Bar(TypedDict):

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -2,6 +2,273 @@
 
 Tests for attribute access on various kinds of types.
 
+## Class and instance variables
+
+### Pure instance variables
+
+#### Variable only declared/bound in `__init__`
+
+Variables only declared and/or bound in `__init__` are pure instance variables. They cannot be
+accessed on the class itself.
+
+```py
+class C:
+    def __init__(self, value2: int, flag: bool = False) -> None:
+        # bound but not declared
+        self.pure_instance_variable1 = "value set in __init__"
+
+        # bound but not declared - with type inferred from parameter
+        self.pure_instance_variable2 = value2
+
+        # declared but not bound
+        self.pure_instance_variable3: bytes
+
+        # declared and bound
+        self.pure_instance_variable4: bool = True
+
+        # possibly undeclared/unbound
+        if flag:
+            self.pure_instance_variable5: str = "possibly set in __init__"
+
+c_instance = C(1)
+
+# TODO: should be `Literal["value set in __init__"]`, or `Unknown | Literal[…]` to allow
+# assignments to this unannotated attribute from other scopes.
+reveal_type(c_instance.pure_instance_variable1)  # revealed: @Todo(instance attributes)
+
+# TODO: should be `int`
+reveal_type(c_instance.pure_instance_variable2)  # revealed: @Todo(instance attributes)
+
+# TODO: should be `bytes`
+reveal_type(c_instance.pure_instance_variable3)  # revealed: @Todo(instance attributes)
+
+# TODO: should be `bool`
+reveal_type(c_instance.pure_instance_variable4)  # revealed: @Todo(instance attributes)
+
+# TODO: should be `str`
+# We probably don't want to emit a diagnostic for this being possibly undeclared/unbound.
+# mypy and pyright do not show an error here.
+reveal_type(c_instance.pure_instance_variable5)  # revealed: @Todo(instance attributes)
+
+# TODO: If we choose to infer a precise `Literal[…]` type for the instance attribute (see
+# above), this should be an error: incompatible types in assignment. If we choose to infer
+# a gradual `Unknown | Literal[…]` type, this assignment is fine.
+c_instance.pure_instance_variable1 = "value set on instance"
+
+# TODO: this should be an error (incompatible types in assignment)
+c_instance.pure_instance_variable2 = "incompatible"
+
+# TODO: we already show an error here but the message might be improved?
+# mypy shows no error here, but pyright raises "reportAttributeAccessIssue"
+# error: [unresolved-attribute] "Type `Literal[C]` has no attribute `pure_instance_variable1`"
+reveal_type(C.pure_instance_variable1)  # revealed: Unknown
+
+# TODO: this should be an error (pure instance variables cannot be accessed on the class)
+# mypy shows no error here, but pyright raises "reportAttributeAccessIssue"
+C.pure_instance_variable1 = "overwritten on class"
+
+c_instance.pure_instance_variable4 = False
+
+# TODO: After this assignment to the attribute within this scope, we may eventually want to narrow
+# the `bool` type (see above) for this instance variable to `Literal[False]` here. This is unsound
+# in general (we don't know what else happened to `c_instance` between the assignment and the use
+# here), but mypy and pyright support this. In conclusion, this could be `bool` but should probably
+# be `Literal[False]`.
+reveal_type(c_instance.pure_instance_variable4)  # revealed: @Todo(instance attributes)
+```
+
+#### Variable declared in class body and declared/bound in `__init__`
+
+The same rule applies even if the variable is *declared* (not bound!) in the class body: it is still
+a pure instance variable.
+
+```py
+class C:
+    pure_instance_variable: str
+
+    def __init__(self) -> None:
+        self.pure_instance_variable = "value set in __init__"
+
+c_instance = C()
+
+# TODO: should be `str`
+reveal_type(c_instance.pure_instance_variable)  # revealed: @Todo(instance attributes)
+
+# TODO: we currently plan to emit a diagnostic here. Note that both mypy
+# and pyright show no error in this case! So we may reconsider this in
+# the future, if it turns out to produce too many false positives.
+reveal_type(C.pure_instance_variable)  # revealed: str
+
+# TODO: same as above. We plan to emit a diagnostic here, even if both mypy
+# and pyright allow this.
+C.pure_instance_variable = "overwritten on class"
+
+# TODO: this should be an error (incompatible types in assignment)
+c_instance.pure_instance_variable = 1
+```
+
+#### Variable only defined in unrelated method
+
+We also recognize pure instance variables if they are defined in a method that is not `__init__`.
+
+```py
+class C:
+    def set_instance_variable(self) -> None:
+        self.pure_instance_variable = "value set in method"
+
+c_instance = C()
+
+# Not that we would use this in static analysis, but for a more realistic example, let's actually
+# call the method, so that the attribute is bound if this example is actually run.
+c_instance.set_instance_variable()
+
+# TODO: should be `Literal["value set in method"]` or `Unknown | Literal[…]` (see above).
+reveal_type(c_instance.pure_instance_variable)  # revealed: @Todo(instance attributes)
+
+# TODO: We already show an error here, but the message might be improved?
+# error: [unresolved-attribute]
+reveal_type(C.pure_instance_variable)  # revealed: Unknown
+
+# TODO: this should be an error
+C.pure_instance_variable = "overwritten on class"
+```
+
+#### Variable declared in class body and not bound anywhere
+
+If a variable is declared in the class body but not bound anywhere, we still consider it a pure
+instance variable and allow access to it via instances.
+
+```py
+class C:
+    pure_instance_variable: str
+
+c_instance = C()
+
+# TODO: should be 'str'
+reveal_type(c_instance.pure_instance_variable)  # revealed: @Todo(instance attributes)
+
+# TODO: mypy and pyright do not show an error here, but we plan to emit a diagnostic.
+# The type could be changed to 'Unknown' if we decide to emit an error?
+reveal_type(C.pure_instance_variable)  # revealed: str
+
+# TODO: mypy and pyright do not show an error here, but we plan to emit one.
+C.pure_instance_variable = "overwritten on class"
+```
+
+### Pure class variables (`ClassVar`)
+
+#### Annotated with `ClassVar` type qualifier
+
+Class variables annotated with the [`typing.ClassVar`] type qualifier are pure class variables. They
+cannot be overwritten on instances, but they can be accessed on instances.
+
+For more details, see the [typing spec on `ClassVar`].
+
+```py
+from typing import ClassVar
+
+class C:
+    pure_class_variable1: ClassVar[str] = "value in class body"
+    pure_class_variable2: ClassVar = 1
+
+reveal_type(C.pure_class_variable1)  # revealed: str
+
+# TODO: this should be `Literal[1]`, or `Unknown | Literal[1]`.
+reveal_type(C.pure_class_variable2)  # revealed: @Todo(Unsupported or invalid type in a type expression)
+
+c_instance = C()
+
+# TODO: This should be `str`. It is okay to access a pure class variable on an instance.
+reveal_type(c_instance.pure_class_variable1)  # revealed: @Todo(instance attributes)
+
+# TODO: should raise an error. It is not allowed to reassign a pure class variable on an instance.
+c_instance.pure_class_variable1 = "value set on instance"
+
+C.pure_class_variable1 = "overwritten on class"
+
+# TODO: should raise an error (incompatible types in assignment)
+C.pure_class_variable1 = 1
+
+class Subclass(C):
+    pure_class_variable1: ClassVar[str] = "overwritten on subclass"
+
+reveal_type(Subclass.pure_class_variable1)  # revealed: str
+```
+
+#### Variable only mentioned in a class method
+
+We also consider a class variable to be a pure class variable if it is only mentioned in a class
+method.
+
+```py
+class C:
+    @classmethod
+    def class_method(cls):
+        cls.pure_class_variable = "value set in class method"
+
+# for a more realistic example, let's actually call the method
+C.class_method()
+
+# TODO: We currently plan to support this and show no error here.
+# mypy shows an error here, pyright does not.
+# error: [unresolved-attribute]
+reveal_type(C.pure_class_variable)  # revealed: Unknown
+
+C.pure_class_variable = "overwritten on class"
+
+# TODO: should be `Literal["overwritten on class"]`
+# error: [unresolved-attribute]
+reveal_type(C.pure_class_variable)  # revealed: Unknown
+
+c_instance = C()
+# TODO: should be `Literal["overwritten on class"]`
+reveal_type(c_instance.pure_class_variable)  # revealed: @Todo(instance attributes)
+
+# TODO: should raise an error.
+c_instance.pure_class_variable = "value set on instance"
+```
+
+### Instance variables with class-level default values
+
+These are instance attributes, but the fact that we can see that they have a binding (not a
+declaration) in the class body means that reading the value from the class directly is also
+permitted. This is the only difference for these attributes as opposed to "pure" instance
+attributes.
+
+#### Basic
+
+```py
+class C:
+    variable_with_class_default: str = "value in class body"
+
+    def instance_method(self):
+        self.variable_with_class_default = "value set in instance method"
+
+reveal_type(C.variable_with_class_default)  # revealed: str
+
+c_instance = C()
+
+# TODO: should be `str`
+reveal_type(c_instance.variable_with_class_default)  # revealed: @Todo(instance attributes)
+
+c_instance.variable_with_class_default = "value set on instance"
+
+reveal_type(C.variable_with_class_default)  # revealed: str
+
+# TODO: Could be Literal["value set on instance"], or still `str` if we choose not to
+# narrow the type.
+reveal_type(c_instance.variable_with_class_default)  # revealed: @Todo(instance attributes)
+
+C.variable_with_class_default = "overwritten on class"
+
+# TODO: Could be `Literal["overwritten on class"]`, or still `str` if we choose not to
+# narrow the type.
+reveal_type(C.variable_with_class_default)  # revealed: str
+
+# TODO: should still be `Literal["value set on instance"]`, or `str`.
+reveal_type(c_instance.variable_with_class_default)  # revealed: @Todo(instance attributes)
+```
+
 ## Union of attributes
 
 ```py
@@ -24,7 +291,9 @@ def _(flag: bool):
     reveal_type(C2.x)  # revealed: Literal[3, 4]
 ```
 
-## Inherited attributes
+## Inherited class attributes
+
+### Basic
 
 ```py
 class A:
@@ -36,7 +305,7 @@ class C(B): ...
 reveal_type(C.X)  # revealed: Literal["foo"]
 ```
 
-## Inherited attributes (multiple inheritance)
+### Multiple inheritance
 
 ```py
 class O: ...
@@ -104,7 +373,7 @@ def _(flag: bool, flag1: bool, flag2: bool):
     reveal_type(C.x)  # revealed: Literal[1, 2, 3]
 ```
 
-## Unions with all paths unbound
+### Unions with all paths unbound
 
 If the symbol is unbound in all elements of the union, we detect that:
 
@@ -158,7 +427,9 @@ class Foo: ...
 reveal_type(Foo.__class__)  # revealed: Literal[type]
 ```
 
-## Function-literal attributes
+## Literal types
+
+### Function-literal attributes
 
 Most attribute accesses on function-literal types are delegated to `types.FunctionType`, since all
 functions are instances of that class:
@@ -179,7 +450,7 @@ reveal_type(f.__get__)  # revealed: @Todo(`__get__` method on functions)
 reveal_type(f.__call__)  # revealed: @Todo(`__call__` method on functions)
 ```
 
-## Int-literal attributes
+### Int-literal attributes
 
 Most attribute accesses on int-literal types are delegated to `builtins.int`, since all literal
 integers are instances of that class:
@@ -196,7 +467,7 @@ reveal_type((2).numerator)  # revealed: Literal[2]
 reveal_type((2).real)  # revealed: Literal[2]
 ```
 
-## Literal `bool` attributes
+### Bool-literal attributes
 
 Most attribute accesses on bool-literal types are delegated to `builtins.bool`, since all literal
 bols are instances of that class:
@@ -213,7 +484,7 @@ reveal_type(True.numerator)  # revealed: Literal[1]
 reveal_type(False.real)  # revealed: Literal[0]
 ```
 
-## Bytes-literal attributes
+### Bytes-literal attributes
 
 All attribute access on literal `bytes` types is currently delegated to `buitins.bytes`:
 
@@ -221,3 +492,12 @@ All attribute access on literal `bytes` types is currently delegated to `buitins
 reveal_type(b"foo".join)  # revealed: @Todo(instance attributes)
 reveal_type(b"foo".endswith)  # revealed: @Todo(instance attributes)
 ```
+
+## References
+
+Some of the tests in the *Class and instance variables* section draw inspiration from
+[pyright's documentation] on this topic.
+
+[pyright's documentation]: https://microsoft.github.io/pyright/#/type-concepts-advanced?id=class-and-instance-variables
+[typing spec on `classvar`]: https://typing.readthedocs.io/en/latest/spec/class-compat.html#classvar
+[`typing.classvar`]: https://docs.python.org/3/library/typing.html#typing.ClassVar

crates/red_knot_python_semantic/resources/mdtest/boundness_declaredness/public.md

@@ -0,0 +1,209 @@
+# Boundness and declaredness: public uses
+
+This document demonstrates how type-inference and diagnostics works for *public* uses of a symbol,
+that is, a use of a symbol from another scope. If a symbol has a declared type in its local scope
+(e.g. `int`), we use that as the symbol's "public type" (the type of the symbol from the perspective
+of other scopes) even if there is a more precise local inferred type for the symbol (`Literal[1]`).
+
+We test the whole matrix of possible boundness and declaredness states. The current behavior is
+summarized in the following table, while the tests below demonstrate each case. Note that some of
+this behavior is questionable and might change in the future. See the TODOs in `symbol_by_id`
+(`types.rs`) and [this issue](https://github.com/astral-sh/ruff/issues/14297) for more information.
+In particular, we should raise errors in the "possibly-undeclared-and-unbound" as well as the
+"undeclared-and-possibly-unbound" cases (marked with a "?").
+
+| **Public type**  | declared     | possibly-undeclared        | undeclared   |
+| ---------------- | ------------ | -------------------------- | ------------ |
+| bound            | `T_declared` | `T_declared \| T_inferred` | `T_inferred` |
+| possibly-unbound | `T_declared` | `T_declared \| T_inferred` | `T_inferred` |
+| unbound          | `T_declared` | `T_declared`               | `Unknown`    |
+
+| **Diagnostic**   | declared | possibly-undeclared       | undeclared          |
+| ---------------- | -------- | ------------------------- | ------------------- |
+| bound            |          |                           |                     |
+| possibly-unbound |          | `possibly-unbound-import` | ?                   |
+| unbound          |          | ?                         | `unresolved-import` |
+
+## Declared
+
+### Declared and bound
+
+If a symbol has a declared type (`int`), we use that even if there is a more precise inferred type
+(`Literal[1]`), or a conflicting inferred type (`Literal[2]`):
+
+```py path=mod.py
+x: int = 1
+
+# error: [invalid-assignment]
+y: str = 2
+```
+
+```py
+from mod import x, y
+
+reveal_type(x)  # revealed: int
+reveal_type(y)  # revealed: str
+```
+
+### Declared and possibly unbound
+
+If a symbol is declared and *possibly* unbound, we trust that other module and use the declared type
+without raising an error.
+
+```py path=mod.py
+def flag() -> bool: ...
+
+x: int
+y: str
+if flag:
+    x = 1
+    # error: [invalid-assignment]
+    y = 2
+```
+
+```py
+from mod import x, y
+
+reveal_type(x)  # revealed: int
+reveal_type(y)  # revealed: str
+```
+
+### Declared and unbound
+
+Similarly, if a symbol is declared but unbound, we do not raise an error. We trust that this symbol
+is available somehow and simply use the declared type.
+
+```py path=mod.py
+x: int
+```
+
+```py
+from mod import x
+
+reveal_type(x)  # revealed: int
+```
+
+## Possibly undeclared
+
+### Possibly undeclared and bound
+
+If a symbol is possibly undeclared but definitely bound, we use the union of the declared and
+inferred types:
+
+```py path=mod.py
+from typing import Any
+
+def flag() -> bool: ...
+
+x = 1
+y = 2
+if flag():
+    x: Any
+    # error: [invalid-declaration]
+    y: str
+```
+
+```py
+from mod import x, y
+
+reveal_type(x)  # revealed: Literal[1] | Any
+reveal_type(y)  # revealed: Literal[2] | Unknown
+```
+
+### Possibly undeclared and possibly unbound
+
+If a symbol is possibly undeclared and possibly unbound, we also use the union of the declared and
+inferred types. This case is interesting because the "possibly declared" definition might not be the
+same as the "possibly bound" definition (symbol `y`). Note that we raise a `possibly-unbound-import`
+error for both `x` and `y`:
+
+```py path=mod.py
+def flag() -> bool: ...
+
+if flag():
+    x: Any = 1
+    y = 2
+else:
+    y: str
+```
+
+```py
+# error: [possibly-unbound-import]
+# error: [possibly-unbound-import]
+from mod import x, y
+
+reveal_type(x)  # revealed: Literal[1] | Any
+reveal_type(y)  # revealed: Literal[2] | str
+```
+
+### Possibly undeclared and unbound
+
+If a symbol is possibly undeclared and definitely unbound, we currently do not raise an error. This
+seems inconsistent when compared to the case just above.
+
+```py path=mod.py
+def flag() -> bool: ...
+
+if flag():
+    x: int
+```
+
+```py
+# TODO: this should raise an error. Once we fix this, update the section description and the table
+# on top of this document.
+from mod import x
+
+reveal_type(x)  # revealed: int
+```
+
+## Undeclared
+
+### Undeclared but bound
+
+We use the inferred type as the public type, if a symbol has no declared type.
+
+```py path=mod.py
+x = 1
+```
+
+```py
+from mod import x
+
+reveal_type(x)  # revealed: Literal[1]
+```
+
+### Undeclared and possibly unbound
+
+If a symbol is undeclared and *possibly* unbound, we currently do not raise an error. This seems
+inconsistent when compared to the "possibly-undeclared-and-possibly-unbound" case.
+
+```py path=mod.py
+def flag() -> bool: ...
+
+if flag:
+    x = 1
+```
+
+```py
+# TODO: this should raise an error. Once we fix this, update the section description and the table
+# on top of this document.
+from mod import x
+
+reveal_type(x)  # revealed: Literal[1]
+```
+
+### Undeclared and unbound
+
+If a symbol is undeclared *and* unbound, we infer `Unknown` and raise an error.
+
+```py path=mod.py
+if False:
+    x: int = 1
+```
+
+```py
+# error: [unresolved-import]
+from mod import x
+
+reveal_type(x)  # revealed: Unknown
+```

crates/red_knot_python_semantic/resources/mdtest/call/function.md

@@ -169,6 +169,15 @@ def f(*args: int) -> int:
 reveal_type(f(1, 2, 3))  # revealed: int
 ```
 
+### Multiple keyword arguments map to keyword variadic parameter
+
+```py
+def f(**kwargs: int) -> int:
+    return 1
+
+reveal_type(f(foo=1, bar=2))  # revealed: int
+```
+
 ## Missing arguments
 
 ### No defaults or variadic

crates/red_knot_python_semantic/resources/mdtest/comparison/intersections.md

@@ -92,8 +92,7 @@ def _(o: object):
     n = None
 
     if o is not None:
-        reveal_type(o)  # revealed: object & ~None
-
+        reveal_type(o)  # revealed:  ~None
         reveal_type(o is n)  # revealed: Literal[False]
         reveal_type(o is not n)  # revealed: Literal[True]
 ```

crates/red_knot_python_semantic/resources/mdtest/directives/assert_type.md

@@ -0,0 +1,142 @@
+# `assert_type`
+
+## Basic
+
+```py
+from typing_extensions import assert_type
+
+def _(x: int):
+    assert_type(x, int)  # fine
+    assert_type(x, str)  # error: [type-assertion-failure]
+```
+
+## Narrowing
+
+The asserted type is checked against the inferred type, not the declared type.
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+from typing_extensions import assert_type
+
+def _(x: int | str):
+    if isinstance(x, int):
+        reveal_type(x)  # revealed: int
+        assert_type(x, int)  # fine
+```
+
+## Equivalence
+
+The actual type must match the asserted type precisely.
+
+```py
+from typing import Any, Type, Union
+from typing_extensions import assert_type
+
+# Subtype does not count
+def _(x: bool):
+    assert_type(x, int)  # error: [type-assertion-failure]
+
+def _(a: type[int], b: type[Any]):
+    assert_type(a, type[Any])  # error: [type-assertion-failure]
+    assert_type(b, type[int])  # error: [type-assertion-failure]
+
+# The expression constructing the type is not taken into account
+def _(a: type[int]):
+    assert_type(a, Type[int])  # fine
+```
+
+## Gradual types
+
+```py
+from typing import Any
+from typing_extensions import Literal, assert_type
+
+from knot_extensions import Unknown
+
+# Any and Unknown are considered equivalent
+def _(a: Unknown, b: Any):
+    reveal_type(a)  # revealed: Unknown
+    assert_type(a, Any)  # fine
+
+    reveal_type(b)  # revealed: Any
+    assert_type(b, Unknown)  # fine
+
+def _(a: type[Unknown], b: type[Any]):
+    reveal_type(a)  # revealed: type[Unknown]
+    assert_type(a, type[Any])  # fine
+
+    reveal_type(b)  # revealed: type[Any]
+    assert_type(b, type[Unknown])  # fine
+```
+
+## Tuples
+
+Tuple types with the same elements are the same.
+
+```py
+from typing_extensions import assert_type
+
+from knot_extensions import Unknown
+
+def _(a: tuple[int, str, bytes]):
+    assert_type(a, tuple[int, str, bytes])  # fine
+
+    assert_type(a, tuple[int, str])  # error: [type-assertion-failure]
+    assert_type(a, tuple[int, str, bytes, None])  # error: [type-assertion-failure]
+    assert_type(a, tuple[int, bytes, str])  # error: [type-assertion-failure]
+
+def _(a: tuple[Any, ...], b: tuple[Unknown, ...]):
+    assert_type(a, tuple[Any, ...])  # fine
+    assert_type(a, tuple[Unknown, ...])  # fine
+
+    assert_type(b, tuple[Unknown, ...])  # fine
+    assert_type(b, tuple[Any, ...])  # fine
+```
+
+## Unions
+
+Unions with the same elements are the same, regardless of order.
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+from typing_extensions import assert_type
+
+def _(a: str | int):
+    assert_type(a, str | int)  # fine
+
+    # TODO: Order-independent union handling in type equivalence
+    assert_type(a, int | str)  # error: [type-assertion-failure]
+```
+
+## Intersections
+
+Intersections are the same when their positive and negative parts are respectively the same,
+regardless of order.
+
+```py
+from typing_extensions import assert_type
+
+from knot_extensions import Intersection, Not
+
+class A: ...
+class B: ...
+class C: ...
+class D: ...
+
+def _(a: A):
+    if isinstance(a, B) and not isinstance(a, C) and not isinstance(a, D):
+        reveal_type(a)  # revealed: A & B & ~C & ~D
+
+        assert_type(a, Intersection[A, B, Not[C], Not[D]])  # fine
+
+        # TODO: Order-independent intersection handling in type equivalence
+        assert_type(a, Intersection[B, A, Not[D], Not[C]])  # error: [type-assertion-failure]
+```

crates/red_knot_python_semantic/resources/mdtest/directives/cast.md

@@ -0,0 +1,27 @@
+# `cast`
+
+`cast()` takes two arguments, one type and one value, and returns a value of the given type.
+
+The (inferred) type of the value and the given type do not need to have any correlation.
+
+```py
+from typing import Literal, cast
+
+reveal_type(True)  # revealed: Literal[True]
+reveal_type(cast(str, True))  # revealed: str
+reveal_type(cast("str", True))  # revealed: str
+
+reveal_type(cast(int | str, 1))  # revealed: int | str
+
+# error: [invalid-type-form]
+reveal_type(cast(Literal, True))  # revealed: Unknown
+
+# TODO: These should be errors
+cast(1)
+cast(str)
+cast(str, b"ar", "foo")
+
+# TODO: Either support keyword arguments properly,
+# or give a comprehensible error message saying they're unsupported
+cast(val="foo", typ=int)  # error: [unresolved-reference] "Name `foo` used when not defined"
+```

crates/red_knot_python_semantic/resources/mdtest/intersection_types.md

@@ -0,0 +1,848 @@
+# Intersection types
+
+## Introduction
+
+This test suite covers certain properties of intersection types and makes sure that we can apply
+various simplification strategies. We use `Intersection` (`&`) and `Not` (`~`) to construct
+intersection types (note that we display negative contributions at the end; the order does not
+matter):
+
+```py
+from knot_extensions import Intersection, Not
+
+class P: ...
+class Q: ...
+
+def _(
+    i1: Intersection[P, Q],
+    i2: Intersection[P, Not[Q]],
+    i3: Intersection[Not[P], Q],
+    i4: Intersection[Not[P], Not[Q]],
+) -> None:
+    reveal_type(i1)  # revealed: P & Q
+    reveal_type(i2)  # revealed: P & ~Q
+    reveal_type(i3)  # revealed: Q & ~P
+    reveal_type(i4)  # revealed: ~P & ~Q
+```
+
+## Notation
+
+Throughout this document, we use the following types as representatives for certain equivalence
+classes.
+
+### Non-disjoint types
+
+We use `P`, `Q`, `R`, … to denote types that are non-disjoint:
+
+```py
+from knot_extensions import static_assert, is_disjoint_from
+
+class P: ...
+class Q: ...
+class R: ...
+
+static_assert(not is_disjoint_from(P, Q))
+static_assert(not is_disjoint_from(P, R))
+static_assert(not is_disjoint_from(Q, R))
+```
+
+Although `P` is not a subtype of `Q` and `Q` is not a subtype of `P`, the two types are not disjoint
+because it would be possible to create a class `S` that inherits from both `P` and `Q` using
+multiple inheritance. An instance of `S` would be a member of the `P` type _and_ the `Q` type.
+
+### Disjoint types
+
+We use `Literal[1]`, `Literal[2]`, … as examples of pairwise-disjoint types, and `int` as a joint
+supertype of these:
+
+```py
+from knot_extensions import static_assert, is_disjoint_from, is_subtype_of
+from typing import Literal
+
+static_assert(is_disjoint_from(Literal[1], Literal[2]))
+static_assert(is_disjoint_from(Literal[1], Literal[3]))
+static_assert(is_disjoint_from(Literal[2], Literal[3]))
+
+static_assert(is_subtype_of(Literal[1], int))
+static_assert(is_subtype_of(Literal[2], int))
+static_assert(is_subtype_of(Literal[3], int))
+```
+
+### Subtypes
+
+Finally, we use `A <: B <: C` and `A <: B1`, `A <: B2` to denote hierarchies of (proper) subtypes:
+
+```py
+from knot_extensions import static_assert, is_subtype_of, is_disjoint_from
+
+class A: ...
+class B(A): ...
+class C(B): ...
+
+static_assert(is_subtype_of(B, A))
+static_assert(is_subtype_of(C, B))
+static_assert(is_subtype_of(C, A))
+
+static_assert(not is_subtype_of(A, B))
+static_assert(not is_subtype_of(B, C))
+static_assert(not is_subtype_of(A, C))
+
+class B1(A): ...
+class B2(A): ...
+
+static_assert(is_subtype_of(B1, A))
+static_assert(is_subtype_of(B2, A))
+
+static_assert(not is_subtype_of(A, B1))
+static_assert(not is_subtype_of(A, B2))
+
+static_assert(not is_subtype_of(B1, B2))
+static_assert(not is_subtype_of(B2, B1))
+```
+
+## Structural properties
+
+This section covers structural properties of intersection types and documents some decisions on how
+to represent mixtures of intersections and unions.
+
+### Single-element intersections
+
+If we have an intersection with a single element, we can simplify to that element. Similarly, we
+show an intersection with a single negative contribution as just the negation of that element.
+
+```py
+from knot_extensions import Intersection, Not
+
+class P: ...
+
+def _(
+    i1: Intersection[P],
+    i2: Intersection[Not[P]],
+) -> None:
+    reveal_type(i1)  # revealed: P
+    reveal_type(i2)  # revealed: ~P
+```
+
+### Flattening of nested intersections
+
+We eagerly flatten nested intersections types.
+
+```py
+from knot_extensions import Intersection, Not
+
+class P: ...
+class Q: ...
+class R: ...
+class S: ...
+
+def positive_contributions(
+    i1: Intersection[P, Intersection[Q, R]],
+    i2: Intersection[Intersection[P, Q], R],
+) -> None:
+    reveal_type(i1)  # revealed: P & Q & R
+    reveal_type(i2)  # revealed: P & Q & R
+
+def negative_contributions(
+    i1: Intersection[Not[P], Intersection[Not[Q], Not[R]]],
+    i2: Intersection[Intersection[Not[P], Not[Q]], Not[R]],
+) -> None:
+    reveal_type(i1)  # revealed: ~P & ~Q & ~R
+    reveal_type(i2)  # revealed: ~P & ~Q & ~R
+
+def mixed(
+    i1: Intersection[P, Intersection[Not[Q], R]],
+    i2: Intersection[Intersection[P, Not[Q]], R],
+    i3: Intersection[Not[P], Intersection[Q, Not[R]]],
+    i4: Intersection[Intersection[Q, Not[R]], Not[P]],
+) -> None:
+    reveal_type(i1)  # revealed: P & R & ~Q
+    reveal_type(i2)  # revealed: P & R & ~Q
+    reveal_type(i3)  # revealed: Q & ~P & ~R
+    reveal_type(i4)  # revealed: Q & ~R & ~P
+
+def multiple(
+    i1: Intersection[Intersection[P, Q], Intersection[R, S]],
+):
+    reveal_type(i1)  # revealed: P & Q & R & S
+
+def nested(
+    i1: Intersection[Intersection[Intersection[P, Q], R], S],
+    i2: Intersection[P, Intersection[Q, Intersection[R, S]]],
+):
+    reveal_type(i1)  # revealed: P & Q & R & S
+    reveal_type(i2)  # revealed: P & Q & R & S
+```
+
+### Union of intersections
+
+We always normalize our representation to a _union of intersections_, so when we add a _union to an
+intersection_, we distribute the union over the respective elements:
+
+```py
+from knot_extensions import Intersection, Not
+
+class P: ...
+class Q: ...
+class R: ...
+class S: ...
+
+def _(
+    i1: Intersection[P, Q | R | S],
+    i2: Intersection[P | Q | R, S],
+    i3: Intersection[P | Q, R | S],
+) -> None:
+    reveal_type(i1)  # revealed: P & Q | P & R | P & S
+    reveal_type(i2)  # revealed: P & S | Q & S | R & S
+    reveal_type(i3)  # revealed: P & R | Q & R | P & S | Q & S
+
+def simplifications_for_same_elements(
+    i1: Intersection[P, Q | P],
+    i2: Intersection[Q, P | Q],
+    i3: Intersection[P | Q, Q | R],
+    i4: Intersection[P | Q, P | Q],
+    i5: Intersection[P | Q, Q | P],
+) -> None:
+    #   P & (Q | P)
+    # = P & Q | P & P
+    # = P & Q | P
+    # = P
+    # (because P is a supertype of P & Q)
+    reveal_type(i1)  # revealed: P
+    # similar here:
+    reveal_type(i2)  # revealed: Q
+
+    #   (P | Q) & (Q | R)
+    # = P & Q | P & R | Q & Q | Q & R
+    # = P & Q | P & R | Q | Q & R
+    # = Q | P & R
+    # (again, because Q is a supertype of P & Q and of Q & R)
+    reveal_type(i3)  # revealed: Q | P & R
+
+    #   (P | Q) & (P | Q)
+    # = P & P | P & Q | Q & P | Q & Q
+    # = P | P & Q | Q
+    # = P | Q
+    reveal_type(i4)  # revealed: P | Q
+```
+
+### Negation distributes over union
+
+Distribution also applies to a negation operation. This is a manifestation of one of
+[De Morgan's laws], namely `~(P | Q) = ~P & ~Q`:
+
+```py
+from knot_extensions import Not
+from typing import Literal
+
+class P: ...
+class Q: ...
+class R: ...
+
+def _(i1: Not[P | Q], i2: Not[P | Q | R]) -> None:
+    reveal_type(i1)  # revealed: ~P & ~Q
+    reveal_type(i2)  # revealed: ~P & ~Q & ~R
+
+def example_literals(i: Not[Literal[1, 2]]) -> None:
+    reveal_type(i)  # revealed: ~Literal[1] & ~Literal[2]
+```
+
+### Negation of intersections
+
+The other of [De Morgan's laws], `~(P & Q) = ~P | ~Q`, also holds:
+
+```py
+from knot_extensions import Intersection, Not
+
+class P: ...
+class Q: ...
+class R: ...
+
+def _(
+    i1: Not[Intersection[P, Q]],
+    i2: Not[Intersection[P, Q, R]],
+) -> None:
+    reveal_type(i1)  # revealed: ~P | ~Q
+    reveal_type(i2)  # revealed: ~P | ~Q | ~R
+```
+
+### `Never` is dual to `object`
+
+`Never` represents the empty set of values, while `object` represents the set of all values, so
+`~Never` is equivalent to `object`, and `~object` is equivalent to `Never`. This is a manifestation
+of the [complement laws] of set theory.
+
+```py
+from knot_extensions import Intersection, Not
+from typing_extensions import Never
+
+def _(
+    not_never: Not[Never],
+    not_object: Not[object],
+) -> None:
+    reveal_type(not_never)  # revealed: object
+    reveal_type(not_object)  # revealed: Never
+```
+
+### `object & ~T` is equivalent to `~T`
+
+A second consequence of the fact that `object` is the top type is that `object` is always redundant
+in intersections, and can be eagerly simplified out. `object & P` is equivalent to `P`;
+`object & ~P` is equivalent to `~P` for any type `P`.
+
+```py
+from knot_extensions import Intersection, Not, is_equivalent_to, static_assert
+
+class P: ...
+
+static_assert(is_equivalent_to(Intersection[object, P], P))
+static_assert(is_equivalent_to(Intersection[object, Not[P]], Not[P]))
+```
+
+### Intersection of a type and its negation
+
+Continuing with more [complement laws], if we see both `P` and `~P` in an intersection, we can
+simplify to `Never`, even in the presence of other types:
+
+```py
+from knot_extensions import Intersection, Not
+from typing import Any
+
+class P: ...
+class Q: ...
+
+def _(
+    i1: Intersection[P, Not[P]],
+    i2: Intersection[Not[P], P],
+    i3: Intersection[P, Q, Not[P]],
+    i4: Intersection[Not[P], Q, P],
+    i5: Intersection[P, Any, Not[P]],
+    i6: Intersection[Not[P], Any, P],
+) -> None:
+    reveal_type(i1)  # revealed: Never
+    reveal_type(i2)  # revealed: Never
+    reveal_type(i3)  # revealed: Never
+    reveal_type(i4)  # revealed: Never
+    reveal_type(i5)  # revealed: Never
+    reveal_type(i6)  # revealed: Never
+```
+
+### Union of a type and its negation
+
+Similarly, if we have both `P` and `~P` in a _union_, we can simplify that to `object`.
+
+```py
+from knot_extensions import Intersection, Not
+
+class P: ...
+class Q: ...
+
+def _(
+    i1: P | Not[P],
+    i2: Not[P] | P,
+    i3: P | Q | Not[P],
+    i4: Not[P] | Q | P,
+) -> None:
+    reveal_type(i1)  # revealed: object
+    reveal_type(i2)  # revealed: object
+    reveal_type(i3)  # revealed: object
+    reveal_type(i4)  # revealed: object
+```
+
+### Negation is an involution
+
+The final of the [complement laws] states that negating twice is equivalent to not negating at all:
+
+```py
+from knot_extensions import Not
+
+class P: ...
+
+def _(
+    i1: Not[P],
+    i2: Not[Not[P]],
+    i3: Not[Not[Not[P]]],
+    i4: Not[Not[Not[Not[P]]]],
+) -> None:
+    reveal_type(i1)  # revealed: ~P
+    reveal_type(i2)  # revealed: P
+    reveal_type(i3)  # revealed: ~P
+    reveal_type(i4)  # revealed: P
+```
+
+## Simplification strategies
+
+In this section, we present various simplification strategies that go beyond the structure of the
+representation.
+
+### `Never` in intersections
+
+If we intersect with `Never`, we can simplify the whole intersection to `Never`, even if there are
+dynamic types involved:
+
+```py
+from knot_extensions import Intersection, Not
+from typing_extensions import Never, Any
+
+class P: ...
+class Q: ...
+
+def _(
+    i1: Intersection[P, Never],
+    i2: Intersection[Never, P],
+    i3: Intersection[Any, Never],
+    i4: Intersection[Never, Not[Any]],
+) -> None:
+    reveal_type(i1)  # revealed: Never
+    reveal_type(i2)  # revealed: Never
+    reveal_type(i3)  # revealed: Never
+    reveal_type(i4)  # revealed: Never
+```
+
+### Simplifications using disjointness
+
+#### Positive contributions
+
+If we intersect disjoint types, we can simplify to `Never`, even in the presence of other types:
+
+```py
+from knot_extensions import Intersection, Not
+from typing import Literal, Any
+
+class P: ...
+
+def _(
+    i01: Intersection[Literal[1], Literal[2]],
+    i02: Intersection[Literal[2], Literal[1]],
+    i03: Intersection[Literal[1], Literal[2], P],
+    i04: Intersection[Literal[1], P, Literal[2]],
+    i05: Intersection[P, Literal[1], Literal[2]],
+    i06: Intersection[Literal[1], Literal[2], Any],
+    i07: Intersection[Literal[1], Any, Literal[2]],
+    i08: Intersection[Any, Literal[1], Literal[2]],
+) -> None:
+    reveal_type(i01)  # revealed: Never
+    reveal_type(i02)  # revealed: Never
+    reveal_type(i03)  # revealed: Never
+    reveal_type(i04)  # revealed: Never
+    reveal_type(i05)  # revealed: Never
+    reveal_type(i06)  # revealed: Never
+    reveal_type(i07)  # revealed: Never
+    reveal_type(i08)  # revealed: Never
+
+# `bool` is final and can not be subclassed, so `type[bool]` is equivalent to `Literal[bool]`, which
+# is disjoint from `type[str]`:
+def example_type_bool_type_str(
+    i: Intersection[type[bool], type[str]],
+) -> None:
+    reveal_type(i)  # revealed: Never
+```
+
+#### Positive and negative contributions
+
+If we intersect a type `X` with the negation `~Y` of a disjoint type `Y`, we can remove the negative
+contribution `~Y`, as `~Y` must fully contain the positive contribution `X` as a subtype:
+
+```py
+from knot_extensions import Intersection, Not
+from typing import Literal
+
+def _(
+    i1: Intersection[Literal[1], Not[Literal[2]]],
+    i2: Intersection[Not[Literal[2]], Literal[1]],
+    i3: Intersection[Literal[1], Not[Literal[2]], int],
+    i4: Intersection[Literal[1], int, Not[Literal[2]]],
+    i5: Intersection[int, Literal[1], Not[Literal[2]]],
+) -> None:
+    reveal_type(i1)  # revealed: Literal[1]
+    reveal_type(i2)  # revealed: Literal[1]
+    reveal_type(i3)  # revealed: Literal[1]
+    reveal_type(i4)  # revealed: Literal[1]
+    reveal_type(i5)  # revealed: Literal[1]
+
+# None is disjoint from int, so this simplification applies here
+def example_none(
+    i1: Intersection[int, Not[None]],
+    i2: Intersection[Not[None], int],
+) -> None:
+    reveal_type(i1)  # revealed: int
+    reveal_type(i2)  # revealed: int
+```
+
+### Simplifications using subtype relationships
+
+#### Positive type and positive subtype
+
+Subtypes are contained within their supertypes, so we can simplify intersections by removing
+superfluous supertypes:
+
+```py
+from knot_extensions import Intersection, Not
+from typing import Any
+
+class A: ...
+class B(A): ...
+class C(B): ...
+class Unrelated: ...
+
+def _(
+    i01: Intersection[A, B],
+    i02: Intersection[B, A],
+    i03: Intersection[A, C],
+    i04: Intersection[C, A],
+    i05: Intersection[B, C],
+    i06: Intersection[C, B],
+    i07: Intersection[A, B, C],
+    i08: Intersection[C, B, A],
+    i09: Intersection[B, C, A],
+    i10: Intersection[A, B, Unrelated],
+    i11: Intersection[B, A, Unrelated],
+    i12: Intersection[B, Unrelated, A],
+    i13: Intersection[A, Unrelated, B],
+    i14: Intersection[Unrelated, A, B],
+    i15: Intersection[Unrelated, B, A],
+    i16: Intersection[A, B, Any],
+    i17: Intersection[B, A, Any],
+    i18: Intersection[B, Any, A],
+    i19: Intersection[A, Any, B],
+    i20: Intersection[Any, A, B],
+    i21: Intersection[Any, B, A],
+) -> None:
+    reveal_type(i01)  # revealed: B
+    reveal_type(i02)  # revealed: B
+    reveal_type(i03)  # revealed: C
+    reveal_type(i04)  # revealed: C
+    reveal_type(i05)  # revealed: C
+    reveal_type(i06)  # revealed: C
+    reveal_type(i07)  # revealed: C
+    reveal_type(i08)  # revealed: C
+    reveal_type(i09)  # revealed: C
+    reveal_type(i10)  # revealed: B & Unrelated
+    reveal_type(i11)  # revealed: B & Unrelated
+    reveal_type(i12)  # revealed: B & Unrelated
+    reveal_type(i13)  # revealed: Unrelated & B
+    reveal_type(i14)  # revealed: Unrelated & B
+    reveal_type(i15)  # revealed: Unrelated & B
+    reveal_type(i16)  # revealed: B & Any
+    reveal_type(i17)  # revealed: B & Any
+    reveal_type(i18)  # revealed: B & Any
+    reveal_type(i19)  # revealed: Any & B
+    reveal_type(i20)  # revealed: Any & B
+    reveal_type(i21)  # revealed: Any & B
+```
+
+#### Negative type and negative subtype
+
+For negative contributions, this property is reversed. Here we can remove superfluous _subtypes_:
+
+```py
+from knot_extensions import Intersection, Not
+from typing import Any
+
+class A: ...
+class B(A): ...
+class C(B): ...
+class Unrelated: ...
+
+def _(
+    i01: Intersection[Not[B], Not[A]],
+    i02: Intersection[Not[A], Not[B]],
+    i03: Intersection[Not[A], Not[C]],
+    i04: Intersection[Not[C], Not[A]],
+    i05: Intersection[Not[B], Not[C]],
+    i06: Intersection[Not[C], Not[B]],
+    i07: Intersection[Not[A], Not[B], Not[C]],
+    i08: Intersection[Not[C], Not[B], Not[A]],
+    i09: Intersection[Not[B], Not[C], Not[A]],
+    i10: Intersection[Not[B], Not[A], Unrelated],
+    i11: Intersection[Not[A], Not[B], Unrelated],
+    i12: Intersection[Not[A], Unrelated, Not[B]],
+    i13: Intersection[Not[B], Unrelated, Not[A]],
+    i14: Intersection[Unrelated, Not[A], Not[B]],
+    i15: Intersection[Unrelated, Not[B], Not[A]],
+    i16: Intersection[Not[B], Not[A], Any],
+    i17: Intersection[Not[A], Not[B], Any],
+    i18: Intersection[Not[A], Any, Not[B]],
+    i19: Intersection[Not[B], Any, Not[A]],
+    i20: Intersection[Any, Not[A], Not[B]],
+    i21: Intersection[Any, Not[B], Not[A]],
+) -> None:
+    reveal_type(i01)  # revealed: ~A
+    reveal_type(i02)  # revealed: ~A
+    reveal_type(i03)  # revealed: ~A
+    reveal_type(i04)  # revealed: ~A
+    reveal_type(i05)  # revealed: ~B
+    reveal_type(i06)  # revealed: ~B
+    reveal_type(i07)  # revealed: ~A
+    reveal_type(i08)  # revealed: ~A
+    reveal_type(i09)  # revealed: ~A
+    reveal_type(i10)  # revealed: Unrelated & ~A
+    reveal_type(i11)  # revealed: Unrelated & ~A
+    reveal_type(i12)  # revealed: Unrelated & ~A
+    reveal_type(i13)  # revealed: Unrelated & ~A
+    reveal_type(i14)  # revealed: Unrelated & ~A
+    reveal_type(i15)  # revealed: Unrelated & ~A
+    reveal_type(i16)  # revealed: Any & ~A
+    reveal_type(i17)  # revealed: Any & ~A
+    reveal_type(i18)  # revealed: Any & ~A
+    reveal_type(i19)  # revealed: Any & ~A
+    reveal_type(i20)  # revealed: Any & ~A
+    reveal_type(i21)  # revealed: Any & ~A
+```
+
+#### Negative type and multiple negative subtypes
+
+If there are multiple negative subtypes, all of them can be removed:
+
+```py
+from knot_extensions import Intersection, Not
+
+class A: ...
+class B1(A): ...
+class B2(A): ...
+
+def _(
+    i1: Intersection[Not[A], Not[B1], Not[B2]],
+    i2: Intersection[Not[A], Not[B2], Not[B1]],
+    i3: Intersection[Not[B1], Not[A], Not[B2]],
+    i4: Intersection[Not[B1], Not[B2], Not[A]],
+    i5: Intersection[Not[B2], Not[A], Not[B1]],
+    i6: Intersection[Not[B2], Not[B1], Not[A]],
+) -> None:
+    reveal_type(i1)  # revealed: ~A
+    reveal_type(i2)  # revealed: ~A
+    reveal_type(i3)  # revealed: ~A
+    reveal_type(i4)  # revealed: ~A
+    reveal_type(i5)  # revealed: ~A
+    reveal_type(i6)  # revealed: ~A
+```
+
+#### Negative type and positive subtype
+
+When `A` is a supertype of `B`, its negation `~A` is disjoint from `B`, so we can simplify the
+intersection to `Never`:
+
+```py
+from knot_extensions import Intersection, Not
+from typing import Any
+
+class A: ...
+class B(A): ...
+class C(B): ...
+class Unrelated: ...
+
+def _(
+    i1: Intersection[Not[A], B],
+    i2: Intersection[B, Not[A]],
+    i3: Intersection[Not[A], C],
+    i4: Intersection[C, Not[A]],
+    i5: Intersection[Unrelated, Not[A], B],
+    i6: Intersection[B, Not[A], Not[Unrelated]],
+    i7: Intersection[Any, Not[A], B],
+    i8: Intersection[B, Not[A], Not[Any]],
+) -> None:
+    reveal_type(i1)  # revealed: Never
+    reveal_type(i2)  # revealed: Never
+    reveal_type(i3)  # revealed: Never
+    reveal_type(i4)  # revealed: Never
+    reveal_type(i5)  # revealed: Never
+    reveal_type(i6)  # revealed: Never
+    reveal_type(i7)  # revealed: Never
+    reveal_type(i8)  # revealed: Never
+```
+
+### Simplifications of `bool`, `AlwaysTruthy` and `AlwaysFalsy`
+
+In general, intersections with `AlwaysTruthy` and `AlwaysFalsy` cannot be simplified. Naively, you
+might think that `int & AlwaysFalsy` could simplify to `Literal[0]`, but this is not the case: for
+example, the `False` constant inhabits the type `int & AlwaysFalsy` (due to the fact that
+`False.__class__` is `bool` at runtime, and `bool` subclasses `int`), but `False` does not inhabit
+the type `Literal[0]`.
+
+Nonetheless, intersections of `AlwaysFalsy` or `AlwaysTruthy` with `bool` _can_ be simplified, due
+to the fact that `bool` is a `@final` class at runtime that cannot be subclassed.
+
+```py
+from knot_extensions import Intersection, Not, AlwaysTruthy, AlwaysFalsy
+
+class P: ...
+
+def f(
+    a: Intersection[bool, AlwaysTruthy],
+    b: Intersection[bool, AlwaysFalsy],
+    c: Intersection[bool, Not[AlwaysTruthy]],
+    d: Intersection[bool, Not[AlwaysFalsy]],
+    e: Intersection[bool, AlwaysTruthy, P],
+    f: Intersection[bool, AlwaysFalsy, P],
+    g: Intersection[bool, Not[AlwaysTruthy], P],
+    h: Intersection[bool, Not[AlwaysFalsy], P],
+):
+    reveal_type(a)  # revealed: Literal[True]
+    reveal_type(b)  # revealed: Literal[False]
+    reveal_type(c)  # revealed: Literal[False]
+    reveal_type(d)  # revealed: Literal[True]
+
+    # `bool & AlwaysTruthy & P` -> `Literal[True] & P` -> `Never`
+    reveal_type(e)  # revealed: Never
+    reveal_type(f)  # revealed: Never
+    reveal_type(g)  # revealed: Never
+    reveal_type(h)  # revealed: Never
+```
+
+## Simplification of `LiteralString`, `AlwaysTruthy` and `AlwaysFalsy`
+
+Similarly, intersections between `LiteralString`, `AlwaysTruthy` and `AlwaysFalsy` can be
+simplified, due to the fact that a `LiteralString` inhabitant is known to have `__class__` set to
+exactly `str` (and not a subclass of `str`):
+
+```py
+from knot_extensions import Intersection, Not, AlwaysTruthy, AlwaysFalsy, Unknown
+from typing_extensions import LiteralString
+
+def f(
+    a: Intersection[LiteralString, AlwaysTruthy],
+    b: Intersection[LiteralString, AlwaysFalsy],
+    c: Intersection[LiteralString, Not[AlwaysTruthy]],
+    d: Intersection[LiteralString, Not[AlwaysFalsy]],
+    e: Intersection[AlwaysFalsy, LiteralString],
+    f: Intersection[Not[AlwaysTruthy], LiteralString],
+    g: Intersection[AlwaysTruthy, LiteralString],
+    h: Intersection[Not[AlwaysFalsy], LiteralString],
+    i: Intersection[Unknown, LiteralString, AlwaysFalsy],
+    j: Intersection[Not[AlwaysTruthy], Unknown, LiteralString],
+):
+    reveal_type(a)  # revealed: LiteralString & ~Literal[""]
+    reveal_type(b)  # revealed: Literal[""]
+    reveal_type(c)  # revealed: Literal[""]
+    reveal_type(d)  # revealed: LiteralString & ~Literal[""]
+    reveal_type(e)  # revealed: Literal[""]
+    reveal_type(f)  # revealed: Literal[""]
+    reveal_type(g)  # revealed: LiteralString & ~Literal[""]
+    reveal_type(h)  # revealed: LiteralString & ~Literal[""]
+    reveal_type(i)  # revealed: Unknown & Literal[""]
+    reveal_type(j)  # revealed: Unknown & Literal[""]
+```
+
+## Addition of a type to an intersection with many non-disjoint types
+
+This slightly strange-looking test is a regression test for a mistake that was nearly made in a PR:
+<https://github.com/astral-sh/ruff/pull/15475#discussion_r1915041987>.
+
+```py
+from knot_extensions import AlwaysFalsy, Intersection, Unknown
+from typing_extensions import Literal
+
+def _(x: Intersection[str, Unknown, AlwaysFalsy, Literal[""]]):
+    reveal_type(x)  # revealed: Unknown & Literal[""]
+```
+
+## Non fully-static types
+
+### Negation of dynamic types
+
+`Any` represents the dynamic type, an unknown set of runtime values. The negation of that, `~Any`,
+is still an unknown set of runtime values, so `~Any` is equivalent to `Any`. We therefore eagerly
+simplify `~Any` to `Any` in intersections. The same applies to `Unknown`.
+
+```py
+from knot_extensions import Intersection, Not, Unknown
+from typing_extensions import Any, Never
+
+class P: ...
+
+def any(
+    i1: Not[Any],
+    i2: Intersection[P, Not[Any]],
+    i3: Intersection[Never, Not[Any]],
+) -> None:
+    reveal_type(i1)  # revealed: Any
+    reveal_type(i2)  # revealed: P & Any
+    reveal_type(i3)  # revealed: Never
+
+def unknown(
+    i1: Not[Unknown],
+    i2: Intersection[P, Not[Unknown]],
+    i3: Intersection[Never, Not[Unknown]],
+) -> None:
+    reveal_type(i1)  # revealed: Unknown
+    reveal_type(i2)  # revealed: P & Unknown
+    reveal_type(i3)  # revealed: Never
+```
+
+### Collapsing of multiple `Any`/`Unknown` contributions
+
+The intersection of an unknown set of runtime values with (another) unknown set of runtime values is
+still an unknown set of runtime values:
+
+```py
+from knot_extensions import Intersection, Not, Unknown
+from typing_extensions import Any
+
+class P: ...
+
+def any(
+    i1: Intersection[Any, Any],
+    i2: Intersection[P, Any, Any],
+    i3: Intersection[Any, P, Any],
+    i4: Intersection[Any, Any, P],
+) -> None:
+    reveal_type(i1)  # revealed: Any
+    reveal_type(i2)  # revealed: P & Any
+    reveal_type(i3)  # revealed: Any & P
+    reveal_type(i4)  # revealed: Any & P
+
+def unknown(
+    i1: Intersection[Unknown, Unknown],
+    i2: Intersection[P, Unknown, Unknown],
+    i3: Intersection[Unknown, P, Unknown],
+    i4: Intersection[Unknown, Unknown, P],
+) -> None:
+    reveal_type(i1)  # revealed: Unknown
+    reveal_type(i2)  # revealed: P & Unknown
+    reveal_type(i3)  # revealed: Unknown & P
+    reveal_type(i4)  # revealed: Unknown & P
+```
+
+### No self-cancellation
+
+Dynamic types do not cancel each other out. Intersecting an unknown set of values with the negation
+of another unknown set of values is not necessarily empty, so we keep the positive contribution:
+
+```py
+from knot_extensions import Intersection, Not, Unknown
+
+def any(
+    i1: Intersection[Any, Not[Any]],
+    i2: Intersection[Not[Any], Any],
+) -> None:
+    reveal_type(i1)  # revealed: Any
+    reveal_type(i2)  # revealed: Any
+
+def unknown(
+    i1: Intersection[Unknown, Not[Unknown]],
+    i2: Intersection[Not[Unknown], Unknown],
+) -> None:
+    reveal_type(i1)  # revealed: Unknown
+    reveal_type(i2)  # revealed: Unknown
+```
+
+### Mixed dynamic types
+
+We currently do not simplify mixed dynamic types, but might consider doing so in the future:
+
+```py
+from knot_extensions import Intersection, Not, Unknown
+
+def mixed(
+    i1: Intersection[Any, Unknown],
+    i2: Intersection[Any, Not[Unknown]],
+    i3: Intersection[Not[Any], Unknown],
+    i4: Intersection[Not[Any], Not[Unknown]],
+) -> None:
+    reveal_type(i1)  # revealed: Any & Unknown
+    reveal_type(i2)  # revealed: Any & Unknown
+    reveal_type(i3)  # revealed: Any & Unknown
+    reveal_type(i4)  # revealed: Any & Unknown
+```
+
+[complement laws]: https://en.wikipedia.org/wiki/Complement_(set_theory)
+[de morgan's laws]: https://en.wikipedia.org/wiki/De_Morgan%27s_laws

crates/red_knot_python_semantic/resources/mdtest/narrow/isinstance.md

@@ -91,8 +91,7 @@ if isinstance(x, (A, B)):
 elif isinstance(x, (A, C)):
     reveal_type(x)  # revealed: C & ~A & ~B
 else:
-    # TODO: Should be simplified to ~A & ~B & ~C
-    reveal_type(x)  # revealed: object & ~A & ~B & ~C
+    reveal_type(x)  # revealed: ~A & ~B & ~C
 ```
 
 ## No narrowing for instances of `builtins.type`
@@ -181,3 +180,43 @@ def _(x: object, y: type[int]):
     if isinstance(x, y):
         reveal_type(x)  # revealed: int
 ```
+
+## Adding a disjoint element to an existing intersection
+
+We used to incorrectly infer `Literal` booleans for some of these.
+
+```py
+from knot_extensions import Not, Intersection, AlwaysTruthy, AlwaysFalsy
+
+class P: ...
+
+def f(
+    a: Intersection[P, AlwaysTruthy],
+    b: Intersection[P, AlwaysFalsy],
+    c: Intersection[P, Not[AlwaysTruthy]],
+    d: Intersection[P, Not[AlwaysFalsy]],
+):
+    if isinstance(a, bool):
+        reveal_type(a)  # revealed: Never
+    else:
+        # TODO: `bool` is final, so `& ~bool` is redundant here
+        reveal_type(a)  # revealed: P & AlwaysTruthy & ~bool
+
+    if isinstance(b, bool):
+        reveal_type(b)  # revealed: Never
+    else:
+        # TODO: `bool` is final, so `& ~bool` is redundant here
+        reveal_type(b)  # revealed: P & AlwaysFalsy & ~bool
+
+    if isinstance(c, bool):
+        reveal_type(c)  # revealed: Never
+    else:
+        # TODO: `bool` is final, so `& ~bool` is redundant here
+        reveal_type(c)  # revealed: P & ~AlwaysTruthy & ~bool
+
+    if isinstance(d, bool):
+        reveal_type(d)  # revealed: Never
+    else:
+        # TODO: `bool` is final, so `& ~bool` is redundant here
+        reveal_type(d)  # revealed: P & ~AlwaysFalsy & ~bool
+```

crates/red_knot_python_semantic/resources/mdtest/narrow/truthiness.md

@@ -21,22 +21,22 @@ else:
 if x and not x:
     reveal_type(x)  # revealed: Never
 else:
-    reveal_type(x)  # revealed: Literal[0, "", b"", -1, "foo", b"bar"] | bool | None | tuple[()]
+    reveal_type(x)  # revealed: Literal[0, -1, "", "foo", b"", b"bar"] | bool | None | tuple[()]
 
 if not (x and not x):
-    reveal_type(x)  # revealed: Literal[0, "", b"", -1, "foo", b"bar"] | bool | None | tuple[()]
+    reveal_type(x)  # revealed: Literal[0, -1, "", "foo", b"", b"bar"] | bool | None | tuple[()]
 else:
     reveal_type(x)  # revealed: Never
 
 if x or not x:
-    reveal_type(x)  # revealed: Literal[-1, "foo", b"bar", 0, "", b""] | bool | None | tuple[()]
+    reveal_type(x)  # revealed: Literal[0, -1, "", "foo", b"", b"bar"] | bool | None | tuple[()]
 else:
     reveal_type(x)  # revealed: Never
 
 if not (x or not x):
     reveal_type(x)  # revealed: Never
 else:
-    reveal_type(x)  # revealed: Literal[-1, "foo", b"bar", 0, "", b""] | bool | None | tuple[()]
+    reveal_type(x)  # revealed: Literal[0, -1, "", "foo", b"", b"bar"] | bool | None | tuple[()]
 
 if (isinstance(x, int) or isinstance(x, str)) and x:
     reveal_type(x)  # revealed: Literal[-1, True, "foo"]
@@ -87,10 +87,10 @@ def f(x: A | B):
     if x and not x:
         reveal_type(x)  # revealed: A & ~AlwaysFalsy & ~AlwaysTruthy | B & ~AlwaysFalsy & ~AlwaysTruthy
     else:
-        reveal_type(x)  # revealed: A & ~AlwaysTruthy | B & ~AlwaysTruthy | A & ~AlwaysFalsy | B & ~AlwaysFalsy
+        reveal_type(x)  # revealed: A | B
 
     if x or not x:
-        reveal_type(x)  # revealed: A & ~AlwaysFalsy | B & ~AlwaysFalsy | A & ~AlwaysTruthy | B & ~AlwaysTruthy
+        reveal_type(x)  # revealed: A | B
     else:
         reveal_type(x)  # revealed: A & ~AlwaysTruthy & ~AlwaysFalsy | B & ~AlwaysTruthy & ~AlwaysFalsy
 ```
@@ -199,7 +199,7 @@ def f(x: Literal[0, 1], y: Literal["", "hello"]):
         reveal_type(y)  # revealed: Literal["", "hello"]
 ```
 
-## ControlFlow Merging
+## Control Flow Merging
 
 After merging control flows, when we take the union of all constraints applied in each branch, we
 should return to the original state.
@@ -214,10 +214,9 @@ if x and not x:
     reveal_type(y)  # revealed: A & ~AlwaysFalsy & ~AlwaysTruthy
 else:
     y = x
-    reveal_type(y)  # revealed: A & ~AlwaysTruthy | A & ~AlwaysFalsy
+    reveal_type(y)  # revealed: A
 
-# TODO: It should be A. We should improve UnionBuilder or IntersectionBuilder. (issue #15023)
-reveal_type(y)  # revealed: A & ~AlwaysTruthy | A & ~AlwaysFalsy
+reveal_type(y)  # revealed: A
 ```
 
 ## Truthiness of classes
@@ -313,3 +312,20 @@ def _(x: type[FalsyClass] | type[TruthyClass]):
     reveal_type(x or A())  # revealed: type[TruthyClass] | A
     reveal_type(x and A())  # revealed: type[FalsyClass] | A
 ```
+
+## Truthiness narrowing for `LiteralString`
+
+```py
+from typing_extensions import LiteralString
+
+def _(x: LiteralString):
+    if x:
+        reveal_type(x)  # revealed: LiteralString & ~Literal[""]
+    else:
+        reveal_type(x)  # revealed: Literal[""]
+
+    if not x:
+        reveal_type(x)  # revealed: Literal[""]
+    else:
+        reveal_type(x)  # revealed: LiteralString & ~Literal[""]
+```

crates/red_knot_python_semantic/resources/mdtest/sys_platform.md

@@ -13,7 +13,7 @@ typeshed:
 ```py
 import sys
 
-reveal_type(sys.platform)  # revealed: str
+reveal_type(sys.platform)  # revealed: LiteralString
 ```
 
 ## Explicit selection of `all` platforms
@@ -26,7 +26,7 @@ python-platform = "all"
 ```py
 import sys
 
-reveal_type(sys.platform)  # revealed: str
+reveal_type(sys.platform)  # revealed: LiteralString
 ```
 
 ## Explicit selection of a specific platform
@@ -66,6 +66,6 @@ It is [recommended](https://docs.python.org/3/library/sys.html#sys.platform) to
 ```py
 import sys
 
-reveal_type(sys.platform.startswith("freebsd"))  # revealed: @Todo(instance attributes)
-reveal_type(sys.platform.startswith("linux"))  # revealed: @Todo(instance attributes)
+reveal_type(sys.platform.startswith("freebsd"))  # revealed: @Todo(Attribute access on `LiteralString` types)
+reveal_type(sys.platform.startswith("linux"))  # revealed: @Todo(Attribute access on `LiteralString` types)
 ```

crates/red_knot_python_semantic/resources/mdtest/type_api.md

@@ -94,6 +94,36 @@ reveal_type(C.__mro__)
 u: Unknown[str]
 ```
 
+### `AlwaysTruthy` and `AlwaysFalsy`
+
+`AlwaysTruthy` and `AlwaysFalsy` represent the sets of all possible objects whose truthiness is
+always truthy or falsy, respectively.
+
+They do not accept any type arguments.
+
+```py
+from typing_extensions import Literal
+
+from knot_extensions import AlwaysFalsy, AlwaysTruthy, is_subtype_of, static_assert
+
+static_assert(is_subtype_of(Literal[True], AlwaysTruthy))
+static_assert(is_subtype_of(Literal[False], AlwaysFalsy))
+
+static_assert(not is_subtype_of(int, AlwaysFalsy))
+static_assert(not is_subtype_of(str, AlwaysFalsy))
+
+def _(t: AlwaysTruthy, f: AlwaysFalsy):
+    reveal_type(t)  # revealed: AlwaysTruthy
+    reveal_type(f)  # revealed: AlwaysFalsy
+
+def f(
+    a: AlwaysTruthy[int],  # error: [invalid-type-form]
+    b: AlwaysFalsy[str],  # error: [invalid-type-form]
+):
+    reveal_type(a)  # revealed: Unknown
+    reveal_type(b)  # revealed: Unknown
+```
+
 ## Static assertions
 
 ### Basics

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_equivalent_to.md

@@ -0,0 +1,35 @@
+# Equivalence relation
+
+`is_equivalent_to` implements [the equivalence relation] for fully static types.
+
+Two types `A` and `B` are equivalent iff `A` is a subtype of `B` and `B` is a subtype of `A`.
+
+## Basic
+
+```py
+from typing import Any
+from typing_extensions import Literal
+from knot_extensions import Unknown, is_equivalent_to, static_assert
+
+static_assert(is_equivalent_to(Literal[1, 2], Literal[1, 2]))
+static_assert(is_equivalent_to(type[object], type))
+
+static_assert(not is_equivalent_to(Any, Any))
+static_assert(not is_equivalent_to(Unknown, Unknown))
+static_assert(not is_equivalent_to(Any, None))
+static_assert(not is_equivalent_to(Literal[1, 2], Literal[1, 0]))
+static_assert(not is_equivalent_to(Literal[1, 2], Literal[1, 2, 3]))
+```
+
+## Equivalence is commutative
+
+```py
+from typing_extensions import Literal
+from knot_extensions import is_equivalent_to, static_assert
+
+static_assert(is_equivalent_to(type, type[object]))
+static_assert(not is_equivalent_to(Literal[1, 0], Literal[1, 2]))
+static_assert(not is_equivalent_to(Literal[1, 2, 3], Literal[1, 2]))
+```
+
+[the equivalence relation]: https://typing.readthedocs.io/en/latest/spec/glossary.html#term-equivalent

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_subtype_of.md

@@ -0,0 +1,453 @@
+# Subtype relation
+
+The `is_subtype_of(S, T)` relation below checks if type `S` is a subtype of type `T`.
+
+A fully static type `S` is a subtype of another fully static type `T` iff the set of values
+represented by `S` is a subset of the set of values represented by `T`.
+
+See the [typing documentation] for more information.
+
+## Basic builtin types
+
+- `bool` is a subtype of `int`. This is modeled after Python's runtime behavior, where `int` is a
+    supertype of `bool` (present in `bool`s bases and MRO).
+- `int` is not a subtype of `float`/`complex`, even though `float`/`complex` can be used in place of
+    `int` in some contexts (see [special case for float and complex]).
+
+```py
+from knot_extensions import is_subtype_of, static_assert
+
+static_assert(is_subtype_of(bool, bool))
+static_assert(is_subtype_of(bool, int))
+static_assert(is_subtype_of(bool, object))
+
+static_assert(is_subtype_of(int, int))
+static_assert(is_subtype_of(int, object))
+
+static_assert(is_subtype_of(object, object))
+
+static_assert(not is_subtype_of(int, bool))
+static_assert(not is_subtype_of(int, str))
+static_assert(not is_subtype_of(object, int))
+
+static_assert(not is_subtype_of(int, float))
+static_assert(not is_subtype_of(int, complex))
+
+static_assert(is_subtype_of(TypeError, Exception))
+static_assert(is_subtype_of(FloatingPointError, Exception))
+```
+
+## Class hierarchies
+
+```py
+from knot_extensions import is_subtype_of, static_assert
+from typing_extensions import Never
+
+class A: ...
+class B1(A): ...
+class B2(A): ...
+class C(B1, B2): ...
+
+static_assert(is_subtype_of(B1, A))
+static_assert(not is_subtype_of(A, B1))
+
+static_assert(is_subtype_of(B2, A))
+static_assert(not is_subtype_of(A, B2))
+
+static_assert(not is_subtype_of(B1, B2))
+static_assert(not is_subtype_of(B2, B1))
+
+static_assert(is_subtype_of(C, B1))
+static_assert(is_subtype_of(C, B2))
+static_assert(not is_subtype_of(B1, C))
+static_assert(not is_subtype_of(B2, C))
+static_assert(is_subtype_of(C, A))
+static_assert(not is_subtype_of(A, C))
+
+static_assert(is_subtype_of(Never, A))
+static_assert(is_subtype_of(Never, B1))
+static_assert(is_subtype_of(Never, B2))
+static_assert(is_subtype_of(Never, C))
+
+static_assert(is_subtype_of(A, object))
+static_assert(is_subtype_of(B1, object))
+static_assert(is_subtype_of(B2, object))
+static_assert(is_subtype_of(C, object))
+```
+
+## Literal types
+
+```py
+from typing_extensions import Literal, LiteralString
+from knot_extensions import is_subtype_of, static_assert
+
+# Boolean literals
+static_assert(is_subtype_of(Literal[True], bool))
+static_assert(is_subtype_of(Literal[True], int))
+static_assert(is_subtype_of(Literal[True], object))
+
+# Integer literals
+static_assert(is_subtype_of(Literal[1], int))
+static_assert(is_subtype_of(Literal[1], object))
+
+static_assert(not is_subtype_of(Literal[1], bool))
+
+# See the note above (or link below) concerning int and float/complex
+static_assert(not is_subtype_of(Literal[1], float))
+
+# String literals
+static_assert(is_subtype_of(Literal["foo"], LiteralString))
+static_assert(is_subtype_of(Literal["foo"], str))
+static_assert(is_subtype_of(Literal["foo"], object))
+
+static_assert(is_subtype_of(LiteralString, str))
+static_assert(is_subtype_of(LiteralString, object))
+
+# Bytes literals
+static_assert(is_subtype_of(Literal[b"foo"], bytes))
+static_assert(is_subtype_of(Literal[b"foo"], object))
+```
+
+## Tuple types
+
+```py
+from knot_extensions import is_subtype_of, static_assert
+
+class A1: ...
+class B1(A1): ...
+class A2: ...
+class B2(A2): ...
+class Unrelated: ...
+
+static_assert(is_subtype_of(B1, A1))
+static_assert(is_subtype_of(B2, A2))
+
+# Zero-element tuples
+static_assert(is_subtype_of(tuple[()], tuple[()]))
+static_assert(not is_subtype_of(tuple[()], tuple[Unrelated]))
+
+# One-element tuples
+static_assert(is_subtype_of(tuple[B1], tuple[A1]))
+static_assert(not is_subtype_of(tuple[B1], tuple[Unrelated]))
+static_assert(not is_subtype_of(tuple[B1], tuple[()]))
+static_assert(not is_subtype_of(tuple[B1], tuple[A1, Unrelated]))
+
+# Two-element tuples
+static_assert(is_subtype_of(tuple[B1, B2], tuple[A1, A2]))
+static_assert(not is_subtype_of(tuple[B1, B2], tuple[Unrelated, A2]))
+static_assert(not is_subtype_of(tuple[B1, B2], tuple[A1, Unrelated]))
+static_assert(not is_subtype_of(tuple[B1, B2], tuple[Unrelated, Unrelated]))
+static_assert(not is_subtype_of(tuple[B1, B2], tuple[()]))
+static_assert(not is_subtype_of(tuple[B1, B2], tuple[A1]))
+static_assert(not is_subtype_of(tuple[B1, B2], tuple[A1, A2, Unrelated]))
+
+static_assert(is_subtype_of(tuple[int], tuple))
+```
+
+## Union types
+
+```py
+from knot_extensions import is_subtype_of, static_assert
+
+class A: ...
+class B1(A): ...
+class B2(A): ...
+class Unrelated1: ...
+class Unrelated2: ...
+
+static_assert(is_subtype_of(B1, A))
+static_assert(is_subtype_of(B2, A))
+
+# Union on the right hand side
+static_assert(is_subtype_of(B1, A | Unrelated1))
+static_assert(is_subtype_of(B1, Unrelated1 | A))
+
+static_assert(not is_subtype_of(B1, Unrelated1 | Unrelated2))
+
+# Union on the left hand side
+static_assert(is_subtype_of(B1 | B2, A))
+static_assert(is_subtype_of(B1 | B2 | A, object))
+
+static_assert(not is_subtype_of(B1 | Unrelated1, A))
+static_assert(not is_subtype_of(Unrelated1 | B1, A))
+
+# Union on both sides
+static_assert(is_subtype_of(B1 | bool, A | int))
+static_assert(is_subtype_of(B1 | bool, int | A))
+
+static_assert(not is_subtype_of(B1 | bool, Unrelated1 | int))
+static_assert(not is_subtype_of(B1 | bool, int | Unrelated1))
+
+# Example: Unions of literals
+static_assert(is_subtype_of(Literal[1, 2, 3], int))
+static_assert(not is_subtype_of(Literal[1, "two", 3], int))
+```
+
+## Intersection types
+
+```py
+from typing_extensions import Literal, LiteralString
+from knot_extensions import Intersection, Not, is_subtype_of, static_assert
+
+class A: ...
+class B1(A): ...
+class B2(A): ...
+class C(B1, B2): ...
+class Unrelated: ...
+
+static_assert(is_subtype_of(B1, A))
+static_assert(is_subtype_of(B2, A))
+static_assert(is_subtype_of(C, A))
+static_assert(is_subtype_of(C, B1))
+static_assert(is_subtype_of(C, B2))
+
+# For complements, the subtyping relation is reversed:
+static_assert(is_subtype_of(Not[A], Not[B1]))
+static_assert(is_subtype_of(Not[A], Not[B2]))
+static_assert(is_subtype_of(Not[A], Not[C]))
+static_assert(is_subtype_of(Not[B1], Not[C]))
+static_assert(is_subtype_of(Not[B2], Not[C]))
+
+# The intersection of two types is a subtype of both:
+static_assert(is_subtype_of(Intersection[B1, B2], B1))
+static_assert(is_subtype_of(Intersection[B1, B2], B2))
+# … and of their common supertype:
+static_assert(is_subtype_of(Intersection[B1, B2], A))
+
+# A common subtype of two types is a subtype of their intersection:
+static_assert(is_subtype_of(C, Intersection[B1, B2]))
+# … but not the other way around:
+static_assert(not is_subtype_of(Intersection[B1, B2], C))
+
+# "Removing" B1 from A leaves a subtype of A.
+static_assert(is_subtype_of(Intersection[A, Not[B1]], A))
+static_assert(is_subtype_of(Intersection[A, Not[B1]], Not[B1]))
+
+# B1 and B2 are not disjoint, so this is not true:
+static_assert(not is_subtype_of(B2, Intersection[A, Not[B1]]))
+# … but for two disjoint subtypes, it is:
+static_assert(is_subtype_of(Literal[2], Intersection[int, Not[Literal[1]]]))
+
+# A and Unrelated are not related, so this is not true:
+static_assert(not is_subtype_of(Intersection[A, Not[B1]], Not[Unrelated]))
+# … but for a disjoint type like `None`, it is:
+static_assert(is_subtype_of(Intersection[A, Not[B1]], Not[None]))
+
+# Complements of types are still subtypes of `object`:
+static_assert(is_subtype_of(Not[A], object))
+
+# More examples:
+static_assert(is_subtype_of(type[str], Not[None]))
+static_assert(is_subtype_of(Not[LiteralString], object))
+
+static_assert(not is_subtype_of(Intersection[int, Not[Literal[2]]], Intersection[int, Not[Literal[3]]]))
+static_assert(not is_subtype_of(Not[Literal[2]], Not[Literal[3]]))
+static_assert(not is_subtype_of(Not[Literal[2]], Not[int]))
+static_assert(not is_subtype_of(int, Not[Literal[3]]))
+static_assert(not is_subtype_of(Literal[1], Intersection[int, Not[Literal[1]]]))
+```
+
+## Special types
+
+### `Never`
+
+`Never` is a subtype of all types.
+
+```py
+from typing_extensions import Literal, Never
+from knot_extensions import AlwaysTruthy, AlwaysFalsy, is_subtype_of, static_assert
+
+static_assert(is_subtype_of(Never, Never))
+static_assert(is_subtype_of(Never, Literal[True]))
+static_assert(is_subtype_of(Never, bool))
+static_assert(is_subtype_of(Never, int))
+static_assert(is_subtype_of(Never, object))
+
+static_assert(is_subtype_of(Never, AlwaysTruthy))
+static_assert(is_subtype_of(Never, AlwaysFalsy))
+```
+
+### `AlwaysTruthy` and `AlwaysFalsy`
+
+```py
+from knot_extensions import AlwaysTruthy, AlwaysFalsy, is_subtype_of, static_assert
+
+static_assert(is_subtype_of(Literal[1], AlwaysTruthy))
+static_assert(is_subtype_of(Literal[0], AlwaysFalsy))
+
+static_assert(is_subtype_of(AlwaysTruthy, object))
+static_assert(is_subtype_of(AlwaysFalsy, object))
+
+static_assert(not is_subtype_of(Literal[1], AlwaysFalsy))
+static_assert(not is_subtype_of(Literal[0], AlwaysTruthy))
+
+static_assert(not is_subtype_of(str, AlwaysTruthy))
+static_assert(not is_subtype_of(str, AlwaysFalsy))
+```
+
+### Module literals
+
+```py
+from types import ModuleType
+from knot_extensions import TypeOf, is_subtype_of, static_assert
+from typing_extensions import assert_type
+import typing
+
+assert_type(typing, TypeOf[typing])
+
+static_assert(is_subtype_of(TypeOf[typing], ModuleType))
+```
+
+### Slice literals
+
+```py
+from knot_extensions import TypeOf, is_subtype_of, static_assert
+
+static_assert(is_subtype_of(TypeOf[1:2:3], slice))
+```
+
+### Special forms
+
+```py
+from typing import _SpecialForm
+from knot_extensions import TypeOf, is_subtype_of, static_assert
+
+static_assert(is_subtype_of(TypeOf[Literal], _SpecialForm))
+static_assert(is_subtype_of(TypeOf[Literal], object))
+
+static_assert(not is_subtype_of(_SpecialForm, TypeOf[Literal]))
+```
+
+## Class literal types and `type[…]`
+
+### Basic
+
+```py
+from typing import _SpecialForm
+from typing_extensions import Literal, assert_type
+from knot_extensions import TypeOf, is_subtype_of, static_assert
+
+class Meta(type): ...
+class HasCustomMetaclass(metaclass=Meta): ...
+
+type LiteralBool = TypeOf[bool]
+type LiteralInt = TypeOf[int]
+type LiteralStr = TypeOf[str]
+type LiteralObject = TypeOf[object]
+
+assert_type(bool, LiteralBool)
+assert_type(int, LiteralInt)
+assert_type(str, LiteralStr)
+assert_type(object, LiteralObject)
+
+# bool
+
+static_assert(is_subtype_of(LiteralBool, LiteralBool))
+static_assert(is_subtype_of(LiteralBool, type[bool]))
+static_assert(is_subtype_of(LiteralBool, type[int]))
+static_assert(is_subtype_of(LiteralBool, type[object]))
+static_assert(is_subtype_of(LiteralBool, type))
+static_assert(is_subtype_of(LiteralBool, object))
+
+static_assert(not is_subtype_of(LiteralBool, LiteralInt))
+static_assert(not is_subtype_of(LiteralBool, LiteralObject))
+static_assert(not is_subtype_of(LiteralBool, bool))
+
+static_assert(not is_subtype_of(type, type[bool]))
+
+# int
+
+static_assert(is_subtype_of(LiteralInt, LiteralInt))
+static_assert(is_subtype_of(LiteralInt, type[int]))
+static_assert(is_subtype_of(LiteralInt, type[object]))
+static_assert(is_subtype_of(LiteralInt, type))
+static_assert(is_subtype_of(LiteralInt, object))
+
+static_assert(not is_subtype_of(LiteralInt, LiteralObject))
+static_assert(not is_subtype_of(LiteralInt, int))
+
+static_assert(not is_subtype_of(type, type[int]))
+
+# LiteralString
+
+static_assert(is_subtype_of(LiteralStr, type[str]))
+static_assert(is_subtype_of(LiteralStr, type))
+static_assert(is_subtype_of(LiteralStr, type[object]))
+
+static_assert(not is_subtype_of(type[str], LiteralStr))
+
+# custom meta classes
+
+type LiteralHasCustomMetaclass = TypeOf[HasCustomMetaclass]
+
+static_assert(is_subtype_of(LiteralHasCustomMetaclass, Meta))
+static_assert(is_subtype_of(Meta, type[object]))
+static_assert(is_subtype_of(Meta, type))
+
+static_assert(not is_subtype_of(Meta, type[type]))
+```
+
+### Unions of class literals
+
+```py
+from typing_extensions import assert_type
+from knot_extensions import TypeOf, is_subtype_of, static_assert
+
+class Base: ...
+class Derived(Base): ...
+class Unrelated: ...
+
+type LiteralBase = TypeOf[Base]
+type LiteralDerived = TypeOf[Derived]
+type LiteralUnrelated = TypeOf[Unrelated]
+
+assert_type(Base, LiteralBase)
+assert_type(Derived, LiteralDerived)
+assert_type(Unrelated, LiteralUnrelated)
+
+static_assert(is_subtype_of(LiteralBase, type))
+static_assert(is_subtype_of(LiteralBase, object))
+
+static_assert(is_subtype_of(LiteralBase, type[Base]))
+static_assert(is_subtype_of(LiteralDerived, type[Base]))
+static_assert(is_subtype_of(LiteralDerived, type[Derived]))
+
+static_assert(not is_subtype_of(LiteralBase, type[Derived]))
+static_assert(is_subtype_of(type[Derived], type[Base]))
+
+static_assert(is_subtype_of(LiteralBase | LiteralUnrelated, type))
+static_assert(is_subtype_of(LiteralBase | LiteralUnrelated, object))
+```
+
+## Non-fully-static types
+
+`Any`, `Unknown`, `Todo` and derivatives thereof do not participate in subtyping.
+
+```py
+from knot_extensions import Unknown, is_subtype_of, static_assert, Intersection
+from typing_extensions import Any
+
+static_assert(not is_subtype_of(Any, Any))
+static_assert(not is_subtype_of(Any, int))
+static_assert(not is_subtype_of(int, Any))
+static_assert(not is_subtype_of(Any, object))
+static_assert(not is_subtype_of(object, Any))
+
+static_assert(not is_subtype_of(int, Any | int))
+static_assert(not is_subtype_of(Intersection[Any, int], int))
+static_assert(not is_subtype_of(tuple[int, int], tuple[int, Any]))
+
+# The same for `Unknown`:
+static_assert(not is_subtype_of(Unknown, Unknown))
+static_assert(not is_subtype_of(Unknown, int))
+static_assert(not is_subtype_of(int, Unknown))
+static_assert(not is_subtype_of(Unknown, object))
+static_assert(not is_subtype_of(object, Unknown))
+
+static_assert(not is_subtype_of(int, Unknown | int))
+static_assert(not is_subtype_of(Intersection[Unknown, int], int))
+static_assert(not is_subtype_of(tuple[int, int], tuple[int, Unknown]))
+```
+
+[special case for float and complex]: https://typing.readthedocs.io/en/latest/spec/special-types.html#special-cases-for-float-and-complex
+[typing documentation]: https://typing.readthedocs.io/en/latest/spec/concepts.html#subtype-supertype-and-type-equivalence

crates/red_knot_python_semantic/resources/mdtest/type_properties/tuples_containing_never.md

@@ -0,0 +1,33 @@
+# Tuples containing `Never`
+
+A heterogeneous `tuple[…]` type that contains `Never` as a type argument simplifies to `Never`. One
+way to think about this is the following: in order to construct a tuple, you need to have an object
+of every element type. But since there is no object of type `Never`, you cannot construct the tuple.
+Such a tuple type is therefore uninhabited and equivalent to `Never`.
+
+In the language of algebraic data types, a tuple type is a product type and `Never` acts like the
+zero element in multiplication, similar to how a Cartesian product with the empty set is the empty
+set.
+
+```py
+from knot_extensions import static_assert, is_equivalent_to
+from typing_extensions import Never, NoReturn
+
+static_assert(is_equivalent_to(Never, tuple[Never]))
+static_assert(is_equivalent_to(Never, tuple[Never, int]))
+static_assert(is_equivalent_to(Never, tuple[int, Never]))
+static_assert(is_equivalent_to(Never, tuple[int, Never, str]))
+static_assert(is_equivalent_to(Never, tuple[int, tuple[str, Never]]))
+static_assert(is_equivalent_to(Never, tuple[tuple[str, Never], int]))
+
+# The empty tuple is *not* equivalent to Never!
+static_assert(not is_equivalent_to(Never, tuple[()]))
+
+# NoReturn is just a different spelling of Never, so the same is true for NoReturn
+static_assert(is_equivalent_to(NoReturn, tuple[NoReturn]))
+static_assert(is_equivalent_to(NoReturn, tuple[NoReturn, int]))
+static_assert(is_equivalent_to(NoReturn, tuple[int, NoReturn]))
+static_assert(is_equivalent_to(NoReturn, tuple[int, NoReturn, str]))
+static_assert(is_equivalent_to(NoReturn, tuple[int, tuple[str, NoReturn]]))
+static_assert(is_equivalent_to(NoReturn, tuple[tuple[str, NoReturn], int]))
+```

crates/red_knot_python_semantic/resources/mdtest/union_types.md

@@ -0,0 +1,143 @@
+# Union types
+
+This test suite covers certain basic properties and simplification strategies for union types.
+
+## Basic unions
+
+```py
+from typing import Literal
+
+def _(u1: int | str, u2: Literal[0] | Literal[1]) -> None:
+    reveal_type(u1)  # revealed: int | str
+    reveal_type(u2)  # revealed: Literal[0, 1]
+```
+
+## Duplicate elements are collapsed
+
+```py
+def _(u1: int | int | str, u2: int | str | int) -> None:
+    reveal_type(u1)  # revealed: int | str
+    reveal_type(u2)  # revealed: int | str
+```
+
+## `Never` is removed
+
+`Never` is an empty set, a type with no inhabitants. Its presence in a union is always redundant,
+and so we eagerly simplify it away. `NoReturn` is equivalent to `Never`.
+
+```py
+from typing_extensions import Never, NoReturn
+
+def never(u1: int | Never, u2: int | Never | str) -> None:
+    reveal_type(u1)  # revealed: int
+    reveal_type(u2)  # revealed:  int | str
+
+def noreturn(u1: int | NoReturn, u2: int | NoReturn | str) -> None:
+    reveal_type(u1)  # revealed: int
+    reveal_type(u2)  # revealed:  int | str
+```
+
+## Flattening of nested unions
+
+```py
+from typing import Literal
+
+def _(
+    u1: (int | str) | bytes,
+    u2: int | (str | bytes),
+    u3: int | (str | (bytes | complex)),
+) -> None:
+    reveal_type(u1)  # revealed: int | str | bytes
+    reveal_type(u2)  # revealed: int | str | bytes
+    reveal_type(u3)  # revealed: int | str | bytes | complex
+```
+
+## Simplification using subtyping
+
+The type `S | T` can be simplified to `T` if `S` is a subtype of `T`:
+
+```py
+from typing_extensions import Literal, LiteralString
+
+def _(
+    u1: str | LiteralString, u2: LiteralString | str, u3: Literal["a"] | str | LiteralString, u4: str | bytes | LiteralString
+) -> None:
+    reveal_type(u1)  # revealed: str
+    reveal_type(u2)  # revealed: str
+    reveal_type(u3)  # revealed: str
+    reveal_type(u4)  # revealed: str | bytes
+```
+
+## Boolean literals
+
+The union `Literal[True] | Literal[False]` is exactly equivalent to `bool`:
+
+```py
+from typing import Literal
+
+def _(
+    u1: Literal[True, False],
+    u2: bool | Literal[True],
+    u3: Literal[True] | bool,
+    u4: Literal[True] | Literal[True, 17],
+    u5: Literal[True, False, True, 17],
+) -> None:
+    reveal_type(u1)  # revealed: bool
+    reveal_type(u2)  # revealed: bool
+    reveal_type(u3)  # revealed: bool
+    reveal_type(u4)  # revealed: Literal[True, 17]
+    reveal_type(u5)  # revealed: bool | Literal[17]
+```
+
+## Do not erase `Unknown`
+
+```py
+from knot_extensions import Unknown
+
+def _(u1: Unknown | str, u2: str | Unknown) -> None:
+    reveal_type(u1)  # revealed: Unknown | str
+    reveal_type(u2)  # revealed: str | Unknown
+```
+
+## Collapse multiple `Unknown`s
+
+Since `Unknown` is a gradual type, it is not a subtype of anything, but multiple `Unknown`s in a
+union are still redundant:
+
+```py
+from knot_extensions import Unknown
+
+def _(u1: Unknown | Unknown | str, u2: Unknown | str | Unknown, u3: str | Unknown | Unknown) -> None:
+    reveal_type(u1)  # revealed: Unknown | str
+    reveal_type(u2)  # revealed: Unknown | str
+    reveal_type(u3)  # revealed: str | Unknown
+```
+
+## Subsume multiple elements
+
+Simplifications still apply when `Unknown` is present.
+
+```py
+from knot_extensions import Unknown
+
+def _(u1: str | Unknown | int | object):
+    reveal_type(u1)  # revealed: Unknown | object
+```
+
+## Union of intersections
+
+We can simplify unions of intersections:
+
+```py
+from knot_extensions import Intersection, Not
+
+class P: ...
+class Q: ...
+
+def _(
+    i1: Intersection[P, Q] | Intersection[P, Q],
+    i2: Intersection[P, Q] | Intersection[Q, P],
+) -> None:
+    reveal_type(i1)  # revealed: P & Q
+    reveal_type(i2)  # revealed: P & Q
+```

crates/red_knot_python_semantic/src/db.rs

@@ -180,7 +180,7 @@ pub(crate) mod tests {
 
             Program::from_settings(
                 &db,
-                &ProgramSettings {
+                ProgramSettings {
                     python_version: self.python_version,
                     python_platform: self.python_platform,
                     search_paths,

crates/red_knot_python_semantic/src/module_resolver/module.rs

@@ -154,6 +154,10 @@ impl KnownModule {
         }
     }
 
+    pub const fn is_builtins(self) -> bool {
+        matches!(self, Self::Builtins)
+    }
+
     pub const fn is_typing(self) -> bool {
         matches!(self, Self::Typing)
     }

crates/red_knot_python_semantic/src/module_resolver/resolver.rs

@@ -1294,7 +1294,7 @@ mod tests {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 python_version: PythonVersion::PY38,
                 python_platform: PythonPlatform::default(),
                 search_paths: SearchPathSettings {
@@ -1800,7 +1800,7 @@ not_a_directory
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 python_version: PythonVersion::default(),
                 python_platform: PythonPlatform::default(),
                 search_paths: SearchPathSettings {

crates/red_knot_python_semantic/src/module_resolver/testing.rs

@@ -232,7 +232,7 @@ impl TestCaseBuilder<MockedTypeshed> {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 python_version,
                 python_platform,
                 search_paths: SearchPathSettings {
@@ -290,7 +290,7 @@ impl TestCaseBuilder<VendoredTypeshed> {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 python_version,
                 python_platform,
                 search_paths: SearchPathSettings {

crates/red_knot_python_semantic/src/program.rs

@@ -1,18 +1,18 @@
+use crate::module_resolver::SearchPaths;
 use crate::python_platform::PythonPlatform;
 use crate::python_version::PythonVersion;
+use crate::Db;
+
 use anyhow::Context;
+use ruff_db::system::{SystemPath, SystemPathBuf};
 use salsa::Durability;
 use salsa::Setter;
 
-use ruff_db::system::{SystemPath, SystemPathBuf};
-
-use crate::module_resolver::SearchPaths;
-use crate::Db;
-
 #[salsa::input(singleton)]
 pub struct Program {
     pub python_version: PythonVersion,
 
+    #[return_ref]
     pub python_platform: PythonPlatform,
 
     #[return_ref]
@@ -20,25 +20,51 @@ pub struct Program {
 }
 
 impl Program {
-    pub fn from_settings(db: &dyn Db, settings: &ProgramSettings) -> anyhow::Result<Self> {
+    pub fn from_settings(db: &dyn Db, settings: ProgramSettings) -> anyhow::Result<Self> {
         let ProgramSettings {
             python_version,
             python_platform,
             search_paths,
         } = settings;
 
-        tracing::info!("Python version: Python {python_version}");
+        tracing::info!("Python version: Python {python_version}, platform: {python_platform}");
 
-        let search_paths = SearchPaths::from_settings(db, search_paths)
+        let search_paths = SearchPaths::from_settings(db, &search_paths)
             .with_context(|| "Invalid search path settings")?;
 
         Ok(
-            Program::builder(*python_version, python_platform.clone(), search_paths)
+            Program::builder(python_version, python_platform, search_paths)
                 .durability(Durability::HIGH)
                 .new(db),
         )
     }
 
+    pub fn update_from_settings(
+        self,
+        db: &mut dyn Db,
+        settings: ProgramSettings,
+    ) -> anyhow::Result<()> {
+        let ProgramSettings {
+            python_version,
+            python_platform,
+            search_paths,
+        } = settings;
+
+        if &python_platform != self.python_platform(db) {
+            tracing::debug!("Updating python platform: `{python_platform:?}`");
+            self.set_python_platform(db).to(python_platform);
+        }
+
+        if python_version != self.python_version(db) {
+            tracing::debug!("Updating python version: Python {python_version}");
+            self.set_python_version(db).to(python_version);
+        }
+
+        self.update_search_paths(db, &search_paths)?;
+
+        Ok(())
+    }
+
     pub fn update_search_paths(
         self,
         db: &mut dyn Db,
@@ -76,7 +102,7 @@ pub struct SearchPathSettings {
     /// or pyright's stubPath configuration setting.
     pub extra_paths: Vec<SystemPathBuf>,
 
-    /// The root of the workspace, used for finding first-party modules.
+    /// The root of the project, used for finding first-party modules.
     pub src_root: SystemPathBuf,
 
     /// Optional path to a "custom typeshed" directory on disk for us to use for standard-library types.

crates/red_knot_python_semantic/src/python_platform.rs

@@ -1,3 +1,5 @@
+use std::fmt::{Display, Formatter};
+
 /// The target platform to assume when resolving types.
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 #[cfg_attr(
@@ -17,3 +19,12 @@ pub enum PythonPlatform {
     #[cfg_attr(feature = "serde", serde(untagged))]
     Identifier(String),
 }
+
+impl Display for PythonPlatform {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            PythonPlatform::All => f.write_str("all"),
+            PythonPlatform::Identifier(name) => f.write_str(name),
+        }
+    }
+}

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -4,11 +4,10 @@ use ruff_python_ast as ast;
 use ruff_text_size::{Ranged, TextRange};
 
 use crate::ast_node_ref::AstNodeRef;
-use crate::module_resolver::file_to_module;
 use crate::node_key::NodeKey;
 use crate::semantic_index::symbol::{FileScopeId, ScopeId, ScopedSymbolId};
 use crate::unpack::Unpack;
-use crate::{Db, KnownModule};
+use crate::Db;
 
 /// A definition of a symbol.
 ///
@@ -61,24 +60,6 @@ impl<'db> Definition<'db> {
     pub(crate) fn is_binding(self, db: &'db dyn Db) -> bool {
         self.kind(db).category().is_binding()
     }
-
-    pub(crate) fn is_builtin_definition(self, db: &'db dyn Db) -> bool {
-        file_to_module(db, self.file(db))
-            .is_some_and(|module| module.is_known(KnownModule::Builtins))
-    }
-
-    /// Return true if this symbol was defined in the `typing` or `typing_extensions` modules
-    pub(crate) fn is_typing_definition(self, db: &'db dyn Db) -> bool {
-        matches!(
-            file_to_module(db, self.file(db)).and_then(|module| module.known()),
-            Some(KnownModule::Typing | KnownModule::TypingExtensions)
-        )
-    }
-
-    pub(crate) fn is_knot_extensions_definition(self, db: &'db dyn Db) -> bool {
-        file_to_module(db, self.file(db))
-            .is_some_and(|module| module.is_known(KnownModule::KnotExtensions))
-    }
 }
 
 #[derive(Copy, Clone, Debug)]

crates/red_knot_python_semantic/src/semantic_index/use_def/bitset.rs

@@ -93,6 +93,19 @@ impl<const B: usize> BitSet<B> {
         }
     }
 
+    /// Union in-place with another [`BitSet`].
+    pub(super) fn union(&mut self, other: &BitSet<B>) {
+        let mut max_len = self.blocks().len();
+        let other_len = other.blocks().len();
+        if other_len > max_len {
+            max_len = other_len;
+            self.resize_blocks(max_len);
+        }
+        for (my_block, other_block) in self.blocks_mut().iter_mut().zip(other.blocks()) {
+            *my_block |= other_block;
+        }
+    }
+
     /// Return an iterator over the values (in ascending order) in this [`BitSet`].
     pub(super) fn iter(&self) -> BitSetIterator<'_, B> {
         let blocks = self.blocks();
@@ -222,6 +235,59 @@ mod tests {
         assert_bitset(&b1, &[89]);
     }
 
+    #[test]
+    fn union() {
+        let mut b1 = BitSet::<1>::with(2);
+        let b2 = BitSet::<1>::with(4);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[2, 4]);
+    }
+
+    #[test]
+    fn union_mixed_1() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(89);
+        b2.insert(5);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 5, 89]);
+    }
+
+    #[test]
+    fn union_mixed_2() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(23);
+        b2.insert(89);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 23, 89]);
+    }
+
+    #[test]
+    fn union_heap() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(89);
+        b2.insert(90);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 89, 90]);
+    }
+
+    #[test]
+    fn union_heap_2() {
+        let mut b1 = BitSet::<1>::with(89);
+        let mut b2 = BitSet::<1>::with(89);
+        b1.insert(91);
+        b2.insert(90);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[89, 90, 91]);
+    }
+
     #[test]
     fn multiple_blocks() {
         let mut b = BitSet::<2>::with(120);

crates/red_knot_python_semantic/src/semantic_index/use_def/symbol_state.rs

@@ -316,6 +316,9 @@ impl SymbolState {
         };
 
         std::mem::swap(&mut a, self);
+        self.declarations
+            .live_declarations
+            .union(&b.declarations.live_declarations);
 
         let mut a_defs_iter = a.bindings.live_bindings.iter();
         let mut b_defs_iter = b.bindings.live_bindings.iter();
@@ -449,10 +452,8 @@ impl SymbolState {
         let mut opt_a_decl: Option<u32> = a_decls_iter.next();
         let mut opt_b_decl: Option<u32> = b_decls_iter.next();
 
-        let push = |decl,
-                    vis_constraints_iter: &mut VisibilityConstraintsIntoIterator,
+        let push = |vis_constraints_iter: &mut VisibilityConstraintsIntoIterator,
                     merged: &mut Self| {
-            merged.declarations.live_declarations.insert(decl);
             let vis_constraints = vis_constraints_iter
                 .next()
                 .expect("declarations and visibility_constraints length mismatch");
@@ -466,15 +467,15 @@ impl SymbolState {
             match (opt_a_decl, opt_b_decl) {
                 (Some(a_decl), Some(b_decl)) => match a_decl.cmp(&b_decl) {
                     std::cmp::Ordering::Less => {
-                        push(a_decl, &mut a_vis_constraints_iter, self);
+                        push(&mut a_vis_constraints_iter, self);
                         opt_a_decl = a_decls_iter.next();
                     }
                     std::cmp::Ordering::Greater => {
-                        push(b_decl, &mut b_vis_constraints_iter, self);
+                        push(&mut b_vis_constraints_iter, self);
                         opt_b_decl = b_decls_iter.next();
                     }
                     std::cmp::Ordering::Equal => {
-                        push(a_decl, &mut b_vis_constraints_iter, self);
+                        push(&mut b_vis_constraints_iter, self);
 
                         let a_vis_constraint = a_vis_constraints_iter
                             .next()
@@ -487,12 +488,12 @@ impl SymbolState {
                         opt_b_decl = b_decls_iter.next();
                     }
                 },
-                (Some(a_decl), None) => {
-                    push(a_decl, &mut a_vis_constraints_iter, self);
+                (Some(_), None) => {
+                    push(&mut a_vis_constraints_iter, self);
                     opt_a_decl = a_decls_iter.next();
                 }
-                (None, Some(b_decl)) => {
-                    push(b_decl, &mut b_vis_constraints_iter, self);
+                (None, Some(_)) => {
+                    push(&mut b_vis_constraints_iter, self);
                     opt_b_decl = b_decls_iter.next();
                 }
                 (None, None) => break,

crates/red_knot_python_semantic/src/types/call.rs

@@ -1,5 +1,5 @@
 use super::context::InferContext;
-use super::diagnostic::CALL_NON_CALLABLE;
+use super::diagnostic::{CALL_NON_CALLABLE, TYPE_ASSERTION_FAILURE};
 use super::{Severity, Signature, Type, TypeArrayDisplay, UnionBuilder};
 use crate::types::diagnostic::STATIC_ASSERT_ERROR;
 use crate::Db;
@@ -44,10 +44,14 @@ pub(super) enum CallOutcome<'db> {
         binding: CallBinding<'db>,
         error_kind: StaticAssertionErrorKind<'db>,
     },
+    AssertType {
+        binding: CallBinding<'db>,
+        asserted_ty: Type<'db>,
+    },
 }
 
 impl<'db> CallOutcome<'db> {
-    /// Create a new `CallOutcome::Callable` with given return type.
+    /// Create a new `CallOutcome::Callable` with given binding.
     pub(super) fn callable(binding: CallBinding<'db>) -> CallOutcome<'db> {
         CallOutcome::Callable { binding }
     }
@@ -76,6 +80,14 @@ impl<'db> CallOutcome<'db> {
         }
     }
 
+    /// Create a new `CallOutcome::AssertType` with given asserted and return types.
+    pub(super) fn asserted(binding: CallBinding<'db>, asserted_ty: Type<'db>) -> CallOutcome<'db> {
+        CallOutcome::AssertType {
+            binding,
+            asserted_ty,
+        }
+    }
+
     /// Get the return type of the call, or `None` if not callable.
     pub(super) fn return_ty(&self, db: &'db dyn Db) -> Option<Type<'db>> {
         match self {
@@ -97,12 +109,16 @@ impl<'db> CallOutcome<'db> {
                     match (acc, ty) {
                         (None, None) => None,
                         (None, Some(ty)) => Some(UnionBuilder::new(db).add(ty)),
-                        (Some(builder), ty) => Some(builder.add(ty.unwrap_or(Type::Unknown))),
+                        (Some(builder), ty) => Some(builder.add(ty.unwrap_or(Type::unknown()))),
                     }
                 })
                 .map(UnionBuilder::build),
             Self::PossiblyUnboundDunderCall { call_outcome, .. } => call_outcome.return_ty(db),
             Self::StaticAssertionError { .. } => Some(Type::none(db)),
+            Self::AssertType {
+                binding,
+                asserted_ty: _,
+            } => Some(binding.return_ty()),
         }
     }
 
@@ -206,7 +222,7 @@ impl<'db> CallOutcome<'db> {
             }
             Self::NotCallable { not_callable_ty } => Err(NotCallableError::Type {
                 not_callable_ty: *not_callable_ty,
-                return_ty: Type::Unknown,
+                return_ty: Type::unknown(),
             }),
             Self::PossiblyUnboundDunderCall {
                 called_ty,
@@ -215,7 +231,7 @@ impl<'db> CallOutcome<'db> {
                 callable_ty: *called_ty,
                 return_ty: call_outcome
                     .return_ty(context.db())
-                    .unwrap_or(Type::Unknown),
+                    .unwrap_or(Type::unknown()),
             }),
             Self::Union {
                 outcomes,
@@ -228,7 +244,7 @@ impl<'db> CallOutcome<'db> {
                     let return_ty = match outcome {
                         Self::NotCallable { not_callable_ty } => {
                             not_callable.push(*not_callable_ty);
-                            Type::Unknown
+                            Type::unknown()
                         }
                         Self::RevealType {
                             binding,
@@ -264,7 +280,7 @@ impl<'db> CallOutcome<'db> {
                     }),
                 }
             }
-            CallOutcome::StaticAssertionError {
+            Self::StaticAssertionError {
                 binding,
                 error_kind,
             } => {
@@ -307,7 +323,29 @@ impl<'db> CallOutcome<'db> {
                     }
                 }
 
-                Ok(Type::Unknown)
+                Ok(Type::unknown())
+            }
+            Self::AssertType {
+                binding,
+                asserted_ty,
+            } => {
+                let [actual_ty, _asserted] = binding.parameter_tys() else {
+                    return Ok(binding.return_ty());
+                };
+
+                if !actual_ty.is_gradual_equivalent_to(context.db(), *asserted_ty) {
+                    context.report_lint(
+                        &TYPE_ASSERTION_FAILURE,
+                        node,
+                        format_args!(
+                            "Actual type `{}` is not the same as asserted type `{}`",
+                            actual_ty.display(context.db()),
+                            asserted_ty.display(context.db()),
+                        ),
+                    );
+                }
+
+                Ok(binding.return_ty())
             }
         }
     }

crates/red_knot_python_semantic/src/types/call/bind.rs

@@ -84,7 +84,7 @@ pub(crate) fn bind_call<'db>(
             }
         }
         if let Some(existing) = parameter_tys[index].replace(*argument_ty) {
-            if parameter.is_variadic() {
+            if parameter.is_variadic() || parameter.is_keyword_variadic() {
                 let union = UnionType::from_elements(db, [existing, *argument_ty]);
                 parameter_tys[index].replace(union);
             } else {
@@ -125,10 +125,10 @@ pub(crate) fn bind_call<'db>(
 
     CallBinding {
         callable_ty,
-        return_ty: signature.return_ty.unwrap_or(Type::Unknown),
+        return_ty: signature.return_ty.unwrap_or(Type::unknown()),
         parameter_tys: parameter_tys
             .into_iter()
-            .map(|opt_ty| opt_ty.unwrap_or(Type::Unknown))
+            .map(|opt_ty| opt_ty.unwrap_or(Type::unknown()))
             .collect(),
         errors,
     }

crates/red_knot_python_semantic/src/types/class_base.rs

@@ -1,5 +1,5 @@
 use crate::types::{
-    todo_type, Class, ClassLiteralType, KnownClass, KnownInstanceType, TodoType, Type,
+    todo_type, Class, ClassLiteralType, DynamicType, KnownClass, KnownInstanceType, Type,
 };
 use crate::Db;
 use itertools::Either;
@@ -8,19 +8,25 @@ use itertools::Either;
 ///
 /// This is much more limited than the [`Type`] enum:
 /// all types that would be invalid to have as a class base are
-/// transformed into [`ClassBase::Unknown`]
+/// transformed into [`ClassBase::unknown`]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, salsa::Update)]
 pub enum ClassBase<'db> {
-    Any,
-    Unknown,
-    Todo(TodoType),
+    Dynamic(DynamicType),
     Class(Class<'db>),
 }
 
 impl<'db> ClassBase<'db> {
+    pub const fn any() -> Self {
+        Self::Dynamic(DynamicType::Any)
+    }
+
+    pub const fn unknown() -> Self {
+        Self::Dynamic(DynamicType::Unknown)
+    }
+
     pub const fn is_dynamic(self) -> bool {
         match self {
-            ClassBase::Any | ClassBase::Unknown | ClassBase::Todo(_) => true,
+            ClassBase::Dynamic(_) => true,
             ClassBase::Class(_) => false,
         }
     }
@@ -34,9 +40,7 @@ impl<'db> ClassBase<'db> {
         impl std::fmt::Display for Display<'_> {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 match self.base {
-                    ClassBase::Any => f.write_str("Any"),
-                    ClassBase::Todo(todo) => todo.fmt(f),
-                    ClassBase::Unknown => f.write_str("Unknown"),
+                    ClassBase::Dynamic(dynamic) => dynamic.fmt(f),
                     ClassBase::Class(class) => write!(f, "<class '{}'>", class.name(self.db)),
                 }
             }
@@ -50,7 +54,7 @@ impl<'db> ClassBase<'db> {
         KnownClass::Object
             .to_class_literal(db)
             .into_class_literal()
-            .map_or(Self::Unknown, |ClassLiteralType { class }| {
+            .map_or(Self::unknown(), |ClassLiteralType { class }| {
                 Self::Class(class)
             })
     }
@@ -60,9 +64,7 @@ impl<'db> ClassBase<'db> {
     /// Return `None` if `ty` is not an acceptable type for a class base.
     pub(super) fn try_from_ty(db: &'db dyn Db, ty: Type<'db>) -> Option<Self> {
         match ty {
-            Type::Any => Some(Self::Any),
-            Type::Unknown => Some(Self::Unknown),
-            Type::Todo(todo) => Some(Self::Todo(todo)),
+            Type::Dynamic(dynamic) => Some(Self::Dynamic(dynamic)),
             Type::ClassLiteral(ClassLiteralType { class }) => Some(Self::Class(class)),
             Type::Union(_) => None, // TODO -- forces consideration of multiple possible MROs?
             Type::Intersection(_) => None, // TODO -- probably incorrect?
@@ -103,9 +105,11 @@ impl<'db> ClassBase<'db> {
                 | KnownInstanceType::Optional
                 | KnownInstanceType::Not
                 | KnownInstanceType::Intersection
-                | KnownInstanceType::TypeOf => None,
-                KnownInstanceType::Unknown => Some(Self::Unknown),
-                KnownInstanceType::Any => Some(Self::Any),
+                | KnownInstanceType::TypeOf
+                | KnownInstanceType::AlwaysTruthy
+                | KnownInstanceType::AlwaysFalsy => None,
+                KnownInstanceType::Unknown => Some(Self::unknown()),
+                KnownInstanceType::Any => Some(Self::any()),
                 // TODO: Classes inheriting from `typing.Type` et al. also have `Generic` in their MRO
                 KnownInstanceType::Dict => {
                     Self::try_from_ty(db, KnownClass::Dict.to_class_literal(db))
@@ -150,7 +154,7 @@ impl<'db> ClassBase<'db> {
     pub(super) fn into_class(self) -> Option<Class<'db>> {
         match self {
             Self::Class(class) => Some(class),
-            _ => None,
+            Self::Dynamic(_) => None,
         }
     }
 
@@ -160,13 +164,7 @@ impl<'db> ClassBase<'db> {
         db: &'db dyn Db,
     ) -> Either<impl Iterator<Item = ClassBase<'db>>, impl Iterator<Item = ClassBase<'db>>> {
         match self {
-            ClassBase::Any => Either::Left([ClassBase::Any, ClassBase::object(db)].into_iter()),
-            ClassBase::Unknown => {
-                Either::Left([ClassBase::Unknown, ClassBase::object(db)].into_iter())
-            }
-            ClassBase::Todo(todo) => {
-                Either::Left([ClassBase::Todo(todo), ClassBase::object(db)].into_iter())
-            }
+            ClassBase::Dynamic(_) => Either::Left([self, ClassBase::object(db)].into_iter()),
             ClassBase::Class(class) => Either::Right(class.iter_mro(db)),
         }
     }
@@ -181,9 +179,7 @@ impl<'db> From<Class<'db>> for ClassBase<'db> {
 impl<'db> From<ClassBase<'db>> for Type<'db> {
     fn from(value: ClassBase<'db>) -> Self {
         match value {
-            ClassBase::Any => Type::Any,
-            ClassBase::Todo(todo) => Type::Todo(todo),
-            ClassBase::Unknown => Type::Unknown,
+            ClassBase::Dynamic(dynamic) => Type::Dynamic(dynamic),
             ClassBase::Class(class) => Type::class_literal(class),
         }
     }

crates/red_knot_python_semantic/src/types/diagnostic.rs

@@ -49,6 +49,7 @@ pub(crate) fn register_lints(registry: &mut LintRegistryBuilder) {
     registry.register_lint(&POSSIBLY_UNBOUND_IMPORT);
     registry.register_lint(&POSSIBLY_UNRESOLVED_REFERENCE);
     registry.register_lint(&SUBCLASS_OF_FINAL_CLASS);
+    registry.register_lint(&TYPE_ASSERTION_FAILURE);
     registry.register_lint(&TOO_MANY_POSITIONAL_ARGUMENTS);
     registry.register_lint(&UNDEFINED_REVEAL);
     registry.register_lint(&UNKNOWN_ARGUMENT);
@@ -575,6 +576,28 @@ declare_lint! {
     }
 }
 
+declare_lint! {
+    /// ## What it does
+    /// Checks for `assert_type()` calls where the actual type
+    /// is not the same as the asserted type.
+    ///
+    /// ## Why is this bad?
+    /// `assert_type()` allows confirming the inferred type of a certain value.
+    ///
+    /// ## Example
+    ///
+    /// ```python
+    /// def _(x: int):
+    ///     assert_type(x, int)  # fine
+    ///     assert_type(x, str)  # error: Actual type does not match asserted type
+    /// ```
+    pub(crate) static TYPE_ASSERTION_FAILURE = {
+        summary: "detects failed type assertions",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
 declare_lint! {
     /// ## What it does
     /// Checks for calls that pass more positional arguments than the callable can accept.

crates/red_knot_python_semantic/src/types/display.rs

@@ -65,9 +65,8 @@ struct DisplayRepresentation<'db> {
 impl Display for DisplayRepresentation<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self.ty {
-            Type::Any => f.write_str("Any"),
+            Type::Dynamic(dynamic) => dynamic.fmt(f),
             Type::Never => f.write_str("Never"),
-            Type::Unknown => f.write_str("Unknown"),
             Type::Instance(InstanceType { class }) => {
                 let representation = match class.known(self.db) {
                     Some(KnownClass::NoneType) => "None",
@@ -76,9 +75,6 @@ impl Display for DisplayRepresentation<'_> {
                 };
                 f.write_str(representation)
             }
-            // `[Type::Todo]`'s display should be explicit that is not a valid display of
-            // any other type
-            Type::Todo(todo) => write!(f, "@Todo{todo}"),
             Type::ModuleLiteral(module) => {
                 write!(f, "<module '{}'>", module.module(self.db).name())
             }
@@ -88,9 +84,7 @@ impl Display for DisplayRepresentation<'_> {
                 // Only show the bare class name here; ClassBase::display would render this as
                 // type[<class 'Foo'>] instead of type[Foo].
                 ClassBase::Class(class) => write!(f, "type[{}]", class.name(self.db)),
-                base @ (ClassBase::Any | ClassBase::Todo(_) | ClassBase::Unknown) => {
-                    write!(f, "type[{}]", base.display(self.db))
-                }
+                ClassBase::Dynamic(dynamic) => write!(f, "type[{dynamic}]"),
             },
             Type::KnownInstance(known_instance) => f.write_str(known_instance.repr(self.db)),
             Type::FunctionLiteral(function) => f.write_str(function.name(self.db)),

crates/red_knot_python_semantic/src/types/infer.rs

@@ -62,11 +62,11 @@ use crate::types::mro::MroErrorKind;
 use crate::types::unpacker::{UnpackResult, Unpacker};
 use crate::types::{
     bindings_ty, builtins_symbol, declarations_ty, global_symbol, symbol, todo_type,
-    typing_extensions_symbol, Boundness, CallDunderResult, Class, ClassLiteralType, FunctionType,
-    InstanceType, IntersectionBuilder, IntersectionType, IterationOutcome, KnownClass,
-    KnownFunction, KnownInstanceType, MetaclassCandidate, MetaclassErrorKind, SliceLiteralType,
-    SubclassOfType, Symbol, Truthiness, TupleType, Type, TypeAliasType, TypeArrayDisplay,
-    TypeVarBoundOrConstraints, TypeVarInstance, UnionBuilder, UnionType,
+    typing_extensions_symbol, Boundness, CallDunderResult, Class, ClassLiteralType, DynamicType,
+    FunctionType, InstanceType, IntersectionBuilder, IntersectionType, IterationOutcome,
+    KnownClass, KnownFunction, KnownInstanceType, MetaclassCandidate, MetaclassErrorKind,
+    SliceLiteralType, SubclassOfType, Symbol, Truthiness, TupleType, Type, TypeAliasType,
+    TypeArrayDisplay, TypeVarBoundOrConstraints, TypeVarInstance, UnionBuilder, UnionType,
 };
 use crate::unpack::Unpack;
 use crate::util::subscript::{PyIndex, PySlice};
@@ -83,6 +83,7 @@ use super::slots::check_class_slots;
 use super::string_annotation::{
     parse_string_annotation, BYTE_STRING_TYPE_ANNOTATION, FSTRING_TYPE_ANNOTATION,
 };
+use super::{ParameterExpectation, ParameterExpectations};
 
 /// Infer all types for a [`ScopeId`], including all definitions and expressions in that scope.
 /// Use when checking a scope, or needing to provide a type for an arbitrary expression in the
@@ -101,7 +102,7 @@ pub(crate) fn infer_scope_types<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> Ty
     TypeInferenceBuilder::new(db, InferenceRegion::Scope(scope), index).finish()
 }
 
-/// Cycle recovery for [`infer_definition_types()`]: for now, just [`Type::Unknown`]
+/// Cycle recovery for [`infer_definition_types()`]: for now, just [`Type::unknown`]
 /// TODO fixpoint iteration
 fn infer_definition_types_cycle_recovery<'db>(
     db: &'db dyn Db,
@@ -112,10 +113,10 @@ fn infer_definition_types_cycle_recovery<'db>(
     let mut inference = TypeInference::empty(input.scope(db));
     let category = input.category(db);
     if category.is_declaration() {
-        inference.declarations.insert(input, Type::Unknown);
+        inference.declarations.insert(input, Type::unknown());
     }
     if category.is_binding() {
-        inference.bindings.insert(input, Type::Unknown);
+        inference.bindings.insert(input, Type::unknown());
     }
     // TODO we don't fill in expression types for the cycle-participant definitions, which can
     // later cause a panic when looking up an expression type.
@@ -310,6 +311,18 @@ enum IntersectionOn {
     Right,
 }
 
+/// A helper to track if we already know that declared and inferred types are the same.
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum DeclaredAndInferredType<'db> {
+    /// We know that both the declared and inferred types are the same.
+    AreTheSame(Type<'db>),
+    /// Declared and inferred types might be different, we need to check assignability.
+    MightBeDifferent {
+        declared_ty: Type<'db>,
+        inferred_ty: Type<'db>,
+    },
+}
+
 /// Builder to infer all types in a region.
 ///
 /// A builder is used by creating it with [`new()`](TypeInferenceBuilder::new), and then calling
@@ -842,7 +855,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         let declarations = use_def.declarations_at_binding(binding);
         let mut bound_ty = ty;
         let declared_ty = declarations_ty(self.db(), declarations)
-            .map(|s| s.ignore_possibly_unbound().unwrap_or(Type::Unknown))
+            .map(|s| s.ignore_possibly_unbound().unwrap_or(Type::unknown()))
             .unwrap_or_else(|(ty, conflicting)| {
                 // TODO point out the conflicting declarations in the diagnostic?
                 let symbol_table = self.index.symbol_table(binding.file_scope(self.db()));
@@ -886,7 +899,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     inferred_ty.display(self.db())
                 ),
             );
-            Type::Unknown
+            Type::unknown()
         };
         self.types.declarations.insert(declaration, ty);
     }
@@ -895,20 +908,28 @@ impl<'db> TypeInferenceBuilder<'db> {
         &mut self,
         node: AnyNodeRef,
         definition: Definition<'db>,
-        declared_ty: Type<'db>,
-        inferred_ty: Type<'db>,
+        declared_and_inferred_ty: &DeclaredAndInferredType<'db>,
     ) {
         debug_assert!(definition.is_binding(self.db()));
         debug_assert!(definition.is_declaration(self.db()));
-        let inferred_ty = if inferred_ty.is_assignable_to(self.db(), declared_ty) {
-            inferred_ty
-        } else {
-            report_invalid_assignment(&self.context, node, declared_ty, inferred_ty);
-            // if the assignment is invalid, fall back to assuming the annotation is correct
-            declared_ty
+
+        let (declared_ty, inferred_ty) = match declared_and_inferred_ty {
+            DeclaredAndInferredType::AreTheSame(ty) => (ty, ty),
+            DeclaredAndInferredType::MightBeDifferent {
+                declared_ty,
+                inferred_ty,
+            } => {
+                if inferred_ty.is_assignable_to(self.db(), *declared_ty) {
+                    (declared_ty, inferred_ty)
+                } else {
+                    report_invalid_assignment(&self.context, node, *declared_ty, *inferred_ty);
+                    // if the assignment is invalid, fall back to assuming the annotation is correct
+                    (declared_ty, declared_ty)
+                }
+            }
         };
-        self.types.declarations.insert(definition, declared_ty);
-        self.types.bindings.insert(definition, inferred_ty);
+        self.types.declarations.insert(definition, *declared_ty);
+        self.types.bindings.insert(definition, *inferred_ty);
     }
 
     fn add_unknown_declaration_with_binding(
@@ -916,7 +937,11 @@ impl<'db> TypeInferenceBuilder<'db> {
         node: AnyNodeRef,
         definition: Definition<'db>,
     ) {
-        self.add_declaration_with_binding(node, definition, Type::Unknown, Type::Unknown);
+        self.add_declaration_with_binding(
+            node,
+            definition,
+            &DeclaredAndInferredType::AreTheSame(Type::unknown()),
+        );
     }
 
     fn infer_module(&mut self, module: &ast::ModModule) {
@@ -932,7 +957,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.infer_type_parameters(type_params);
 
         if let Some(arguments) = class.arguments.as_deref() {
-            self.infer_arguments(arguments, false);
+            self.infer_arguments(arguments, ParameterExpectations::default());
         }
     }
 
@@ -1097,7 +1122,11 @@ impl<'db> TypeInferenceBuilder<'db> {
             decorator_tys.into_boxed_slice(),
         ));
 
-        self.add_declaration_with_binding(function.into(), definition, function_ty, function_ty);
+        self.add_declaration_with_binding(
+            function.into(),
+            definition,
+            &DeclaredAndInferredType::AreTheSame(function_ty),
+        );
     }
 
     fn infer_parameters(&mut self, parameters: &ast::Parameters) {
@@ -1188,15 +1217,18 @@ impl<'db> TypeInferenceBuilder<'db> {
             .map(|default| self.file_expression_ty(default));
         if let Some(annotation) = parameter.annotation.as_ref() {
             let declared_ty = self.file_expression_ty(annotation);
-            let inferred_ty = if let Some(default_ty) = default_ty {
+            let declared_and_inferred_ty = if let Some(default_ty) = default_ty {
                 if default_ty.is_assignable_to(self.db(), declared_ty) {
-                    UnionType::from_elements(self.db(), [declared_ty, default_ty])
+                    DeclaredAndInferredType::MightBeDifferent {
+                        declared_ty,
+                        inferred_ty: UnionType::from_elements(self.db(), [declared_ty, default_ty]),
+                    }
                 } else if self.in_stub()
                     && default
                         .as_ref()
                         .is_some_and(|d| d.is_ellipsis_literal_expr())
                 {
-                    declared_ty
+                    DeclaredAndInferredType::AreTheSame(declared_ty)
                 } else {
                     self.context.report_lint(
                         &INVALID_PARAMETER_DEFAULT,
@@ -1205,22 +1237,21 @@ impl<'db> TypeInferenceBuilder<'db> {
                             "Default value of type `{}` is not assignable to annotated parameter type `{}`",
                             default_ty.display(self.db()), declared_ty.display(self.db())),
                     );
-                    declared_ty
+                    DeclaredAndInferredType::AreTheSame(declared_ty)
                 }
             } else {
-                declared_ty
+                DeclaredAndInferredType::AreTheSame(declared_ty)
             };
             self.add_declaration_with_binding(
                 parameter.into(),
                 definition,
-                declared_ty,
-                inferred_ty,
+                &declared_and_inferred_ty,
             );
         } else {
             let ty = if let Some(default_ty) = default_ty {
-                UnionType::from_elements(self.db(), [Type::Unknown, default_ty])
+                UnionType::from_elements(self.db(), [Type::unknown(), default_ty])
             } else {
-                Type::Unknown
+                Type::unknown()
             };
             self.add_binding(parameter.into(), definition, ty);
         }
@@ -1240,7 +1271,11 @@ impl<'db> TypeInferenceBuilder<'db> {
             let _annotated_ty = self.file_expression_ty(annotation);
             // TODO `tuple[annotated_ty, ...]`
             let ty = KnownClass::Tuple.to_instance(self.db());
-            self.add_declaration_with_binding(parameter.into(), definition, ty, ty);
+            self.add_declaration_with_binding(
+                parameter.into(),
+                definition,
+                &DeclaredAndInferredType::AreTheSame(ty),
+            );
         } else {
             self.add_binding(
                 parameter.into(),
@@ -1265,7 +1300,11 @@ impl<'db> TypeInferenceBuilder<'db> {
             let _annotated_ty = self.file_expression_ty(annotation);
             // TODO `dict[str, annotated_ty]`
             let ty = KnownClass::Dict.to_instance(self.db());
-            self.add_declaration_with_binding(parameter.into(), definition, ty, ty);
+            self.add_declaration_with_binding(
+                parameter.into(),
+                definition,
+                &DeclaredAndInferredType::AreTheSame(ty),
+            );
         } else {
             self.add_binding(
                 parameter.into(),
@@ -1308,7 +1347,11 @@ impl<'db> TypeInferenceBuilder<'db> {
         let class = Class::new(self.db(), &name.id, body_scope, maybe_known_class);
         let class_ty = Type::class_literal(class);
 
-        self.add_declaration_with_binding(class_node.into(), definition, class_ty, class_ty);
+        self.add_declaration_with_binding(
+            class_node.into(),
+            definition,
+            &DeclaredAndInferredType::AreTheSame(class_ty),
+        );
 
         // if there are type parameters, then the keywords and bases are within that scope
         // and we don't need to run inference here
@@ -1365,8 +1408,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.add_declaration_with_binding(
             type_alias.into(),
             definition,
-            type_alias_ty,
-            type_alias_ty,
+            &DeclaredAndInferredType::AreTheSame(type_alias_ty),
         );
     }
 
@@ -1487,7 +1529,7 @@ impl<'db> TypeInferenceBuilder<'db> {
 
     /// Infers the type of a context expression (`with expr`) and returns the target's type
     ///
-    /// Returns [`Type::Unknown`] if the context expression doesn't implement the context manager protocol.
+    /// Returns [`Type::unknown`] if the context expression doesn't implement the context manager protocol.
     ///
     /// ## Terminology
     /// See [PEP343](https://peps.python.org/pep-0343/#standard-terminology).
@@ -1518,7 +1560,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         context_expression_ty.display(self.db())
                     ),
                 );
-                Type::Unknown
+                Type::unknown()
             }
             (Symbol::Unbound, _) => {
                 self.context.report_lint(
@@ -1529,7 +1571,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         context_expression_ty.display(self.db())
                     ),
                 );
-                Type::Unknown
+                Type::unknown()
             }
             (Symbol::Type(enter_ty, enter_boundness), exit) => {
                 if enter_boundness == Boundness::PossiblyUnbound {
@@ -1622,7 +1664,7 @@ impl<'db> TypeInferenceBuilder<'db> {
 
         // If there is no handled exception, it's invalid syntax;
         // a diagnostic will have already been emitted
-        let node_ty = node.map_or(Type::Unknown, |ty| self.infer_expression(ty));
+        let node_ty = node.map_or(Type::unknown(), |ty| self.infer_expression(ty));
 
         // If it's an `except*` handler, this won't actually be the type of the bound symbol;
         // it will actually be the type of the generic parameters to `BaseExceptionGroup` or `ExceptionGroup`.
@@ -1637,7 +1679,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         if let Some(node) = node {
                             report_invalid_exception_caught(&self.context, node, element);
                         }
-                        Type::Unknown
+                        Type::unknown()
                     },
                 );
             }
@@ -1652,7 +1694,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                 if let Some(node) = node {
                     report_invalid_exception_caught(&self.context, node, node_ty);
                 }
-                Type::Unknown
+                Type::unknown()
             }
         };
 
@@ -1718,7 +1760,11 @@ impl<'db> TypeInferenceBuilder<'db> {
             bound_or_constraint,
             default_ty,
         )));
-        self.add_declaration_with_binding(node.into(), definition, ty, ty);
+        self.add_declaration_with_binding(
+            node.into(),
+            definition,
+            &DeclaredAndInferredType::AreTheSame(ty),
+        );
     }
 
     fn infer_paramspec_definition(
@@ -1733,7 +1779,11 @@ impl<'db> TypeInferenceBuilder<'db> {
         } = node;
         self.infer_optional_expression(default.as_deref());
         let pep_695_todo = todo_type!("PEP-695 ParamSpec definition types");
-        self.add_declaration_with_binding(node.into(), definition, pep_695_todo, pep_695_todo);
+        self.add_declaration_with_binding(
+            node.into(),
+            definition,
+            &DeclaredAndInferredType::AreTheSame(pep_695_todo),
+        );
     }
 
     fn infer_typevartuple_definition(
@@ -1748,7 +1798,11 @@ impl<'db> TypeInferenceBuilder<'db> {
         } = node;
         self.infer_optional_expression(default.as_deref());
         let pep_695_todo = todo_type!("PEP-695 TypeVarTuple definition types");
-        self.add_declaration_with_binding(node.into(), definition, pep_695_todo, pep_695_todo);
+        self.add_declaration_with_binding(
+            node.into(),
+            definition,
+            &DeclaredAndInferredType::AreTheSame(pep_695_todo),
+        );
     }
 
     fn infer_match_statement(&mut self, match_statement: &ast::StmtMatch) {
@@ -1953,11 +2007,11 @@ impl<'db> TypeInferenceBuilder<'db> {
                 }
 
                 let name_ast_id = name.scoped_expression_id(self.db(), self.scope());
-                unpacked.get(name_ast_id).unwrap_or(Type::Unknown)
+                unpacked.get(name_ast_id).unwrap_or(Type::unknown())
             }
             TargetKind::Name => {
                 if self.in_stub() && value.is_ellipsis_literal_expr() {
-                    Type::Unknown
+                    Type::unknown()
                 } else {
                     value_ty
                 }
@@ -2006,13 +2060,13 @@ impl<'db> TypeInferenceBuilder<'db> {
             simple: _,
         } = assignment;
 
-        let mut annotation_ty = self.infer_annotation_expression(
+        let mut declared_ty = self.infer_annotation_expression(
             annotation,
             DeferredExpressionState::from(self.are_all_types_deferred()),
         );
 
         // Handle various singletons.
-        if let Type::Instance(InstanceType { class }) = annotation_ty {
+        if let Type::Instance(InstanceType { class }) = declared_ty {
             if class.is_known(self.db(), KnownClass::SpecialForm) {
                 if let Some(name_expr) = target.as_name_expr() {
                     if let Some(known_instance) = KnownInstanceType::try_from_file_and_name(
@@ -2020,27 +2074,29 @@ impl<'db> TypeInferenceBuilder<'db> {
                         self.file(),
                         &name_expr.id,
                     ) {
-                        annotation_ty = Type::KnownInstance(known_instance);
+                        declared_ty = Type::KnownInstance(known_instance);
                     }
                 }
             }
         }
 
         if let Some(value) = value.as_deref() {
-            let value_ty = self.infer_expression(value);
-            let value_ty = if self.in_stub() && value.is_ellipsis_literal_expr() {
-                annotation_ty
+            let inferred_ty = self.infer_expression(value);
+            let inferred_ty = if self.in_stub() && value.is_ellipsis_literal_expr() {
+                declared_ty
             } else {
-                value_ty
+                inferred_ty
             };
             self.add_declaration_with_binding(
                 assignment.into(),
                 definition,
-                annotation_ty,
-                value_ty,
+                &DeclaredAndInferredType::MightBeDifferent {
+                    declared_ty,
+                    inferred_ty,
+                },
             );
         } else {
-            self.add_declaration(assignment.into(), definition, annotation_ty);
+            self.add_declaration(assignment.into(), definition, declared_ty);
         }
 
         self.infer_expression(target);
@@ -2113,7 +2169,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                                             right_ty.display(self.db())
                                         ),
                                     );
-                                    Type::Unknown
+                                    Type::unknown()
                                 });
 
                             UnionType::from_elements(
@@ -2142,7 +2198,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         right_ty.display(self.db())
                     ),
                 );
-                Type::Unknown
+                Type::unknown()
             })
     }
 
@@ -2219,7 +2275,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         self.context.extend(unpacked);
                     }
                     let name_ast_id = name.scoped_expression_id(self.db(), self.scope());
-                    unpacked.get(name_ast_id).unwrap_or(Type::Unknown)
+                    unpacked.get(name_ast_id).unwrap_or(Type::unknown())
                 }
                 TargetKind::Name => iterable_ty
                     .iterate(self.db())
@@ -2294,7 +2350,11 @@ impl<'db> TypeInferenceBuilder<'db> {
             full_module_ty
         };
 
-        self.add_declaration_with_binding(alias.into(), definition, binding_ty, binding_ty);
+        self.add_declaration_with_binding(
+            alias.into(),
+            definition,
+            &DeclaredAndInferredType::AreTheSame(binding_ty),
+        );
     }
 
     fn infer_import_from_statement(&mut self, import: &ast::StmtImportFrom) {
@@ -2470,7 +2530,11 @@ impl<'db> TypeInferenceBuilder<'db> {
                     format_args!("Member `{name}` of module `{module_name}` is possibly unbound",),
                 );
             }
-            self.add_declaration_with_binding(alias.into(), definition, ty, ty);
+            self.add_declaration_with_binding(
+                alias.into(),
+                definition,
+                &DeclaredAndInferredType::AreTheSame(ty),
+            );
             return;
         };
 
@@ -2496,8 +2560,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                 self.add_declaration_with_binding(
                     alias.into(),
                     definition,
-                    submodule_ty,
-                    submodule_ty,
+                    &DeclaredAndInferredType::AreTheSame(submodule_ty),
                 );
                 return;
             }
@@ -2539,17 +2602,17 @@ impl<'db> TypeInferenceBuilder<'db> {
     fn infer_arguments<'a>(
         &mut self,
         arguments: &'a ast::Arguments,
-        infer_as_type_expressions: bool,
+        parameter_expectations: ParameterExpectations,
     ) -> CallArguments<'a, 'db> {
-        let infer_argument_type = if infer_as_type_expressions {
-            Self::infer_type_expression
-        } else {
-            Self::infer_expression
-        };
-
         arguments
             .arguments_source_order()
-            .map(|arg_or_keyword| {
+            .enumerate()
+            .map(|(index, arg_or_keyword)| {
+                let infer_argument_type = match parameter_expectations.expectation_at_index(index) {
+                    ParameterExpectation::TypeExpression => Self::infer_type_expression,
+                    ParameterExpectation::ValueExpression => Self::infer_expression,
+                };
+
                 match arg_or_keyword {
                     ast::ArgOrKeyword::Arg(arg) => match arg {
                         ast::Expr::Starred(ast::ExprStarred {
@@ -2672,7 +2735,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             ast::Number::Float(_) => KnownClass::Float.to_instance(self.db()),
             ast::Number::Complex { .. } => builtins_symbol(self.db(), "complex")
                 .ignore_possibly_unbound()
-                .unwrap_or(Type::Unknown)
+                .unwrap_or(Type::unknown())
                 .to_instance(self.db()),
         }
     }
@@ -2759,7 +2822,7 @@ impl<'db> TypeInferenceBuilder<'db> {
     ) -> Type<'db> {
         builtins_symbol(self.db(), "Ellipsis")
             .ignore_possibly_unbound()
-            .unwrap_or(Type::Unknown)
+            .unwrap_or(Type::unknown())
     }
 
     fn infer_tuple_expression(&mut self, tuple: &ast::ExprTuple) -> Type<'db> {
@@ -3016,7 +3079,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             // For syntactically invalid targets, we still need to run type inference:
             self.infer_expression(&named.target);
             self.infer_expression(&named.value);
-            Type::Unknown
+            Type::unknown()
         }
     }
 
@@ -3092,12 +3155,13 @@ impl<'db> TypeInferenceBuilder<'db> {
 
         let function_type = self.infer_expression(func);
 
-        let infer_arguments_as_type_expressions = function_type
+        let parameter_expectations = function_type
             .into_function_literal()
             .and_then(|f| f.known(self.db()))
-            .is_some_and(KnownFunction::takes_type_expression_arguments);
+            .map(KnownFunction::parameter_expectations)
+            .unwrap_or_default();
 
-        let call_arguments = self.infer_arguments(arguments, infer_arguments_as_type_expressions);
+        let call_arguments = self.infer_arguments(arguments, parameter_expectations);
         function_type
             .call(self.db(), &call_arguments)
             .unwrap_with_diagnostic(&self.context, call_expression.into())
@@ -3267,7 +3331,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     }
                     Symbol::Unbound => {
                         report_unresolved_reference(&self.context, name);
-                        Type::Unknown
+                        Type::unknown()
                     }
                     Symbol::Type(_, Boundness::Bound) => unreachable!("Handled above"),
                 },
@@ -3279,7 +3343,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         match name.ctx {
             ExprContext::Load => self.infer_name_load(name),
             ExprContext::Store | ExprContext::Del => Type::Never,
-            ExprContext::Invalid => Type::Unknown,
+            ExprContext::Invalid => Type::unknown(),
         }
     }
 
@@ -3319,7 +3383,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         attr.id
                     ),
                 );
-                Type::Unknown
+                Type::unknown()
             }
         }
     }
@@ -3340,7 +3404,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             }
             ExprContext::Invalid => {
                 self.infer_expression(value);
-                Type::Unknown
+                Type::unknown()
             }
         }
     }
@@ -3355,10 +3419,8 @@ impl<'db> TypeInferenceBuilder<'db> {
         let operand_type = self.infer_expression(operand);
 
         match (op, operand_type) {
-            (_, Type::Any) => Type::Any,
-            (_, Type::Todo(_)) => operand_type,
+            (_, Type::Dynamic(_)) => operand_type,
             (_, Type::Never) => Type::Never,
-            (_, Type::Unknown) => Type::Unknown,
 
             (ast::UnaryOp::UAdd, Type::IntLiteral(value)) => Type::IntLiteral(value),
             (ast::UnaryOp::USub, Type::IntLiteral(value)) => Type::IntLiteral(-value),
@@ -3428,7 +3490,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         ),
                     );
 
-                    Type::Unknown
+                    Type::unknown()
                 }
             }
         }
@@ -3468,7 +3530,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         right_ty.display(self.db())
                     ),
                 );
-                Type::Unknown
+                Type::unknown()
             })
     }
 
@@ -3479,12 +3541,15 @@ impl<'db> TypeInferenceBuilder<'db> {
         op: ast::Operator,
     ) -> Option<Type<'db>> {
         match (left_ty, right_ty, op) {
-            // When interacting with Todo, Any and Unknown should propagate (as if we fix this
-            // `Todo` in the future, the result would then become Any or Unknown, respectively.)
-            (Type::Any, _, _) | (_, Type::Any, _) => Some(Type::Any),
-            (todo @ Type::Todo(_), _, _) | (_, todo @ Type::Todo(_), _) => Some(todo),
+            // Non-todo Anys take precedence over Todos (as if we fix this `Todo` in the future,
+            // the result would then become Any or Unknown, respectively).
+            (any @ Type::Dynamic(DynamicType::Any), _, _)
+            | (_, any @ Type::Dynamic(DynamicType::Any), _) => Some(any),
+            (unknown @ Type::Dynamic(DynamicType::Unknown), _, _)
+            | (_, unknown @ Type::Dynamic(DynamicType::Unknown), _) => Some(unknown),
+            (todo @ Type::Dynamic(DynamicType::Todo(_)), _, _)
+            | (_, todo @ Type::Dynamic(DynamicType::Todo(_)), _) => Some(todo),
             (Type::Never, _, _) | (_, Type::Never, _) => Some(Type::Never),
-            (Type::Unknown, _, _) | (_, Type::Unknown, _) => Some(Type::Unknown),
 
             (Type::IntLiteral(n), Type::IntLiteral(m), ast::Operator::Add) => Some(
                 n.checked_add(m)
@@ -3827,7 +3892,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                                 | ast::CmpOp::Is
                                 | ast::CmpOp::IsNot => KnownClass::Bool.to_instance(self.db()),
                                 // Other operators can return arbitrary types
-                                _ => Type::Unknown,
+                                _ => Type::unknown(),
                             }
                         })
                 }),
@@ -4151,7 +4216,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                             ).expect("infer_binary_type_comparison should never return None for `CmpOp::Eq`");
 
                             match eq_result {
-                                todo @ Type::Todo(_) => return Ok(todo),
+                                todo @ Type::Dynamic(DynamicType::Todo(_)) => return Ok(todo),
                                 ty => match ty.bool(self.db()) {
                                     Truthiness::AlwaysTrue => eq_count += 1,
                                     Truthiness::AlwaysFalse => not_eq_count += 1,
@@ -4176,7 +4241,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         );
 
                         Ok(match eq_result {
-                            todo @ Type::Todo(_) => todo,
+                            todo @ Type::Dynamic(DynamicType::Todo(_)) => todo,
                             ty => match ty.bool(self.db()) {
                                 Truthiness::AlwaysFalse => Type::BooleanLiteral(op.is_is_not()),
                                 _ => KnownClass::Bool.to_instance(self.db()),
@@ -4258,7 +4323,7 @@ impl<'db> TypeInferenceBuilder<'db> {
 
             match pairwise_eq_result {
                 // If propagation is required, return the result as is
-                todo @ Type::Todo(_) => return Ok(todo),
+                todo @ Type::Dynamic(DynamicType::Todo(_)) => return Ok(todo),
                 ty => match ty.bool(self.db()) {
                     // - AlwaysTrue : Continue to the next pair for lexicographic comparison
                     Truthiness::AlwaysTrue => continue,
@@ -4357,7 +4422,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                             elements.len(),
                             int,
                         );
-                        Type::Unknown
+                        Type::unknown()
                     })
             }
             // Ex) Given `("a", 1, Null)[0:2]`, return `("a", 1)`
@@ -4369,7 +4434,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     TupleType::from_elements(self.db(), new_elements)
                 } else {
                     report_slice_step_size_zero(&self.context, value_node.into());
-                    Type::Unknown
+                    Type::unknown()
                 }
             }
             // Ex) Given `"value"[1]`, return `"a"`
@@ -4390,7 +4455,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                             literal_value.chars().count(),
                             int,
                         );
-                        Type::Unknown
+                        Type::unknown()
                     })
             }
             // Ex) Given `"value"[1:3]`, return `"al"`
@@ -4404,7 +4469,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     Type::string_literal(self.db(), &literal)
                 } else {
                     report_slice_step_size_zero(&self.context, value_node.into());
-                    Type::Unknown
+                    Type::unknown()
                 };
                 result
             }
@@ -4426,7 +4491,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                             literal_value.len(),
                             int,
                         );
-                        Type::Unknown
+                        Type::unknown()
                     })
             }
             // Ex) Given `b"value"[1:3]`, return `b"al"`
@@ -4439,7 +4504,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     Type::bytes_literal(self.db(), &new_bytes)
                 } else {
                     report_slice_step_size_zero(&self.context, value_node.into());
-                    Type::Unknown
+                    Type::unknown()
                 }
             }
             // Ex) Given `"value"[True]`, return `"a"`
@@ -4474,7 +4539,7 @@ impl<'db> TypeInferenceBuilder<'db> {
 
                         return dunder_getitem_method
                             .call(self.db(), &CallArguments::positional([value_ty, slice_ty]))
-                            .return_ty_result( &self.context, value_node.into())
+                            .return_ty_result(&self.context, value_node.into())
                             .unwrap_or_else(|err| {
                                 self.context.report_lint(
                                     &CALL_NON_CALLABLE,
@@ -4555,7 +4620,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     );
                 }
 
-                Type::Unknown
+                Type::unknown()
             }
         }
     }
@@ -4670,7 +4735,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     bytes.into(),
                     format_args!("Type expressions cannot use bytes literal"),
                 );
-                Type::Unknown
+                Type::unknown()
             }
 
             ast::Expr::FString(fstring) => {
@@ -4680,7 +4745,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     format_args!("Type expressions cannot use f-strings"),
                 );
                 self.infer_fstring_expression(fstring);
-                Type::Unknown
+                Type::unknown()
             }
 
             // All other annotation expressions are (possibly) valid type expressions, so handle
@@ -4703,7 +4768,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     DeferredExpressionState::InStringAnnotation,
                 )
             }
-            None => Type::Unknown,
+            None => Type::unknown(),
         }
     }
 }
@@ -4751,7 +4816,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     .infer_name_expression(name)
                     .in_type_expression(self.db())
                     .unwrap_or_else(|error| error.into_fallback_type(&self.context, expression)),
-                ast::ExprContext::Invalid => Type::Unknown,
+                ast::ExprContext::Invalid => Type::unknown(),
                 ast::ExprContext::Store | ast::ExprContext::Del => todo_type!(),
             },
 
@@ -4760,7 +4825,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     .infer_attribute_expression(attribute_expression)
                     .in_type_expression(self.db())
                     .unwrap_or_else(|error| error.into_fallback_type(&self.context, expression)),
-                ast::ExprContext::Invalid => Type::Unknown,
+                ast::ExprContext::Invalid => Type::unknown(),
                 ast::ExprContext::Store | ast::ExprContext::Del => todo_type!(),
             },
 
@@ -4813,7 +4878,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     // anything else is an invalid annotation:
                     _ => {
                         self.infer_binary_expression(binary);
-                        Type::Unknown
+                        Type::unknown()
                     }
                 }
             }
@@ -4826,90 +4891,90 @@ impl<'db> TypeInferenceBuilder<'db> {
 
             // Avoid inferring the types of invalid type expressions that have been parsed from a
             // string annotation, as they are not present in the semantic index.
-            _ if self.deferred_state.in_string_annotation() => Type::Unknown,
+            _ if self.deferred_state.in_string_annotation() => Type::unknown(),
 
             // Forms which are invalid in the context of annotation expressions: we infer their
             // nested expressions as normal expressions, but the type of the top-level expression is
-            // always `Type::Unknown` in these cases.
+            // always `Type::unknown` in these cases.
             ast::Expr::BoolOp(bool_op) => {
                 self.infer_boolean_expression(bool_op);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Named(named) => {
                 self.infer_named_expression(named);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::UnaryOp(unary) => {
                 self.infer_unary_expression(unary);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Lambda(lambda_expression) => {
                 self.infer_lambda_expression(lambda_expression);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::If(if_expression) => {
                 self.infer_if_expression(if_expression);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Dict(dict) => {
                 self.infer_dict_expression(dict);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Set(set) => {
                 self.infer_set_expression(set);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::ListComp(listcomp) => {
                 self.infer_list_comprehension_expression(listcomp);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::SetComp(setcomp) => {
                 self.infer_set_comprehension_expression(setcomp);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::DictComp(dictcomp) => {
                 self.infer_dict_comprehension_expression(dictcomp);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Generator(generator) => {
                 self.infer_generator_expression(generator);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Await(await_expression) => {
                 self.infer_await_expression(await_expression);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Yield(yield_expression) => {
                 self.infer_yield_expression(yield_expression);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::YieldFrom(yield_from) => {
                 self.infer_yield_from_expression(yield_from);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Compare(compare) => {
                 self.infer_compare_expression(compare);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Call(call_expr) => {
                 self.infer_call_expression(call_expr);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::FString(fstring) => {
                 self.infer_fstring_expression(fstring);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::List(list) => {
                 self.infer_list_expression(list);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Tuple(tuple) => {
                 self.infer_tuple_expression(tuple);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Slice(slice) => {
                 self.infer_slice_expression(slice);
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::IpyEscapeCommand(_) => todo!("Implement Ipy escape command support"),
         }
@@ -4925,7 +4990,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     DeferredExpressionState::InStringAnnotation,
                 )
             }
-            None => Type::Unknown,
+            None => Type::unknown(),
         }
     }
 
@@ -5001,6 +5066,9 @@ impl<'db> TypeInferenceBuilder<'db> {
                     Type::KnownInstance(KnownInstanceType::Any) => {
                         SubclassOfType::subclass_of_any()
                     }
+                    Type::KnownInstance(KnownInstanceType::Unknown) => {
+                        SubclassOfType::subclass_of_unknown()
+                    }
                     _ => todo_type!("unsupported type[X] special form"),
                 }
             }
@@ -5023,7 +5091,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     slice.into(),
                     format_args!("type[...] must have exactly one type argument"),
                 );
-                Type::Unknown
+                Type::unknown()
             }
             ast::Expr::Subscript(ast::ExprSubscript {
                 value,
@@ -5076,7 +5144,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             Type::KnownInstance(known_instance) => {
                 self.infer_parameterized_known_instance_type_expression(subscript, known_instance)
             }
-            Type::Todo(_) => {
+            Type::Dynamic(DynamicType::Todo(_)) => {
                 self.infer_type_expression(slice);
                 value_ty
             }
@@ -5125,7 +5193,7 @@ impl<'db> TypeInferenceBuilder<'db> {
 
                 let [type_expr, metadata @ ..] = &arguments[..] else {
                     self.infer_type_expression(arguments_slice);
-                    return Type::Unknown;
+                    return Type::unknown();
                 };
 
                 for element in metadata {
@@ -5150,7 +5218,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                                 ),
                             );
                         }
-                        Type::Unknown
+                        Type::unknown()
                     }
                 }
             }
@@ -5193,7 +5261,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                             known_instance.repr(self.db())
                         ),
                     );
-                    Type::Unknown
+                    Type::unknown()
                 }
                 _ => {
                     let argument_type = self.infer_type_expression(arguments_slice);
@@ -5222,7 +5290,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                             known_instance.repr(self.db())
                         ),
                     );
-                    Type::Unknown
+                    Type::unknown()
                 }
                 _ => {
                     // NB: This calls `infer_expression` instead of `infer_type_expression`.
@@ -5278,8 +5346,8 @@ impl<'db> TypeInferenceBuilder<'db> {
                 todo_type!("`NotRequired[]` type qualifier")
             }
             KnownInstanceType::ClassVar => {
-                self.infer_type_expression(arguments_slice);
-                todo_type!("`ClassVar[]` type qualifier")
+                let ty = self.infer_type_expression(arguments_slice);
+                ty
             }
             KnownInstanceType::Final => {
                 self.infer_type_expression(arguments_slice);
@@ -5305,7 +5373,11 @@ impl<'db> TypeInferenceBuilder<'db> {
                 self.infer_type_expression(arguments_slice);
                 todo_type!("`Unpack[]` special form")
             }
-            KnownInstanceType::NoReturn | KnownInstanceType::Never | KnownInstanceType::Any => {
+            KnownInstanceType::NoReturn
+            | KnownInstanceType::Never
+            | KnownInstanceType::Any
+            | KnownInstanceType::AlwaysTruthy
+            | KnownInstanceType::AlwaysFalsy => {
                 self.context.report_lint(
                     &INVALID_TYPE_FORM,
                     subscript.into(),
@@ -5314,7 +5386,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         known_instance.repr(self.db())
                     ),
                 );
-                Type::Unknown
+                Type::unknown()
             }
             KnownInstanceType::TypingSelf
             | KnownInstanceType::TypeAlias
@@ -5327,7 +5399,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         known_instance.repr(self.db())
                     ),
                 );
-                Type::Unknown
+                Type::unknown()
             }
             KnownInstanceType::LiteralString => {
                 self.context.report_lint(
@@ -5338,7 +5410,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         known_instance.repr(self.db())
                     ),
                 );
-                Type::Unknown
+                Type::unknown()
             }
             KnownInstanceType::Type => self.infer_subclass_of_type_expression(arguments_slice),
             KnownInstanceType::Tuple => self.infer_tuple_type_expression(arguments_slice),
@@ -5361,7 +5433,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     self.store_expression_type(parameters, ty);
                     ty
                 } else {
-                    self.store_expression_type(parameters, Type::Unknown);
+                    self.store_expression_type(parameters, Type::unknown());
 
                     return Err(vec![parameters]);
                 }
@@ -5388,7 +5460,7 @@ impl<'db> TypeInferenceBuilder<'db> {
 
                     union_type
                 } else {
-                    self.store_expression_type(parameters, Type::Unknown);
+                    self.store_expression_type(parameters, Type::unknown());
 
                     return Err(errors);
                 }
@@ -5408,7 +5480,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                 value_ty
                     .member(self.db(), &attr.id)
                     .ignore_possibly_unbound()
-                    .unwrap_or(Type::Unknown)
+                    .unwrap_or(Type::unknown())
             }
             // for negative and positive numbers
             ast::Expr::UnaryOp(ref u)
@@ -5715,7 +5787,7 @@ fn perform_membership_test_comparison<'db>(
 
     compare_result_opt
         .map(|ty| {
-            if matches!(ty, Type::Todo(_)) {
+            if matches!(ty, Type::Dynamic(DynamicType::Todo(_))) {
                 return ty;
             }
 

crates/red_knot_python_semantic/src/types/mro.rs

@@ -34,7 +34,7 @@ impl<'db> Mro<'db> {
     pub(super) fn from_error(db: &'db dyn Db, class: Class<'db>) -> Self {
         Self::from([
             ClassBase::Class(class),
-            ClassBase::Unknown,
+            ClassBase::unknown(),
             ClassBase::object(db),
         ])
     }

crates/red_knot_python_semantic/src/types/property_tests.rs

@@ -28,7 +28,7 @@ use std::sync::{Arc, Mutex, MutexGuard, OnceLock};
 
 use super::tests::Ty;
 use crate::db::tests::{setup_db, TestDb};
-use crate::types::KnownClass;
+use crate::types::{IntersectionBuilder, KnownClass, Type, UnionType};
 use quickcheck::{Arbitrary, Gen};
 
 fn arbitrary_core_type(g: &mut Gen) -> Ty {
@@ -219,16 +219,41 @@ macro_rules! type_property_test {
     };
 }
 
+fn intersection<'db>(db: &'db TestDb, s: Type<'db>, t: Type<'db>) -> Type<'db> {
+    IntersectionBuilder::new(db)
+        .add_positive(s)
+        .add_positive(t)
+        .build()
+}
+
+fn union<'db>(db: &'db TestDb, s: Type<'db>, t: Type<'db>) -> Type<'db> {
+    UnionType::from_elements(db, [s, t])
+}
+
 mod stable {
+    use super::union;
     use crate::types::{KnownClass, Type};
 
-    // `T` is equivalent to itself.
+    // Reflexivity: `T` is equivalent to itself.
     type_property_test!(
         equivalent_to_is_reflexive, db,
         forall types t. t.is_fully_static(db) => t.is_equivalent_to(db, t)
     );
 
-    // `T` is a subtype of itself.
+    // Symmetry: If `S` is equivalent to `T`, then `T` must be equivalent to `S`.
+    // Note that this (trivially) holds true for gradual types as well.
+    type_property_test!(
+        equivalent_to_is_symmetric, db,
+        forall types s, t. s.is_equivalent_to(db, t) => t.is_equivalent_to(db, s)
+    );
+
+    // Transitivity: If `S` is equivalent to `T` and `T` is equivalent to `U`, then `S` must be equivalent to `U`.
+    type_property_test!(
+        equivalent_to_is_transitive, db,
+        forall types s, t, u. s.is_equivalent_to(db, t) && t.is_equivalent_to(db, u) => s.is_equivalent_to(db, u)
+    );
+
+    // A fully static type `T` is a subtype of itself.
     type_property_test!(
         subtype_of_is_reflexive, db,
         forall types t. t.is_fully_static(db) => t.is_subtype_of(db, t)
@@ -305,6 +330,14 @@ mod stable {
         never_subtype_of_every_fully_static_type, db,
         forall types t. t.is_fully_static(db) => Type::Never.is_subtype_of(db, t)
     );
+
+    // For any two fully static types, each type in the pair must be a subtype of their union.
+    type_property_test!(
+        all_fully_static_type_pairs_are_subtype_of_their_union, db,
+        forall types s, t.
+            s.is_fully_static(db) && t.is_fully_static(db)
+            => s.is_subtype_of(db, union(db, s, t)) && t.is_subtype_of(db, union(db, s, t))
+    );
 }
 
 /// This module contains property tests that currently lead to many false positives.
@@ -315,10 +348,7 @@ mod stable {
 /// tests to the `stable` section. In the meantime, it can still be useful to run these
 /// tests (using [`types::property_tests::flaky`]), to see if there are any new obvious bugs.
 mod flaky {
-    use crate::{
-        db::tests::TestDb,
-        types::{IntersectionBuilder, Type},
-    };
+    use super::{intersection, union};
 
     // Currently fails due to https://github.com/astral-sh/ruff/issues/14899
     // `T` can be assigned to itself.
@@ -327,21 +357,8 @@ mod flaky {
         forall types t. t.is_assignable_to(db, t)
     );
 
-    // Currently fails due to https://github.com/astral-sh/ruff/issues/14899
-    // An intersection of two types should be assignable to both of them
-    fn intersection<'db>(db: &'db TestDb, s: Type<'db>, t: Type<'db>) -> Type<'db> {
-        IntersectionBuilder::new(db)
-            .add_positive(s)
-            .add_positive(t)
-            .build()
-    }
-
-    type_property_test!(
-        intersection_assignable_to_both, db,
-        forall types s, t. intersection(db, s, t).is_assignable_to(db, s) && intersection(db, s, t).is_assignable_to(db, t)
-    );
-
     // `S <: T` and `T <: S` implies that `S` is equivalent to `T`.
+    // This very often passes now, but occasionally flakes due to https://github.com/astral-sh/ruff/issues/15380
     type_property_test!(
         subtype_of_is_antisymmetric, db,
         forall types s, t. s.is_subtype_of(db, t) && t.is_subtype_of(db, s) => s.is_equivalent_to(db, t)
@@ -352,4 +369,39 @@ mod flaky {
         double_negation_is_identity, db,
         forall types t. t.negate(db).negate(db).is_equivalent_to(db, t)
     );
+
+    // ~T should be disjoint from T
+    type_property_test!(
+        negation_is_disjoint, db,
+        forall types t. t.is_fully_static(db) => t.negate(db).is_disjoint_from(db, t)
+    );
+
+    // If `S <: T`, then `~T <: ~S`.
+    type_property_test!(
+        negation_reverses_subtype_order, db,
+        forall types s, t. s.is_subtype_of(db, t) => t.negate(db).is_subtype_of(db, s.negate(db))
+    );
+
+    // For two fully static types, their intersection must be a subtype of each type in the pair.
+    type_property_test!(
+        all_fully_static_type_pairs_are_supertypes_of_their_intersection, db,
+        forall types s, t.
+            s.is_fully_static(db) && t.is_fully_static(db)
+            => intersection(db, s, t).is_subtype_of(db, s) && intersection(db, s, t).is_subtype_of(db, t)
+    );
+
+    // And for non-fully-static types, the intersection of a pair of types
+    // should be assignable to both types of the pair.
+    // Currently fails due to https://github.com/astral-sh/ruff/issues/14899
+    type_property_test!(
+        all_type_pairs_can_be_assigned_from_their_intersection, db,
+        forall types s, t. intersection(db, s, t).is_assignable_to(db, s) && intersection(db, s, t).is_assignable_to(db, t)
+    );
+
+    // For *any* pair of types, whether fully static or not,
+    // each of the pair should be assignable to the union of the two.
+    type_property_test!(
+        all_type_pairs_are_assignable_to_their_union, db,
+        forall types s, t. s.is_assignable_to(db, union(db, s, t)) && t.is_assignable_to(db, union(db, s, t))
+    );
 }

crates/red_knot_python_semantic/src/types/string_annotation.rs

@@ -1,7 +1,7 @@
 use ruff_db::source::source_text;
 use ruff_python_ast::str::raw_contents;
-use ruff_python_ast::{self as ast, ModExpression, StringFlags};
-use ruff_python_parser::{parse_expression_range, Parsed};
+use ruff_python_ast::{self as ast, ModExpression};
+use ruff_python_parser::Parsed;
 use ruff_text_size::Ranged;
 
 use crate::declare_lint;
@@ -153,19 +153,7 @@ pub(crate) fn parse_string_annotation(
         } else if raw_contents(node_text)
             .is_some_and(|raw_contents| raw_contents == string_literal.as_str())
         {
-            let range_excluding_quotes = string_literal
-                .range()
-                .add_start(string_literal.flags.opener_len())
-                .sub_end(string_literal.flags.closer_len());
-
-            // TODO: Support multiline strings like:
-            // ```py
-            // x: """
-            //     int
-            //     | float
-            // """ = 1
-            // ```
-            match parse_expression_range(source.as_str(), range_excluding_quotes) {
+            match ruff_python_parser::parse_string_annotation(source.as_str(), string_literal) {
                 Ok(parsed) => return Some(parsed),
                 Err(parse_error) => context.report_lint(
                     &INVALID_SYNTAX_IN_FORWARD_ANNOTATION,

crates/red_knot_python_semantic/src/types/subclass_of.rs

@@ -22,9 +22,7 @@ impl<'db> SubclassOfType<'db> {
     pub(crate) fn from(db: &'db dyn Db, subclass_of: impl Into<ClassBase<'db>>) -> Type<'db> {
         let subclass_of = subclass_of.into();
         match subclass_of {
-            ClassBase::Any | ClassBase::Unknown | ClassBase::Todo(_) => {
-                Type::SubclassOf(Self { subclass_of })
-            }
+            ClassBase::Dynamic(_) => Type::SubclassOf(Self { subclass_of }),
             ClassBase::Class(class) => {
                 if class.is_final(db) {
                     Type::ClassLiteral(ClassLiteralType { class })
@@ -40,14 +38,14 @@ impl<'db> SubclassOfType<'db> {
     /// Return a [`Type`] instance representing the type `type[Unknown]`.
     pub(crate) const fn subclass_of_unknown() -> Type<'db> {
         Type::SubclassOf(SubclassOfType {
-            subclass_of: ClassBase::Unknown,
+            subclass_of: ClassBase::unknown(),
         })
     }
 
     /// Return a [`Type`] instance representing the type `type[Any]`.
     pub(crate) const fn subclass_of_any() -> Type<'db> {
         Type::SubclassOf(SubclassOfType {
-            subclass_of: ClassBase::Any,
+            subclass_of: ClassBase::any(),
         })
     }
 
@@ -77,8 +75,7 @@ impl<'db> SubclassOfType<'db> {
     pub(crate) fn is_subtype_of(self, db: &'db dyn Db, other: SubclassOfType<'db>) -> bool {
         match (self.subclass_of, other.subclass_of) {
             // Non-fully-static types do not participate in subtyping
-            (ClassBase::Any | ClassBase::Unknown | ClassBase::Todo(_), _)
-            | (_, ClassBase::Any | ClassBase::Unknown | ClassBase::Todo(_)) => false,
+            (ClassBase::Dynamic(_), _) | (_, ClassBase::Dynamic(_)) => false,
 
             // For example, `type[bool]` describes all possible runtime subclasses of the class `bool`,
             // and `type[int]` describes all possible runtime subclasses of the class `int`.

crates/red_knot_python_semantic/src/types/unpacker.rs

@@ -52,7 +52,7 @@ impl<'db> Unpacker<'db> {
                 .node_ref(self.db())
                 .is_ellipsis_literal_expr()
         {
-            value_ty = Type::Unknown;
+            value_ty = Type::unknown();
         }
         if value.is_iterable() {
             // If the value is an iterable, then the type that needs to be unpacked is the iterator
@@ -164,7 +164,7 @@ impl<'db> Unpacker<'db> {
                 for (index, element) in elts.iter().enumerate() {
                     // SAFETY: `target_types` is initialized with the same length as `elts`.
                     let element_ty = match target_types[index].as_slice() {
-                        [] => Type::Unknown,
+                        [] => Type::unknown(),
                         types => UnionType::from_elements(self.db(), types),
                     };
                     self.unpack_inner(element, element_ty);
@@ -241,7 +241,7 @@ impl<'db> Unpacker<'db> {
 
             // Subtract 1 to insert the starred expression type at the correct
             // index.
-            element_types.resize(targets.len() - 1, Type::Unknown);
+            element_types.resize(targets.len() - 1, Type::unknown());
             // TODO: This should be `list[Unknown]`
             element_types.insert(starred_index, todo_type!("starred unpacking"));
 

crates/red_knot_server/src/message.rs

@@ -40,7 +40,7 @@ pub(super) fn try_show_message(
 /// Sends an error to the client with a formatted message. The error is sent in a
 /// `window/showMessage` notification.
 macro_rules! show_err_msg {
-    ($msg:expr$(, $($arg:tt),*)?) => {
-        crate::message::show_message(::core::format_args!($msg, $($($arg),*)?).to_string(), lsp_types::MessageType::ERROR)
+    ($msg:expr$(, $($arg:tt)*)?) => {
+        crate::message::show_message(::core::format_args!($msg$(, $($arg)*)?).to_string(), lsp_types::MessageType::ERROR)
     };
 }

crates/red_knot_server/src/server/api.rs

@@ -86,13 +86,11 @@ fn background_request_task<'a, R: traits::BackgroundDocumentRequestHandler>(
             return Box::new(|_, _| {});
         };
         let db = match path {
-            AnySystemPath::System(path) => {
-                match session.workspace_db_for_path(path.as_std_path()) {
-                    Some(db) => db.clone(),
-                    None => session.default_workspace_db().clone(),
-                }
-            }
-            AnySystemPath::SystemVirtual(_) => session.default_workspace_db().clone(),
+            AnySystemPath::System(path) => match session.project_db_for_path(path.as_std_path()) {
+                Some(db) => db.clone(),
+                None => session.default_project_db().clone(),
+            },
+            AnySystemPath::SystemVirtual(_) => session.default_project_db().clone(),
         };
 
         let Some(snapshot) = session.take_snapshot(url) else {

crates/red_knot_server/src/server/api/notifications/did_change.rs

@@ -36,14 +36,14 @@ impl SyncNotificationHandler for DidChangeTextDocumentHandler {
 
         match path {
             AnySystemPath::System(path) => {
-                let db = match session.workspace_db_for_path_mut(path.as_std_path()) {
+                let db = match session.project_db_for_path_mut(path.as_std_path()) {
                     Some(db) => db,
-                    None => session.default_workspace_db_mut(),
+                    None => session.default_project_db_mut(),
                 };
                 db.apply_changes(vec![ChangeEvent::file_content_changed(path)], None);
             }
             AnySystemPath::SystemVirtual(virtual_path) => {
-                let db = session.default_workspace_db_mut();
+                let db = session.default_project_db_mut();
                 db.apply_changes(vec![ChangeEvent::ChangedVirtual(virtual_path)], None);
             }
         }

crates/red_knot_server/src/server/api/notifications/did_close.rs

@@ -34,7 +34,7 @@ impl SyncNotificationHandler for DidCloseTextDocumentHandler {
             .with_failure_code(ErrorCode::InternalError)?;
 
         if let AnySystemPath::SystemVirtual(virtual_path) = path {
-            let db = session.default_workspace_db_mut();
+            let db = session.default_project_db_mut();
             db.apply_changes(vec![ChangeEvent::DeletedVirtual(virtual_path)], None);
         }
 

crates/red_knot_server/src/server/api/notifications/did_close_notebook.rs

@@ -33,7 +33,7 @@ impl SyncNotificationHandler for DidCloseNotebookHandler {
             .with_failure_code(lsp_server::ErrorCode::InternalError)?;
 
         if let AnySystemPath::SystemVirtual(virtual_path) = path {
-            let db = session.default_workspace_db_mut();
+            let db = session.default_project_db_mut();
             db.apply_changes(vec![ChangeEvent::DeletedVirtual(virtual_path)], None);
         }
 

crates/red_knot_server/src/server/api/notifications/did_open.rs

@@ -33,14 +33,14 @@ impl SyncNotificationHandler for DidOpenTextDocumentHandler {
 
         match path {
             AnySystemPath::System(path) => {
-                let db = match session.workspace_db_for_path_mut(path.as_std_path()) {
+                let db = match session.project_db_for_path_mut(path.as_std_path()) {
                     Some(db) => db,
-                    None => session.default_workspace_db_mut(),
+                    None => session.default_project_db_mut(),
                 };
                 db.apply_changes(vec![ChangeEvent::Opened(path)], None);
             }
             AnySystemPath::SystemVirtual(virtual_path) => {
-                let db = session.default_workspace_db_mut();
+                let db = session.default_project_db_mut();
                 db.files().virtual_file(db, &virtual_path);
             }
         }

crates/red_knot_server/src/server/api/notifications/did_open_notebook.rs

@@ -41,14 +41,14 @@ impl SyncNotificationHandler for DidOpenNotebookHandler {
 
         match path {
             AnySystemPath::System(path) => {
-                let db = match session.workspace_db_for_path_mut(path.as_std_path()) {
+                let db = match session.project_db_for_path_mut(path.as_std_path()) {
                     Some(db) => db,
-                    None => session.default_workspace_db_mut(),
+                    None => session.default_project_db_mut(),
                 };
                 db.apply_changes(vec![ChangeEvent::Opened(path)], None);
             }
             AnySystemPath::SystemVirtual(virtual_path) => {
-                let db = session.default_workspace_db_mut();
+                let db = session.default_project_db_mut();
                 db.files().virtual_file(db, &virtual_path);
             }
         }

crates/red_knot_server/src/server/api/requests/diagnostic.rs

@@ -11,7 +11,7 @@ use crate::edit::ToRangeExt;
 use crate::server::api::traits::{BackgroundDocumentRequestHandler, RequestHandler};
 use crate::server::{client::Notifier, Result};
 use crate::session::DocumentSnapshot;
-use red_knot_workspace::db::{Db, RootDatabase};
+use red_knot_workspace::db::{Db, ProjectDatabase};
 use ruff_db::diagnostic::Severity;
 use ruff_db::source::{line_index, source_text};
 
@@ -28,7 +28,7 @@ impl BackgroundDocumentRequestHandler for DocumentDiagnosticRequestHandler {
 
     fn run_with_snapshot(
         snapshot: DocumentSnapshot,
-        db: RootDatabase,
+        db: ProjectDatabase,
         _notifier: Notifier,
         _params: DocumentDiagnosticParams,
     ) -> Result<DocumentDiagnosticReportResult> {
@@ -46,7 +46,7 @@ impl BackgroundDocumentRequestHandler for DocumentDiagnosticRequestHandler {
     }
 }
 
-fn compute_diagnostics(snapshot: &DocumentSnapshot, db: &RootDatabase) -> Vec<Diagnostic> {
+fn compute_diagnostics(snapshot: &DocumentSnapshot, db: &ProjectDatabase) -> Vec<Diagnostic> {
     let Some(file) = snapshot.file(db) else {
         tracing::info!(
             "No file found for snapshot for `{}`",

crates/red_knot_server/src/server/api/traits.rs

@@ -5,7 +5,7 @@ use crate::session::{DocumentSnapshot, Session};
 
 use lsp_types::notification::Notification as LSPNotification;
 use lsp_types::request::Request;
-use red_knot_workspace::db::RootDatabase;
+use red_knot_workspace::db::ProjectDatabase;
 
 /// A supertrait for any server request handler.
 pub(super) trait RequestHandler {
@@ -34,7 +34,7 @@ pub(super) trait BackgroundDocumentRequestHandler: RequestHandler {
 
     fn run_with_snapshot(
         snapshot: DocumentSnapshot,
-        db: RootDatabase,
+        db: ProjectDatabase,
         notifier: Notifier,
         params: <<Self as RequestHandler>::RequestType as Request>::Params,
     ) -> super::Result<<<Self as RequestHandler>::RequestType as Request>::Result>;

crates/red_knot_server/src/session.rs

@@ -8,8 +8,8 @@ use std::sync::Arc;
 use anyhow::anyhow;
 use lsp_types::{ClientCapabilities, TextDocumentContentChangeEvent, Url};
 
-use red_knot_workspace::db::RootDatabase;
-use red_knot_workspace::workspace::WorkspaceMetadata;
+use red_knot_workspace::db::ProjectDatabase;
+use red_knot_workspace::project::ProjectMetadata;
 use ruff_db::files::{system_path_to_file, File};
 use ruff_db::system::SystemPath;
 use ruff_db::Db;
@@ -28,7 +28,7 @@ pub(crate) mod index;
 mod settings;
 
 // TODO(dhruvmanila): In general, the server shouldn't use any salsa queries directly and instead
-// should use methods on `RootDatabase`.
+// should use methods on `ProjectDatabase`.
 
 /// The global state for the LSP
 pub struct Session {
@@ -41,8 +41,9 @@ pub struct Session {
     /// [`index_mut`]: Session::index_mut
     index: Option<Arc<index::Index>>,
 
-    /// Maps workspace root paths to their respective databases.
-    workspaces: BTreeMap<PathBuf, RootDatabase>,
+    /// Maps workspace folders to their respective project databases.
+    projects_by_workspace_folder: BTreeMap<PathBuf, ProjectDatabase>,
+
     /// The global position encoding, negotiated during LSP initialization.
     position_encoding: PositionEncoding,
     /// Tracks what LSP features the client supports and doesn't support.
@@ -68,14 +69,14 @@ impl Session {
             let system = LSPSystem::new(index.clone());
 
             // TODO(dhruvmanila): Get the values from the client settings
-            let metadata = WorkspaceMetadata::discover(system_path, &system, None)?;
+            let metadata = ProjectMetadata::discover(system_path, &system, None)?;
             // TODO(micha): Handle the case where the program settings are incorrect more gracefully.
-            workspaces.insert(path, RootDatabase::new(metadata, system)?);
+            workspaces.insert(path, ProjectDatabase::new(metadata, system)?);
         }
 
         Ok(Self {
             position_encoding,
-            workspaces,
+            projects_by_workspace_folder: workspaces,
             index: Some(index),
             resolved_client_capabilities: Arc::new(ResolvedClientCapabilities::new(
                 client_capabilities,
@@ -87,38 +88,41 @@ impl Session {
     // and `default_workspace_db_mut` but the borrow checker doesn't allow that.
     // https://github.com/astral-sh/ruff/pull/13041#discussion_r1726725437
 
-    /// Returns a reference to the workspace [`RootDatabase`] corresponding to the given path, if
+    /// Returns a reference to the project's [`ProjectDatabase`] corresponding to the given path, if
     /// any.
-    pub(crate) fn workspace_db_for_path(&self, path: impl AsRef<Path>) -> Option<&RootDatabase> {
-        self.workspaces
+    pub(crate) fn project_db_for_path(&self, path: impl AsRef<Path>) -> Option<&ProjectDatabase> {
+        self.projects_by_workspace_folder
             .range(..=path.as_ref().to_path_buf())
             .next_back()
             .map(|(_, db)| db)
     }
 
-    /// Returns a mutable reference to the workspace [`RootDatabase`] corresponding to the given
+    /// Returns a mutable reference to the project [`ProjectDatabase`] corresponding to the given
     /// path, if any.
-    pub(crate) fn workspace_db_for_path_mut(
+    pub(crate) fn project_db_for_path_mut(
         &mut self,
         path: impl AsRef<Path>,
-    ) -> Option<&mut RootDatabase> {
-        self.workspaces
+    ) -> Option<&mut ProjectDatabase> {
+        self.projects_by_workspace_folder
             .range_mut(..=path.as_ref().to_path_buf())
             .next_back()
             .map(|(_, db)| db)
     }
 
-    /// Returns a reference to the default workspace [`RootDatabase`]. The default workspace is the
-    /// minimum root path in the workspace map.
-    pub(crate) fn default_workspace_db(&self) -> &RootDatabase {
-        // SAFETY: Currently, red knot only support a single workspace.
-        self.workspaces.values().next().unwrap()
+    /// Returns a reference to the default project [`ProjectDatabase`]. The default project is the
+    /// minimum root path in the project map.
+    pub(crate) fn default_project_db(&self) -> &ProjectDatabase {
+        // SAFETY: Currently, red knot only support a single project.
+        self.projects_by_workspace_folder.values().next().unwrap()
     }
 
-    /// Returns a mutable reference to the default workspace [`RootDatabase`].
-    pub(crate) fn default_workspace_db_mut(&mut self) -> &mut RootDatabase {
-        // SAFETY: Currently, red knot only support a single workspace.
-        self.workspaces.values_mut().next().unwrap()
+    /// Returns a mutable reference to the default project [`ProjectDatabase`].
+    pub(crate) fn default_project_db_mut(&mut self) -> &mut ProjectDatabase {
+        // SAFETY: Currently, red knot only support a single project.
+        self.projects_by_workspace_folder
+            .values_mut()
+            .next()
+            .unwrap()
     }
 
     pub fn key_from_url(&self, url: Url) -> DocumentKey {
@@ -187,7 +191,7 @@ impl Session {
     fn index_mut(&mut self) -> MutIndexGuard {
         let index = self.index.take().unwrap();
 
-        for db in self.workspaces.values_mut() {
+        for db in self.projects_by_workspace_folder.values_mut() {
             // Remove the `index` from each database. This drops the count of `Arc<Index>` down to 1
             db.system_mut()
                 .as_any_mut()
@@ -232,7 +236,7 @@ impl Drop for MutIndexGuard<'_> {
     fn drop(&mut self) {
         if let Some(index) = self.index.take() {
             let index = Arc::new(index);
-            for db in self.session.workspaces.values_mut() {
+            for db in self.session.projects_by_workspace_folder.values_mut() {
                 db.system_mut()
                     .as_any_mut()
                     .downcast_mut::<LSPSystem>()
@@ -267,7 +271,7 @@ impl DocumentSnapshot {
         self.position_encoding
     }
 
-    pub(crate) fn file(&self, db: &RootDatabase) -> Option<File> {
+    pub(crate) fn file(&self, db: &ProjectDatabase) -> Option<File> {
         match url_to_any_system_path(self.document_ref.file_url()).ok()? {
             AnySystemPath::System(path) => system_path_to_file(db, path).ok(),
             AnySystemPath::SystemVirtual(virtual_path) => db

crates/red_knot_server/src/session/index.rs

@@ -74,7 +74,7 @@ impl Index {
             DocumentKey::NotebookCell(url)
         } else if Path::new(url.path())
             .extension()
-            .map_or(false, |ext| ext.eq_ignore_ascii_case("ipynb"))
+            .is_some_and(|ext| ext.eq_ignore_ascii_case("ipynb"))
         {
             DocumentKey::Notebook(url)
         } else {

crates/red_knot_test/src/db.rs

@@ -38,7 +38,7 @@ impl Db {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 python_version: PythonVersion::default(),
                 python_platform: PythonPlatform::default(),
                 search_paths: SearchPathSettings::new(db.workspace_root.clone()),

crates/red_knot_vendored/knot_extensions/knot_extensions.pyi

@@ -5,6 +5,8 @@ def static_assert(condition: object, msg: LiteralString | None = None) -> None:
 
 # Types
 Unknown = object()
+AlwaysTruthy = object()
+AlwaysFalsy = object()
 
 # Special forms
 Not: _SpecialForm

crates/red_knot_vendored/vendor/typeshed/README.md

@@ -21,7 +21,7 @@ the project the stubs are for, but instead report them here to typeshed.**
 Further documentation on stub files, typeshed, and Python's typing system in
 general, can also be found at https://typing.readthedocs.io/en/latest/.
 
-Typeshed supports Python versions 3.8 to 3.13.
+Typeshed supports Python versions 3.9 to 3.13.
 
 ## Using
 

crates/red_knot_vendored/vendor/typeshed/source_commit.txt

@@ -1 +1 @@
-2047b820730fdd65d37e6e8efcf29ca9af7ec3e7
+101287091cbd71a3305a4fc4a1a8eb5df0e3f6f7

crates/red_knot_vendored/vendor/typeshed/stdlib/_interpqueues.pyi

@@ -1,16 +1,19 @@
-from typing import Any, SupportsIndex
+from typing import Any, Literal, SupportsIndex
+from typing_extensions import TypeAlias
+
+_UnboundOp: TypeAlias = Literal[1, 2, 3]
 
 class QueueError(RuntimeError): ...
 class QueueNotFoundError(QueueError): ...
 
 def bind(qid: SupportsIndex) -> None: ...
-def create(maxsize: SupportsIndex, fmt: SupportsIndex) -> int: ...
+def create(maxsize: SupportsIndex, fmt: SupportsIndex, unboundop: _UnboundOp) -> int: ...
 def destroy(qid: SupportsIndex) -> None: ...
-def get(qid: SupportsIndex) -> tuple[Any, int]: ...
+def get(qid: SupportsIndex) -> tuple[Any, int, _UnboundOp | None]: ...
 def get_count(qid: SupportsIndex) -> int: ...
 def get_maxsize(qid: SupportsIndex) -> int: ...
-def get_queue_defaults(qid: SupportsIndex) -> tuple[int]: ...
+def get_queue_defaults(qid: SupportsIndex) -> tuple[int, _UnboundOp]: ...
 def is_full(qid: SupportsIndex) -> bool: ...
-def list_all() -> list[tuple[int, int]]: ...
-def put(qid: SupportsIndex, obj: Any, fmt: SupportsIndex) -> None: ...
+def list_all() -> list[tuple[int, int, _UnboundOp]]: ...
+def put(qid: SupportsIndex, obj: Any, fmt: SupportsIndex, unboundop: _UnboundOp) -> None: ...
 def release(qid: SupportsIndex) -> None: ...

crates/red_knot_vendored/vendor/typeshed/stdlib/_interpreters.pyi

@@ -21,7 +21,9 @@ def get_main() -> tuple[int, int]: ...
 def is_running(id: SupportsIndex, *, restrict: bool = False) -> bool: ...
 def get_config(id: SupportsIndex, *, restrict: bool = False) -> types.SimpleNamespace: ...
 def whence(id: SupportsIndex) -> int: ...
-def exec(id: SupportsIndex, code: str, shared: bool | None = None, *, restrict: bool = False) -> None: ...
+def exec(
+    id: SupportsIndex, code: str | types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
+) -> None | types.SimpleNamespace: ...
 def call(
     id: SupportsIndex,
     callable: Callable[..., object],

crates/red_knot_vendored/vendor/typeshed/stdlib/_ssl.pyi

@@ -240,9 +240,7 @@ OP_SINGLE_ECDH_USE: int
 OP_NO_COMPRESSION: int
 OP_ENABLE_MIDDLEBOX_COMPAT: int
 OP_NO_RENEGOTIATION: int
-if sys.version_info >= (3, 11):
-    OP_IGNORE_UNEXPECTED_EOF: int
-elif sys.version_info >= (3, 8) and sys.platform == "linux":
+if sys.version_info >= (3, 11) or sys.platform == "linux":
     OP_IGNORE_UNEXPECTED_EOF: int
 if sys.version_info >= (3, 12):
     OP_LEGACY_SERVER_CONNECT: int

crates/red_knot_vendored/vendor/typeshed/stdlib/ctypes/__init__.pyi

@@ -159,7 +159,14 @@ def ARRAY(typ: _CT, len: int) -> Array[_CT]: ...  # Soft Deprecated, no plans to
 if sys.platform == "win32":
     def DllCanUnloadNow() -> int: ...
     def DllGetClassObject(rclsid: Any, riid: Any, ppv: Any) -> int: ...  # TODO not documented
-    def GetLastError() -> int: ...
+
+    # Actually just an instance of _NamedFuncPointer (aka _CDLLFuncPointer),
+    # but we want to set a more specific __call__
+    @type_check_only
+    class _GetLastErrorFunctionType(_NamedFuncPointer):
+        def __call__(self) -> int: ...
+
+    GetLastError: _GetLastErrorFunctionType
 
 # Actually just an instance of _CFunctionType, but we want to set a more
 # specific __call__.

crates/red_knot_vendored/vendor/typeshed/stdlib/socket.pyi

@@ -1399,7 +1399,7 @@ def create_server(
     address: _Address, *, family: int = ..., backlog: int | None = None, reuse_port: bool = False, dualstack_ipv6: bool = False
 ) -> socket: ...
 
-# the 5th tuple item is an address
+# The 5th tuple item is the socket address, for IP4, IP6, or IP6 if Python is compiled with --disable-ipv6, respectively.
 def getaddrinfo(
     host: bytes | str | None, port: bytes | str | int | None, family: int = 0, type: int = 0, proto: int = 0, flags: int = 0
-) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int]]]: ...
+) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes]]]: ...

crates/red_knot_vendored/vendor/typeshed/stdlib/sys/__init__.pyi

@@ -6,7 +6,7 @@ from collections.abc import AsyncGenerator, Callable, Sequence
 from io import TextIOWrapper
 from types import FrameType, ModuleType, TracebackType
 from typing import Any, Final, Literal, NoReturn, Protocol, TextIO, TypeVar, final, type_check_only
-from typing_extensions import TypeAlias
+from typing_extensions import LiteralString, TypeAlias
 
 _T = TypeVar("_T")
 
@@ -45,7 +45,7 @@ if sys.version_info >= (3, 10):
 path: list[str]
 path_hooks: list[Callable[[str], PathEntryFinderProtocol]]
 path_importer_cache: dict[str, PathEntryFinderProtocol | None]
-platform: str
+platform: LiteralString
 if sys.version_info >= (3, 9):
     platlibdir: str
 prefix: str
@@ -393,6 +393,10 @@ if sys.platform == "win32":
     def getwindowsversion() -> _WinVersion: ...
 
 def intern(string: str, /) -> str: ...
+
+if sys.version_info >= (3, 13):
+    def _is_gil_enabled() -> bool: ...
+
 def is_finalizing() -> bool: ...
 def breakpointhook(*args: Any, **kwargs: Any) -> Any: ...
 

crates/red_knot_vendored/vendor/typeshed/stdlib/tarfile.pyi

@@ -123,7 +123,7 @@ def open(
 @overload
 def open(
     name: StrOrBytesPath | None,
-    mode: Literal["x", "x:", "a", "a:", "w", "w:"],
+    mode: Literal["x", "x:", "a", "a:", "w", "w:", "w:tar"],
     fileobj: _Fileobj | None = None,
     bufsize: int = 10240,
     *,
@@ -141,7 +141,7 @@ def open(
 def open(
     name: StrOrBytesPath | None = None,
     *,
-    mode: Literal["x", "x:", "a", "a:", "w", "w:"],
+    mode: Literal["x", "x:", "a", "a:", "w", "w:", "w:tar"],
     fileobj: _Fileobj | None = None,
     bufsize: int = 10240,
     format: int | None = ...,

crates/red_knot_vendored/vendor/typeshed/stdlib/telnetlib.pyi

@@ -1,5 +1,5 @@
 import socket
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, MutableSequence, Sequence
 from re import Match, Pattern
 from types import TracebackType
 from typing import Any
@@ -114,7 +114,7 @@ class Telnet:
     def mt_interact(self) -> None: ...
     def listener(self) -> None: ...
     def expect(
-        self, list: Sequence[Pattern[bytes] | bytes], timeout: float | None = None
+        self, list: MutableSequence[Pattern[bytes] | bytes] | Sequence[Pattern[bytes]], timeout: float | None = None
     ) -> tuple[int, Match[bytes] | None, bytes]: ...
     def __enter__(self) -> Self: ...
     def __exit__(

crates/red_knot_vendored/vendor/typeshed/stdlib/tkinter/filedialog.pyi

@@ -80,8 +80,8 @@ class Directory(commondialog.Dialog):
 # TODO: command kwarg available on macos
 def asksaveasfilename(
     *,
-    confirmoverwrite: bool | None = ...,
-    defaultextension: str | None = ...,
+    confirmoverwrite: bool | None = True,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,
@@ -91,7 +91,7 @@ def asksaveasfilename(
 ) -> str: ...  # can be empty string
 def askopenfilename(
     *,
-    defaultextension: str | None = ...,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,
@@ -101,7 +101,7 @@ def askopenfilename(
 ) -> str: ...  # can be empty string
 def askopenfilenames(
     *,
-    defaultextension: str | None = ...,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,
@@ -110,15 +110,15 @@ def askopenfilenames(
     typevariable: StringVar | str | None = ...,
 ) -> Literal[""] | tuple[str, ...]: ...
 def askdirectory(
-    *, initialdir: StrOrBytesPath | None = ..., mustexist: bool | None = ..., parent: Misc | None = ..., title: str | None = ...
+    *, initialdir: StrOrBytesPath | None = ..., mustexist: bool | None = False, parent: Misc | None = ..., title: str | None = ...
 ) -> str: ...  # can be empty string
 
 # TODO: If someone actually uses these, overload to have the actual return type of open(..., mode)
 def asksaveasfile(
     mode: str = "w",
     *,
-    confirmoverwrite: bool | None = ...,
-    defaultextension: str | None = ...,
+    confirmoverwrite: bool | None = True,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,
@@ -129,7 +129,7 @@ def asksaveasfile(
 def askopenfile(
     mode: str = "r",
     *,
-    defaultextension: str | None = ...,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,
@@ -140,7 +140,7 @@ def askopenfile(
 def askopenfiles(
     mode: str = "r",
     *,
-    defaultextension: str | None = ...,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,

crates/red_knot_vendored/vendor/typeshed/stdlib/xml/dom/minidom.pyi

@@ -291,8 +291,8 @@ class ReadOnlySequentialNamedNodeMap:
     def length(self) -> int: ...
 
 class Identified:
-    publicId: Incomplete
-    systemId: Incomplete
+    publicId: str | None
+    systemId: str | None
 
 class DocumentType(Identified, Childless, Node):
     nodeType: int
@@ -331,7 +331,7 @@ class Notation(Identified, Childless, Node):
 class DOMImplementation(DOMImplementationLS):
     def hasFeature(self, feature: str, version: str | None) -> bool: ...
     def createDocument(self, namespaceURI: str | None, qualifiedName: str | None, doctype: DocumentType | None) -> Document: ...
-    def createDocumentType(self, qualifiedName: str | None, publicId: str, systemId: str) -> DocumentType: ...
+    def createDocumentType(self, qualifiedName: str | None, publicId: str | None, systemId: str | None) -> DocumentType: ...
     def getInterface(self, feature: str) -> Self | None: ...
 
 class ElementInfo:

crates/red_knot_wasm/src/lib.rs

@@ -3,9 +3,9 @@ use std::any::Any;
 use js_sys::Error;
 use wasm_bindgen::prelude::*;
 
-use red_knot_workspace::db::{Db, RootDatabase};
-use red_knot_workspace::workspace::settings::Configuration;
-use red_knot_workspace::workspace::WorkspaceMetadata;
+use red_knot_workspace::db::{Db, ProjectDatabase};
+use red_knot_workspace::project::settings::Configuration;
+use red_knot_workspace::project::ProjectMetadata;
 use ruff_db::diagnostic::Diagnostic;
 use ruff_db::files::{system_path_to_file, File};
 use ruff_db::system::walk_directory::WalkDirectoryBuilder;
@@ -33,7 +33,7 @@ pub fn run() {
 
 #[wasm_bindgen]
 pub struct Workspace {
-    db: RootDatabase,
+    db: ProjectDatabase,
     system: WasmSystem,
 }
 
@@ -42,7 +42,7 @@ impl Workspace {
     #[wasm_bindgen(constructor)]
     pub fn new(root: &str, settings: &Settings) -> Result<Workspace, Error> {
         let system = WasmSystem::new(SystemPath::new(root));
-        let workspace = WorkspaceMetadata::discover(
+        let workspace = ProjectMetadata::discover(
             SystemPath::new(root),
             &system,
             Some(&Configuration {
@@ -52,7 +52,7 @@ impl Workspace {
         )
         .map_err(into_error)?;
 
-        let db = RootDatabase::new(workspace, system.clone()).map_err(into_error)?;
+        let db = ProjectDatabase::new(workspace, system.clone()).map_err(into_error)?;
 
         Ok(Self { db, system })
     }
@@ -67,7 +67,7 @@ impl Workspace {
         let file = system_path_to_file(&self.db, path).expect("File to exist");
         file.sync(&mut self.db);
 
-        self.db.workspace().open_file(&mut self.db, file);
+        self.db.project().open_file(&mut self.db, file);
 
         Ok(FileHandle {
             file,
@@ -95,7 +95,7 @@ impl Workspace {
     pub fn close_file(&mut self, file_id: &FileHandle) -> Result<(), Error> {
         let file = file_id.file;
 
-        self.db.workspace().close_file(&mut self.db, file);
+        self.db.project().close_file(&mut self.db, file);
         self.system
             .fs
             .remove_file(&file_id.path)

crates/red_knot_workspace/src/db.rs

@@ -1,7 +1,7 @@
 use std::panic::RefUnwindSafe;
 use std::sync::Arc;
 
-use crate::workspace::{check_file, Workspace, WorkspaceMetadata};
+use crate::project::{check_file, Project, ProjectMetadata};
 use crate::DEFAULT_LINT_REGISTRY;
 use red_knot_python_semantic::lint::{LintRegistry, RuleSelection};
 use red_knot_python_semantic::{Db as SemanticDb, Program};
@@ -17,28 +17,28 @@ mod changes;
 
 #[salsa::db]
 pub trait Db: SemanticDb + Upcast<dyn SemanticDb> {
-    fn workspace(&self) -> Workspace;
+    fn project(&self) -> Project;
 }
 
 #[salsa::db]
 #[derive(Clone)]
-pub struct RootDatabase {
-    workspace: Option<Workspace>,
-    storage: salsa::Storage<RootDatabase>,
+pub struct ProjectDatabase {
+    project: Option<Project>,
+    storage: salsa::Storage<ProjectDatabase>,
     files: Files,
     system: Arc<dyn System + Send + Sync + RefUnwindSafe>,
     rule_selection: Arc<RuleSelection>,
 }
 
-impl RootDatabase {
-    pub fn new<S>(workspace: WorkspaceMetadata, system: S) -> anyhow::Result<Self>
+impl ProjectDatabase {
+    pub fn new<S>(project_metadata: ProjectMetadata, system: S) -> anyhow::Result<Self>
     where
         S: System + 'static + Send + Sync + RefUnwindSafe,
     {
         let rule_selection = RuleSelection::from_registry(&DEFAULT_LINT_REGISTRY);
 
         let mut db = Self {
-            workspace: None,
+            project: None,
             storage: salsa::Storage::default(),
             files: Files::default(),
             system: Arc::new(system),
@@ -46,16 +46,17 @@ impl RootDatabase {
         };
 
         // Initialize the `Program` singleton
-        Program::from_settings(&db, workspace.settings().program())?;
+        let program_settings = project_metadata.to_program_settings();
+        Program::from_settings(&db, program_settings)?;
 
-        db.workspace = Some(Workspace::from_metadata(&db, workspace));
+        db.project = Some(Project::from_metadata(&db, project_metadata));
 
         Ok(db)
     }
 
-    /// Checks all open files in the workspace and its dependencies.
+    /// Checks all open files in the project and its dependencies.
     pub fn check(&self) -> Result<Vec<Box<dyn Diagnostic>>, Cancelled> {
-        self.with_db(|db| db.workspace().check(db))
+        self.with_db(|db| db.project().check(db))
     }
 
     pub fn check_file(&self, file: File) -> Result<Vec<Box<dyn Diagnostic>>, Cancelled> {
@@ -77,13 +78,13 @@ impl RootDatabase {
 
     pub(crate) fn with_db<F, T>(&self, f: F) -> Result<T, Cancelled>
     where
-        F: FnOnce(&RootDatabase) -> T + std::panic::UnwindSafe,
+        F: FnOnce(&ProjectDatabase) -> T + std::panic::UnwindSafe,
     {
         Cancelled::catch(|| f(self))
     }
 }
 
-impl Upcast<dyn SemanticDb> for RootDatabase {
+impl Upcast<dyn SemanticDb> for ProjectDatabase {
     fn upcast(&self) -> &(dyn SemanticDb + 'static) {
         self
     }
@@ -93,7 +94,7 @@ impl Upcast<dyn SemanticDb> for RootDatabase {
     }
 }
 
-impl Upcast<dyn SourceDb> for RootDatabase {
+impl Upcast<dyn SourceDb> for ProjectDatabase {
     fn upcast(&self) -> &(dyn SourceDb + 'static) {
         self
     }
@@ -104,13 +105,13 @@ impl Upcast<dyn SourceDb> for RootDatabase {
 }
 
 #[salsa::db]
-impl SemanticDb for RootDatabase {
+impl SemanticDb for ProjectDatabase {
     fn is_file_open(&self, file: File) -> bool {
-        let Some(workspace) = &self.workspace else {
+        let Some(project) = &self.project else {
             return false;
         };
 
-        workspace.is_file_open(self, file)
+        project.is_file_open(self, file)
     }
 
     fn rule_selection(&self) -> &RuleSelection {
@@ -123,7 +124,7 @@ impl SemanticDb for RootDatabase {
 }
 
 #[salsa::db]
-impl SourceDb for RootDatabase {
+impl SourceDb for ProjectDatabase {
     fn vendored(&self) -> &VendoredFileSystem {
         red_knot_vendored::file_system()
     }
@@ -138,7 +139,7 @@ impl SourceDb for RootDatabase {
 }
 
 #[salsa::db]
-impl salsa::Database for RootDatabase {
+impl salsa::Database for ProjectDatabase {
     fn salsa_event(&self, event: &dyn Fn() -> Event) {
         if !tracing::enabled!(tracing::Level::TRACE) {
             return;
@@ -154,9 +155,9 @@ impl salsa::Database for RootDatabase {
 }
 
 #[salsa::db]
-impl Db for RootDatabase {
-    fn workspace(&self) -> Workspace {
-        self.workspace.unwrap()
+impl Db for ProjectDatabase {
+    fn project(&self) -> Project {
+        self.project.unwrap()
     }
 }
 
@@ -174,7 +175,7 @@ pub(crate) mod tests {
     use ruff_db::{Db as SourceDb, Upcast};
 
     use crate::db::Db;
-    use crate::workspace::{Workspace, WorkspaceMetadata};
+    use crate::project::{Project, ProjectMetadata};
     use crate::DEFAULT_LINT_REGISTRY;
 
     #[salsa::db]
@@ -186,11 +187,11 @@ pub(crate) mod tests {
         system: TestSystem,
         vendored: VendoredFileSystem,
         rule_selection: RuleSelection,
-        workspace: Option<Workspace>,
+        project: Option<Project>,
     }
 
     impl TestDb {
-        pub(crate) fn new(workspace: WorkspaceMetadata) -> Self {
+        pub(crate) fn new(project: ProjectMetadata) -> Self {
             let mut db = Self {
                 storage: salsa::Storage::default(),
                 system: TestSystem::default(),
@@ -198,11 +199,11 @@ pub(crate) mod tests {
                 files: Files::default(),
                 events: Arc::default(),
                 rule_selection: RuleSelection::from_registry(&DEFAULT_LINT_REGISTRY),
-                workspace: None,
+                project: None,
             };
 
-            let workspace = Workspace::from_metadata(&db, workspace);
-            db.workspace = Some(workspace);
+            let project = Project::from_metadata(&db, project);
+            db.project = Some(project);
             db
         }
     }
@@ -280,8 +281,8 @@ pub(crate) mod tests {
 
     #[salsa::db]
     impl Db for TestDb {
-        fn workspace(&self) -> Workspace {
-            self.workspace.unwrap()
+        fn project(&self) -> Project {
+            self.project.unwrap()
         }
     }
 

crates/red_knot_workspace/src/db/changes.rs

@@ -1,8 +1,7 @@
-use crate::db::{Db, RootDatabase};
-use crate::watch;
+use crate::db::{Db, ProjectDatabase};
+use crate::project::settings::Configuration;
+use crate::project::{Project, ProjectMetadata};
 use crate::watch::{ChangeEvent, CreatedKind, DeletedKind};
-use crate::workspace::settings::Configuration;
-use crate::workspace::{Workspace, WorkspaceMetadata};
 use red_knot_python_semantic::Program;
 use ruff_db::files::{system_path_to_file, File, Files};
 use ruff_db::system::walk_directory::WalkState;
@@ -10,25 +9,24 @@ use ruff_db::system::SystemPath;
 use ruff_db::Db as _;
 use rustc_hash::FxHashSet;
 
-impl RootDatabase {
+impl ProjectDatabase {
     #[tracing::instrument(level = "debug", skip(self, changes, base_configuration))]
     pub fn apply_changes(
         &mut self,
-        changes: Vec<watch::ChangeEvent>,
+        changes: Vec<ChangeEvent>,
         base_configuration: Option<&Configuration>,
     ) {
-        let mut workspace = self.workspace();
-        let workspace_path = workspace.root(self).to_path_buf();
+        let mut project = self.project();
+        let project_path = project.root(self).to_path_buf();
         let program = Program::get(self);
         let custom_stdlib_versions_path = program
             .custom_stdlib_search_path(self)
             .map(|path| path.join("VERSIONS"));
 
-        let mut workspace_change = false;
+        // Are there structural changes to the project
+        let mut project_changed = false;
         // Changes to a custom stdlib path's VERSIONS
         let mut custom_stdlib_change = false;
-        // Packages that need reloading
-        let mut changed_packages = FxHashSet::default();
         // Paths that were added
         let mut added_paths = FxHashSet::default();
 
@@ -36,13 +34,13 @@ impl RootDatabase {
         let mut synced_files = FxHashSet::default();
         let mut synced_recursively = FxHashSet::default();
 
-        let mut sync_path = |db: &mut RootDatabase, path: &SystemPath| {
+        let mut sync_path = |db: &mut ProjectDatabase, path: &SystemPath| {
             if synced_files.insert(path.to_path_buf()) {
                 File::sync_path(db, path);
             }
         };
 
-        let mut sync_recursively = |db: &mut RootDatabase, path: &SystemPath| {
+        let mut sync_recursively = |db: &mut ProjectDatabase, path: &SystemPath| {
             if synced_recursively.insert(path.to_path_buf()) {
                 Files::sync_recursively(db, path);
             }
@@ -54,19 +52,8 @@ impl RootDatabase {
                     path.file_name(),
                     Some(".gitignore" | ".ignore" | "ruff.toml" | ".ruff.toml" | "pyproject.toml")
                 ) {
-                    // Changes to ignore files or settings can change the workspace structure or add/remove files
-                    // from packages.
-                    if let Some(package) = workspace.package(self, path) {
-                        if package.root(self) == workspace.root(self)
-                            || matches!(change, ChangeEvent::Deleted { .. })
-                        {
-                            workspace_change = true;
-                        }
-
-                        changed_packages.insert(package);
-                    } else {
-                        workspace_change = true;
-                    }
+                    // Changes to ignore files or settings can change the project structure or add/remove files.
+                    project_changed = true;
 
                     continue;
                 }
@@ -77,10 +64,11 @@ impl RootDatabase {
             }
 
             match change {
-                watch::ChangeEvent::Changed { path, kind: _ }
-                | watch::ChangeEvent::Opened(path) => sync_path(self, &path),
+                ChangeEvent::Changed { path, kind: _ } | ChangeEvent::Opened(path) => {
+                    sync_path(self, &path);
+                }
 
-                watch::ChangeEvent::Created { kind, path } => {
+                ChangeEvent::Created { kind, path } => {
                     match kind {
                         CreatedKind::File => sync_path(self, &path),
                         CreatedKind::Directory | CreatedKind::Any => {
@@ -97,7 +85,7 @@ impl RootDatabase {
                     }
                 }
 
-                watch::ChangeEvent::Deleted { kind, path } => {
+                ChangeEvent::Deleted { kind, path } => {
                     let is_file = match kind {
                         DeletedKind::File => true,
                         DeletedKind::Directory => {
@@ -113,10 +101,8 @@ impl RootDatabase {
                     if is_file {
                         sync_path(self, &path);
 
-                        if let Some(package) = workspace.package(self, &path) {
-                            if let Some(file) = self.files().try_system(self, &path) {
-                                package.remove_file(self, file);
-                            }
+                        if let Some(file) = self.files().try_system(self, &path) {
+                            project.remove_file(self, file);
                         }
                     } else {
                         sync_recursively(self, &path);
@@ -128,69 +114,68 @@ impl RootDatabase {
                             custom_stdlib_change = true;
                         }
 
-                        if let Some(package) = workspace.package(self, &path) {
-                            changed_packages.insert(package);
-                        } else {
-                            workspace_change = true;
-                        }
+                        // Perform a full-reload in case the deleted directory contained the pyproject.toml.
+                        // We may want to make this more clever in the future, to e.g. iterate over the
+                        // indexed files and remove the once that start with the same path, unless
+                        // the deleted path is the project configuration.
+                        project_changed = true;
                     }
                 }
 
-                watch::ChangeEvent::CreatedVirtual(path)
-                | watch::ChangeEvent::ChangedVirtual(path) => {
+                ChangeEvent::CreatedVirtual(path) | ChangeEvent::ChangedVirtual(path) => {
                     File::sync_virtual_path(self, &path);
                 }
 
-                watch::ChangeEvent::DeletedVirtual(path) => {
+                ChangeEvent::DeletedVirtual(path) => {
                     if let Some(virtual_file) = self.files().try_virtual_file(&path) {
                         virtual_file.close(self);
                     }
                 }
 
-                watch::ChangeEvent::Rescan => {
-                    workspace_change = true;
+                ChangeEvent::Rescan => {
+                    project_changed = true;
                     Files::sync_all(self);
                     break;
                 }
             }
         }
 
-        if workspace_change {
-            match WorkspaceMetadata::discover(&workspace_path, self.system(), base_configuration) {
+        if project_changed {
+            match ProjectMetadata::discover(&project_path, self.system(), base_configuration) {
                 Ok(metadata) => {
-                    if metadata.root() == workspace.root(self) {
-                        tracing::debug!("Reloading workspace after structural change");
-                        // TODO: Handle changes in the program settings.
-                        workspace.reload(self, metadata);
+                    let program_settings = metadata.to_program_settings();
+
+                    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");
+                        project.reload(self, metadata);
                     } else {
-                        tracing::debug!("Replace workspace after structural change");
-                        workspace = Workspace::from_metadata(self, metadata);
-                        self.workspace = Some(workspace);
+                        tracing::debug!("Replace project after structural change");
+                        project = Project::from_metadata(self, metadata);
+                        self.project = Some(project);
                     }
                 }
                 Err(error) => {
                     tracing::error!(
-                        "Failed to load workspace, keeping old workspace configuration: {error}"
+                        "Failed to load project, keeping old project configuration: {error}"
                     );
                 }
             }
 
             return;
         } else if custom_stdlib_change {
-            let search_paths = workspace.search_path_settings(self).clone();
+            let search_paths = project.metadata(self).to_program_settings().search_paths;
+
             if let Err(error) = program.update_search_paths(self, &search_paths) {
                 tracing::error!("Failed to set the new search paths: {error}");
             }
         }
 
-        let mut added_paths = added_paths.into_iter().filter(|path| {
-            let Some(package) = workspace.package(self, path) else {
-                return false;
-            };
-
-            // Skip packages that need reloading
-            !changed_packages.contains(&package)
-        });
+        let mut added_paths = added_paths.into_iter();
 
         // Use directory walking to discover newly added files.
         if let Some(path) = added_paths.next() {
@@ -221,18 +206,12 @@ impl RootDatabase {
             });
 
             for path in added_paths.into_inner().unwrap() {
-                let package = workspace.package(self, &path);
                 let file = system_path_to_file(self, &path);
 
-                if let (Some(package), Ok(file)) = (package, file) {
-                    package.add_file(self, file);
+                if let Ok(file) = file {
+                    project.add_file(self, file);
                 }
             }
         }
-
-        // Reload
-        for package in changed_packages {
-            package.reload_files(self);
-        }
     }
 }

crates/red_knot_workspace/src/lib.rs

@@ -2,8 +2,8 @@ use red_knot_python_semantic::lint::{LintRegistry, LintRegistryBuilder};
 use red_knot_python_semantic::register_lints;
 
 pub mod db;
+pub mod project;
 pub mod watch;
-pub mod workspace;
 
 pub static DEFAULT_LINT_REGISTRY: std::sync::LazyLock<LintRegistry> =
     std::sync::LazyLock::new(default_lints_registry);

crates/red_knot_workspace/src/project.rs

@@ -0,0 +1,459 @@
+#![allow(clippy::ref_option)]
+
+use crate::db::Db;
+use crate::db::ProjectDatabase;
+use crate::project::files::{Index, Indexed, IndexedFiles, IndexedIter};
+pub use metadata::{ProjectDiscoveryError, ProjectMetadata};
+
+use red_knot_python_semantic::types::check_types;
+use ruff_db::diagnostic::{Diagnostic, DiagnosticId, ParseDiagnostic, Severity};
+use ruff_db::parsed::parsed_module;
+use ruff_db::source::{source_text, SourceTextError};
+use ruff_db::system::FileType;
+use ruff_db::{
+    files::{system_path_to_file, File},
+    system::{walk_directory::WalkState, SystemPath},
+};
+use ruff_python_ast::PySourceType;
+use ruff_text_size::TextRange;
+use rustc_hash::{FxBuildHasher, FxHashSet};
+use salsa::{Durability, Setter as _};
+use std::borrow::Cow;
+use std::sync::Arc;
+
+mod files;
+mod metadata;
+mod pyproject;
+pub mod settings;
+
+/// The project as a Salsa ingredient.
+///
+/// ## How is a project different from a program?
+/// There are two (related) motivations:
+///
+/// 1. Program is defined in `ruff_db` and it can't reference the settings types for the linter and formatter
+///    without introducing a cyclic dependency. The project is defined in a higher level crate
+///    where it can reference these setting types.
+/// 2. Running `ruff check` with different target versions results in different programs (settings) but
+///    it remains the same project. That's why program is a narrowed view of the project only
+///    holding on to the most fundamental settings required for checking.
+#[salsa::input]
+pub struct Project {
+    /// The files that are open in the project.
+    ///
+    /// Setting the open files to a non-`None` value changes `check` to only check the
+    /// open files rather than all files in the project.
+    #[return_ref]
+    #[default]
+    open_fileset: Option<Arc<FxHashSet<File>>>,
+
+    /// The first-party files of this project.
+    #[default]
+    #[return_ref]
+    file_set: IndexedFiles,
+
+    /// The metadata describing the project, including the unresolved configuration.
+    #[return_ref]
+    pub metadata: ProjectMetadata,
+}
+
+impl Project {
+    pub fn from_metadata(db: &dyn Db, metadata: ProjectMetadata) -> Self {
+        Project::builder(metadata)
+            .durability(Durability::MEDIUM)
+            .open_fileset_durability(Durability::LOW)
+            .file_set_durability(Durability::LOW)
+            .new(db)
+    }
+
+    pub fn root(self, db: &dyn Db) -> &SystemPath {
+        self.metadata(db).root()
+    }
+
+    pub fn name(self, db: &dyn Db) -> &str {
+        self.metadata(db).name()
+    }
+
+    pub fn reload(self, db: &mut dyn Db, metadata: ProjectMetadata) {
+        tracing::debug!("Reloading project");
+        assert_eq!(self.root(db), metadata.root());
+
+        if &metadata != self.metadata(db) {
+            self.set_metadata(db).to(metadata);
+        }
+
+        self.reload_files(db);
+    }
+
+    /// Checks all open files in the project and its dependencies.
+    pub fn check(self, db: &ProjectDatabase) -> Vec<Box<dyn Diagnostic>> {
+        let project_span = tracing::debug_span!("Project::check");
+        let _span = project_span.enter();
+
+        tracing::debug!("Checking project '{name}'", name = self.name(db));
+        let result = Arc::new(std::sync::Mutex::new(Vec::new()));
+        let inner_result = Arc::clone(&result);
+
+        let db = db.clone();
+        let project_span = project_span.clone();
+
+        rayon::scope(move |scope| {
+            let files = ProjectFiles::new(&db, self);
+            for file in &files {
+                let result = inner_result.clone();
+                let db = db.clone();
+                let project_span = project_span.clone();
+
+                scope.spawn(move |_| {
+                    let check_file_span = tracing::debug_span!(parent: &project_span, "check_file", file=%file.path(&db));
+                    let _entered = check_file_span.entered();
+
+                    let file_diagnostics = check_file(&db, file);
+                    result.lock().unwrap().extend(file_diagnostics);
+                });
+            }
+        });
+
+        Arc::into_inner(result).unwrap().into_inner().unwrap()
+    }
+
+    /// Opens a file in the project.
+    ///
+    /// This changes the behavior of `check` to only check the open files rather than all files in the project.
+    pub fn open_file(self, db: &mut dyn Db, file: File) {
+        tracing::debug!("Opening file `{}`", file.path(db));
+
+        let mut open_files = self.take_open_files(db);
+        open_files.insert(file);
+        self.set_open_files(db, open_files);
+    }
+
+    /// Closes a file in the project.
+    pub fn close_file(self, db: &mut dyn Db, file: File) -> bool {
+        tracing::debug!("Closing file `{}`", file.path(db));
+
+        let mut open_files = self.take_open_files(db);
+        let removed = open_files.remove(&file);
+
+        if removed {
+            self.set_open_files(db, open_files);
+        }
+
+        removed
+    }
+
+    /// Returns the open files in the project or `None` if the entire project should be checked.
+    pub fn open_files(self, db: &dyn Db) -> Option<&FxHashSet<File>> {
+        self.open_fileset(db).as_deref()
+    }
+
+    /// Sets the open files in the project.
+    ///
+    /// This changes the behavior of `check` to only check the open files rather than all files in the project.
+    #[tracing::instrument(level = "debug", skip(self, db))]
+    pub fn set_open_files(self, db: &mut dyn Db, open_files: FxHashSet<File>) {
+        tracing::debug!("Set open project files (count: {})", open_files.len());
+
+        self.set_open_fileset(db).to(Some(Arc::new(open_files)));
+    }
+
+    /// This takes the open files from the project and returns them.
+    ///
+    /// This changes the behavior of `check` to check all files in the project instead of just the open files.
+    fn take_open_files(self, db: &mut dyn Db) -> FxHashSet<File> {
+        tracing::debug!("Take open project files");
+
+        // Salsa will cancel any pending queries and remove its own reference to `open_files`
+        // so that the reference counter to `open_files` now drops to 1.
+        let open_files = self.set_open_fileset(db).to(None);
+
+        if let Some(open_files) = open_files {
+            Arc::try_unwrap(open_files).unwrap()
+        } else {
+            FxHashSet::default()
+        }
+    }
+
+    /// Returns `true` if the file is open in the project.
+    ///
+    /// A file is considered open when:
+    /// * explicitly set as an open file using [`open_file`](Self::open_file)
+    /// * It has a [`SystemPath`] and belongs to a package's `src` files
+    /// * It has a [`SystemVirtualPath`](ruff_db::system::SystemVirtualPath)
+    pub fn is_file_open(self, db: &dyn Db, file: File) -> bool {
+        if let Some(open_files) = self.open_files(db) {
+            open_files.contains(&file)
+        } else if file.path(db).is_system_path() {
+            self.contains_file(db, file)
+        } else {
+            file.path(db).is_system_virtual_path()
+        }
+    }
+
+    /// Returns `true` if `file` is a first-party file part of this package.
+    pub fn contains_file(self, db: &dyn Db, file: File) -> bool {
+        self.files(db).contains(&file)
+    }
+
+    #[tracing::instrument(level = "debug", skip(db))]
+    pub fn remove_file(self, db: &mut dyn Db, file: File) {
+        tracing::debug!(
+            "Removing file `{}` from project `{}`",
+            file.path(db),
+            self.name(db)
+        );
+
+        let Some(mut index) = IndexedFiles::indexed_mut(db, self) else {
+            return;
+        };
+
+        index.remove(file);
+    }
+
+    pub fn add_file(self, db: &mut dyn Db, file: File) {
+        tracing::debug!(
+            "Adding file `{}` to project `{}`",
+            file.path(db),
+            self.name(db)
+        );
+
+        let Some(mut index) = IndexedFiles::indexed_mut(db, self) else {
+            return;
+        };
+
+        index.insert(file);
+    }
+
+    /// Returns the files belonging to this project.
+    pub fn files(self, db: &dyn Db) -> Indexed<'_> {
+        let files = self.file_set(db);
+
+        let indexed = match files.get() {
+            Index::Lazy(vacant) => {
+                let _entered =
+                    tracing::debug_span!("Project::index_files", package = %self.name(db))
+                        .entered();
+
+                let files = discover_project_files(db, self);
+                tracing::info!("Found {} files in project `{}`", files.len(), self.name(db));
+                vacant.set(files)
+            }
+            Index::Indexed(indexed) => indexed,
+        };
+
+        indexed
+    }
+
+    pub fn reload_files(self, db: &mut dyn Db) {
+        tracing::debug!("Reloading files for project `{}`", self.name(db));
+
+        if !self.file_set(db).is_lazy() {
+            // Force a re-index of the files in the next revision.
+            self.set_file_set(db).to(IndexedFiles::lazy());
+        }
+    }
+}
+
+pub(super) fn check_file(db: &dyn Db, file: File) -> Vec<Box<dyn Diagnostic>> {
+    let mut diagnostics: Vec<Box<dyn Diagnostic>> = Vec::new();
+    // Abort checking if there are IO errors.
+    let source = source_text(db.upcast(), file);
+
+    if let Some(read_error) = source.read_error() {
+        diagnostics.push(Box::new(IOErrorDiagnostic {
+            file,
+            error: read_error.clone(),
+        }));
+        return diagnostics;
+    }
+
+    let parsed = parsed_module(db.upcast(), file);
+    diagnostics.extend(parsed.errors().iter().map(|error| {
+        let diagnostic: Box<dyn Diagnostic> = Box::new(ParseDiagnostic::new(file, error.clone()));
+        diagnostic
+    }));
+
+    diagnostics.extend(check_types(db.upcast(), file).iter().map(|diagnostic| {
+        let boxed: Box<dyn Diagnostic> = Box::new(diagnostic.clone());
+        boxed
+    }));
+
+    diagnostics.sort_unstable_by_key(|diagnostic| diagnostic.range().unwrap_or_default().start());
+
+    diagnostics
+}
+
+fn discover_project_files(db: &dyn Db, project: Project) -> FxHashSet<File> {
+    let paths = std::sync::Mutex::new(Vec::new());
+
+    db.system().walk_directory(project.root(db)).run(|| {
+        Box::new(|entry| {
+            match entry {
+                Ok(entry) => {
+                    // Skip over any non python files to avoid creating too many entries in `Files`.
+                    match entry.file_type() {
+                        FileType::File => {
+                            if entry
+                                .path()
+                                .extension()
+                                .and_then(PySourceType::try_from_extension)
+                                .is_some()
+                            {
+                                let mut paths = paths.lock().unwrap();
+                                paths.push(entry.into_path());
+                            }
+                        }
+                        FileType::Directory | FileType::Symlink => {}
+                    }
+                }
+                Err(error) => {
+                    // TODO Handle error
+                    tracing::error!("Failed to walk path: {error}");
+                }
+            }
+
+            WalkState::Continue
+        })
+    });
+
+    let paths = paths.into_inner().unwrap();
+    let mut files = FxHashSet::with_capacity_and_hasher(paths.len(), FxBuildHasher);
+
+    for path in paths {
+        // If this returns `None`, then the file was deleted between the `walk_directory` call and now.
+        // We can ignore this.
+        if let Ok(file) = system_path_to_file(db.upcast(), &path) {
+            files.insert(file);
+        }
+    }
+
+    files
+}
+
+#[derive(Debug)]
+enum ProjectFiles<'a> {
+    OpenFiles(&'a FxHashSet<File>),
+    Indexed(Indexed<'a>),
+}
+
+impl<'a> ProjectFiles<'a> {
+    fn new(db: &'a dyn Db, project: Project) -> Self {
+        if let Some(open_files) = project.open_files(db) {
+            ProjectFiles::OpenFiles(open_files)
+        } else {
+            ProjectFiles::Indexed(project.files(db))
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a ProjectFiles<'a> {
+    type Item = File;
+    type IntoIter = ProjectFilesIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        match self {
+            ProjectFiles::OpenFiles(files) => ProjectFilesIter::OpenFiles(files.iter()),
+            ProjectFiles::Indexed(indexed) => ProjectFilesIter::Indexed {
+                files: indexed.into_iter(),
+            },
+        }
+    }
+}
+
+enum ProjectFilesIter<'db> {
+    OpenFiles(std::collections::hash_set::Iter<'db, File>),
+    Indexed { files: IndexedIter<'db> },
+}
+
+impl Iterator for ProjectFilesIter<'_> {
+    type Item = File;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            ProjectFilesIter::OpenFiles(files) => files.next().copied(),
+            ProjectFilesIter::Indexed { files } => files.next(),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct IOErrorDiagnostic {
+    file: File,
+    error: SourceTextError,
+}
+
+impl Diagnostic for IOErrorDiagnostic {
+    fn id(&self) -> DiagnosticId {
+        DiagnosticId::Io
+    }
+
+    fn message(&self) -> Cow<str> {
+        self.error.to_string().into()
+    }
+
+    fn file(&self) -> File {
+        self.file
+    }
+
+    fn range(&self) -> Option<TextRange> {
+        None
+    }
+
+    fn severity(&self) -> Severity {
+        Severity::Error
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::db::tests::TestDb;
+    use crate::project::{check_file, ProjectMetadata};
+    use red_knot_python_semantic::types::check_types;
+    use ruff_db::diagnostic::Diagnostic;
+    use ruff_db::files::system_path_to_file;
+    use ruff_db::source::source_text;
+    use ruff_db::system::{DbWithTestSystem, SystemPath, SystemPathBuf};
+    use ruff_db::testing::assert_function_query_was_not_run;
+    use ruff_python_ast::name::Name;
+
+    #[test]
+    fn check_file_skips_type_checking_when_file_cant_be_read() -> ruff_db::system::Result<()> {
+        let project = ProjectMetadata::new(Name::new_static("test"), SystemPathBuf::from("/"));
+        let mut db = TestDb::new(project);
+        let path = SystemPath::new("test.py");
+
+        db.write_file(path, "x = 10")?;
+        let file = system_path_to_file(&db, path).unwrap();
+
+        // Now the file gets deleted before we had a chance to read its source text.
+        db.memory_file_system().remove_file(path)?;
+        file.sync(&mut db);
+
+        assert_eq!(source_text(&db, file).as_str(), "");
+        assert_eq!(
+            check_file(&db, file)
+                .into_iter()
+                .map(|diagnostic| diagnostic.message().into_owned())
+                .collect::<Vec<_>>(),
+            vec!["Failed to read file: No such file or directory".to_string()]
+        );
+
+        let events = db.take_salsa_events();
+        assert_function_query_was_not_run(&db, check_types, file, &events);
+
+        // The user now creates a new file with an empty text. The source text
+        // content returned by `source_text` remains unchanged, but the diagnostics should get updated.
+        db.write_file(path, "").unwrap();
+
+        assert_eq!(source_text(&db, file).as_str(), "");
+        assert_eq!(
+            check_file(&db, file)
+                .into_iter()
+                .map(|diagnostic| diagnostic.message().into_owned())
+                .collect::<Vec<_>>(),
+            vec![] as Vec<String>
+        );
+
+        Ok(())
+    }
+}

crates/red_knot_workspace/src/project/files.rs

@@ -8,12 +8,12 @@ use salsa::Setter;
 use ruff_db::files::File;
 
 use crate::db::Db;
-use crate::workspace::Package;
+use crate::project::Project;
 
 /// Cheap cloneable hash set of files.
 type FileSet = Arc<FxHashSet<File>>;
 
-/// The indexed files of a package.
+/// The indexed files of a project.
 ///
 /// The indexing happens lazily, but the files are then cached for subsequent reads.
 ///
@@ -24,11 +24,11 @@ type FileSet = Arc<FxHashSet<File>>;
 /// the indexed files must go through `IndexedMut`, which uses the Salsa setter `package.set_file_set` to
 /// ensure that Salsa always knows when the set of indexed files have changed.
 #[derive(Debug)]
-pub struct PackageFiles {
+pub struct IndexedFiles {
     state: std::sync::Mutex<State>,
 }
 
-impl PackageFiles {
+impl IndexedFiles {
     pub fn lazy() -> Self {
         Self {
             state: std::sync::Mutex::new(State::Lazy),
@@ -60,7 +60,7 @@ impl PackageFiles {
     /// Returns a mutable view on the index that allows cheap in-place mutations.
     ///
     /// The changes are automatically written back to the database once the view is dropped.
-    pub(super) fn indexed_mut(db: &mut dyn Db, package: Package) -> Option<IndexedMut> {
+    pub(super) fn indexed_mut(db: &mut dyn Db, project: Project) -> Option<IndexedMut> {
         // Calling `zalsa_mut` cancels all pending salsa queries. This ensures that there are no pending
         // reads to the file set.
         // TODO: Use a non-internal API instead https://salsa.zulipchat.com/#narrow/stream/333573-salsa-3.2E0/topic/Expose.20an.20API.20to.20cancel.20other.20queries
@@ -79,7 +79,7 @@ impl PackageFiles {
         //   all clones must have been dropped at this point and the `Indexed`
         //   can't outlive the database (constrained by the `db` lifetime).
         let state = {
-            let files = package.file_set(db);
+            let files = project.file_set(db);
             let mut locked = files.state.lock().unwrap();
             std::mem::replace(&mut *locked, State::Lazy)
         };
@@ -93,14 +93,14 @@ impl PackageFiles {
 
         Some(IndexedMut {
             db: Some(db),
-            package,
+            project,
             files: indexed,
             did_change: false,
         })
     }
 }
 
-impl Default for PackageFiles {
+impl Default for IndexedFiles {
     fn default() -> Self {
         Self::lazy()
     }
@@ -142,7 +142,7 @@ impl<'db> LazyFiles<'db> {
 /// The indexed files of a package.
 ///
 /// Note: This type is intentionally non-cloneable. Making it cloneable requires
-/// revisiting the locking behavior in [`PackageFiles::indexed_mut`].
+/// revisiting the locking behavior in [`IndexedFiles::indexed_mut`].
 #[derive(Debug, PartialEq, Eq)]
 pub struct Indexed<'db> {
     files: FileSet,
@@ -169,13 +169,13 @@ impl<'a> IntoIterator for &'a Indexed<'_> {
     }
 }
 
-/// A Mutable view of a package's indexed files.
+/// A Mutable view of a project's indexed files.
 ///
 /// Allows in-place mutation of the files without deep cloning the hash set.
 /// The changes are written back when the mutable view is dropped or by calling [`Self::set`] manually.
 pub(super) struct IndexedMut<'db> {
     db: Option<&'db mut dyn Db>,
-    package: Package,
+    project: Project,
     files: FileSet,
     did_change: bool,
 }
@@ -212,12 +212,12 @@ impl IndexedMut<'_> {
 
         if self.did_change {
             // If there are changes, set the new file_set to trigger a salsa revision change.
-            self.package
+            self.project
                 .set_file_set(db)
-                .to(PackageFiles::indexed(files));
+                .to(IndexedFiles::indexed(files));
         } else {
             // The `indexed_mut` replaced the `state` with Lazy. Restore it back to the indexed state.
-            *self.package.file_set(db).state.lock().unwrap() = State::Indexed(files);
+            *self.project.file_set(db).state.lock().unwrap() = State::Indexed(files);
         }
     }
 }
@@ -234,30 +234,24 @@ mod tests {
 
     use crate::db::tests::TestDb;
     use crate::db::Db;
-    use crate::workspace::files::Index;
-    use crate::workspace::WorkspaceMetadata;
+    use crate::project::files::Index;
+    use crate::project::ProjectMetadata;
     use ruff_db::files::system_path_to_file;
     use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
     use ruff_python_ast::name::Name;
 
     #[test]
     fn re_entrance() -> anyhow::Result<()> {
-        let metadata = WorkspaceMetadata::single_package(
-            Name::new_static("test"),
-            SystemPathBuf::from("/test"),
-        );
+        let metadata = ProjectMetadata::new(Name::new_static("test"), SystemPathBuf::from("/test"));
         let mut db = TestDb::new(metadata);
 
         db.write_file("test.py", "")?;
 
-        let package = db
-            .workspace()
-            .package(&db, "/test")
-            .expect("test package to exist");
+        let project = db.project();
 
         let file = system_path_to_file(&db, "test.py").unwrap();
 
-        let files = match package.file_set(&db).get() {
+        let files = match project.file_set(&db).get() {
             Index::Lazy(lazy) => lazy.set(FxHashSet::from_iter([file])),
             Index::Indexed(files) => files,
         };
@@ -265,7 +259,7 @@ mod tests {
         // Calling files a second time should not dead-lock.
         // This can e.g. happen when `check_file` iterates over all files and
         // `is_file_open` queries the open files.
-        let files_2 = package.file_set(&db).get();
+        let files_2 = project.file_set(&db).get();
 
         match files_2 {
             Index::Lazy(_) => {

crates/red_knot_workspace/src/project/metadata.rs

@@ -0,0 +1,418 @@
+use ruff_db::system::{System, SystemPath, SystemPathBuf};
+use ruff_python_ast::name::Name;
+
+use crate::project::pyproject::{PyProject, PyProjectError};
+use crate::project::settings::Configuration;
+use red_knot_python_semantic::ProgramSettings;
+use thiserror::Error;
+
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(test, derive(serde::Serialize))]
+pub struct ProjectMetadata {
+    pub(super) name: Name,
+
+    pub(super) root: SystemPathBuf,
+
+    /// The resolved settings for this project.
+    pub(super) configuration: Configuration,
+}
+
+impl ProjectMetadata {
+    /// Creates a project with the given name and root that uses the default configuration options.
+    pub fn new(name: Name, root: SystemPathBuf) -> Self {
+        Self {
+            name,
+            root,
+            configuration: Configuration::default(),
+        }
+    }
+
+    /// Loads a project from a `pyproject.toml` file.
+    pub(crate) fn from_pyproject(
+        pyproject: PyProject,
+        root: SystemPathBuf,
+        base_configuration: Option<&Configuration>,
+    ) -> Self {
+        let name = pyproject.project.and_then(|project| project.name);
+        let name = name
+            .map(|name| Name::new(&*name))
+            .unwrap_or_else(|| Name::new(root.file_name().unwrap_or("root")));
+
+        // TODO: load configuration from pyrpoject.toml
+        let mut configuration = Configuration::default();
+
+        if let Some(base_configuration) = base_configuration {
+            configuration.extend(base_configuration.clone());
+        }
+
+        Self {
+            name,
+            root,
+            configuration,
+        }
+    }
+
+    /// Discovers the closest project at `path` and returns its metadata.
+    ///
+    /// The algorithm traverses upwards in the `path`'s ancestor chain and uses the following precedence
+    /// the resolve the project's root.
+    ///
+    /// 1. The closest `pyproject.toml` with a `tool.knot` section.
+    /// 1. The closest `pyproject.toml`.
+    /// 1. Fallback to use `path` as the root and use the default settings.
+    pub fn discover(
+        path: &SystemPath,
+        system: &dyn System,
+        base_configuration: Option<&Configuration>,
+    ) -> Result<ProjectMetadata, ProjectDiscoveryError> {
+        tracing::debug!("Searching for a project in '{path}'");
+
+        if !system.is_directory(path) {
+            return Err(ProjectDiscoveryError::NotADirectory(path.to_path_buf()));
+        }
+
+        let mut closest_project: Option<ProjectMetadata> = None;
+
+        for ancestor in path.ancestors() {
+            let pyproject_path = ancestor.join("pyproject.toml");
+            if let Ok(pyproject_str) = system.read_to_string(&pyproject_path) {
+                let pyproject = PyProject::from_str(&pyproject_str).map_err(|error| {
+                    ProjectDiscoveryError::InvalidPyProject {
+                        path: pyproject_path,
+                        source: Box::new(error),
+                    }
+                })?;
+
+                let has_knot_section = pyproject.knot().is_some();
+                let metadata = ProjectMetadata::from_pyproject(
+                    pyproject,
+                    ancestor.to_path_buf(),
+                    base_configuration,
+                );
+
+                if has_knot_section {
+                    let project_root = ancestor;
+                    tracing::debug!("Found project at '{}'", project_root);
+
+                    return Ok(metadata);
+                }
+
+                // Not a project itself, keep looking for an enclosing project.
+                if closest_project.is_none() {
+                    closest_project = Some(metadata);
+                }
+            }
+        }
+
+        // No project found, but maybe a pyproject.toml was found.
+        let metadata = if let Some(closest_project) = closest_project {
+            tracing::debug!(
+                "Project without `tool.knot` section: '{}'",
+                closest_project.root()
+            );
+
+            closest_project
+        } else {
+            tracing::debug!("The ancestor directories contain no `pyproject.toml`. Falling back to a virtual project.");
+
+            // Create a package with a default configuration
+            Self {
+                name: path.file_name().unwrap_or("root").into(),
+                root: path.to_path_buf(),
+                // TODO create the configuration from the pyproject toml
+                configuration: base_configuration.cloned().unwrap_or_default(),
+            }
+        };
+
+        Ok(metadata)
+    }
+
+    pub fn root(&self) -> &SystemPath {
+        &self.root
+    }
+
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn configuration(&self) -> &Configuration {
+        &self.configuration
+    }
+
+    pub fn to_program_settings(&self) -> ProgramSettings {
+        self.configuration.to_program_settings(self.root())
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum ProjectDiscoveryError {
+    #[error("project path '{0}' is not a directory")]
+    NotADirectory(SystemPathBuf),
+
+    #[error("{path} is not a valid `pyproject.toml`: {source}")]
+    InvalidPyProject {
+        source: Box<PyProjectError>,
+        path: SystemPathBuf,
+    },
+}
+
+#[cfg(test)]
+mod tests {
+    //! Integration tests for project discovery
+
+    use crate::snapshot_project;
+    use anyhow::{anyhow, Context};
+    use insta::assert_ron_snapshot;
+    use ruff_db::system::{SystemPathBuf, TestSystem};
+
+    use crate::project::{ProjectDiscoveryError, ProjectMetadata};
+
+    #[test]
+    fn project_without_pyproject() -> anyhow::Result<()> {
+        let system = TestSystem::default();
+        let root = SystemPathBuf::from("/app");
+
+        system
+            .memory_file_system()
+            .write_files([(root.join("foo.py"), ""), (root.join("bar.py"), "")])
+            .context("Failed to write files")?;
+
+        let project = ProjectMetadata::discover(&root, &system, None)
+            .context("Failed to discover project")?;
+
+        assert_eq!(project.root(), &*root);
+
+        snapshot_project!(project);
+
+        Ok(())
+    }
+
+    #[test]
+    fn project_with_pyproject() -> anyhow::Result<()> {
+        let system = TestSystem::default();
+        let root = SystemPathBuf::from("/app");
+
+        system
+            .memory_file_system()
+            .write_files([
+                (
+                    root.join("pyproject.toml"),
+                    r#"
+                    [project]
+                    name = "backend"
+
+                    "#,
+                ),
+                (root.join("db/__init__.py"), ""),
+            ])
+            .context("Failed to write files")?;
+
+        let project = ProjectMetadata::discover(&root, &system, None)
+            .context("Failed to discover project")?;
+
+        assert_eq!(project.root(), &*root);
+        snapshot_project!(project);
+
+        // Discovering the same package from a subdirectory should give the same result
+        let from_src = ProjectMetadata::discover(&root.join("db"), &system, None)
+            .context("Failed to discover project from src sub-directory")?;
+
+        assert_eq!(from_src, project);
+
+        Ok(())
+    }
+
+    #[test]
+    fn project_with_invalid_pyproject() -> anyhow::Result<()> {
+        let system = TestSystem::default();
+        let root = SystemPathBuf::from("/app");
+
+        system
+            .memory_file_system()
+            .write_files([
+                (
+                    root.join("pyproject.toml"),
+                    r#"
+                    [project]
+                    name = "backend"
+
+                    [tool.knot
+                    "#,
+                ),
+                (root.join("db/__init__.py"), ""),
+            ])
+            .context("Failed to write files")?;
+
+        let Err(error) = ProjectMetadata::discover(&root, &system, None) else {
+            return Err(anyhow!("Expected project discovery to fail because of invalid syntax in the pyproject.toml"));
+        };
+
+        assert_error_eq(
+            &error,
+            r#"/app/pyproject.toml is not a valid `pyproject.toml`: TOML parse error at line 5, column 31
+  |
+5 |                     [tool.knot
+  |                               ^
+invalid table header
+expected `.`, `]`
+"#,
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn nested_projects_in_sub_project() -> anyhow::Result<()> {
+        let system = TestSystem::default();
+        let root = SystemPathBuf::from("/app");
+
+        system
+            .memory_file_system()
+            .write_files([
+                (
+                    root.join("pyproject.toml"),
+                    r#"
+                    [project]
+                    name = "project-root"
+
+                    [tool.knot]
+                    "#,
+                ),
+                (
+                    root.join("packages/a/pyproject.toml"),
+                    r#"
+                    [project]
+                    name = "nested-project"
+
+                    [tool.knot]
+                    "#,
+                ),
+            ])
+            .context("Failed to write files")?;
+
+        let sub_project = ProjectMetadata::discover(&root.join("packages/a"), &system, None)?;
+
+        snapshot_project!(sub_project);
+
+        Ok(())
+    }
+
+    #[test]
+    fn nested_projects_in_root_project() -> anyhow::Result<()> {
+        let system = TestSystem::default();
+        let root = SystemPathBuf::from("/app");
+
+        system
+            .memory_file_system()
+            .write_files([
+                (
+                    root.join("pyproject.toml"),
+                    r#"
+                    [project]
+                    name = "project-root"
+
+                    [tool.knot]
+                    "#,
+                ),
+                (
+                    root.join("packages/a/pyproject.toml"),
+                    r#"
+                    [project]
+                    name = "nested-project"
+
+                    [tool.knot]
+                    "#,
+                ),
+            ])
+            .context("Failed to write files")?;
+
+        let root = ProjectMetadata::discover(&root, &system, None)?;
+
+        snapshot_project!(root);
+
+        Ok(())
+    }
+
+    #[test]
+    fn nested_projects_without_knot_sections() -> anyhow::Result<()> {
+        let system = TestSystem::default();
+        let root = SystemPathBuf::from("/app");
+
+        system
+            .memory_file_system()
+            .write_files([
+                (
+                    root.join("pyproject.toml"),
+                    r#"
+                    [project]
+                    name = "project-root"
+                    "#,
+                ),
+                (
+                    root.join("packages/a/pyproject.toml"),
+                    r#"
+                    [project]
+                    name = "nested-project"
+                    "#,
+                ),
+            ])
+            .context("Failed to write files")?;
+
+        let sub_project = ProjectMetadata::discover(&root.join("packages/a"), &system, None)?;
+
+        snapshot_project!(sub_project);
+
+        Ok(())
+    }
+
+    #[test]
+    fn nested_projects_with_outer_knot_section() -> anyhow::Result<()> {
+        let system = TestSystem::default();
+        let root = SystemPathBuf::from("/app");
+
+        system
+            .memory_file_system()
+            .write_files([
+                (
+                    root.join("pyproject.toml"),
+                    r#"
+                    [project]
+                    name = "project-root"
+
+                    [tool.knot]
+                    "#,
+                ),
+                (
+                    root.join("packages/a/pyproject.toml"),
+                    r#"
+                    [project]
+                    name = "nested-project"
+                    "#,
+                ),
+            ])
+            .context("Failed to write files")?;
+
+        let root = ProjectMetadata::discover(&root.join("packages/a"), &system, None)?;
+
+        snapshot_project!(root);
+
+        Ok(())
+    }
+
+    #[track_caller]
+    fn assert_error_eq(error: &ProjectDiscoveryError, message: &str) {
+        assert_eq!(error.to_string().replace('\\', "/"), message);
+    }
+
+    /// Snapshots a project but with all paths using unix separators.
+    #[macro_export]
+    macro_rules! snapshot_project {
+    ($project:expr) => {{
+        assert_ron_snapshot!($project,{
+            ".root" => insta::dynamic_redaction(|content, _content_path| {
+                content.as_str().unwrap().replace("\\", "/")
+            }),
+        });
+    }};
+}
+}

crates/red_knot_workspace/src/project/pyproject.rs

@@ -4,9 +4,7 @@ use pep440_rs::{Version, VersionSpecifiers};
 use serde::Deserialize;
 use thiserror::Error;
 
-use crate::workspace::metadata::WorkspaceDiscoveryError;
 pub(crate) use package_name::PackageName;
-use ruff_db::system::SystemPath;
 
 /// A `pyproject.toml` as specified in PEP 517.
 #[derive(Deserialize, Debug, Default, Clone)]
@@ -19,11 +17,8 @@ pub(crate) struct PyProject {
 }
 
 impl PyProject {
-    pub(crate) fn workspace(&self) -> Option<&Workspace> {
-        self.tool
-            .as_ref()
-            .and_then(|tool| tool.knot.as_ref())
-            .and_then(|knot| knot.workspace.as_ref())
+    pub(crate) fn knot(&self) -> Option<&Knot> {
+        self.tool.as_ref().and_then(|tool| tool.knot.as_ref())
     }
 }
 
@@ -62,47 +57,9 @@ pub(crate) struct Tool {
     pub knot: Option<Knot>,
 }
 
+// TODO(micha): Remove allow once we add knot settings.
+//  We can't use a unit struct here or deserializing `[tool.knot]` fails.
+#[allow(clippy::empty_structs_with_brackets)]
 #[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub(crate) struct Knot {
-    pub(crate) workspace: Option<Workspace>,
-}
-
-#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub(crate) struct Workspace {
-    pub(crate) members: Option<Vec<String>>,
-    pub(crate) exclude: Option<Vec<String>>,
-}
-
-impl Workspace {
-    pub(crate) fn members(&self) -> &[String] {
-        self.members.as_deref().unwrap_or_default()
-    }
-
-    pub(crate) fn exclude(&self) -> &[String] {
-        self.exclude.as_deref().unwrap_or_default()
-    }
-
-    pub(crate) fn is_excluded(
-        &self,
-        path: &SystemPath,
-        workspace_root: &SystemPath,
-    ) -> Result<bool, WorkspaceDiscoveryError> {
-        for exclude in self.exclude() {
-            let full_glob =
-                glob::Pattern::new(workspace_root.join(exclude).as_str()).map_err(|error| {
-                    WorkspaceDiscoveryError::InvalidMembersPattern {
-                        raw_glob: exclude.clone(),
-                        source: error,
-                    }
-                })?;
-
-            if full_glob.matches_path(path.as_std_path()) {
-                return Ok(true);
-            }
-        }
-
-        Ok(false)
-    }
-}
+pub(crate) struct Knot {}

crates/red_knot_workspace/src/project/settings.rs

@@ -1,4 +1,3 @@
-use crate::workspace::PackageMetadata;
 use red_knot_python_semantic::{
     ProgramSettings, PythonPlatform, PythonVersion, SearchPathSettings, SitePackages,
 };
@@ -9,17 +8,17 @@ use ruff_db::system::{SystemPath, SystemPathBuf};
 /// The main difference to [`Configuration`] is that default values are filled in.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(test, derive(serde::Serialize))]
-pub struct WorkspaceSettings {
+pub struct ProjectSettings {
     pub(super) program: ProgramSettings,
 }
 
-impl WorkspaceSettings {
+impl ProjectSettings {
     pub fn program(&self) -> &ProgramSettings {
         &self.program
     }
 }
 
-/// The configuration for the workspace or a package.
+/// The configuration for the project or a package.
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 #[cfg_attr(test, derive(serde::Serialize))]
 pub struct Configuration {
@@ -34,17 +33,11 @@ impl Configuration {
         self.search_paths.extend(with.search_paths);
     }
 
-    pub fn to_workspace_settings(
-        &self,
-        workspace_root: &SystemPath,
-        _packages: &[PackageMetadata],
-    ) -> WorkspaceSettings {
-        WorkspaceSettings {
-            program: ProgramSettings {
-                python_version: self.python_version.unwrap_or_default(),
-                python_platform: PythonPlatform::default(),
-                search_paths: self.search_paths.to_settings(workspace_root),
-            },
+    pub(super) fn to_program_settings(&self, first_party_root: &SystemPath) -> ProgramSettings {
+        ProgramSettings {
+            python_version: self.python_version.unwrap_or_default(),
+            python_platform: PythonPlatform::default(),
+            search_paths: self.search_paths.to_settings(first_party_root),
         }
     }
 }
@@ -57,7 +50,7 @@ pub struct SearchPathConfiguration {
     /// or pyright's stubPath configuration setting.
     pub extra_paths: Option<Vec<SystemPathBuf>>,
 
-    /// The root of the workspace, used for finding first-party modules.
+    /// The root of the project, used for finding first-party modules.
     pub src_root: Option<SystemPathBuf>,
 
     /// Optional path to a "typeshed" directory on disk for us to use for standard-library types.

crates/red_knot_workspace/src/project/snapshots/red_knot_workspace__project__metadata__tests__nested_projects_in_root_project.snap

@@ -0,0 +1,17 @@
+---
+source: crates/red_knot_workspace/src/project/metadata.rs
+expression: root
+---
+ProjectMetadata(
+  name: Name("project-root"),
+  root: "/app",
+  configuration: Configuration(
+    python_version: None,
+    search_paths: SearchPathConfiguration(
+      extra_paths: None,
+      src_root: None,
+      typeshed: None,
+      site_packages: None,
+    ),
+  ),
+)

crates/red_knot_workspace/src/project/snapshots/red_knot_workspace__project__metadata__tests__nested_projects_in_sub_project.snap

@@ -0,0 +1,17 @@
+---
+source: crates/red_knot_workspace/src/project/metadata.rs
+expression: sub_project
+---
+ProjectMetadata(
+  name: Name("nested-project"),
+  root: "/app/packages/a",
+  configuration: Configuration(
+    python_version: None,
+    search_paths: SearchPathConfiguration(
+      extra_paths: None,
+      src_root: None,
+      typeshed: None,
+      site_packages: None,
+    ),
+  ),
+)

crates/red_knot_workspace/src/project/snapshots/red_knot_workspace__project__metadata__tests__nested_projects_with_outer_knot_section.snap

@@ -0,0 +1,17 @@
+---
+source: crates/red_knot_workspace/src/project/metadata.rs
+expression: root
+---
+ProjectMetadata(
+  name: Name("project-root"),
+  root: "/app",
+  configuration: Configuration(
+    python_version: None,
+    search_paths: SearchPathConfiguration(
+      extra_paths: None,
+      src_root: None,
+      typeshed: None,
+      site_packages: None,
+    ),
+  ),
+)

crates/red_knot_workspace/src/project/snapshots/red_knot_workspace__project__metadata__tests__nested_projects_without_knot_sections.snap

@@ -0,0 +1,17 @@
+---
+source: crates/red_knot_workspace/src/project/metadata.rs
+expression: sub_project
+---
+ProjectMetadata(
+  name: Name("nested-project"),
+  root: "/app/packages/a",
+  configuration: Configuration(
+    python_version: None,
+    search_paths: SearchPathConfiguration(
+      extra_paths: None,
+      src_root: None,
+      typeshed: None,
+      site_packages: None,
+    ),
+  ),
+)

crates/red_knot_workspace/src/project/snapshots/red_knot_workspace__project__metadata__tests__project_with_pyproject.snap

@@ -0,0 +1,17 @@
+---
+source: crates/red_knot_workspace/src/project/metadata.rs
+expression: project
+---
+ProjectMetadata(
+  name: Name("backend"),
+  root: "/app",
+  configuration: Configuration(
+    python_version: None,
+    search_paths: SearchPathConfiguration(
+      extra_paths: None,
+      src_root: None,
+      typeshed: None,
+      site_packages: None,
+    ),
+  ),
+)

crates/red_knot_workspace/src/project/snapshots/red_knot_workspace__project__metadata__tests__project_without_pyproject.snap

@@ -0,0 +1,17 @@
+---
+source: crates/red_knot_workspace/src/project/metadata.rs
+expression: project
+---
+ProjectMetadata(
+  name: Name("app"),
+  root: "/app",
+  configuration: Configuration(
+    python_version: None,
+    search_paths: SearchPathConfiguration(
+      extra_paths: None,
+      src_root: None,
+      typeshed: None,
+      site_packages: None,
+    ),
+  ),
+)

crates/red_knot_workspace/src/watch.rs

@@ -1,9 +1,9 @@
+pub use project_watcher::ProjectWatcher;
 use ruff_db::system::{SystemPath, SystemPathBuf, SystemVirtualPathBuf};
 pub use watcher::{directory_watcher, EventHandler, Watcher};
-pub use workspace_watcher::WorkspaceWatcher;
 
+mod project_watcher;
 mod watcher;
-mod workspace_watcher;
 
 /// Classification of a file system change event.
 ///

crates/red_knot_workspace/src/watch/project_watcher.rs

@@ -8,11 +8,11 @@ use ruff_cache::{CacheKey, CacheKeyHasher};
 use ruff_db::system::{SystemPath, SystemPathBuf};
 use ruff_db::{Db as _, Upcast};
 
-use crate::db::{Db, RootDatabase};
+use crate::db::{Db, ProjectDatabase};
 use crate::watch::Watcher;
 
-/// Wrapper around a [`Watcher`] that watches the relevant paths of a workspace.
-pub struct WorkspaceWatcher {
+/// Wrapper around a [`Watcher`] that watches the relevant paths of a project.
+pub struct ProjectWatcher {
     watcher: Watcher,
 
     /// The paths that need to be watched. This includes paths for which setting up file watching failed.
@@ -25,9 +25,9 @@ pub struct WorkspaceWatcher {
     cache_key: Option<u64>,
 }
 
-impl WorkspaceWatcher {
-    /// Create a new workspace watcher.
-    pub fn new(watcher: Watcher, db: &RootDatabase) -> Self {
+impl ProjectWatcher {
+    /// Create a new project watcher.
+    pub fn new(watcher: Watcher, db: &ProjectDatabase) -> Self {
         let mut watcher = Self {
             watcher,
             watched_paths: Vec::new(),
@@ -40,11 +40,11 @@ impl WorkspaceWatcher {
         watcher
     }
 
-    pub fn update(&mut self, db: &RootDatabase) {
+    pub fn update(&mut self, db: &ProjectDatabase) {
         let search_paths: Vec<_> = system_module_search_paths(db.upcast()).collect();
-        let workspace_path = db.workspace().root(db).to_path_buf();
+        let project_path = db.project().root(db).to_path_buf();
 
-        let new_cache_key = Self::compute_cache_key(&workspace_path, &search_paths);
+        let new_cache_key = Self::compute_cache_key(&project_path, &search_paths);
 
         if self.cache_key == Some(new_cache_key) {
             return;
@@ -56,7 +56,7 @@ impl WorkspaceWatcher {
         // ```text
         // - bar
         //   - baz.py
-        // - workspace
+        // - project
         //   - bar -> /bar
         //   - foo.py
         // ```
@@ -68,23 +68,23 @@ impl WorkspaceWatcher {
 
         self.has_errored_paths = false;
 
-        let workspace_path = db
+        let project_path = db
             .system()
-            .canonicalize_path(&workspace_path)
-            .unwrap_or(workspace_path);
+            .canonicalize_path(&project_path)
+            .unwrap_or(project_path);
 
-        // Find the non-overlapping module search paths and filter out paths that are already covered by the workspace.
+        // Find the non-overlapping module search paths and filter out paths that are already covered by the project.
         // Module search paths are already canonicalized.
         let unique_module_paths = ruff_db::system::deduplicate_nested_paths(
             search_paths
                 .into_iter()
-                .filter(|path| !path.starts_with(&workspace_path)),
+                .filter(|path| !path.starts_with(&project_path)),
         )
         .map(SystemPath::to_path_buf);
 
-        // Now add the new paths, first starting with the workspace path and then
+        // Now add the new paths, first starting with the project path and then
         // adding the library search paths.
-        for path in std::iter::once(workspace_path).chain(unique_module_paths) {
+        for path in std::iter::once(project_path).chain(unique_module_paths) {
             // Log a warning. It's not worth aborting if registering a single folder fails because
             // Ruff otherwise stills works as expected.
             if let Err(error) = self.watcher.watch(&path) {
@@ -106,10 +106,10 @@ impl WorkspaceWatcher {
         self.cache_key = Some(new_cache_key);
     }
 
-    fn compute_cache_key(workspace_root: &SystemPath, search_paths: &[&SystemPath]) -> u64 {
+    fn compute_cache_key(project_root: &SystemPath, search_paths: &[&SystemPath]) -> u64 {
         let mut cache_key_hasher = CacheKeyHasher::new();
         search_paths.cache_key(&mut cache_key_hasher);
-        workspace_root.cache_key(&mut cache_key_hasher);
+        project_root.cache_key(&mut cache_key_hasher);
 
         cache_key_hasher.finish()
     }

crates/red_knot_workspace/src/workspace.rs

@@ -1,665 +0,0 @@
-#![allow(clippy::ref_option)]
-
-use crate::db::Db;
-use crate::db::RootDatabase;
-use crate::workspace::files::{Index, Indexed, IndexedIter, PackageFiles};
-pub use metadata::{PackageMetadata, WorkspaceDiscoveryError, WorkspaceMetadata};
-use red_knot_python_semantic::types::check_types;
-use red_knot_python_semantic::SearchPathSettings;
-use ruff_db::diagnostic::{Diagnostic, DiagnosticId, ParseDiagnostic, Severity};
-use ruff_db::parsed::parsed_module;
-use ruff_db::source::{source_text, SourceTextError};
-use ruff_db::system::FileType;
-use ruff_db::{
-    files::{system_path_to_file, File},
-    system::{walk_directory::WalkState, SystemPath, SystemPathBuf},
-};
-use ruff_python_ast::{name::Name, PySourceType};
-use ruff_text_size::TextRange;
-use rustc_hash::{FxBuildHasher, FxHashSet};
-use salsa::{Durability, Setter as _};
-use std::borrow::Cow;
-use std::iter::FusedIterator;
-use std::{collections::BTreeMap, sync::Arc};
-
-mod files;
-mod metadata;
-mod pyproject;
-pub mod settings;
-
-/// The project workspace as a Salsa ingredient.
-///
-/// A workspace consists of one or multiple packages. Packages can be nested. A file in a workspace
-/// belongs to no or exactly one package (files can't belong to multiple packages).
-///
-/// How workspaces and packages are discovered is TBD. For now, a workspace can be any directory,
-/// and it always contains a single package which has the same root as the workspace.
-///
-/// ## Examples
-///
-/// ```text
-/// app-1/
-///     pyproject.toml
-///     src/
-///         ... python files
-///
-/// app-2/
-///     pyproject.toml
-///     src/
-///         ... python files
-///
-/// shared/
-///     pyproject.toml
-///     src/
-///         ... python files
-///
-/// pyproject.toml
-/// ```
-///
-/// The above project structure has three packages: `app-1`, `app-2`, and `shared`.
-/// Each of the packages can define their own settings in their `pyproject.toml` file, but
-/// they must be compatible. For example, each package can define a different `requires-python` range,
-/// but the ranges must overlap.
-///
-/// ## How is a workspace different from a program?
-/// There are two (related) motivations:
-///
-/// 1. Program is defined in `ruff_db` and it can't reference the settings types for the linter and formatter
-///    without introducing a cyclic dependency. The workspace is defined in a higher level crate
-///    where it can reference these setting types.
-/// 2. Running `ruff check` with different target versions results in different programs (settings) but
-///    it remains the same workspace. That's why program is a narrowed view of the workspace only
-///    holding on to the most fundamental settings required for checking.
-#[salsa::input]
-pub struct Workspace {
-    #[return_ref]
-    root_buf: SystemPathBuf,
-
-    /// The files that are open in the workspace.
-    ///
-    /// Setting the open files to a non-`None` value changes `check` to only check the
-    /// open files rather than all files in the workspace.
-    #[return_ref]
-    #[default]
-    open_fileset: Option<Arc<FxHashSet<File>>>,
-
-    /// The (first-party) packages in this workspace.
-    #[return_ref]
-    package_tree: PackageTree,
-
-    /// The unresolved search path configuration.
-    #[return_ref]
-    pub search_path_settings: SearchPathSettings,
-}
-
-/// A first-party package in a workspace.
-#[salsa::input]
-pub struct Package {
-    #[return_ref]
-    pub name: Name,
-
-    /// The path to the root directory of the package.
-    #[return_ref]
-    root_buf: SystemPathBuf,
-
-    /// The files that are part of this package.
-    #[default]
-    #[return_ref]
-    file_set: PackageFiles,
-    // TODO: Add the loaded settings.
-}
-
-impl Workspace {
-    pub fn from_metadata(db: &dyn Db, metadata: WorkspaceMetadata) -> Self {
-        let mut packages = BTreeMap::new();
-
-        for package in metadata.packages {
-            packages.insert(package.root.clone(), Package::from_metadata(db, package));
-        }
-
-        let program_settings = metadata.settings.program;
-
-        Workspace::builder(
-            metadata.root,
-            PackageTree(packages),
-            program_settings.search_paths,
-        )
-        .durability(Durability::MEDIUM)
-        .open_fileset_durability(Durability::LOW)
-        .new(db)
-    }
-
-    pub fn root(self, db: &dyn Db) -> &SystemPath {
-        self.root_buf(db)
-    }
-
-    pub fn reload(self, db: &mut dyn Db, metadata: WorkspaceMetadata) {
-        tracing::debug!("Reloading workspace");
-        assert_eq!(self.root(db), metadata.root());
-
-        let mut old_packages = self.package_tree(db).0.clone();
-        let mut new_packages = BTreeMap::new();
-
-        for package_metadata in metadata.packages {
-            let path = package_metadata.root().to_path_buf();
-
-            let package = if let Some(old_package) = old_packages.remove(&path) {
-                old_package.update(db, package_metadata);
-                old_package
-            } else {
-                Package::from_metadata(db, package_metadata)
-            };
-
-            new_packages.insert(path, package);
-        }
-
-        if &metadata.settings.program.search_paths != self.search_path_settings(db) {
-            self.set_search_path_settings(db)
-                .to(metadata.settings.program.search_paths);
-        }
-
-        self.set_package_tree(db).to(PackageTree(new_packages));
-    }
-
-    pub fn update_package(self, db: &mut dyn Db, metadata: PackageMetadata) -> anyhow::Result<()> {
-        let path = metadata.root().to_path_buf();
-
-        if let Some(package) = self.package_tree(db).get(&path) {
-            package.update(db, metadata);
-            Ok(())
-        } else {
-            Err(anyhow::anyhow!("Package {path} not found"))
-        }
-    }
-
-    pub fn packages(self, db: &dyn Db) -> &PackageTree {
-        self.package_tree(db)
-    }
-
-    /// Returns the closest package to which the first-party `path` belongs.
-    ///
-    /// Returns `None` if the `path` is outside of any package or if `file` isn't a first-party file
-    /// (e.g. third-party dependencies or `excluded`).
-    pub fn package(self, db: &dyn Db, path: impl AsRef<SystemPath>) -> Option<Package> {
-        let packages = self.package_tree(db);
-        packages.get(path.as_ref())
-    }
-
-    /// Checks all open files in the workspace and its dependencies.
-    pub fn check(self, db: &RootDatabase) -> Vec<Box<dyn Diagnostic>> {
-        let workspace_span = tracing::debug_span!("check_workspace");
-        let _span = workspace_span.enter();
-
-        tracing::debug!("Checking workspace");
-        let files = WorkspaceFiles::new(db, self);
-        let result = Arc::new(std::sync::Mutex::new(Vec::new()));
-        let inner_result = Arc::clone(&result);
-
-        let db = db.clone();
-        let workspace_span = workspace_span.clone();
-
-        rayon::scope(move |scope| {
-            for file in &files {
-                let result = inner_result.clone();
-                let db = db.clone();
-                let workspace_span = workspace_span.clone();
-
-                scope.spawn(move |_| {
-                    let check_file_span = tracing::debug_span!(parent: &workspace_span, "check_file", file=%file.path(&db));
-                    let _entered = check_file_span.entered();
-
-                    let file_diagnostics = check_file(&db, file);
-                    result.lock().unwrap().extend(file_diagnostics);
-                });
-            }
-        });
-
-        Arc::into_inner(result).unwrap().into_inner().unwrap()
-    }
-
-    /// Opens a file in the workspace.
-    ///
-    /// This changes the behavior of `check` to only check the open files rather than all files in the workspace.
-    pub fn open_file(self, db: &mut dyn Db, file: File) {
-        tracing::debug!("Opening file `{}`", file.path(db));
-
-        let mut open_files = self.take_open_files(db);
-        open_files.insert(file);
-        self.set_open_files(db, open_files);
-    }
-
-    /// Closes a file in the workspace.
-    pub fn close_file(self, db: &mut dyn Db, file: File) -> bool {
-        tracing::debug!("Closing file `{}`", file.path(db));
-
-        let mut open_files = self.take_open_files(db);
-        let removed = open_files.remove(&file);
-
-        if removed {
-            self.set_open_files(db, open_files);
-        }
-
-        removed
-    }
-
-    /// Returns the open files in the workspace or `None` if the entire workspace should be checked.
-    pub fn open_files(self, db: &dyn Db) -> Option<&FxHashSet<File>> {
-        self.open_fileset(db).as_deref()
-    }
-
-    /// Sets the open files in the workspace.
-    ///
-    /// This changes the behavior of `check` to only check the open files rather than all files in the workspace.
-    #[tracing::instrument(level = "debug", skip(self, db))]
-    pub fn set_open_files(self, db: &mut dyn Db, open_files: FxHashSet<File>) {
-        tracing::debug!("Set open workspace files (count: {})", open_files.len());
-
-        self.set_open_fileset(db).to(Some(Arc::new(open_files)));
-    }
-
-    /// This takes the open files from the workspace and returns them.
-    ///
-    /// This changes the behavior of `check` to check all files in the workspace instead of just the open files.
-    pub fn take_open_files(self, db: &mut dyn Db) -> FxHashSet<File> {
-        tracing::debug!("Take open workspace files");
-
-        // Salsa will cancel any pending queries and remove its own reference to `open_files`
-        // so that the reference counter to `open_files` now drops to 1.
-        let open_files = self.set_open_fileset(db).to(None);
-
-        if let Some(open_files) = open_files {
-            Arc::try_unwrap(open_files).unwrap()
-        } else {
-            FxHashSet::default()
-        }
-    }
-
-    /// Returns `true` if the file is open in the workspace.
-    ///
-    /// A file is considered open when:
-    /// * explicitly set as an open file using [`open_file`](Self::open_file)
-    /// * It has a [`SystemPath`] and belongs to a package's `src` files
-    /// * It has a [`SystemVirtualPath`](ruff_db::system::SystemVirtualPath)
-    pub fn is_file_open(self, db: &dyn Db, file: File) -> bool {
-        if let Some(open_files) = self.open_files(db) {
-            open_files.contains(&file)
-        } else if let Some(system_path) = file.path(db).as_system_path() {
-            self.package(db, system_path)
-                .map_or(false, |package| package.contains_file(db, file))
-        } else {
-            file.path(db).is_system_virtual_path()
-        }
-    }
-}
-
-impl Package {
-    pub fn root(self, db: &dyn Db) -> &SystemPath {
-        self.root_buf(db)
-    }
-
-    /// Returns `true` if `file` is a first-party file part of this package.
-    pub fn contains_file(self, db: &dyn Db, file: File) -> bool {
-        self.files(db).contains(&file)
-    }
-
-    #[tracing::instrument(level = "debug", skip(db))]
-    pub fn remove_file(self, db: &mut dyn Db, file: File) {
-        tracing::debug!(
-            "Removing file `{}` from package `{}`",
-            file.path(db),
-            self.name(db)
-        );
-
-        let Some(mut index) = PackageFiles::indexed_mut(db, self) else {
-            return;
-        };
-
-        index.remove(file);
-    }
-
-    pub fn add_file(self, db: &mut dyn Db, file: File) {
-        tracing::debug!(
-            "Adding file `{}` to package `{}`",
-            file.path(db),
-            self.name(db)
-        );
-
-        let Some(mut index) = PackageFiles::indexed_mut(db, self) else {
-            return;
-        };
-
-        index.insert(file);
-    }
-
-    /// Returns the files belonging to this package.
-    pub fn files(self, db: &dyn Db) -> Indexed<'_> {
-        let files = self.file_set(db);
-
-        let indexed = match files.get() {
-            Index::Lazy(vacant) => {
-                let _entered =
-                    tracing::debug_span!("index_package_files", package = %self.name(db)).entered();
-
-                let files = discover_package_files(db, self);
-                tracing::info!("Found {} files in package `{}`", files.len(), self.name(db));
-                vacant.set(files)
-            }
-            Index::Indexed(indexed) => indexed,
-        };
-
-        indexed
-    }
-
-    fn from_metadata(db: &dyn Db, metadata: PackageMetadata) -> Self {
-        Self::builder(metadata.name, metadata.root)
-            .durability(Durability::MEDIUM)
-            .file_set_durability(Durability::LOW)
-            .new(db)
-    }
-
-    fn update(self, db: &mut dyn Db, metadata: PackageMetadata) {
-        let root = self.root(db);
-        assert_eq!(root, metadata.root());
-
-        if self.name(db) != metadata.name() {
-            self.set_name(db).to(metadata.name);
-        }
-    }
-
-    pub fn reload_files(self, db: &mut dyn Db) {
-        tracing::debug!("Reloading files for package `{}`", self.name(db));
-
-        if !self.file_set(db).is_lazy() {
-            // Force a re-index of the files in the next revision.
-            self.set_file_set(db).to(PackageFiles::lazy());
-        }
-    }
-}
-
-pub(super) fn check_file(db: &dyn Db, file: File) -> Vec<Box<dyn Diagnostic>> {
-    let mut diagnostics: Vec<Box<dyn Diagnostic>> = Vec::new();
-    // Abort checking if there are IO errors.
-    let source = source_text(db.upcast(), file);
-
-    if let Some(read_error) = source.read_error() {
-        diagnostics.push(Box::new(IOErrorDiagnostic {
-            file,
-            error: read_error.clone(),
-        }));
-        return diagnostics;
-    }
-
-    let parsed = parsed_module(db.upcast(), file);
-    diagnostics.extend(parsed.errors().iter().map(|error| {
-        let diagnostic: Box<dyn Diagnostic> = Box::new(ParseDiagnostic::new(file, error.clone()));
-        diagnostic
-    }));
-
-    diagnostics.extend(check_types(db.upcast(), file).iter().map(|diagnostic| {
-        let boxed: Box<dyn Diagnostic> = Box::new(diagnostic.clone());
-        boxed
-    }));
-
-    diagnostics.sort_unstable_by_key(|diagnostic| diagnostic.range().unwrap_or_default().start());
-
-    diagnostics
-}
-
-fn discover_package_files(db: &dyn Db, package: Package) -> FxHashSet<File> {
-    let paths = std::sync::Mutex::new(Vec::new());
-    let packages = db.workspace().packages(db);
-
-    db.system().walk_directory(package.root(db)).run(|| {
-        Box::new(|entry| {
-            match entry {
-                Ok(entry) => {
-                    // Skip over any non python files to avoid creating too many entries in `Files`.
-                    match entry.file_type() {
-                        FileType::File => {
-                            if entry
-                                .path()
-                                .extension()
-                                .and_then(PySourceType::try_from_extension)
-                                .is_some()
-                            {
-                                let mut paths = paths.lock().unwrap();
-                                paths.push(entry.into_path());
-                            }
-                        }
-                        FileType::Directory | FileType::Symlink => {
-                            // Don't traverse into nested packages (the workspace-package is an ancestor of all other packages)
-                            if packages.get(entry.path()) != Some(package) {
-                                return WalkState::Skip;
-                            }
-                        }
-                    }
-                }
-                Err(error) => {
-                    // TODO Handle error
-                    tracing::error!("Failed to walk path: {error}");
-                }
-            }
-
-            WalkState::Continue
-        })
-    });
-
-    let paths = paths.into_inner().unwrap();
-    let mut files = FxHashSet::with_capacity_and_hasher(paths.len(), FxBuildHasher);
-
-    for path in paths {
-        // If this returns `None`, then the file was deleted between the `walk_directory` call and now.
-        // We can ignore this.
-        if let Ok(file) = system_path_to_file(db.upcast(), &path) {
-            files.insert(file);
-        }
-    }
-
-    files
-}
-
-#[derive(Debug)]
-enum WorkspaceFiles<'a> {
-    OpenFiles(&'a FxHashSet<File>),
-    PackageFiles(Vec<Indexed<'a>>),
-}
-
-impl<'a> WorkspaceFiles<'a> {
-    fn new(db: &'a dyn Db, workspace: Workspace) -> Self {
-        if let Some(open_files) = workspace.open_files(db) {
-            WorkspaceFiles::OpenFiles(open_files)
-        } else {
-            WorkspaceFiles::PackageFiles(
-                workspace
-                    .packages(db)
-                    .iter()
-                    .map(|package| package.files(db))
-                    .collect(),
-            )
-        }
-    }
-}
-
-impl<'a> IntoIterator for &'a WorkspaceFiles<'a> {
-    type Item = File;
-    type IntoIter = WorkspaceFilesIter<'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        match self {
-            WorkspaceFiles::OpenFiles(files) => WorkspaceFilesIter::OpenFiles(files.iter()),
-            WorkspaceFiles::PackageFiles(package_files) => {
-                let mut package_files = package_files.iter();
-                WorkspaceFilesIter::PackageFiles {
-                    current: package_files.next().map(IntoIterator::into_iter),
-                    package_files,
-                }
-            }
-        }
-    }
-}
-
-enum WorkspaceFilesIter<'db> {
-    OpenFiles(std::collections::hash_set::Iter<'db, File>),
-    PackageFiles {
-        package_files: std::slice::Iter<'db, Indexed<'db>>,
-        current: Option<IndexedIter<'db>>,
-    },
-}
-
-impl Iterator for WorkspaceFilesIter<'_> {
-    type Item = File;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self {
-            WorkspaceFilesIter::OpenFiles(files) => files.next().copied(),
-            WorkspaceFilesIter::PackageFiles {
-                package_files,
-                current,
-            } => loop {
-                if let Some(file) = current.as_mut().and_then(Iterator::next) {
-                    return Some(file);
-                }
-
-                *current = Some(package_files.next()?.into_iter());
-            },
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct IOErrorDiagnostic {
-    file: File,
-    error: SourceTextError,
-}
-
-impl Diagnostic for IOErrorDiagnostic {
-    fn id(&self) -> DiagnosticId {
-        DiagnosticId::Io
-    }
-
-    fn message(&self) -> Cow<str> {
-        self.error.to_string().into()
-    }
-
-    fn file(&self) -> File {
-        self.file
-    }
-
-    fn range(&self) -> Option<TextRange> {
-        None
-    }
-
-    fn severity(&self) -> Severity {
-        Severity::Error
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub struct PackageTree(BTreeMap<SystemPathBuf, Package>);
-
-impl PackageTree {
-    pub fn get(&self, path: &SystemPath) -> Option<Package> {
-        let (package_path, package) = self.0.range(..=path.to_path_buf()).next_back()?;
-
-        if path.starts_with(package_path) {
-            Some(*package)
-        } else {
-            None
-        }
-    }
-
-    // The package table should never be empty, that's why `is_empty` makes little sense
-    #[allow(clippy::len_without_is_empty)]
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn iter(&self) -> PackageTreeIter {
-        PackageTreeIter(self.0.values())
-    }
-}
-
-impl<'a> IntoIterator for &'a PackageTree {
-    type Item = Package;
-    type IntoIter = PackageTreeIter<'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
-pub struct PackageTreeIter<'a>(std::collections::btree_map::Values<'a, SystemPathBuf, Package>);
-
-impl Iterator for PackageTreeIter<'_> {
-    type Item = Package;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next().copied()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
-    }
-
-    fn last(mut self) -> Option<Self::Item> {
-        self.0.next_back().copied()
-    }
-}
-
-impl ExactSizeIterator for PackageTreeIter<'_> {}
-impl FusedIterator for PackageTreeIter<'_> {}
-
-#[cfg(test)]
-mod tests {
-    use crate::db::tests::TestDb;
-    use crate::workspace::{check_file, WorkspaceMetadata};
-    use red_knot_python_semantic::types::check_types;
-    use ruff_db::diagnostic::Diagnostic;
-    use ruff_db::files::system_path_to_file;
-    use ruff_db::source::source_text;
-    use ruff_db::system::{DbWithTestSystem, SystemPath, SystemPathBuf};
-    use ruff_db::testing::assert_function_query_was_not_run;
-    use ruff_python_ast::name::Name;
-
-    #[test]
-    fn check_file_skips_type_checking_when_file_cant_be_read() -> ruff_db::system::Result<()> {
-        let workspace =
-            WorkspaceMetadata::single_package(Name::new_static("test"), SystemPathBuf::from("/"));
-        let mut db = TestDb::new(workspace);
-        let path = SystemPath::new("test.py");
-
-        db.write_file(path, "x = 10")?;
-        let file = system_path_to_file(&db, path).unwrap();
-
-        // Now the file gets deleted before we had a chance to read its source text.
-        db.memory_file_system().remove_file(path)?;
-        file.sync(&mut db);
-
-        assert_eq!(source_text(&db, file).as_str(), "");
-        assert_eq!(
-            check_file(&db, file)
-                .into_iter()
-                .map(|diagnostic| diagnostic.message().into_owned())
-                .collect::<Vec<_>>(),
-            vec!["Failed to read file: No such file or directory".to_string()]
-        );
-
-        let events = db.take_salsa_events();
-        assert_function_query_was_not_run(&db, check_types, file, &events);
-
-        // The user now creates a new file with an empty text. The source text
-        // content returned by `source_text` remains unchanged, but the diagnostics should get updated.
-        db.write_file(path, "").unwrap();
-
-        assert_eq!(source_text(&db, file).as_str(), "");
-        assert_eq!(
-            check_file(&db, file)
-                .into_iter()
-                .map(|diagnostic| diagnostic.message().into_owned())
-                .collect::<Vec<_>>(),
-            vec![] as Vec<String>
-        );
-
-        Ok(())
-    }
-}

crates/red_knot_workspace/src/workspace/metadata.rs

@@ -1,812 +0,0 @@
-use ruff_db::system::{GlobError, System, SystemPath, SystemPathBuf};
-use ruff_python_ast::name::Name;
-use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
-use thiserror::Error;
-
-use crate::workspace::pyproject::{PyProject, PyProjectError, Workspace};
-use crate::workspace::settings::{Configuration, WorkspaceSettings};
-
-#[derive(Debug, PartialEq, Eq)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct WorkspaceMetadata {
-    pub(super) root: SystemPathBuf,
-
-    /// The (first-party) packages in this workspace.
-    pub(super) packages: Vec<PackageMetadata>,
-
-    /// The resolved settings for this workspace.
-    pub(super) settings: WorkspaceSettings,
-}
-
-/// A first-party package in a workspace.
-#[derive(Debug, Clone, PartialEq, Eq)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct PackageMetadata {
-    pub(super) name: Name,
-
-    /// The path to the root directory of the package.
-    pub(super) root: SystemPathBuf,
-
-    pub(super) configuration: Configuration,
-}
-
-impl WorkspaceMetadata {
-    /// Creates a workspace that consists of a single package located at `root`.
-    pub fn single_package(name: Name, root: SystemPathBuf) -> Self {
-        let package = PackageMetadata {
-            name,
-            root: root.clone(),
-            configuration: Configuration::default(),
-        };
-
-        let packages = vec![package];
-        let settings = packages[0]
-            .configuration
-            .to_workspace_settings(&root, &packages);
-
-        Self {
-            root,
-            packages,
-            settings,
-        }
-    }
-
-    /// Discovers the closest workspace at `path` and returns its metadata.
-    ///
-    /// 1. Traverse upwards in the `path`'s ancestor chain and find the first `pyproject.toml`.
-    /// 1. If the `pyproject.toml` contains no `knot.workspace` table, then keep traversing the `path`'s ancestor
-    ///    chain until we find one or reach the root.
-    /// 1. If we've found a workspace, then resolve the workspace's members and assert that the closest
-    ///    package (the first found package without a `knot.workspace` table is a member. If not, create
-    ///    a single package workspace for the closest package.
-    /// 1. If there's no `pyrpoject.toml` with a `knot.workspace` table, then create a single-package workspace.
-    /// 1. If no ancestor directory contains any `pyproject.toml`, create an ad-hoc workspace for `path`
-    ///    that consists of a single package and uses the default settings.
-    pub fn discover(
-        path: &SystemPath,
-        system: &dyn System,
-        base_configuration: Option<&Configuration>,
-    ) -> Result<WorkspaceMetadata, WorkspaceDiscoveryError> {
-        tracing::debug!("Searching for a workspace in '{path}'");
-
-        if !system.is_directory(path) {
-            return Err(WorkspaceDiscoveryError::NotADirectory(path.to_path_buf()));
-        }
-
-        let mut closest_package: Option<PackageMetadata> = None;
-
-        for ancestor in path.ancestors() {
-            let pyproject_path = ancestor.join("pyproject.toml");
-            if let Ok(pyproject_str) = system.read_to_string(&pyproject_path) {
-                let pyproject = PyProject::from_str(&pyproject_str).map_err(|error| {
-                    WorkspaceDiscoveryError::InvalidPyProject {
-                        path: pyproject_path,
-                        source: Box::new(error),
-                    }
-                })?;
-
-                let workspace_table = pyproject.workspace().cloned();
-                let package = PackageMetadata::from_pyproject(
-                    pyproject,
-                    ancestor.to_path_buf(),
-                    base_configuration,
-                );
-
-                if let Some(workspace_table) = workspace_table {
-                    let workspace_root = ancestor;
-                    tracing::debug!("Found workspace at '{}'", workspace_root);
-
-                    match collect_packages(
-                        package,
-                        &workspace_table,
-                        closest_package,
-                        base_configuration,
-                        system,
-                    )? {
-                        CollectedPackagesOrStandalone::Packages(mut packages) => {
-                            let mut by_name =
-                                FxHashMap::with_capacity_and_hasher(packages.len(), FxBuildHasher);
-
-                            let mut workspace_package = None;
-
-                            for package in &packages {
-                                if let Some(conflicting) = by_name.insert(package.name(), package) {
-                                    return Err(WorkspaceDiscoveryError::DuplicatePackageNames {
-                                        name: package.name().clone(),
-                                        first: conflicting.root().to_path_buf(),
-                                        second: package.root().to_path_buf(),
-                                    });
-                                }
-
-                                if package.root() == workspace_root {
-                                    workspace_package = Some(package);
-                                } else if !package.root().starts_with(workspace_root) {
-                                    return Err(WorkspaceDiscoveryError::PackageOutsideWorkspace {
-                                        package_name: package.name().clone(),
-                                        package_root: package.root().to_path_buf(),
-                                        workspace_root: workspace_root.to_path_buf(),
-                                    });
-                                }
-                            }
-
-                            let workspace_package = workspace_package
-                                .expect("workspace package to be part of the workspace's packages");
-
-                            let settings = workspace_package
-                                .configuration
-                                .to_workspace_settings(workspace_root, &packages);
-
-                            packages.sort_unstable_by(|a, b| a.root().cmp(b.root()));
-
-                            return Ok(Self {
-                                root: workspace_root.to_path_buf(),
-                                packages,
-                                settings,
-                            });
-                        }
-                        CollectedPackagesOrStandalone::Standalone(package) => {
-                            closest_package = Some(package);
-                            break;
-                        }
-                    }
-                }
-
-                // Not a workspace itself, keep looking for an enclosing workspace.
-                if closest_package.is_none() {
-                    closest_package = Some(package);
-                }
-            }
-        }
-
-        // No workspace found, but maybe a pyproject.toml was found.
-        let package = if let Some(enclosing_package) = closest_package {
-            tracing::debug!("Single package workspace at '{}'", enclosing_package.root());
-
-            enclosing_package
-        } else {
-            tracing::debug!("The ancestor directories contain no `pyproject.toml`. Falling back to a virtual project.");
-
-            // Create a package with a default configuration
-            PackageMetadata {
-                name: path.file_name().unwrap_or("root").into(),
-                root: path.to_path_buf(),
-                // TODO create the configuration from the pyproject toml
-                configuration: base_configuration.cloned().unwrap_or_default(),
-            }
-        };
-
-        let root = package.root().to_path_buf();
-        let packages = vec![package];
-        let settings = packages[0]
-            .configuration
-            .to_workspace_settings(&root, &packages);
-
-        Ok(Self {
-            root,
-            packages,
-            settings,
-        })
-    }
-
-    pub fn root(&self) -> &SystemPath {
-        &self.root
-    }
-
-    pub fn packages(&self) -> &[PackageMetadata] {
-        &self.packages
-    }
-
-    pub fn settings(&self) -> &WorkspaceSettings {
-        &self.settings
-    }
-}
-
-impl PackageMetadata {
-    pub(crate) fn from_pyproject(
-        pyproject: PyProject,
-        root: SystemPathBuf,
-        base_configuration: Option<&Configuration>,
-    ) -> Self {
-        let name = pyproject.project.and_then(|project| project.name);
-        let name = name
-            .map(|name| Name::new(&*name))
-            .unwrap_or_else(|| Name::new(root.file_name().unwrap_or("root")));
-
-        // TODO: load configuration from pyrpoject.toml
-        let mut configuration = Configuration::default();
-
-        if let Some(base_configuration) = base_configuration {
-            configuration.extend(base_configuration.clone());
-        }
-
-        PackageMetadata {
-            name,
-            root,
-            configuration,
-        }
-    }
-
-    pub fn name(&self) -> &Name {
-        &self.name
-    }
-
-    pub fn root(&self) -> &SystemPath {
-        &self.root
-    }
-}
-
-fn collect_packages(
-    workspace_package: PackageMetadata,
-    workspace_table: &Workspace,
-    closest_package: Option<PackageMetadata>,
-    base_configuration: Option<&Configuration>,
-    system: &dyn System,
-) -> Result<CollectedPackagesOrStandalone, WorkspaceDiscoveryError> {
-    let workspace_root = workspace_package.root().to_path_buf();
-    let mut member_paths = FxHashSet::default();
-
-    for glob in workspace_table.members() {
-        let full_glob = workspace_package.root().join(glob);
-
-        let matches = system.glob(full_glob.as_str()).map_err(|error| {
-            WorkspaceDiscoveryError::InvalidMembersPattern {
-                raw_glob: glob.clone(),
-                source: error,
-            }
-        })?;
-
-        for result in matches {
-            let path = result?;
-            let normalized = SystemPath::absolute(path, &workspace_root);
-
-            // Skip over non-directory entry. E.g.finder might end up creating a `.DS_STORE` file
-            // that ends up matching `/projects/*`.
-            if system.is_directory(&normalized) {
-                member_paths.insert(normalized);
-            } else {
-                tracing::debug!("Ignoring non-directory workspace member '{normalized}'");
-            }
-        }
-    }
-
-    // The workspace root is always a member. Don't re-add it
-    let mut packages = vec![workspace_package];
-    member_paths.remove(&workspace_root);
-
-    // Add the package that is closest to the current working directory except
-    // if that package isn't a workspace member, then fallback to creating a single
-    // package workspace.
-    if let Some(closest_package) = closest_package {
-        // the closest `pyproject.toml` isn't a member of this workspace because it is
-        // explicitly included or simply not listed.
-        // Create a standalone workspace.
-        if !member_paths.remove(closest_package.root())
-            || workspace_table.is_excluded(closest_package.root(), &workspace_root)?
-        {
-            tracing::debug!(
-                "Ignoring workspace '{workspace_root}' because package '{package}' is not a member",
-                package = closest_package.name()
-            );
-            return Ok(CollectedPackagesOrStandalone::Standalone(closest_package));
-        }
-
-        tracing::debug!("adding package '{}'", closest_package.name());
-        packages.push(closest_package);
-    }
-
-    // Add all remaining member paths
-    for member_path in member_paths {
-        if workspace_table.is_excluded(&member_path, workspace_root.as_path())? {
-            tracing::debug!("Ignoring excluded member '{member_path}'");
-            continue;
-        }
-
-        let pyproject_path = member_path.join("pyproject.toml");
-
-        let pyproject_str = match system.read_to_string(&pyproject_path) {
-            Ok(pyproject_str) => pyproject_str,
-
-            Err(error) => {
-                if error.kind() == std::io::ErrorKind::NotFound
-                    && member_path
-                        .file_name()
-                        .is_some_and(|name| name.starts_with('.'))
-                {
-                    tracing::debug!(
-                        "Ignore member '{member_path}' because it has no pyproject.toml and is hidden",
-                    );
-                    continue;
-                }
-
-                return Err(WorkspaceDiscoveryError::MemberFailedToReadPyProject {
-                    package_root: member_path,
-                    source: error,
-                });
-            }
-        };
-
-        let pyproject = PyProject::from_str(&pyproject_str).map_err(|error| {
-            WorkspaceDiscoveryError::InvalidPyProject {
-                source: Box::new(error),
-                path: pyproject_path,
-            }
-        })?;
-
-        if pyproject.workspace().is_some() {
-            return Err(WorkspaceDiscoveryError::NestedWorkspaces {
-                package_root: member_path,
-            });
-        }
-
-        let package = PackageMetadata::from_pyproject(pyproject, member_path, base_configuration);
-
-        tracing::debug!(
-            "Adding package '{}' at '{}'",
-            package.name(),
-            package.root()
-        );
-
-        packages.push(package);
-    }
-
-    packages.sort_unstable_by(|a, b| a.root().cmp(b.root()));
-
-    Ok(CollectedPackagesOrStandalone::Packages(packages))
-}
-
-enum CollectedPackagesOrStandalone {
-    Packages(Vec<PackageMetadata>),
-    Standalone(PackageMetadata),
-}
-
-#[derive(Debug, Error)]
-pub enum WorkspaceDiscoveryError {
-    #[error("workspace path '{0}' is not a directory")]
-    NotADirectory(SystemPathBuf),
-
-    #[error("nested workspaces aren't supported but the package located at '{package_root}' defines a `knot.workspace` table")]
-    NestedWorkspaces { package_root: SystemPathBuf },
-
-    #[error("the workspace contains two packages named '{name}': '{first}' and '{second}'")]
-    DuplicatePackageNames {
-        name: Name,
-        first: SystemPathBuf,
-        second: SystemPathBuf,
-    },
-
-    #[error("the package '{package_name}' located at '{package_root}' is outside the workspace's root directory '{workspace_root}'")]
-    PackageOutsideWorkspace {
-        workspace_root: SystemPathBuf,
-        package_name: Name,
-        package_root: SystemPathBuf,
-    },
-
-    #[error(
-        "failed to read the `pyproject.toml` for the package located at '{package_root}': {source}"
-    )]
-    MemberFailedToReadPyProject {
-        package_root: SystemPathBuf,
-        source: std::io::Error,
-    },
-
-    #[error("{path} is not a valid `pyproject.toml`: {source}")]
-    InvalidPyProject {
-        source: Box<PyProjectError>,
-        path: SystemPathBuf,
-    },
-
-    #[error("invalid glob '{raw_glob}' in `tool.knot.workspace.members`: {source}")]
-    InvalidMembersPattern {
-        source: glob::PatternError,
-        raw_glob: String,
-    },
-
-    #[error("failed to match member glob: {error}")]
-    FailedToMatchGlob {
-        #[from]
-        error: GlobError,
-    },
-}
-
-#[cfg(test)]
-mod tests {
-    //! Integration tests for workspace discovery
-
-    use crate::snapshot_workspace;
-    use anyhow::Context;
-    use insta::assert_ron_snapshot;
-    use ruff_db::system::{SystemPathBuf, TestSystem};
-
-    use crate::workspace::{WorkspaceDiscoveryError, WorkspaceMetadata};
-
-    #[test]
-    fn package_without_pyproject() -> anyhow::Result<()> {
-        let system = TestSystem::default();
-        let root = SystemPathBuf::from("/app");
-
-        system
-            .memory_file_system()
-            .write_files([(root.join("foo.py"), ""), (root.join("bar.py"), "")])
-            .context("Failed to write files")?;
-
-        let workspace = WorkspaceMetadata::discover(&root, &system, None)
-            .context("Failed to discover workspace")?;
-
-        assert_eq!(workspace.root(), &*root);
-
-        snapshot_workspace!(workspace);
-
-        Ok(())
-    }
-
-    #[test]
-    fn single_package() -> anyhow::Result<()> {
-        let system = TestSystem::default();
-        let root = SystemPathBuf::from("/app");
-
-        system
-            .memory_file_system()
-            .write_files([
-                (
-                    root.join("pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "backend"
-                    "#,
-                ),
-                (root.join("db/__init__.py"), ""),
-            ])
-            .context("Failed to write files")?;
-
-        let workspace = WorkspaceMetadata::discover(&root, &system, None)
-            .context("Failed to discover workspace")?;
-
-        assert_eq!(workspace.root(), &*root);
-        snapshot_workspace!(workspace);
-
-        // Discovering the same package from a subdirectory should give the same result
-        let from_src = WorkspaceMetadata::discover(&root.join("db"), &system, None)
-            .context("Failed to discover workspace from src sub-directory")?;
-
-        assert_eq!(from_src, workspace);
-
-        Ok(())
-    }
-
-    #[test]
-    fn workspace_members() -> anyhow::Result<()> {
-        let system = TestSystem::default();
-        let root = SystemPathBuf::from("/app");
-
-        system
-            .memory_file_system()
-            .write_files([
-                (
-                    root.join("pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "workspace-root"
-
-                    [tool.knot.workspace]
-                    members = ["packages/*"]
-                    exclude = ["packages/excluded"]
-                    "#,
-                ),
-                (
-                    root.join("packages/a/pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "member-a"
-                    "#,
-                ),
-                (
-                    root.join("packages/x/pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "member-x"
-                    "#,
-                ),
-            ])
-            .context("Failed to write files")?;
-
-        let workspace = WorkspaceMetadata::discover(&root, &system, None)
-            .context("Failed to discover workspace")?;
-
-        assert_eq!(workspace.root(), &*root);
-
-        snapshot_workspace!(workspace);
-
-        // Discovering the same package from a member should give the same result
-        let from_src = WorkspaceMetadata::discover(&root.join("packages/a"), &system, None)
-            .context("Failed to discover workspace from src sub-directory")?;
-
-        assert_eq!(from_src, workspace);
-
-        Ok(())
-    }
-
-    #[test]
-    fn workspace_excluded() -> anyhow::Result<()> {
-        let system = TestSystem::default();
-        let root = SystemPathBuf::from("/app");
-
-        system
-            .memory_file_system()
-            .write_files([
-                (
-                    root.join("pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "workspace-root"
-
-                    [tool.knot.workspace]
-                    members = ["packages/*"]
-                    exclude = ["packages/excluded"]
-                    "#,
-                ),
-                (
-                    root.join("packages/a/pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "member-a"
-                    "#,
-                ),
-                (
-                    root.join("packages/excluded/pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "member-x"
-                    "#,
-                ),
-            ])
-            .context("Failed to write files")?;
-
-        let workspace = WorkspaceMetadata::discover(&root, &system, None)
-            .context("Failed to discover workspace")?;
-
-        assert_eq!(workspace.root(), &*root);
-        snapshot_workspace!(workspace);
-
-        // Discovering the `workspace` for `excluded` should discover a single-package workspace
-        let excluded_workspace =
-            WorkspaceMetadata::discover(&root.join("packages/excluded"), &system, None)
-                .context("Failed to discover workspace from src sub-directory")?;
-
-        assert_ne!(excluded_workspace, workspace);
-
-        Ok(())
-    }
-
-    #[test]
-    fn workspace_non_unique_member_names() -> anyhow::Result<()> {
-        let system = TestSystem::default();
-        let root = SystemPathBuf::from("/app");
-
-        system
-            .memory_file_system()
-            .write_files([
-                (
-                    root.join("pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "workspace-root"
-
-                    [tool.knot.workspace]
-                    members = ["packages/*"]
-                    "#,
-                ),
-                (
-                    root.join("packages/a/pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "a"
-                    "#,
-                ),
-                (
-                    root.join("packages/b/pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "a"
-                    "#,
-                ),
-            ])
-            .context("Failed to write files")?;
-
-        let error = WorkspaceMetadata::discover(&root, &system, None).expect_err(
-            "Discovery should error because the workspace contains two packages with the same names.",
-        );
-
-        assert_error_eq(&error, "the workspace contains two packages named 'a': '/app/packages/a' and '/app/packages/b'");
-
-        Ok(())
-    }
-
-    #[test]
-    fn nested_workspaces() -> anyhow::Result<()> {
-        let system = TestSystem::default();
-        let root = SystemPathBuf::from("/app");
-
-        system
-            .memory_file_system()
-            .write_files([
-                (
-                    root.join("pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "workspace-root"
-
-                    [tool.knot.workspace]
-                    members = ["packages/*"]
-                    "#,
-                ),
-                (
-                    root.join("packages/a/pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "nested-workspace"
-
-                    [tool.knot.workspace]
-                    members = ["packages/*"]
-                    "#,
-                ),
-            ])
-            .context("Failed to write files")?;
-
-        let error = WorkspaceMetadata::discover(&root, &system, None).expect_err(
-            "Discovery should error because the workspace has a package that itself is a workspace",
-        );
-
-        assert_error_eq(&error, "nested workspaces aren't supported but the package located at '/app/packages/a' defines a `knot.workspace` table");
-
-        Ok(())
-    }
-
-    #[test]
-    fn member_missing_pyproject_toml() -> anyhow::Result<()> {
-        let system = TestSystem::default();
-        let root = SystemPathBuf::from("/app");
-
-        system
-            .memory_file_system()
-            .write_files([
-                (
-                    root.join("pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "workspace-root"
-
-                    [tool.knot.workspace]
-                    members = ["packages/*"]
-                    "#,
-                ),
-                (root.join("packages/a/test.py"), ""),
-            ])
-            .context("Failed to write files")?;
-
-        let error = WorkspaceMetadata::discover(&root, &system, None)
-            .expect_err("Discovery should error because member `a` has no `pypyroject.toml`");
-
-        assert_error_eq(&error, "failed to read the `pyproject.toml` for the package located at '/app/packages/a': No such file or directory");
-
-        Ok(())
-    }
-
-    /// Folders that match the members pattern but don't have a pyproject.toml
-    /// aren't valid members and discovery fails. However, don't fail
-    /// if the folder name indicates that it is a hidden folder that might
-    /// have been created by another tool
-    #[test]
-    fn member_pattern_matching_hidden_folder() -> anyhow::Result<()> {
-        let system = TestSystem::default();
-        let root = SystemPathBuf::from("/app");
-
-        system
-            .memory_file_system()
-            .write_files([
-                (
-                    root.join("pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "workspace-root"
-
-                    [tool.knot.workspace]
-                    members = ["packages/*"]
-                    "#,
-                ),
-                (root.join("packages/.hidden/a.py"), ""),
-            ])
-            .context("Failed to write files")?;
-
-        let workspace = WorkspaceMetadata::discover(&root, &system, None)?;
-
-        snapshot_workspace!(workspace);
-
-        Ok(())
-    }
-
-    #[test]
-    fn member_pattern_matching_file() -> anyhow::Result<()> {
-        let system = TestSystem::default();
-        let root = SystemPathBuf::from("/app");
-
-        system
-            .memory_file_system()
-            .write_files([
-                (
-                    root.join("pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "workspace-root"
-
-                    [tool.knot.workspace]
-                    members = ["packages/*"]
-                    "#,
-                ),
-                (root.join("packages/.DS_STORE"), ""),
-            ])
-            .context("Failed to write files")?;
-
-        let workspace = WorkspaceMetadata::discover(&root, &system, None)?;
-
-        snapshot_workspace!(&workspace);
-
-        Ok(())
-    }
-
-    #[test]
-    fn workspace_root_not_an_ancestor_of_member() -> anyhow::Result<()> {
-        let system = TestSystem::default();
-        let root = SystemPathBuf::from("/app");
-
-        system
-            .memory_file_system()
-            .write_files([
-                (
-                    root.join("pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "workspace-root"
-
-                    [tool.knot.workspace]
-                    members = ["../packages/*"]
-                    "#,
-                ),
-                (
-                    root.join("../packages/a/pyproject.toml"),
-                    r#"
-                    [project]
-                    name = "a"
-                    "#,
-                ),
-            ])
-            .context("Failed to write files")?;
-
-        let error = WorkspaceMetadata::discover(&root, &system, None).expect_err(
-            "Discovery should error because member `a` is outside the workspace's directory`",
-        );
-
-        assert_error_eq(&error, "the package 'a' located at '/packages/a' is outside the workspace's root directory '/app'");
-
-        Ok(())
-    }
-
-    #[track_caller]
-    fn assert_error_eq(error: &WorkspaceDiscoveryError, message: &str) {
-        assert_eq!(error.to_string().replace('\\', "/"), message);
-    }
-
-    /// Snapshots a workspace but with all paths using unix separators.
-    #[macro_export]
-    macro_rules! snapshot_workspace {
-    ($workspace:expr) => {{
-        assert_ron_snapshot!($workspace,{
-            ".root" => insta::dynamic_redaction(|content, _content_path| {
-                content.as_str().unwrap().replace("\\", "/")
-            }),
-            ".packages[].root" => insta::dynamic_redaction(|content, _content_path| {
-                content.as_str().unwrap().replace("\\", "/")
-            }),
-        });
-    }};
-}
-}

crates/red_knot_workspace/src/workspace/snapshots/red_knot_workspace__workspace__metadata__tests__member_pattern_matching_file.snap

@@ -1,34 +0,0 @@
----
-source: crates/red_knot_workspace/src/workspace/metadata.rs
-expression: "&workspace"
----
-WorkspaceMetadata(
-  root: "/app",
-  packages: [
-    PackageMetadata(
-      name: Name("workspace-root"),
-      root: "/app",
-      configuration: Configuration(
-        python_version: None,
-        search_paths: SearchPathConfiguration(
-          extra_paths: None,
-          src_root: None,
-          typeshed: None,
-          site_packages: None,
-        ),
-      ),
-    ),
-  ],
-  settings: WorkspaceSettings(
-    program: ProgramSettings(
-      python_version: "3.9",
-      python_platform: all,
-      search_paths: SearchPathSettings(
-        extra_paths: [],
-        src_root: "/app",
-        typeshed: None,
-        site_packages: Known([]),
-      ),
-    ),
-  ),
-)

crates/red_knot_workspace/src/workspace/snapshots/red_knot_workspace__workspace__metadata__tests__member_pattern_matching_hidden_folder.snap

@@ -1,34 +0,0 @@
----
-source: crates/red_knot_workspace/src/workspace/metadata.rs
-expression: workspace
----
-WorkspaceMetadata(
-  root: "/app",
-  packages: [
-    PackageMetadata(
-      name: Name("workspace-root"),
-      root: "/app",
-      configuration: Configuration(
-        python_version: None,
-        search_paths: SearchPathConfiguration(
-          extra_paths: None,
-          src_root: None,
-          typeshed: None,
-          site_packages: None,
-        ),
-      ),
-    ),
-  ],
-  settings: WorkspaceSettings(
-    program: ProgramSettings(
-      python_version: "3.9",
-      python_platform: all,
-      search_paths: SearchPathSettings(
-        extra_paths: [],
-        src_root: "/app",
-        typeshed: None,
-        site_packages: Known([]),
-      ),
-    ),
-  ),
-)

crates/red_knot_workspace/src/workspace/snapshots/red_knot_workspace__workspace__metadata__tests__package_without_pyproject.snap

@@ -1,34 +0,0 @@
----
-source: crates/red_knot_workspace/src/workspace/metadata.rs
-expression: workspace
----
-WorkspaceMetadata(
-  root: "/app",
-  packages: [
-    PackageMetadata(
-      name: Name("app"),
-      root: "/app",
-      configuration: Configuration(
-        python_version: None,
-        search_paths: SearchPathConfiguration(
-          extra_paths: None,
-          src_root: None,
-          typeshed: None,
-          site_packages: None,
-        ),
-      ),
-    ),
-  ],
-  settings: WorkspaceSettings(
-    program: ProgramSettings(
-      python_version: "3.9",
-      python_platform: all,
-      search_paths: SearchPathSettings(
-        extra_paths: [],
-        src_root: "/app",
-        typeshed: None,
-        site_packages: Known([]),
-      ),
-    ),
-  ),
-)

crates/red_knot_workspace/src/workspace/snapshots/red_knot_workspace__workspace__metadata__tests__single_package.snap

@@ -1,34 +0,0 @@
----
-source: crates/red_knot_workspace/src/workspace/metadata.rs
-expression: workspace
----
-WorkspaceMetadata(
-  root: "/app",
-  packages: [
-    PackageMetadata(
-      name: Name("backend"),
-      root: "/app",
-      configuration: Configuration(
-        python_version: None,
-        search_paths: SearchPathConfiguration(
-          extra_paths: None,
-          src_root: None,
-          typeshed: None,
-          site_packages: None,
-        ),
-      ),
-    ),
-  ],
-  settings: WorkspaceSettings(
-    program: ProgramSettings(
-      python_version: "3.9",
-      python_platform: all,
-      search_paths: SearchPathSettings(
-        extra_paths: [],
-        src_root: "/app",
-        typeshed: None,
-        site_packages: Known([]),
-      ),
-    ),
-  ),
-)

crates/red_knot_workspace/src/workspace/snapshots/red_knot_workspace__workspace__metadata__tests__workspace_excluded.snap

@@ -1,47 +0,0 @@
----
-source: crates/red_knot_workspace/src/workspace/metadata.rs
-expression: workspace
----
-WorkspaceMetadata(
-  root: "/app",
-  packages: [
-    PackageMetadata(
-      name: Name("workspace-root"),
-      root: "/app",
-      configuration: Configuration(
-        python_version: None,
-        search_paths: SearchPathConfiguration(
-          extra_paths: None,
-          src_root: None,
-          typeshed: None,
-          site_packages: None,
-        ),
-      ),
-    ),
-    PackageMetadata(
-      name: Name("member-a"),
-      root: "/app/packages/a",
-      configuration: Configuration(
-        python_version: None,
-        search_paths: SearchPathConfiguration(
-          extra_paths: None,
-          src_root: None,
-          typeshed: None,
-          site_packages: None,
-        ),
-      ),
-    ),
-  ],
-  settings: WorkspaceSettings(
-    program: ProgramSettings(
-      python_version: "3.9",
-      python_platform: all,
-      search_paths: SearchPathSettings(
-        extra_paths: [],
-        src_root: "/app",
-        typeshed: None,
-        site_packages: Known([]),
-      ),
-    ),
-  ),
-)