[WIP] working version of SSA-style use-def map

2024-08-14 17:10:11 -07:00
185 changed files with 2221 additions and 7120 deletions
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -6,8 +6,6 @@ exclude: |
    crates/red_knot_workspace/resources/.*|
    crates/ruff_linter/resources/.*|
    crates/ruff_linter/src/rules/.*/snapshots/.*|
-    crates/ruff_notebook/resources/.*|
-    crates/ruff_server/resources/.*|
    crates/ruff/resources/.*|
    crates/ruff_python_formatter/resources/.*|
    crates/ruff_python_formatter/tests/snapshots/.*|
@@ -17,7 +15,7 @@ exclude: |

 repos:
  - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.19
+    rev: v0.18
    hooks:
      - id: validate-pyproject

@@ -59,7 +57,7 @@ repos:
        pass_filenames: false # This makes it a lot faster

  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.1
+    rev: v0.5.7
    hooks:
      - id: ruff-format
      - id: ruff
--- a/BREAKING_CHANGES.md
+++ b/BREAKING_CHANGES.md
@@ -1,43 +1,5 @@
 # Breaking Changes

-## 0.6.0
-
- Detect imports in `src` layouts by default for `isort` rules ([#12848](https://github.com/astral-sh/ruff/pull/12848))
-
- The pytest rules `PT001` and `PT023` now default to omitting the decorator parentheses when there are no arguments ([#12838](https://github.com/astral-sh/ruff/pull/12838)).
-
- Lint and format Jupyter Notebook by default ([#12878](https://github.com/astral-sh/ruff/pull/12878)).
-
-    You can disable specific rules for notebooks using [`per-file-ignores`](https://docs.astral.sh/ruff/settings/#lint_per-file-ignores):
-
-    ```toml
-    [tool.ruff.lint.per-file-ignores]
-    "*.ipynb" = ["E501"] # disable line-too-long in notebooks
-    ```
-
-    If you'd prefer to either only lint or only format Jupyter Notebook files, you can use the
-    section-specific `exclude` option to do so. For example, the following would only lint Jupyter
-    Notebook files and not format them:
-
-    ```toml
-    [tool.ruff.format]
-    exclude = ["*.ipynb"]
-    ```
-
-    And, conversely, the following would only format Jupyter Notebook files and not lint them:
-
-    ```toml
-    [tool.ruff.lint]
-    exclude = ["*.ipynb"]
-    ```
-
-    You can completely disable Jupyter Notebook support by updating the [`extend-exclude`](https://docs.astral.sh/ruff/settings/#extend-exclude) setting:
-
-    ```toml
-    [tool.ruff]
-    extend-exclude = ["*.ipynb"]
-    ```
-
 ## 0.5.0

 - Follow the XDG specification to discover user-level configurations on macOS (same as on other Unix platforms)
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,154 +1,5 @@
 # Changelog

-## 0.6.2
-
-### Preview features
-
- \[`flake8-simplify`\] Extend `open-file-with-context-handler` to work with other standard-library IO modules (`SIM115`) ([#12959](https://github.com/astral-sh/ruff/pull/12959))
- \[`ruff`\] Avoid `unused-async` for functions with FastAPI route decorator (`RUF029`) ([#12938](https://github.com/astral-sh/ruff/pull/12938))
- \[`ruff`\] Ignore `fstring-missing-syntax` (`RUF027`) for `fastAPI` paths ([#12939](https://github.com/astral-sh/ruff/pull/12939))
- \[`ruff`\] Implement check for Decimal called with a float literal (RUF032) ([#12909](https://github.com/astral-sh/ruff/pull/12909))
-
-### Rule changes
-
- \[`flake8-bugbear`\] Update diagnostic message when expression is at the end of function (`B015`) ([#12944](https://github.com/astral-sh/ruff/pull/12944))
- \[`flake8-pyi`\] Skip type annotations in `string-or-bytes-too-long` (`PYI053`) ([#13002](https://github.com/astral-sh/ruff/pull/13002))
- \[`flake8-type-checking`\] Always recognise relative imports as first-party ([#12994](https://github.com/astral-sh/ruff/pull/12994))
- \[`flake8-unused-arguments`\] Ignore unused arguments on stub functions (`ARG001`) ([#12966](https://github.com/astral-sh/ruff/pull/12966))
- \[`pylint`\] Ignore augmented assignment for `self-cls-assignment` (`PLW0642`) ([#12957](https://github.com/astral-sh/ruff/pull/12957))
-
-### Server
-
- Show full context in error log messages ([#13029](https://github.com/astral-sh/ruff/pull/13029))
-
-### Bug fixes
-
- \[`pep8-naming`\] Don't flag `from` imports following conventional import names (`N817`) ([#12946](https://github.com/astral-sh/ruff/pull/12946))
- \[`pylint`\] - Allow `__new__` methods to have `cls` as their first argument even if decorated with `@staticmethod` for `bad-staticmethod-argument` (`PLW0211`) ([#12958](https://github.com/astral-sh/ruff/pull/12958))
-
-### Documentation
-
- Add `hyperfine` installation instructions; update `hyperfine` code samples ([#13034](https://github.com/astral-sh/ruff/pull/13034))
- Expand note to use Ruff with other language server in Kate ([#12806](https://github.com/astral-sh/ruff/pull/12806))
- Update example for `PT001` as per the new default behavior ([#13019](https://github.com/astral-sh/ruff/pull/13019))
- \[`perflint`\] Improve docs for `try-except-in-loop` (`PERF203`) ([#12947](https://github.com/astral-sh/ruff/pull/12947))
- \[`pydocstyle`\] Add reference to `lint.pydocstyle.ignore-decorators` setting to rule docs ([#12996](https://github.com/astral-sh/ruff/pull/12996))
-
-## 0.6.1
-
-This is a hotfix release to address an issue with `ruff-pre-commit`. In v0.6,
-Ruff changed its behavior to lint and format Jupyter notebooks by default;
-however, due to an oversight, these files were still excluded by default if
-Ruff was run via pre-commit, leading to inconsistent behavior.
-This has [now been fixed](https://github.com/astral-sh/ruff-pre-commit/pull/96).
-
-### Preview features
-
- \[`fastapi`\] Implement `fast-api-unused-path-parameter` (`FAST003`) ([#12638](https://github.com/astral-sh/ruff/pull/12638))
-
-### Rule changes
-
- \[`pylint`\] Rename `too-many-positional` to `too-many-positional-arguments` (`R0917`) ([#12905](https://github.com/astral-sh/ruff/pull/12905))
-
-### Server
-
- Fix crash when applying "fix-all" code-action to notebook cells ([#12929](https://github.com/astral-sh/ruff/pull/12929))
-
-### Other changes
-
- \[`flake8-naming`\]: Respect import conventions (`N817`) ([#12922](https://github.com/astral-sh/ruff/pull/12922))
-
-## 0.6.0
-
-Check out the [blog post](https://astral.sh/blog/ruff-v0.6.0) for a migration guide and overview of the changes!
-
-### Breaking changes
-
-See also, the "Remapped rules" section which may result in disabled rules.
-
- Lint and format Jupyter Notebook by default ([#12878](https://github.com/astral-sh/ruff/pull/12878)).
- Detect imports in `src` layouts by default for `isort` rules ([#12848](https://github.com/astral-sh/ruff/pull/12848))
- The pytest rules `PT001` and `PT023` now default to omitting the decorator parentheses when there are no arguments ([#12838](https://github.com/astral-sh/ruff/pull/12838)).
-
-### Deprecations
-
-The following rules are now deprecated:
-
- [`pytest-missing-fixture-name-underscore`](https://docs.astral.sh/ruff/rules/pytest-missing-fixture-name-underscore/) (`PT004`)
- [`pytest-incorrect-fixture-name-underscore`](https://docs.astral.sh/ruff/rules/pytest-incorrect-fixture-name-underscore/) (`PT005`)
- [`unpacked-list-comprehension`](https://docs.astral.sh/ruff/rules/unpacked-list-comprehension/) (`UP027`)
-
-### Remapped rules
-
-The following rules have been remapped to new rule codes:
-
- [`unnecessary-dict-comprehension-for-iterable`](https://docs.astral.sh/ruff/rules/unnecessary-dict-comprehension-for-iterable/): `RUF025` to `C420`
-
-### Stabilization
-
-The following rules have been stabilized and are no longer in preview:
-
- [`singledispatch-method`](https://docs.astral.sh/ruff/rules/singledispatch-method/) (`PLE1519`)
- [`singledispatchmethod-function`](https://docs.astral.sh/ruff/rules/singledispatchmethod-function/) (`PLE1520`)
- [`bad-staticmethod-argument`](https://docs.astral.sh/ruff/rules/bad-staticmethod-argument/) (`PLW0211`)
- [`if-stmt-min-max`](https://docs.astral.sh/ruff/rules/if-stmt-min-max/) (`PLR1730`)
- [`invalid-bytes-return-type`](https://docs.astral.sh/ruff/rules/invalid-bytes-return-type/) (`PLE0308`)
- [`invalid-hash-return-type`](https://docs.astral.sh/ruff/rules/invalid-hash-return-type/) (`PLE0309`)
- [`invalid-index-return-type`](https://docs.astral.sh/ruff/rules/invalid-index-return-type/) (`PLE0305`)
- [`invalid-length-return-type`](https://docs.astral.sh/ruff/rules/invalid-length-return-type/) (`PLEE303`)
- [`self-or-cls-assignment`](https://docs.astral.sh/ruff/rules/self-or-cls-assignment/) (`PLW0642`)
- [`byte-string-usage`](https://docs.astral.sh/ruff/rules/byte-string-usage/) (`PYI057`)
- [`duplicate-literal-member`](https://docs.astral.sh/ruff/rules/duplicate-literal-member/) (`PYI062`)
- [`redirected-noqa`](https://docs.astral.sh/ruff/rules/redirected-noqa/) (`RUF101`)
-
-The following behaviors have been stabilized:
-
- [`cancel-scope-no-checkpoint`](https://docs.astral.sh/ruff/rules/cancel-scope-no-checkpoint/) (`ASYNC100`): Support `asyncio` and `anyio` context mangers.
- [`async-function-with-timeout`](https://docs.astral.sh/ruff/rules/async-function-with-timeout/) (`ASYNC109`): Support `asyncio` and `anyio` context mangers.
- [`async-busy-wait`](https://docs.astral.sh/ruff/rules/async-busy-wait/) (`ASYNC110`): Support `asyncio` and `anyio` context mangers.
- [`async-zero-sleep`](https://docs.astral.sh/ruff/rules/async-zero-sleep/) (`ASYNC115`): Support `anyio` context mangers.
- [`long-sleep-not-forever`](https://docs.astral.sh/ruff/rules/long-sleep-not-forever/) (`ASYNC116`): Support `anyio` context mangers.
-
-The following fixes have been stabilized:
-
- [`superfluous-else-return`](https://docs.astral.sh/ruff/rules/superfluous-else-return/) (`RET505`)
- [`superfluous-else-raise`](https://docs.astral.sh/ruff/rules/superfluous-else-raise/) (`RET506`)
- [`superfluous-else-continue`](https://docs.astral.sh/ruff/rules/superfluous-else-continue/) (`RET507`)
- [`superfluous-else-break`](https://docs.astral.sh/ruff/rules/superfluous-else-break/) (`RET508`)
-
-### Preview features
-
- \[`flake8-simplify`\] Further simplify to binary in preview for (`SIM108`) ([#12796](https://github.com/astral-sh/ruff/pull/12796))
- \[`pyupgrade`\] Show violations without auto-fix (`UP031`) ([#11229](https://github.com/astral-sh/ruff/pull/11229))
-
-### Rule changes
-
- \[`flake8-import-conventions`\] Add `xml.etree.ElementTree` to default conventions ([#12455](https://github.com/astral-sh/ruff/pull/12455))
- \[`flake8-pytest-style`\] Add a space after comma in CSV output (`PT006`) ([#12853](https://github.com/astral-sh/ruff/pull/12853))
-
-### Server
-
- Show a message for incorrect settings ([#12781](https://github.com/astral-sh/ruff/pull/12781))
-
-### Bug fixes
-
- \[`flake8-async`\] Do not lint yield in context manager (`ASYNC100`) ([#12896](https://github.com/astral-sh/ruff/pull/12896))
- \[`flake8-comprehensions`\] Do not lint `async for` comprehensions (`C419`) ([#12895](https://github.com/astral-sh/ruff/pull/12895))
- \[`flake8-return`\] Only add return `None` at end of a function (`RET503`) ([#11074](https://github.com/astral-sh/ruff/pull/11074))
- \[`flake8-type-checking`\] Avoid treating `dataclasses.KW_ONLY` as typing-only (`TCH003`) ([#12863](https://github.com/astral-sh/ruff/pull/12863))
- \[`pep8-naming`\] Treat `type(Protocol)` et al as metaclass base (`N805`) ([#12770](https://github.com/astral-sh/ruff/pull/12770))
- \[`pydoclint`\] Don't enforce returns and yields in abstract methods (`DOC201`, `DOC202`) ([#12771](https://github.com/astral-sh/ruff/pull/12771))
- \[`ruff`\] Skip tuples with slice expressions in (`RUF031`) ([#12768](https://github.com/astral-sh/ruff/pull/12768))
- \[`ruff`\] Ignore unparenthesized tuples in subscripts when the subscript is a type annotation or type alias (`RUF031`) ([#12762](https://github.com/astral-sh/ruff/pull/12762))
- \[`ruff`\] Ignore template strings passed to logging and `builtins._()` calls (`RUF027`) ([#12889](https://github.com/astral-sh/ruff/pull/12889))
- \[`ruff`\] Do not remove parens for tuples with starred expressions in Python \<=3.10 (`RUF031`) ([#12784](https://github.com/astral-sh/ruff/pull/12784))
- Evaluate default parameter values for a function in that function's enclosing scope ([#12852](https://github.com/astral-sh/ruff/pull/12852))
-
-### Other changes
-
- Respect VS Code cell metadata when detecting the language of Jupyter Notebook cells ([#12864](https://github.com/astral-sh/ruff/pull/12864))
- Respect `kernelspec` notebook metadata when detecting the preferred language for a Jupyter Notebook ([#12875](https://github.com/astral-sh/ruff/pull/12875))
-
 ## 0.5.7

 ### Preview features
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,6 +2,35 @@

 Welcome! We're happy to have you here. Thank you in advance for your contribution to Ruff.

+- [The Basics](#the-basics)
+    - [Prerequisites](#prerequisites)
+    - [Development](#development)
+    - [Project Structure](#project-structure)
+    - [Example: Adding a new lint rule](#example-adding-a-new-lint-rule)
+        - [Rule naming convention](#rule-naming-convention)
+        - [Rule testing: fixtures and snapshots](#rule-testing-fixtures-and-snapshots)
+    - [Example: Adding a new configuration option](#example-adding-a-new-configuration-option)
+- [MkDocs](#mkdocs)
+- [Release Process](#release-process)
+    - [Creating a new release](#creating-a-new-release)
+- [Ecosystem CI](#ecosystem-ci)
+- [Benchmarking and Profiling](#benchmarking-and-profiling)
+    - [CPython Benchmark](#cpython-benchmark)
+    - [Microbenchmarks](#microbenchmarks)
+        - [Benchmark-driven Development](#benchmark-driven-development)
+        - [PR Summary](#pr-summary)
+        - [Tips](#tips)
+    - [Profiling Projects](#profiling-projects)
+        - [Linux](#linux)
+        - [Mac](#mac)
+- [`cargo dev`](#cargo-dev)
+- [Subsystems](#subsystems)
+    - [Compilation Pipeline](#compilation-pipeline)
+    - [Import Categorization](#import-categorization)
+        - [Project root](#project-root)
+        - [Package root](#package-root)
+        - [Import categorization](#import-categorization-1)
+
 ## The Basics

 Ruff welcomes contributions in the form of pull requests.
@@ -304,34 +333,22 @@ even patch releases may contain [non-backwards-compatible changes](https://semve
 ### Creating a new release

 1. Install `uv`: `curl -LsSf https://astral.sh/uv/install.sh | sh`
-
 1. Run `./scripts/release.sh`; this command will:
-
    - Generate a temporary virtual environment with `rooster`
    - Generate a changelog entry in `CHANGELOG.md`
    - Update versions in `pyproject.toml` and `Cargo.toml`
    - Update references to versions in the `README.md` and documentation
    - Display contributors for the release
-
 1. The changelog should then be editorialized for consistency
-
    - Often labels will be missing from pull requests they will need to be manually organized into the proper section
    - Changes should be edited to be user-facing descriptions, avoiding internal details
-
 1. Highlight any breaking changes in `BREAKING_CHANGES.md`
-
 1. Run `cargo check`. This should update the lock file with new versions.
-
 1. Create a pull request with the changelog and version updates
-
 1. Merge the PR
-
 1. Run the [release workflow](https://github.com/astral-sh/ruff/actions/workflows/release.yml) with:
-
    - The new version number (without starting `v`)
-
 1. The release workflow will do the following:
-
    1. Build all the assets. If this fails (even though we tested in step 4), we haven't tagged or
        uploaded anything, you can restart after pushing a fix. If you just need to rerun the build,
        make sure you're [re-running all the failed
@@ -342,25 +359,14 @@ even patch releases may contain [non-backwards-compatible changes](https://semve
    1. Attach artifacts to draft GitHub release
    1. Trigger downstream repositories. This can fail non-catastrophically, as we can run any
        downstream jobs manually if needed.
-
 1. Verify the GitHub release:
-
    1. The Changelog should match the content of `CHANGELOG.md`
-    1. Append the contributors from the `scripts/release.sh` script
-
+    1. Append the contributors from the `bump.sh` script
 1. If needed, [update the schemastore](https://github.com/astral-sh/ruff/blob/main/scripts/update_schemastore.py).
-
    1. One can determine if an update is needed when
        `git diff old-version-tag new-version-tag -- ruff.schema.json` returns a non-empty diff.
    1. Once run successfully, you should follow the link in the output to create a PR.
-
-1. If needed, update the [`ruff-lsp`](https://github.com/astral-sh/ruff-lsp) and
-    [`ruff-vscode`](https://github.com/astral-sh/ruff-vscode) repositories and follow
-    the release instructions in those repositories. `ruff-lsp` should always be updated
-    before `ruff-vscode`.
-
-    This step is generally not required for a patch release, but should always be done
-    for a minor release.
+1. If needed, update the `ruff-lsp` and `ruff-vscode` repositories.

 ## Ecosystem CI

@@ -383,7 +389,7 @@ We have several ways of benchmarking and profiling Ruff:
 - Microbenchmarks which run the linter or the formatter on individual files. These run on pull requests.
 - Profiling the linter on either the microbenchmarks or entire projects

-> **Note**
+> \[!NOTE\]
 > When running benchmarks, ensure that your CPU is otherwise idle (e.g., close any background
 > applications, like web browsers). You may also want to switch your CPU to a "performance"
 > mode, if it exists, especially when benchmarking short-lived processes.
@@ -397,18 +403,12 @@ which makes it a good target for benchmarking.
 git clone --branch 3.10 https://github.com/python/cpython.git crates/ruff_linter/resources/test/cpython
 ```

-Install `hyperfine`:
-
-```shell
-cargo install hyperfine
-```
-
 To benchmark the release build:

 ```shell
 cargo build --release && hyperfine --warmup 10 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache -e" \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ -e"
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache -e" \
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ -e"

 Benchmark 1: ./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache
  Time (mean ± σ):     293.8 ms ±   3.2 ms    [User: 2384.6 ms, System: 90.3 ms]
@@ -427,7 +427,7 @@ To benchmark against the ecosystem's existing tools:

 ```shell
 hyperfine --ignore-failure --warmup 5 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache" \
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache" \
  "pyflakes crates/ruff_linter/resources/test/cpython" \
  "autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython" \
  "pycodestyle crates/ruff_linter/resources/test/cpython" \
@@ -473,7 +473,7 @@ To benchmark a subset of rules, e.g. `LineTooLong` and `DocLineTooLong`:

 ```shell
 cargo build --release && hyperfine --warmup 10 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache -e --select W505,E501"
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache -e --select W505,E501"
 ```

 You can run `poetry install` from `./scripts/benchmarks` to create a working environment for the
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -228,9 +228,9 @@ dependencies = [

 [[package]]
 name = "camino"
-version = "1.1.9"
+version = "1.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
+checksum = "e0ec6b951b160caa93cc0c7b209e5a3bff7aae9062213451ac99493cd844c239"

 [[package]]
 name = "cast"
@@ -270,12 +270,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"

-[[package]]
-name = "cfg_aliases"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
-
 [[package]]
 name = "chic"
 version = "1.2.2"
@@ -326,9 +320,9 @@ dependencies = [

 [[package]]
 name = "clap"
-version = "4.5.16"
+version = "4.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed6719fffa43d0d87e5fd8caeab59be1554fb028cd30edc88fc4369b17971019"
+checksum = "11d8838454fda655dafd3accb2b6e2bea645b9e4078abe84a22ceb947235c5cc"
 dependencies = [
 "clap_builder",
 "clap_derive",
@@ -401,7 +395,7 @@ version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f8c93eb5f77c9050c7750e14f13ef1033a40a0aac70c6371535b6763a01438c"
 dependencies = [
- "nix 0.28.0",
+ "nix",
 "terminfo",
 "thiserror",
 "which",
@@ -618,12 +612,12 @@ checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"

 [[package]]
 name = "ctrlc"
-version = "3.4.5"
+version = "3.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90eeab0aa92f3f9b4e87f258c72b139c207d251f9cbc1080a0086b86a8870dd3"
+checksum = "672465ae37dc1bc6380a6547a8883d5dd397b0f1faaad4f265726cc7042a5345"
 dependencies = [
- "nix 0.29.0",
- "windows-sys 0.59.0",
+ "nix",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -1053,9 +1047,9 @@ dependencies = [

 [[package]]
 name = "indexmap"
-version = "2.4.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93ead53efc7ea8ed3cfb0c79fc8023fbb782a5432b52830b6518941cebe6505c"
+checksum = "de3fc2e30ba82dd1b3911c8de1ffc143c74a914a14e99514d7637e3099df5ea0"
 dependencies = [
 "equivalent",
 "hashbrown",
@@ -1221,9 +1215,9 @@ checksum = "8b23360e99b8717f20aaa4598f5a6541efbe30630039fbc7706cf954a87947ae"

 [[package]]
 name = "js-sys"
-version = "0.3.70"
+version = "0.3.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
+checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
 dependencies = [
 "wasm-bindgen",
 ]
@@ -1256,9 +1250,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.157"
+version = "0.2.155"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "374af5f94e54fa97cf75e945cce8a6b201e88a1a07e688b47dfd2a59c66dbd86"
+checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"

 [[package]]
 name = "libcst"
@@ -1394,16 +1388,6 @@ dependencies = [
 "libmimalloc-sys",
 ]

-[[package]]
-name = "minicov"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c71e683cd655513b99affab7d317deb690528255a0d5f717f1024093c12b169"
-dependencies = [
- "cc",
- "walkdir",
-]
-
 [[package]]
 name = "minimal-lexical"
 version = "0.2.1"
@@ -1454,19 +1438,7 @@ checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
 dependencies = [
 "bitflags 2.6.0",
 "cfg-if",
- "cfg_aliases 0.1.1",
- "libc",
-]
-
-[[package]]
-name = "nix"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
-dependencies = [
- "bitflags 2.6.0",
- "cfg-if",
- "cfg_aliases 0.2.1",
+ "cfg_aliases",
 "libc",
 ]

@@ -1553,9 +1525,9 @@ checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"

 [[package]]
 name = "ordermap"
-version = "0.5.2"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61d7d835be600a7ac71b24e39c92fe6fad9e818b3c71bfc379e3ba65e327d77f"
+checksum = "8c81974681ab4f0cc9fe49cad56f821d1cc67a08cd2caa9b5d58b0adaa5dd36d"
 dependencies = [
 "indexmap",
 ]
@@ -1933,9 +1905,7 @@ dependencies = [
 "rustc-hash 2.0.0",
 "salsa",
 "smallvec",
- "static_assertions",
 "tempfile",
- "thiserror",
 "tracing",
 "walkdir",
 "zip",
@@ -1951,8 +1921,10 @@ dependencies = [
 "libc",
 "lsp-server",
 "lsp-types",
+ "red_knot_python_semantic",
 "red_knot_workspace",
 "ruff_db",
+ "ruff_linter",
 "ruff_notebook",
 "ruff_python_ast",
 "ruff_source_file",
@@ -1995,6 +1967,7 @@ dependencies = [
 "ruff_text_size",
 "rustc-hash 2.0.0",
 "salsa",
+ "thiserror",
 "tracing",
 ]

@@ -2088,7 +2061,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.6.2"
+version = "0.5.7"
 dependencies = [
 "anyhow",
 "argfile",
@@ -2280,7 +2253,7 @@ dependencies = [

 [[package]]
 name = "ruff_linter"
-version = "0.6.2"
+version = "0.5.7"
 dependencies = [
 "aho-corasick",
 "annotate-snippets 0.9.2",
@@ -2600,7 +2573,7 @@ dependencies = [

 [[package]]
 name = "ruff_wasm"
-version = "0.6.2"
+version = "0.5.7"
 dependencies = [
 "console_error_panic_hook",
 "console_log",
@@ -2740,7 +2713,7 @@ checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
 [[package]]
 name = "salsa"
 version = "0.18.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=f608ff8b24f07706492027199f51132244034f29#f608ff8b24f07706492027199f51132244034f29"
+source = "git+https://github.com/MichaReiser/salsa.git?tag=red-knot-0.0.1#ece083e15b79f155f9e4368ec1318cec9a08d88b"
 dependencies = [
 "append-only-vec",
 "arc-swap",
@@ -2760,12 +2733,12 @@ dependencies = [
 [[package]]
 name = "salsa-macro-rules"
 version = "0.1.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=f608ff8b24f07706492027199f51132244034f29#f608ff8b24f07706492027199f51132244034f29"
+source = "git+https://github.com/MichaReiser/salsa.git?tag=red-knot-0.0.1#ece083e15b79f155f9e4368ec1318cec9a08d88b"

 [[package]]
 name = "salsa-macros"
 version = "0.18.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=f608ff8b24f07706492027199f51132244034f29#f608ff8b24f07706492027199f51132244034f29"
+source = "git+https://github.com/MichaReiser/salsa.git?tag=red-knot-0.0.1#ece083e15b79f155f9e4368ec1318cec9a08d88b"
 dependencies = [
 "heck",
 "proc-macro2",
@@ -2827,9 +2800,9 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"

 [[package]]
 name = "serde"
-version = "1.0.208"
+version = "1.0.206"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2"
+checksum = "5b3e4cd94123dd520a128bcd11e34d9e9e423e7e3e50425cb1b4b1e3549d0284"
 dependencies = [
 "serde_derive",
 ]
@@ -2847,9 +2820,9 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.208"
+version = "1.0.206"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24008e81ff7613ed8e5ba0cfaf24e2c2f1e5b8a0495711e44fcd4882fca62bcf"
+checksum = "fabfb6138d2383ea8208cf98ccf69cdfb1aff4088460681d84189aa259762f97"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2869,9 +2842,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.125"
+version = "1.0.124"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83c8e735a073ccf5be70aa8066aa984eaf2fa000db6c8d0100ae605b366d31ed"
+checksum = "66ad62847a56b3dba58cc891acd13884b9c61138d330c0d7b6181713d4fce38d"
 dependencies = [
 "itoa",
 "memchr",
@@ -3030,9 +3003,9 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"

 [[package]]
 name = "syn"
-version = "2.0.75"
+version = "2.0.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6af063034fc1935ede7be0122941bafa9bacb949334d090b77ca98b5817c7d9"
+checksum = "1fceb41e3d546d0bd83421d3409b1460cc7444cd389341a4c880fe7a042cb3d7"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -3554,20 +3527,19 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

 [[package]]
 name = "wasm-bindgen"
-version = "0.2.93"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
+checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
 dependencies = [
 "cfg-if",
- "once_cell",
 "wasm-bindgen-macro",
 ]

 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.93"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
+checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
 dependencies = [
 "bumpalo",
 "log",
@@ -3580,9 +3552,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.43"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61e9300f63a621e96ed275155c108eb6f843b6a26d053f122ab69724559dc8ed"
+checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
 dependencies = [
 "cfg-if",
 "js-sys",
@@ -3592,9 +3564,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.93"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
+checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
 dependencies = [
 "quote",
 "wasm-bindgen-macro-support",
@@ -3602,9 +3574,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.93"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
+checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -3615,19 +3587,18 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.93"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
+checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"

 [[package]]
 name = "wasm-bindgen-test"
-version = "0.3.43"
+version = "0.3.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68497a05fb21143a08a7d24fc81763384a3072ee43c44e86aad1744d6adef9d9"
+checksum = "d9bf62a58e0780af3e852044583deee40983e5886da43a271dd772379987667b"
 dependencies = [
 "console_error_panic_hook",
 "js-sys",
- "minicov",
 "scoped-tls",
 "wasm-bindgen",
 "wasm-bindgen-futures",
@@ -3636,9 +3607,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-test-macro"
-version = "0.3.43"
+version = "0.3.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b8220be1fa9e4c889b30fd207d4906657e7e90b12e0e6b0c8b8d8709f5de021"
+checksum = "b7f89739351a2e03cb94beb799d47fb2cac01759b40ec441f7de39b00cbf7ef0"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -108,7 +108,7 @@ rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "f608ff8b24f07706492027199f51132244034f29" }
+salsa = { git = "https://github.com/MichaReiser/salsa.git", tag = "red-knot-0.0.1" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
--- a/README.md
+++ b/README.md
@@ -136,8 +136,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.6.2/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.6.2/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.5.7/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.5.7/install.ps1 | iex"
 ```

 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -170,7 +170,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.6.2
+  rev: v0.5.7
  hooks:
    # Run the linter.
    - id: ruff
--- a/crates/red_knot/src/logging.rs
+++ b/crates/red_knot/src/logging.rs
@@ -5,8 +5,8 @@ use colored::Colorize;
 use std::fmt;
 use std::fs::File;
 use std::io::BufWriter;
+use tracing::log::LevelFilter;
 use tracing::{Event, Subscriber};
-use tracing_subscriber::filter::LevelFilter;
 use tracing_subscriber::fmt::format::Writer;
 use tracing_subscriber::fmt::{FmtContext, FormatEvent, FormatFields};
 use tracing_subscriber::registry::LookupSpan;
@@ -60,10 +60,10 @@ pub(crate) enum VerbosityLevel {
 impl VerbosityLevel {
    const fn level_filter(self) -> LevelFilter {
        match self {
-            VerbosityLevel::Default => LevelFilter::WARN,
-            VerbosityLevel::Verbose => LevelFilter::INFO,
-            VerbosityLevel::ExtraVerbose => LevelFilter::DEBUG,
-            VerbosityLevel::Trace => LevelFilter::TRACE,
+            VerbosityLevel::Default => LevelFilter::Warn,
+            VerbosityLevel::Verbose => LevelFilter::Info,
+            VerbosityLevel::ExtraVerbose => LevelFilter::Debug,
+            VerbosityLevel::Trace => LevelFilter::Trace,
        }
    }

@@ -88,7 +88,7 @@ pub(crate) fn setup_tracing(level: VerbosityLevel) -> anyhow::Result<TracingGuar
        match level {
            VerbosityLevel::Default => {
                // Show warning traces
-                EnvFilter::default().add_directive(LevelFilter::WARN.into())
+                EnvFilter::default().add_directive(tracing::level_filters::LevelFilter::WARN.into())
            }
            level => {
                let level_filter = level.level_filter();
--- a/crates/red_knot/src/main.rs
+++ b/crates/red_knot/src/main.rs
@@ -7,12 +7,12 @@ use colored::Colorize;
 use crossbeam::channel as crossbeam_channel;
 use salsa::plumbing::ZalsaDatabase;

-use red_knot_python_semantic::SitePackages;
+use red_knot_python_semantic::{ProgramSettings, SearchPathSettings};
 use red_knot_server::run_server;
 use red_knot_workspace::db::RootDatabase;
+use red_knot_workspace::site_packages::VirtualEnvironment;
 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 ruff_db::system::{OsSystem, System, SystemPath, SystemPathBuf};
 use target_version::TargetVersion;
@@ -65,14 +65,15 @@ to resolve type information for the project's third-party dependencies.",
        value_name = "PATH",
        help = "Additional path to use as a module-resolution source (can be passed multiple times)"
    )]
-    extra_search_path: Option<Vec<SystemPathBuf>>,
+    extra_search_path: Vec<SystemPathBuf>,

    #[arg(
        long,
        help = "Python version to assume when resolving types",
-        value_name = "VERSION"
-    )]
-    target_version: Option<TargetVersion>,
+        default_value_t = TargetVersion::default(),
+        value_name="VERSION")
+    ]
+    target_version: TargetVersion,

    #[clap(flatten)]
    verbosity: Verbosity,
@@ -85,36 +86,6 @@ to resolve type information for the project's third-party dependencies.",
    watch: bool,
 }

-impl Args {
-    fn to_configuration(&self, cli_cwd: &SystemPath) -> Configuration {
-        let mut configuration = Configuration::default();
-
-        if let Some(target_version) = self.target_version {
-            configuration.target_version = Some(target_version.into());
-        }
-
-        if let Some(venv_path) = &self.venv_path {
-            configuration.search_paths.site_packages = Some(SitePackages::Derived {
-                venv_path: SystemPath::absolute(venv_path, cli_cwd),
-            });
-        }
-
-        if let Some(custom_typeshed_dir) = &self.custom_typeshed_dir {
-            configuration.search_paths.custom_typeshed =
-                Some(SystemPath::absolute(custom_typeshed_dir, cli_cwd));
-        }
-
-        if let Some(extra_search_paths) = &self.extra_search_path {
-            configuration.search_paths.extra_paths = extra_search_paths
-                .iter()
-                .map(|path| Some(SystemPath::absolute(path, cli_cwd)))
-                .collect();
-        }
-
-        configuration
-    }
-}
-
 #[derive(Debug, clap::Subcommand)]
 pub enum Command {
    /// Start the language server
@@ -144,13 +115,22 @@ pub fn main() -> ExitStatus {
 }

 fn run() -> anyhow::Result<ExitStatus> {
-    let args = Args::parse_from(std::env::args().collect::<Vec<_>>());
+    let Args {
+        command,
+        current_directory,
+        custom_typeshed_dir,
+        extra_search_path: extra_paths,
+        venv_path,
+        target_version,
+        verbosity,
+        watch,
+    } = Args::parse_from(std::env::args().collect::<Vec<_>>());

-    if matches!(args.command, Some(Command::Server)) {
+    if matches!(command, Some(Command::Server)) {
        return run_server().map(|()| ExitStatus::Success);
    }

-    let verbosity = args.verbosity.level();
+    let verbosity = verbosity.level();
    countme::enable(verbosity.is_trace());
    let _guard = setup_tracing(verbosity)?;

@@ -166,12 +146,10 @@ fn run() -> anyhow::Result<ExitStatus> {
            })?
    };

-    let cwd = args
-        .current_directory
-        .as_ref()
+    let cwd = current_directory
        .map(|cwd| {
            if cwd.as_std_path().is_dir() {
-                Ok(SystemPath::absolute(cwd, &cli_base_path))
+                Ok(SystemPath::absolute(&cwd, &cli_base_path))
            } else {
                Err(anyhow!(
                    "Provided current-directory path '{cwd}' is not a directory."
@@ -182,18 +160,33 @@ fn run() -> anyhow::Result<ExitStatus> {
        .unwrap_or_else(|| cli_base_path.clone());

    let system = OsSystem::new(cwd.clone());
-    let cli_configuration = args.to_configuration(&cwd);
-    let workspace_metadata = WorkspaceMetadata::from_path(
-        system.current_directory(),
-        &system,
-        Some(cli_configuration.clone()),
-    )?;
+    let workspace_metadata = WorkspaceMetadata::from_path(system.current_directory(), &system)?;
+
+    // TODO: Verify the remaining search path settings eagerly.
+    let site_packages = venv_path
+        .map(|path| {
+            VirtualEnvironment::new(path, &OsSystem::new(cli_base_path))
+                .and_then(|venv| venv.site_packages_directories(&system))
+        })
+        .transpose()?
+        .unwrap_or_default();
+
+    // TODO: Respect the settings from the workspace metadata. when resolving the program settings.
+    let program_settings = ProgramSettings {
+        target_version: target_version.into(),
+        search_paths: SearchPathSettings {
+            extra_paths,
+            src_root: workspace_metadata.root().to_path_buf(),
+            custom_typeshed: custom_typeshed_dir,
+            site_packages,
+        },
+    };

    // 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 = RootDatabase::new(workspace_metadata, program_settings, system)?;

-    let (main_loop, main_loop_cancellation_token) = MainLoop::new(cli_configuration);
+    let (main_loop, main_loop_cancellation_token) = MainLoop::new();

    // Listen to Ctrl+C and abort the watch mode.
    let main_loop_cancellation_token = Mutex::new(Some(main_loop_cancellation_token));
@@ -205,7 +198,7 @@ fn run() -> anyhow::Result<ExitStatus> {
        }
    })?;

-    let exit_status = if args.watch {
+    let exit_status = if watch {
        main_loop.watch(&mut db)?
    } else {
        main_loop.run(&mut db)
@@ -245,12 +238,10 @@ struct MainLoop {

    /// The file system watcher, if running in watch mode.
    watcher: Option<WorkspaceWatcher>,
-
-    cli_configuration: Configuration,
 }

 impl MainLoop {
-    fn new(cli_configuration: Configuration) -> (Self, MainLoopCancellationToken) {
+    fn new() -> (Self, MainLoopCancellationToken) {
        let (sender, receiver) = crossbeam_channel::bounded(10);

        (
@@ -258,7 +249,6 @@ impl MainLoop {
                sender: sender.clone(),
                receiver,
                watcher: None,
-                cli_configuration,
            },
            MainLoopCancellationToken { sender },
        )
@@ -341,7 +331,7 @@ impl MainLoop {
                MainLoopMessage::ApplyChanges(changes) => {
                    revision += 1;
                    // Automatically cancels any pending queries and waits for them to complete.
-                    db.apply_changes(changes, Some(&self.cli_configuration));
+                    db.apply_changes(changes);
                    if let Some(watcher) = self.watcher.as_mut() {
                        watcher.update(db);
                    }
--- a/crates/red_knot/tests/file_watching.rs
+++ b/crates/red_knot/tests/file_watching.rs
@@ -5,11 +5,12 @@ use std::time::Duration;

 use anyhow::{anyhow, Context};

-use red_knot_python_semantic::{resolve_module, ModuleName, Program, PythonVersion, SitePackages};
+use red_knot_python_semantic::{
+    resolve_module, ModuleName, Program, ProgramSettings, PythonVersion, SearchPathSettings,
+};
 use red_knot_workspace::db::RootDatabase;
 use red_knot_workspace::watch;
 use red_knot_workspace::watch::{directory_watcher, WorkspaceWatcher};
-use red_knot_workspace::workspace::settings::{Configuration, SearchPathConfiguration};
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::files::{system_path_to_file, File, FileError};
 use ruff_db::source::source_text;
@@ -24,7 +25,7 @@ struct TestCase {
    /// We need to hold on to it in the test case or the temp files get deleted.
    _temp_dir: tempfile::TempDir,
    root_dir: SystemPathBuf,
-    configuration: Configuration,
+    search_path_settings: SearchPathSettings,
 }

 impl TestCase {
@@ -40,6 +41,10 @@ impl TestCase {
        &self.db
    }

+    fn db_mut(&mut self) -> &mut RootDatabase {
+        &mut self.db
+    }
+
    fn stop_watch(&mut self) -> Vec<watch::ChangeEvent> {
        self.try_stop_watch(Duration::from_secs(10))
            .expect("Expected watch changes but observed none.")
@@ -100,20 +105,16 @@ impl TestCase {
        Some(all_events)
    }

-    fn apply_changes(&mut self, changes: Vec<watch::ChangeEvent>) {
-        self.db.apply_changes(changes, Some(&self.configuration));
-    }
-
    fn update_search_path_settings(
        &mut self,
-        configuration: SearchPathConfiguration,
+        f: impl FnOnce(&SearchPathSettings) -> SearchPathSettings,
    ) -> anyhow::Result<()> {
        let program = Program::get(self.db());

-        self.configuration.search_paths = configuration.clone();
-        let new_settings = configuration.into_settings(self.db.workspace().root(&self.db));
+        let new_settings = f(&self.search_path_settings);

-        program.update_search_paths(&mut self.db, &new_settings)?;
+        program.update_search_paths(&mut self.db, new_settings.clone())?;
+        self.search_path_settings = new_settings;

        if let Some(watcher) = &mut self.watcher {
            watcher.update(&self.db);
@@ -126,6 +127,7 @@ impl TestCase {
    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());
+        let files = files.read();
        let mut collected: Vec<_> = files.into_iter().collect();
        collected.sort_unstable_by_key(|file| file.path(self.db()).as_system_path().unwrap());
        collected
@@ -178,14 +180,17 @@ fn setup<F>(setup_files: F) -> anyhow::Result<TestCase>
 where
    F: SetupFiles,
 {
-    setup_with_search_paths(setup_files, |_root, _workspace_path| {
-        SearchPathConfiguration::default()
+    setup_with_search_paths(setup_files, |_root, workspace_path| SearchPathSettings {
+        extra_paths: vec![],
+        src_root: workspace_path.to_path_buf(),
+        custom_typeshed: None,
+        site_packages: vec![],
    })
 }

 fn setup_with_search_paths<F>(
    setup_files: F,
-    create_search_paths: impl FnOnce(&SystemPath, &SystemPath) -> SearchPathConfiguration,
+    create_search_paths: impl FnOnce(&SystemPath, &SystemPath) -> SearchPathSettings,
 ) -> anyhow::Result<TestCase>
 where
    F: SetupFiles,
@@ -217,34 +222,25 @@ where

    let system = OsSystem::new(&workspace_path);

-    let search_paths = create_search_paths(&root_path, &workspace_path);
+    let workspace = WorkspaceMetadata::from_path(&workspace_path, &system)?;
+    let search_path_settings = create_search_paths(&root_path, workspace.root());

-    for path in search_paths
+    for path in search_path_settings
        .extra_paths
        .iter()
-        .flatten()
-        .chain(search_paths.custom_typeshed.iter())
-        .chain(search_paths.site_packages.iter().flat_map(|site_packages| {
-            if let SitePackages::Known(path) = site_packages {
-                path.as_slice()
-            } else {
-                &[]
-            }
-        }))
+        .chain(search_path_settings.site_packages.iter())
+        .chain(search_path_settings.custom_typeshed.iter())
    {
        std::fs::create_dir_all(path.as_std_path())
            .with_context(|| format!("Failed to create search path '{path}'"))?;
    }

-    let configuration = Configuration {
-        target_version: Some(PythonVersion::PY312),
-        search_paths,
+    let settings = ProgramSettings {
+        target_version: PythonVersion::default(),
+        search_paths: search_path_settings.clone(),
    };

-    let workspace =
-        WorkspaceMetadata::from_path(&workspace_path, &system, Some(configuration.clone()))?;
-
-    let db = RootDatabase::new(workspace, system)?;
+    let db = RootDatabase::new(workspace, settings, system)?;

    let (sender, receiver) = crossbeam::channel::unbounded();
    let watcher = directory_watcher(move |events| sender.send(events).unwrap())
@@ -259,7 +255,7 @@ where
        watcher: Some(watcher),
        _temp_dir: temp_dir,
        root_dir: root_path,
-        configuration,
+        search_path_settings,
    };

    // Sometimes the file watcher reports changes for events that happened before the watcher was started.
@@ -312,7 +308,7 @@ fn new_file() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    let foo = case.system_file(&foo_path).expect("foo.py to exist.");

@@ -335,7 +331,7 @@ fn new_ignored_file() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    assert!(case.system_file(&foo_path).is_ok());
    assert_eq!(&case.collect_package_files(&bar_path), &[bar_file]);
@@ -359,7 +355,7 @@ fn changed_file() -> anyhow::Result<()> {

    assert!(!changes.is_empty());

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    assert_eq!(source_text(case.db(), foo).as_str(), "print('Version 2')");
    assert_eq!(&case.collect_package_files(&foo_path), &[foo]);
@@ -382,7 +378,7 @@ fn deleted_file() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    assert!(!foo.exists(case.db()));
    assert_eq!(&case.collect_package_files(&foo_path), &[] as &[File]);
@@ -414,7 +410,7 @@ fn move_file_to_trash() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    assert!(!foo.exists(case.db()));
    assert_eq!(&case.collect_package_files(&foo_path), &[] as &[File]);
@@ -446,7 +442,7 @@ fn move_file_to_workspace() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    let foo_in_workspace = case.system_file(&foo_in_workspace_path)?;

@@ -474,7 +470,7 @@ fn rename_file() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    assert!(!foo.exists(case.db()));

@@ -515,7 +511,7 @@ fn directory_moved_to_workspace() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    let init_file = case
        .system_file(sub_new_path.join("__init__.py"))
@@ -566,7 +562,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    // `import sub.a` should no longer resolve
    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_none());
@@ -620,7 +616,7 @@ fn directory_renamed() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    // `import sub.a` should no longer resolve
    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_none());
@@ -685,7 +681,7 @@ fn directory_deleted() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    // `import sub.a` should no longer resolve
    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_none());
@@ -699,13 +695,15 @@ fn directory_deleted() -> anyhow::Result<()> {

 #[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, workspace_path| {
+            SearchPathSettings {
+                extra_paths: vec![],
+                src_root: workspace_path.to_path_buf(),
+                custom_typeshed: None,
+                site_packages: vec![root_path.join("site_packages")],
+            }
+        })?;

    let site_packages = case.root_path().join("site_packages");

@@ -718,7 +716,7 @@ fn search_path() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("a").unwrap()).is_some());
    assert_eq!(
@@ -739,9 +737,9 @@ fn add_search_path() -> anyhow::Result<()> {
    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("a").unwrap()).is_none());

    // Register site-packages as a search path.
-    case.update_search_path_settings(SearchPathConfiguration {
-        site_packages: Some(SitePackages::Known(vec![site_packages.clone()])),
-        ..SearchPathConfiguration::default()
+    case.update_search_path_settings(|settings| SearchPathSettings {
+        site_packages: vec![site_packages.clone()],
+        ..settings.clone()
    })
    .expect("Search path settings to be valid");

@@ -749,7 +747,7 @@ fn add_search_path() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("a").unwrap()).is_some());

@@ -758,19 +756,21 @@ 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, workspace_path| {
+            SearchPathSettings {
+                extra_paths: vec![],
+                src_root: workspace_path.to_path_buf(),
+                custom_typeshed: None,
+                site_packages: vec![root_path.join("site_packages")],
+            }
+        })?;

    // Remove site packages from the search path settings.
    let site_packages = case.root_path().join("site_packages");
-    case.update_search_path_settings(SearchPathConfiguration {
-        site_packages: None,
-        ..SearchPathConfiguration::default()
+    case.update_search_path_settings(|settings| SearchPathSettings {
+        site_packages: vec![],
+        ..settings.clone()
    })
    .expect("Search path settings to be valid");

@@ -783,48 +783,6 @@ fn remove_search_path() -> anyhow::Result<()> {
    Ok(())
 }

-#[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")?;
-            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(
-                root_path.join("typeshed/stdlib/os.pyi").as_std_path(),
-                "# not important",
-            )?;
-
-            Ok(())
-        },
-        |root_path, _workspace_path| SearchPathConfiguration {
-            custom_typeshed: Some(root_path.join("typeshed")),
-            ..SearchPathConfiguration::default()
-        },
-    )?;
-
-    // Unset the custom typeshed directory.
-    assert_eq!(
-        resolve_module(case.db(), ModuleName::new("os").unwrap()),
-        None
-    );
-
-    std::fs::write(
-        case.root_path()
-            .join("typeshed/stdlib/VERSIONS")
-            .as_std_path(),
-        "os: 3.0-",
-    )?;
-
-    let changes = case.stop_watch();
-
-    case.apply_changes(changes);
-
-    assert!(resolve_module(case.db(), ModuleName::new("os").unwrap()).is_some());
-
-    Ok(())
-}
-
 /// Watch a workspace that contains two files where one file is a hardlink to another.
 ///
 /// Setup:
@@ -871,7 +829,7 @@ fn hard_links_in_workspace() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    assert_eq!(source_text(case.db(), foo).as_str(), "print('Version 2')");

@@ -942,7 +900,7 @@ fn hard_links_to_target_outside_workspace() -> anyhow::Result<()> {

    let changes = case.stop_watch();

-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);

    assert_eq!(source_text(case.db(), bar).as_str(), "print('Version 2')");

@@ -981,7 +939,7 @@ mod unix {

        let changes = case.stop_watch();

-        case.apply_changes(changes);
+        case.db_mut().apply_changes(changes);

        assert_eq!(
            foo.permissions(case.db()),
@@ -1066,7 +1024,7 @@ mod unix {

        let changes = case.take_watch_changes();

-        case.apply_changes(changes);
+        case.db_mut().apply_changes(changes);

        assert_eq!(
            source_text(case.db(), baz.file()).as_str(),
@@ -1079,7 +1037,7 @@ mod unix {

        let changes = case.stop_watch();

-        case.apply_changes(changes);
+        case.db_mut().apply_changes(changes);

        assert_eq!(
            source_text(case.db(), baz.file()).as_str(),
@@ -1150,7 +1108,7 @@ mod unix {

        let changes = case.stop_watch();

-        case.apply_changes(changes);
+        case.db_mut().apply_changes(changes);

        // The file watcher is guaranteed to emit one event for the changed file, but it isn't specified
        // if the event is emitted for the "original" or linked path because both paths are watched.
@@ -1219,11 +1177,11 @@ mod unix {

                Ok(())
            },
-            |_root, workspace| SearchPathConfiguration {
-                site_packages: Some(SitePackages::Known(vec![
-                    workspace.join(".venv/lib/python3.12/site-packages")
-                ])),
-                ..SearchPathConfiguration::default()
+            |_root, workspace| SearchPathSettings {
+                extra_paths: vec![],
+                src_root: workspace.to_path_buf(),
+                custom_typeshed: None,
+                site_packages: vec![workspace.join(".venv/lib/python3.12/site-packages")],
            },
        )?;

@@ -1258,7 +1216,7 @@ mod unix {

        let changes = case.stop_watch();

-        case.apply_changes(changes);
+        case.db_mut().apply_changes(changes);

        assert_eq!(
            source_text(case.db(), baz_original_file).as_str(),
--- a/crates/red_knot_python_semantic/Cargo.toml
+++ b/crates/red_knot_python_semantic/Cargo.toml
@@ -26,12 +26,10 @@ countme = { workspace = true }
 once_cell = { workspace = true }
 ordermap = { workspace = true }
 salsa = { workspace = true }
-thiserror = { workspace = true }
+smallvec = { workspace = true }
 tracing = { workspace = true }
 rustc-hash = { workspace = true }
 hashbrown = { workspace = true }
-smallvec = { workspace = true }
-static_assertions = { workspace = true }

 [build-dependencies]
 path-slash = { workspace = true }
--- a/crates/red_knot_python_semantic/src/db.rs
+++ b/crates/red_knot_python_semantic/src/db.rs
@@ -1,18 +1,15 @@
-use ruff_db::files::File;
 use ruff_db::{Db as SourceDb, Upcast};

 /// Database giving access to semantic information about a Python program.
 #[salsa::db]
-pub trait Db: SourceDb + Upcast<dyn SourceDb> {
-    fn is_file_open(&self, file: File) -> bool;
-}
+pub trait Db: SourceDb + Upcast<dyn SourceDb> {}

 #[cfg(test)]
 pub(crate) mod tests {
    use std::sync::Arc;

    use crate::module_resolver::vendored_typeshed_stubs;
-    use ruff_db::files::{File, Files};
+    use ruff_db::files::Files;
    use ruff_db::system::{DbWithTestSystem, System, TestSystem};
    use ruff_db::vendored::VendoredFileSystem;
    use ruff_db::{Db as SourceDb, Upcast};
@@ -94,11 +91,7 @@ pub(crate) mod tests {
    }

    #[salsa::db]
-    impl Db for TestDb {
-        fn is_file_open(&self, file: File) -> bool {
-            !file.path(self).is_vendored_path()
-        }
-    }
+    impl Db for TestDb {}

    #[salsa::db]
    impl salsa::Database for TestDb {
--- a/crates/red_knot_python_semantic/src/lib.rs
+++ b/crates/red_knot_python_semantic/src/lib.rs
@@ -5,7 +5,7 @@ use rustc_hash::FxHasher;
 pub use db::Db;
 pub use module_name::ModuleName;
 pub use module_resolver::{resolve_module, system_module_search_paths, vendored_typeshed_stubs};
-pub use program::{Program, ProgramSettings, SearchPathSettings, SitePackages};
+pub use program::{Program, ProgramSettings, SearchPathSettings};
 pub use python_version::PythonVersion;
 pub use semantic_model::{HasTy, SemanticModel};

@@ -19,7 +19,6 @@ mod program;
 mod python_version;
 pub mod semantic_index;
 mod semantic_model;
-pub(crate) mod site_packages;
 pub mod types;

 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;
--- a/crates/red_knot_python_semantic/src/module_name.rs
+++ b/crates/red_knot_python_semantic/src/module_name.rs
@@ -168,24 +168,6 @@ impl ModuleName {
        };
        Some(Self(name))
    }
-
-    /// Extend `self` with the components of `other`
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use red_knot_python_semantic::ModuleName;
-    ///
-    /// let mut module_name = ModuleName::new_static("foo").unwrap();
-    /// module_name.extend(&ModuleName::new_static("bar").unwrap());
-    /// assert_eq!(&module_name, "foo.bar");
-    /// module_name.extend(&ModuleName::new_static("baz.eggs.ham").unwrap());
-    /// assert_eq!(&module_name, "foo.bar.baz.eggs.ham");
-    /// ```
-    pub fn extend(&mut self, other: &ModuleName) {
-        self.0.push('.');
-        self.0.push_str(other);
-    }
 }

 impl Deref for ModuleName {
--- a/crates/red_knot_python_semantic/src/module_resolver/mod.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/mod.rs
@@ -2,7 +2,7 @@ use std::iter::FusedIterator;

 pub(crate) use module::Module;
 pub use resolver::resolve_module;
-pub(crate) use resolver::{file_to_module, SearchPaths};
+pub(crate) use resolver::SearchPaths;
 use ruff_db::system::SystemPath;
 pub use typeshed::vendored_typeshed_stubs;

@@ -13,6 +13,7 @@ use resolver::SearchPathIterator;
 mod module;
 mod path;
 mod resolver;
+mod state;
 mod typeshed;

 #[cfg(test)]
--- a/crates/red_knot_python_semantic/src/module_resolver/module.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/module.rs
@@ -77,9 +77,3 @@ pub enum ModuleKind {
    /// A python package (`foo/__init__.py` or `foo/__init__.pyi`)
    Package,
 }
-
-impl ModuleKind {
-    pub const fn is_package(self) -> bool {
-        matches!(self, ModuleKind::Package)
-    }
-}
--- a/crates/red_knot_python_semantic/src/module_resolver/path.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/path.rs
@@ -9,11 +9,11 @@ use ruff_db::files::{system_path_to_file, vendored_path_to_file, File, FileError
 use ruff_db::system::{System, SystemPath, SystemPathBuf};
 use ruff_db::vendored::{VendoredPath, VendoredPathBuf};

-use super::typeshed::{typeshed_versions, TypeshedVersionsParseError, TypeshedVersionsQueryResult};
 use crate::db::Db;
 use crate::module_name::ModuleName;
-use crate::module_resolver::resolver::ResolverContext;
-use crate::site_packages::SitePackagesDiscoveryError;
+
+use super::state::ResolverState;
+use super::typeshed::{TypeshedVersionsParseError, TypeshedVersionsQueryResult};

 /// A path that points to a Python module.
 ///
@@ -60,7 +60,7 @@ impl ModulePath {
    }

    #[must_use]
-    pub(super) fn is_directory(&self, resolver: &ResolverContext) -> bool {
+    pub(crate) fn is_directory(&self, resolver: &ResolverState) -> bool {
        let ModulePath {
            search_path,
            relative_path,
@@ -74,7 +74,7 @@ impl ModulePath {
                    == Err(FileError::IsADirectory)
            }
            SearchPathInner::StandardLibraryCustom(stdlib_root) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(Some(stdlib_root), relative_path, resolver) {
                    TypeshedVersionsQueryResult::DoesNotExist => false,
                    TypeshedVersionsQueryResult::Exists
                    | TypeshedVersionsQueryResult::MaybeExists => {
@@ -84,7 +84,7 @@ impl ModulePath {
                }
            }
            SearchPathInner::StandardLibraryVendored(stdlib_root) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(None, relative_path, resolver) {
                    TypeshedVersionsQueryResult::DoesNotExist => false,
                    TypeshedVersionsQueryResult::Exists
                    | TypeshedVersionsQueryResult::MaybeExists => resolver
@@ -96,7 +96,7 @@ impl ModulePath {
    }

    #[must_use]
-    pub(super) fn is_regular_package(&self, resolver: &ResolverContext) -> bool {
+    pub(crate) fn is_regular_package(&self, resolver: &ResolverState) -> bool {
        let ModulePath {
            search_path,
            relative_path,
@@ -113,7 +113,7 @@ impl ModulePath {
                        .is_ok()
            }
            SearchPathInner::StandardLibraryCustom(search_path) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(Some(search_path), relative_path, resolver) {
                    TypeshedVersionsQueryResult::DoesNotExist => false,
                    TypeshedVersionsQueryResult::Exists
                    | TypeshedVersionsQueryResult::MaybeExists => system_path_to_file(
@@ -124,7 +124,7 @@ impl ModulePath {
                }
            }
            SearchPathInner::StandardLibraryVendored(search_path) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(None, relative_path, resolver) {
                    TypeshedVersionsQueryResult::DoesNotExist => false,
                    TypeshedVersionsQueryResult::Exists
                    | TypeshedVersionsQueryResult::MaybeExists => resolver
@@ -136,7 +136,7 @@ impl ModulePath {
    }

    #[must_use]
-    pub(super) fn to_file(&self, resolver: &ResolverContext) -> Option<File> {
+    pub(crate) fn to_file(&self, resolver: &ResolverState) -> Option<File> {
        let db = resolver.db.upcast();
        let ModulePath {
            search_path,
@@ -150,7 +150,7 @@ impl ModulePath {
                system_path_to_file(db, search_path.join(relative_path)).ok()
            }
            SearchPathInner::StandardLibraryCustom(stdlib_root) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(Some(stdlib_root), relative_path, resolver) {
                    TypeshedVersionsQueryResult::DoesNotExist => None,
                    TypeshedVersionsQueryResult::Exists
                    | TypeshedVersionsQueryResult::MaybeExists => {
@@ -159,7 +159,7 @@ impl ModulePath {
                }
            }
            SearchPathInner::StandardLibraryVendored(stdlib_root) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(None, relative_path, resolver) {
                    TypeshedVersionsQueryResult::DoesNotExist => None,
                    TypeshedVersionsQueryResult::Exists
                    | TypeshedVersionsQueryResult::MaybeExists => {
@@ -273,15 +273,19 @@ fn stdlib_path_to_module_name(relative_path: &Utf8Path) -> Option<ModuleName> {

 #[must_use]
 fn query_stdlib_version(
+    custom_stdlib_root: Option<&SystemPath>,
    relative_path: &Utf8Path,
-    context: &ResolverContext,
+    resolver: &ResolverState,
 ) -> TypeshedVersionsQueryResult {
    let Some(module_name) = stdlib_path_to_module_name(relative_path) else {
        return TypeshedVersionsQueryResult::DoesNotExist;
    };
-    let ResolverContext { db, target_version } = context;
-
-    typeshed_versions(*db).query_module(&module_name, *target_version)
+    let ResolverState {
+        db,
+        typeshed_versions,
+        target_version,
+    } = resolver;
+    typeshed_versions.query_module(*db, &module_name, custom_stdlib_root, *target_version)
 }

 /// Enumeration describing the various ways in which validation of a search path might fail.
@@ -289,7 +293,7 @@ fn query_stdlib_version(
 /// If validation fails for a search path derived from the user settings,
 /// a message must be displayed to the user,
 /// as type checking cannot be done reliably in these circumstances.
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub(crate) enum SearchPathValidationError {
    /// The path provided by the user was not a directory
    NotADirectory(SystemPathBuf),
@@ -300,20 +304,18 @@ pub(crate) enum SearchPathValidationError {
    NoStdlibSubdirectory(SystemPathBuf),

    /// The typeshed path provided by the user is a directory,
-    /// but `stdlib/VERSIONS` could not be read.
+    /// but no `stdlib/VERSIONS` file exists.
    /// (This is only relevant for stdlib search paths.)
-    FailedToReadVersionsFile {
-        path: SystemPathBuf,
-        error: std::io::Error,
-    },
+    NoVersionsFile(SystemPathBuf),
+
+    /// `stdlib/VERSIONS` is a directory.
+    /// (This is only relevant for stdlib search paths.)
+    VersionsIsADirectory(SystemPathBuf),

    /// The path provided by the user is a directory,
    /// and a `stdlib/VERSIONS` file exists, but it fails to parse.
    /// (This is only relevant for stdlib search paths.)
    VersionsParseError(TypeshedVersionsParseError),
-
-    /// Failed to discover the site-packages for the configured virtual environment.
-    SitePackagesDiscovery(SitePackagesDiscoveryError),
 }

 impl fmt::Display for SearchPathValidationError {
@@ -323,16 +325,9 @@ impl fmt::Display for SearchPathValidationError {
            Self::NoStdlibSubdirectory(path) => {
                write!(f, "The directory at {path} has no `stdlib/` subdirectory")
            }
-            Self::FailedToReadVersionsFile { path, error } => {
-                write!(
-                    f,
-                    "Failed to read the custom typeshed versions file '{path}': {error}"
-                )
-            }
+            Self::NoVersionsFile(path) => write!(f, "Expected a file at {path}/stdlib/VERSIONS"),
+            Self::VersionsIsADirectory(path) => write!(f, "{path}/stdlib/VERSIONS is a directory."),
            Self::VersionsParseError(underlying_error) => underlying_error.fmt(f),
-            SearchPathValidationError::SitePackagesDiscovery(error) => {
-                write!(f, "Failed to discover the site-packages directory: {error}")
-            }
        }
    }
 }
@@ -347,18 +342,6 @@ impl std::error::Error for SearchPathValidationError {
    }
 }

-impl From<TypeshedVersionsParseError> for SearchPathValidationError {
-    fn from(value: TypeshedVersionsParseError) -> Self {
-        Self::VersionsParseError(value)
-    }
-}
-
-impl From<SitePackagesDiscoveryError> for SearchPathValidationError {
-    fn from(value: SitePackagesDiscoveryError) -> Self {
-        Self::SitePackagesDiscovery(value)
-    }
-}
-
 type SearchPathResult<T> = Result<T, SearchPathValidationError>;

 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -401,10 +384,11 @@ pub(crate) struct SearchPath(Arc<SearchPathInner>);

 impl SearchPath {
    fn directory_path(system: &dyn System, root: SystemPathBuf) -> SearchPathResult<SystemPathBuf> {
-        if system.is_directory(&root) {
-            Ok(root)
+        let canonicalized = system.canonicalize_path(&root).unwrap_or(root);
+        if system.is_directory(&canonicalized) {
+            Ok(canonicalized)
        } else {
-            Err(SearchPathValidationError::NotADirectory(root))
+            Err(SearchPathValidationError::NotADirectory(canonicalized))
        }
    }

@@ -423,22 +407,32 @@ impl SearchPath {
    }

    /// Create a new standard-library search path pointing to a custom directory on disk
-    pub(crate) fn custom_stdlib(db: &dyn Db, typeshed: &SystemPath) -> SearchPathResult<Self> {
+    pub(crate) fn custom_stdlib(db: &dyn Db, typeshed: SystemPathBuf) -> SearchPathResult<Self> {
        let system = db.system();
-        if !system.is_directory(typeshed) {
+        if !system.is_directory(&typeshed) {
            return Err(SearchPathValidationError::NotADirectory(
                typeshed.to_path_buf(),
            ));
        }
-
        let stdlib =
            Self::directory_path(system, typeshed.join("stdlib")).map_err(|err| match err {
-                SearchPathValidationError::NotADirectory(_) => {
-                    SearchPathValidationError::NoStdlibSubdirectory(typeshed.to_path_buf())
+                SearchPathValidationError::NotADirectory(path) => {
+                    SearchPathValidationError::NoStdlibSubdirectory(path)
                }
                err => err,
            })?;
-
+        let typeshed_versions =
+            system_path_to_file(db.upcast(), stdlib.join("VERSIONS")).map_err(|err| match err {
+                FileError::NotFound => SearchPathValidationError::NoVersionsFile(typeshed),
+                FileError::IsADirectory => {
+                    SearchPathValidationError::VersionsIsADirectory(typeshed)
+                }
+            })?;
+        super::typeshed::parse_typeshed_versions(db, typeshed_versions)
+            .as_ref()
+            .map_err(|validation_error| {
+                SearchPathValidationError::VersionsParseError(validation_error.clone())
+            })?;
        Ok(Self(Arc::new(SearchPathInner::StandardLibraryCustom(
            stdlib,
        ))))
@@ -629,10 +623,10 @@ mod tests {
    use ruff_db::Db;

    use crate::db::tests::TestDb;
-    use crate::module_resolver::testing::{FileSpec, MockedTypeshed, TestCase, TestCaseBuilder};
-    use crate::python_version::PythonVersion;

    use super::*;
+    use crate::module_resolver::testing::{FileSpec, MockedTypeshed, TestCase, TestCaseBuilder};
+    use crate::python_version::PythonVersion;

    impl ModulePath {
        #[must_use]
@@ -644,6 +638,15 @@ mod tests {
    }

    impl SearchPath {
+        #[must_use]
+        pub(crate) fn is_stdlib_search_path(&self) -> bool {
+            matches!(
+                &*self.0,
+                SearchPathInner::StandardLibraryCustom(_)
+                    | SearchPathInner::StandardLibraryVendored(_)
+            )
+        }
+
        fn join(&self, component: &str) -> ModulePath {
            self.to_module_path().join(component)
        }
@@ -658,7 +661,7 @@ mod tests {
            .build();

        assert_eq!(
-            SearchPath::custom_stdlib(&db, stdlib.parent().unwrap())
+            SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf())
                .unwrap()
                .to_module_path()
                .with_py_extension(),
@@ -666,7 +669,7 @@ mod tests {
        );

        assert_eq!(
-            &SearchPath::custom_stdlib(&db, stdlib.parent().unwrap())
+            &SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf())
                .unwrap()
                .join("foo")
                .with_pyi_extension(),
@@ -777,7 +780,7 @@ mod tests {
        let TestCase { db, stdlib, .. } = TestCaseBuilder::new()
            .with_custom_typeshed(MockedTypeshed::default())
            .build();
-        SearchPath::custom_stdlib(&db, stdlib.parent().unwrap())
+        SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf())
            .unwrap()
            .to_module_path()
            .push("bar.py");
@@ -789,7 +792,7 @@ mod tests {
        let TestCase { db, stdlib, .. } = TestCaseBuilder::new()
            .with_custom_typeshed(MockedTypeshed::default())
            .build();
-        SearchPath::custom_stdlib(&db, stdlib.parent().unwrap())
+        SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf())
            .unwrap()
            .to_module_path()
            .push("bar.rs");
@@ -821,7 +824,7 @@ mod tests {
            .with_custom_typeshed(MockedTypeshed::default())
            .build();

-        let root = SearchPath::custom_stdlib(&db, stdlib.parent().unwrap()).unwrap();
+        let root = SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf()).unwrap();

        // Must have a `.pyi` extension or no extension:
        let bad_absolute_path = SystemPath::new("foo/stdlib/x.py");
@@ -869,7 +872,8 @@ mod tests {
            .with_custom_typeshed(typeshed)
            .with_target_version(target_version)
            .build();
-        let stdlib = SearchPath::custom_stdlib(&db, stdlib.parent().unwrap()).unwrap();
+        let stdlib =
+            SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf()).unwrap();
        (db, stdlib)
    }

@@ -894,7 +898,7 @@ mod tests {
        };

        let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);

        let asyncio_regular_package = stdlib_path.join("asyncio");
        assert!(asyncio_regular_package.is_directory(&resolver));
@@ -922,7 +926,7 @@ mod tests {
        };

        let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);

        let xml_namespace_package = stdlib_path.join("xml");
        assert!(xml_namespace_package.is_directory(&resolver));
@@ -944,7 +948,7 @@ mod tests {
        };

        let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);

        let functools_module = stdlib_path.join("functools.pyi");
        assert!(functools_module.to_file(&resolver).is_some());
@@ -960,7 +964,7 @@ mod tests {
        };

        let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);

        let collections_regular_package = stdlib_path.join("collections");
        assert_eq!(collections_regular_package.to_file(&resolver), None);
@@ -976,7 +980,7 @@ mod tests {
        };

        let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);

        let importlib_namespace_package = stdlib_path.join("importlib");
        assert_eq!(importlib_namespace_package.to_file(&resolver), None);
@@ -997,7 +1001,7 @@ mod tests {
        };

        let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);

        let non_existent = stdlib_path.join("doesnt_even_exist");
        assert_eq!(non_existent.to_file(&resolver), None);
@@ -1025,7 +1029,7 @@ mod tests {
        };

        let (db, stdlib_path) = py39_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY39);
+        let resolver = ResolverState::new(&db, PythonVersion::PY39);

        // Since we've set the target version to Py39,
        // `collections` should now exist as a directory, according to VERSIONS...
@@ -1054,7 +1058,7 @@ mod tests {
        };

        let (db, stdlib_path) = py39_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY39);
+        let resolver = ResolverState::new(&db, PythonVersion::PY39);

        // The `importlib` directory now also exists
        let importlib_namespace_package = stdlib_path.join("importlib");
@@ -1078,7 +1082,7 @@ mod tests {
        };

        let (db, stdlib_path) = py39_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY39);
+        let resolver = ResolverState::new(&db, PythonVersion::PY39);

        // The `xml` package no longer exists on py39:
        let xml_namespace_package = stdlib_path.join("xml");
--- a/crates/red_knot_python_semantic/src/module_resolver/resolver.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/resolver.rs
@@ -1,19 +1,19 @@
-use rustc_hash::{FxBuildHasher, FxHashSet};
 use std::borrow::Cow;
 use std::iter::FusedIterator;
-use std::ops::Deref;
+
+use rustc_hash::{FxBuildHasher, FxHashSet};

 use ruff_db::files::{File, FilePath, FileRootKind};
-use ruff_db::system::{DirectoryEntry, System, SystemPath, SystemPathBuf};
-use ruff_db::vendored::{VendoredFileSystem, VendoredPath};
+use ruff_db::system::{DirectoryEntry, SystemPath, SystemPathBuf};
+use ruff_db::vendored::VendoredPath;
+
+use crate::db::Db;
+use crate::module_name::ModuleName;
+use crate::{Program, SearchPathSettings};

 use super::module::{Module, ModuleKind};
 use super::path::{ModulePath, SearchPath, SearchPathValidationError};
-use crate::db::Db;
-use crate::module_name::ModuleName;
-use crate::module_resolver::typeshed::{vendored_typeshed_versions, TypeshedVersions};
-use crate::site_packages::VirtualEnvironment;
-use crate::{Program, PythonVersion, SearchPathSettings, SitePackages};
+use super::state::ResolverState;

 /// Resolves a module name to a module.
 pub fn resolve_module(db: &dyn Db, module_name: ModuleName) -> Option<Module> {
@@ -41,7 +41,7 @@ pub(crate) fn resolve_module_query<'db>(

    let module = Module::new(name.clone(), kind, search_path, module_file);

-    tracing::trace!(
+    tracing::debug!(
        "Resolved module '{name}' to '{path}'.",
        path = module_file.path(db)
    );
@@ -122,7 +122,7 @@ pub(crate) fn search_paths(db: &dyn Db) -> SearchPathIterator {
    Program::get(db).search_paths(db).iter(db)
 }

-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Default)]
 pub(crate) struct SearchPaths {
    /// Search paths that have been statically determined purely from reading Ruff's configuration settings.
    /// These shouldn't ever change unless the config settings themselves change.
@@ -135,8 +135,6 @@ pub(crate) struct SearchPaths {
    /// in terms of module-resolution priority until we've discovered the editable installs
    /// for the first `site-packages` path
    site_packages: Vec<SearchPath>,
-
-    typeshed_versions: ResolvedTypeshedVersions,
 }

 impl SearchPaths {
@@ -148,14 +146,8 @@ impl SearchPaths {
    /// [module resolution order]: https://typing.readthedocs.io/en/latest/spec/distributing.html#import-resolution-ordering
    pub(crate) fn from_settings(
        db: &dyn Db,
-        settings: &SearchPathSettings,
+        settings: SearchPathSettings,
    ) -> Result<Self, SearchPathValidationError> {
-        fn canonicalize(path: &SystemPath, system: &dyn System) -> SystemPathBuf {
-            system
-                .canonicalize_path(path)
-                .unwrap_or_else(|_| path.to_path_buf())
-        }
-
        let SearchPathSettings {
            extra_paths,
            src_root,
@@ -169,65 +161,45 @@ impl SearchPaths {
        let mut static_paths = vec![];

        for path in extra_paths {
-            let path = canonicalize(path, system);
-            files.try_add_root(db.upcast(), &path, FileRootKind::LibrarySearchPath);
-            tracing::debug!("Adding extra search-path '{path}'");
-
-            static_paths.push(SearchPath::extra(system, path)?);
-        }
-
-        tracing::debug!("Adding first-party search path '{src_root}'");
-        static_paths.push(SearchPath::first_party(system, src_root.to_path_buf())?);
-
-        let (typeshed_versions, stdlib_path) = if let Some(custom_typeshed) = custom_typeshed {
-            let custom_typeshed = canonicalize(custom_typeshed, system);
-            tracing::debug!("Adding custom-stdlib search path '{custom_typeshed}'");
+            tracing::debug!("Adding static extra search-path '{path}'");

+            let search_path = SearchPath::extra(system, path)?;
            files.try_add_root(
                db.upcast(),
-                &custom_typeshed,
+                search_path.as_system_path().unwrap(),
                FileRootKind::LibrarySearchPath,
            );
+            static_paths.push(search_path);
+        }

-            let versions_path = custom_typeshed.join("stdlib/VERSIONS");
+        tracing::debug!("Adding static search path '{src_root}'");
+        static_paths.push(SearchPath::first_party(system, src_root)?);

-            let versions_content = system.read_to_string(&versions_path).map_err(|error| {
-                SearchPathValidationError::FailedToReadVersionsFile {
-                    path: versions_path,
-                    error,
-                }
-            })?;
+        static_paths.push(if let Some(custom_typeshed) = custom_typeshed {
+            tracing::debug!("Adding static custom-sdtlib search-path '{custom_typeshed}'");

-            let parsed: TypeshedVersions = versions_content.parse()?;
-
-            let search_path = SearchPath::custom_stdlib(db, &custom_typeshed)?;
-
-            (ResolvedTypeshedVersions::Custom(parsed), search_path)
+            let search_path = SearchPath::custom_stdlib(db, custom_typeshed)?;
+            files.try_add_root(
+                db.upcast(),
+                search_path.as_system_path().unwrap(),
+                FileRootKind::LibrarySearchPath,
+            );
+            search_path
        } else {
-            tracing::debug!("Using vendored stdlib");
-            (
-                ResolvedTypeshedVersions::Vendored(vendored_typeshed_versions()),
-                SearchPath::vendored_stdlib(),
-            )
-        };
-
-        static_paths.push(stdlib_path);
-
-        let site_packages_paths = match site_packages_paths {
-            SitePackages::Derived { venv_path } => VirtualEnvironment::new(venv_path, system)
-                .and_then(|venv| venv.site_packages_directories(system))?,
-            SitePackages::Known(paths) => paths
-                .iter()
-                .map(|path| canonicalize(path, system))
-                .collect(),
-        };
+            SearchPath::vendored_stdlib()
+        });

        let mut site_packages: Vec<_> = Vec::with_capacity(site_packages_paths.len());

        for path in site_packages_paths {
-            tracing::debug!("Adding site-packages search path '{path}'");
-            files.try_add_root(db.upcast(), &path, FileRootKind::LibrarySearchPath);
-            site_packages.push(SearchPath::site_packages(system, path)?);
+            tracing::debug!("Adding site-package path '{path}'");
+            let search_path = SearchPath::site_packages(system, path)?;
+            files.try_add_root(
+                db.upcast(),
+                search_path.as_system_path().unwrap(),
+                FileRootKind::LibrarySearchPath,
+            );
+            site_packages.push(search_path);
        }

        // TODO vendor typeshed's third-party stubs as well as the stdlib and fallback to them as a final step
@@ -252,48 +224,16 @@ impl SearchPaths {
        Ok(SearchPaths {
            static_paths,
            site_packages,
-            typeshed_versions,
        })
    }

-    pub(super) fn iter<'a>(&'a self, db: &'a dyn Db) -> SearchPathIterator<'a> {
+    pub(crate) fn iter<'a>(&'a self, db: &'a dyn Db) -> SearchPathIterator<'a> {
        SearchPathIterator {
            db,
            static_paths: self.static_paths.iter(),
            dynamic_paths: None,
        }
    }
-
-    pub(crate) fn custom_stdlib(&self) -> Option<&SystemPath> {
-        self.static_paths.iter().find_map(|search_path| {
-            if search_path.is_standard_library() {
-                search_path.as_system_path()
-            } else {
-                None
-            }
-        })
-    }
-
-    pub(super) fn typeshed_versions(&self) -> &TypeshedVersions {
-        &self.typeshed_versions
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-enum ResolvedTypeshedVersions {
-    Vendored(&'static TypeshedVersions),
-    Custom(TypeshedVersions),
-}
-
-impl Deref for ResolvedTypeshedVersions {
-    type Target = TypeshedVersions;
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            ResolvedTypeshedVersions::Vendored(versions) => versions,
-            ResolvedTypeshedVersions::Custom(versions) => versions,
-        }
-    }
 }

 /// Collect all dynamic search paths. For each `site-packages` path:
@@ -311,7 +251,6 @@ pub(crate) fn dynamic_resolution_paths(db: &dyn Db) -> Vec<SearchPath> {
    let SearchPaths {
        static_paths,
        site_packages,
-        typeshed_versions: _,
    } = Program::get(db).search_paths(db);

    let mut dynamic_paths = Vec::new();
@@ -376,16 +315,12 @@ pub(crate) fn dynamic_resolution_paths(db: &dyn Db) -> Vec<SearchPath> {
        let installations = all_pth_files.iter().flat_map(PthFile::items);

        for installation in installations {
-            let installation = system
-                .canonicalize_path(&installation)
-                .unwrap_or(installation);
-
            if existing_paths.insert(Cow::Owned(installation.clone())) {
-                match SearchPath::editable(system, installation.clone()) {
+                match SearchPath::editable(system, installation) {
                    Ok(search_path) => {
                        tracing::debug!(
                            "Adding editable installation to module resolution path {path}",
-                            path = installation
+                            path = search_path.as_system_path().unwrap()
                        );
                        dynamic_paths.push(search_path);
                    }
@@ -547,7 +482,7 @@ struct ModuleNameIngredient<'db> {
 fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(SearchPath, File, ModuleKind)> {
    let program = Program::get(db);
    let target_version = program.target_version(db);
-    let resolver_state = ResolverContext::new(db, target_version);
+    let resolver_state = ResolverState::new(db, target_version);
    let is_builtin_module =
        ruff_python_stdlib::sys::is_builtin_module(target_version.minor, name.as_str());

@@ -610,7 +545,7 @@ fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(SearchPath, File, Mod
 fn resolve_package<'a, 'db, I>(
    module_search_path: &SearchPath,
    components: I,
-    resolver_state: &ResolverContext<'db>,
+    resolver_state: &ResolverState<'db>,
 ) -> Result<ResolvedPackage, PackageKind>
 where
    I: Iterator<Item = &'a str>,
@@ -692,21 +627,6 @@ impl PackageKind {
    }
 }

-pub(super) struct ResolverContext<'db> {
-    pub(super) db: &'db dyn Db,
-    pub(super) target_version: PythonVersion,
-}
-
-impl<'db> ResolverContext<'db> {
-    pub(super) fn new(db: &'db dyn Db, target_version: PythonVersion) -> Self {
-        Self { db, target_version }
-    }
-
-    pub(super) fn vendored(&self) -> &VendoredFileSystem {
-        self.db.vendored()
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use ruff_db::files::{system_path_to_file, File, FilePath};
@@ -861,7 +781,7 @@ mod tests {
                "Search path for {module_name} was unexpectedly {search_path:?}"
            );
            assert!(
-                search_path.is_standard_library(),
+                search_path.is_stdlib_search_path(),
                "Expected a stdlib search path, but got {search_path:?}"
            );
        }
@@ -957,7 +877,7 @@ mod tests {
                "Search path for {module_name} was unexpectedly {search_path:?}"
            );
            assert!(
-                search_path.is_standard_library(),
+                search_path.is_stdlib_search_path(),
                "Expected a stdlib search path, but got {search_path:?}"
            );
        }
@@ -1274,13 +1194,13 @@ mod tests {

        Program::from_settings(
            &db,
-            &ProgramSettings {
+            ProgramSettings {
                target_version: PythonVersion::PY38,
                search_paths: SearchPathSettings {
                    extra_paths: vec![],
                    src_root: src.clone(),
                    custom_typeshed: Some(custom_typeshed.clone()),
-                    site_packages: SitePackages::Known(vec![site_packages]),
+                    site_packages: vec![site_packages],
                },
            },
        )
@@ -1779,16 +1699,13 @@ not_a_directory

        Program::from_settings(
            &db,
-            &ProgramSettings {
+            ProgramSettings {
                target_version: PythonVersion::default(),
                search_paths: SearchPathSettings {
                    extra_paths: vec![],
                    src_root: SystemPathBuf::from("/src"),
                    custom_typeshed: None,
-                    site_packages: SitePackages::Known(vec![
-                        venv_site_packages,
-                        system_site_packages,
-                    ]),
+                    site_packages: vec![venv_site_packages, system_site_packages],
                },
            },
        )
--- a/crates/red_knot_python_semantic/src/module_resolver/state.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/state.rs
@@ -0,0 +1,25 @@
+use ruff_db::vendored::VendoredFileSystem;
+
+use super::typeshed::LazyTypeshedVersions;
+use crate::db::Db;
+use crate::python_version::PythonVersion;
+
+pub(crate) struct ResolverState<'db> {
+    pub(crate) db: &'db dyn Db,
+    pub(crate) typeshed_versions: LazyTypeshedVersions<'db>,
+    pub(crate) target_version: PythonVersion,
+}
+
+impl<'db> ResolverState<'db> {
+    pub(crate) fn new(db: &'db dyn Db, target_version: PythonVersion) -> Self {
+        Self {
+            db,
+            typeshed_versions: LazyTypeshedVersions::new(),
+            target_version,
+        }
+    }
+
+    pub(crate) fn vendored(&self) -> &VendoredFileSystem {
+        self.db.vendored()
+    }
+}
--- a/crates/red_knot_python_semantic/src/module_resolver/testing.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/testing.rs
@@ -4,7 +4,7 @@ use ruff_db::vendored::VendoredPathBuf;
 use crate::db::tests::TestDb;
 use crate::program::{Program, SearchPathSettings};
 use crate::python_version::PythonVersion;
-use crate::{ProgramSettings, SitePackages};
+use crate::ProgramSettings;

 /// A test case for the module resolver.
 ///
@@ -179,7 +179,6 @@ impl TestCaseBuilder<UnspecifiedTypeshed> {
            first_party_files,
            site_packages_files,
        } = self;
-
        TestCaseBuilder {
            typeshed_option: typeshed,
            target_version,
@@ -196,7 +195,6 @@ impl TestCaseBuilder<UnspecifiedTypeshed> {
            site_packages,
            target_version,
        } = self.with_custom_typeshed(MockedTypeshed::default()).build();
-
        TestCase {
            db,
            src,
@@ -225,13 +223,13 @@ impl TestCaseBuilder<MockedTypeshed> {

        Program::from_settings(
            &db,
-            &ProgramSettings {
+            ProgramSettings {
                target_version,
                search_paths: SearchPathSettings {
                    extra_paths: vec![],
                    src_root: src.clone(),
                    custom_typeshed: Some(typeshed.clone()),
-                    site_packages: SitePackages::Known(vec![site_packages.clone()]),
+                    site_packages: vec![site_packages.clone()],
                },
            },
        )
@@ -281,11 +279,13 @@ impl TestCaseBuilder<VendoredTypeshed> {

        Program::from_settings(
            &db,
-            &ProgramSettings {
+            ProgramSettings {
                target_version,
                search_paths: SearchPathSettings {
-                    site_packages: SitePackages::Known(vec![site_packages.clone()]),
-                    ..SearchPathSettings::new(src.clone())
+                    extra_paths: vec![],
+                    src_root: src.clone(),
+                    custom_typeshed: None,
+                    site_packages: vec![site_packages.clone()],
                },
            },
        )
--- a/crates/red_knot_python_semantic/src/module_resolver/typeshed/mod.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/typeshed/mod.rs
@@ -1,6 +1,6 @@
 pub use self::vendored::vendored_typeshed_stubs;
 pub(super) use self::versions::{
-    typeshed_versions, vendored_typeshed_versions, TypeshedVersions, TypeshedVersionsParseError,
+    parse_typeshed_versions, LazyTypeshedVersions, TypeshedVersionsParseError,
    TypeshedVersionsQueryResult,
 };

--- a/crates/red_knot_python_semantic/src/module_resolver/typeshed/versions.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/typeshed/versions.rs
@@ -1,3 +1,4 @@
+use std::cell::OnceCell;
 use std::collections::BTreeMap;
 use std::fmt;
 use std::num::{NonZeroU16, NonZeroUsize};
@@ -5,12 +6,78 @@ use std::ops::{RangeFrom, RangeInclusive};
 use std::str::FromStr;

 use once_cell::sync::Lazy;
+use ruff_db::system::SystemPath;
 use rustc_hash::FxHashMap;

+use ruff_db::files::{system_path_to_file, File};
+
 use super::vendored::vendored_typeshed_stubs;
 use crate::db::Db;
 use crate::module_name::ModuleName;
-use crate::{Program, PythonVersion};
+use crate::python_version::PythonVersion;
+
+#[derive(Debug)]
+pub(crate) struct LazyTypeshedVersions<'db>(OnceCell<&'db TypeshedVersions>);
+
+impl<'db> LazyTypeshedVersions<'db> {
+    #[must_use]
+    pub(crate) fn new() -> Self {
+        Self(OnceCell::new())
+    }
+
+    /// Query whether a module exists at runtime in the stdlib on a certain Python version.
+    ///
+    /// Simply probing whether a file exists in typeshed is insufficient for this question,
+    /// as a module in the stdlib may have been added in Python 3.10, but the typeshed stub
+    /// will still be available (either in a custom typeshed dir or in our vendored copy)
+    /// even if the user specified Python 3.8 as the target version.
+    ///
+    /// For top-level modules and packages, the VERSIONS file can always provide an unambiguous answer
+    /// as to whether the module exists on the specified target version. However, VERSIONS does not
+    /// provide comprehensive information on all submodules, meaning that this method sometimes
+    /// returns [`TypeshedVersionsQueryResult::MaybeExists`].
+    /// See [`TypeshedVersionsQueryResult`] for more details.
+    #[must_use]
+    pub(crate) fn query_module(
+        &self,
+        db: &'db dyn Db,
+        module: &ModuleName,
+        stdlib_root: Option<&SystemPath>,
+        target_version: PythonVersion,
+    ) -> TypeshedVersionsQueryResult {
+        let versions = self.0.get_or_init(|| {
+            let versions_path = if let Some(system_path) = stdlib_root {
+                system_path.join("VERSIONS")
+            } else {
+                return &VENDORED_VERSIONS;
+            };
+            let Ok(versions_file) = system_path_to_file(db.upcast(), &versions_path) else {
+                todo!(
+                    "Still need to figure out how to handle VERSIONS files being deleted \
+                    from custom typeshed directories! Expected a file to exist at {versions_path}"
+                )
+            };
+            // TODO(Alex/Micha): If VERSIONS is invalid,
+            // this should invalidate not just the specific module resolution we're currently attempting,
+            // but all type inference that depends on any standard-library types.
+            // Unwrapping here is not correct...
+            parse_typeshed_versions(db, versions_file).as_ref().unwrap()
+        });
+        versions.query_module(module, target_version)
+    }
+}
+
+#[salsa::tracked(return_ref)]
+pub(crate) fn parse_typeshed_versions(
+    db: &dyn Db,
+    versions_file: File,
+) -> Result<TypeshedVersions, TypeshedVersionsParseError> {
+    // TODO: Handle IO errors
+    let file_content = versions_file
+        .read_to_string(db.upcast())
+        .unwrap_or_default();
+    file_content.parse()
+}

 static VENDORED_VERSIONS: Lazy<TypeshedVersions> = Lazy::new(|| {
    TypeshedVersions::from_str(
@@ -21,14 +88,6 @@ static VENDORED_VERSIONS: Lazy<TypeshedVersions> = Lazy::new(|| {
    .unwrap()
 });

-pub(crate) fn vendored_typeshed_versions() -> &'static TypeshedVersions {
-    &VENDORED_VERSIONS
-}
-
-pub(crate) fn typeshed_versions(db: &dyn Db) -> &TypeshedVersions {
-    Program::get(db).search_paths(db).typeshed_versions()
-}
-
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub(crate) struct TypeshedVersionsParseError {
    line_number: Option<NonZeroU16>,
@@ -115,7 +174,7 @@ impl TypeshedVersions {
    }

    #[must_use]
-    pub(in crate::module_resolver) fn query_module(
+    fn query_module(
        &self,
        module: &ModuleName,
        target_version: PythonVersion,
@@ -145,7 +204,7 @@ impl TypeshedVersions {
    }
 }

-/// Possible answers [`TypeshedVersions::query_module()`] could give to the question:
+/// Possible answers [`LazyTypeshedVersions::query_module()`] could give to the question:
 /// "Does this module exist in the stdlib at runtime on a certain target version?"
 #[derive(Debug, Copy, PartialEq, Eq, Clone, Hash)]
 pub(crate) enum TypeshedVersionsQueryResult {
--- a/crates/red_knot_python_semantic/src/program.rs
+++ b/crates/red_knot_python_semantic/src/program.rs
@@ -3,7 +3,7 @@ use anyhow::Context;
 use salsa::Durability;
 use salsa::Setter;

-use ruff_db::system::{SystemPath, SystemPathBuf};
+use ruff_db::system::SystemPathBuf;

 use crate::module_resolver::SearchPaths;
 use crate::Db;
@@ -12,31 +12,33 @@ use crate::Db;
 pub struct Program {
    pub target_version: PythonVersion,

+    #[default]
    #[return_ref]
    pub(crate) search_paths: SearchPaths,
 }

 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 {
            target_version,
            search_paths,
        } = settings;

-        tracing::info!("Target version: Python {target_version}");
+        tracing::info!("Target version: {target_version}");

        let search_paths = SearchPaths::from_settings(db, search_paths)
            .with_context(|| "Invalid search path settings")?;

-        Ok(Program::builder(settings.target_version, search_paths)
+        Ok(Program::builder(settings.target_version)
            .durability(Durability::HIGH)
+            .search_paths(search_paths)
            .new(db))
    }

    pub fn update_search_paths(
-        self,
+        &self,
        db: &mut dyn Db,
-        search_path_settings: &SearchPathSettings,
+        search_path_settings: SearchPathSettings,
    ) -> anyhow::Result<()> {
        let search_paths = SearchPaths::from_settings(db, search_path_settings)?;

@@ -47,20 +49,16 @@ impl Program {

        Ok(())
    }
-
-    pub fn custom_stdlib_search_path(self, db: &dyn Db) -> Option<&SystemPath> {
-        self.search_paths(db).custom_stdlib()
-    }
 }

-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Debug, Eq, PartialEq)]
 pub struct ProgramSettings {
    pub target_version: PythonVersion,
    pub search_paths: SearchPathSettings,
 }

 /// Configures the search paths for module resolution.
-#[derive(Eq, PartialEq, Debug, Clone)]
+#[derive(Eq, PartialEq, Debug, Clone, Default)]
 pub struct SearchPathSettings {
    /// List of user-provided paths that should take first priority in the module resolution.
    /// Examples in other type checkers are mypy's MYPYPATH environment variable,
@@ -76,25 +74,5 @@ pub struct SearchPathSettings {
    pub custom_typeshed: Option<SystemPathBuf>,

    /// The path to the user's `site-packages` directory, where third-party packages from ``PyPI`` are installed.
-    pub site_packages: SitePackages,
-}
-
-impl SearchPathSettings {
-    pub fn new(src_root: SystemPathBuf) -> Self {
-        Self {
-            src_root,
-            extra_paths: vec![],
-            custom_typeshed: None,
-            site_packages: SitePackages::Known(vec![]),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum SitePackages {
-    Derived {
-        venv_path: SystemPathBuf,
-    },
-    /// Resolved site packages paths
-    Known(Vec<SystemPathBuf>),
+    pub site_packages: Vec<SystemPathBuf>,
 }
--- a/crates/red_knot_python_semantic/src/semantic_index.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index.rs
@@ -16,9 +16,10 @@ use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{
    FileScopeId, NodeWithScopeKey, NodeWithScopeRef, Scope, ScopeId, ScopedSymbolId, SymbolTable,
 };
-use crate::semantic_index::use_def::UseDefMap;
 use crate::Db;

+pub(crate) use self::use_def::UseDefMap;
+
 pub mod ast_ids;
 mod builder;
 pub mod definition;
@@ -26,8 +27,6 @@ pub mod expression;
 pub mod symbol;
 mod use_def;

-pub(crate) use self::use_def::{DefinitionWithConstraints, DefinitionWithConstraintsIterator};
-
 type SymbolMap = hashbrown::HashMap<ScopedSymbolId, (), ()>;

 /// Returns the semantic index for `file`.
@@ -127,7 +126,7 @@ impl<'db> SemanticIndex<'db> {
    ///
    /// Use the Salsa cached [`use_def_map()`] query if you only need the
    /// use-def map for a single scope.
-    pub(super) fn use_def_map(&self, scope_id: FileScopeId) -> Arc<UseDefMap> {
+    pub(super) fn use_def_map(&self, scope_id: FileScopeId) -> Arc<UseDefMap<'db>> {
        self.use_def_maps[scope_id].clone()
    }

@@ -154,10 +153,6 @@ impl<'db> SemanticIndex<'db> {
        &self.scopes[id]
    }

-    pub(crate) fn scope_ids(&self) -> impl Iterator<Item = ScopeId> {
-        self.scope_ids_by_scope.iter().copied()
-    }
-
    /// Returns the id of the parent scope.
    pub(crate) fn parent_scope_id(&self, scope_id: FileScopeId) -> Option<FileScopeId> {
        let scope = self.scope(scope_id);
@@ -315,29 +310,12 @@ mod tests {
    use ruff_text_size::{Ranged, TextRange};

    use crate::db::tests::TestDb;
-    use crate::semantic_index::ast_ids::{HasScopedUseId, ScopedUseId};
-    use crate::semantic_index::definition::{Definition, DefinitionKind};
-    use crate::semantic_index::symbol::{
-        FileScopeId, Scope, ScopeKind, ScopedSymbolId, SymbolTable,
-    };
-    use crate::semantic_index::use_def::UseDefMap;
+    use crate::semantic_index::ast_ids::HasScopedUseId;
+    use crate::semantic_index::definition::{DefinitionKind, DefinitionNode};
+    use crate::semantic_index::symbol::{FileScopeId, Scope, ScopeKind, SymbolTable};
    use crate::semantic_index::{global_scope, semantic_index, symbol_table, use_def_map};
    use crate::Db;

-    impl UseDefMap<'_> {
-        fn first_public_definition(&self, symbol: ScopedSymbolId) -> Option<Definition<'_>> {
-            self.public_definitions(symbol)
-                .next()
-                .map(|constrained_definition| constrained_definition.definition)
-        }
-
-        fn first_use_definition(&self, use_id: ScopedUseId) -> Option<Definition<'_>> {
-            self.use_definitions(use_id)
-                .next()
-                .map(|constrained_definition| constrained_definition.definition)
-        }
-    }
-
    struct TestCase {
        db: TestDb,
        file: File,
@@ -396,8 +374,11 @@ mod tests {
        let foo = global_table.symbol_id_by_name("foo").unwrap();

        let use_def = use_def_map(&db, scope);
-        let definition = use_def.first_public_definition(foo).unwrap();
-        assert!(matches!(definition.node(&db), DefinitionKind::Import(_)));
+        let definition = use_def.public_definition(foo).unwrap();
+        assert!(matches!(
+            definition.kind(&db),
+            DefinitionKind::Node(DefinitionNode::Import(_))
+        ));
    }

    #[test]
@@ -432,15 +413,15 @@ mod tests {

        let use_def = use_def_map(&db, scope);
        let definition = use_def
-            .first_public_definition(
+            .public_definition(
                global_table
                    .symbol_id_by_name("foo")
                    .expect("symbol to exist"),
            )
            .unwrap();
        assert!(matches!(
-            definition.node(&db),
-            DefinitionKind::ImportFrom(_)
+            definition.kind(&db),
+            DefinitionKind::Node(DefinitionNode::ImportFrom(_))
        ));
    }

@@ -459,30 +440,11 @@ mod tests {
        );
        let use_def = use_def_map(&db, scope);
        let definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("x").expect("symbol exists"))
+            .public_definition(global_table.symbol_id_by_name("x").expect("symbol exists"))
            .unwrap();
        assert!(matches!(
-            definition.node(&db),
-            DefinitionKind::Assignment(_)
-        ));
-    }
-
-    #[test]
-    fn augmented_assignment() {
-        let TestCase { db, file } = test_case("x += 1");
-        let scope = global_scope(&db, file);
-        let global_table = symbol_table(&db, scope);
-
-        assert_eq!(names(&global_table), vec!["x"]);
-
-        let use_def = use_def_map(&db, scope);
-        let definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("x").unwrap())
-            .unwrap();
-
-        assert!(matches!(
-            definition.node(&db),
-            DefinitionKind::AugmentedAssignment(_)
+            definition.kind(&db),
+            DefinitionKind::Node(DefinitionNode::Assignment(_))
        ));
    }

@@ -515,11 +477,11 @@ y = 2

        let use_def = index.use_def_map(class_scope_id);
        let definition = use_def
-            .first_public_definition(class_table.symbol_id_by_name("x").expect("symbol exists"))
+            .public_definition(class_table.symbol_id_by_name("x").expect("symbol exists"))
            .unwrap();
        assert!(matches!(
-            definition.node(&db),
-            DefinitionKind::Assignment(_)
+            definition.kind(&db),
+            DefinitionKind::Node(DefinitionNode::Assignment(_))
        ));
    }

@@ -551,115 +513,18 @@ y = 2

        let use_def = index.use_def_map(function_scope_id);
        let definition = use_def
-            .first_public_definition(
+            .public_definition(
                function_table
                    .symbol_id_by_name("x")
                    .expect("symbol exists"),
            )
            .unwrap();
        assert!(matches!(
-            definition.node(&db),
-            DefinitionKind::Assignment(_)
+            definition.kind(&db),
+            DefinitionKind::Node(DefinitionNode::Assignment(_))
        ));
    }

-    #[test]
-    fn function_parameter_symbols() {
-        let TestCase { db, file } = test_case(
-            "
-def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
-    pass
-",
-        );
-
-        let index = semantic_index(&db, file);
-        let global_table = symbol_table(&db, global_scope(&db, file));
-
-        assert_eq!(names(&global_table), vec!["f", "str", "int"]);
-
-        let [(function_scope_id, _function_scope)] = index
-            .child_scopes(FileScopeId::global())
-            .collect::<Vec<_>>()[..]
-        else {
-            panic!("Expected a function scope")
-        };
-
-        let function_table = index.symbol_table(function_scope_id);
-        assert_eq!(
-            names(&function_table),
-            vec!["a", "b", "c", "args", "d", "kwargs"],
-        );
-
-        let use_def = index.use_def_map(function_scope_id);
-        for name in ["a", "b", "c", "d"] {
-            let definition = use_def
-                .first_public_definition(
-                    function_table
-                        .symbol_id_by_name(name)
-                        .expect("symbol exists"),
-                )
-                .unwrap();
-            assert!(matches!(
-                definition.node(&db),
-                DefinitionKind::ParameterWithDefault(_)
-            ));
-        }
-        for name in ["args", "kwargs"] {
-            let definition = use_def
-                .first_public_definition(
-                    function_table
-                        .symbol_id_by_name(name)
-                        .expect("symbol exists"),
-                )
-                .unwrap();
-            assert!(matches!(definition.node(&db), DefinitionKind::Parameter(_)));
-        }
-    }
-
-    #[test]
-    fn lambda_parameter_symbols() {
-        let TestCase { db, file } = test_case("lambda a, b, c=1, *args, d=2, **kwargs: None");
-
-        let index = semantic_index(&db, file);
-        let global_table = symbol_table(&db, global_scope(&db, file));
-
-        assert!(names(&global_table).is_empty());
-
-        let [(lambda_scope_id, _lambda_scope)] = index
-            .child_scopes(FileScopeId::global())
-            .collect::<Vec<_>>()[..]
-        else {
-            panic!("Expected a lambda scope")
-        };
-
-        let lambda_table = index.symbol_table(lambda_scope_id);
-        assert_eq!(
-            names(&lambda_table),
-            vec!["a", "b", "c", "args", "d", "kwargs"],
-        );
-
-        let use_def = index.use_def_map(lambda_scope_id);
-        for name in ["a", "b", "c", "d"] {
-            let definition = use_def
-                .first_public_definition(
-                    lambda_table.symbol_id_by_name(name).expect("symbol exists"),
-                )
-                .unwrap();
-            assert!(matches!(
-                definition.node(&db),
-                DefinitionKind::ParameterWithDefault(_)
-            ));
-        }
-        for name in ["args", "kwargs"] {
-            let definition = use_def
-                .first_public_definition(
-                    lambda_table.symbol_id_by_name(name).expect("symbol exists"),
-                )
-                .unwrap();
-            assert!(matches!(definition.node(&db), DefinitionKind::Parameter(_)));
-        }
-    }
-
    /// Test case to validate that the comprehension scope is correctly identified and that the target
    /// variable is defined only in the comprehension scope and not in the global scope.
    #[test]
@@ -726,8 +591,10 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
        let element_use_id =
            element.scoped_use_id(&db, comprehension_scope_id.to_scope_id(&db, file));

-        let definition = use_def.first_use_definition(element_use_id).unwrap();
-        let DefinitionKind::Comprehension(comprehension) = definition.node(&db) else {
+        let definition = use_def.definition_for_use(element_use_id).unwrap();
+        let DefinitionKind::Node(DefinitionNode::Comprehension(comprehension)) =
+            definition.kind(&db)
+        else {
            panic!("expected generator definition")
        };
        let ast::Comprehension { target, .. } = comprehension.node();
@@ -741,7 +608,7 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
    /// the outer comprehension scope and the variables are correctly defined in the respective
    /// scopes.
    #[test]
-    fn nested_generators() {
+    fn nested_comprehensions() {
        let TestCase { db, file } = test_case(
            "
 [{x for x in iter2} for y in iter1]
@@ -774,7 +641,7 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
            .child_scopes(comprehension_scope_id)
            .collect::<Vec<_>>()[..]
        else {
-            panic!("expected one inner generator scope")
+            panic!("expected one inner comprehension scope")
        };

        assert_eq!(inner_comprehension_scope.kind(), ScopeKind::Comprehension);
@@ -790,56 +657,6 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
        assert_eq!(names(&inner_comprehension_symbol_table), vec!["x"]);
    }

-    #[test]
-    fn with_item_definition() {
-        let TestCase { db, file } = test_case(
-            "
-with item1 as x, item2 as y:
-    pass
-",
-        );
-
-        let index = semantic_index(&db, file);
-        let global_table = index.symbol_table(FileScopeId::global());
-
-        assert_eq!(names(&global_table), vec!["item1", "x", "item2", "y"]);
-
-        let use_def = index.use_def_map(FileScopeId::global());
-        for name in ["x", "y"] {
-            let Some(definition) = use_def.first_public_definition(
-                global_table.symbol_id_by_name(name).expect("symbol exists"),
-            ) else {
-                panic!("Expected with item definition for {name}");
-            };
-            assert!(matches!(definition.node(&db), DefinitionKind::WithItem(_)));
-        }
-    }
-
-    #[test]
-    fn with_item_unpacked_definition() {
-        let TestCase { db, file } = test_case(
-            "
-with context() as (x, y):
-    pass
-",
-        );
-
-        let index = semantic_index(&db, file);
-        let global_table = index.symbol_table(FileScopeId::global());
-
-        assert_eq!(names(&global_table), vec!["context", "x", "y"]);
-
-        let use_def = index.use_def_map(FileScopeId::global());
-        for name in ["x", "y"] {
-            let Some(definition) = use_def.first_public_definition(
-                global_table.symbol_id_by_name(name).expect("symbol exists"),
-            ) else {
-                panic!("Expected with item definition for {name}");
-            };
-            assert!(matches!(definition.node(&db), DefinitionKind::WithItem(_)));
-        }
-    }
-
    #[test]
    fn dupes() {
        let TestCase { db, file } = test_case(
@@ -874,13 +691,16 @@ def func():

        let use_def = index.use_def_map(FileScopeId::global());
        let definition = use_def
-            .first_public_definition(
+            .public_definition(
                global_table
                    .symbol_id_by_name("func")
                    .expect("symbol exists"),
            )
            .unwrap();
-        assert!(matches!(definition.node(&db), DefinitionKind::Function(_)));
+        assert!(matches!(
+            definition.kind(&db),
+            DefinitionKind::Node(DefinitionNode::Function(_))
+        ));
    }

    #[test]
@@ -980,8 +800,9 @@ class C[T]:
        };
        let x_use_id = x_use_expr_name.scoped_use_id(&db, scope);
        let use_def = use_def_map(&db, scope);
-        let definition = use_def.first_use_definition(x_use_id).unwrap();
-        let DefinitionKind::Assignment(assignment) = definition.node(&db) else {
+        let definition = use_def.definition_for_use(x_use_id).unwrap();
+        let DefinitionKind::Node(DefinitionNode::Assignment(assignment)) = definition.kind(&db)
+        else {
            panic!("should be an assignment definition")
        };
        let ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
@@ -1071,28 +892,4 @@ def x():
            vec!["bar", "foo", "Test", "<module>"]
        );
    }
-
-    #[test]
-    fn match_stmt_symbols() {
-        let TestCase { db, file } = test_case(
-            "
-match subject:
-    case a: ...
-    case [b, c, *d]: ...
-    case e as f: ...
-    case {'x': g, **h}: ...
-    case Foo(i, z=j): ...
-    case k | l: ...
-    case _: ...
-",
-        );
-
-        let global_table = symbol_table(&db, global_scope(&db, file));
-
-        assert!(global_table.symbol_by_name("Foo").unwrap().is_used());
-        assert_eq!(
-            names(&global_table),
-            vec!["subject", "a", "b", "c", "d", "f", "e", "h", "g", "Foo", "i", "j", "k", "l"]
-        );
-    }
 }
--- a/crates/red_knot_python_semantic/src/semantic_index/builder.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/builder.rs
@@ -7,27 +7,24 @@ use ruff_db::parsed::ParsedModule;
 use ruff_index::IndexVec;
 use ruff_python_ast as ast;
 use ruff_python_ast::name::Name;
-use ruff_python_ast::visitor::{walk_expr, walk_pattern, walk_stmt, Visitor};
-use ruff_python_ast::AnyParameterRef;
+use ruff_python_ast::visitor::{walk_expr, walk_stmt, Visitor};

 use crate::ast_node_ref::AstNodeRef;
 use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey;
 use crate::semantic_index::ast_ids::AstIdsBuilder;
 use crate::semantic_index::definition::{
-    AssignmentDefinitionNodeRef, ComprehensionDefinitionNodeRef, Definition, DefinitionNodeKey,
-    DefinitionNodeRef, ImportFromDefinitionNodeRef,
+    AssignmentDefinitionNodeRef, ComprehensionDefinitionNodeRef, Definition, DefinitionKind,
+    DefinitionNodeKey, DefinitionNodeRef, ImportFromDefinitionNodeRef,
 };
 use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{
    FileScopeId, NodeWithScopeKey, NodeWithScopeRef, Scope, ScopeId, ScopedSymbolId, SymbolFlags,
    SymbolTableBuilder,
 };
-use crate::semantic_index::use_def::{FlowSnapshot, UseDefMapBuilder};
+use crate::semantic_index::use_def::{BasicBlockId, UseDefMapBuilder};
 use crate::semantic_index::SemanticIndex;
 use crate::Db;

-use super::definition::WithItemDefinitionNodeRef;
-
 pub(super) struct SemanticIndexBuilder<'db> {
    // Builder state
    db: &'db dyn Db,
@@ -36,8 +33,8 @@ pub(super) struct SemanticIndexBuilder<'db> {
    scope_stack: Vec<FileScopeId>,
    /// The assignment we're currently visiting.
    current_assignment: Option<CurrentAssignment<'db>>,
-    /// Flow states at each `break` in the current loop.
-    loop_break_states: Vec<FlowSnapshot>,
+    /// Basic block ending at each `break` in the current loop.
+    loop_breaks: Vec<BasicBlockId>,

    // Semantic Index fields
    scopes: IndexVec<FileScopeId, Scope>,
@@ -59,7 +56,7 @@ impl<'db> SemanticIndexBuilder<'db> {
            module: parsed,
            scope_stack: Vec::new(),
            current_assignment: None,
-            loop_break_states: vec![],
+            loop_breaks: vec![],

            scopes: IndexVec::new(),
            symbol_tables: IndexVec::new(),
@@ -101,7 +98,8 @@ impl<'db> SemanticIndexBuilder<'db> {

        let file_scope_id = self.scopes.push(scope);
        self.symbol_tables.push(SymbolTableBuilder::new());
-        self.use_def_maps.push(UseDefMapBuilder::new());
+        self.use_def_maps
+            .push(UseDefMapBuilder::new(self.db, self.file, file_scope_id));
        let ast_id_scope = self.ast_ids.push(AstIdsBuilder::new());

        #[allow(unsafe_code)]
@@ -135,41 +133,50 @@ impl<'db> SemanticIndexBuilder<'db> {
        &mut self.symbol_tables[scope_id]
    }

-    fn current_use_def_map_mut(&mut self) -> &mut UseDefMapBuilder<'db> {
+    fn current_use_def_map(&mut self) -> &mut UseDefMapBuilder<'db> {
        let scope_id = self.current_scope();
        &mut self.use_def_maps[scope_id]
    }

-    fn current_use_def_map(&self) -> &UseDefMapBuilder<'db> {
-        let scope_id = self.current_scope();
-        &self.use_def_maps[scope_id]
-    }
-
    fn current_ast_ids(&mut self) -> &mut AstIdsBuilder {
        let scope_id = self.current_scope();
        &mut self.ast_ids[scope_id]
    }

-    fn flow_snapshot(&self) -> FlowSnapshot {
-        self.current_use_def_map().snapshot()
+    /// Start a new basic block and return the previous block's ID.
+    fn next_block(&mut self) -> BasicBlockId {
+        self.current_use_def_map().next_block(/* sealed */ true)
    }

-    fn flow_restore(&mut self, state: FlowSnapshot) {
-        self.current_use_def_map_mut().restore(state);
+    /// Start a new unsealed basic block and return the previous block's ID.
+    fn next_block_unsealed(&mut self) -> BasicBlockId {
+        self.current_use_def_map().next_block(/* sealed */ false)
    }

-    fn flow_merge(&mut self, state: FlowSnapshot) {
-        self.current_use_def_map_mut().merge(state);
+    /// Seal an unsealed basic block.
+    fn seal_block(&mut self) {
+        self.current_use_def_map().seal_current_block();
+    }
+
+    /// Start a new basic block with the given block as predecessor.
+    fn new_block_from(&mut self, predecessor: BasicBlockId) {
+        self.current_use_def_map()
+            .new_block_from(predecessor, /* sealed */ true);
+    }
+
+    /// Add a predecessor to the current block.
+    fn merge_block(&mut self, predecessor: BasicBlockId) {
+        self.current_use_def_map().merge_block(predecessor);
+    }
+
+    /// Add predecessors to the current block.
+    fn merge_blocks(&mut self, predecessors: Vec<BasicBlockId>) {
+        self.current_use_def_map().merge_blocks(predecessors);
    }

    fn add_or_update_symbol(&mut self, name: Name, flags: SymbolFlags) -> ScopedSymbolId {
        let symbol_table = self.current_symbol_table();
-        let (symbol_id, added) = symbol_table.add_or_update_symbol(name, flags);
-        if added {
-            let use_def_map = self.current_use_def_map_mut();
-            use_def_map.add_symbol(symbol_id);
-        }
-        symbol_id
+        symbol_table.add_or_update_symbol(name, flags)
    }

    fn add_definition<'a>(
@@ -184,30 +191,21 @@ impl<'db> SemanticIndexBuilder<'db> {
            self.current_scope(),
            symbol,
            #[allow(unsafe_code)]
-            unsafe {
-                definition_node.into_owned(self.module.clone())
-            },
+            DefinitionKind::Node(unsafe { definition_node.into_owned(self.module.clone()) }),
            countme::Count::default(),
        );

        self.definitions_by_node
            .insert(definition_node.key(), definition);
-        self.current_use_def_map_mut()
+        self.current_use_def_map()
            .record_definition(symbol, definition);

        definition
    }

-    fn add_constraint(&mut self, constraint_node: &ast::Expr) -> Expression<'db> {
-        let expression = self.add_standalone_expression(constraint_node);
-        self.current_use_def_map_mut().record_constraint(expression);
-
-        expression
-    }
-
    /// Record an expression that needs to be a Salsa ingredient, because we need to infer its type
    /// standalone (type narrowing tests, RHS of an assignment.)
-    fn add_standalone_expression(&mut self, expression_node: &ast::Expr) -> Expression<'db> {
+    fn add_standalone_expression(&mut self, expression_node: &ast::Expr) {
        let expression = Expression::new(
            self.db,
            self.file,
@@ -220,7 +218,6 @@ impl<'db> SemanticIndexBuilder<'db> {
        );
        self.expressions_by_node
            .insert(expression_node.into(), expression);
-        expression
    }

    fn with_type_params(
@@ -312,23 +309,6 @@ impl<'db> SemanticIndexBuilder<'db> {
        }
    }

-    fn declare_parameter(&mut self, parameter: AnyParameterRef) {
-        let symbol =
-            self.add_or_update_symbol(parameter.name().id().clone(), SymbolFlags::IS_DEFINED);
-
-        let definition = self.add_definition(symbol, parameter);
-
-        if let AnyParameterRef::NonVariadic(with_default) = parameter {
-            // Insert a mapping from the parameter to the same definition.
-            // This ensures that calling `HasTy::ty` on the inner parameter returns
-            // a valid type (and doesn't panic)
-            self.definitions_by_node.insert(
-                DefinitionNodeRef::from(AnyParameterRef::Variadic(&with_default.parameter)).key(),
-                definition,
-            );
-        }
-    }
-
    pub(super) fn build(mut self) -> SemanticIndex<'db> {
        let module = self.module;
        self.visit_body(module.suite());
@@ -396,16 +376,6 @@ where
                    .add_or_update_symbol(function_def.name.id.clone(), SymbolFlags::IS_DEFINED);
                self.add_definition(symbol, function_def);

-                // The default value of the parameters needs to be evaluated in the
-                // enclosing scope.
-                for default in function_def
-                    .parameters
-                    .iter_non_variadic_params()
-                    .filter_map(|param| param.default.as_deref())
-                {
-                    self.visit_expr(default);
-                }
-
                self.with_type_params(
                    NodeWithScopeRef::FunctionTypeParameters(function_def),
                    function_def.type_params.as_deref(),
@@ -416,12 +386,6 @@ where
                        }

                        builder.push_scope(NodeWithScopeRef::Function(function_def));
-
-                        // Add symbols and definitions for the parameters to the function scope.
-                        for parameter in &*function_def.parameters {
-                            builder.declare_parameter(parameter);
-                        }
-
                        builder.visit_body(&function_def.body);
                        builder.pop_scope()
                    },
@@ -497,38 +461,21 @@ where
                self.visit_expr(&node.target);
                self.current_assignment = None;
            }
-            ast::Stmt::AugAssign(
-                aug_assign @ ast::StmtAugAssign {
-                    range: _,
-                    target,
-                    op: _,
-                    value,
-                },
-            ) => {
-                debug_assert!(self.current_assignment.is_none());
-                self.visit_expr(value);
-                self.current_assignment = Some(aug_assign.into());
-                self.visit_expr(target);
-                self.current_assignment = None;
-            }
            ast::Stmt::If(node) => {
                self.visit_expr(&node.test);
-                let pre_if = self.flow_snapshot();
-                self.add_constraint(&node.test);
+                let pre_if = self.next_block();
                self.visit_body(&node.body);
-                let mut post_clauses: Vec<FlowSnapshot> = vec![];
+                let mut post_clauses: Vec<BasicBlockId> = vec![];
                for clause in &node.elif_else_clauses {
                    // snapshot after every block except the last; the last one will just become
                    // the state that we merge the other snapshots into
-                    post_clauses.push(self.flow_snapshot());
+                    post_clauses.push(self.next_block());
                    // we can only take an elif/else branch if none of the previous ones were
                    // taken, so the block entry state is always `pre_if`
-                    self.flow_restore(pre_if.clone());
+                    self.new_block_from(pre_if);
                    self.visit_elif_else_clause(clause);
                }
-                for post_clause_state in post_clauses {
-                    self.flow_merge(post_clause_state);
-                }
+                self.next_block_unsealed();
                let has_else = node
                    .elif_else_clauses
                    .last()
@@ -536,47 +483,39 @@ where
                if !has_else {
                    // if there's no else clause, then it's possible we took none of the branches,
                    // and the pre_if state can reach here
-                    self.flow_merge(pre_if);
+                    self.merge_block(pre_if);
                }
+                self.merge_blocks(post_clauses);
+                self.seal_block();
            }
            ast::Stmt::While(node) => {
                self.visit_expr(&node.test);

-                let pre_loop = self.flow_snapshot();
+                let pre_loop = self.next_block();

                // Save aside any break states from an outer loop
-                let saved_break_states = std::mem::take(&mut self.loop_break_states);
+                let saved_break_states = std::mem::take(&mut self.loop_breaks);
                self.visit_body(&node.body);
                // Get the break states from the body of this loop, and restore the saved outer
                // ones.
-                let break_states =
-                    std::mem::replace(&mut self.loop_break_states, saved_break_states);
+                let break_states = std::mem::replace(&mut self.loop_breaks, saved_break_states);

                // We may execute the `else` clause without ever executing the body, so merge in
                // the pre-loop state before visiting `else`.
-                self.flow_merge(pre_loop);
+                self.next_block_unsealed();
+                self.merge_block(pre_loop);
+                self.seal_block();
                self.visit_body(&node.orelse);

                // Breaking out of a while loop bypasses the `else` clause, so merge in the break
                // states after visiting `else`.
-                for break_state in break_states {
-                    self.flow_merge(break_state);
-                }
-            }
-            ast::Stmt::With(ast::StmtWith { items, body, .. }) => {
-                for item in items {
-                    self.visit_expr(&item.context_expr);
-                    if let Some(optional_vars) = item.optional_vars.as_deref() {
-                        self.add_standalone_expression(&item.context_expr);
-                        self.current_assignment = Some(item.into());
-                        self.visit_expr(optional_vars);
-                        self.current_assignment = None;
-                    }
-                }
-                self.visit_body(body);
+                self.next_block_unsealed();
+                self.merge_blocks(break_states);
+                self.seal_block();
            }
            ast::Stmt::Break(_) => {
-                self.loop_break_states.push(self.flow_snapshot());
+                let block_id = self.next_block();
+                self.loop_breaks.push(block_id);
            }
            _ => {
                walk_stmt(self, stmt);
@@ -591,21 +530,12 @@ where

        match expr {
            ast::Expr::Name(name_node @ ast::ExprName { id, ctx, .. }) => {
-                let mut flags = match ctx {
+                let flags = match ctx {
                    ast::ExprContext::Load => SymbolFlags::IS_USED,
                    ast::ExprContext::Store => SymbolFlags::IS_DEFINED,
                    ast::ExprContext::Del => SymbolFlags::IS_DEFINED,
                    ast::ExprContext::Invalid => SymbolFlags::empty(),
                };
-                if matches!(
-                    self.current_assignment,
-                    Some(CurrentAssignment::AugAssign(_))
-                ) && !ctx.is_invalid()
-                {
-                    // For augmented assignment, the target expression is also used, so we should
-                    // record that as a use.
-                    flags |= SymbolFlags::IS_USED;
-                }
                let symbol = self.add_or_update_symbol(id.clone(), flags);
                if flags.contains(SymbolFlags::IS_DEFINED) {
                    match self.current_assignment {
@@ -621,9 +551,6 @@ where
                        Some(CurrentAssignment::AnnAssign(ann_assign)) => {
                            self.add_definition(symbol, ann_assign);
                        }
-                        Some(CurrentAssignment::AugAssign(aug_assign)) => {
-                            self.add_definition(symbol, aug_assign);
-                        }
                        Some(CurrentAssignment::Named(named)) => {
                            // TODO(dhruvmanila): If the current scope is a comprehension, then the
                            // named expression is implicitly nonlocal. This is yet to be
@@ -636,22 +563,13 @@ where
                                ComprehensionDefinitionNodeRef { node, first },
                            );
                        }
-                        Some(CurrentAssignment::WithItem(with_item)) => {
-                            self.add_definition(
-                                symbol,
-                                WithItemDefinitionNodeRef {
-                                    node: with_item,
-                                    target: name_node,
-                                },
-                            );
-                        }
                        None => {}
                    }
                }

                if flags.contains(SymbolFlags::IS_USED) {
                    let use_id = self.current_ast_ids().record_use(expr);
-                    self.current_use_def_map_mut().record_use(symbol, use_id);
+                    self.current_use_def_map().record_use(symbol, use_id);
                }

                walk_expr(self, expr);
@@ -666,25 +584,9 @@ where
            }
            ast::Expr::Lambda(lambda) => {
                if let Some(parameters) = &lambda.parameters {
-                    // The default value of the parameters needs to be evaluated in the
-                    // enclosing scope.
-                    for default in parameters
-                        .iter_non_variadic_params()
-                        .filter_map(|param| param.default.as_deref())
-                    {
-                        self.visit_expr(default);
-                    }
                    self.visit_parameters(parameters);
                }
                self.push_scope(NodeWithScopeRef::Lambda(lambda));
-
-                // Add symbols and definitions for the parameters to the lambda scope.
-                if let Some(parameters) = &lambda.parameters {
-                    for parameter in &**parameters {
-                        self.declare_parameter(parameter);
-                    }
-                }
-
                self.visit_expr(lambda.body.as_ref());
            }
            ast::Expr::If(ast::ExprIf {
@@ -694,12 +596,14 @@ where
                // AST inspection, so we can't simplify here, need to record test expression for
                // later checking)
                self.visit_expr(test);
-                let pre_if = self.flow_snapshot();
+                let pre_if = self.next_block();
                self.visit_expr(body);
-                let post_body = self.flow_snapshot();
-                self.flow_restore(pre_if);
+                let post_body = self.next_block();
+                self.new_block_from(pre_if);
                self.visit_expr(orelse);
-                self.flow_merge(post_body);
+                self.next_block_unsealed();
+                self.merge_block(post_body);
+                self.seal_block();
            }
            ast::Expr::ListComp(
                list_comprehension @ ast::ExprListComp {
@@ -762,46 +666,17 @@ where
            self.pop_scope();
        }
    }
-
-    fn visit_parameters(&mut self, parameters: &'ast ruff_python_ast::Parameters) {
-        // Intentionally avoid walking default expressions, as we handle them in the enclosing
-        // scope.
-        for parameter in parameters.iter().map(ast::AnyParameterRef::as_parameter) {
-            self.visit_parameter(parameter);
-        }
-    }
-
-    fn visit_pattern(&mut self, pattern: &'ast ast::Pattern) {
-        if let ast::Pattern::MatchAs(ast::PatternMatchAs {
-            name: Some(name), ..
-        })
-        | ast::Pattern::MatchStar(ast::PatternMatchStar {
-            name: Some(name),
-            range: _,
-        })
-        | ast::Pattern::MatchMapping(ast::PatternMatchMapping {
-            rest: Some(name), ..
-        }) = pattern
-        {
-            // TODO(dhruvmanila): Add definition
-            self.add_or_update_symbol(name.id.clone(), SymbolFlags::IS_DEFINED);
-        }
-
-        walk_pattern(self, pattern);
-    }
 }

 #[derive(Copy, Clone, Debug)]
 enum CurrentAssignment<'a> {
    Assign(&'a ast::StmtAssign),
    AnnAssign(&'a ast::StmtAnnAssign),
-    AugAssign(&'a ast::StmtAugAssign),
    Named(&'a ast::ExprNamed),
    Comprehension {
        node: &'a ast::Comprehension,
        first: bool,
    },
-    WithItem(&'a ast::WithItem),
 }

 impl<'a> From<&'a ast::StmtAssign> for CurrentAssignment<'a> {
@@ -816,20 +691,8 @@ impl<'a> From<&'a ast::StmtAnnAssign> for CurrentAssignment<'a> {
    }
 }

-impl<'a> From<&'a ast::StmtAugAssign> for CurrentAssignment<'a> {
-    fn from(value: &'a ast::StmtAugAssign) -> Self {
-        Self::AugAssign(value)
-    }
-}
-
 impl<'a> From<&'a ast::ExprNamed> for CurrentAssignment<'a> {
    fn from(value: &'a ast::ExprNamed) -> Self {
        Self::Named(value)
    }
 }
-
-impl<'a> From<&'a ast::WithItem> for CurrentAssignment<'a> {
-    fn from(value: &'a ast::WithItem) -> Self {
-        Self::WithItem(value)
-    }
-}
--- a/crates/red_knot_python_semantic/src/semantic_index/definition.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/definition.rs
@@ -1,5 +1,6 @@
 use ruff_db::files::File;
 use ruff_db::parsed::ParsedModule;
+use ruff_index::newtype_index;
 use ruff_python_ast as ast;

 use crate::ast_node_ref::AstNodeRef;
@@ -8,7 +9,7 @@ use crate::semantic_index::symbol::{FileScopeId, ScopeId, ScopedSymbolId};
 use crate::Db;

 #[salsa::tracked]
-pub struct Definition<'db> {
+pub(crate) struct Definition<'db> {
    /// The file in which the definition occurs.
    #[id]
    pub(crate) file: File,
@@ -23,7 +24,7 @@ pub struct Definition<'db> {

    #[no_eq]
    #[return_ref]
-    pub(crate) node: DefinitionKind,
+    pub(crate) kind: DefinitionKind,

    #[no_eq]
    count: countme::Count<Definition<'static>>,
@@ -35,6 +36,22 @@ impl<'db> Definition<'db> {
    }
 }

+#[derive(Clone, Debug)]
+pub(crate) enum DefinitionKind {
+    /// Inserted at control-flow merge points, if multiple definitions can reach the merge point.
+    ///
+    /// Operands are not kept inline, since it's not possible to construct cyclically-referential
+    /// Salsa tracked structs; they are kept instead in the
+    /// [`UseDefMap`](super::use_def::UseDefMap).
+    Phi(ScopedPhiId),
+
+    /// An assignment to the symbol.
+    Node(DefinitionNode),
+}
+
+#[newtype_index]
+pub(crate) struct ScopedPhiId;
+
 #[derive(Copy, Clone, Debug)]
 pub(crate) enum DefinitionNodeRef<'a> {
    Import(&'a ast::Alias),
@@ -44,10 +61,7 @@ pub(crate) enum DefinitionNodeRef<'a> {
    NamedExpression(&'a ast::ExprNamed),
    Assignment(AssignmentDefinitionNodeRef<'a>),
    AnnotatedAssignment(&'a ast::StmtAnnAssign),
-    AugmentedAssignment(&'a ast::StmtAugAssign),
    Comprehension(ComprehensionDefinitionNodeRef<'a>),
-    Parameter(ast::AnyParameterRef<'a>),
-    WithItem(WithItemDefinitionNodeRef<'a>),
 }

 impl<'a> From<&'a ast::StmtFunctionDef> for DefinitionNodeRef<'a> {
@@ -74,12 +88,6 @@ impl<'a> From<&'a ast::StmtAnnAssign> for DefinitionNodeRef<'a> {
    }
 }

-impl<'a> From<&'a ast::StmtAugAssign> for DefinitionNodeRef<'a> {
-    fn from(node: &'a ast::StmtAugAssign) -> Self {
-        Self::AugmentedAssignment(node)
-    }
-}
-
 impl<'a> From<&'a ast::Alias> for DefinitionNodeRef<'a> {
    fn from(node_ref: &'a ast::Alias) -> Self {
        Self::Import(node_ref)
@@ -98,24 +106,12 @@ impl<'a> From<AssignmentDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
    }
 }

-impl<'a> From<WithItemDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
-    fn from(node_ref: WithItemDefinitionNodeRef<'a>) -> Self {
-        Self::WithItem(node_ref)
-    }
-}
-
 impl<'a> From<ComprehensionDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
    fn from(node: ComprehensionDefinitionNodeRef<'a>) -> Self {
        Self::Comprehension(node)
    }
 }

-impl<'a> From<ast::AnyParameterRef<'a>> for DefinitionNodeRef<'a> {
-    fn from(node: ast::AnyParameterRef<'a>) -> Self {
-        Self::Parameter(node)
-    }
-}
-
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct ImportFromDefinitionNodeRef<'a> {
    pub(crate) node: &'a ast::StmtImportFrom,
@@ -128,12 +124,6 @@ pub(crate) struct AssignmentDefinitionNodeRef<'a> {
    pub(crate) target: &'a ast::ExprName,
 }

-#[derive(Copy, Clone, Debug)]
-pub(crate) struct WithItemDefinitionNodeRef<'a> {
-    pub(crate) node: &'a ast::WithItem,
-    pub(crate) target: &'a ast::ExprName,
-}
-
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct ComprehensionDefinitionNodeRef<'a> {
    pub(crate) node: &'a ast::Comprehension,
@@ -142,58 +132,41 @@ pub(crate) struct ComprehensionDefinitionNodeRef<'a> {

 impl DefinitionNodeRef<'_> {
    #[allow(unsafe_code)]
-    pub(super) unsafe fn into_owned(self, parsed: ParsedModule) -> DefinitionKind {
+    pub(super) unsafe fn into_owned(self, parsed: ParsedModule) -> DefinitionNode {
        match self {
            DefinitionNodeRef::Import(alias) => {
-                DefinitionKind::Import(AstNodeRef::new(parsed, alias))
+                DefinitionNode::Import(AstNodeRef::new(parsed, alias))
            }
            DefinitionNodeRef::ImportFrom(ImportFromDefinitionNodeRef { node, alias_index }) => {
-                DefinitionKind::ImportFrom(ImportFromDefinitionKind {
+                DefinitionNode::ImportFrom(ImportFromDefinitionNode {
                    node: AstNodeRef::new(parsed, node),
                    alias_index,
                })
            }
            DefinitionNodeRef::Function(function) => {
-                DefinitionKind::Function(AstNodeRef::new(parsed, function))
+                DefinitionNode::Function(AstNodeRef::new(parsed, function))
            }
            DefinitionNodeRef::Class(class) => {
-                DefinitionKind::Class(AstNodeRef::new(parsed, class))
+                DefinitionNode::Class(AstNodeRef::new(parsed, class))
            }
            DefinitionNodeRef::NamedExpression(named) => {
-                DefinitionKind::NamedExpression(AstNodeRef::new(parsed, named))
+                DefinitionNode::NamedExpression(AstNodeRef::new(parsed, named))
            }
            DefinitionNodeRef::Assignment(AssignmentDefinitionNodeRef { assignment, target }) => {
-                DefinitionKind::Assignment(AssignmentDefinitionKind {
+                DefinitionNode::Assignment(AssignmentDefinitionNode {
                    assignment: AstNodeRef::new(parsed.clone(), assignment),
                    target: AstNodeRef::new(parsed, target),
                })
            }
            DefinitionNodeRef::AnnotatedAssignment(assign) => {
-                DefinitionKind::AnnotatedAssignment(AstNodeRef::new(parsed, assign))
-            }
-            DefinitionNodeRef::AugmentedAssignment(augmented_assignment) => {
-                DefinitionKind::AugmentedAssignment(AstNodeRef::new(parsed, augmented_assignment))
+                DefinitionNode::AnnotatedAssignment(AstNodeRef::new(parsed, assign))
            }
            DefinitionNodeRef::Comprehension(ComprehensionDefinitionNodeRef { node, first }) => {
-                DefinitionKind::Comprehension(ComprehensionDefinitionKind {
+                DefinitionNode::Comprehension(ComprehensionDefinitionNode {
                    node: AstNodeRef::new(parsed, node),
                    first,
                })
            }
-            DefinitionNodeRef::Parameter(parameter) => match parameter {
-                ast::AnyParameterRef::Variadic(parameter) => {
-                    DefinitionKind::Parameter(AstNodeRef::new(parsed, parameter))
-                }
-                ast::AnyParameterRef::NonVariadic(parameter) => {
-                    DefinitionKind::ParameterWithDefault(AstNodeRef::new(parsed, parameter))
-                }
-            },
-            DefinitionNodeRef::WithItem(WithItemDefinitionNodeRef { node, target }) => {
-                DefinitionKind::WithItem(WithItemDefinitionKind {
-                    node: AstNodeRef::new(parsed.clone(), node),
-                    target: AstNodeRef::new(parsed, target),
-                })
-            }
        }
    }

@@ -211,40 +184,30 @@ impl DefinitionNodeRef<'_> {
                target,
            }) => target.into(),
            Self::AnnotatedAssignment(node) => node.into(),
-            Self::AugmentedAssignment(node) => node.into(),
            Self::Comprehension(ComprehensionDefinitionNodeRef { node, first: _ }) => node.into(),
-            Self::Parameter(node) => match node {
-                ast::AnyParameterRef::Variadic(parameter) => parameter.into(),
-                ast::AnyParameterRef::NonVariadic(parameter) => parameter.into(),
-            },
-            Self::WithItem(WithItemDefinitionNodeRef { node: _, target }) => target.into(),
        }
    }
 }

 #[derive(Clone, Debug)]
-pub enum DefinitionKind {
+pub enum DefinitionNode {
    Import(AstNodeRef<ast::Alias>),
-    ImportFrom(ImportFromDefinitionKind),
+    ImportFrom(ImportFromDefinitionNode),
    Function(AstNodeRef<ast::StmtFunctionDef>),
    Class(AstNodeRef<ast::StmtClassDef>),
    NamedExpression(AstNodeRef<ast::ExprNamed>),
-    Assignment(AssignmentDefinitionKind),
+    Assignment(AssignmentDefinitionNode),
    AnnotatedAssignment(AstNodeRef<ast::StmtAnnAssign>),
-    AugmentedAssignment(AstNodeRef<ast::StmtAugAssign>),
-    Comprehension(ComprehensionDefinitionKind),
-    Parameter(AstNodeRef<ast::Parameter>),
-    ParameterWithDefault(AstNodeRef<ast::ParameterWithDefault>),
-    WithItem(WithItemDefinitionKind),
+    Comprehension(ComprehensionDefinitionNode),
 }

 #[derive(Clone, Debug)]
-pub struct ComprehensionDefinitionKind {
+pub struct ComprehensionDefinitionNode {
    node: AstNodeRef<ast::Comprehension>,
    first: bool,
 }

-impl ComprehensionDefinitionKind {
+impl ComprehensionDefinitionNode {
    pub(crate) fn node(&self) -> &ast::Comprehension {
        self.node.node()
    }
@@ -255,12 +218,12 @@ impl ComprehensionDefinitionKind {
 }

 #[derive(Clone, Debug)]
-pub struct ImportFromDefinitionKind {
+pub struct ImportFromDefinitionNode {
    node: AstNodeRef<ast::StmtImportFrom>,
    alias_index: usize,
 }

-impl ImportFromDefinitionKind {
+impl ImportFromDefinitionNode {
    pub(crate) fn import(&self) -> &ast::StmtImportFrom {
        self.node.node()
    }
@@ -271,35 +234,16 @@ impl ImportFromDefinitionKind {
 }

 #[derive(Clone, Debug)]
-pub struct AssignmentDefinitionKind {
+#[allow(dead_code)]
+pub struct AssignmentDefinitionNode {
    assignment: AstNodeRef<ast::StmtAssign>,
    target: AstNodeRef<ast::ExprName>,
 }

-impl AssignmentDefinitionKind {
+impl AssignmentDefinitionNode {
    pub(crate) fn assignment(&self) -> &ast::StmtAssign {
        self.assignment.node()
    }
-
-    pub(crate) fn target(&self) -> &ast::ExprName {
-        self.target.node()
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct WithItemDefinitionKind {
-    node: AstNodeRef<ast::WithItem>,
-    target: AstNodeRef<ast::ExprName>,
-}
-
-impl WithItemDefinitionKind {
-    pub(crate) fn node(&self) -> &ast::WithItem {
-        self.node.node()
-    }
-
-    pub(crate) fn target(&self) -> &ast::ExprName {
-        self.target.node()
-    }
 }

 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
@@ -341,26 +285,8 @@ impl From<&ast::StmtAnnAssign> for DefinitionNodeKey {
    }
 }

-impl From<&ast::StmtAugAssign> for DefinitionNodeKey {
-    fn from(node: &ast::StmtAugAssign) -> Self {
-        Self(NodeKey::from_node(node))
-    }
-}
-
 impl From<&ast::Comprehension> for DefinitionNodeKey {
    fn from(node: &ast::Comprehension) -> Self {
        Self(NodeKey::from_node(node))
    }
 }
-
-impl From<&ast::Parameter> for DefinitionNodeKey {
-    fn from(node: &ast::Parameter) -> Self {
-        Self(NodeKey::from_node(node))
-    }
-}
-
-impl From<&ast::ParameterWithDefault> for DefinitionNodeKey {
-    fn from(node: &ast::ParameterWithDefault) -> Self {
-        Self(NodeKey::from_node(node))
-    }
-}
--- a/crates/red_knot_python_semantic/src/semantic_index/expression.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/expression.rs
@@ -21,7 +21,7 @@ pub(crate) struct Expression<'db> {
    /// The expression node.
    #[no_eq]
    #[return_ref]
-    pub(crate) node_ref: AstNodeRef<ast::Expr>,
+    pub(crate) node: AstNodeRef<ast::Expr>,

    #[no_eq]
    count: countme::Count<Expression<'static>>,
--- a/crates/red_knot_python_semantic/src/semantic_index/symbol.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/symbol.rs
@@ -272,7 +272,7 @@ impl SymbolTableBuilder {
        &mut self,
        name: Name,
        flags: SymbolFlags,
-    ) -> (ScopedSymbolId, bool) {
+    ) -> ScopedSymbolId {
        let hash = SymbolTable::hash_name(&name);
        let entry = self
            .table
@@ -285,7 +285,7 @@ impl SymbolTableBuilder {
                let symbol = &mut self.table.symbols[*entry.key()];
                symbol.insert_flags(flags);

-                (*entry.key(), false)
+                *entry.key()
            }
            RawEntryMut::Vacant(entry) => {
                let mut symbol = Symbol::new(name);
@@ -295,7 +295,7 @@ impl SymbolTableBuilder {
                entry.insert_with_hasher(hash, id, (), |id| {
                    SymbolTable::hash_name(self.table.symbols[*id].name().as_str())
                });
-                (id, true)
+                id
            }
        }
    }
--- a/crates/red_knot_python_semantic/src/semantic_index/use_def.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/use_def.rs
@@ -1,5 +1,4 @@
-//! Build a map from each use of a symbol to the definitions visible from that use, and the
-//! type-narrowing constraints that apply to each definition.
+//! Build a map from each use of a symbol to the definitions visible from that use.
 //!
 //! Let's take this code sample:
 //!
@@ -7,7 +6,7 @@
 //! x = 1
 //! x = 2
 //! y = x
-//! if y is not None:
+//! if flag:
 //!     x = 3
 //! else:
 //!     x = 4
@@ -35,8 +34,8 @@
 //! [`AstIds`](crate::semantic_index::ast_ids::AstIds) we number all uses (that means a `Name` node
 //! with `Load` context) so we have a `ScopedUseId` to efficiently represent each use.
 //!
-//! Another case we need to handle is when a symbol is referenced from a different scope (the most
-//! obvious example of this is an import). We call this "public" use of a symbol. So the other
+//! The other case we need to handle is when a symbol is referenced from a different scope (the
+//! most obvious example of this is an import). We call this "public" use of a symbol. So the other
 //! question we need to be able to answer is, what are the publicly-visible definitions of each
 //! symbol?
 //!
@@ -54,322 +53,326 @@
 //! start.)
 //!
 //! So this means that the publicly-visible definitions of a symbol are the definitions still
-//! visible at the end of the scope; effectively we have an implicit "use" of every symbol at the
-//! end of the scope.
+//! visible at the end of the scope.
 //!
-//! We also need to know, for a given definition of a symbol, what type-narrowing constraints apply
-//! to it. For instance, in this code sample:
+//! The data structure we build to answer these two questions is the `UseDefMap`. It has a
+//! `definitions_by_use` vector indexed by [`ScopedUseId`] and a `public_definitions` map
+//! indexed by [`ScopedSymbolId`]. The values in each are the visible definition of a symbol at
+//! that use, or at the end of the scope.
 //!
-//! ```python
-//! x = 1 if flag else None
-//! if x is not None:
-//!     y = x
-//! ```
-//!
-//! At the use of `x` in `y = x`, the visible definition of `x` is `1 if flag else None`, which
-//! would infer as the type `Literal[1] | None`. But the constraint `x is not None` dominates this
-//! use, which means we can rule out the possibility that `x` is `None` here, which should give us
-//! the type `Literal[1]` for this use.
-//!
-//! The data structure we build to answer these questions is the `UseDefMap`. It has a
-//! `definitions_by_use` vector indexed by [`ScopedUseId`] and a `public_definitions` vector
-//! indexed by [`ScopedSymbolId`]. The values in each of these vectors are (in principle) a list of
-//! visible definitions at that use, or at the end of the scope for that symbol, with a list of the
-//! dominating constraints for each of those definitions.
-//!
-//! In order to avoid vectors-of-vectors-of-vectors and all the allocations that would entail, we
-//! don't actually store these "list of visible definitions" as a vector of [`Definition`].
-//! Instead, the values in `definitions_by_use` and `public_definitions` are a [`SymbolState`]
-//! struct which uses bit-sets to track definitions and constraints in terms of
-//! [`ScopedDefinitionId`] and [`ScopedConstraintId`], which are indices into the `all_definitions`
-//! and `all_constraints` indexvecs in the [`UseDefMap`].
-//!
-//! There is another special kind of possible "definition" for a symbol: there might be a path from
-//! the scope entry to a given use in which the symbol is never bound.
-//!
-//! The simplest way to model "unbound" would be as an actual [`Definition`] itself: the initial
-//! visible [`Definition`] for each symbol in a scope. But actually modeling it this way would
-//! unnecessarily increase the number of [`Definition`] that Salsa must track. Since "unbound" is a
-//! special definition in that all symbols share it, and it doesn't have any additional per-symbol
-//! state, and constraints are irrelevant to it, we can represent it more efficiently: we use the
-//! `may_be_unbound` boolean on the [`SymbolState`] struct. If this flag is `true`, it means the
-//! symbol/use really has one additional visible "definition", which is the unbound state. If this
-//! flag is `false`, it means we've eliminated the possibility of unbound: every path we've
-//! followed includes a definition for this symbol.
-//!
-//! To build a [`UseDefMap`], the [`UseDefMapBuilder`] is notified of each new use, definition, and
-//! constraint as they are encountered by the
-//! [`SemanticIndexBuilder`](crate::semantic_index::builder::SemanticIndexBuilder) AST visit. For
-//! each symbol, the builder tracks the `SymbolState` for that symbol. When we hit a use of a
-//! symbol, it records the current state for that symbol for that use. When we reach the end of the
-//! scope, it records the state for each symbol as the public definitions of that symbol.
-//!
-//! Let's walk through the above example. Initially we record for `x` that it has no visible
-//! definitions, and may be unbound. When we see `x = 1`, we record that as the sole visible
-//! definition of `x`, and flip `may_be_unbound` to `false`. Then we see `x = 2`, and it replaces
-//! `x = 1` as the sole visible definition of `x`. When we get to `y = x`, we record that the
-//! visible definitions for that use of `x` are just the `x = 2` definition.
-//!
-//! Then we hit the `if` branch. We visit the `test` node (`flag` in this case), since that will
-//! happen regardless. Then we take a pre-branch snapshot of the currently visible definitions for
-//! all symbols, which we'll need later. Then we record `flag` as a possible constraint on the
-//! currently visible definition (`x = 2`), and go ahead and visit the `if` body. When we see `x =
-//! 3`, it replaces `x = 2` (constrained by `flag`) as the sole visible definition of `x`. At the
-//! end of the `if` body, we take another snapshot of the currently-visible definitions; we'll call
-//! this the post-if-body snapshot.
-//!
-//! Now we need to visit the `else` clause. The conditions when entering the `else` clause should
-//! be the pre-if conditions; if we are entering the `else` clause, we know that the `if` test
-//! failed and we didn't execute the `if` body. So we first reset the builder to the pre-if state,
-//! using the snapshot we took previously (meaning we now have `x = 2` as the sole visible
-//! definition for `x` again), then visit the `else` clause, where `x = 4` replaces `x = 2` as the
-//! sole visible definition of `x`.
-//!
-//! Now we reach the end of the if/else, and want to visit the following code. The state here needs
-//! to reflect that we might have gone through the `if` branch, or we might have gone through the
-//! `else` branch, and we don't know which. So we need to "merge" our current builder state
-//! (reflecting the end-of-else state, with `x = 4` as the only visible definition) with our
-//! post-if-body snapshot (which has `x = 3` as the only visible definition). The result of this
-//! merge is that we now have two visible definitions of `x`: `x = 3` and `x = 4`.
-//!
-//! The [`UseDefMapBuilder`] itself just exposes methods for taking a snapshot, resetting to a
-//! snapshot, and merging a snapshot into the current state. The logic using these methods lives in
-//! [`SemanticIndexBuilder`](crate::semantic_index::builder::SemanticIndexBuilder), e.g. where it
-//! visits a `StmtIf` node.
-//!
-//! (In the future we may have some other questions we want to answer as well, such as "is this
-//! definition used?", which will require tracking a bit more info in our map, e.g. a "used" bit
-//! for each [`Definition`] which is flipped to true when we record that definition for a use.)
-use self::symbol_state::{
-    ConstraintIdIterator, DefinitionIdWithConstraintsIterator, ScopedConstraintId,
-    ScopedDefinitionId, SymbolState,
-};
+//! Rather than have multiple definitions, we use a Phi definition at control flow join points to
+//! merge the visible definition in each path. This means at any given point we always have exactly
+//! one definition for a symbol. (This is analogous to static-single-assignment, or SSA, form, and
+//! in fact we use the algorithm from [Simple and efficient construction of static single
+//! assignment form](https://dl.acm.org/doi/10.1007/978-3-642-37051-9_6) here.)
 use crate::semantic_index::ast_ids::ScopedUseId;
-use crate::semantic_index::definition::Definition;
-use crate::semantic_index::expression::Expression;
-use crate::semantic_index::symbol::ScopedSymbolId;
-use ruff_index::IndexVec;
+use crate::semantic_index::definition::{Definition, DefinitionKind, ScopedPhiId};
+use crate::semantic_index::symbol::{FileScopeId, ScopedSymbolId};
+use crate::Db;
+use ruff_db::files::File;
+use ruff_index::{newtype_index, IndexVec};
+use rustc_hash::{FxHashMap, FxHashSet};
+use smallvec::{smallvec, SmallVec};

-mod bitset;
-mod symbol_state;
+/// Number of basic block predecessors we store inline.
+const PREDECESSORS: usize = 2;

-/// Applicable definitions and constraints for every use of a name.
+/// Input operands (definitions) for a Phi definition. None means not defined.
+// TODO would like to use SmallVec here but can't due to lifetime invariance issue.
+type PhiOperands<'db> = Vec<Option<Definition<'db>>>;
+
+/// Definition for each use of a name.
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) struct UseDefMap<'db> {
-    /// Array of [`Definition`] in this scope.
-    all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,
+    // TODO store constraints with definitions for type narrowing
+    /// Definition that reaches each [`ScopedUseId`].
+    definitions_by_use: IndexVec<ScopedUseId, Option<Definition<'db>>>,

-    /// Array of constraints (as [`Expression`]) in this scope.
-    all_constraints: IndexVec<ScopedConstraintId, Expression<'db>>,
+    /// Definition of each symbol visible at end of scope.
+    ///
+    /// Sparse, because it only includes symbols defined in the scope.
+    public_definitions: FxHashMap<ScopedSymbolId, Definition<'db>>,

-    /// [`SymbolState`] visible at a [`ScopedUseId`].
-    definitions_by_use: IndexVec<ScopedUseId, SymbolState>,
-
-    /// [`SymbolState`] visible at end of scope for each symbol.
-    public_definitions: IndexVec<ScopedSymbolId, SymbolState>,
+    /// Operands for each Phi definition in this scope.
+    phi_operands: IndexVec<ScopedPhiId, PhiOperands<'db>>,
 }

 impl<'db> UseDefMap<'db> {
-    pub(crate) fn use_definitions(
-        &self,
-        use_id: ScopedUseId,
-    ) -> DefinitionWithConstraintsIterator<'_, 'db> {
-        DefinitionWithConstraintsIterator {
-            all_definitions: &self.all_definitions,
-            all_constraints: &self.all_constraints,
-            inner: self.definitions_by_use[use_id].visible_definitions(),
-        }
+    /// Return the dominating definition for a given use of a name; None means not-defined.
+    pub(crate) fn definition_for_use(&self, use_id: ScopedUseId) -> Option<Definition<'db>> {
+        self.definitions_by_use[use_id]
    }

-    pub(crate) fn use_may_be_unbound(&self, use_id: ScopedUseId) -> bool {
-        self.definitions_by_use[use_id].may_be_unbound()
+    /// Return the definition visible at end of scope for a symbol.
+    ///
+    /// Return None if the symbol is never defined in the scope.
+    pub(crate) fn public_definition(&self, symbol_id: ScopedSymbolId) -> Option<Definition<'db>> {
+        self.public_definitions.get(&symbol_id).copied()
    }

-    pub(crate) fn public_definitions(
-        &self,
-        symbol: ScopedSymbolId,
-    ) -> DefinitionWithConstraintsIterator<'_, 'db> {
-        DefinitionWithConstraintsIterator {
-            all_definitions: &self.all_definitions,
-            all_constraints: &self.all_constraints,
-            inner: self.public_definitions[symbol].visible_definitions(),
-        }
-    }
-
-    pub(crate) fn public_may_be_unbound(&self, symbol: ScopedSymbolId) -> bool {
-        self.public_definitions[symbol].may_be_unbound()
+    /// Return the operands for a Phi in this scope; a None means not-defined.
+    pub(crate) fn phi_operands<'s>(&'s self, phi_id: ScopedPhiId) -> &'s [Option<Definition<'db>>] {
+        self.phi_operands[phi_id].as_slice()
    }
 }

-#[derive(Debug)]
-pub(crate) struct DefinitionWithConstraintsIterator<'map, 'db> {
-    all_definitions: &'map IndexVec<ScopedDefinitionId, Definition<'db>>,
-    all_constraints: &'map IndexVec<ScopedConstraintId, Expression<'db>>,
-    inner: DefinitionIdWithConstraintsIterator<'map>,
-}
+type PredecessorBlocks = SmallVec<[BasicBlockId; PREDECESSORS]>;

-impl<'map, 'db> Iterator for DefinitionWithConstraintsIterator<'map, 'db> {
-    type Item = DefinitionWithConstraints<'map, 'db>;
+/// A basic block is a linear region of code (no branches.)
+#[newtype_index]
+pub(super) struct BasicBlockId;

-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner
-            .next()
-            .map(|def_id_with_constraints| DefinitionWithConstraints {
-                definition: self.all_definitions[def_id_with_constraints.definition],
-                constraints: ConstraintsIterator {
-                    all_constraints: self.all_constraints,
-                    constraint_ids: def_id_with_constraints.constraint_ids,
-                },
-            })
-    }
-}
-
-impl std::iter::FusedIterator for DefinitionWithConstraintsIterator<'_, '_> {}
-
-pub(crate) struct DefinitionWithConstraints<'map, 'db> {
-    pub(crate) definition: Definition<'db>,
-    pub(crate) constraints: ConstraintsIterator<'map, 'db>,
-}
-
-pub(crate) struct ConstraintsIterator<'map, 'db> {
-    all_constraints: &'map IndexVec<ScopedConstraintId, Expression<'db>>,
-    constraint_ids: ConstraintIdIterator<'map>,
-}
-
-impl<'map, 'db> Iterator for ConstraintsIterator<'map, 'db> {
-    type Item = Expression<'db>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.constraint_ids
-            .next()
-            .map(|constraint_id| self.all_constraints[constraint_id])
-    }
-}
-
-impl std::iter::FusedIterator for ConstraintsIterator<'_, '_> {}
-
-/// A snapshot of the definitions and constraints state at a particular point in control flow.
-#[derive(Clone, Debug)]
-pub(super) struct FlowSnapshot {
-    definitions_by_symbol: IndexVec<ScopedSymbolId, SymbolState>,
-}
-
-#[derive(Debug, Default)]
 pub(super) struct UseDefMapBuilder<'db> {
-    /// Append-only array of [`Definition`]; None is unbound.
-    all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,
+    db: &'db dyn Db,
+    file: File,
+    file_scope: FileScopeId,

-    /// Append-only array of constraints (as [`Expression`]).
-    all_constraints: IndexVec<ScopedConstraintId, Expression<'db>>,
+    /// Predecessor blocks for each basic block.
+    ///
+    /// Entry block has none, all other blocks have at least one, blocks that join control flow can
+    /// have two or more.
+    predecessors: IndexVec<BasicBlockId, PredecessorBlocks>,

-    /// Visible definitions at each so-far-recorded use.
-    definitions_by_use: IndexVec<ScopedUseId, SymbolState>,
+    /// The definition of each symbol which dominates each basic block.
+    ///
+    /// No entry means "lazily unfilled"; we haven't had to query for it yet, and we may never have
+    /// to, if the symbol isn't used in this block or any successor block.
+    ///
+    /// Each block has an [`FxHashMap`] of symbols instead of an [`IndexVec`] because it is lazy
+    /// and potentially sparse; it will only include a definition for a symbol that is actually
+    /// used in that block or a successor. An [`IndexVec`] would have to be eagerly filled with
+    /// placeholders.
+    definitions_per_block:
+        IndexVec<BasicBlockId, FxHashMap<ScopedSymbolId, Option<Definition<'db>>>>,

-    /// Currently visible definitions for each symbol.
-    definitions_by_symbol: IndexVec<ScopedSymbolId, SymbolState>,
+    /// Incomplete Phi definitions in each block.
+    ///
+    /// An incomplete Phi is used when we don't know, while processing a block's body, what new
+    /// predecessors it may later gain (that is, backward jumps.)
+    ///
+    /// Sparse, because relative few blocks (just loop headers) will have any incomplete Phis.
+    incomplete_phis: FxHashMap<BasicBlockId, Vec<Definition<'db>>>,
+
+    /// Operands for each Phi definition in this scope.
+    phi_operands: IndexVec<ScopedPhiId, PhiOperands<'db>>,
+
+    /// Are this block's predecessors fully populated?
+    ///
+    /// If not, it isn't safe to recurse to predecessors yet; we might miss a predecessor block.
+    sealed_blocks: IndexVec<BasicBlockId, bool>,
+
+    /// Definition for each so-far-recorded use.
+    definitions_by_use: IndexVec<ScopedUseId, Option<Definition<'db>>>,
+
+    /// All symbols defined in this scope.
+    defined_symbols: FxHashSet<ScopedSymbolId>,
 }

 impl<'db> UseDefMapBuilder<'db> {
-    pub(super) fn new() -> Self {
-        Self::default()
-    }
-
-    pub(super) fn add_symbol(&mut self, symbol: ScopedSymbolId) {
-        let new_symbol = self.definitions_by_symbol.push(SymbolState::unbound());
-        debug_assert_eq!(symbol, new_symbol);
+    pub(super) fn new(db: &'db dyn Db, file: File, file_scope: FileScopeId) -> Self {
+        let mut new = Self {
+            db,
+            file,
+            file_scope,
+            predecessors: IndexVec::new(),
+            definitions_per_block: IndexVec::new(),
+            incomplete_phis: FxHashMap::default(),
+            sealed_blocks: IndexVec::new(),
+            definitions_by_use: IndexVec::new(),
+            phi_operands: IndexVec::new(),
+            defined_symbols: FxHashSet::default(),
+        };
+
+        // create the entry basic block
+        new.predecessors.push(PredecessorBlocks::default());
+        new.definitions_per_block.push(FxHashMap::default());
+        new.sealed_blocks.push(true);
+
+        new
    }

+    /// Record a definition for a symbol.
    pub(super) fn record_definition(
        &mut self,
-        symbol: ScopedSymbolId,
+        symbol_id: ScopedSymbolId,
        definition: Definition<'db>,
    ) {
-        // We have a new definition of a symbol; this replaces any previous definitions in this
-        // path.
-        let def_id = self.all_definitions.push(definition);
-        self.definitions_by_symbol[symbol] = SymbolState::with(def_id);
+        self.memoize(self.current_block_id(), symbol_id, Some(definition));
+        self.defined_symbols.insert(symbol_id);
    }

-    pub(super) fn record_constraint(&mut self, constraint: Expression<'db>) {
-        let constraint_id = self.all_constraints.push(constraint);
-        for definitions in &mut self.definitions_by_symbol {
-            definitions.add_constraint(constraint_id);
-        }
-    }
-
-    pub(super) fn record_use(&mut self, symbol: ScopedSymbolId, use_id: ScopedUseId) {
-        // We have a use of a symbol; clone the currently visible definitions for that symbol, and
-        // record them as the visible definitions for this use.
-        let new_use = self
-            .definitions_by_use
-            .push(self.definitions_by_symbol[symbol].clone());
+    /// Record a use of a symbol.
+    pub(super) fn record_use(&mut self, symbol_id: ScopedSymbolId, use_id: ScopedUseId) {
+        let definition_id = self.lookup(symbol_id);
+        let new_use = self.definitions_by_use.push(definition_id);
        debug_assert_eq!(use_id, new_use);
    }

-    /// Take a snapshot of the current visible-symbols state.
-    pub(super) fn snapshot(&self) -> FlowSnapshot {
-        FlowSnapshot {
-            definitions_by_symbol: self.definitions_by_symbol.clone(),
+    /// Get the id of the current basic block.
+    pub(super) fn current_block_id(&self) -> BasicBlockId {
+        BasicBlockId::from(self.definitions_per_block.len() - 1)
+    }
+
+    /// Push a new basic block, with given block as predecessor.
+    pub(super) fn new_block_from(&mut self, block_id: BasicBlockId, sealed: bool) {
+        self.new_block_with_predecessors(smallvec![block_id], sealed);
+    }
+
+    /// Push a new basic block, with current block as predecessor; return the current block's ID.
+    pub(super) fn next_block(&mut self, sealed: bool) -> BasicBlockId {
+        let current_block_id = self.current_block_id();
+        self.new_block_from(current_block_id, sealed);
+        current_block_id
+    }
+
+    /// Add a predecessor to the current block.
+    pub(super) fn merge_block(&mut self, new_predecessor: BasicBlockId) {
+        let block_id = self.current_block_id();
+        debug_assert!(!self.sealed_blocks[block_id]);
+        self.predecessors[block_id].push(new_predecessor);
+    }
+
+    /// Add predecessors to the current block.
+    pub(super) fn merge_blocks(&mut self, new_predecessors: Vec<BasicBlockId>) {
+        let block_id = self.current_block_id();
+        debug_assert!(!self.sealed_blocks[block_id]);
+        self.predecessors[block_id].extend(new_predecessors);
+    }
+
+    /// Mark the current block as sealed; it cannot have any more predecessors added.
+    pub(super) fn seal_current_block(&mut self) {
+        self.seal_block(self.current_block_id());
+    }
+
+    /// Mark a block as sealed; it cannot have any more predecessors added.
+    pub(super) fn seal_block(&mut self, block_id: BasicBlockId) {
+        debug_assert!(!self.sealed_blocks[block_id]);
+        if let Some(phis) = self.incomplete_phis.get(&block_id) {
+            for phi in phis.clone() {
+                self.add_phi_operands(block_id, phi);
+            }
+            self.incomplete_phis.remove(&block_id);
+        }
+        self.sealed_blocks[block_id] = true;
+    }
+
+    pub(super) fn finish(mut self) -> UseDefMap<'db> {
+        debug_assert!(self.incomplete_phis.is_empty());
+        debug_assert!(self.sealed_blocks.iter().all(|&b| b));
+        self.definitions_by_use.shrink_to_fit();
+        self.phi_operands.shrink_to_fit();
+
+        let mut public_definitions: FxHashMap<ScopedSymbolId, Definition<'db>> =
+            FxHashMap::default();
+
+        for symbol_id in self.defined_symbols.clone() {
+            // SAFETY: We are only looking up defined symbols here, can't get None.
+            public_definitions.insert(symbol_id, self.lookup(symbol_id).unwrap());
+        }
+
+        UseDefMap {
+            definitions_by_use: self.definitions_by_use,
+            public_definitions,
+            phi_operands: self.phi_operands,
        }
    }

-    /// Restore the current builder visible-definitions state to the given snapshot.
-    pub(super) fn restore(&mut self, snapshot: FlowSnapshot) {
-        // We never remove symbols from `definitions_by_symbol` (it's an IndexVec, and the symbol
-        // IDs must line up), so the current number of known symbols must always be equal to or
-        // greater than the number of known symbols in a previously-taken snapshot.
-        let num_symbols = self.definitions_by_symbol.len();
-        debug_assert!(num_symbols >= snapshot.definitions_by_symbol.len());
+    /// Push a new basic block (with given predecessors) and return its ID.
+    fn new_block_with_predecessors(
+        &mut self,
+        predecessors: PredecessorBlocks,
+        sealed: bool,
+    ) -> BasicBlockId {
+        let new_block_id = self.predecessors.push(predecessors);
+        self.definitions_per_block.push(FxHashMap::default());
+        self.sealed_blocks.push(sealed);

-        // Restore the current visible-definitions state to the given snapshot.
-        self.definitions_by_symbol = snapshot.definitions_by_symbol;
-
-        // If the snapshot we are restoring is missing some symbols we've recorded since, we need
-        // to fill them in so the symbol IDs continue to line up. Since they don't exist in the
-        // snapshot, the correct state to fill them in with is "unbound".
-        self.definitions_by_symbol
-            .resize(num_symbols, SymbolState::unbound());
+        new_block_id
    }

-    /// Merge the given snapshot into the current state, reflecting that we might have taken either
-    /// path to get here. The new visible-definitions state for each symbol should include
-    /// definitions from both the prior state and the snapshot.
-    pub(super) fn merge(&mut self, snapshot: FlowSnapshot) {
-        // The tricky thing about merging two Ranges pointing into `all_definitions` is that if the
-        // two Ranges aren't already adjacent in `all_definitions`, we will have to copy at least
-        // one or the other of the ranges to the end of `all_definitions` so as to make them
-        // adjacent. We can't ever move things around in `all_definitions` because previously
-        // recorded uses may still have ranges pointing to any part of it; all we can do is append.
-        // It's possible we may end up with some old entries in `all_definitions` that nobody is
-        // pointing to, but that's OK.
+    /// Look up the dominating definition for a symbol in the current block.
+    ///
+    /// If there isn't a local definition, recursively look up the symbol in predecessor blocks,
+    /// memoizing the found symbol in each block.
+    fn lookup(&mut self, symbol_id: ScopedSymbolId) -> Option<Definition<'db>> {
+        self.lookup_impl(self.current_block_id(), symbol_id)
+    }

-        // We never remove symbols from `definitions_by_symbol` (it's an IndexVec, and the symbol
-        // IDs must line up), so the current number of known symbols must always be equal to or
-        // greater than the number of known symbols in a previously-taken snapshot.
-        debug_assert!(self.definitions_by_symbol.len() >= snapshot.definitions_by_symbol.len());
-
-        let mut snapshot_definitions_iter = snapshot.definitions_by_symbol.into_iter();
-        for current in &mut self.definitions_by_symbol {
-            if let Some(snapshot) = snapshot_definitions_iter.next() {
-                current.merge(snapshot);
-            } else {
-                // Symbol not present in snapshot, so it's unbound from that path.
-                current.add_unbound();
+    fn lookup_impl(
+        &mut self,
+        block_id: BasicBlockId,
+        symbol_id: ScopedSymbolId,
+    ) -> Option<Definition<'db>> {
+        if let Some(local) = self.definitions_per_block[block_id].get(&symbol_id) {
+            return *local;
+        }
+        if !self.sealed_blocks[block_id] {
+            // we may still be missing predecessors; insert an incomplete Phi.
+            let definition = self.create_incomplete_phi(block_id, symbol_id);
+            self.incomplete_phis
+                .entry(block_id)
+                .or_default()
+                .push(definition);
+            return Some(definition);
+        }
+        match self.predecessors[block_id].as_slice() {
+            // entry block, no definition found: return None
+            [] => None,
+            // single predecessor, recurse
+            &[single_predecessor_id] => {
+                let definition = self.lookup_impl(single_predecessor_id, symbol_id);
+                self.memoize(block_id, symbol_id, definition);
+                definition
+            }
+            // multiple predecessors: create and memoize an incomplete Phi to break cycles, then
+            // recurse into predecessors and fill the Phi operands.
+            _ => {
+                let phi = self.create_incomplete_phi(block_id, symbol_id);
+                self.add_phi_operands(block_id, phi);
+                Some(phi)
            }
        }
    }

-    pub(super) fn finish(mut self) -> UseDefMap<'db> {
-        self.all_definitions.shrink_to_fit();
-        self.all_constraints.shrink_to_fit();
-        self.definitions_by_symbol.shrink_to_fit();
-        self.definitions_by_use.shrink_to_fit();
+    /// Recurse into predecessors to add operands for an incomplete Phi.
+    fn add_phi_operands(&mut self, block_id: BasicBlockId, phi: Definition<'db>) {
+        let predecessors: PredecessorBlocks = self.predecessors[block_id].clone();
+        let operands: PhiOperands = predecessors
+            .iter()
+            .map(|pred_id| self.lookup_impl(*pred_id, phi.symbol(self.db)))
+            .collect();
+        let DefinitionKind::Phi(phi_id) = phi.kind(self.db) else {
+            unreachable!("add_phi_operands called with non-Phi");
+        };
+        self.phi_operands[*phi_id] = operands;
+    }

-        UseDefMap {
-            all_definitions: self.all_definitions,
-            all_constraints: self.all_constraints,
-            definitions_by_use: self.definitions_by_use,
-            public_definitions: self.definitions_by_symbol,
-        }
+    /// Remember a given definition for a given symbol in the given block.
+    fn memoize(
+        &mut self,
+        block_id: BasicBlockId,
+        symbol_id: ScopedSymbolId,
+        definition_id: Option<Definition<'db>>,
+    ) {
+        self.definitions_per_block[block_id].insert(symbol_id, definition_id);
+    }
+
+    /// Create an incomplete Phi for the given block and symbol, memoize it, and return its ID.
+    fn create_incomplete_phi(
+        &mut self,
+        block_id: BasicBlockId,
+        symbol_id: ScopedSymbolId,
+    ) -> Definition<'db> {
+        let phi_id = self.phi_operands.push(vec![]);
+        let definition = Definition::new(
+            self.db,
+            self.file,
+            self.file_scope,
+            symbol_id,
+            DefinitionKind::Phi(phi_id),
+            countme::Count::default(),
+        );
+        self.memoize(block_id, symbol_id, Some(definition));
+        definition
    }
 }
--- a/crates/red_knot_python_semantic/src/semantic_index/use_def/bitset.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/use_def/bitset.rs
@@ -1,228 +0,0 @@
-/// Ordered set of `u32`.
-///
-/// Uses an inline bit-set for small values (up to 64 * B), falls back to heap allocated vector of
-/// blocks for larger values.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(super) enum BitSet<const B: usize> {
-    /// Bit-set (in 64-bit blocks) for the first 64 * B entries.
-    Inline([u64; B]),
-
-    /// Overflow beyond 64 * B.
-    Heap(Vec<u64>),
-}
-
-impl<const B: usize> Default for BitSet<B> {
-    fn default() -> Self {
-        // B * 64 must fit in a u32, or else we have unusable bits; this assertion makes the
-        // truncating casts to u32 below safe. This would be better as a const assertion, but
-        // that's not possible on stable with const generic params. (B should never really be
-        // anywhere close to this large.)
-        assert!(B * 64 < (u32::MAX as usize));
-        // This implementation requires usize >= 32 bits.
-        static_assertions::const_assert!(usize::BITS >= 32);
-        Self::Inline([0; B])
-    }
-}
-
-impl<const B: usize> BitSet<B> {
-    /// Create and return a new [`BitSet`] with a single `value` inserted.
-    pub(super) fn with(value: u32) -> Self {
-        let mut bitset = Self::default();
-        bitset.insert(value);
-        bitset
-    }
-
-    /// Convert from Inline to Heap, if needed, and resize the Heap vector, if needed.
-    fn resize(&mut self, value: u32) {
-        let num_blocks_needed = (value / 64) + 1;
-        match self {
-            Self::Inline(blocks) => {
-                let mut vec = blocks.to_vec();
-                vec.resize(num_blocks_needed as usize, 0);
-                *self = Self::Heap(vec);
-            }
-            Self::Heap(vec) => {
-                vec.resize(num_blocks_needed as usize, 0);
-            }
-        }
-    }
-
-    fn blocks_mut(&mut self) -> &mut [u64] {
-        match self {
-            Self::Inline(blocks) => blocks.as_mut_slice(),
-            Self::Heap(blocks) => blocks.as_mut_slice(),
-        }
-    }
-
-    fn blocks(&self) -> &[u64] {
-        match self {
-            Self::Inline(blocks) => blocks.as_slice(),
-            Self::Heap(blocks) => blocks.as_slice(),
-        }
-    }
-
-    /// Insert a value into the [`BitSet`].
-    ///
-    /// Return true if the value was newly inserted, false if already present.
-    pub(super) fn insert(&mut self, value: u32) -> bool {
-        let value_usize = value as usize;
-        let (block, index) = (value_usize / 64, value_usize % 64);
-        if block >= self.blocks().len() {
-            self.resize(value);
-        }
-        let blocks = self.blocks_mut();
-        let missing = blocks[block] & (1 << index) == 0;
-        blocks[block] |= 1 << index;
-        missing
-    }
-
-    /// Intersect in-place with another [`BitSet`].
-    pub(super) fn intersect(&mut self, other: &BitSet<B>) {
-        let my_blocks = self.blocks_mut();
-        let other_blocks = other.blocks();
-        let min_len = my_blocks.len().min(other_blocks.len());
-        for i in 0..min_len {
-            my_blocks[i] &= other_blocks[i];
-        }
-        for block in my_blocks.iter_mut().skip(min_len) {
-            *block = 0;
-        }
-    }
-
-    /// Return an iterator over the values (in ascending order) in this [`BitSet`].
-    pub(super) fn iter(&self) -> BitSetIterator<'_, B> {
-        let blocks = self.blocks();
-        BitSetIterator {
-            blocks,
-            current_block_index: 0,
-            current_block: blocks[0],
-        }
-    }
-}
-
-/// Iterator over values in a [`BitSet`].
-#[derive(Debug)]
-pub(super) struct BitSetIterator<'a, const B: usize> {
-    /// The blocks we are iterating over.
-    blocks: &'a [u64],
-
-    /// The index of the block we are currently iterating through.
-    current_block_index: usize,
-
-    /// The block we are currently iterating through (and zeroing as we go.)
-    current_block: u64,
-}
-
-impl<const B: usize> Iterator for BitSetIterator<'_, B> {
-    type Item = u32;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while self.current_block == 0 {
-            if self.current_block_index + 1 >= self.blocks.len() {
-                return None;
-            }
-            self.current_block_index += 1;
-            self.current_block = self.blocks[self.current_block_index];
-        }
-        let lowest_bit_set = self.current_block.trailing_zeros();
-        // reset the lowest set bit, without a data dependency on `lowest_bit_set`
-        self.current_block &= self.current_block.wrapping_sub(1);
-        // SAFETY: `lowest_bit_set` cannot be more than 64, `current_block_index` cannot be more
-        // than `B - 1`, and we check above that `B * 64 < u32::MAX`. So both `64 *
-        // current_block_index` and the final value here must fit in u32.
-        #[allow(clippy::cast_possible_truncation)]
-        Some(lowest_bit_set + (64 * self.current_block_index) as u32)
-    }
-}
-
-impl<const B: usize> std::iter::FusedIterator for BitSetIterator<'_, B> {}
-
-#[cfg(test)]
-mod tests {
-    use super::BitSet;
-
-    fn assert_bitset<const B: usize>(bitset: &BitSet<B>, contents: &[u32]) {
-        assert_eq!(bitset.iter().collect::<Vec<_>>(), contents);
-    }
-
-    #[test]
-    fn iter() {
-        let mut b = BitSet::<1>::with(3);
-        b.insert(27);
-        b.insert(6);
-        assert!(matches!(b, BitSet::Inline(_)));
-        assert_bitset(&b, &[3, 6, 27]);
-    }
-
-    #[test]
-    fn iter_overflow() {
-        let mut b = BitSet::<1>::with(140);
-        b.insert(100);
-        b.insert(129);
-        assert!(matches!(b, BitSet::Heap(_)));
-        assert_bitset(&b, &[100, 129, 140]);
-    }
-
-    #[test]
-    fn intersect() {
-        let mut b1 = BitSet::<1>::with(4);
-        let mut b2 = BitSet::<1>::with(4);
-        b1.insert(23);
-        b2.insert(5);
-
-        b1.intersect(&b2);
-        assert_bitset(&b1, &[4]);
-    }
-
-    #[test]
-    fn intersect_mixed_1() {
-        let mut b1 = BitSet::<1>::with(4);
-        let mut b2 = BitSet::<1>::with(4);
-        b1.insert(89);
-        b2.insert(5);
-
-        b1.intersect(&b2);
-        assert_bitset(&b1, &[4]);
-    }
-
-    #[test]
-    fn intersect_mixed_2() {
-        let mut b1 = BitSet::<1>::with(4);
-        let mut b2 = BitSet::<1>::with(4);
-        b1.insert(23);
-        b2.insert(89);
-
-        b1.intersect(&b2);
-        assert_bitset(&b1, &[4]);
-    }
-
-    #[test]
-    fn intersect_heap() {
-        let mut b1 = BitSet::<1>::with(4);
-        let mut b2 = BitSet::<1>::with(4);
-        b1.insert(89);
-        b2.insert(90);
-
-        b1.intersect(&b2);
-        assert_bitset(&b1, &[4]);
-    }
-
-    #[test]
-    fn intersect_heap_2() {
-        let mut b1 = BitSet::<1>::with(89);
-        let mut b2 = BitSet::<1>::with(89);
-        b1.insert(91);
-        b2.insert(90);
-
-        b1.intersect(&b2);
-        assert_bitset(&b1, &[89]);
-    }
-
-    #[test]
-    fn multiple_blocks() {
-        let mut b = BitSet::<2>::with(120);
-        b.insert(45);
-        assert!(matches!(b, BitSet::Inline(_)));
-        assert_bitset(&b, &[45, 120]);
-    }
-}
--- a/crates/red_knot_python_semantic/src/semantic_index/use_def/symbol_state.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/use_def/symbol_state.rs
@@ -1,374 +0,0 @@
-//! Track visible definitions of a symbol, and applicable constraints per definition.
-//!
-//! These data structures operate entirely on scope-local newtype-indices for definitions and
-//! constraints, referring to their location in the `all_definitions` and `all_constraints`
-//! indexvecs in [`super::UseDefMapBuilder`].
-//!
-//! We need to track arbitrary associations between definitions and constraints, not just a single
-//! set of currently dominating constraints (where "dominating" means "control flow must have
-//! passed through it to reach this point"), because we can have dominating constraints that apply
-//! to some definitions but not others, as in this code:
-//!
-//! ```python
-//! x = 1 if flag else None
-//! if x is not None:
-//!     if flag2:
-//!         x = 2 if flag else None
-//!     x
-//! ```
-//!
-//! The `x is not None` constraint dominates the final use of `x`, but it applies only to the first
-//! definition of `x`, not the second, so `None` is a possible value for `x`.
-//!
-//! And we can't just track, for each definition, an index into a list of dominating constraints,
-//! either, because we can have definitions which are still visible, but subject to constraints
-//! that are no longer dominating, as in this code:
-//!
-//! ```python
-//! x = 0
-//! if flag1:
-//!     x = 1 if flag2 else None
-//!     assert x is not None
-//! x
-//! ```
-//!
-//! From the point of view of the final use of `x`, the `x is not None` constraint no longer
-//! dominates, but it does dominate the `x = 1 if flag2 else None` definition, so we have to keep
-//! track of that.
-//!
-//! The data structures used here ([`BitSet`] and [`smallvec::SmallVec`]) optimize for keeping all
-//! data inline (avoiding lots of scattered allocations) in small-to-medium cases, and falling back
-//! to heap allocation to be able to scale to arbitrary numbers of definitions and constraints when
-//! needed.
-use super::bitset::{BitSet, BitSetIterator};
-use ruff_index::newtype_index;
-use smallvec::SmallVec;
-
-/// A newtype-index for a definition in a particular scope.
-#[newtype_index]
-pub(super) struct ScopedDefinitionId;
-
-/// A newtype-index for a constraint expression in a particular scope.
-#[newtype_index]
-pub(super) struct ScopedConstraintId;
-
-/// Can reference this * 64 total definitions inline; more will fall back to the heap.
-const INLINE_DEFINITION_BLOCKS: usize = 3;
-
-/// A [`BitSet`] of [`ScopedDefinitionId`], representing visible definitions of a symbol in a scope.
-type Definitions = BitSet<INLINE_DEFINITION_BLOCKS>;
-type DefinitionsIterator<'a> = BitSetIterator<'a, INLINE_DEFINITION_BLOCKS>;
-
-/// Can reference this * 64 total constraints inline; more will fall back to the heap.
-const INLINE_CONSTRAINT_BLOCKS: usize = 2;
-
-/// Can keep inline this many visible definitions per symbol at a given time; more will go to heap.
-const INLINE_VISIBLE_DEFINITIONS_PER_SYMBOL: usize = 4;
-
-/// One [`BitSet`] of applicable [`ScopedConstraintId`] per visible definition.
-type InlineConstraintArray =
-    [BitSet<INLINE_CONSTRAINT_BLOCKS>; INLINE_VISIBLE_DEFINITIONS_PER_SYMBOL];
-type Constraints = SmallVec<InlineConstraintArray>;
-type ConstraintsIterator<'a> = std::slice::Iter<'a, BitSet<INLINE_CONSTRAINT_BLOCKS>>;
-type ConstraintsIntoIterator = smallvec::IntoIter<InlineConstraintArray>;
-
-/// Visible definitions and narrowing constraints for a single symbol at some point in control flow.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(super) struct SymbolState {
-    /// [`BitSet`]: which [`ScopedDefinitionId`] are visible for this symbol?
-    visible_definitions: Definitions,
-
-    /// For each definition, which [`ScopedConstraintId`] apply?
-    ///
-    /// This is a [`smallvec::SmallVec`] which should always have one [`BitSet`] of constraints per
-    /// definition in `visible_definitions`.
-    constraints: Constraints,
-
-    /// Could the symbol be unbound at this point?
-    may_be_unbound: bool,
-}
-
-/// A single [`ScopedDefinitionId`] with an iterator of its applicable [`ScopedConstraintId`].
-#[derive(Debug)]
-pub(super) struct DefinitionIdWithConstraints<'a> {
-    pub(super) definition: ScopedDefinitionId,
-    pub(super) constraint_ids: ConstraintIdIterator<'a>,
-}
-
-impl SymbolState {
-    /// Return a new [`SymbolState`] representing an unbound symbol.
-    pub(super) fn unbound() -> Self {
-        Self {
-            visible_definitions: Definitions::default(),
-            constraints: Constraints::default(),
-            may_be_unbound: true,
-        }
-    }
-
-    /// Return a new [`SymbolState`] representing a symbol with a single visible definition.
-    pub(super) fn with(definition_id: ScopedDefinitionId) -> Self {
-        let mut constraints = Constraints::with_capacity(1);
-        constraints.push(BitSet::default());
-        Self {
-            visible_definitions: Definitions::with(definition_id.into()),
-            constraints,
-            may_be_unbound: false,
-        }
-    }
-
-    /// Add Unbound as a possibility for this symbol.
-    pub(super) fn add_unbound(&mut self) {
-        self.may_be_unbound = true;
-    }
-
-    /// Add given constraint to all currently-visible definitions.
-    pub(super) fn add_constraint(&mut self, constraint_id: ScopedConstraintId) {
-        for bitset in &mut self.constraints {
-            bitset.insert(constraint_id.into());
-        }
-    }
-
-    /// Merge another [`SymbolState`] into this one.
-    pub(super) fn merge(&mut self, b: SymbolState) {
-        let mut a = Self {
-            visible_definitions: Definitions::default(),
-            constraints: Constraints::default(),
-            may_be_unbound: self.may_be_unbound || b.may_be_unbound,
-        };
-        std::mem::swap(&mut a, self);
-        let mut a_defs_iter = a.visible_definitions.iter();
-        let mut b_defs_iter = b.visible_definitions.iter();
-        let mut a_constraints_iter = a.constraints.into_iter();
-        let mut b_constraints_iter = b.constraints.into_iter();
-
-        let mut opt_a_def: Option<u32> = a_defs_iter.next();
-        let mut opt_b_def: Option<u32> = b_defs_iter.next();
-
-        // Iterate through the definitions from `a` and `b`, always processing the lower definition
-        // ID first, and pushing each definition onto the merged `SymbolState` with its
-        // constraints. If a definition is found in both `a` and `b`, push it with the intersection
-        // of the constraints from the two paths; a constraint that applies from only one possible
-        // path is irrelevant.
-
-        // Helper to push `def`, with constraints in `constraints_iter`, onto `self`.
-        let push = |def, constraints_iter: &mut ConstraintsIntoIterator, merged: &mut Self| {
-            merged.visible_definitions.insert(def);
-            // SAFETY: we only ever create SymbolState with either no definitions and no constraint
-            // bitsets (`::unbound`) or one definition and one constraint bitset (`::with`), and
-            // `::merge` always pushes one definition and one constraint bitset together (just
-            // below), so the number of definitions and the number of constraint bitsets can never
-            // get out of sync.
-            let constraints = constraints_iter
-                .next()
-                .expect("definitions and constraints length mismatch");
-            merged.constraints.push(constraints);
-        };
-
-        loop {
-            match (opt_a_def, opt_b_def) {
-                (Some(a_def), Some(b_def)) => match a_def.cmp(&b_def) {
-                    std::cmp::Ordering::Less => {
-                        // Next definition ID is only in `a`, push it to `self` and advance `a`.
-                        push(a_def, &mut a_constraints_iter, self);
-                        opt_a_def = a_defs_iter.next();
-                    }
-                    std::cmp::Ordering::Greater => {
-                        // Next definition ID is only in `b`, push it to `self` and advance `b`.
-                        push(b_def, &mut b_constraints_iter, self);
-                        opt_b_def = b_defs_iter.next();
-                    }
-                    std::cmp::Ordering::Equal => {
-                        // Next definition is in both; push to `self` and intersect constraints.
-                        push(a_def, &mut b_constraints_iter, self);
-                        // SAFETY: we only ever create SymbolState with either no definitions and
-                        // no constraint bitsets (`::unbound`) or one definition and one constraint
-                        // bitset (`::with`), and `::merge` always pushes one definition and one
-                        // constraint bitset together (just below), so the number of definitions
-                        // and the number of constraint bitsets can never get out of sync.
-                        let a_constraints = a_constraints_iter
-                            .next()
-                            .expect("definitions and constraints length mismatch");
-                        // If the same definition is visible through both paths, any constraint
-                        // that applies on only one path is irrelevant to the resulting type from
-                        // unioning the two paths, so we intersect the constraints.
-                        self.constraints
-                            .last_mut()
-                            .unwrap()
-                            .intersect(&a_constraints);
-                        opt_a_def = a_defs_iter.next();
-                        opt_b_def = b_defs_iter.next();
-                    }
-                },
-                (Some(a_def), None) => {
-                    // We've exhausted `b`, just push the def from `a` and move on to the next.
-                    push(a_def, &mut a_constraints_iter, self);
-                    opt_a_def = a_defs_iter.next();
-                }
-                (None, Some(b_def)) => {
-                    // We've exhausted `a`, just push the def from `b` and move on to the next.
-                    push(b_def, &mut b_constraints_iter, self);
-                    opt_b_def = b_defs_iter.next();
-                }
-                (None, None) => break,
-            }
-        }
-    }
-
-    /// Get iterator over visible definitions with constraints.
-    pub(super) fn visible_definitions(&self) -> DefinitionIdWithConstraintsIterator {
-        DefinitionIdWithConstraintsIterator {
-            definitions: self.visible_definitions.iter(),
-            constraints: self.constraints.iter(),
-        }
-    }
-
-    /// Could the symbol be unbound?
-    pub(super) fn may_be_unbound(&self) -> bool {
-        self.may_be_unbound
-    }
-}
-
-/// The default state of a symbol (if we've seen no definitions of it) is unbound.
-impl Default for SymbolState {
-    fn default() -> Self {
-        SymbolState::unbound()
-    }
-}
-
-#[derive(Debug)]
-pub(super) struct DefinitionIdWithConstraintsIterator<'a> {
-    definitions: DefinitionsIterator<'a>,
-    constraints: ConstraintsIterator<'a>,
-}
-
-impl<'a> Iterator for DefinitionIdWithConstraintsIterator<'a> {
-    type Item = DefinitionIdWithConstraints<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match (self.definitions.next(), self.constraints.next()) {
-            (None, None) => None,
-            (Some(def), Some(constraints)) => Some(DefinitionIdWithConstraints {
-                definition: ScopedDefinitionId::from_u32(def),
-                constraint_ids: ConstraintIdIterator {
-                    wrapped: constraints.iter(),
-                },
-            }),
-            // SAFETY: see above.
-            _ => unreachable!("definitions and constraints length mismatch"),
-        }
-    }
-}
-
-impl std::iter::FusedIterator for DefinitionIdWithConstraintsIterator<'_> {}
-
-#[derive(Debug)]
-pub(super) struct ConstraintIdIterator<'a> {
-    wrapped: BitSetIterator<'a, INLINE_CONSTRAINT_BLOCKS>,
-}
-
-impl Iterator for ConstraintIdIterator<'_> {
-    type Item = ScopedConstraintId;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.wrapped.next().map(ScopedConstraintId::from_u32)
-    }
-}
-
-impl std::iter::FusedIterator for ConstraintIdIterator<'_> {}
-
-#[cfg(test)]
-mod tests {
-    use super::{ScopedConstraintId, ScopedDefinitionId, SymbolState};
-
-    impl SymbolState {
-        pub(crate) fn assert(&self, may_be_unbound: bool, expected: &[&str]) {
-            assert_eq!(self.may_be_unbound(), may_be_unbound);
-            let actual = self
-                .visible_definitions()
-                .map(|def_id_with_constraints| {
-                    format!(
-                        "{}<{}>",
-                        def_id_with_constraints.definition.as_u32(),
-                        def_id_with_constraints
-                            .constraint_ids
-                            .map(ScopedConstraintId::as_u32)
-                            .map(|idx| idx.to_string())
-                            .collect::<Vec<_>>()
-                            .join(", ")
-                    )
-                })
-                .collect::<Vec<_>>();
-            assert_eq!(actual, expected);
-        }
-    }
-
-    #[test]
-    fn unbound() {
-        let cd = SymbolState::unbound();
-
-        cd.assert(true, &[]);
-    }
-
-    #[test]
-    fn with() {
-        let cd = SymbolState::with(ScopedDefinitionId::from_u32(0));
-
-        cd.assert(false, &["0<>"]);
-    }
-
-    #[test]
-    fn add_unbound() {
-        let mut cd = SymbolState::with(ScopedDefinitionId::from_u32(0));
-        cd.add_unbound();
-
-        cd.assert(true, &["0<>"]);
-    }
-
-    #[test]
-    fn add_constraint() {
-        let mut cd = SymbolState::with(ScopedDefinitionId::from_u32(0));
-        cd.add_constraint(ScopedConstraintId::from_u32(0));
-
-        cd.assert(false, &["0<0>"]);
-    }
-
-    #[test]
-    fn merge() {
-        // merging the same definition with the same constraint keeps the constraint
-        let mut cd0a = SymbolState::with(ScopedDefinitionId::from_u32(0));
-        cd0a.add_constraint(ScopedConstraintId::from_u32(0));
-
-        let mut cd0b = SymbolState::with(ScopedDefinitionId::from_u32(0));
-        cd0b.add_constraint(ScopedConstraintId::from_u32(0));
-
-        cd0a.merge(cd0b);
-        let mut cd0 = cd0a;
-        cd0.assert(false, &["0<0>"]);
-
-        // merging the same definition with differing constraints drops all constraints
-        let mut cd1a = SymbolState::with(ScopedDefinitionId::from_u32(1));
-        cd1a.add_constraint(ScopedConstraintId::from_u32(1));
-
-        let mut cd1b = SymbolState::with(ScopedDefinitionId::from_u32(1));
-        cd1b.add_constraint(ScopedConstraintId::from_u32(2));
-
-        cd1a.merge(cd1b);
-        let cd1 = cd1a;
-        cd1.assert(false, &["1<>"]);
-
-        // merging a constrained definition with unbound keeps both
-        let mut cd2a = SymbolState::with(ScopedDefinitionId::from_u32(2));
-        cd2a.add_constraint(ScopedConstraintId::from_u32(3));
-
-        let cd2b = SymbolState::unbound();
-
-        cd2a.merge(cd2b);
-        let cd2 = cd2a;
-        cd2.assert(true, &["2<3>"]);
-
-        // merging different definitions keeps them each with their existing constraints
-        cd0.merge(cd2);
-        let cd = cd0;
-        cd.assert(true, &["0<0>", "2<3>"]);
-    }
-}
--- a/crates/red_knot_python_semantic/src/semantic_model.rs
+++ b/crates/red_knot_python_semantic/src/semantic_model.rs
@@ -1,7 +1,7 @@
 use ruff_db::files::{File, FilePath};
 use ruff_db::source::line_index;
 use ruff_python_ast as ast;
-use ruff_python_ast::{Expr, ExpressionRef};
+use ruff_python_ast::{Expr, ExpressionRef, StmtClassDef};
 use ruff_source_file::LineIndex;

 use crate::module_name::ModuleName;
@@ -147,24 +147,29 @@ impl HasTy for ast::Expr {
    }
 }

-macro_rules! impl_definition_has_ty {
-    ($ty: ty) => {
-        impl HasTy for $ty {
-            #[inline]
-            fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
-                let index = semantic_index(model.db, model.file);
-                let definition = index.definition(self);
-                definition_ty(model.db, definition)
-            }
-        }
-    };
+impl HasTy for ast::StmtFunctionDef {
+    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
+        let index = semantic_index(model.db, model.file);
+        let definition = index.definition(self);
+        definition_ty(model.db, Some(definition))
+    }
 }

-impl_definition_has_ty!(ast::StmtFunctionDef);
-impl_definition_has_ty!(ast::StmtClassDef);
-impl_definition_has_ty!(ast::Alias);
-impl_definition_has_ty!(ast::Parameter);
-impl_definition_has_ty!(ast::ParameterWithDefault);
+impl HasTy for StmtClassDef {
+    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
+        let index = semantic_index(model.db, model.file);
+        let definition = index.definition(self);
+        definition_ty(model.db, Some(definition))
+    }
+}
+
+impl HasTy for ast::Alias {
+    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
+        let index = semantic_index(model.db, model.file);
+        let definition = index.definition(self);
+        definition_ty(model.db, Some(definition))
+    }
+}

 #[cfg(test)]
 mod tests {
@@ -184,9 +189,14 @@ mod tests {

        Program::from_settings(
            &db,
-            &ProgramSettings {
+            ProgramSettings {
                target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(SystemPathBuf::from("/src")),
+                search_paths: SearchPathSettings {
+                    extra_paths: vec![],
+                    src_root: SystemPathBuf::from("/src"),
+                    site_packages: vec![],
+                    custom_typeshed: None,
+                },
            },
        )?;

--- a/crates/red_knot_python_semantic/src/types.rs
+++ b/crates/red_knot_python_semantic/src/types.rs
@@ -4,38 +4,15 @@ use ruff_python_ast::name::Name;
 use crate::builtins::builtins_scope;
 use crate::semantic_index::definition::Definition;
 use crate::semantic_index::symbol::{ScopeId, ScopedSymbolId};
-use crate::semantic_index::{
-    global_scope, semantic_index, symbol_table, use_def_map, DefinitionWithConstraints,
-    DefinitionWithConstraintsIterator,
-};
-use crate::types::narrow::narrowing_constraint;
+use crate::semantic_index::{global_scope, symbol_table, use_def_map};
 use crate::{Db, FxOrderSet};

-pub(crate) use self::builder::{IntersectionBuilder, UnionBuilder};
-pub(crate) use self::diagnostic::TypeCheckDiagnostics;
-pub(crate) use self::infer::{
-    infer_definition_types, infer_expression_types, infer_scope_types, TypeInference,
-};
-
 mod builder;
-mod diagnostic;
 mod display;
 mod infer;
-mod narrow;

-pub fn check_types(db: &dyn Db, file: File) -> TypeCheckDiagnostics {
-    let _span = tracing::trace_span!("check_types", file=?file.path(db)).entered();
-
-    let index = semantic_index(db, file);
-    let mut diagnostics = TypeCheckDiagnostics::new();
-
-    for scope_id in index.scope_ids() {
-        let result = infer_scope_types(db, scope_id);
-        diagnostics.extend(result.diagnostics());
-    }
-
-    diagnostics
-}
+pub(crate) use self::builder::UnionBuilder;
+pub(crate) use self::infer::{infer_definition_types, infer_scope_types};

 /// Infer the public type of a symbol (its type as seen from outside its scope).
 pub(crate) fn symbol_ty<'db>(
@@ -46,13 +23,7 @@ pub(crate) fn symbol_ty<'db>(
    let _span = tracing::trace_span!("symbol_ty", ?symbol).entered();

    let use_def = use_def_map(db, scope);
-    definitions_ty(
-        db,
-        use_def.public_definitions(symbol),
-        use_def
-            .public_may_be_unbound(symbol)
-            .then_some(Type::Unbound),
-    )
+    definition_ty(db, use_def.public_definition(symbol))
 }

 /// Shorthand for `symbol_ty` that takes a symbol name instead of an ID.
@@ -83,70 +54,16 @@ pub(crate) fn builtins_symbol_ty_by_name<'db>(db: &'db dyn Db, name: &str) -> Ty
 }

 /// Infer the type of a [`Definition`].
-pub(crate) fn definition_ty<'db>(db: &'db dyn Db, definition: Definition<'db>) -> Type<'db> {
-    let inference = infer_definition_types(db, definition);
-    inference.definition_ty(definition)
-}
-
-/// Infer the combined type of an array of [`Definition`]s, plus one optional "unbound type".
-///
-/// Will return a union if there is more than one definition, or at least one plus an unbound
-/// type.
-///
-/// The "unbound type" represents the type in case control flow may not have passed through any
-/// definitions in this scope. If this isn't possible, then it will be `None`. If it is possible,
-/// and the result in that case should be Unbound (e.g. an unbound function local), then it will be
-/// `Some(Type::Unbound)`. If it is possible and the result should be something else (e.g. an
-/// implicit global lookup), then `unbound_type` will be `Some(the_global_symbol_type)`.
-///
-/// # Panics
-/// Will panic if called with zero definitions and no `unbound_ty`. This is a logic error,
-/// as any symbol with zero visible definitions clearly may be unbound, and the caller should
-/// provide an `unbound_ty`.
-pub(crate) fn definitions_ty<'db>(
+pub(crate) fn definition_ty<'db>(
    db: &'db dyn Db,
-    definitions_with_constraints: DefinitionWithConstraintsIterator<'_, 'db>,
-    unbound_ty: Option<Type<'db>>,
+    definition: Option<Definition<'db>>,
 ) -> Type<'db> {
-    let def_types = definitions_with_constraints.map(
-        |DefinitionWithConstraints {
-             definition,
-             constraints,
-         }| {
-            let mut constraint_tys =
-                constraints.filter_map(|test| narrowing_constraint(db, test, definition));
-            let definition_ty = definition_ty(db, definition);
-            if let Some(first_constraint_ty) = constraint_tys.next() {
-                let mut builder = IntersectionBuilder::new(db);
-                builder = builder
-                    .add_positive(definition_ty)
-                    .add_positive(first_constraint_ty);
-                for constraint_ty in constraint_tys {
-                    builder = builder.add_positive(constraint_ty);
-                }
-                builder.build()
-            } else {
-                definition_ty
-            }
-        },
-    );
-    let mut all_types = unbound_ty.into_iter().chain(def_types);
-
-    let Some(first) = all_types.next() else {
-        panic!("definitions_ty should never be called with zero definitions and no unbound_ty.")
-    };
-
-    if let Some(second) = all_types.next() {
-        let mut builder = UnionBuilder::new(db);
-        builder = builder.add(first).add(second);
-
-        for variant in all_types {
-            builder = builder.add(variant);
+    match definition {
+        Some(definition) => {
+            let inference = infer_definition_types(db, definition);
+            inference.definition_ty(definition)
        }
-
-        builder.build()
-    } else {
-        first
+        None => Type::Unbound,
    }
 }

@@ -157,7 +74,7 @@ pub enum Type<'db> {
    Any,
    /// the empty set of values
    Never,
-    /// unknown type (either no annotation, or some kind of type error)
+    /// unknown type (no annotation)
    /// equivalent to Any, or possibly to object in strict mode
    Unknown,
    /// name does not exist or is not bound to any value (this represents an error, but with some
@@ -189,20 +106,10 @@ impl<'db> Type<'db> {
        matches!(self, Type::Unbound)
    }

-    pub const fn is_unknown(&self) -> bool {
-        matches!(self, Type::Unknown)
-    }
-
-    pub const fn is_never(&self) -> bool {
-        matches!(self, Type::Never)
-    }
-
    pub fn may_be_unbound(&self, db: &'db dyn Db) -> bool {
        match self {
            Type::Unbound => true,
            Type::Union(union) => union.contains(db, Type::Unbound),
-            // Unbound can't appear in an intersection, because an intersection with Unbound
-            // simplifies to just Unbound.
            _ => false,
        }
    }
@@ -222,42 +129,20 @@ impl<'db> Type<'db> {
        }
    }

-    /// Resolve a member access of a type.
-    ///
-    /// For example, if `foo` is `Type::Instance(<Bar>)`,
-    /// `foo.member(&db, "baz")` returns the type of `baz` attributes
-    /// as accessed from instances of the `Bar` class.
-    ///
-    /// TODO: use of this method currently requires manually checking
-    /// whether the returned type is `Unknown`/`Unbound`
-    /// (or a union with `Unknown`/`Unbound`) in many places.
-    /// Ideally we'd use a more type-safe pattern, such as returning
-    /// an `Option` or a `Result` from this method, which would force
-    /// us to explicitly consider whether to handle an error or propagate
-    /// it up the call stack.
    #[must_use]
    pub fn member(&self, db: &'db dyn Db, name: &Name) -> Type<'db> {
        match self {
            Type::Any => Type::Any,
-            Type::Never => {
-                // TODO: attribute lookup on Never type
-                Type::Unknown
-            }
+            Type::Never => todo!("attribute lookup on Never type"),
            Type::Unknown => Type::Unknown,
            Type::Unbound => Type::Unbound,
-            Type::None => {
-                // TODO: attribute lookup on None type
-                Type::Unknown
-            }
-            Type::Function(_) => {
-                // TODO: attribute lookup on function type
-                Type::Unknown
-            }
+            Type::None => todo!("attribute lookup on None type"),
+            Type::Function(_) => todo!("attribute lookup on Function type"),
            Type::Module(file) => global_symbol_ty_by_name(db, *file, name),
            Type::Class(class) => class.class_member(db, name),
            Type::Instance(_) => {
                // TODO MRO? get_own_instance_member, get_instance_member
-                Type::Unknown
+                todo!("attribute lookup on Instance type")
            }
            Type::Union(union) => union
                .elements(db)
@@ -269,7 +154,7 @@ impl<'db> Type<'db> {
            Type::Intersection(_) => {
                // TODO perform the get_member on each type in the intersection
                // TODO return the intersection of those results
-                Type::Unknown
+                todo!("attribute lookup on Intersection type")
            }
            Type::IntLiteral(_) => {
                // TODO raise error
@@ -371,110 +256,3 @@ pub struct IntersectionType<'db> {
    /// directly in intersections rather than as a separate type.
    negative: FxOrderSet<Type<'db>>,
 }
-
-#[cfg(test)]
-mod tests {
-    use anyhow::Context;
-
-    use ruff_db::files::system_path_to_file;
-    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
-
-    use crate::db::tests::TestDb;
-    use crate::{Program, ProgramSettings, PythonVersion, SearchPathSettings};
-
-    use super::TypeCheckDiagnostics;
-
-    fn setup_db() -> TestDb {
-        let db = TestDb::new();
-        db.memory_file_system()
-            .create_directory_all("/src")
-            .unwrap();
-
-        Program::from_settings(
-            &db,
-            &ProgramSettings {
-                target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(SystemPathBuf::from("/src")),
-            },
-        )
-        .expect("Valid search path settings");
-
-        db
-    }
-
-    fn assert_diagnostic_messages(diagnostics: &TypeCheckDiagnostics, expected: &[&str]) {
-        let messages: Vec<&str> = diagnostics
-            .iter()
-            .map(|diagnostic| diagnostic.message())
-            .collect();
-        assert_eq!(&messages, expected);
-    }
-
-    #[test]
-    fn unresolved_import_statement() -> anyhow::Result<()> {
-        let mut db = setup_db();
-
-        db.write_file("src/foo.py", "import bar\n")
-            .context("Failed to write foo.py")?;
-
-        let foo = system_path_to_file(&db, "src/foo.py").context("Failed to resolve foo.py")?;
-
-        let diagnostics = super::check_types(&db, foo);
-        assert_diagnostic_messages(&diagnostics, &["Import 'bar' could not be resolved."]);
-
-        Ok(())
-    }
-
-    #[test]
-    fn unresolved_import_from_statement() {
-        let mut db = setup_db();
-
-        db.write_file("src/foo.py", "from bar import baz\n")
-            .unwrap();
-        let foo = system_path_to_file(&db, "src/foo.py").unwrap();
-        let diagnostics = super::check_types(&db, foo);
-        assert_diagnostic_messages(&diagnostics, &["Import 'bar' could not be resolved."]);
-    }
-
-    #[test]
-    fn unresolved_import_from_resolved_module() {
-        let mut db = setup_db();
-
-        db.write_files([("/src/a.py", ""), ("/src/b.py", "from a import thing")])
-            .unwrap();
-
-        let b_file = system_path_to_file(&db, "/src/b.py").unwrap();
-        let b_file_diagnostics = super::check_types(&db, b_file);
-        assert_diagnostic_messages(
-            &b_file_diagnostics,
-            &["Could not resolve import of 'thing' from 'a'"],
-        );
-    }
-
-    #[ignore = "\
-A spurious second 'Unresolved import' diagnostic message is emitted on `b.py`, \
-despite the symbol existing in the symbol table for `a.py`"]
-    #[test]
-    fn resolved_import_of_symbol_from_unresolved_import() {
-        let mut db = setup_db();
-
-        db.write_files([
-            ("/src/a.py", "import foo as foo"),
-            ("/src/b.py", "from a import foo"),
-        ])
-        .unwrap();
-
-        let a_file = system_path_to_file(&db, "/src/a.py").unwrap();
-        let a_file_diagnostics = super::check_types(&db, a_file);
-        assert_diagnostic_messages(
-            &a_file_diagnostics,
-            &["Import 'foo' could not be resolved."],
-        );
-
-        // Importing the unresolved import into a second first-party file should not trigger
-        // an additional "unresolved import" violation
-        let b_file = system_path_to_file(&db, "/src/b.py").unwrap();
-        let b_file_diagnostics = super::check_types(&db, b_file);
-        assert_eq!(&*b_file_diagnostics, &[]);
-    }
-}
--- a/crates/red_knot_python_semantic/src/types/builder.rs
+++ b/crates/red_knot_python_semantic/src/types/builder.rs
@@ -65,6 +65,7 @@ impl<'db> UnionBuilder<'db> {
    }
 }

+#[allow(unused)]
 #[derive(Clone)]
 pub(crate) struct IntersectionBuilder<'db> {
    // Really this builds a union-of-intersections, because we always keep our set-theoretic types
@@ -77,7 +78,8 @@ pub(crate) struct IntersectionBuilder<'db> {
 }

 impl<'db> IntersectionBuilder<'db> {
-    pub(crate) fn new(db: &'db dyn Db) -> Self {
+    #[allow(dead_code)]
+    fn new(db: &'db dyn Db) -> Self {
        Self {
            db,
            intersections: vec![InnerIntersectionBuilder::new()],
@@ -91,7 +93,8 @@ impl<'db> IntersectionBuilder<'db> {
        }
    }

-    pub(crate) fn add_positive(mut self, ty: Type<'db>) -> Self {
+    #[allow(dead_code)]
+    fn add_positive(mut self, ty: Type<'db>) -> Self {
        if let Type::Union(union) = ty {
            // Distribute ourself over this union: for each union element, clone ourself and
            // intersect with that union element, then create a new union-of-intersections with all
@@ -119,7 +122,8 @@ impl<'db> IntersectionBuilder<'db> {
        }
    }

-    pub(crate) fn add_negative(mut self, ty: Type<'db>) -> Self {
+    #[allow(dead_code)]
+    fn add_negative(mut self, ty: Type<'db>) -> Self {
        // See comments above in `add_positive`; this is just the negated version.
        if let Type::Union(union) = ty {
            union
@@ -138,7 +142,8 @@ impl<'db> IntersectionBuilder<'db> {
        }
    }

-    pub(crate) fn build(mut self) -> Type<'db> {
+    #[allow(dead_code)]
+    fn build(mut self) -> Type<'db> {
        // Avoid allocating the UnionBuilder unnecessarily if we have just one intersection:
        if self.intersections.len() == 1 {
            self.intersections.pop().unwrap().build(self.db)
@@ -152,6 +157,7 @@ impl<'db> IntersectionBuilder<'db> {
    }
 }

+#[allow(unused)]
 #[derive(Debug, Clone, Default)]
 struct InnerIntersectionBuilder<'db> {
    positive: FxOrderSet<Type<'db>>,
@@ -195,7 +201,6 @@ impl<'db> InnerIntersectionBuilder<'db> {
                self.negative.retain(|elem| !pos.contains(elem));
            }
            Type::Never => {}
-            Type::Unbound => {}
            _ => {
                if !self.positive.remove(&ty) {
                    self.negative.insert(ty);
@@ -209,23 +214,9 @@ impl<'db> InnerIntersectionBuilder<'db> {

        // Never is a subtype of all types
        if self.positive.contains(&Type::Never) {
-            self.positive.retain(Type::is_never);
+            self.positive.clear();
            self.negative.clear();
-        }
-
-        if self.positive.contains(&Type::Unbound) {
-            self.positive.retain(Type::is_unbound);
-            self.negative.clear();
-        }
-
-        // None intersects only with object
-        for pos in &self.positive {
-            if let Type::Instance(_) = pos {
-                // could be `object` type
-            } else {
-                self.negative.remove(&Type::None);
-                break;
-            }
+            self.positive.insert(Type::Never);
        }
    }

@@ -435,37 +426,4 @@ mod tests {

        assert_eq!(ty, Type::Never);
    }
-
-    #[test]
-    fn build_intersection_simplify_positive_unbound() {
-        let db = setup_db();
-        let ty = IntersectionBuilder::new(&db)
-            .add_positive(Type::Unbound)
-            .add_positive(Type::IntLiteral(1))
-            .build();
-
-        assert_eq!(ty, Type::Unbound);
-    }
-
-    #[test]
-    fn build_intersection_simplify_negative_unbound() {
-        let db = setup_db();
-        let ty = IntersectionBuilder::new(&db)
-            .add_negative(Type::Unbound)
-            .add_positive(Type::IntLiteral(1))
-            .build();
-
-        assert_eq!(ty, Type::IntLiteral(1));
-    }
-
-    #[test]
-    fn build_intersection_simplify_negative_none() {
-        let db = setup_db();
-        let ty = IntersectionBuilder::new(&db)
-            .add_negative(Type::None)
-            .add_positive(Type::IntLiteral(1))
-            .build();
-
-        assert_eq!(ty, Type::IntLiteral(1));
-    }
 }
--- a/crates/red_knot_python_semantic/src/types/diagnostic.rs
+++ b/crates/red_knot_python_semantic/src/types/diagnostic.rs
@@ -1,111 +0,0 @@
-use ruff_db::files::File;
-use ruff_text_size::{Ranged, TextRange};
-use std::fmt::Formatter;
-use std::ops::Deref;
-use std::sync::Arc;
-
-#[derive(Debug, Eq, PartialEq)]
-pub struct TypeCheckDiagnostic {
-    // TODO: Don't use string keys for rules
-    pub(super) rule: String,
-    pub(super) message: String,
-    pub(super) range: TextRange,
-    pub(super) file: File,
-}
-
-impl TypeCheckDiagnostic {
-    pub fn rule(&self) -> &str {
-        &self.rule
-    }
-
-    pub fn message(&self) -> &str {
-        &self.message
-    }
-
-    pub fn file(&self) -> File {
-        self.file
-    }
-}
-
-impl Ranged for TypeCheckDiagnostic {
-    fn range(&self) -> TextRange {
-        self.range
-    }
-}
-
-/// A collection of type check diagnostics.
-///
-/// The diagnostics are wrapped in an `Arc` because they need to be cloned multiple times
-/// when going from `infer_expression` to `check_file`. We could consider
-/// making [`TypeCheckDiagnostic`] a Salsa struct to have them Arena-allocated (once the Tables refactor is done).
-/// Using Salsa struct does have the downside that it leaks the Salsa dependency into diagnostics and
-/// each Salsa-struct comes with an overhead.
-#[derive(Default, Eq, PartialEq)]
-pub struct TypeCheckDiagnostics {
-    inner: Vec<std::sync::Arc<TypeCheckDiagnostic>>,
-}
-
-impl TypeCheckDiagnostics {
-    pub fn new() -> Self {
-        Self { inner: Vec::new() }
-    }
-
-    pub(super) fn push(&mut self, diagnostic: TypeCheckDiagnostic) {
-        self.inner.push(Arc::new(diagnostic));
-    }
-
-    pub(crate) fn shrink_to_fit(&mut self) {
-        self.inner.shrink_to_fit();
-    }
-}
-
-impl Extend<TypeCheckDiagnostic> for TypeCheckDiagnostics {
-    fn extend<T: IntoIterator<Item = TypeCheckDiagnostic>>(&mut self, iter: T) {
-        self.inner.extend(iter.into_iter().map(std::sync::Arc::new));
-    }
-}
-
-impl Extend<std::sync::Arc<TypeCheckDiagnostic>> for TypeCheckDiagnostics {
-    fn extend<T: IntoIterator<Item = Arc<TypeCheckDiagnostic>>>(&mut self, iter: T) {
-        self.inner.extend(iter);
-    }
-}
-
-impl<'a> Extend<&'a std::sync::Arc<TypeCheckDiagnostic>> for TypeCheckDiagnostics {
-    fn extend<T: IntoIterator<Item = &'a Arc<TypeCheckDiagnostic>>>(&mut self, iter: T) {
-        self.inner
-            .extend(iter.into_iter().map(std::sync::Arc::clone));
-    }
-}
-
-impl std::fmt::Debug for TypeCheckDiagnostics {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.inner.fmt(f)
-    }
-}
-
-impl Deref for TypeCheckDiagnostics {
-    type Target = [std::sync::Arc<TypeCheckDiagnostic>];
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl IntoIterator for TypeCheckDiagnostics {
-    type Item = Arc<TypeCheckDiagnostic>;
-    type IntoIter = std::vec::IntoIter<std::sync::Arc<TypeCheckDiagnostic>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.inner.into_iter()
-    }
-}
-
-impl<'a> IntoIterator for &'a TypeCheckDiagnostics {
-    type Item = &'a Arc<TypeCheckDiagnostic>;
-    type IntoIter = std::slice::Iter<'a, std::sync::Arc<TypeCheckDiagnostic>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.inner.iter()
-    }
-}
--- a/crates/red_knot_python_semantic/src/types/infer.rs
+++ b/crates/red_knot_python_semantic/src/types/infer.rs
--- a/crates/red_knot_python_semantic/src/types/narrow.rs
+++ b/crates/red_knot_python_semantic/src/types/narrow.rs
@@ -1,115 +0,0 @@
-use crate::semantic_index::ast_ids::HasScopedAstId;
-use crate::semantic_index::definition::Definition;
-use crate::semantic_index::expression::Expression;
-use crate::semantic_index::symbol::{ScopeId, ScopedSymbolId, SymbolTable};
-use crate::semantic_index::symbol_table;
-use crate::types::{infer_expression_types, IntersectionBuilder, Type, TypeInference};
-use crate::Db;
-use ruff_python_ast as ast;
-use rustc_hash::FxHashMap;
-use std::sync::Arc;
-
-/// Return the type constraint that `test` (if true) would place on `definition`, if any.
-///
-/// For example, if we have this code:
-///
-/// ```python
-/// y = 1 if flag else None
-/// x = 1 if flag else None
-/// if x is not None:
-///     ...
-/// ```
-///
-/// The `test` expression `x is not None` places the constraint "not None" on the definition of
-/// `x`, so in that case we'd return `Some(Type::Intersection(negative=[Type::None]))`.
-///
-/// But if we called this with the same `test` expression, but the `definition` of `y`, no
-/// constraint is applied to that definition, so we'd just return `None`.
-pub(crate) fn narrowing_constraint<'db>(
-    db: &'db dyn Db,
-    test: Expression<'db>,
-    definition: Definition<'db>,
-) -> Option<Type<'db>> {
-    all_narrowing_constraints(db, test)
-        .get(&definition.symbol(db))
-        .copied()
-}
-
-#[salsa::tracked(return_ref)]
-fn all_narrowing_constraints<'db>(
-    db: &'db dyn Db,
-    test: Expression<'db>,
-) -> NarrowingConstraints<'db> {
-    NarrowingConstraintsBuilder::new(db, test).finish()
-}
-
-type NarrowingConstraints<'db> = FxHashMap<ScopedSymbolId, Type<'db>>;
-
-struct NarrowingConstraintsBuilder<'db> {
-    db: &'db dyn Db,
-    expression: Expression<'db>,
-    constraints: NarrowingConstraints<'db>,
-}
-
-impl<'db> NarrowingConstraintsBuilder<'db> {
-    fn new(db: &'db dyn Db, expression: Expression<'db>) -> Self {
-        Self {
-            db,
-            expression,
-            constraints: NarrowingConstraints::default(),
-        }
-    }
-
-    fn finish(mut self) -> NarrowingConstraints<'db> {
-        if let ast::Expr::Compare(expr_compare) = self.expression.node_ref(self.db).node() {
-            self.add_expr_compare(expr_compare);
-        }
-        // TODO other test expression kinds
-
-        self.constraints.shrink_to_fit();
-        self.constraints
-    }
-
-    fn symbols(&self) -> Arc<SymbolTable> {
-        symbol_table(self.db, self.scope())
-    }
-
-    fn scope(&self) -> ScopeId<'db> {
-        self.expression.scope(self.db)
-    }
-
-    fn inference(&self) -> &'db TypeInference<'db> {
-        infer_expression_types(self.db, self.expression)
-    }
-
-    fn add_expr_compare(&mut self, expr_compare: &ast::ExprCompare) {
-        let ast::ExprCompare {
-            range: _,
-            left,
-            ops,
-            comparators,
-        } = expr_compare;
-
-        if let ast::Expr::Name(ast::ExprName {
-            range: _,
-            id,
-            ctx: _,
-        }) = left.as_ref()
-        {
-            // SAFETY: we should always have a symbol for every Name node.
-            let symbol = self.symbols().symbol_id_by_name(id).unwrap();
-            let scope = self.scope();
-            let inference = self.inference();
-            for (op, comparator) in std::iter::zip(&**ops, &**comparators) {
-                let comp_ty = inference.expression_ty(comparator.scoped_ast_id(self.db, scope));
-                if matches!(op, ast::CmpOp::IsNot) {
-                    let ty = IntersectionBuilder::new(self.db)
-                        .add_negative(comp_ty)
-                        .build();
-                    self.constraints.insert(symbol, ty);
-                };
-                // TODO other comparison types
-            }
-        }
-    }
-}
--- a/crates/red_knot_python_semantic/vendor/typeshed/source_commit.txt
+++ b/crates/red_knot_python_semantic/vendor/typeshed/source_commit.txt
@@ -1 +1 @@
-1ace5718deaf3041f8e3d1dc9c9e8a8e830e517f
+4ef2d66663fc080fefa379e6ae5fc45d4f8b54eb
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_ast.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_ast.pyi
@@ -753,11 +753,9 @@ class Constant(expr):
        __match_args__ = ("value", "kind")
    value: Any  # None, str, bytes, bool, int, float, complex, Ellipsis
    kind: str | None
-    if sys.version_info < (3, 14):
-        # Aliases for value, for backwards compatibility
-        s: Any
-        n: int | float | complex
-
+    # Aliases for value, for backwards compatibility
+    s: Any
+    n: int | float | complex
    def __init__(self, value: Any, kind: str | None = None, **kwargs: Unpack[_Attributes]) -> None: ...

 class NamedExpr(expr):
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_collections_abc.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_collections_abc.pyi
@@ -1,12 +1,13 @@
 import sys
 from abc import abstractmethod
 from types import MappingProxyType
-from typing import (  # noqa: Y022,Y038
+from typing import (  # noqa: Y022,Y038,Y057
    AbstractSet as Set,
    AsyncGenerator as AsyncGenerator,
    AsyncIterable as AsyncIterable,
    AsyncIterator as AsyncIterator,
    Awaitable as Awaitable,
+    ByteString as ByteString,
    Callable as Callable,
    Collection as Collection,
    Container as Container,
@@ -58,12 +59,8 @@ __all__ = [
    "ValuesView",
    "Sequence",
    "MutableSequence",
+    "ByteString",
 ]
-if sys.version_info < (3, 14):
-    from typing import ByteString as ByteString  # noqa: Y057
-
-    __all__ += ["ByteString"]
-
 if sys.version_info >= (3, 12):
    __all__ += ["Buffer"]

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_ctypes.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_ctypes.pyi
@@ -51,8 +51,8 @@ class _CDataMeta(type):
    # By default mypy complains about the following two methods, because strictly speaking cls
    # might not be a Type[_CT]. However this can never actually happen, because the only class that
    # uses _CDataMeta as its metaclass is _CData. So it's safe to ignore the errors here.
-    def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
-    def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+    def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]
+    def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]

 class _CData(metaclass=_CDataMeta):
    _b_base_: int
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/argparse.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/argparse.pyi
@@ -357,17 +357,7 @@ class Action(_AttributeHolder):

 if sys.version_info >= (3, 12):
    class BooleanOptionalAction(Action):
-        if sys.version_info >= (3, 14):
-            def __init__(
-                self,
-                option_strings: Sequence[str],
-                dest: str,
-                default: bool | None = None,
-                required: bool = False,
-                help: str | None = None,
-                deprecated: bool = False,
-            ) -> None: ...
-        elif sys.version_info >= (3, 13):
+        if sys.version_info >= (3, 13):
            @overload
            def __init__(
                self,
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ast.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ast.pyi
@@ -10,28 +10,27 @@ class _ABC(type):
    if sys.version_info >= (3, 9):
        def __init__(cls, *args: Unused) -> None: ...

-if sys.version_info < (3, 14):
-    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
-    class Num(Constant, metaclass=_ABC):
-        value: int | float | complex
+@deprecated("Replaced by ast.Constant; removal scheduled for Python 3.14")
+class Num(Constant, metaclass=_ABC):
+    value: int | float | complex

-    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
-    class Str(Constant, metaclass=_ABC):
-        value: str
-        # Aliases for value, for backwards compatibility
-        s: str
+@deprecated("Replaced by ast.Constant; removal scheduled for Python 3.14")
+class Str(Constant, metaclass=_ABC):
+    value: str
+    # Aliases for value, for backwards compatibility
+    s: str

-    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
-    class Bytes(Constant, metaclass=_ABC):
-        value: bytes
-        # Aliases for value, for backwards compatibility
-        s: bytes
+@deprecated("Replaced by ast.Constant; removal scheduled for Python 3.14")
+class Bytes(Constant, metaclass=_ABC):
+    value: bytes
+    # Aliases for value, for backwards compatibility
+    s: bytes

-    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
-    class NameConstant(Constant, metaclass=_ABC): ...
+@deprecated("Replaced by ast.Constant; removal scheduled for Python 3.14")
+class NameConstant(Constant, metaclass=_ABC): ...

-    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
-    class Ellipsis(Constant, metaclass=_ABC): ...
+@deprecated("Replaced by ast.Constant; removal scheduled for Python 3.14")
+class Ellipsis(Constant, metaclass=_ABC): ...

 if sys.version_info >= (3, 9):
    class slice(AST): ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/asyncio/tasks.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/asyncio/tasks.pyi
@@ -151,13 +151,13 @@ if sys.version_info >= (3, 10):
    @overload
    def gather(*coros_or_futures: _FutureLike[_T], return_exceptions: Literal[False] = False) -> Future[list[_T]]: ...  # type: ignore[overload-overlap]
    @overload
-    def gather(coro_or_future1: _FutureLike[_T1], /, *, return_exceptions: bool) -> Future[tuple[_T1 | BaseException]]: ...
+    def gather(coro_or_future1: _FutureLike[_T1], /, *, return_exceptions: bool) -> Future[tuple[_T1 | BaseException]]: ...  # type: ignore[overload-overlap]
    @overload
-    def gather(
+    def gather(  # type: ignore[overload-overlap]
        coro_or_future1: _FutureLike[_T1], coro_or_future2: _FutureLike[_T2], /, *, return_exceptions: bool
    ) -> Future[tuple[_T1 | BaseException, _T2 | BaseException]]: ...
    @overload
-    def gather(
+    def gather(  # type: ignore[overload-overlap]
        coro_or_future1: _FutureLike[_T1],
        coro_or_future2: _FutureLike[_T2],
        coro_or_future3: _FutureLike[_T3],
@@ -166,7 +166,7 @@ if sys.version_info >= (3, 10):
        return_exceptions: bool,
    ) -> Future[tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException]]: ...
    @overload
-    def gather(
+    def gather(  # type: ignore[overload-overlap]
        coro_or_future1: _FutureLike[_T1],
        coro_or_future2: _FutureLike[_T2],
        coro_or_future3: _FutureLike[_T3],
@@ -176,7 +176,7 @@ if sys.version_info >= (3, 10):
        return_exceptions: bool,
    ) -> Future[tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException, _T4 | BaseException]]: ...
    @overload
-    def gather(
+    def gather(  # type: ignore[overload-overlap]
        coro_or_future1: _FutureLike[_T1],
        coro_or_future2: _FutureLike[_T2],
        coro_or_future3: _FutureLike[_T3],
@@ -189,7 +189,7 @@ if sys.version_info >= (3, 10):
        tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException, _T4 | BaseException, _T5 | BaseException]
    ]: ...
    @overload
-    def gather(
+    def gather(  # type: ignore[overload-overlap]
        coro_or_future1: _FutureLike[_T1],
        coro_or_future2: _FutureLike[_T2],
        coro_or_future3: _FutureLike[_T3],
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/asyncio/unix_events.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/asyncio/unix_events.pyi
@@ -159,7 +159,7 @@ if sys.platform != "win32":

    class _UnixSelectorEventLoop(BaseSelectorEventLoop):
        if sys.version_info >= (3, 13):
-            async def create_unix_server(
+            async def create_unix_server(  # type: ignore[override]
                self,
                protocol_factory: _ProtocolFactory,
                path: StrPath | None = None,
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/builtins.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/builtins.pyi
@@ -1744,7 +1744,7 @@ _SupportsSumNoDefaultT = TypeVar("_SupportsSumNoDefaultT", bound=_SupportsSumWit
 # without creating many false-positive errors (see #7578).
 # Instead, we special-case the most common examples of this: bool and literal integers.
@overload
-def sum(iterable: Iterable[bool | _LiteralInteger], /, start: int = 0) -> int: ...
+def sum(iterable: Iterable[bool | _LiteralInteger], /, start: int = 0) -> int: ...  # type: ignore[overload-overlap]
@overload
 def sum(iterable: Iterable[_SupportsSumNoDefaultT], /) -> _SupportsSumNoDefaultT | Literal[0]: ...
@overload
@@ -1752,8 +1752,9 @@ def sum(iterable: Iterable[_AddableT1], /, start: _AddableT2) -> _AddableT1 | _A

 # The argument to `vars()` has to have a `__dict__` attribute, so the second overload can't be annotated with `object`
 # (A "SupportsDunderDict" protocol doesn't work)
+# Use a type: ignore to make complaints about overlapping overloads go away
@overload
-def vars(object: type, /) -> types.MappingProxyType[str, Any]: ...
+def vars(object: type, /) -> types.MappingProxyType[str, Any]: ...  # type: ignore[overload-overlap]
@overload
 def vars(object: Any = ..., /) -> dict[str, Any]: ...

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/contextlib.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/contextlib.pyi
@@ -55,7 +55,6 @@ class AbstractAsyncContextManager(Protocol[_T_co, _ExitT_co]):
    ) -> _ExitT_co: ...

 class ContextDecorator:
-    def _recreate_cm(self) -> Self: ...
    def __call__(self, func: _F) -> _F: ...

 class _GeneratorContextManager(AbstractContextManager[_T_co, bool | None], ContextDecorator):
@@ -81,7 +80,6 @@ if sys.version_info >= (3, 10):
    _AF = TypeVar("_AF", bound=Callable[..., Awaitable[Any]])

    class AsyncContextDecorator:
-        def _recreate_cm(self) -> Self: ...
        def __call__(self, func: _AF) -> _AF: ...

    class _AsyncGeneratorContextManager(AbstractAsyncContextManager[_T_co, bool | None], AsyncContextDecorator):
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ctypes/_endian.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ctypes/_endian.pyi
@@ -1,5 +1,12 @@
 import sys
-from ctypes import Structure, Union
+from _ctypes import RTLD_GLOBAL as RTLD_GLOBAL, RTLD_LOCAL as RTLD_LOCAL, Structure, Union
+from ctypes import DEFAULT_MODE as DEFAULT_MODE, cdll as cdll, pydll as pydll, pythonapi as pythonapi
+
+if sys.version_info >= (3, 12):
+    from _ctypes import SIZEOF_TIME_T as SIZEOF_TIME_T
+
+if sys.platform == "win32":
+    from ctypes import oledll as oledll, windll as windll

 # At runtime, the native endianness is an alias for Structure,
 # while the other is a subclass with a metaclass added in.
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/dataclasses.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/dataclasses.pyi
@@ -5,7 +5,7 @@ from _typeshed import DataclassInstance
 from builtins import type as Type  # alias to avoid name clashes with fields named "type"
 from collections.abc import Callable, Iterable, Mapping
 from typing import Any, Generic, Literal, Protocol, TypeVar, overload
-from typing_extensions import Never, TypeAlias, TypeIs
+from typing_extensions import TypeAlias, TypeIs

 if sys.version_info >= (3, 9):
    from types import GenericAlias
@@ -213,10 +213,6 @@ else:
    ) -> Any: ...

 def fields(class_or_instance: DataclassInstance | type[DataclassInstance]) -> tuple[Field[Any], ...]: ...
-
-# HACK: `obj: Never` typing matches if object argument is using `Any` type.
-@overload
-def is_dataclass(obj: Never) -> TypeIs[DataclassInstance | type[DataclassInstance]]: ...  # type: ignore[narrowed-type-not-subtype]  # pyright: ignore[reportGeneralTypeIssues]
@overload
 def is_dataclass(obj: type) -> TypeIs[type[DataclassInstance]]: ...
@overload
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/cmd.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/cmd.pyi
@@ -1,26 +1,6 @@
 from _typeshed import BytesPath, Incomplete, StrOrBytesPath, StrPath, Unused
 from abc import abstractmethod
 from collections.abc import Callable, Iterable
-from distutils.command.bdist import bdist
-from distutils.command.bdist_dumb import bdist_dumb
-from distutils.command.bdist_rpm import bdist_rpm
-from distutils.command.build import build
-from distutils.command.build_clib import build_clib
-from distutils.command.build_ext import build_ext
-from distutils.command.build_py import build_py
-from distutils.command.build_scripts import build_scripts
-from distutils.command.check import check
-from distutils.command.clean import clean
-from distutils.command.config import config
-from distutils.command.install import install
-from distutils.command.install_data import install_data
-from distutils.command.install_egg_info import install_egg_info
-from distutils.command.install_headers import install_headers
-from distutils.command.install_lib import install_lib
-from distutils.command.install_scripts import install_scripts
-from distutils.command.register import register
-from distutils.command.sdist import sdist
-from distutils.command.upload import upload
 from distutils.dist import Distribution
 from distutils.file_util import _BytesPathT, _StrPathT
 from typing import Any, ClassVar, Literal, TypeVar, overload
@@ -48,108 +28,8 @@ class Command:
    def ensure_dirname(self, option: str) -> None: ...
    def get_command_name(self) -> str: ...
    def set_undefined_options(self, src_cmd: str, *option_pairs: tuple[str, str]) -> None: ...
-    # NOTE: This list comes directly from the distutils/command folder. Minus bdist_msi and bdist_wininst.
-    @overload
-    def get_finalized_command(self, command: Literal["bdist"], create: bool | Literal[0, 1] = 1) -> bdist: ...
-    @overload
-    def get_finalized_command(self, command: Literal["bdist_dumb"], create: bool | Literal[0, 1] = 1) -> bdist_dumb: ...
-    @overload
-    def get_finalized_command(self, command: Literal["bdist_rpm"], create: bool | Literal[0, 1] = 1) -> bdist_rpm: ...
-    @overload
-    def get_finalized_command(self, command: Literal["build"], create: bool | Literal[0, 1] = 1) -> build: ...
-    @overload
-    def get_finalized_command(self, command: Literal["build_clib"], create: bool | Literal[0, 1] = 1) -> build_clib: ...
-    @overload
-    def get_finalized_command(self, command: Literal["build_ext"], create: bool | Literal[0, 1] = 1) -> build_ext: ...
-    @overload
-    def get_finalized_command(self, command: Literal["build_py"], create: bool | Literal[0, 1] = 1) -> build_py: ...
-    @overload
-    def get_finalized_command(self, command: Literal["build_scripts"], create: bool | Literal[0, 1] = 1) -> build_scripts: ...
-    @overload
-    def get_finalized_command(self, command: Literal["check"], create: bool | Literal[0, 1] = 1) -> check: ...
-    @overload
-    def get_finalized_command(self, command: Literal["clean"], create: bool | Literal[0, 1] = 1) -> clean: ...
-    @overload
-    def get_finalized_command(self, command: Literal["config"], create: bool | Literal[0, 1] = 1) -> config: ...
-    @overload
-    def get_finalized_command(self, command: Literal["install"], create: bool | Literal[0, 1] = 1) -> install: ...
-    @overload
-    def get_finalized_command(self, command: Literal["install_data"], create: bool | Literal[0, 1] = 1) -> install_data: ...
-    @overload
-    def get_finalized_command(
-        self, command: Literal["install_egg_info"], create: bool | Literal[0, 1] = 1
-    ) -> install_egg_info: ...
-    @overload
-    def get_finalized_command(self, command: Literal["install_headers"], create: bool | Literal[0, 1] = 1) -> install_headers: ...
-    @overload
-    def get_finalized_command(self, command: Literal["install_lib"], create: bool | Literal[0, 1] = 1) -> install_lib: ...
-    @overload
-    def get_finalized_command(self, command: Literal["install_scripts"], create: bool | Literal[0, 1] = 1) -> install_scripts: ...
-    @overload
-    def get_finalized_command(self, command: Literal["register"], create: bool | Literal[0, 1] = 1) -> register: ...
-    @overload
-    def get_finalized_command(self, command: Literal["sdist"], create: bool | Literal[0, 1] = 1) -> sdist: ...
-    @overload
-    def get_finalized_command(self, command: Literal["upload"], create: bool | Literal[0, 1] = 1) -> upload: ...
-    @overload
    def get_finalized_command(self, command: str, create: bool | Literal[0, 1] = 1) -> Command: ...
    @overload
-    def reinitialize_command(self, command: Literal["bdist"], reinit_subcommands: bool | Literal[0, 1] = 0) -> bdist: ...
-    @overload
-    def reinitialize_command(
-        self, command: Literal["bdist_dumb"], reinit_subcommands: bool | Literal[0, 1] = 0
-    ) -> bdist_dumb: ...
-    @overload
-    def reinitialize_command(self, command: Literal["bdist_rpm"], reinit_subcommands: bool | Literal[0, 1] = 0) -> bdist_rpm: ...
-    @overload
-    def reinitialize_command(self, command: Literal["build"], reinit_subcommands: bool | Literal[0, 1] = 0) -> build: ...
-    @overload
-    def reinitialize_command(
-        self, command: Literal["build_clib"], reinit_subcommands: bool | Literal[0, 1] = 0
-    ) -> build_clib: ...
-    @overload
-    def reinitialize_command(self, command: Literal["build_ext"], reinit_subcommands: bool | Literal[0, 1] = 0) -> build_ext: ...
-    @overload
-    def reinitialize_command(self, command: Literal["build_py"], reinit_subcommands: bool | Literal[0, 1] = 0) -> build_py: ...
-    @overload
-    def reinitialize_command(
-        self, command: Literal["build_scripts"], reinit_subcommands: bool | Literal[0, 1] = 0
-    ) -> build_scripts: ...
-    @overload
-    def reinitialize_command(self, command: Literal["check"], reinit_subcommands: bool | Literal[0, 1] = 0) -> check: ...
-    @overload
-    def reinitialize_command(self, command: Literal["clean"], reinit_subcommands: bool | Literal[0, 1] = 0) -> clean: ...
-    @overload
-    def reinitialize_command(self, command: Literal["config"], reinit_subcommands: bool | Literal[0, 1] = 0) -> config: ...
-    @overload
-    def reinitialize_command(self, command: Literal["install"], reinit_subcommands: bool | Literal[0, 1] = 0) -> install: ...
-    @overload
-    def reinitialize_command(
-        self, command: Literal["install_data"], reinit_subcommands: bool | Literal[0, 1] = 0
-    ) -> install_data: ...
-    @overload
-    def reinitialize_command(
-        self, command: Literal["install_egg_info"], reinit_subcommands: bool | Literal[0, 1] = 0
-    ) -> install_egg_info: ...
-    @overload
-    def reinitialize_command(
-        self, command: Literal["install_headers"], reinit_subcommands: bool | Literal[0, 1] = 0
-    ) -> install_headers: ...
-    @overload
-    def reinitialize_command(
-        self, command: Literal["install_lib"], reinit_subcommands: bool | Literal[0, 1] = 0
-    ) -> install_lib: ...
-    @overload
-    def reinitialize_command(
-        self, command: Literal["install_scripts"], reinit_subcommands: bool | Literal[0, 1] = 0
-    ) -> install_scripts: ...
-    @overload
-    def reinitialize_command(self, command: Literal["register"], reinit_subcommands: bool | Literal[0, 1] = 0) -> register: ...
-    @overload
-    def reinitialize_command(self, command: Literal["sdist"], reinit_subcommands: bool | Literal[0, 1] = 0) -> sdist: ...
-    @overload
-    def reinitialize_command(self, command: Literal["upload"], reinit_subcommands: bool | Literal[0, 1] = 0) -> upload: ...
-    @overload
    def reinitialize_command(self, command: str, reinit_subcommands: bool | Literal[0, 1] = 0) -> Command: ...
    @overload
    def reinitialize_command(self, command: _CommandT, reinit_subcommands: bool | Literal[0, 1] = 0) -> _CommandT: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/init.pyi
@@ -1,48 +0,0 @@
-import sys
-
-from . import (
-    bdist,
-    bdist_dumb,
-    bdist_rpm,
-    build,
-    build_clib,
-    build_ext,
-    build_py,
-    build_scripts,
-    check,
-    clean,
-    install,
-    install_data,
-    install_headers,
-    install_lib,
-    install_scripts,
-    register,
-    sdist,
-    upload,
-)
-
-__all__ = [
-    "build",
-    "build_py",
-    "build_ext",
-    "build_clib",
-    "build_scripts",
-    "clean",
-    "install",
-    "install_lib",
-    "install_headers",
-    "install_scripts",
-    "install_data",
-    "sdist",
-    "register",
-    "bdist",
-    "bdist_dumb",
-    "bdist_rpm",
-    "check",
-    "upload",
-]
-
-if sys.version_info < (3, 10):
-    from . import bdist_wininst
-
-    __all__ += ["bdist_wininst"]
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/dist.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/dist.pyi
@@ -1,26 +1,6 @@
 from _typeshed import Incomplete, StrOrBytesPath, StrPath, SupportsWrite
 from collections.abc import Iterable, MutableMapping
 from distutils.cmd import Command
-from distutils.command.bdist import bdist
-from distutils.command.bdist_dumb import bdist_dumb
-from distutils.command.bdist_rpm import bdist_rpm
-from distutils.command.build import build
-from distutils.command.build_clib import build_clib
-from distutils.command.build_ext import build_ext
-from distutils.command.build_py import build_py
-from distutils.command.build_scripts import build_scripts
-from distutils.command.check import check
-from distutils.command.clean import clean
-from distutils.command.config import config
-from distutils.command.install import install
-from distutils.command.install_data import install_data
-from distutils.command.install_egg_info import install_egg_info
-from distutils.command.install_headers import install_headers
-from distutils.command.install_lib import install_lib
-from distutils.command.install_scripts import install_scripts
-from distutils.command.register import register
-from distutils.command.sdist import sdist
-from distutils.command.upload import upload
 from re import Pattern
 from typing import IO, ClassVar, Literal, TypeVar, overload
 from typing_extensions import TypeAlias
@@ -83,6 +63,10 @@ class Distribution:
    def __init__(self, attrs: MutableMapping[str, Incomplete] | None = None) -> None: ...
    def get_option_dict(self, command: str) -> dict[str, tuple[str, str]]: ...
    def parse_config_files(self, filenames: Iterable[str] | None = None) -> None: ...
+    @overload
+    def get_command_obj(self, command: str, create: Literal[1, True] = 1) -> Command: ...
+    @overload
+    def get_command_obj(self, command: str, create: Literal[0, False]) -> Command | None: ...
    global_options: ClassVar[_OptionsList]
    common_usage: ClassVar[str]
    display_options: ClassVar[_OptionsList]
@@ -124,137 +108,8 @@ class Distribution:
    def print_commands(self) -> None: ...
    def get_command_list(self): ...
    def get_command_packages(self): ...
-    # NOTE: This list comes directly from the distutils/command folder. Minus bdist_msi and bdist_wininst.
-    @overload
-    def get_command_obj(self, command: Literal["bdist"], create: Literal[1, True] = 1) -> bdist: ...
-    @overload
-    def get_command_obj(self, command: Literal["bdist_dumb"], create: Literal[1, True] = 1) -> bdist_dumb: ...
-    @overload
-    def get_command_obj(self, command: Literal["bdist_rpm"], create: Literal[1, True] = 1) -> bdist_rpm: ...
-    @overload
-    def get_command_obj(self, command: Literal["build"], create: Literal[1, True] = 1) -> build: ...
-    @overload
-    def get_command_obj(self, command: Literal["build_clib"], create: Literal[1, True] = 1) -> build_clib: ...
-    @overload
-    def get_command_obj(self, command: Literal["build_ext"], create: Literal[1, True] = 1) -> build_ext: ...
-    @overload
-    def get_command_obj(self, command: Literal["build_py"], create: Literal[1, True] = 1) -> build_py: ...
-    @overload
-    def get_command_obj(self, command: Literal["build_scripts"], create: Literal[1, True] = 1) -> build_scripts: ...
-    @overload
-    def get_command_obj(self, command: Literal["check"], create: Literal[1, True] = 1) -> check: ...
-    @overload
-    def get_command_obj(self, command: Literal["clean"], create: Literal[1, True] = 1) -> clean: ...
-    @overload
-    def get_command_obj(self, command: Literal["config"], create: Literal[1, True] = 1) -> config: ...
-    @overload
-    def get_command_obj(self, command: Literal["install"], create: Literal[1, True] = 1) -> install: ...
-    @overload
-    def get_command_obj(self, command: Literal["install_data"], create: Literal[1, True] = 1) -> install_data: ...
-    @overload
-    def get_command_obj(self, command: Literal["install_egg_info"], create: Literal[1, True] = 1) -> install_egg_info: ...
-    @overload
-    def get_command_obj(self, command: Literal["install_headers"], create: Literal[1, True] = 1) -> install_headers: ...
-    @overload
-    def get_command_obj(self, command: Literal["install_lib"], create: Literal[1, True] = 1) -> install_lib: ...
-    @overload
-    def get_command_obj(self, command: Literal["install_scripts"], create: Literal[1, True] = 1) -> install_scripts: ...
-    @overload
-    def get_command_obj(self, command: Literal["register"], create: Literal[1, True] = 1) -> register: ...
-    @overload
-    def get_command_obj(self, command: Literal["sdist"], create: Literal[1, True] = 1) -> sdist: ...
-    @overload
-    def get_command_obj(self, command: Literal["upload"], create: Literal[1, True] = 1) -> upload: ...
-    @overload
-    def get_command_obj(self, command: str, create: Literal[1, True] = 1) -> Command: ...
-    # Not replicating the overloads for "Command | None", user may use "isinstance"
-    @overload
-    def get_command_obj(self, command: str, create: Literal[0, False]) -> Command | None: ...
-    @overload
-    def get_command_class(self, command: Literal["bdist"]) -> type[bdist]: ...
-    @overload
-    def get_command_class(self, command: Literal["bdist_dumb"]) -> type[bdist_dumb]: ...
-    @overload
-    def get_command_class(self, command: Literal["bdist_rpm"]) -> type[bdist_rpm]: ...
-    @overload
-    def get_command_class(self, command: Literal["build"]) -> type[build]: ...
-    @overload
-    def get_command_class(self, command: Literal["build_clib"]) -> type[build_clib]: ...
-    @overload
-    def get_command_class(self, command: Literal["build_ext"]) -> type[build_ext]: ...
-    @overload
-    def get_command_class(self, command: Literal["build_py"]) -> type[build_py]: ...
-    @overload
-    def get_command_class(self, command: Literal["build_scripts"]) -> type[build_scripts]: ...
-    @overload
-    def get_command_class(self, command: Literal["check"]) -> type[check]: ...
-    @overload
-    def get_command_class(self, command: Literal["clean"]) -> type[clean]: ...
-    @overload
-    def get_command_class(self, command: Literal["config"]) -> type[config]: ...
-    @overload
-    def get_command_class(self, command: Literal["install"]) -> type[install]: ...
-    @overload
-    def get_command_class(self, command: Literal["install_data"]) -> type[install_data]: ...
-    @overload
-    def get_command_class(self, command: Literal["install_egg_info"]) -> type[install_egg_info]: ...
-    @overload
-    def get_command_class(self, command: Literal["install_headers"]) -> type[install_headers]: ...
-    @overload
-    def get_command_class(self, command: Literal["install_lib"]) -> type[install_lib]: ...
-    @overload
-    def get_command_class(self, command: Literal["install_scripts"]) -> type[install_scripts]: ...
-    @overload
-    def get_command_class(self, command: Literal["register"]) -> type[register]: ...
-    @overload
-    def get_command_class(self, command: Literal["sdist"]) -> type[sdist]: ...
-    @overload
-    def get_command_class(self, command: Literal["upload"]) -> type[upload]: ...
-    @overload
    def get_command_class(self, command: str) -> type[Command]: ...
    @overload
-    def reinitialize_command(self, command: Literal["bdist"], reinit_subcommands: bool = False) -> bdist: ...
-    @overload
-    def reinitialize_command(self, command: Literal["bdist_dumb"], reinit_subcommands: bool = False) -> bdist_dumb: ...
-    @overload
-    def reinitialize_command(self, command: Literal["bdist_rpm"], reinit_subcommands: bool = False) -> bdist_rpm: ...
-    @overload
-    def reinitialize_command(self, command: Literal["build"], reinit_subcommands: bool = False) -> build: ...
-    @overload
-    def reinitialize_command(self, command: Literal["build_clib"], reinit_subcommands: bool = False) -> build_clib: ...
-    @overload
-    def reinitialize_command(self, command: Literal["build_ext"], reinit_subcommands: bool = False) -> build_ext: ...
-    @overload
-    def reinitialize_command(self, command: Literal["build_py"], reinit_subcommands: bool = False) -> build_py: ...
-    @overload
-    def reinitialize_command(self, command: Literal["build_scripts"], reinit_subcommands: bool = False) -> build_scripts: ...
-    @overload
-    def reinitialize_command(self, command: Literal["check"], reinit_subcommands: bool = False) -> check: ...
-    @overload
-    def reinitialize_command(self, command: Literal["clean"], reinit_subcommands: bool = False) -> clean: ...
-    @overload
-    def reinitialize_command(self, command: Literal["config"], reinit_subcommands: bool = False) -> config: ...
-    @overload
-    def reinitialize_command(self, command: Literal["install"], reinit_subcommands: bool = False) -> install: ...
-    @overload
-    def reinitialize_command(self, command: Literal["install_data"], reinit_subcommands: bool = False) -> install_data: ...
-    @overload
-    def reinitialize_command(
-        self, command: Literal["install_egg_info"], reinit_subcommands: bool = False
-    ) -> install_egg_info: ...
-    @overload
-    def reinitialize_command(self, command: Literal["install_headers"], reinit_subcommands: bool = False) -> install_headers: ...
-    @overload
-    def reinitialize_command(self, command: Literal["install_lib"], reinit_subcommands: bool = False) -> install_lib: ...
-    @overload
-    def reinitialize_command(self, command: Literal["install_scripts"], reinit_subcommands: bool = False) -> install_scripts: ...
-    @overload
-    def reinitialize_command(self, command: Literal["register"], reinit_subcommands: bool = False) -> register: ...
-    @overload
-    def reinitialize_command(self, command: Literal["sdist"], reinit_subcommands: bool = False) -> sdist: ...
-    @overload
-    def reinitialize_command(self, command: Literal["upload"], reinit_subcommands: bool = False) -> upload: ...
-    @overload
    def reinitialize_command(self, command: str, reinit_subcommands: bool = False) -> Command: ...
    @overload
    def reinitialize_command(self, command: _CommandT, reinit_subcommands: bool = False) -> _CommandT: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/utils.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/utils.pyi
@@ -66,10 +66,7 @@ def mktime_tz(data: _PDTZ) -> int: ...
 def formatdate(timeval: float | None = None, localtime: bool = False, usegmt: bool = False) -> str: ...
 def format_datetime(dt: datetime.datetime, usegmt: bool = False) -> str: ...

-if sys.version_info >= (3, 14):
-    def localtime(dt: datetime.datetime | None = None) -> datetime.datetime: ...
-
-elif sys.version_info >= (3, 12):
+if sys.version_info >= (3, 12):
    @overload
    def localtime(dt: datetime.datetime | None = None) -> datetime.datetime: ...
    @overload
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/filecmp.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/filecmp.pyi
@@ -17,24 +17,13 @@ def cmpfiles(
 ) -> tuple[list[AnyStr], list[AnyStr], list[AnyStr]]: ...

 class dircmp(Generic[AnyStr]):
-    if sys.version_info >= (3, 13):
-        def __init__(
-            self,
-            a: GenericPath[AnyStr],
-            b: GenericPath[AnyStr],
-            ignore: Sequence[AnyStr] | None = None,
-            hide: Sequence[AnyStr] | None = None,
-            *,
-            shallow: bool = True,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            a: GenericPath[AnyStr],
-            b: GenericPath[AnyStr],
-            ignore: Sequence[AnyStr] | None = None,
-            hide: Sequence[AnyStr] | None = None,
-        ) -> None: ...
+    def __init__(
+        self,
+        a: GenericPath[AnyStr],
+        b: GenericPath[AnyStr],
+        ignore: Sequence[AnyStr] | None = None,
+        hide: Sequence[AnyStr] | None = None,
+    ) -> None: ...
    left: AnyStr
    right: AnyStr
    hide: Sequence[AnyStr]
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/importlib/metadata/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/importlib/metadata/init.pyi
@@ -155,7 +155,7 @@ if sys.version_info >= (3, 10) and sys.version_info < (3, 12):
        @property
        def names(self) -> set[str]: ...
        @overload
-        def select(self) -> Self: ...
+        def select(self) -> Self: ...  # type: ignore[misc]
        @overload
        def select(
            self,
@@ -277,7 +277,7 @@ if sys.version_info >= (3, 12):

 elif sys.version_info >= (3, 10):
    @overload
-    def entry_points() -> SelectableGroups: ...
+    def entry_points() -> SelectableGroups: ...  # type: ignore[overload-overlap]
    @overload
    def entry_points(
        *, name: str = ..., value: str = ..., group: str = ..., module: str = ..., attr: str = ..., extras: list[str] = ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/lib2to3/fixes/fix_unicode.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/lib2to3/fixes/fix_unicode.pyi
@@ -6,7 +6,7 @@ from ..pytree import Node

 class FixUnicode(fixer_base.BaseFix):
    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
+    PATTERN: ClassVar[Literal["STRING | 'unicode' | 'unichr'"]]  # type: ignore[name-defined]  # Name "STRING" is not defined
    unicode_literals: bool
    def start_tree(self, tree: Node, filename: StrPath) -> None: ...
    def transform(self, node, results): ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/logging/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/logging/init.pyi
@@ -55,9 +55,10 @@ __all__ = [
    "setLogRecordFactory",
    "lastResort",
    "raiseExceptions",
-    "warn",
 ]

+if sys.version_info < (3, 13):
+    __all__ += ["warn"]
 if sys.version_info >= (3, 11):
    __all__ += ["getLevelNamesMapping"]
 if sys.version_info >= (3, 12):
@@ -156,16 +157,17 @@ class Logger(Filterer):
        stacklevel: int = 1,
        extra: Mapping[str, object] | None = None,
    ) -> None: ...
-    @deprecated("Deprecated; use warning() instead.")
-    def warn(
-        self,
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = None,
-        stack_info: bool = False,
-        stacklevel: int = 1,
-        extra: Mapping[str, object] | None = None,
-    ) -> None: ...
+    if sys.version_info < (3, 13):
+        def warn(
+            self,
+            msg: object,
+            *args: object,
+            exc_info: _ExcInfoType = None,
+            stack_info: bool = False,
+            stacklevel: int = 1,
+            extra: Mapping[str, object] | None = None,
+        ) -> None: ...
+
    def error(
        self,
        msg: object,
@@ -410,17 +412,18 @@ class LoggerAdapter(Generic[_L]):
        extra: Mapping[str, object] | None = None,
        **kwargs: object,
    ) -> None: ...
-    @deprecated("Deprecated; use warning() instead.")
-    def warn(
-        self,
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = None,
-        stack_info: bool = False,
-        stacklevel: int = 1,
-        extra: Mapping[str, object] | None = None,
-        **kwargs: object,
-    ) -> None: ...
+    if sys.version_info < (3, 13):
+        def warn(
+            self,
+            msg: object,
+            *args: object,
+            exc_info: _ExcInfoType = None,
+            stack_info: bool = False,
+            stacklevel: int = 1,
+            extra: Mapping[str, object] | None = None,
+            **kwargs: object,
+        ) -> None: ...
+
    def error(
        self,
        msg: object,
@@ -520,15 +523,17 @@ def warning(
    stacklevel: int = 1,
    extra: Mapping[str, object] | None = None,
 ) -> None: ...
-@deprecated("Deprecated; use warning() instead.")
-def warn(
-    msg: object,
-    *args: object,
-    exc_info: _ExcInfoType = None,
-    stack_info: bool = False,
-    stacklevel: int = 1,
-    extra: Mapping[str, object] | None = None,
-) -> None: ...
+
+if sys.version_info < (3, 13):
+    def warn(
+        msg: object,
+        *args: object,
+        exc_info: _ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+
 def error(
    msg: object,
    *args: object,
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/multiprocessing/sharedctypes.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/multiprocessing/sharedctypes.pyi
@@ -73,7 +73,7 @@ def copy(obj: _CT) -> _CT: ...
@overload
 def synchronized(obj: _SimpleCData[_T], lock: _LockLike | None = None, ctx: Any | None = None) -> Synchronized[_T]: ...
@overload
-def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...
+def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...  # type: ignore
@overload
 def synchronized(
    obj: ctypes.Array[_SimpleCData[_T]], lock: _LockLike | None = None, ctx: Any | None = None
@@ -115,12 +115,12 @@ class SynchronizedArray(SynchronizedBase[ctypes.Array[_SimpleCData[_T]]], Generi
 class SynchronizedString(SynchronizedArray[bytes]):
    @overload  # type: ignore[override]
    def __getitem__(self, i: slice) -> bytes: ...
-    @overload
+    @overload  # type: ignore[override]
    def __getitem__(self, i: int) -> bytes: ...
    @overload  # type: ignore[override]
    def __setitem__(self, i: slice, value: bytes) -> None: ...
-    @overload
-    def __setitem__(self, i: int, value: bytes) -> None: ...
+    @overload  # type: ignore[override]
+    def __setitem__(self, i: int, value: bytes) -> None: ...  # type: ignore[override]
    def __getslice__(self, start: int, stop: int) -> bytes: ...  # type: ignore[override]
    def __setslice__(self, start: int, stop: int, values: bytes) -> None: ...  # type: ignore[override]

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pathlib.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pathlib.pyi
@@ -159,20 +159,6 @@ class Path(PurePath):
    def lchmod(self, mode: int) -> None: ...
    def lstat(self) -> stat_result: ...
    def mkdir(self, mode: int = 0o777, parents: bool = False, exist_ok: bool = False) -> None: ...
-
-    if sys.version_info >= (3, 14):
-        def copy(self, target: StrPath, *, follow_symlinks: bool = True, preserve_metadata: bool = False) -> None: ...
-        def copytree(
-            self,
-            target: StrPath,
-            *,
-            follow_symlinks: bool = True,
-            preserve_metadata: bool = False,
-            dirs_exist_ok: bool = False,
-            ignore: Callable[[Self], bool] | None = None,
-            on_error: Callable[[OSError], object] | None = None,
-        ) -> None: ...
-
    # Adapted from builtins.open
    # Text mode: always returns a TextIOWrapper
    # The Traversable .open in stdlib/importlib/abc.pyi should be kept in sync with this.
@@ -246,18 +232,10 @@ class Path(PurePath):
    if sys.version_info >= (3, 9):
        def readlink(self) -> Self: ...

-    if sys.version_info >= (3, 10):
-        def rename(self, target: StrPath) -> Self: ...
-        def replace(self, target: StrPath) -> Self: ...
-    else:
-        def rename(self, target: str | PurePath) -> Self: ...
-        def replace(self, target: str | PurePath) -> Self: ...
-
+    def rename(self, target: str | PurePath) -> Self: ...
+    def replace(self, target: str | PurePath) -> Self: ...
    def resolve(self, strict: bool = False) -> Self: ...
    def rmdir(self) -> None: ...
-    if sys.version_info >= (3, 14):
-        def delete(self, ignore_errors: bool = False, on_error: Callable[[OSError], object] | None = None) -> None: ...
-
    def symlink_to(self, target: StrOrBytesPath, target_is_directory: bool = False) -> None: ...
    if sys.version_info >= (3, 10):
        def hardlink_to(self, target: StrOrBytesPath) -> None: ...
@@ -288,9 +266,6 @@ class Path(PurePath):
            self, top_down: bool = ..., on_error: Callable[[OSError], object] | None = ..., follow_symlinks: bool = ...
        ) -> Iterator[tuple[Self, list[str], list[str]]]: ...

-    if sys.version_info >= (3, 14):
-        def rmtree(self, ignore_errors: bool = False, on_error: Callable[[OSError], object] | None = None) -> None: ...
-
 class PosixPath(Path, PurePosixPath): ...
 class WindowsPath(Path, PureWindowsPath): ...

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pdb.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pdb.pyi
@@ -84,7 +84,7 @@ class Pdb(Bdb, Cmd):
        def _runscript(self, filename: str) -> None: ...

    if sys.version_info >= (3, 13):
-        def completedefault(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...
+        def completedefault(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...  # type: ignore[override]

    def do_commands(self, arg: str) -> bool | None: ...
    def do_break(self, arg: str, temporary: bool = ...) -> bool | None: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pty.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pty.pyi
@@ -1,7 +1,7 @@
 import sys
 from collections.abc import Callable, Iterable
 from typing import Final
-from typing_extensions import TypeAlias, deprecated
+from typing_extensions import TypeAlias

 if sys.platform != "win32":
    __all__ = ["openpty", "fork", "spawn"]
@@ -13,12 +13,7 @@ if sys.platform != "win32":

    CHILD: Final = 0
    def openpty() -> tuple[int, int]: ...
-
-    if sys.version_info < (3, 14):
-        @deprecated("Deprecated in 3.12, to be removed in 3.14; use openpty() instead")
-        def master_open() -> tuple[int, str]: ...
-        @deprecated("Deprecated in 3.12, to be removed in 3.14; use openpty() instead")
-        def slave_open(tty_name: str) -> int: ...
-
+    def master_open() -> tuple[int, str]: ...  # deprecated, use openpty()
+    def slave_open(tty_name: str) -> int: ...  # deprecated, use openpty()
    def fork() -> tuple[int, int]: ...
    def spawn(argv: str | Iterable[str], master_read: _Reader = ..., stdin_read: _Reader = ...) -> int: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/re.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/re.pyi
@@ -74,7 +74,7 @@ class Match(Generic[AnyStr]):
    @overload
    def expand(self: Match[str], template: str) -> str: ...
    @overload
-    def expand(self: Match[bytes], template: ReadableBuffer) -> bytes: ...
+    def expand(self: Match[bytes], template: ReadableBuffer) -> bytes: ...  # type: ignore[overload-overlap]
    @overload
    def expand(self, template: AnyStr) -> AnyStr: ...
    # group() returns "AnyStr" or "AnyStr | None", depending on the pattern.
@@ -124,21 +124,19 @@ class Pattern(Generic[AnyStr]):
    @overload
    def search(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
    @overload
-    def search(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...
+    def search(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...  # type: ignore[overload-overlap]
    @overload
    def search(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
    @overload
    def match(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
    @overload
-    def match(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...
+    def match(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...  # type: ignore[overload-overlap]
    @overload
    def match(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
    @overload
    def fullmatch(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
    @overload
-    def fullmatch(
-        self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize
-    ) -> Match[bytes] | None: ...
+    def fullmatch(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...  # type: ignore[overload-overlap]
    @overload
    def fullmatch(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
    @overload
@@ -157,15 +155,13 @@ class Pattern(Generic[AnyStr]):
    @overload
    def finditer(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[str]]: ...
    @overload
-    def finditer(
-        self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize
-    ) -> Iterator[Match[bytes]]: ...
+    def finditer(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[bytes]]: ...  # type: ignore[overload-overlap]
    @overload
    def finditer(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[AnyStr]]: ...
    @overload
    def sub(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0) -> str: ...
    @overload
-    def sub(
+    def sub(  # type: ignore[overload-overlap]
        self: Pattern[bytes],
        repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
        string: ReadableBuffer,
@@ -176,7 +172,7 @@ class Pattern(Generic[AnyStr]):
    @overload
    def subn(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0) -> tuple[str, int]: ...
    @overload
-    def subn(
+    def subn(  # type: ignore[overload-overlap]
        self: Pattern[bytes],
        repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
        string: ReadableBuffer,
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/sqlite3/dbapi2.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/sqlite3/dbapi2.pyi
@@ -29,10 +29,7 @@ def DateFromTicks(ticks: float) -> Date: ...
 def TimeFromTicks(ticks: float) -> Time: ...
 def TimestampFromTicks(ticks: float) -> Timestamp: ...

-if sys.version_info < (3, 14):
-    # Deprecated in 3.12, removed in 3.14.
-    version_info: tuple[int, int, int]
-
+version_info: tuple[int, int, int]
 sqlite_version_info: tuple[int, int, int]
 Binary = memoryview

@@ -93,10 +90,7 @@ SQLITE_UPDATE: Final[int]
 adapters: dict[tuple[type[Any], type[Any]], _Adapter[Any]]
 converters: dict[str, _Converter]
 sqlite_version: str
-
-if sys.version_info < (3, 14):
-    # Deprecated in 3.12, removed in 3.14.
-    version: str
+version: str

 if sys.version_info >= (3, 11):
    SQLITE_ABORT: Final[int]
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/symtable.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/symtable.pyi
@@ -2,7 +2,6 @@ import sys
 from _collections_abc import dict_keys
 from collections.abc import Sequence
 from typing import Any
-from typing_extensions import deprecated

 __all__ = ["symtable", "SymbolTable", "Class", "Function", "Symbol"]

@@ -52,9 +51,7 @@ class Function(SymbolTable):
    def get_nonlocals(self) -> tuple[str, ...]: ...

 class Class(SymbolTable):
-    if sys.version_info < (3, 16):
-        @deprecated("deprecated in Python 3.14, will be removed in Python 3.16")
-        def get_methods(self) -> tuple[str, ...]: ...
+    def get_methods(self) -> tuple[str, ...]: ...

 class Symbol:
    def __init__(
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tarfile.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tarfile.pyi
@@ -423,7 +423,7 @@ class TarInfo:
    name: str
    path: str
    size: int
-    mtime: int | float
+    mtime: int
    chksum: int
    devmajor: int
    devminor: int
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tempfile.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tempfile.pyi
@@ -463,7 +463,7 @@ class TemporaryDirectory(Generic[AnyStr]):

 # The overloads overlap, but they should still work fine.
@overload
-def mkstemp(
+def mkstemp(  # type: ignore[overload-overlap]
    suffix: str | None = None, prefix: str | None = None, dir: StrPath | None = None, text: bool = False
 ) -> tuple[int, str]: ...
@overload
@@ -473,7 +473,7 @@ def mkstemp(

 # The overloads overlap, but they should still work fine.
@overload
-def mkdtemp(suffix: str | None = None, prefix: str | None = None, dir: StrPath | None = None) -> str: ...
+def mkdtemp(suffix: str | None = None, prefix: str | None = None, dir: StrPath | None = None) -> str: ...  # type: ignore[overload-overlap]
@overload
 def mkdtemp(suffix: bytes | None = None, prefix: bytes | None = None, dir: BytesPath | None = None) -> bytes: ...
 def mktemp(suffix: str = "", prefix: str = "tmp", dir: StrPath | None = None) -> str: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/init.pyi
@@ -2148,12 +2148,11 @@ class Listbox(Widget, XView, YView):
        selectborderwidth: _ScreenUnits = 0,
        selectforeground: str = ...,
        # from listbox man page: "The value of the [selectmode] option may be
-        # arbitrary, but the default bindings expect it to be either single,
-        # browse, multiple, or extended"
+        # arbitrary, but the default bindings expect it to be ..."
        #
        # I have never seen anyone setting this to something else than what
        # "the default bindings expect", but let's support it anyway.
-        selectmode: str | Literal["single", "browse", "multiple", "extended"] = "browse",  # noqa: Y051
+        selectmode: str = "browse",
        setgrid: bool = False,
        state: Literal["normal", "disabled"] = "normal",
        takefocus: _TakeFocusValue = "",
@@ -2188,7 +2187,7 @@ class Listbox(Widget, XView, YView):
        selectbackground: str = ...,
        selectborderwidth: _ScreenUnits = ...,
        selectforeground: str = ...,
-        selectmode: str | Literal["single", "browse", "multiple", "extended"] = ...,  # noqa: Y051
+        selectmode: str = ...,
        setgrid: bool = ...,
        state: Literal["normal", "disabled"] = ...,
        takefocus: _TakeFocusValue = ...,
@@ -2908,9 +2907,6 @@ class Scrollbar(Widget):
    def set(self, first: float | str, last: float | str) -> None: ...

 _TextIndex: TypeAlias = _tkinter.Tcl_Obj | str | float | Misc
-_WhatToCount: TypeAlias = Literal[
-    "chars", "displaychars", "displayindices", "displaylines", "indices", "lines", "xpixels", "ypixels"
-]

 class Text(Widget, XView, YView):
    def __init__(
@@ -3025,27 +3021,7 @@ class Text(Widget, XView, YView):
    config = configure
    def bbox(self, index: _TextIndex) -> tuple[int, int, int, int] | None: ...  # type: ignore[override]
    def compare(self, index1: _TextIndex, op: Literal["<", "<=", "==", ">=", ">", "!="], index2: _TextIndex) -> bool: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex) -> tuple[int] | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg: _WhatToCount | Literal["update"], /) -> tuple[int] | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg1: Literal["update"], arg2: _WhatToCount, /) -> int | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: Literal["update"], /) -> int | None: ...
-    @overload
-    def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: _WhatToCount, /) -> tuple[int, int]: ...
-    @overload
-    def count(
-        self,
-        index1: _TextIndex,
-        index2: _TextIndex,
-        arg1: _WhatToCount | Literal["update"],
-        arg2: _WhatToCount | Literal["update"],
-        arg3: _WhatToCount | Literal["update"],
-        /,
-        *args: _WhatToCount | Literal["update"],
-    ) -> tuple[int, ...]: ...
+    def count(self, index1, index2, *args): ...  # TODO
    @overload
    def debug(self, boolean: None = None) -> bool: ...
    @overload
@@ -3588,7 +3564,7 @@ class Spinbox(Widget, XView):
    def scan_dragto(self, x): ...
    def selection(self, *args) -> tuple[int, ...]: ...
    def selection_adjust(self, index): ...
-    def selection_clear(self): ...  # type: ignore[override]
+    def selection_clear(self): ...
    def selection_element(self, element: Incomplete | None = None): ...
    def selection_from(self, index: int) -> None: ...
    def selection_present(self) -> None: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/ttk.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/ttk.pyi
@@ -1040,7 +1040,7 @@ class Treeview(Widget, tkinter.XView, tkinter.YView):
    @overload
    def heading(self, column: str | int, option: str) -> Any: ...
    @overload
-    def heading(self, column: str | int, option: None = None) -> _TreeviewHeaderDict: ...
+    def heading(self, column: str | int, option: None = None) -> _TreeviewHeaderDict: ...  # type: ignore[overload-overlap]
    @overload
    def heading(
        self,
@@ -1052,8 +1052,7 @@ class Treeview(Widget, tkinter.XView, tkinter.YView):
        anchor: tkinter._Anchor = ...,
        command: str | Callable[[], object] = ...,
    ) -> None: ...
-    # Internal Method. Leave untyped:
-    def identify(self, component, x, y): ...  # type: ignore[override]
+    def identify(self, component, x, y): ...  # Internal Method. Leave untyped
    def identify_row(self, y: int) -> str: ...
    def identify_column(self, x: int) -> str: ...
    def identify_region(self, x: int, y: int) -> Literal["heading", "separator", "tree", "cell", "nothing"]: ...
@@ -1085,7 +1084,7 @@ class Treeview(Widget, tkinter.XView, tkinter.YView):
    @overload
    def item(self, item: str | int, option: str) -> Any: ...
    @overload
-    def item(self, item: str | int, option: None = None) -> _TreeviewItemDict: ...
+    def item(self, item: str | int, option: None = None) -> _TreeviewItemDict: ...  # type: ignore[overload-overlap]
    @overload
    def item(
        self,
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/turtle.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/turtle.pyi
@@ -338,7 +338,7 @@ class TPen:
    def isvisible(self) -> bool: ...
    # Note: signatures 1 and 2 overlap unsafely when no arguments are provided
    @overload
-    def pen(self) -> _PenState: ...
+    def pen(self) -> _PenState: ...  # type: ignore[overload-overlap]
    @overload
    def pen(
        self,
@@ -384,7 +384,7 @@ class RawTurtle(TPen, TNavigator):
    def shape(self, name: str) -> None: ...
    # Unsafely overlaps when no arguments are provided
    @overload
-    def shapesize(self) -> tuple[float, float, float]: ...
+    def shapesize(self) -> tuple[float, float, float]: ...  # type: ignore[overload-overlap]
    @overload
    def shapesize(
        self, stretch_wid: float | None = None, stretch_len: float | None = None, outline: float | None = None
@@ -395,7 +395,7 @@ class RawTurtle(TPen, TNavigator):
    def shearfactor(self, shear: float) -> None: ...
    # Unsafely overlaps when no arguments are provided
    @overload
-    def shapetransform(self) -> tuple[float, float, float, float]: ...
+    def shapetransform(self) -> tuple[float, float, float, float]: ...  # type: ignore[overload-overlap]
    @overload
    def shapetransform(
        self, t11: float | None = None, t12: float | None = None, t21: float | None = None, t22: float | None = None
@@ -622,7 +622,7 @@ def isvisible() -> bool: ...

 # Note: signatures 1 and 2 overlap unsafely when no arguments are provided
@overload
-def pen() -> _PenState: ...
+def pen() -> _PenState: ...  # type: ignore[overload-overlap]
@overload
 def pen(
    pen: _PenState | None = None,
@@ -661,7 +661,7 @@ if sys.version_info >= (3, 12):

 # Unsafely overlaps when no arguments are provided
@overload
-def shapesize() -> tuple[float, float, float]: ...
+def shapesize() -> tuple[float, float, float]: ...  # type: ignore[overload-overlap]
@overload
 def shapesize(stretch_wid: float | None = None, stretch_len: float | None = None, outline: float | None = None) -> None: ...
@overload
@@ -671,7 +671,7 @@ def shearfactor(shear: float) -> None: ...

 # Unsafely overlaps when no arguments are provided
@overload
-def shapetransform() -> tuple[float, float, float, float]: ...
+def shapetransform() -> tuple[float, float, float, float]: ...  # type: ignore[overload-overlap]
@overload
 def shapetransform(
    t11: float | None = None, t12: float | None = None, t21: float | None = None, t22: float | None = None
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/types.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/types.pyi
@@ -305,9 +305,9 @@ class MappingProxyType(Mapping[_KT, _VT_co]):
    def values(self) -> ValuesView[_VT_co]: ...
    def items(self) -> ItemsView[_KT, _VT_co]: ...
    @overload
-    def get(self, key: _KT, /) -> _VT_co | None: ...
+    def get(self, key: _KT, /) -> _VT_co | None: ...  # type: ignore[override]
    @overload
-    def get(self, key: _KT, default: _VT_co | _T2, /) -> _VT_co | _T2: ...
+    def get(self, key: _KT, default: _VT_co | _T2, /) -> _VT_co | _T2: ...  # type: ignore[override]
    if sys.version_info >= (3, 9):
        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
        def __reversed__(self) -> Iterator[_KT]: ...
@@ -583,7 +583,7 @@ _P = ParamSpec("_P")

 # it's not really an Awaitable, but can be used in an await expression. Real type: Generator & Awaitable
@overload
-def coroutine(func: Callable[_P, Generator[Any, Any, _R]]) -> Callable[_P, Awaitable[_R]]: ...
+def coroutine(func: Callable[_P, Generator[Any, Any, _R]]) -> Callable[_P, Awaitable[_R]]: ...  # type: ignore[overload-overlap]
@overload
 def coroutine(func: _Fn) -> _Fn: ...

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/typing.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/typing.pyi
@@ -846,8 +846,7 @@ class TextIO(IO[str]):
    @abstractmethod
    def __enter__(self) -> TextIO: ...

-if sys.version_info < (3, 14):
-    ByteString: typing_extensions.TypeAlias = bytes | bytearray | memoryview
+ByteString: typing_extensions.TypeAlias = bytes | bytearray | memoryview

 # Functions

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/unittest/mock.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/unittest/mock.pyi
@@ -299,7 +299,7 @@ class _patcher:
    # Ideally we'd be able to add an overload for it so that the return type is _patch[MagicMock],
    # but that's impossible with the current type system.
    @overload
-    def __call__(
+    def __call__(  # type: ignore[overload-overlap]
        self,
        target: str,
        new: _T,
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/urllib/parse.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/urllib/parse.pyi
@@ -198,13 +198,13 @@ else:

 # Requires an iterable of length 6
@overload
-def urlunparse(components: Iterable[None]) -> Literal[b""]: ...  # type: ignore[overload-overlap]
+def urlunparse(components: Iterable[None]) -> Literal[b""]: ...
@overload
 def urlunparse(components: Iterable[AnyStr | None]) -> AnyStr: ...

 # Requires an iterable of length 5
@overload
-def urlunsplit(components: Iterable[None]) -> Literal[b""]: ...  # type: ignore[overload-overlap]
+def urlunsplit(components: Iterable[None]) -> Literal[b""]: ...
@overload
 def urlunsplit(components: Iterable[AnyStr | None]) -> AnyStr: ...
 def unwrap(url: str) -> str: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/urllib/request.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/urllib/request.pyi
@@ -79,7 +79,6 @@ else:
    def pathname2url(pathname: str) -> str: ...

 def getproxies() -> dict[str, str]: ...
-def getproxies_environment() -> dict[str, str]: ...
 def parse_http_list(s: str) -> list[str]: ...
 def parse_keqv_list(l: list[str]) -> dict[str, str]: ...

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/xml/dom/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/xml/dom/init.pyi
@@ -1,4 +1,4 @@
-from typing import Any, Final
+from typing import Any

 from .domreg import getDOMImplementation as getDOMImplementation, registerDOMImplementation as registerDOMImplementation

@@ -17,22 +17,22 @@ class Node:
    NOTATION_NODE: int

 # ExceptionCode
-INDEX_SIZE_ERR: Final[int]
-DOMSTRING_SIZE_ERR: Final[int]
-HIERARCHY_REQUEST_ERR: Final[int]
-WRONG_DOCUMENT_ERR: Final[int]
-INVALID_CHARACTER_ERR: Final[int]
-NO_DATA_ALLOWED_ERR: Final[int]
-NO_MODIFICATION_ALLOWED_ERR: Final[int]
-NOT_FOUND_ERR: Final[int]
-NOT_SUPPORTED_ERR: Final[int]
-INUSE_ATTRIBUTE_ERR: Final[int]
-INVALID_STATE_ERR: Final[int]
-SYNTAX_ERR: Final[int]
-INVALID_MODIFICATION_ERR: Final[int]
-NAMESPACE_ERR: Final[int]
-INVALID_ACCESS_ERR: Final[int]
-VALIDATION_ERR: Final[int]
+INDEX_SIZE_ERR: int
+DOMSTRING_SIZE_ERR: int
+HIERARCHY_REQUEST_ERR: int
+WRONG_DOCUMENT_ERR: int
+INVALID_CHARACTER_ERR: int
+NO_DATA_ALLOWED_ERR: int
+NO_MODIFICATION_ALLOWED_ERR: int
+NOT_FOUND_ERR: int
+NOT_SUPPORTED_ERR: int
+INUSE_ATTRIBUTE_ERR: int
+INVALID_STATE_ERR: int
+SYNTAX_ERR: int
+INVALID_MODIFICATION_ERR: int
+NAMESPACE_ERR: int
+INVALID_ACCESS_ERR: int
+VALIDATION_ERR: int

 class DOMException(Exception):
    code: int
@@ -62,8 +62,8 @@ class UserDataHandler:
    NODE_DELETED: int
    NODE_RENAMED: int

-XML_NAMESPACE: Final[str]
-XMLNS_NAMESPACE: Final[str]
-XHTML_NAMESPACE: Final[str]
-EMPTY_NAMESPACE: Final[None]
-EMPTY_PREFIX: Final[None]
+XML_NAMESPACE: str
+XMLNS_NAMESPACE: str
+XHTML_NAMESPACE: str
+EMPTY_NAMESPACE: None
+EMPTY_PREFIX: None
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/xml/etree/ElementInclude.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/xml/etree/ElementInclude.pyi
@@ -1,15 +1,14 @@
 import sys
 from _typeshed import FileDescriptorOrPath
 from collections.abc import Callable
-from typing import Final
 from xml.etree.ElementTree import Element

-XINCLUDE: Final[str]
-XINCLUDE_INCLUDE: Final[str]
-XINCLUDE_FALLBACK: Final[str]
+XINCLUDE: str
+XINCLUDE_INCLUDE: str
+XINCLUDE_FALLBACK: str

 if sys.version_info >= (3, 9):
-    DEFAULT_MAX_INCLUSION_DEPTH: Final = 6
+    DEFAULT_MAX_INCLUSION_DEPTH: int

 class FatalIncludeError(SyntaxError): ...

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/xml/etree/ElementTree.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/xml/etree/ElementTree.pyi
@@ -2,7 +2,7 @@ import sys
 from _collections_abc import dict_keys
 from _typeshed import FileDescriptorOrPath, ReadableBuffer, SupportsRead, SupportsWrite
 from collections.abc import Callable, Generator, ItemsView, Iterable, Iterator, Mapping, Sequence
-from typing import Any, Final, Literal, SupportsIndex, TypeVar, overload
+from typing import Any, Literal, SupportsIndex, TypeVar, overload
 from typing_extensions import TypeAlias, TypeGuard, deprecated

 __all__ = [
@@ -41,7 +41,7 @@ _FileRead: TypeAlias = FileDescriptorOrPath | SupportsRead[bytes] | SupportsRead
 _FileWriteC14N: TypeAlias = FileDescriptorOrPath | SupportsWrite[bytes]
 _FileWrite: TypeAlias = _FileWriteC14N | SupportsWrite[str]

-VERSION: Final[str]
+VERSION: str

 class ParseError(SyntaxError):
    code: int
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/zipfile/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/zipfile/init.pyi
@@ -94,20 +94,6 @@ class ZipExtFile(io.BufferedIOBase):
 class _Writer(Protocol):
    def write(self, s: str, /) -> object: ...

-class _ZipReadable(Protocol):
-    def seek(self, offset: int, whence: int = 0, /) -> int: ...
-    def read(self, n: int = -1, /) -> bytes: ...
-
-class _ZipTellable(Protocol):
-    def tell(self) -> int: ...
-
-class _ZipReadableTellable(_ZipReadable, _ZipTellable, Protocol): ...
-
-class _ZipWritable(Protocol):
-    def flush(self) -> None: ...
-    def close(self) -> None: ...
-    def write(self, b: bytes, /) -> int: ...
-
 class ZipFile:
    filename: str | None
    debug: int
@@ -120,50 +106,24 @@ class ZipFile:
    compresslevel: int | None  # undocumented
    mode: _ZipFileMode  # undocumented
    pwd: bytes | None  # undocumented
-    # metadata_encoding is new in 3.11
    if sys.version_info >= (3, 11):
        @overload
        def __init__(
            self,
            file: StrPath | IO[bytes],
-            mode: _ZipFileMode = "r",
-            compression: int = 0,
-            allowZip64: bool = True,
-            compresslevel: int | None = None,
-            *,
-            strict_timestamps: bool = True,
-            metadata_encoding: str | None = None,
-        ) -> None: ...
-        # metadata_encoding is only allowed for read mode
-        @overload
-        def __init__(
-            self,
-            file: StrPath | _ZipReadable,
            mode: Literal["r"] = "r",
            compression: int = 0,
            allowZip64: bool = True,
            compresslevel: int | None = None,
            *,
            strict_timestamps: bool = True,
-            metadata_encoding: str | None = None,
+            metadata_encoding: str | None,
        ) -> None: ...
        @overload
        def __init__(
            self,
-            file: StrPath | _ZipWritable,
-            mode: Literal["w", "x"] = ...,
-            compression: int = 0,
-            allowZip64: bool = True,
-            compresslevel: int | None = None,
-            *,
-            strict_timestamps: bool = True,
-            metadata_encoding: None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self,
-            file: StrPath | _ZipReadableTellable,
-            mode: Literal["a"] = ...,
+            file: StrPath | IO[bytes],
+            mode: _ZipFileMode = "r",
            compression: int = 0,
            allowZip64: bool = True,
            compresslevel: int | None = None,
@@ -172,7 +132,6 @@ class ZipFile:
            metadata_encoding: None = None,
        ) -> None: ...
    else:
-        @overload
        def __init__(
            self,
            file: StrPath | IO[bytes],
@@ -183,39 +142,6 @@ class ZipFile:
            *,
            strict_timestamps: bool = True,
        ) -> None: ...
-        @overload
-        def __init__(
-            self,
-            file: StrPath | _ZipReadable,
-            mode: Literal["r"] = "r",
-            compression: int = 0,
-            allowZip64: bool = True,
-            compresslevel: int | None = None,
-            *,
-            strict_timestamps: bool = True,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self,
-            file: StrPath | _ZipWritable,
-            mode: Literal["w", "x"] = ...,
-            compression: int = 0,
-            allowZip64: bool = True,
-            compresslevel: int | None = None,
-            *,
-            strict_timestamps: bool = True,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self,
-            file: StrPath | _ZipReadableTellable,
-            mode: Literal["a"] = ...,
-            compression: int = 0,
-            allowZip64: bool = True,
-            compresslevel: int | None = None,
-            *,
-            strict_timestamps: bool = True,
-        ) -> None: ...

    def __enter__(self) -> Self: ...
    def __exit__(
--- a/crates/red_knot_server/Cargo.toml
+++ b/crates/red_knot_server/Cargo.toml
@@ -11,8 +11,10 @@ repository = { workspace = true }
 license = { workspace = true }

 [dependencies]
+red_knot_python_semantic = { workspace = true }
 red_knot_workspace = { workspace = true }
 ruff_db = { workspace = true }
+ruff_linter = { workspace = true }
 ruff_notebook = { workspace = true }
 ruff_python_ast = { workspace = true }
 ruff_source_file = { workspace = true }
--- a/crates/red_knot_server/src/server.rs
+++ b/crates/red_knot_server/src/server.rs
@@ -3,10 +3,11 @@
 use std::num::NonZeroUsize;
 use std::panic::PanicInfo;

-use lsp_server::Message;
+use lsp_server as lsp;
+use lsp_types as types;
 use lsp_types::{
-    ClientCapabilities, DiagnosticOptions, DiagnosticServerCapabilities, MessageType,
-    ServerCapabilities, TextDocumentSyncCapability, TextDocumentSyncOptions, Url,
+    ClientCapabilities, DiagnosticOptions, NotebookCellSelector, NotebookDocumentSyncOptions,
+    NotebookSelector, TextDocumentSyncCapability, TextDocumentSyncOptions,
 };

 use self::connection::{Connection, ConnectionInitializer};
@@ -73,7 +74,7 @@ impl Server {
            init_params.client_info.as_ref(),
        );

-        let mut workspace_for_url = |url: Url| {
+        let mut workspace_for_url = |url: lsp_types::Url| {
            let Some(workspace_settings) = workspace_settings.as_mut() else {
                return (url, ClientSettings::default());
            };
@@ -92,7 +93,7 @@ impl Server {
            }).collect())
            .or_else(|| {
                tracing::warn!("No workspace(s) were provided during initialization. Using the current working directory as a default workspace...");
-                let uri = Url::from_file_path(std::env::current_dir().ok()?).ok()?;
+                let uri = types::Url::from_file_path(std::env::current_dir().ok()?).ok()?;
                Some(vec![workspace_for_url(uri)])
            })
            .ok_or_else(|| {
@@ -148,7 +149,7 @@ impl Server {
            try_show_message(
                "The Ruff language server exited with a panic. See the logs for more details."
                    .to_string(),
-                MessageType::ERROR,
+                lsp_types::MessageType::ERROR,
            )
            .ok();
        }));
@@ -181,9 +182,9 @@ impl Server {
                break;
            }
            let task = match msg {
-                Message::Request(req) => api::request(req),
-                Message::Notification(notification) => api::notification(notification),
-                Message::Response(response) => scheduler.response(response),
+                lsp::Message::Request(req) => api::request(req),
+                lsp::Message::Notification(notification) => api::notification(notification),
+                lsp::Message::Response(response) => scheduler.response(response),
            };
            scheduler.dispatch(task);
        }
@@ -205,12 +206,24 @@ impl Server {
            .unwrap_or_default()
    }

-    fn server_capabilities(position_encoding: PositionEncoding) -> ServerCapabilities {
-        ServerCapabilities {
+    fn server_capabilities(position_encoding: PositionEncoding) -> types::ServerCapabilities {
+        types::ServerCapabilities {
            position_encoding: Some(position_encoding.into()),
-            diagnostic_provider: Some(DiagnosticServerCapabilities::Options(DiagnosticOptions {
-                identifier: Some(crate::DIAGNOSTIC_NAME.into()),
-                ..Default::default()
+            diagnostic_provider: Some(types::DiagnosticServerCapabilities::Options(
+                DiagnosticOptions {
+                    identifier: Some(crate::DIAGNOSTIC_NAME.into()),
+                    ..Default::default()
+                },
+            )),
+            notebook_document_sync: Some(types::OneOf::Left(NotebookDocumentSyncOptions {
+                save: Some(false),
+                notebook_selector: [NotebookSelector::ByCells {
+                    notebook: None,
+                    cells: vec![NotebookCellSelector {
+                        language: "python".to_string(),
+                    }],
+                }]
+                .to_vec(),
            })),
            text_document_sync: Some(TextDocumentSyncCapability::Options(
                TextDocumentSyncOptions {
--- a/crates/red_knot_server/src/session.rs
+++ b/crates/red_knot_server/src/session.rs
@@ -8,6 +8,7 @@ use std::sync::Arc;
 use anyhow::anyhow;
 use lsp_types::{ClientCapabilities, Url};

+use red_knot_python_semantic::{ProgramSettings, PythonVersion, SearchPathSettings};
 use red_knot_workspace::db::RootDatabase;
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::files::{system_path_to_file, File};
@@ -66,10 +67,19 @@ impl Session {
                .ok_or_else(|| anyhow!("Workspace path is not a valid UTF-8 path: {:?}", path))?;
            let system = LSPSystem::new(index.clone());

+            let metadata = WorkspaceMetadata::from_path(system_path, &system)?;
            // TODO(dhruvmanila): Get the values from the client settings
-            let metadata = WorkspaceMetadata::from_path(system_path, &system, None)?;
+            let program_settings = ProgramSettings {
+                target_version: PythonVersion::default(),
+                search_paths: SearchPathSettings {
+                    extra_paths: vec![],
+                    src_root: system_path.to_path_buf(),
+                    site_packages: vec![],
+                    custom_typeshed: None,
+                },
+            };
            // TODO(micha): Handle the case where the program settings are incorrect more gracefully.
-            workspaces.insert(path, RootDatabase::new(metadata, system)?);
+            workspaces.insert(path, RootDatabase::new(metadata, program_settings, system)?);
        }

        Ok(Self {
--- a/crates/red_knot_server/src/session/capabilities.rs
+++ b/crates/red_knot_server/src/session/capabilities.rs
@@ -1,4 +1,5 @@
 use lsp_types::ClientCapabilities;
+use ruff_linter::display_settings;

 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 #[allow(clippy::struct_excessive_bools)]
@@ -65,3 +66,20 @@ impl ResolvedClientCapabilities {
        }
    }
 }
+
+impl std::fmt::Display for ResolvedClientCapabilities {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "capabilities",
+            fields = [
+                self.code_action_deferred_edit_resolution,
+                self.apply_edit,
+                self.document_changes,
+                self.workspace_refresh,
+                self.pull_diagnostics,
+            ]
+        };
+        Ok(())
+    }
+}
--- a/crates/red_knot_server/src/session/index.rs
+++ b/crates/red_knot_server/src/session/index.rs
@@ -278,6 +278,18 @@ impl DocumentQuery {
        }
    }

+    /// Generate a source kind used by the linter.
+    pub(crate) fn make_source_kind(&self) -> ruff_linter::source_kind::SourceKind {
+        match self {
+            Self::Text { document, .. } => {
+                ruff_linter::source_kind::SourceKind::Python(document.contents().to_string())
+            }
+            Self::Notebook { notebook, .. } => {
+                ruff_linter::source_kind::SourceKind::IpyNotebook(notebook.make_ruff_notebook())
+            }
+        }
+    }
+
    /// Attempts to access the underlying notebook document that this query is selecting.
    pub fn as_notebook(&self) -> Option<&NotebookDocument> {
        match self {
--- a/crates/red_knot_wasm/src/lib.rs
+++ b/crates/red_knot_wasm/src/lib.rs
@@ -3,8 +3,8 @@ use std::any::Any;
 use js_sys::Error;
 use wasm_bindgen::prelude::*;

+use red_knot_python_semantic::{ProgramSettings, SearchPathSettings};
 use red_knot_workspace::db::RootDatabase;
-use red_knot_workspace::workspace::settings::Configuration;
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::files::{system_path_to_file, File};
 use ruff_db::system::walk_directory::WalkDirectoryBuilder;
@@ -41,17 +41,16 @@ 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::from_path(
-            SystemPath::new(root),
-            &system,
-            Some(Configuration {
-                target_version: Some(settings.target_version.into()),
-                ..Configuration::default()
-            }),
-        )
-        .map_err(into_error)?;
+        let workspace =
+            WorkspaceMetadata::from_path(SystemPath::new(root), &system).map_err(into_error)?;

-        let db = RootDatabase::new(workspace, system.clone()).map_err(into_error)?;
+        let program_settings = ProgramSettings {
+            target_version: settings.target_version.into(),
+            search_paths: SearchPathSettings::default(),
+        };
+
+        let db =
+            RootDatabase::new(workspace, program_settings, system.clone()).map_err(into_error)?;

        Ok(Self { db, system })
    }
@@ -110,7 +109,7 @@ impl Workspace {
    pub fn check_file(&self, file_id: &FileHandle) -> Result<Vec<String>, Error> {
        let result = self.db.check_file(file_id.file).map_err(into_error)?;

-        Ok(result.clone())
+        Ok(result.to_vec())
    }

    /// Checks all open files
--- a/crates/red_knot_wasm/tests/api.rs
+++ b/crates/red_knot_wasm/tests/api.rs
@@ -17,8 +17,5 @@ fn check() {

    let result = workspace.check_file(&test).expect("Check to succeed");

-    assert_eq!(
-        result,
-        vec!["/test.py:1:8: Import 'random22' could not be resolved.",]
-    );
+    assert_eq!(result, vec!["/test.py:1:8: Unresolved import 'random22'"]);
 }
--- a/crates/red_knot_workspace/Cargo.toml
+++ b/crates/red_knot_workspace/Cargo.toml
@@ -24,10 +24,10 @@ crossbeam = { workspace = true }
 notify = { workspace = true }
 rustc-hash = { workspace = true }
 salsa = { workspace = true }
+thiserror = { workspace = true }
 tracing = { workspace = true }

 [dev-dependencies]
-ruff_db = { workspace = true, features = ["testing"]}

 [lints]
 workspace = true
--- a/crates/red_knot_workspace/src/db.rs
+++ b/crates/red_knot_workspace/src/db.rs
@@ -1,15 +1,17 @@
 use std::panic::RefUnwindSafe;
 use std::sync::Arc;

-use salsa::plumbing::ZalsaDatabase;
-use salsa::{Cancelled, Event};
-
-use red_knot_python_semantic::{vendored_typeshed_stubs, Db as SemanticDb, Program};
+use red_knot_python_semantic::{
+    vendored_typeshed_stubs, Db as SemanticDb, Program, ProgramSettings,
+};
 use ruff_db::files::{File, Files};
 use ruff_db::system::System;
 use ruff_db::vendored::VendoredFileSystem;
 use ruff_db::{Db as SourceDb, Upcast};
+use salsa::plumbing::ZalsaDatabase;
+use salsa::{Cancelled, Event};

+use crate::lint::Diagnostics;
 use crate::workspace::{check_file, Workspace, WorkspaceMetadata};

 mod changes;
@@ -26,7 +28,11 @@ pub struct RootDatabase {
 }

 impl RootDatabase {
-    pub fn new<S>(workspace: WorkspaceMetadata, system: S) -> anyhow::Result<Self>
+    pub fn new<S>(
+        workspace: WorkspaceMetadata,
+        settings: ProgramSettings,
+        system: S,
+    ) -> anyhow::Result<Self>
    where
        S: System + 'static + Send + Sync + RefUnwindSafe,
    {
@@ -37,11 +43,11 @@ impl RootDatabase {
            system: Arc::new(system),
        };

+        let workspace = Workspace::from_metadata(&db, workspace);
        // Initialize the `Program` singleton
-        Program::from_settings(&db, workspace.settings().program())?;
-
-        db.workspace = Some(Workspace::from_metadata(&db, workspace));
+        Program::from_settings(&db, settings)?;

+        db.workspace = Some(workspace);
        Ok(db)
    }

@@ -55,7 +61,7 @@ impl RootDatabase {
        self.with_db(|db| db.workspace().check(db))
    }

-    pub fn check_file(&self, file: File) -> Result<Vec<String>, Cancelled> {
+    pub fn check_file(&self, file: File) -> Result<Diagnostics, Cancelled> {
        self.with_db(|db| check_file(db, file))
    }

@@ -109,15 +115,7 @@ impl Upcast<dyn SourceDb> for RootDatabase {
 }

 #[salsa::db]
-impl SemanticDb for RootDatabase {
-    fn is_file_open(&self, file: File) -> bool {
-        let Some(workspace) = &self.workspace else {
-            return false;
-        };
-
-        workspace.is_file_open(self, file)
-    }
-}
+impl SemanticDb for RootDatabase {}

 #[salsa::db]
 impl SourceDb for RootDatabase {
@@ -155,9 +153,8 @@ impl Db for RootDatabase {}

 #[cfg(test)]
 pub(crate) mod tests {
-    use std::sync::Arc;
-
    use salsa::Event;
+    use std::sync::Arc;

    use red_knot_python_semantic::{vendored_typeshed_stubs, Db as SemanticDb};
    use ruff_db::files::Files;
@@ -245,12 +242,7 @@ pub(crate) mod tests {
    }

    #[salsa::db]
-    impl red_knot_python_semantic::Db for TestDb {
-        fn is_file_open(&self, file: ruff_db::files::File) -> bool {
-            !file.path(self).is_vendored_path()
-        }
-    }
-
+    impl red_knot_python_semantic::Db for TestDb {}
    #[salsa::db]
    impl Db for TestDb {}

--- a/crates/red_knot_workspace/src/db/changes.rs
+++ b/crates/red_knot_workspace/src/db/changes.rs
@@ -1,33 +1,22 @@
-use red_knot_python_semantic::Program;
+use rustc_hash::FxHashSet;
+
 use ruff_db::files::{system_path_to_file, File, Files};
 use ruff_db::system::walk_directory::WalkState;
 use ruff_db::system::SystemPath;
 use ruff_db::Db;
-use rustc_hash::FxHashSet;

 use crate::db::RootDatabase;
 use crate::watch;
 use crate::watch::{CreatedKind, DeletedKind};
-use crate::workspace::settings::Configuration;
 use crate::workspace::WorkspaceMetadata;

 impl RootDatabase {
-    #[tracing::instrument(level = "debug", skip(self, changes, base_configuration))]
-    pub fn apply_changes(
-        &mut self,
-        changes: Vec<watch::ChangeEvent>,
-        base_configuration: Option<&Configuration>,
-    ) {
+    #[tracing::instrument(level = "debug", skip(self, changes))]
+    pub fn apply_changes(&mut self, changes: Vec<watch::ChangeEvent>) {
        let workspace = self.workspace();
        let workspace_path = workspace.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;
-        // 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
@@ -65,10 +54,6 @@ impl RootDatabase {

                    continue;
                }
-
-                if Some(path) == custom_stdlib_versions_path.as_deref() {
-                    custom_stdlib_change = true;
-                }
            }

            match change {
@@ -115,13 +100,7 @@ impl RootDatabase {
                    } else {
                        sync_recursively(self, &path);

-                        if custom_stdlib_versions_path
-                            .as_ref()
-                            .is_some_and(|versions_path| versions_path.starts_with(&path))
-                        {
-                            custom_stdlib_change = true;
-                        }
-
+                        // TODO: Remove after converting `package.files()` to a salsa query.
                        if let Some(package) = workspace.package(self, &path) {
                            changed_packages.insert(package);
                        } else {
@@ -139,13 +118,9 @@ impl RootDatabase {
        }

        if workspace_change {
-            match WorkspaceMetadata::from_path(
-                &workspace_path,
-                self.system(),
-                base_configuration.cloned(),
-            ) {
+            match WorkspaceMetadata::from_path(&workspace_path, self.system()) {
                Ok(metadata) => {
-                    tracing::debug!("Reloading workspace after structural change.");
+                    tracing::debug!("Reload workspace after structural change.");
                    // TODO: Handle changes in the program settings.
                    workspace.reload(self, metadata);
                }
@@ -155,11 +130,6 @@ impl RootDatabase {
            }

            return;
-        } else if custom_stdlib_change {
-            let search_paths = workspace.search_path_settings(self).clone();
-            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| {
--- a/crates/red_knot_workspace/src/lib.rs
+++ b/crates/red_knot_workspace/src/lib.rs
@@ -1,4 +1,5 @@
 pub mod db;
 pub mod lint;
+pub mod site_packages;
 pub mod watch;
 pub mod workspace;
--- a/crates/red_knot_workspace/src/lint.rs
+++ b/crates/red_knot_workspace/src/lint.rs
@@ -1,4 +1,5 @@
 use std::cell::RefCell;
+use std::ops::Deref;
 use std::time::Duration;

 use tracing::debug_span;
@@ -21,7 +22,7 @@ use crate::db::Db;
 pub(crate) fn unwind_if_cancelled(db: &dyn Db) {}

 #[salsa::tracked(return_ref)]
-pub(crate) fn lint_syntax(db: &dyn Db, file_id: File) -> Vec<String> {
+pub(crate) fn lint_syntax(db: &dyn Db, file_id: File) -> Diagnostics {
    #[allow(clippy::print_stdout)]
    if std::env::var("RED_KNOT_SLOW_LINT").is_ok() {
        for i in 0..10 {
@@ -63,7 +64,7 @@ pub(crate) fn lint_syntax(db: &dyn Db, file_id: File) -> Vec<String> {
        }));
    }

-    diagnostics
+    Diagnostics::from(diagnostics)
 }

 fn lint_lines(source: &str, diagnostics: &mut Vec<String>) {
@@ -85,7 +86,7 @@ fn lint_lines(source: &str, diagnostics: &mut Vec<String>) {

 #[allow(unreachable_pub)]
 #[salsa::tracked(return_ref)]
-pub fn lint_semantic(db: &dyn Db, file_id: File) -> Vec<String> {
+pub fn lint_semantic(db: &dyn Db, file_id: File) -> Diagnostics {
    let _span = debug_span!("lint_semantic", file=%file_id.path(db)).entered();

    let source = source_text(db.upcast(), file_id);
@@ -93,7 +94,7 @@ pub fn lint_semantic(db: &dyn Db, file_id: File) -> Vec<String> {
    let semantic = SemanticModel::new(db.upcast(), file_id);

    if !parsed.is_valid() {
-        return vec![];
+        return Diagnostics::Empty;
    }

    let context = SemanticLintContext {
@@ -105,7 +106,7 @@ pub fn lint_semantic(db: &dyn Db, file_id: File) -> Vec<String> {

    SemanticVisitor { context: &context }.visit_body(parsed.suite());

-    context.diagnostics.take()
+    Diagnostics::from(context.diagnostics.take())
 }

 fn format_diagnostic(context: &SemanticLintContext, message: &str, start: TextSize) -> String {
@@ -115,13 +116,44 @@ fn format_diagnostic(context: &SemanticLintContext, message: &str, start: TextSi
        .source_location(start, context.source_text());
    format!(
        "{}:{}:{}: {}",
-        context.semantic.file_path(),
+        context.semantic.file_path().as_str(),
        source_location.row,
        source_location.column,
        message,
    )
 }

+fn lint_unresolved_imports(context: &SemanticLintContext, import: AnyImportRef) {
+    match import {
+        AnyImportRef::Import(import) => {
+            for alias in &import.names {
+                let ty = alias.ty(&context.semantic);
+
+                if ty.is_unbound() {
+                    context.push_diagnostic(format_diagnostic(
+                        context,
+                        &format!("Unresolved import '{}'", &alias.name),
+                        alias.start(),
+                    ));
+                }
+            }
+        }
+        AnyImportRef::ImportFrom(import) => {
+            for alias in &import.names {
+                let ty = alias.ty(&context.semantic);
+
+                if ty.is_unbound() {
+                    context.push_diagnostic(format_diagnostic(
+                        context,
+                        &format!("Unresolved import '{}'", &alias.name),
+                        alias.start(),
+                    ));
+                }
+            }
+        }
+    }
+}
+
 fn lint_maybe_undefined(context: &SemanticLintContext, name: &ast::ExprName) {
    if !matches!(name.ctx, ast::ExprContext::Load) {
        return;
@@ -244,8 +276,17 @@ struct SemanticVisitor<'a> {

 impl Visitor<'_> for SemanticVisitor<'_> {
    fn visit_stmt(&mut self, stmt: &ast::Stmt) {
-        if let ast::Stmt::ClassDef(class) = stmt {
-            lint_bad_override(self.context, class);
+        match stmt {
+            ast::Stmt::ClassDef(class) => {
+                lint_bad_override(self.context, class);
+            }
+            ast::Stmt::Import(import) => {
+                lint_unresolved_imports(self.context, AnyImportRef::Import(import));
+            }
+            ast::Stmt::ImportFrom(import) => {
+                lint_unresolved_imports(self.context, AnyImportRef::ImportFrom(import));
+            }
+            _ => {}
        }

        walk_stmt(self, stmt);
@@ -263,6 +304,53 @@ impl Visitor<'_> for SemanticVisitor<'_> {
    }
 }

+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Diagnostics {
+    Empty,
+    List(Vec<String>),
+}
+
+impl Diagnostics {
+    pub fn as_slice(&self) -> &[String] {
+        match self {
+            Diagnostics::Empty => &[],
+            Diagnostics::List(list) => list.as_slice(),
+        }
+    }
+}
+
+impl Deref for Diagnostics {
+    type Target = [String];
+    fn deref(&self) -> &Self::Target {
+        self.as_slice()
+    }
+}
+
+impl From<Vec<String>> for Diagnostics {
+    fn from(value: Vec<String>) -> Self {
+        if value.is_empty() {
+            Diagnostics::Empty
+        } else {
+            Diagnostics::List(value)
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+enum AnyImportRef<'a> {
+    Import(&'a ast::StmtImport),
+    ImportFrom(&'a ast::StmtImportFrom),
+}
+
+impl Ranged for AnyImportRef<'_> {
+    fn range(&self) -> ruff_text_size::TextRange {
+        match self {
+            AnyImportRef::Import(import) => import.range(),
+            AnyImportRef::ImportFrom(import) => import.range(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use red_knot_python_semantic::{Program, ProgramSettings, PythonVersion, SearchPathSettings};
@@ -271,7 +359,7 @@ mod tests {

    use crate::db::tests::TestDb;

-    use super::lint_semantic;
+    use super::{lint_semantic, Diagnostics};

    fn setup_db() -> TestDb {
        setup_db_with_root(SystemPathBuf::from("/src"))
@@ -286,9 +374,14 @@ mod tests {

        Program::from_settings(
            &db,
-            &ProgramSettings {
+            ProgramSettings {
                target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(src_root),
+                search_paths: SearchPathSettings {
+                    extra_paths: Vec::new(),
+                    src_root,
+                    site_packages: vec![],
+                    custom_typeshed: None,
+                },
            },
        )
        .expect("Valid program settings");
@@ -312,9 +405,9 @@ mod tests {
        .unwrap();

        let file = system_path_to_file(&db, "/src/a.py").expect("file to exist");
-        let messages = lint_semantic(&db, file);
-
-        assert_ne!(messages, &[] as &[String], "expected some diagnostics");
+        let Diagnostics::List(messages) = lint_semantic(&db, file) else {
+            panic!("expected some diagnostics");
+        };

        assert_eq!(
            *messages,
--- a/crates/red_knot_python_semantic/src/site_packages.rs
+++ b/crates/red_knot_python_semantic/src/site_packages.rs
@@ -13,10 +13,9 @@ use std::io;
 use std::num::NonZeroUsize;
 use std::ops::Deref;

+use red_knot_python_semantic::PythonVersion;
 use ruff_db::system::{System, SystemPath, SystemPathBuf};

-use crate::PythonVersion;
-
 type SitePackagesDiscoveryResult<T> = Result<T, SitePackagesDiscoveryError>;

 /// Abstraction for a Python virtual environment.
@@ -25,7 +24,7 @@ type SitePackagesDiscoveryResult<T> = Result<T, SitePackagesDiscoveryError>;
 /// The format of this file is not defined anywhere, and exactly which keys are present
 /// depends on the tool that was used to create the virtual environment.
 #[derive(Debug)]
-pub(crate) struct VirtualEnvironment {
+pub struct VirtualEnvironment {
    venv_path: SysPrefixPath,
    base_executable_home_path: PythonHomePath,
    include_system_site_packages: bool,
@@ -42,7 +41,7 @@ pub(crate) struct VirtualEnvironment {
 }

 impl VirtualEnvironment {
-    pub(crate) fn new(
+    pub fn new(
        path: impl AsRef<SystemPath>,
        system: &dyn System,
    ) -> SitePackagesDiscoveryResult<Self> {
@@ -56,7 +55,7 @@ impl VirtualEnvironment {

        let venv_path = SysPrefixPath::new(path, system)?;
        let pyvenv_cfg_path = venv_path.join("pyvenv.cfg");
-        tracing::debug!("Attempting to parse virtual environment metadata at '{pyvenv_cfg_path}'");
+        tracing::debug!("Attempting to parse virtual environment metadata at {pyvenv_cfg_path}");

        let pyvenv_cfg = system
            .read_to_string(&pyvenv_cfg_path)
@@ -158,7 +157,7 @@ impl VirtualEnvironment {
    /// Return a list of `site-packages` directories that are available from this virtual environment
    ///
    /// See the documentation for `site_packages_dir_from_sys_prefix` for more details.
-    pub(crate) fn site_packages_directories(
+    pub fn site_packages_directories(
        &self,
        system: &dyn System,
    ) -> SitePackagesDiscoveryResult<Vec<SystemPathBuf>> {
@@ -192,7 +191,7 @@ impl VirtualEnvironment {
            } else {
                tracing::warn!(
                    "Failed to resolve `sys.prefix` of the system Python installation \
-from the `home` value in the `pyvenv.cfg` file at '{}'. \
+from the `home` value in the `pyvenv.cfg` file at {}. \
 System site-packages will not be used for module resolution.",
                    venv_path.join("pyvenv.cfg")
                );
@@ -205,7 +204,7 @@ System site-packages will not be used for module resolution.",
 }

 #[derive(Debug, thiserror::Error)]
-pub(crate) enum SitePackagesDiscoveryError {
+pub enum SitePackagesDiscoveryError {
    #[error("Invalid --venv-path argument: {0} could not be canonicalized")]
    VenvDirCanonicalizationError(SystemPathBuf, #[source] io::Error),
    #[error("Invalid --venv-path argument: {0} does not point to a directory on disk")]
@@ -222,7 +221,7 @@ pub(crate) enum SitePackagesDiscoveryError {

 /// The various ways in which parsing a `pyvenv.cfg` file could fail
 #[derive(Debug)]
-pub(crate) enum PyvenvCfgParseErrorKind {
+pub enum PyvenvCfgParseErrorKind {
    TooManyEquals { line_number: NonZeroUsize },
    MalformedKeyValuePair { line_number: NonZeroUsize },
    NoHomeKey,
@@ -371,7 +370,7 @@ fn site_packages_directory_from_sys_prefix(
 ///
 /// [`sys.prefix`]: https://docs.python.org/3/library/sys.html#sys.prefix
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub(crate) struct SysPrefixPath(SystemPathBuf);
+pub struct SysPrefixPath(SystemPathBuf);

 impl SysPrefixPath {
    fn new(
@@ -426,7 +425,7 @@ impl Deref for SysPrefixPath {

 impl fmt::Display for SysPrefixPath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "`sys.prefix` path '{}'", self.0)
+        write!(f, "`sys.prefix` path {}", self.0)
    }
 }

@@ -483,7 +482,7 @@ impl Deref for PythonHomePath {

 impl fmt::Display for PythonHomePath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "`home` location '{}'", self.0)
+        write!(f, "`home` location {}", self.0)
    }
 }

--- a/crates/red_knot_workspace/src/watch/watcher.rs
+++ b/crates/red_knot_workspace/src/watch/watcher.rs
@@ -109,7 +109,7 @@ struct WatcherInner {
 impl Watcher {
    /// Sets up file watching for `path`.
    pub fn watch(&mut self, path: &SystemPath) -> notify::Result<()> {
-        tracing::debug!("Watching path: '{path}'.");
+        tracing::debug!("Watching path: {path}.");

        self.inner_mut()
            .watcher
@@ -118,7 +118,7 @@ impl Watcher {

    /// Stops file watching for `path`.
    pub fn unwatch(&mut self, path: &SystemPath) -> notify::Result<()> {
-        tracing::debug!("Unwatching path: '{path}'.");
+        tracing::debug!("Unwatching path: {path}.");

        self.inner_mut().watcher.unwatch(path.as_std_path())
    }
@@ -351,7 +351,7 @@ impl Debouncer {
            }

            EventKind::Any => {
-                tracing::debug!("Skipping any FS event for '{path}'.");
+                tracing::debug!("Skip any FS event for {path}.");
                return;
            }
        };
--- a/crates/red_knot_workspace/src/workspace.rs
+++ b/crates/red_knot_workspace/src/workspace.rs
@@ -4,25 +4,21 @@ use rustc_hash::{FxBuildHasher, FxHashSet};
 use salsa::{Durability, Setter as _};

 pub use metadata::{PackageMetadata, WorkspaceMetadata};
-use red_knot_python_semantic::types::check_types;
-use red_knot_python_semantic::SearchPathSettings;
-use ruff_db::source::{line_index, source_text, SourceDiagnostic};
+use ruff_db::source::{source_text, SourceDiagnostic};
 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::Ranged;

-use crate::workspace::files::{Index, Indexed, PackageFiles};
+use crate::workspace::files::{Index, IndexedFiles, PackageFiles};
 use crate::{
    db::Db,
-    lint::{lint_semantic, lint_syntax},
+    lint::{lint_semantic, lint_syntax, Diagnostics},
 };

 mod files;
 mod metadata;
-pub mod settings;

 /// The project workspace as a Salsa ingredient.
 ///
@@ -83,10 +79,6 @@ pub struct Workspace {
    /// The (first-party) packages in this workspace.
    #[return_ref]
    package_tree: BTreeMap<SystemPathBuf, Package>,
-
-    /// The unresolved search path configuration.
-    #[return_ref]
-    pub search_path_settings: SearchPathSettings,
 }

 /// A first-party package in a workspace.
@@ -100,8 +92,8 @@ pub struct Package {
    root_buf: SystemPathBuf,

    /// The files that are part of this package.
-    #[default]
    #[return_ref]
+    #[default]
    file_set: PackageFiles,
    // TODO: Add the loaded settings.
 }
@@ -115,14 +107,10 @@ impl Workspace {
            packages.insert(package.root.clone(), Package::from_metadata(db, package));
        }

-        Workspace::builder(
-            metadata.root,
-            packages,
-            metadata.settings.program.search_paths,
-        )
-        .durability(Durability::MEDIUM)
-        .open_fileset_durability(Durability::LOW)
-        .new(db)
+        Workspace::builder(metadata.root, packages)
+            .durability(Durability::MEDIUM)
+            .open_fileset_durability(Durability::LOW)
+            .new(db)
    }

    pub fn root(self, db: &dyn Db) -> &SystemPath {
@@ -153,12 +141,9 @@ impl Workspace {
            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(new_packages);
+        self.set_package_tree(db)
+            .with_durability(Durability::MEDIUM)
+            .to(new_packages);
    }

    pub fn update_package(self, db: &mut dyn Db, metadata: PackageMetadata) -> anyhow::Result<()> {
@@ -212,7 +197,7 @@ impl 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));
+        tracing::debug!("Opening file {}", file.path(db));

        let mut open_files = self.take_open_files(db);
        open_files.insert(file);
@@ -221,7 +206,7 @@ impl Workspace {

    /// 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));
+        tracing::debug!("Closing file {}", file.path(db));

        let mut open_files = self.take_open_files(db);
        let removed = open_files.remove(&file);
@@ -264,23 +249,6 @@ impl Workspace {
            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()
-        }
-    }
 }

 #[salsa::tracked]
@@ -291,13 +259,13 @@ impl Package {

    /// 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)
+        self.files(db).read().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 '{}'",
+            "Remove file {} from package {}",
            file.path(db),
            self.name(db)
        );
@@ -310,11 +278,7 @@ impl Package {
    }

    pub fn add_file(self, db: &mut dyn Db, file: File) {
-        tracing::debug!(
-            "Adding file '{}' to package '{}'",
-            file.path(db),
-            self.name(db)
-        );
+        tracing::debug!("Add file {} to package {}", file.path(db), self.name(db));

        let Some(mut index) = PackageFiles::indexed_mut(db, self) else {
            return;
@@ -325,10 +289,10 @@ impl Package {

    #[tracing::instrument(level = "debug", skip(db))]
    pub(crate) fn check(self, db: &dyn Db) -> Vec<String> {
-        tracing::debug!("Checking package '{}'", self.root(db));
+        tracing::debug!("Checking package {}", self.root(db));

        let mut result = Vec::new();
-        for file in &self.files(db) {
+        for file in &self.files(db).read() {
            let diagnostics = check_file(db, file);
            result.extend_from_slice(&diagnostics);
        }
@@ -337,16 +301,15 @@ impl Package {
    }

    /// Returns the files belonging to this package.
-    pub fn files(self, db: &dyn Db) -> Indexed<'_> {
+    #[salsa::tracked]
+    pub fn files(self, db: &dyn Db) -> IndexedFiles {
+        let _entered = tracing::debug_span!("files").entered();
        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();
-
+                tracing::debug!("Indexing files for package {}", self.name(db));
                let files = discover_package_files(db, self.root(db));
-                tracing::info!("Found {} files in package '{}'", files.len(), self.name(db));
                vacant.set(files)
            }
            Index::Indexed(indexed) => indexed,
@@ -367,12 +330,14 @@ impl Package {
        assert_eq!(root, metadata.root());

        if self.name(db) != metadata.name() {
-            self.set_name(db).to(metadata.name);
+            self.set_name(db)
+                .with_durability(Durability::MEDIUM)
+                .to(metadata.name);
        }
    }

    pub fn reload_files(self, db: &mut dyn Db) {
-        tracing::debug!("Reloading files for package '{}'", self.name(db));
+        tracing::debug!("Reload files for package {}", self.name(db));

        if !self.file_set(db).is_lazy() {
            // Force a re-index of the files in the next revision.
@@ -382,10 +347,10 @@ impl Package {
 }

 #[salsa::tracked]
-pub(super) fn check_file(db: &dyn Db, file: File) -> Vec<String> {
+pub(super) fn check_file(db: &dyn Db, file: File) -> Diagnostics {
    let path = file.path(db);
    let _span = tracing::debug_span!("check_file", file=%path).entered();
-    tracing::debug!("Checking file '{path}'");
+    tracing::debug!("Checking file {path}");

    let mut diagnostics = Vec::new();

@@ -398,25 +363,13 @@ pub(super) fn check_file(db: &dyn Db, file: File) -> Vec<String> {
    );

    // Abort checking if there are IO errors.
-    let source = source_text(db.upcast(), file);
-
-    if source.has_read_error() {
-        return diagnostics;
-    }
-
-    for diagnostic in check_types(db.upcast(), file) {
-        let index = line_index(db.upcast(), diagnostic.file());
-        let location = index.source_location(diagnostic.start(), source.as_str());
-        diagnostics.push(format!(
-            "{path}:{location}: {message}",
-            path = file.path(db),
-            message = diagnostic.message()
-        ));
+    if source_text(db.upcast(), file).has_read_error() {
+        return Diagnostics::from(diagnostics);
    }

    diagnostics.extend_from_slice(lint_syntax(db, file));
    diagnostics.extend_from_slice(lint_semantic(db, file));
-    diagnostics
+    Diagnostics::from(diagnostics)
 }

 fn discover_package_files(db: &dyn Db, path: &SystemPath) -> FxHashSet<File> {
@@ -470,7 +423,7 @@ mod tests {
    use ruff_db::testing::assert_function_query_was_not_run;

    use crate::db::tests::TestDb;
-    use crate::lint::lint_syntax;
+    use crate::lint::{lint_syntax, Diagnostics};
    use crate::workspace::check_file;

    #[test]
@@ -488,7 +441,9 @@ mod tests {
        assert_eq!(source_text(&db, file).as_str(), "");
        assert_eq!(
            check_file(&db, file),
-            vec!["Failed to read file: No such file or directory".to_string()]
+            Diagnostics::List(vec![
+                "Failed to read file: No such file or directory".to_string()
+            ])
        );

        let events = db.take_salsa_events();
@@ -499,7 +454,7 @@ mod tests {
        db.write_file(path, "").unwrap();

        assert_eq!(source_text(&db, file).as_str(), "");
-        assert_eq!(check_file(&db, file), vec![] as Vec<String>);
+        assert_eq!(check_file(&db, file), Diagnostics::Empty);

        Ok(())
    }
--- a/crates/red_knot_workspace/src/workspace/files.rs
+++ b/crates/red_knot_workspace/src/workspace/files.rs
@@ -1,4 +1,4 @@
-use std::marker::PhantomData;
+use std::iter::FusedIterator;
 use std::ops::Deref;
 use std::sync::Arc;

@@ -10,9 +10,6 @@ use ruff_db::files::File;
 use crate::db::Db;
 use crate::workspace::Package;

-/// Cheap cloneable hash set of files.
-type FileSet = Arc<FxHashSet<File>>;
-
 /// The indexed files of a package.
 ///
 /// The indexing happens lazily, but the files are then cached for subsequent reads.
@@ -21,7 +18,7 @@ type FileSet = Arc<FxHashSet<File>>;
 /// The implementation uses internal mutability to transition between the lazy and indexed state
 /// without triggering a new salsa revision. This is safe because the initial indexing happens on first access,
 /// so no query can be depending on the contents of the indexed files before that. All subsequent mutations to
-/// the indexed files must go through `IndexedMut`, which uses the Salsa setter `package.set_file_set` to
+/// the indexed files must go through `IndexedFilesMut`, 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 {
@@ -35,67 +32,46 @@ impl PackageFiles {
        }
    }

-    fn indexed(files: FileSet) -> Self {
+    fn indexed(indexed_files: IndexedFiles) -> Self {
        Self {
-            state: std::sync::Mutex::new(State::Indexed(files)),
+            state: std::sync::Mutex::new(State::Indexed(indexed_files)),
        }
    }

-    pub(super) fn get(&self) -> Index {
+    pub fn get(&self) -> Index {
        let state = self.state.lock().unwrap();

        match &*state {
            State::Lazy => Index::Lazy(LazyFiles { files: state }),
-            State::Indexed(files) => Index::Indexed(Indexed {
-                files: Arc::clone(files),
-                _lifetime: PhantomData,
-            }),
+            State::Indexed(files) => Index::Indexed(files.clone()),
        }
    }

-    pub(super) fn is_lazy(&self) -> bool {
+    pub fn is_lazy(&self) -> bool {
        matches!(*self.state.lock().unwrap(), State::Lazy)
    }

    /// 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 fn indexed_mut(db: &mut dyn Db, package: Package) -> Option<IndexedFilesMut> {
        // 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
        let _ = db.as_dyn_database_mut().zalsa_mut();

-        // Replace the state with lazy. The `IndexedMut` guard restores the state
-        // to `State::Indexed`  or sets a new `PackageFiles` when it gets dropped to ensure the state
-        // is restored to how it has been before replacing the value.
-        //
-        // It isn't necessary to hold on to the lock after this point:
-        // * The above call to `zalsa_mut` guarantees that there's exactly **one** DB reference.
-        // * `Indexed` has a `'db` lifetime, and this method requires a `&mut db`.
-        //   This means that there can't be any pending reference to `Indexed` because Rust
-        //   doesn't allow borrowing `db` as mutable (to call this method) and immutable (`Indexed<'db>`) at the same time.
-        //   There can't be any other `Indexed<'db>` references created by clones of this DB because
-        //   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 mut locked = files.state.lock().unwrap();
-            std::mem::replace(&mut *locked, State::Lazy)
-        };
+        let files = package.file_set(db);

-        let indexed = match state {
-            // If it's already lazy, just return. We also don't need to restore anything because the
-            // replace above was a no-op.
+        let indexed = match &*files.state.lock().unwrap() {
            State::Lazy => return None,
-            State::Indexed(indexed) => indexed,
+            State::Indexed(indexed) => indexed.clone(),
        };

-        Some(IndexedMut {
+        Some(IndexedFilesMut {
            db: Some(db),
            package,
-            files: indexed,
-            did_change: false,
+            new_revision: indexed.revision,
+            indexed,
        })
    }
 }
@@ -112,93 +88,152 @@ enum State {
    Lazy,

    /// The files are indexed. Stores the known files of a package.
-    Indexed(FileSet),
+    Indexed(IndexedFiles),
 }

-pub(super) enum Index<'db> {
+pub enum Index<'a> {
    /// The index has not yet been computed. Allows inserting the files.
-    Lazy(LazyFiles<'db>),
+    Lazy(LazyFiles<'a>),

-    Indexed(Indexed<'db>),
+    Indexed(IndexedFiles),
 }

 /// Package files that have not been indexed yet.
-pub(super) struct LazyFiles<'db> {
-    files: std::sync::MutexGuard<'db, State>,
+pub struct LazyFiles<'a> {
+    files: std::sync::MutexGuard<'a, State>,
 }

-impl<'db> LazyFiles<'db> {
+impl<'a> LazyFiles<'a> {
    /// Sets the indexed files of a package to `files`.
-    pub(super) fn set(mut self, files: FxHashSet<File>) -> Indexed<'db> {
-        let files = Indexed {
-            files: Arc::new(files),
-            _lifetime: PhantomData,
-        };
-        *self.files = State::Indexed(Arc::clone(&files.files));
+    pub fn set(mut self, files: FxHashSet<File>) -> IndexedFiles {
+        let files = IndexedFiles::new(files);
+        *self.files = State::Indexed(files.clone());
        files
    }
 }

 /// 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`].
-#[derive(Debug, PartialEq, Eq)]
-pub struct Indexed<'db> {
-    files: FileSet,
-    // Preserve the lifetime of `PackageFiles`.
-    _lifetime: PhantomData<&'db ()>,
+/// # Salsa integration
+/// The type is cheap clonable and allows for in-place mutation of the files. The in-place mutation requires
+/// extra care because the type is used as the result of Salsa queries and Salsa relies on a type's equality
+/// to determine if the output has changed. This is accomplished by using a `revision` that gets incremented
+/// whenever the files are changed. The revision ensures that salsa's comparison of the
+/// previous [`IndexedFiles`] with the next [`IndexedFiles`] returns false even though they both
+/// point to the same underlying hash set.
+///
+/// # Equality
+/// Two [`IndexedFiles`] are only equal if they have the same revision and point to the **same** (identity) hash set.
+#[derive(Debug, Clone)]
+pub struct IndexedFiles {
+    revision: u64,
+    files: Arc<std::sync::Mutex<FxHashSet<File>>>,
 }

-impl Deref for Indexed<'_> {
+impl IndexedFiles {
+    fn new(files: FxHashSet<File>) -> Self {
+        Self {
+            files: Arc::new(std::sync::Mutex::new(files)),
+            revision: 0,
+        }
+    }
+
+    /// Locks the file index for reading.
+    pub fn read(&self) -> IndexedFilesGuard {
+        IndexedFilesGuard {
+            guard: self.files.lock().unwrap(),
+        }
+    }
+}
+
+impl PartialEq for IndexedFiles {
+    fn eq(&self, other: &Self) -> bool {
+        self.revision == other.revision && Arc::ptr_eq(&self.files, &other.files)
+    }
+}
+
+impl Eq for IndexedFiles {}
+
+pub struct IndexedFilesGuard<'a> {
+    guard: std::sync::MutexGuard<'a, FxHashSet<File>>,
+}
+
+impl Deref for IndexedFilesGuard<'_> {
    type Target = FxHashSet<File>;

    fn deref(&self) -> &Self::Target {
-        &self.files
+        &self.guard
    }
 }

-impl<'a> IntoIterator for &'a Indexed<'_> {
+impl<'a> IntoIterator for &'a IndexedFilesGuard<'a> {
    type Item = File;
-    type IntoIter = std::iter::Copied<std::collections::hash_set::Iter<'a, File>>;
+    type IntoIter = IndexedFilesIter<'a>;

    fn into_iter(self) -> Self::IntoIter {
-        self.files.iter().copied()
+        IndexedFilesIter {
+            inner: self.guard.iter(),
+        }
    }
 }

+/// Iterator over the indexed files.
+///
+/// # Locks
+/// Holding on to the iterator locks the file index for reading.
+pub struct IndexedFilesIter<'a> {
+    inner: std::collections::hash_set::Iter<'a, File>,
+}
+
+impl<'a> Iterator for IndexedFilesIter<'a> {
+    type Item = File;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next().copied()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+impl FusedIterator for IndexedFilesIter<'_> {}
+
+impl ExactSizeIterator for IndexedFilesIter<'_> {}
+
 /// A Mutable view of a package'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> {
+pub struct IndexedFilesMut<'db> {
    db: Option<&'db mut dyn Db>,
    package: Package,
-    files: FileSet,
-    did_change: bool,
+    indexed: IndexedFiles,
+    new_revision: u64,
 }

-impl IndexedMut<'_> {
-    pub(super) fn insert(&mut self, file: File) -> bool {
-        if self.files_mut().insert(file) {
-            self.did_change = true;
+impl IndexedFilesMut<'_> {
+    pub fn insert(&mut self, file: File) -> bool {
+        if self.indexed.files.lock().unwrap().insert(file) {
+            self.new_revision += 1;
            true
        } else {
            false
        }
    }

-    pub(super) fn remove(&mut self, file: File) -> bool {
-        if self.files_mut().remove(&file) {
-            self.did_change = true;
+    pub fn remove(&mut self, file: File) -> bool {
+        if self.indexed.files.lock().unwrap().remove(&file) {
+            self.new_revision += 1;
            true
        } else {
            false
        }
    }

-    fn files_mut(&mut self) -> &mut FxHashSet<File> {
-        Arc::get_mut(&mut self.files).expect("All references to `FilesSet` to have been dropped")
+    /// Writes the changes back to the database.
+    pub fn set(mut self) {
+        self.set_impl();
    }

    fn set_impl(&mut self) {
@@ -206,70 +241,19 @@ impl IndexedMut<'_> {
            return;
        };

-        let files = Arc::clone(&self.files);
-
-        if self.did_change {
-            // If there are changes, set the new file_set to trigger a salsa revision change.
+        if self.indexed.revision != self.new_revision {
            self.package
                .set_file_set(db)
-                .to(PackageFiles::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);
+                .to(PackageFiles::indexed(IndexedFiles {
+                    revision: self.new_revision,
+                    files: self.indexed.files.clone(),
+                }));
        }
    }
 }

-impl Drop for IndexedMut<'_> {
+impl Drop for IndexedFilesMut<'_> {
    fn drop(&mut self) {
        self.set_impl();
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use rustc_hash::FxHashSet;
-
-    use ruff_db::files::system_path_to_file;
-    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
-    use ruff_python_ast::name::Name;
-
-    use crate::db::tests::TestDb;
-    use crate::workspace::files::Index;
-    use crate::workspace::Package;
-
-    #[test]
-    fn re_entrance() -> anyhow::Result<()> {
-        let mut db = TestDb::new();
-
-        db.write_file("test.py", "")?;
-
-        let package = Package::new(&db, Name::new("test"), SystemPathBuf::from("/test"));
-
-        let file = system_path_to_file(&db, "test.py").unwrap();
-
-        let files = match package.file_set(&db).get() {
-            Index::Lazy(lazy) => lazy.set(FxHashSet::from_iter([file])),
-            Index::Indexed(files) => files,
-        };
-
-        // 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();
-
-        match files_2 {
-            Index::Lazy(_) => {
-                panic!("Expected indexed files, got lazy files");
-            }
-            Index::Indexed(files_2) => {
-                assert_eq!(
-                    files_2.iter().collect::<Vec<_>>(),
-                    files.iter().collect::<Vec<_>>()
-                );
-            }
-        }
-
-        Ok(())
-    }
-}
--- a/crates/red_knot_workspace/src/workspace/metadata.rs
+++ b/crates/red_knot_workspace/src/workspace/metadata.rs
@@ -1,4 +1,3 @@
-use crate::workspace::settings::{Configuration, WorkspaceSettings};
 use ruff_db::system::{System, SystemPath, SystemPathBuf};
 use ruff_python_ast::name::Name;

@@ -8,8 +7,6 @@ pub struct WorkspaceMetadata {

    /// The (first-party) packages in this workspace.
    pub(super) packages: Vec<PackageMetadata>,
-
-    pub(super) settings: WorkspaceSettings,
 }

 /// A first-party package in a workspace.
@@ -24,11 +21,7 @@ pub struct PackageMetadata {

 impl WorkspaceMetadata {
    /// Discovers the closest workspace at `path` and returns its metadata.
-    pub fn from_path(
-        path: &SystemPath,
-        system: &dyn System,
-        base_configuration: Option<Configuration>,
-    ) -> anyhow::Result<WorkspaceMetadata> {
+    pub fn from_path(path: &SystemPath, system: &dyn System) -> anyhow::Result<WorkspaceMetadata> {
        assert!(
            system.is_directory(path),
            "Workspace root path must be a directory"
@@ -45,20 +38,9 @@ impl WorkspaceMetadata {
            root: root.clone(),
        };

-        // TODO: Load the configuration from disk.
-        let mut configuration = Configuration::default();
-
-        if let Some(base_configuration) = base_configuration {
-            configuration.extend(base_configuration);
-        }
-
-        // TODO: Respect the package configurations when resolving settings (e.g. for the target version).
-        let settings = configuration.into_workspace_settings(&root);
-
        let workspace = WorkspaceMetadata {
            root,
            packages: vec![package],
-            settings,
        };

        Ok(workspace)
@@ -71,10 +53,6 @@ impl WorkspaceMetadata {
    pub fn packages(&self) -> &[PackageMetadata] {
        &self.packages
    }
-
-    pub fn settings(&self) -> &WorkspaceSettings {
-        &self.settings
-    }
 }

 impl PackageMetadata {
--- a/crates/red_knot_workspace/src/workspace/settings.rs
+++ b/crates/red_knot_workspace/src/workspace/settings.rs
@@ -1,89 +0,0 @@
-use red_knot_python_semantic::{ProgramSettings, PythonVersion, SearchPathSettings, SitePackages};
-use ruff_db::system::{SystemPath, SystemPathBuf};
-
-/// The resolved configurations.
-///
-/// The main difference to [`Configuration`] is that default values are filled in.
-#[derive(Debug, Clone)]
-pub struct WorkspaceSettings {
-    pub(super) program: ProgramSettings,
-}
-
-impl WorkspaceSettings {
-    pub fn program(&self) -> &ProgramSettings {
-        &self.program
-    }
-}
-
-/// The configuration for the workspace or a package.
-#[derive(Debug, Default, Clone)]
-pub struct Configuration {
-    pub target_version: Option<PythonVersion>,
-    pub search_paths: SearchPathConfiguration,
-}
-
-impl Configuration {
-    /// Extends this configuration by using the values from `with` for all values that are absent in `self`.
-    pub fn extend(&mut self, with: Configuration) {
-        self.target_version = self.target_version.or(with.target_version);
-        self.search_paths.extend(with.search_paths);
-    }
-
-    pub fn into_workspace_settings(self, workspace_root: &SystemPath) -> WorkspaceSettings {
-        WorkspaceSettings {
-            program: ProgramSettings {
-                target_version: self.target_version.unwrap_or_default(),
-                search_paths: self.search_paths.into_settings(workspace_root),
-            },
-        }
-    }
-}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq)]
-pub struct SearchPathConfiguration {
-    /// List of user-provided paths that should take first priority in the module resolution.
-    /// Examples in other type checkers are mypy's MYPYPATH environment variable,
-    /// or pyright's stubPath configuration setting.
-    pub extra_paths: Option<Vec<SystemPathBuf>>,
-
-    /// The root of the workspace, used for finding first-party modules.
-    pub src_root: Option<SystemPathBuf>,
-
-    /// Optional path to a "custom typeshed" directory on disk for us to use for standard-library types.
-    /// If this is not provided, we will fallback to our vendored typeshed stubs for the stdlib,
-    /// bundled as a zip file in the binary
-    pub custom_typeshed: Option<SystemPathBuf>,
-
-    /// The path to the user's `site-packages` directory, where third-party packages from ``PyPI`` are installed.
-    pub site_packages: Option<SitePackages>,
-}
-
-impl SearchPathConfiguration {
-    pub fn into_settings(self, workspace_root: &SystemPath) -> SearchPathSettings {
-        let site_packages = self.site_packages.unwrap_or(SitePackages::Known(vec![]));
-
-        SearchPathSettings {
-            extra_paths: self.extra_paths.unwrap_or_default(),
-            src_root: self
-                .src_root
-                .unwrap_or_else(|| workspace_root.to_path_buf()),
-            custom_typeshed: self.custom_typeshed,
-            site_packages,
-        }
-    }
-
-    pub fn extend(&mut self, with: SearchPathConfiguration) {
-        if let Some(extra_paths) = with.extra_paths {
-            self.extra_paths.get_or_insert(extra_paths);
-        }
-        if let Some(src_root) = with.src_root {
-            self.src_root.get_or_insert(src_root);
-        }
-        if let Some(custom_typeshed) = with.custom_typeshed {
-            self.custom_typeshed.get_or_insert(custom_typeshed);
-        }
-        if let Some(site_packages) = with.site_packages {
-            self.site_packages.get_or_insert(site_packages);
-        }
-    }
-}
--- a/crates/red_knot_workspace/tests/check.rs
+++ b/crates/red_knot_workspace/tests/check.rs
@@ -1,20 +1,26 @@
+use red_knot_python_semantic::{ProgramSettings, PythonVersion, SearchPathSettings};
+use red_knot_workspace::db::RootDatabase;
+use red_knot_workspace::lint::lint_semantic;
+use red_knot_workspace::workspace::WorkspaceMetadata;
+use ruff_db::files::system_path_to_file;
+use ruff_db::system::{OsSystem, SystemPathBuf};
 use std::fs;
 use std::path::PathBuf;

-use red_knot_python_semantic::{HasTy, SemanticModel};
-use red_knot_workspace::db::RootDatabase;
-use red_knot_workspace::workspace::WorkspaceMetadata;
-use ruff_db::files::{system_path_to_file, File};
-use ruff_db::parsed::parsed_module;
-use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
-use ruff_python_ast::visitor::source_order;
-use ruff_python_ast::visitor::source_order::SourceOrderVisitor;
-use ruff_python_ast::{Alias, Expr, Parameter, ParameterWithDefault, Stmt};
-
-fn setup_db(workspace_root: &SystemPath) -> anyhow::Result<RootDatabase> {
-    let system = OsSystem::new(workspace_root);
-    let workspace = WorkspaceMetadata::from_path(workspace_root, &system, None)?;
-    RootDatabase::new(workspace, system)
+fn setup_db(workspace_root: SystemPathBuf) -> anyhow::Result<RootDatabase> {
+    let system = OsSystem::new(&workspace_root);
+    let workspace = WorkspaceMetadata::from_path(&workspace_root, &system)?;
+    let search_paths = SearchPathSettings {
+        extra_paths: vec![],
+        src_root: workspace_root,
+        custom_typeshed: None,
+        site_packages: vec![],
+    };
+    let settings = ProgramSettings {
+        target_version: PythonVersion::default(),
+        search_paths,
+    };
+    RootDatabase::new(workspace, settings, system)
 }

 /// Test that all snippets in testcorpus can be checked without panic
@@ -24,99 +30,15 @@ fn corpus_no_panic() -> anyhow::Result<()> {
    let corpus = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("resources/test/corpus");
    let system_corpus =
        SystemPathBuf::from_path_buf(corpus.clone()).expect("corpus path to be UTF8");
-    let db = setup_db(&system_corpus)?;
+    let db = setup_db(system_corpus.clone())?;

    for path in fs::read_dir(&corpus).expect("corpus to be a directory") {
        let path = path.expect("path to not be an error").path();
        println!("checking {path:?}");
        let path = SystemPathBuf::from_path_buf(path.clone()).expect("path to be UTF-8");
-        // this test is only asserting that we can pull every expression type without a panic
-        // (and some non-expressions that clearly define a single type)
+        // this test is only asserting that we can run the lint without a panic
        let file = system_path_to_file(&db, path).expect("file to exist");
-
-        pull_types(&db, file);
+        lint_semantic(&db, file);
    }
    Ok(())
 }
-
-fn pull_types(db: &RootDatabase, file: File) {
-    let mut visitor = PullTypesVisitor::new(db, file);
-
-    let ast = parsed_module(db, file);
-
-    visitor.visit_body(ast.suite());
-}
-
-struct PullTypesVisitor<'db> {
-    model: SemanticModel<'db>,
-}
-
-impl<'db> PullTypesVisitor<'db> {
-    fn new(db: &'db RootDatabase, file: File) -> Self {
-        Self {
-            model: SemanticModel::new(db, file),
-        }
-    }
-}
-
-impl SourceOrderVisitor<'_> for PullTypesVisitor<'_> {
-    fn visit_stmt(&mut self, stmt: &Stmt) {
-        match stmt {
-            Stmt::FunctionDef(function) => {
-                let _ty = function.ty(&self.model);
-            }
-            Stmt::ClassDef(class) => {
-                let _ty = class.ty(&self.model);
-            }
-            Stmt::AnnAssign(_)
-            | Stmt::Return(_)
-            | Stmt::Delete(_)
-            | Stmt::Assign(_)
-            | Stmt::AugAssign(_)
-            | Stmt::TypeAlias(_)
-            | Stmt::For(_)
-            | Stmt::While(_)
-            | Stmt::If(_)
-            | Stmt::With(_)
-            | Stmt::Match(_)
-            | Stmt::Raise(_)
-            | Stmt::Try(_)
-            | Stmt::Assert(_)
-            | Stmt::Import(_)
-            | Stmt::ImportFrom(_)
-            | Stmt::Global(_)
-            | Stmt::Nonlocal(_)
-            | Stmt::Expr(_)
-            | Stmt::Pass(_)
-            | Stmt::Break(_)
-            | Stmt::Continue(_)
-            | Stmt::IpyEscapeCommand(_) => {}
-        }
-
-        source_order::walk_stmt(self, stmt);
-    }
-
-    fn visit_expr(&mut self, expr: &Expr) {
-        let _ty = expr.ty(&self.model);
-
-        source_order::walk_expr(self, expr);
-    }
-
-    fn visit_parameter(&mut self, parameter: &Parameter) {
-        let _ty = parameter.ty(&self.model);
-
-        source_order::walk_parameter(self, parameter);
-    }
-
-    fn visit_parameter_with_default(&mut self, parameter_with_default: &ParameterWithDefault) {
-        let _ty = parameter_with_default.ty(&self.model);
-
-        source_order::walk_parameter_with_default(self, parameter_with_default);
-    }
-
-    fn visit_alias(&mut self, alias: &Alias) {
-        let _ty = alias.ty(&self.model);
-
-        source_order::walk_alias(self, alias);
-    }
-}
--- a/crates/ruff/Cargo.toml
+++ b/crates/ruff/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.6.2"
+version = "0.5.7"
 publish = true
 authors = { workspace = true }
 edition = { workspace = true }
--- a/crates/ruff/tests/lint.rs
+++ b/crates/ruff/tests/lint.rs
@@ -1434,7 +1434,7 @@ def unused(x):

    insta::assert_snapshot!(test_code, @r###"

-    def unused(x):  # noqa: ANN001, ANN201, D103
+    def unused(x):  # noqa: ANN001, ANN201, ARG001, D103
        pass
    "###);

--- a/crates/ruff_benchmark/benches/red_knot.rs
+++ b/crates/ruff_benchmark/benches/red_knot.rs
@@ -1,9 +1,7 @@
 #![allow(clippy::disallowed_names)]

-use red_knot_python_semantic::PythonVersion;
+use red_knot_python_semantic::{ProgramSettings, PythonVersion, SearchPathSettings};
 use red_knot_workspace::db::RootDatabase;
-use red_knot_workspace::watch::{ChangeEvent, ChangedKind};
-use red_knot_workspace::workspace::settings::Configuration;
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_benchmark::criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use ruff_benchmark::TestFile;
@@ -14,53 +12,13 @@ use ruff_db::system::{MemoryFileSystem, SystemPath, TestSystem};
 struct Case {
    db: RootDatabase,
    fs: MemoryFileSystem,
+    parser: File,
    re: File,
    re_path: &'static SystemPath,
 }

 const TOMLLIB_312_URL: &str = "https://raw.githubusercontent.com/python/cpython/8e8a4baf652f6e1cee7acde9d78c4b6154539748/Lib/tomllib";

-// This first "unresolved import" is because we don't understand `*` imports yet.
-// The following "unresolved import" violations are because we can't distinguish currently from
-// "Symbol exists in the module but its type is unknown" and
-// "Symbol does not exist in the module"
-static EXPECTED_DIAGNOSTICS: &[&str] = &[
-    "/src/tomllib/_parser.py:7:29: Could not resolve import of 'Iterable' from 'collections.abc'",
-    "/src/tomllib/_parser.py:10:20: Could not resolve import of 'Any' from 'typing'",
-    "/src/tomllib/_parser.py:13:5: Could not resolve import of 'RE_DATETIME' from '._re'",
-    "/src/tomllib/_parser.py:14:5: Could not resolve import of 'RE_LOCALTIME' from '._re'",
-    "/src/tomllib/_parser.py:15:5: Could not resolve import of 'RE_NUMBER' from '._re'",
-    "/src/tomllib/_parser.py:20:21: Could not resolve import of 'Key' from '._types'",
-    "/src/tomllib/_parser.py:20:26: Could not resolve import of 'ParseFloat' from '._types'",
-    "Line 69 is too long (89 characters)",
-    "Use double quotes for strings",
-    "Use double quotes for strings",
-    "Use double quotes for strings",
-    "Use double quotes for strings",
-    "Use double quotes for strings",
-    "Use double quotes for strings",
-    "Use double quotes for strings",
-    "/src/tomllib/_parser.py:153:22: Name 'key' used when not defined.",
-    "/src/tomllib/_parser.py:153:27: Name 'flag' used when not defined.",
-    "/src/tomllib/_parser.py:159:16: Name 'k' used when not defined.",
-    "/src/tomllib/_parser.py:161:25: Name 'k' used when not defined.",
-    "/src/tomllib/_parser.py:168:16: Name 'k' used when not defined.",
-    "/src/tomllib/_parser.py:169:22: Name 'k' used when not defined.",
-    "/src/tomllib/_parser.py:170:25: Name 'k' used when not defined.",
-    "/src/tomllib/_parser.py:180:16: Name 'k' used when not defined.",
-    "/src/tomllib/_parser.py:182:31: Name 'k' used when not defined.",
-    "/src/tomllib/_parser.py:206:16: Name 'k' used when not defined.",
-    "/src/tomllib/_parser.py:207:22: Name 'k' used when not defined.",
-    "/src/tomllib/_parser.py:208:25: Name 'k' used when not defined.",
-    "/src/tomllib/_parser.py:330:32: Name 'header' used when not defined.",
-    "/src/tomllib/_parser.py:330:41: Name 'key' used when not defined.",
-    "/src/tomllib/_parser.py:333:26: Name 'cont_key' used when not defined.",
-    "/src/tomllib/_parser.py:334:71: Name 'cont_key' used when not defined.",
-    "/src/tomllib/_parser.py:337:31: Name 'cont_key' used when not defined.",
-    "/src/tomllib/_parser.py:628:75: Name 'e' used when not defined.",
-    "/src/tomllib/_parser.py:686:23: Name 'parse_float' used when not defined.",
-];
-
 fn get_test_file(name: &str) -> TestFile {
    let path = format!("tomllib/{name}");
    let url = format!("{TOMLLIB_312_URL}/{name}");
@@ -70,34 +28,31 @@ fn get_test_file(name: &str) -> TestFile {
 fn setup_case() -> Case {
    let system = TestSystem::default();
    let fs = system.memory_file_system().clone();
+    let init_path = SystemPath::new("/src/tomllib/__init__.py");
    let parser_path = SystemPath::new("/src/tomllib/_parser.py");
    let re_path = SystemPath::new("/src/tomllib/_re.py");
+    let types_path = SystemPath::new("/src/tomllib/_types.py");
    fs.write_files([
-        (
-            SystemPath::new("/src/tomllib/__init__.py"),
-            get_test_file("__init__.py").code(),
-        ),
+        (init_path, get_test_file("__init__.py").code()),
        (parser_path, get_test_file("_parser.py").code()),
        (re_path, get_test_file("_re.py").code()),
-        (
-            SystemPath::new("/src/tomllib/_types.py"),
-            get_test_file("_types.py").code(),
-        ),
+        (types_path, get_test_file("_types.py").code()),
    ])
    .unwrap();

    let src_root = SystemPath::new("/src");
-    let metadata = WorkspaceMetadata::from_path(
-        src_root,
-        &system,
-        Some(Configuration {
-            target_version: Some(PythonVersion::PY312),
-            ..Configuration::default()
-        }),
-    )
-    .unwrap();
+    let metadata = WorkspaceMetadata::from_path(src_root, &system).unwrap();
+    let settings = ProgramSettings {
+        target_version: PythonVersion::PY312,
+        search_paths: SearchPathSettings {
+            extra_paths: vec![],
+            src_root: src_root.to_path_buf(),
+            site_packages: vec![],
+            custom_typeshed: None,
+        },
+    };

-    let mut db = RootDatabase::new(metadata, system).unwrap();
+    let mut db = RootDatabase::new(metadata, settings, system).unwrap();
    let parser = system_path_to_file(&db, parser_path).unwrap();

    db.workspace().open_file(&mut db, parser);
@@ -107,6 +62,7 @@ fn setup_case() -> Case {
    Case {
        db,
        fs,
+        parser,
        re,
        re_path,
    }
@@ -116,8 +72,8 @@ fn benchmark_incremental(criterion: &mut Criterion) {
    criterion.bench_function("red_knot_check_file[incremental]", |b| {
        b.iter_batched_ref(
            || {
-                let case = setup_case();
-                case.db.check().unwrap();
+                let mut case = setup_case();
+                case.db.check_file(case.parser).unwrap();

                case.fs
                    .write_file(
@@ -126,22 +82,14 @@ fn benchmark_incremental(criterion: &mut Criterion) {
                    )
                    .unwrap();

+                case.re.sync(&mut case.db);
                case
            },
            |case| {
-                let Case { db, .. } = case;
+                let Case { db, parser, .. } = case;
+                let result = db.check_file(*parser).unwrap();

-                db.apply_changes(
-                    vec![ChangeEvent::Changed {
-                        path: case.re_path.to_path_buf(),
-                        kind: ChangedKind::FileContent,
-                    }],
-                    None,
-                );
-
-                let result = db.check().unwrap();
-
-                assert_eq!(result, EXPECTED_DIAGNOSTICS);
+                assert_eq!(result.len(), 402);
            },
            BatchSize::SmallInput,
        );
@@ -153,10 +101,10 @@ fn benchmark_cold(criterion: &mut Criterion) {
        b.iter_batched_ref(
            setup_case,
            |case| {
-                let Case { db, .. } = case;
-                let result = db.check().unwrap();
+                let Case { db, parser, .. } = case;
+                let result = db.check_file(*parser).unwrap();

-                assert_eq!(result, EXPECTED_DIAGNOSTICS);
+                assert_eq!(result.len(), 402);
            },
            BatchSize::SmallInput,
        );
--- a/Show More
+++ b/Show More