Bump version to 0.6.5 (#13346 )

Create insta snapshot for SARIF output (#13345 )
## Summary Follow-up from #13268, this PR updates the test case to use `assert_snapshot` now that the output is limited to only include the rules with diagnostics. ## Test Plan `cargo insta test`
2024-09-13 20:12:26 +05:30 · 2024-09-13 14:35:45 +00:00 · 2024-09-13 13:44:24 +01:00 · 2024-09-12 14:25:45 -04:00 · 2024-09-12 14:15:25 -04:00 · 2024-09-11 15:05:40 -04:00
391 changed files with 16041 additions and 4066 deletions
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -20,7 +20,7 @@
 			"extensions": [
 				"ms-python.python",
 				"rust-lang.rust-analyzer",
-				"serayuzgur.crates",
+				"fill-labs.dependi",
 				"tamasfe.even-better-toml",
 				"Swellaby.vscode-rust-test-adapter",
 				"charliermarsh.ruff"
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -37,7 +37,7 @@ jobs:
        with:
          fetch-depth: 0

-      - uses: tj-actions/changed-files@v44
+      - uses: tj-actions/changed-files@v45
        id: changed
        with:
          files_yaml: |
--- a/.github/workflows/publish-docs.yml
+++ b/.github/workflows/publish-docs.yml
@@ -34,10 +34,10 @@ jobs:
      - name: "Set docs version"
        run: |
          version="${{ (inputs.plan != '' && fromJson(inputs.plan).announcement_tag) || inputs.ref }}"
-          # if version is missing, exit with error
-          if [[ -z "$version" ]]; then
-          echo "Can't build docs without a version."
-          exit 1
+          # if version is missing, use 'latest'
+          if [ -z "$version" ]; then
+            echo "Using 'latest' as version"
+            version="latest"
          fi

          # Use version as display name for now
@@ -145,6 +145,7 @@ jobs:
          GITHUB_TOKEN: ${{ secrets.ASTRAL_DOCS_PAT }}
        run: |
          branch_name="${{ env.branch_name }}"
+
          # auto-merge the PR if the build was triggered by a release. Manual builds should be reviewed by a human.
          # give the PR a few seconds to be created before trying to auto-merge it
          sleep 10
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -6,6 +6,8 @@ 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/.*|
@@ -15,7 +17,7 @@ exclude: |

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

@@ -43,7 +45,7 @@ repos:
          )$

  - repo: https://github.com/crate-ci/typos
-    rev: v1.23.6
+    rev: v1.24.5
    hooks:
      - id: typos

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

  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.5.7
+    rev: v0.6.4
    hooks:
      - id: ruff-format
      - id: ruff
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,120 @@
 # Changelog

+## 0.6.5
+
+### Preview features
+
+- \[`pydoclint`\] Ignore `DOC201` when function name is "**new**" ([#13300](https://github.com/astral-sh/ruff/pull/13300))
+- \[`refurb`\] Implement `slice-to-remove-prefix-or-suffix` (`FURB188`) ([#13256](https://github.com/astral-sh/ruff/pull/13256))
+
+### Rule changes
+
+- \[`eradicate`\] Ignore script-comments with multiple end-tags (`ERA001`) ([#13283](https://github.com/astral-sh/ruff/pull/13283))
+- \[`pyflakes`\] Improve error message for `UndefinedName` when a builtin was added in a newer version than specified in Ruff config (`F821`) ([#13293](https://github.com/astral-sh/ruff/pull/13293))
+
+### Server
+
+- Add support for extensionless Python files for server ([#13326](https://github.com/astral-sh/ruff/pull/13326))
+- Fix configuration inheritance for configurations specified in the LSP settings ([#13285](https://github.com/astral-sh/ruff/pull/13285))
+
+### Bug fixes
+
+- \[`ruff`\] Handle unary operators in `decimal-from-float-literal` (`RUF032`) ([#13275](https://github.com/astral-sh/ruff/pull/13275))
+
+### CLI
+
+- Only include rules with diagnostics in SARIF metadata ([#13268](https://github.com/astral-sh/ruff/pull/13268))
+
+### Playground
+
+- Add "Copy as pyproject.toml/ruff.toml" and "Paste from TOML" ([#13328](https://github.com/astral-sh/ruff/pull/13328))
+- Fix errors not shown for restored snippet on page load ([#13262](https://github.com/astral-sh/ruff/pull/13262))
+
+## 0.6.4
+
+### Preview features
+
+- \[`flake8-builtins`\] Use dynamic builtins list based on Python version ([#13172](https://github.com/astral-sh/ruff/pull/13172))
+- \[`pydoclint`\] Permit yielding `None` in `DOC402` and `DOC403` ([#13148](https://github.com/astral-sh/ruff/pull/13148))
+- \[`pylint`\] Update diagnostic message for `PLW3201` ([#13194](https://github.com/astral-sh/ruff/pull/13194))
+- \[`ruff`\] Implement `post-init-default` (`RUF033`) ([#13192](https://github.com/astral-sh/ruff/pull/13192))
+- \[`ruff`\] Implement useless if-else (`RUF034`) ([#13218](https://github.com/astral-sh/ruff/pull/13218))
+
+### Rule changes
+
+- \[`flake8-pyi`\] Respect `pep8_naming.classmethod-decorators` settings when determining if a method is a classmethod in `custom-type-var-return-type` (`PYI019`) ([#13162](https://github.com/astral-sh/ruff/pull/13162))
+- \[`flake8-pyi`\] Teach various rules that annotations might be stringized ([#12951](https://github.com/astral-sh/ruff/pull/12951))
+- \[`pylint`\] Avoid `no-self-use` for `attrs`-style validators ([#13166](https://github.com/astral-sh/ruff/pull/13166))
+- \[`pylint`\] Recurse into subscript subexpressions when searching for list/dict lookups (`PLR1733`, `PLR1736`) ([#13186](https://github.com/astral-sh/ruff/pull/13186))
+- \[`pyupgrade`\] Detect `aiofiles.open` calls in `UP015` ([#13173](https://github.com/astral-sh/ruff/pull/13173))
+- \[`pyupgrade`\] Mark `sys.version_info[0] < 3` and similar comparisons as outdated (`UP036`) ([#13175](https://github.com/astral-sh/ruff/pull/13175))
+
+### CLI
+
+- Enrich messages of SARIF results ([#13180](https://github.com/astral-sh/ruff/pull/13180))
+- Handle singular case for incompatible rules warning in `ruff format` output ([#13212](https://github.com/astral-sh/ruff/pull/13212))
+
+### Bug fixes
+
+- \[`pydocstyle`\] Improve heuristics for detecting Google-style docstrings ([#13142](https://github.com/astral-sh/ruff/pull/13142))
+- \[`refurb`\] Treat `sep` arguments with effects as unsafe removals (`FURB105`) ([#13165](https://github.com/astral-sh/ruff/pull/13165))
+
+## 0.6.3
+
+### Preview features
+
+- \[`flake8-simplify`\] Extend `open-file-with-context-handler` to work with `dbm.sqlite3` (`SIM115`) ([#13104](https://github.com/astral-sh/ruff/pull/13104))
+- \[`pycodestyle`\] Disable `E741` in stub files (`.pyi`) ([#13119](https://github.com/astral-sh/ruff/pull/13119))
+- \[`pydoclint`\] Avoid `DOC201` on explicit returns in functions that only return `None` ([#13064](https://github.com/astral-sh/ruff/pull/13064))
+
+### Rule changes
+
+- \[`flake8-async`\] Disable check for `asyncio` before Python 3.11 (`ASYNC109`) ([#13023](https://github.com/astral-sh/ruff/pull/13023))
+
+### Bug fixes
+
+- \[`FastAPI`\] Avoid introducing invalid syntax in fix for `fast-api-non-annotated-dependency` (`FAST002`) ([#13133](https://github.com/astral-sh/ruff/pull/13133))
+- \[`flake8-implicit-str-concat`\] Normalize octals before merging concatenated strings in `single-line-implicit-string-concatenation` (`ISC001`) ([#13118](https://github.com/astral-sh/ruff/pull/13118))
+- \[`flake8-pytest-style`\] Improve help message for `pytest-incorrect-mark-parentheses-style` (`PT023`) ([#13092](https://github.com/astral-sh/ruff/pull/13092))
+- \[`pylint`\] Avoid autofix for calls that aren't `min` or `max` as starred expression (`PLW3301`) ([#13089](https://github.com/astral-sh/ruff/pull/13089))
+- \[`ruff`\] Add `datetime.time`, `datetime.tzinfo`, and `datetime.timezone` as immutable function calls (`RUF009`) ([#13109](https://github.com/astral-sh/ruff/pull/13109))
+- \[`ruff`\] Extend comment deletion for `RUF100` to include trailing text from `noqa` directives while preserving any following comments on the same line, if any ([#13105](https://github.com/astral-sh/ruff/pull/13105))
+- Fix dark theme on initial page load for the Ruff playground ([#13077](https://github.com/astral-sh/ruff/pull/13077))
+
+## 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,
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,35 +2,6 @@

 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.
@@ -333,22 +304,34 @@ 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
@@ -359,14 +342,25 @@ 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. 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` and `ruff-vscode` repositories.
+
+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.

 ## Ecosystem CI

@@ -389,7 +383,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.
@@ -403,12 +397,18 @@ 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 ./crates/ruff_linter/resources/test/cpython/ --no-cache -e" \
-  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ -e"
+  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache -e" \
+  "./target/release/ruff check ./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 ./crates/ruff_linter/resources/test/cpython/ --no-cache" \
+  "./target/release/ruff check ./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 ./crates/ruff_linter/resources/test/cpython/ --no-cache -e --select W505,E501"
+  "./target/release/ruff check ./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
@@ -530,6 +530,8 @@ You can run the benchmarks with
 cargo benchmark
 ```

+`cargo benchmark` is an alias for `cargo bench -p ruff_benchmark --bench linter --bench formatter --`
+
 #### Benchmark-driven Development

 Ruff uses [Criterion.rs](https://bheisler.github.io/criterion.rs/book/) for benchmarks. You can use
@@ -568,7 +570,7 @@ cargo install critcmp

 #### Tips

- Use `cargo bench -p ruff_benchmark <filter>` to only run specific benchmarks. For example: `cargo benchmark lexer`
+- Use `cargo bench -p ruff_benchmark <filter>` to only run specific benchmarks. For example: `cargo bench -p ruff_benchmark lexer`
    to only run the lexer benchmarks.
 - Use `cargo bench -p ruff_benchmark -- --quiet` for a more cleaned up output (without statistical relevance)
 - Use `cargo bench -p ruff_benchmark -- --quick` to get faster results (more prone to noise)
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -194,6 +194,15 @@ version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"

+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "bstr"
 version = "1.10.0"
@@ -511,6 +520,15 @@ dependencies = [
 "rustc-hash 1.1.0",
 ]

+[[package]]
+name = "cpufeatures"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51e852e6dc9a5bed1fae92dd2375037bf2b768725bf3be87811edee3249d09ad"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "crc32fast"
 version = "1.4.0"
@@ -616,6 +634,16 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"

+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
 [[package]]
 name = "ctrlc"
 version = "3.4.5"
@@ -694,6 +722,16 @@ version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"

+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
 [[package]]
 name = "dirs"
 version = "4.0.0"
@@ -879,6 +917,16 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "getopts"
 version = "0.2.21"
@@ -1112,6 +1160,8 @@ dependencies = [
 "globset",
 "lazy_static",
 "linked-hash-map",
+ "pest",
+ "pest_derive",
 "regex",
 "serde",
 "similar",
@@ -1256,9 +1306,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

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

 [[package]]
 name = "libcst"
@@ -1707,6 +1757,51 @@ version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"

+[[package]]
+name = "pest"
+version = "2.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd53dff83f26735fdc1ca837098ccf133605d794cdae66acfc2bfac3ec809d95"
+dependencies = [
+ "memchr",
+ "thiserror",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a548d2beca6773b1c244554d36fcf8548a8a58e74156968211567250e48e49a"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c93a82e8d145725dcbaf44e5ea887c8a869efdcc28706df2d08c69e17077183"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a941429fea7e08bedec25e4f6785b6ffaacc6b755da98df5ef3e7dcf4a124c4f"
+dependencies = [
+ "once_cell",
+ "pest",
+ "sha2",
+]
+
 [[package]]
 name = "phf"
 version = "0.11.2"
@@ -1803,9 +1898,9 @@ dependencies = [

 [[package]]
 name = "quick-junit"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfc1a6a5406a114913df2df8507998c755311b55b78584bed5f6e88f6417c4d4"
+checksum = "62ffd2f9a162cfae131bed6d9d1ed60adced33be340a94f96952897d7cb0c240"
 dependencies = [
 "chrono",
 "indexmap",
@@ -1818,18 +1913,18 @@ dependencies = [

 [[package]]
 name = "quick-xml"
-version = "0.31.0"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33"
+checksum = "96a05e2e8efddfa51a84ca47cec303fac86c8541b686d37cac5efc0e094417bc"
 dependencies = [
 "memchr",
 ]

 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
 "proc-macro2",
 ]
@@ -1926,6 +2021,7 @@ dependencies = [
 "ruff_db",
 "ruff_index",
 "ruff_python_ast",
+ "ruff_python_literal",
 "ruff_python_parser",
 "ruff_python_stdlib",
 "ruff_source_file",
@@ -1935,6 +2031,8 @@ dependencies = [
 "smallvec",
 "static_assertions",
 "tempfile",
+ "test-case",
+ "thiserror",
 "tracing",
 "walkdir",
 "zip",
@@ -1950,10 +2048,8 @@ 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",
@@ -1989,6 +2085,7 @@ dependencies = [
 "anyhow",
 "crossbeam",
 "notify",
+ "rayon",
 "red_knot_python_semantic",
 "ruff_cache",
 "ruff_db",
@@ -1996,7 +2093,7 @@ dependencies = [
 "ruff_text_size",
 "rustc-hash 2.0.0",
 "salsa",
- "thiserror",
+ "tempfile",
 "tracing",
 ]

@@ -2090,7 +2187,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.6.1"
+version = "0.6.5"
 dependencies = [
 "anyhow",
 "argfile",
@@ -2148,6 +2245,7 @@ dependencies = [
 "criterion",
 "mimalloc",
 "once_cell",
+ "rayon",
 "red_knot_python_semantic",
 "red_knot_workspace",
 "ruff_db",
@@ -2282,7 +2380,7 @@ dependencies = [

 [[package]]
 name = "ruff_linter"
-version = "0.6.1"
+version = "0.6.5"
 dependencies = [
 "aho-corasick",
 "annotate-snippets 0.9.2",
@@ -2602,7 +2700,7 @@ dependencies = [

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

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

 [[package]]
 name = "serde"
-version = "1.0.208"
+version = "1.0.209"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2"
+checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
 dependencies = [
 "serde_derive",
 ]
@@ -2849,9 +2947,9 @@ dependencies = [

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

 [[package]]
 name = "serde_json"
-version = "1.0.125"
+version = "1.0.127"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83c8e735a073ccf5be70aa8066aa984eaf2fa000db6c8d0100ae605b366d31ed"
+checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
 dependencies = [
 "itoa",
 "memchr",
@@ -2933,6 +3031,17 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -3032,9 +3141,9 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"

 [[package]]
 name = "syn"
-version = "2.0.75"
+version = "2.0.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6af063034fc1935ede7be0122941bafa9bacb949334d090b77ca98b5817c7d9"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -3333,6 +3442,18 @@ version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a"

+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
+
 [[package]]
 name = "unic-char-property"
 version = "0.9.0"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -102,13 +102,13 @@ pep440_rs = { version = "0.6.0", features = ["serde"] }
 pretty_assertions = "1.3.0"
 proc-macro2 = { version = "1.0.79" }
 pyproject-toml = { version = "0.9.0" }
-quick-junit = { version = "0.4.0" }
+quick-junit = { version = "0.5.0" }
 quote = { version = "1.0.23" }
 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/MichaReiser/salsa.git", tag = "red-knot-0.0.1" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "f608ff8b24f07706492027199f51132244034f29" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
--- a/README.md
+++ b/README.md
@@ -110,7 +110,7 @@ For more, see the [documentation](https://docs.astral.sh/ruff/).
 1. [Who's Using Ruff?](#whos-using-ruff)
 1. [License](#license)

-## Getting Started
+## Getting Started<a id="getting-started"></a>

 For more, see the [documentation](https://docs.astral.sh/ruff/).

@@ -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.1/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.6.1/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.6.5/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.6.5/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.1
+  rev: v0.6.5
  hooks:
    # Run the linter.
    - id: ruff
@@ -195,7 +195,7 @@ jobs:
      - uses: chartboost/ruff-action@v1
 ```

-### Configuration
+### Configuration<a id="configuration"></a>

 Ruff can be configured through a `pyproject.toml`, `ruff.toml`, or `.ruff.toml` file (see:
 [_Configuration_](https://docs.astral.sh/ruff/configuration/), or [_Settings_](https://docs.astral.sh/ruff/settings/)
@@ -291,7 +291,7 @@ features that may change prior to stabilization.
 See `ruff help` for more on Ruff's top-level commands, or `ruff help check` and `ruff help format`
 for more on the linting and formatting commands, respectively.

-## Rules
+## Rules<a id="rules"></a>

 <!-- Begin section: Rules -->

@@ -367,21 +367,21 @@ quality tools, including:

 For a complete enumeration of the supported rules, see [_Rules_](https://docs.astral.sh/ruff/rules/).

-## Contributing
+## Contributing<a id="contributing"></a>

 Contributions are welcome and highly appreciated. To get started, check out the
 [**contributing guidelines**](https://docs.astral.sh/ruff/contributing/).

 You can also join us on [**Discord**](https://discord.com/invite/astral-sh).

-## Support
+## Support<a id="support"></a>

 Having trouble? Check out the existing issues on [**GitHub**](https://github.com/astral-sh/ruff/issues),
 or feel free to [**open a new one**](https://github.com/astral-sh/ruff/issues/new).

 You can also ask for help on [**Discord**](https://discord.com/invite/astral-sh).

-## Acknowledgements
+## Acknowledgements<a id="acknowledgements"></a>

 Ruff's linter draws on both the APIs and implementation details of many other
 tools in the Python ecosystem, especially [Flake8](https://github.com/PyCQA/flake8), [Pyflakes](https://github.com/PyCQA/pyflakes),
@@ -405,7 +405,7 @@ Ruff is the beneficiary of a large number of [contributors](https://github.com/a

 Ruff is released under the MIT license.

-## Who's Using Ruff?
+## Who's Using Ruff?<a id="whos-using-ruff"></a>

 Ruff is used by a number of major open-source projects and companies, including:

@@ -524,7 +524,7 @@ If you're using Ruff, consider adding the Ruff badge to your project's `README.m
 <a href="https://github.com/astral-sh/ruff"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;"></a>
 ```

-## License
+## License<a id="license"></a>

 This repository is licensed under the [MIT License](https://github.com/astral-sh/ruff/blob/main/LICENSE)

--- a/crates/red_knot/docs/tracing.md
+++ b/crates/red_knot/docs/tracing.md
@@ -13,12 +13,17 @@ The CLI supports different verbosity levels.
 - `-vv` activates `debug!` and timestamps: This should be enough information to get to the bottom of bug reports. When you're processing many packages or files, you'll get pages and pages of output, but each line is link to a specific action or state change.
 - `-vvv` activates `trace!` (only in debug builds) and shows tracing-spans: At this level, you're logging everything. Most of this is wasted, it's really slow, we dump e.g. the entire resolution graph. Only useful to developers, and you almost certainly want to use `RED_KNOT_LOG` to filter it down to the area your investigating.

-## `RED_KNOT_LOG`
+## Better logging with `RED_KNOT_LOG` and `RAYON_NUM_THREADS`

 By default, the CLI shows messages from the `ruff` and `red_knot` crates. Tracing messages from other crates are not shown.
 The `RED_KNOT_LOG` environment variable allows you to customize which messages are shown by specifying one
 or more [filter directives](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#directives).

+The `RAYON_NUM_THREADS` environment variable, meanwhile, can be used to control the level of concurrency red-knot uses.
+By default, red-knot will attempt to parallelize its work so that multiple files are checked simultaneously,
+but this can result in a confused logging output where messages from different threads are intertwined.
+To switch off concurrency entirely and have more readable logs, use `RAYON_NUM_THREADS=1`.
+
 ### Examples

 #### Show all debug messages
--- 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(tracing::level_filters::LevelFilter::WARN.into())
+                EnvFilter::default().add_directive(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::{ProgramSettings, SearchPathSettings};
+use red_knot_python_semantic::SitePackages;
 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,15 +65,14 @@ 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: Vec<SystemPathBuf>,
+    extra_search_path: Option<Vec<SystemPathBuf>>,

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

    #[clap(flatten)]
    verbosity: Verbosity,
@@ -86,6 +85,36 @@ 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
@@ -115,22 +144,13 @@ pub fn main() -> ExitStatus {
 }

 fn run() -> anyhow::Result<ExitStatus> {
-    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<_>>());
+    let args = Args::parse_from(std::env::args().collect::<Vec<_>>());

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

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

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

-    let cwd = current_directory
+    let cwd = args
+        .current_directory
+        .as_ref()
        .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."
@@ -160,33 +182,18 @@ fn run() -> anyhow::Result<ExitStatus> {
        .unwrap_or_else(|| cli_base_path.clone());

    let system = OsSystem::new(cwd.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,
-        },
-    };
+    let cli_configuration = args.to_configuration(&cwd);
+    let workspace_metadata = WorkspaceMetadata::from_path(
+        system.current_directory(),
+        &system,
+        Some(cli_configuration.clone()),
+    )?;

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

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

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

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

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

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

        (
@@ -249,6 +258,7 @@ impl MainLoop {
                sender: sender.clone(),
                receiver,
                watcher: None,
+                cli_configuration,
            },
            MainLoopCancellationToken { sender },
        )
@@ -331,7 +341,7 @@ impl MainLoop {
                MainLoopMessage::ApplyChanges(changes) => {
                    revision += 1;
                    // Automatically cancels any pending queries and waits for them to complete.
-                    db.apply_changes(changes);
+                    db.apply_changes(changes, Some(&self.cli_configuration));
                    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,12 +5,11 @@ use std::time::Duration;

 use anyhow::{anyhow, Context};

-use red_knot_python_semantic::{
-    resolve_module, ModuleName, Program, ProgramSettings, PythonVersion, SearchPathSettings,
-};
+use red_knot_python_semantic::{resolve_module, ModuleName, Program, PythonVersion, SitePackages};
 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;
@@ -25,7 +24,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,
-    search_path_settings: SearchPathSettings,
+    configuration: Configuration,
 }

 impl TestCase {
@@ -41,10 +40,6 @@ 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.")
@@ -105,16 +100,20 @@ 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,
-        f: impl FnOnce(&SearchPathSettings) -> SearchPathSettings,
+        configuration: SearchPathConfiguration,
    ) -> anyhow::Result<()> {
        let program = Program::get(self.db());

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

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

        if let Some(watcher) = &mut self.watcher {
            watcher.update(&self.db);
@@ -127,7 +126,6 @@ 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
@@ -180,17 +178,14 @@ fn setup<F>(setup_files: F) -> anyhow::Result<TestCase>
 where
    F: SetupFiles,
 {
-    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![],
+    setup_with_search_paths(setup_files, |_root, _workspace_path| {
+        SearchPathConfiguration::default()
    })
 }

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

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

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

-    for path in search_path_settings
+    for path in search_paths
        .extra_paths
        .iter()
-        .chain(search_path_settings.site_packages.iter())
-        .chain(search_path_settings.custom_typeshed.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 {
+                &[]
+            }
+        }))
    {
        std::fs::create_dir_all(path.as_std_path())
            .with_context(|| format!("Failed to create search path '{path}'"))?;
    }

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

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

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

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

    let changes = case.stop_watch();

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

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

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

    let changes = case.stop_watch();

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

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

    assert!(!changes.is_empty());

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

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

    let changes = case.stop_watch();

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

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

    let changes = case.stop_watch();

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

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

    let changes = case.stop_watch();

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

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

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

    let changes = case.stop_watch();

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

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

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

    let changes = case.stop_watch();

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

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

    let changes = case.stop_watch();

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

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

    let changes = case.stop_watch();

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

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

    let changes = case.stop_watch();

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

    // `import sub.a` should no longer resolve
    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_none());
@@ -695,15 +699,13 @@ 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| {
-            SearchPathSettings {
-                extra_paths: vec![],
-                src_root: workspace_path.to_path_buf(),
-                custom_typeshed: None,
-                site_packages: vec![root_path.join("site_packages")],
-            }
-        })?;
+    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 site_packages = case.root_path().join("site_packages");

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

    let changes = case.stop_watch();

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

    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("a").unwrap()).is_some());
    assert_eq!(
@@ -737,9 +739,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(|settings| SearchPathSettings {
-        site_packages: vec![site_packages.clone()],
-        ..settings.clone()
+    case.update_search_path_settings(SearchPathConfiguration {
+        site_packages: Some(SitePackages::Known(vec![site_packages.clone()])),
+        ..SearchPathConfiguration::default()
    })
    .expect("Search path settings to be valid");

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

    let changes = case.stop_watch();

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

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

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

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

@@ -783,6 +783,48 @@ 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:
@@ -829,7 +871,7 @@ fn hard_links_in_workspace() -> anyhow::Result<()> {

    let changes = case.stop_watch();

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

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

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

    let changes = case.stop_watch();

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

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

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

        let changes = case.stop_watch();

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

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

        let changes = case.take_watch_changes();

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

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

        let changes = case.stop_watch();

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

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

        let changes = case.stop_watch();

-        case.db_mut().apply_changes(changes);
+        case.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.
@@ -1177,11 +1219,11 @@ mod unix {

                Ok(())
            },
-            |_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")],
+            |_root, workspace| SearchPathConfiguration {
+                site_packages: Some(SitePackages::Known(vec![
+                    workspace.join(".venv/lib/python3.12/site-packages")
+                ])),
+                ..SearchPathConfiguration::default()
            },
        )?;

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

        let changes = case.stop_watch();

-        case.db_mut().apply_changes(changes);
+        case.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
@@ -17,6 +17,7 @@ ruff_python_ast = { workspace = true }
 ruff_python_stdlib = { workspace = true }
 ruff_source_file = { workspace = true }
 ruff_text_size = { workspace = true }
+ruff_python_literal = { workspace = true }

 anyhow = { workspace = true }
 bitflags = { workspace = true }
@@ -26,11 +27,13 @@ countme = { workspace = true }
 once_cell = { workspace = true }
 ordermap = { workspace = true }
 salsa = { workspace = true }
+thiserror = { workspace = true }
 tracing = { workspace = true }
 rustc-hash = { workspace = true }
 hashbrown = { workspace = true }
 smallvec = { workspace = true }
 static_assertions = { workspace = true }
+test-case = { workspace = true }

 [build-dependencies]
 path-slash = { workspace = true }
--- a/crates/red_knot_python_semantic/src/ast_node_ref.rs
+++ b/crates/red_knot_python_semantic/src/ast_node_ref.rs
@@ -31,10 +31,10 @@ impl<T> AstNodeRef<T> {
    /// which the `AstNodeRef` belongs.
    ///
    /// ## Safety
+    ///
    /// Dereferencing the `node` can result in undefined behavior if `parsed` isn't the
    /// [`ParsedModule`] to which `node` belongs. It's the caller's responsibility to ensure that
    /// the invariant `node belongs to parsed` is upheld.
-
    pub(super) unsafe fn new(parsed: ParsedModule, node: &T) -> Self {
        Self {
            _parsed: parsed,
--- a/crates/red_knot_python_semantic/src/builtins.rs
+++ b/crates/red_knot_python_semantic/src/builtins.rs
@@ -1,16 +0,0 @@
-use crate::module_name::ModuleName;
-use crate::module_resolver::resolve_module;
-use crate::semantic_index::global_scope;
-use crate::semantic_index::symbol::ScopeId;
-use crate::Db;
-
-/// Salsa query to get the builtins scope.
-///
-/// Can return None if a custom typeshed is used that is missing `builtins.pyi`.
-#[salsa::tracked]
-pub(crate) fn builtins_scope(db: &dyn Db) -> Option<ScopeId<'_>> {
-    let builtins_name =
-        ModuleName::new_static("builtins").expect("Expected 'builtins' to be a valid module name");
-    let builtins_file = resolve_module(db, builtins_name)?.file();
-    Some(global_scope(db, builtins_file))
-}
--- a/crates/red_knot_python_semantic/src/db.rs
+++ b/crates/red_knot_python_semantic/src/db.rs
@@ -1,15 +1,18 @@
+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> {}
+pub trait Db: SourceDb + Upcast<dyn SourceDb> {
+    fn is_file_open(&self, file: File) -> bool;
+}

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

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

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

    #[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,12 +5,11 @@ 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};
+pub use program::{Program, ProgramSettings, SearchPathSettings, SitePackages};
 pub use python_version::PythonVersion;
 pub use semantic_model::{HasTy, SemanticModel};

 pub mod ast_node_ref;
-mod builtins;
 mod db;
 mod module_name;
 mod module_resolver;
@@ -19,6 +18,9 @@ mod program;
 mod python_version;
 pub mod semantic_index;
 mod semantic_model;
+pub(crate) mod site_packages;
+mod stdlib;
 pub mod types;

 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;
+type FxOrderMap<K, V> = ordermap::map::OrderMap<K, V, BuildHasherDefault<FxHasher>>;
--- a/crates/red_knot_python_semantic/src/module_resolver/mod.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/mod.rs
@@ -13,7 +13,6 @@ use resolver::SearchPathIterator;
 mod module;
 mod path;
 mod resolver;
-mod state;
 mod typeshed;

 #[cfg(test)]
--- 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 super::state::ResolverState;
-use super::typeshed::{TypeshedVersionsParseError, TypeshedVersionsQueryResult};
+use crate::module_resolver::resolver::ResolverContext;
+use crate::site_packages::SitePackagesDiscoveryError;

 /// A path that points to a Python module.
 ///
@@ -59,8 +59,12 @@ impl ModulePath {
        self.relative_path.push(component);
    }

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

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

    #[must_use]
-    pub(crate) fn to_file(&self, resolver: &ResolverState) -> Option<File> {
+    pub(super) fn to_file(&self, resolver: &ResolverContext) -> Option<File> {
        let db = resolver.db.upcast();
        let ModulePath {
            search_path,
@@ -150,7 +154,7 @@ impl ModulePath {
                system_path_to_file(db, search_path.join(relative_path)).ok()
            }
            SearchPathInner::StandardLibraryCustom(stdlib_root) => {
-                match query_stdlib_version(Some(stdlib_root), relative_path, resolver) {
+                match query_stdlib_version(relative_path, resolver) {
                    TypeshedVersionsQueryResult::DoesNotExist => None,
                    TypeshedVersionsQueryResult::Exists
                    | TypeshedVersionsQueryResult::MaybeExists => {
@@ -159,7 +163,7 @@ impl ModulePath {
                }
            }
            SearchPathInner::StandardLibraryVendored(stdlib_root) => {
-                match query_stdlib_version(None, relative_path, resolver) {
+                match query_stdlib_version(relative_path, resolver) {
                    TypeshedVersionsQueryResult::DoesNotExist => None,
                    TypeshedVersionsQueryResult::Exists
                    | TypeshedVersionsQueryResult::MaybeExists => {
@@ -273,19 +277,15 @@ 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,
-    resolver: &ResolverState,
+    context: &ResolverContext,
 ) -> TypeshedVersionsQueryResult {
    let Some(module_name) = stdlib_path_to_module_name(relative_path) else {
        return TypeshedVersionsQueryResult::DoesNotExist;
    };
-    let ResolverState {
-        db,
-        typeshed_versions,
-        target_version,
-    } = resolver;
-    typeshed_versions.query_module(*db, &module_name, custom_stdlib_root, *target_version)
+    let ResolverContext { db, target_version } = context;
+
+    typeshed_versions(*db).query_module(&module_name, *target_version)
 }

 /// Enumeration describing the various ways in which validation of a search path might fail.
@@ -293,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, PartialEq, Eq)]
+#[derive(Debug)]
 pub(crate) enum SearchPathValidationError {
    /// The path provided by the user was not a directory
    NotADirectory(SystemPathBuf),
@@ -304,18 +304,20 @@ pub(crate) enum SearchPathValidationError {
    NoStdlibSubdirectory(SystemPathBuf),

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

    /// 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 {
@@ -325,9 +327,16 @@ impl fmt::Display for SearchPathValidationError {
            Self::NoStdlibSubdirectory(path) => {
                write!(f, "The directory at {path} has no `stdlib/` subdirectory")
            }
-            Self::NoVersionsFile(path) => write!(f, "Expected a file at {path}/stdlib/VERSIONS"),
-            Self::VersionsIsADirectory(path) => write!(f, "{path}/stdlib/VERSIONS is a directory."),
+            Self::FailedToReadVersionsFile { path, error } => {
+                write!(
+                    f,
+                    "Failed to read the custom typeshed versions file '{path}': {error}"
+                )
+            }
            Self::VersionsParseError(underlying_error) => underlying_error.fmt(f),
+            SearchPathValidationError::SitePackagesDiscovery(error) => {
+                write!(f, "Failed to discover the site-packages directory: {error}")
+            }
        }
    }
 }
@@ -342,6 +351,18 @@ 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)]
@@ -384,11 +405,10 @@ pub(crate) struct SearchPath(Arc<SearchPathInner>);

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

@@ -407,32 +427,22 @@ 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: SystemPathBuf) -> SearchPathResult<Self> {
+    pub(crate) fn custom_stdlib(db: &dyn Db, typeshed: &SystemPath) -> 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(path) => {
-                    SearchPathValidationError::NoStdlibSubdirectory(path)
+                SearchPathValidationError::NotADirectory(_) => {
+                    SearchPathValidationError::NoStdlibSubdirectory(typeshed.to_path_buf())
                }
                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,
        ))))
@@ -623,11 +633,11 @@ mod tests {
    use ruff_db::Db;

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

+    use super::*;
+
    impl ModulePath {
        #[must_use]
        fn join(&self, component: &str) -> ModulePath {
@@ -638,15 +648,6 @@ 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)
        }
@@ -661,7 +662,7 @@ mod tests {
            .build();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        let (db, stdlib_path) = py39_typeshed_test_case(TYPESHED);
-        let resolver = ResolverState::new(&db, PythonVersion::PY39);
+        let resolver = ResolverContext::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 rustc_hash::{FxBuildHasher, FxHashSet};
+use std::ops::Deref;

 use ruff_db::files::{File, FilePath, FileRootKind};
-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 ruff_db::system::{DirectoryEntry, System, SystemPath, SystemPathBuf};
+use ruff_db::vendored::{VendoredFileSystem, VendoredPath};

 use super::module::{Module, ModuleKind};
 use super::path::{ModulePath, SearchPath, SearchPathValidationError};
-use super::state::ResolverState;
+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};

 /// 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::debug!(
+    tracing::trace!(
        "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, Default)]
+#[derive(Debug, PartialEq, Eq)]
 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,6 +135,8 @@ 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 {
@@ -146,8 +148,14 @@ 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,
@@ -161,45 +169,65 @@ impl SearchPaths {
        let mut static_paths = vec![];

        for path in extra_paths {
-            tracing::debug!("Adding static extra search-path '{path}'");
+            let path = canonicalize(path, system);
+            files.try_add_root(db.upcast(), &path, FileRootKind::LibrarySearchPath);
+            tracing::debug!("Adding extra search-path '{path}'");

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

-        tracing::debug!("Adding static search path '{src_root}'");
-        static_paths.push(SearchPath::first_party(system, src_root)?);
+        tracing::debug!("Adding first-party search path '{src_root}'");
+        static_paths.push(SearchPath::first_party(system, src_root.to_path_buf())?);

-        static_paths.push(if let Some(custom_typeshed) = custom_typeshed {
-            tracing::debug!("Adding static custom-sdtlib search-path '{custom_typeshed}'");
+        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}'");

-            let search_path = SearchPath::custom_stdlib(db, custom_typeshed)?;
            files.try_add_root(
                db.upcast(),
-                search_path.as_system_path().unwrap(),
+                &custom_typeshed,
                FileRootKind::LibrarySearchPath,
            );
-            search_path
+
+            let versions_path = custom_typeshed.join("stdlib/VERSIONS");
+
+            let versions_content = system.read_to_string(&versions_path).map_err(|error| {
+                SearchPathValidationError::FailedToReadVersionsFile {
+                    path: versions_path,
+                    error,
+                }
+            })?;
+
+            let parsed: TypeshedVersions = versions_content.parse()?;
+
+            let search_path = SearchPath::custom_stdlib(db, &custom_typeshed)?;
+
+            (ResolvedTypeshedVersions::Custom(parsed), search_path)
        } else {
-            SearchPath::vendored_stdlib()
-        });
+            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(),
+        };

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

        for path in site_packages_paths {
-            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);
+            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)?);
        }

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

-    pub(crate) fn iter<'a>(&'a self, db: &'a dyn Db) -> SearchPathIterator<'a> {
+    pub(super) 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:
@@ -251,6 +311,7 @@ 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();
@@ -315,12 +376,16 @@ 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) {
+                match SearchPath::editable(system, installation.clone()) {
                    Ok(search_path) => {
                        tracing::debug!(
                            "Adding editable installation to module resolution path {path}",
-                            path = search_path.as_system_path().unwrap()
+                            path = installation
                        );
                        dynamic_paths.push(search_path);
                    }
@@ -482,7 +547,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 = ResolverState::new(db, target_version);
+    let resolver_state = ResolverContext::new(db, target_version);
    let is_builtin_module =
        ruff_python_stdlib::sys::is_builtin_module(target_version.minor, name.as_str());

@@ -504,24 +569,16 @@ fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(SearchPath, File, Mod

                package_path.push(module_name);

-                // Must be a `__init__.pyi` or `__init__.py` or it isn't a package.
-                let kind = if package_path.is_directory(&resolver_state) {
-                    package_path.push("__init__");
-                    ModuleKind::Package
-                } else {
-                    ModuleKind::Module
-                };
-
-                // TODO Implement full https://peps.python.org/pep-0561/#type-checker-module-resolution-order resolution
-                if let Some(stub) = package_path.with_pyi_extension().to_file(&resolver_state) {
-                    return Some((search_path.clone(), stub, kind));
+                // Check for a regular package first (highest priority)
+                package_path.push("__init__");
+                if let Some(regular_package) = resolve_file_module(&package_path, &resolver_state) {
+                    return Some((search_path.clone(), regular_package, ModuleKind::Package));
                }

-                if let Some(module) = package_path
-                    .with_py_extension()
-                    .and_then(|path| path.to_file(&resolver_state))
-                {
-                    return Some((search_path.clone(), module, kind));
+                // Check for a file module next
+                package_path.pop();
+                if let Some(file_module) = resolve_file_module(&package_path, &resolver_state) {
+                    return Some((search_path.clone(), file_module, ModuleKind::Module));
                }

                // For regular packages, don't search the next search path. All files of that
@@ -542,10 +599,27 @@ fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(SearchPath, File, Mod
    None
 }

+/// If `module` exists on disk with either a `.pyi` or `.py` extension,
+/// return the [`File`] corresponding to that path.
+///
+/// `.pyi` files take priority, as they always have priority when
+/// resolving modules.
+fn resolve_file_module(module: &ModulePath, resolver_state: &ResolverContext) -> Option<File> {
+    // Stubs have precedence over source files
+    module
+        .with_pyi_extension()
+        .to_file(resolver_state)
+        .or_else(|| {
+            module
+                .with_py_extension()
+                .and_then(|path| path.to_file(resolver_state))
+        })
+}
+
 fn resolve_package<'a, 'db, I>(
    module_search_path: &SearchPath,
    components: I,
-    resolver_state: &ResolverState<'db>,
+    resolver_state: &ResolverContext<'db>,
 ) -> Result<ResolvedPackage, PackageKind>
 where
    I: Iterator<Item = &'a str>,
@@ -568,7 +642,10 @@ where

        if is_regular_package {
            in_namespace_package = false;
-        } else if package_path.is_directory(resolver_state) {
+        } else if package_path.is_directory(resolver_state)
+            // Pure modules hide namespace packages with the same name
+            && resolve_file_module(&package_path, resolver_state).is_none()
+        {
            // A directory without an `__init__.py` is a namespace package, continue with the next folder.
            in_namespace_package = true;
        } else if in_namespace_package {
@@ -627,6 +704,21 @@ 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};
@@ -781,7 +873,7 @@ mod tests {
                "Search path for {module_name} was unexpectedly {search_path:?}"
            );
            assert!(
-                search_path.is_stdlib_search_path(),
+                search_path.is_standard_library(),
                "Expected a stdlib search path, but got {search_path:?}"
            );
        }
@@ -877,7 +969,7 @@ mod tests {
                "Search path for {module_name} was unexpectedly {search_path:?}"
            );
            assert!(
-                search_path.is_stdlib_search_path(),
+                search_path.is_standard_library(),
                "Expected a stdlib search path, but got {search_path:?}"
            );
        }
@@ -1011,6 +1103,25 @@ mod tests {
        );
    }

+    #[test]
+    fn single_file_takes_priority_over_namespace_package() {
+        //const SRC: &[FileSpec] = &[("foo.py", "x = 1")];
+        const SRC: &[FileSpec] = &[("foo.py", "x = 1"), ("foo/bar.py", "x = 2")];
+
+        let TestCase { db, src, .. } = TestCaseBuilder::new().with_src_files(SRC).build();
+
+        let foo_module_name = ModuleName::new_static("foo").unwrap();
+        let foo_bar_module_name = ModuleName::new_static("foo.bar").unwrap();
+
+        // `foo.py` takes priority over the `foo` namespace package
+        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
+        assert_eq!(foo_module.file().path(&db), &src.join("foo.py"));
+
+        // `foo.bar` isn't recognised as a module
+        let foo_bar_module = resolve_module(&db, foo_bar_module_name.clone());
+        assert_eq!(foo_bar_module, None);
+    }
+
    #[test]
    fn typing_stub_over_module() {
        const SRC: &[FileSpec] = &[("foo.py", "print('Hello, world!')"), ("foo.pyi", "x: int")];
@@ -1194,13 +1305,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: vec![site_packages],
+                    site_packages: SitePackages::Known(vec![site_packages]),
                },
            },
        )
@@ -1699,13 +1810,16 @@ 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: vec![venv_site_packages, system_site_packages],
+                    site_packages: SitePackages::Known(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
@@ -1,25 +0,0 @@
-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;
+use crate::{ProgramSettings, SitePackages};

 /// A test case for the module resolver.
 ///
@@ -179,6 +179,7 @@ impl TestCaseBuilder<UnspecifiedTypeshed> {
            first_party_files,
            site_packages_files,
        } = self;
+
        TestCaseBuilder {
            typeshed_option: typeshed,
            target_version,
@@ -195,6 +196,7 @@ impl TestCaseBuilder<UnspecifiedTypeshed> {
            site_packages,
            target_version,
        } = self.with_custom_typeshed(MockedTypeshed::default()).build();
+
        TestCase {
            db,
            src,
@@ -223,13 +225,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: vec![site_packages.clone()],
+                    site_packages: SitePackages::Known(vec![site_packages.clone()]),
                },
            },
        )
@@ -279,13 +281,11 @@ impl TestCaseBuilder<VendoredTypeshed> {

        Program::from_settings(
            &db,
-            ProgramSettings {
+            &ProgramSettings {
                target_version,
                search_paths: SearchPathSettings {
-                    extra_paths: vec![],
-                    src_root: src.clone(),
-                    custom_typeshed: None,
-                    site_packages: vec![site_packages.clone()],
+                    site_packages: SitePackages::Known(vec![site_packages.clone()]),
+                    ..SearchPathSettings::new(src.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::{
-    parse_typeshed_versions, LazyTypeshedVersions, TypeshedVersionsParseError,
+    typeshed_versions, vendored_typeshed_versions, TypeshedVersions, 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,4 +1,3 @@
-use std::cell::OnceCell;
 use std::collections::BTreeMap;
 use std::fmt;
 use std::num::{NonZeroU16, NonZeroUsize};
@@ -6,78 +5,12 @@ 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::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()
-}
+use crate::{Program, PythonVersion};

 static VENDORED_VERSIONS: Lazy<TypeshedVersions> = Lazy::new(|| {
    TypeshedVersions::from_str(
@@ -88,6 +21,14 @@ 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>,
@@ -174,7 +115,7 @@ impl TypeshedVersions {
    }

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

-/// Possible answers [`LazyTypeshedVersions::query_module()`] could give to the question:
+/// Possible answers [`TypeshedVersions::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::SystemPathBuf;
+use ruff_db::system::{SystemPath, SystemPathBuf};

 use crate::module_resolver::SearchPaths;
 use crate::Db;
@@ -12,33 +12,31 @@ 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: {target_version}");
+        tracing::info!("Target version: Python {target_version}");

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

-        Ok(Program::builder(settings.target_version)
+        Ok(Program::builder(settings.target_version, search_paths)
            .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)?;

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

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

-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, 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, Default)]
+#[derive(Eq, PartialEq, Debug, Clone)]
 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,
@@ -74,5 +76,25 @@ 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: Vec<SystemPathBuf>,
+    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>),
 }
--- a/crates/red_knot_python_semantic/src/semantic_index.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index.rs
@@ -21,6 +21,7 @@ use crate::Db;

 pub mod ast_ids;
 mod builder;
+pub(crate) mod constraint;
 pub mod definition;
 pub mod expression;
 pub mod symbol;
@@ -154,6 +155,10 @@ 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);
@@ -463,6 +468,25 @@ mod tests {
        ));
    }

+    #[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(_)
+        ));
+    }
+
    #[test]
    fn class_scope() {
        let TestCase { db, file } = test_case(
@@ -552,7 +576,7 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
        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"]);
+        assert_eq!(names(&global_table), vec!["str", "int", "f"]);

        let [(function_scope_id, _function_scope)] = index
            .child_scopes(FileScopeId::global())
@@ -643,7 +667,7 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
    fn comprehension_scope() {
        let TestCase { db, file } = test_case(
            "
-[x for x in iter1]
+[x for x, y in iter1]
 ",
        );

@@ -667,7 +691,22 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):

        let comprehension_symbol_table = index.symbol_table(comprehension_scope_id);

-        assert_eq!(names(&comprehension_symbol_table), vec!["x"]);
+        assert_eq!(names(&comprehension_symbol_table), vec!["x", "y"]);
+
+        let use_def = index.use_def_map(comprehension_scope_id);
+        for name in ["x", "y"] {
+            let definition = use_def
+                .first_public_definition(
+                    comprehension_symbol_table
+                        .symbol_id_by_name(name)
+                        .expect("symbol exists"),
+                )
+                .unwrap();
+            assert!(matches!(
+                definition.node(&db),
+                DefinitionKind::Comprehension(_)
+            ));
+        }
    }

    /// Test case to validate that the `x` variable used in the comprehension is referencing the
@@ -707,8 +746,8 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
        let DefinitionKind::Comprehension(comprehension) = definition.node(&db) else {
            panic!("expected generator definition")
        };
-        let ast::Comprehension { target, .. } = comprehension.node();
-        let name = target.as_name_expr().unwrap().id().as_str();
+        let target = comprehension.target();
+        let name = target.id().as_str();

        assert_eq!(name, "x");
        assert_eq!(target.range(), TextRange::new(23.into(), 24.into()));
@@ -767,6 +806,56 @@ 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(
@@ -998,4 +1087,140 @@ def x():
            vec!["bar", "foo", "Test", "<module>"]
        );
    }
+
+    #[test]
+    fn match_stmt() {
+        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_scope_id = global_scope(&db, file);
+        let global_table = symbol_table(&db, global_scope_id);
+
+        assert!(global_table.symbol_by_name("Foo").unwrap().is_used());
+        assert_eq!(
+            names(&global_table),
+            vec!["subject", "a", "b", "c", "d", "e", "f", "g", "h", "Foo", "i", "j", "k", "l"]
+        );
+
+        let use_def = use_def_map(&db, global_scope_id);
+        for (name, expected_index) in [
+            ("a", 0),
+            ("b", 0),
+            ("c", 1),
+            ("d", 2),
+            ("e", 0),
+            ("f", 1),
+            ("g", 0),
+            ("h", 1),
+            ("i", 0),
+            ("j", 1),
+            ("k", 0),
+            ("l", 1),
+        ] {
+            let definition = use_def
+                .first_public_definition(
+                    global_table.symbol_id_by_name(name).expect("symbol exists"),
+                )
+                .expect("Expected with item definition for {name}");
+            if let DefinitionKind::MatchPattern(pattern) = definition.node(&db) {
+                assert_eq!(pattern.index(), expected_index);
+            } else {
+                panic!("Expected match pattern definition for {name}");
+            }
+        }
+    }
+
+    #[test]
+    fn nested_match_case() {
+        let TestCase { db, file } = test_case(
+            "
+match 1:
+    case first:
+        match 2:
+            case second:
+                pass
+",
+        );
+
+        let global_scope_id = global_scope(&db, file);
+        let global_table = symbol_table(&db, global_scope_id);
+
+        assert_eq!(names(&global_table), vec!["first", "second"]);
+
+        let use_def = use_def_map(&db, global_scope_id);
+        for (name, expected_index) in [("first", 0), ("second", 0)] {
+            let definition = use_def
+                .first_public_definition(
+                    global_table.symbol_id_by_name(name).expect("symbol exists"),
+                )
+                .expect("Expected with item definition for {name}");
+            if let DefinitionKind::MatchPattern(pattern) = definition.node(&db) {
+                assert_eq!(pattern.index(), expected_index);
+            } else {
+                panic!("Expected match pattern definition for {name}");
+            }
+        }
+    }
+
+    #[test]
+    fn for_loops_single_assignment() {
+        let TestCase { db, file } = test_case("for x in a: pass");
+        let scope = global_scope(&db, file);
+        let global_table = symbol_table(&db, scope);
+
+        assert_eq!(&names(&global_table), &["a", "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::For(_)));
+    }
+
+    #[test]
+    fn for_loops_simple_unpacking() {
+        let TestCase { db, file } = test_case("for (x, y) in a: pass");
+        let scope = global_scope(&db, file);
+        let global_table = symbol_table(&db, scope);
+
+        assert_eq!(&names(&global_table), &["a", "x", "y"]);
+
+        let use_def = use_def_map(&db, scope);
+        let x_definition = use_def
+            .first_public_definition(global_table.symbol_id_by_name("x").unwrap())
+            .unwrap();
+        let y_definition = use_def
+            .first_public_definition(global_table.symbol_id_by_name("y").unwrap())
+            .unwrap();
+
+        assert!(matches!(x_definition.node(&db), DefinitionKind::For(_)));
+        assert!(matches!(y_definition.node(&db), DefinitionKind::For(_)));
+    }
+
+    #[test]
+    fn for_loops_complex_unpacking() {
+        let TestCase { db, file } = test_case("for [((a,) b), (c, d)] in e: pass");
+        let scope = global_scope(&db, file);
+        let global_table = symbol_table(&db, scope);
+
+        assert_eq!(&names(&global_table), &["e", "a", "b", "c", "d"]);
+
+        let use_def = use_def_map(&db, scope);
+        let definition = use_def
+            .first_public_definition(global_table.symbol_id_by_name("a").unwrap())
+            .unwrap();
+
+        assert!(matches!(definition.node(&db), DefinitionKind::For(_)));
+    }
 }
--- a/crates/red_knot_python_semantic/src/semantic_index/builder.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/builder.rs
@@ -7,7 +7,7 @@ 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_stmt, Visitor};
+use ruff_python_ast::visitor::{walk_expr, walk_pattern, walk_stmt, Visitor};
 use ruff_python_ast::AnyParameterRef;

 use crate::ast_node_ref::AstNodeRef;
@@ -15,7 +15,7 @@ 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,
+    DefinitionNodeRef, ForStmtDefinitionNodeRef, ImportFromDefinitionNodeRef,
 };
 use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{
@@ -26,6 +26,11 @@ use crate::semantic_index::use_def::{FlowSnapshot, UseDefMapBuilder};
 use crate::semantic_index::SemanticIndex;
 use crate::Db;

+use super::constraint::{Constraint, PatternConstraint};
+use super::definition::{
+    ExceptHandlerDefinitionNodeRef, MatchPatternDefinitionNodeRef, WithItemDefinitionNodeRef,
+};
+
 pub(super) struct SemanticIndexBuilder<'db> {
    // Builder state
    db: &'db dyn Db,
@@ -34,6 +39,8 @@ pub(super) struct SemanticIndexBuilder<'db> {
    scope_stack: Vec<FileScopeId>,
    /// The assignment we're currently visiting.
    current_assignment: Option<CurrentAssignment<'db>>,
+    /// The match case we're currently visiting.
+    current_match_case: Option<CurrentMatchCase<'db>>,
    /// Flow states at each `break` in the current loop.
    loop_break_states: Vec<FlowSnapshot>,

@@ -57,6 +64,7 @@ impl<'db> SemanticIndexBuilder<'db> {
            module: parsed,
            scope_stack: Vec::new(),
            current_assignment: None,
+            current_match_case: None,
            loop_break_states: vec![],

            scopes: IndexVec::new(),
@@ -188,21 +196,50 @@ impl<'db> SemanticIndexBuilder<'db> {
            countme::Count::default(),
        );

-        self.definitions_by_node
+        let existing_definition = self
+            .definitions_by_node
            .insert(definition_node.key(), definition);
+        debug_assert_eq!(existing_definition, None);
+
        self.current_use_def_map_mut()
            .record_definition(symbol, definition);

        definition
    }

-    fn add_constraint(&mut self, constraint_node: &ast::Expr) -> Expression<'db> {
+    fn add_expression_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);
+        self.current_use_def_map_mut()
+            .record_constraint(Constraint::Expression(expression));

        expression
    }

+    fn add_pattern_constraint(
+        &mut self,
+        subject: &ast::Expr,
+        pattern: &ast::Pattern,
+    ) -> PatternConstraint<'db> {
+        #[allow(unsafe_code)]
+        let (subject, pattern) = unsafe {
+            (
+                AstNodeRef::new(self.module.clone(), subject),
+                AstNodeRef::new(self.module.clone(), pattern),
+            )
+        };
+        let pattern_constraint = PatternConstraint::new(
+            self.db,
+            self.file,
+            self.current_scope(),
+            subject,
+            pattern,
+            countme::Count::default(),
+        );
+        self.current_use_def_map_mut()
+            .record_constraint(Constraint::Pattern(pattern_constraint));
+        pattern_constraint
+    }
+
    /// 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> {
@@ -280,6 +317,7 @@ impl<'db> SemanticIndexBuilder<'db> {

        // The `iter` of the first generator is evaluated in the outer scope, while all subsequent
        // nodes are evaluated in the inner scope.
+        self.add_standalone_expression(&generator.iter);
        self.visit_expr(&generator.iter);
        self.push_scope(scope);

@@ -295,6 +333,7 @@ impl<'db> SemanticIndexBuilder<'db> {
        }

        for generator in generators_iter {
+            self.add_standalone_expression(&generator.iter);
            self.visit_expr(&generator.iter);

            self.current_assignment = Some(CurrentAssignment::Comprehension {
@@ -320,10 +359,11 @@ impl<'db> SemanticIndexBuilder<'db> {
            // 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(
+            let existing_definition = self.definitions_by_node.insert(
                DefinitionNodeRef::from(AnyParameterRef::Variadic(&with_default.parameter)).key(),
                definition,
            );
+            debug_assert_eq!(existing_definition, None);
        }
    }

@@ -390,20 +430,6 @@ where
                    self.visit_decorator(decorator);
                }

-                let symbol = self
-                    .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(),
@@ -424,6 +450,21 @@ where
                        builder.pop_scope()
                    },
                );
+                // 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);
+                }
+                // The symbol for the function name itself has to be evaluated
+                // at the end to match the runtime evaluation of parameter defaults
+                // and return-type annotations.
+                let symbol = self
+                    .add_or_update_symbol(function_def.name.id.clone(), SymbolFlags::IS_DEFINED);
+                self.add_definition(symbol, function_def);
            }
            ast::Stmt::ClassDef(class) => {
                for decorator in &class.decorator_list {
@@ -486,7 +527,6 @@ where
            }
            ast::Stmt::AnnAssign(node) => {
                debug_assert!(self.current_assignment.is_none());
-                // TODO deferred annotation visiting
                self.visit_expr(&node.annotation);
                if let Some(value) = &node.value {
                    self.visit_expr(value);
@@ -495,10 +535,24 @@ 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);
+                self.add_expression_constraint(&node.test);
                self.visit_body(&node.body);
                let mut post_clauses: Vec<FlowSnapshot> = vec![];
                for clause in &node.elif_else_clauses {
@@ -523,14 +577,23 @@ where
                    self.flow_merge(pre_if);
                }
            }
-            ast::Stmt::While(node) => {
-                self.visit_expr(&node.test);
+            ast::Stmt::While(ast::StmtWhile {
+                test,
+                body,
+                orelse,
+                range: _,
+            }) => {
+                self.visit_expr(test);

                let pre_loop = self.flow_snapshot();

                // Save aside any break states from an outer loop
                let saved_break_states = std::mem::take(&mut self.loop_break_states);
-                self.visit_body(&node.body);
+
+                // TODO: definitions created inside the body should be fully visible
+                // to other statements/expressions inside the body --Alex/Carl
+                self.visit_body(body);
+
                // Get the break states from the body of this loop, and restore the saved outer
                // ones.
                let break_states =
@@ -539,7 +602,7 @@ where
                // 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.visit_body(&node.orelse);
+                self.visit_body(orelse);

                // Breaking out of a while loop bypasses the `else` clause, so merge in the break
                // states after visiting `else`.
@@ -547,9 +610,139 @@ where
                    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);
+            }
            ast::Stmt::Break(_) => {
                self.loop_break_states.push(self.flow_snapshot());
            }
+
+            ast::Stmt::For(
+                for_stmt @ ast::StmtFor {
+                    range: _,
+                    is_async: _,
+                    target,
+                    iter,
+                    body,
+                    orelse,
+                },
+            ) => {
+                self.add_standalone_expression(iter);
+                self.visit_expr(iter);
+
+                let pre_loop = self.flow_snapshot();
+                let saved_break_states = std::mem::take(&mut self.loop_break_states);
+
+                debug_assert!(self.current_assignment.is_none());
+                self.current_assignment = Some(for_stmt.into());
+                self.visit_expr(target);
+                self.current_assignment = None;
+
+                // TODO: Definitions created by loop variables
+                // (and definitions created inside the body)
+                // are fully visible to other statements/expressions inside the body --Alex/Carl
+                self.visit_body(body);
+
+                let break_states =
+                    std::mem::replace(&mut self.loop_break_states, 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.visit_body(orelse);
+
+                // Breaking out of a `for` 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::Match(ast::StmtMatch {
+                subject,
+                cases,
+                range: _,
+            }) => {
+                self.add_standalone_expression(subject);
+                self.visit_expr(subject);
+
+                let after_subject = self.flow_snapshot();
+                let Some((first, remaining)) = cases.split_first() else {
+                    return;
+                };
+                self.add_pattern_constraint(subject, &first.pattern);
+                self.visit_match_case(first);
+
+                let mut post_case_snapshots = vec![];
+                for case in remaining {
+                    post_case_snapshots.push(self.flow_snapshot());
+                    self.flow_restore(after_subject.clone());
+                    self.add_pattern_constraint(subject, &case.pattern);
+                    self.visit_match_case(case);
+                }
+                for post_clause_state in post_case_snapshots {
+                    self.flow_merge(post_clause_state);
+                }
+                if !cases
+                    .last()
+                    .is_some_and(|case| case.guard.is_none() && case.pattern.is_wildcard())
+                {
+                    self.flow_merge(after_subject);
+                }
+            }
+            ast::Stmt::Try(ast::StmtTry {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+                is_star,
+                range: _,
+            }) => {
+                self.visit_body(body);
+
+                for except_handler in handlers {
+                    let ast::ExceptHandler::ExceptHandler(except_handler) = except_handler;
+                    let ast::ExceptHandlerExceptHandler {
+                        name: symbol_name,
+                        type_: handled_exceptions,
+                        body: handler_body,
+                        range: _,
+                    } = except_handler;
+
+                    if let Some(handled_exceptions) = handled_exceptions {
+                        self.visit_expr(handled_exceptions);
+                    }
+
+                    // If `handled_exceptions` above was `None`, it's something like `except as e:`,
+                    // which is invalid syntax. However, it's still pretty obvious here that the user
+                    // *wanted* `e` to be bound, so we should still create a definition here nonetheless.
+                    if let Some(symbol_name) = symbol_name {
+                        let symbol = self
+                            .add_or_update_symbol(symbol_name.id.clone(), SymbolFlags::IS_DEFINED);
+
+                        self.add_definition(
+                            symbol,
+                            DefinitionNodeRef::ExceptHandler(ExceptHandlerDefinitionNodeRef {
+                                handler: except_handler,
+                                is_star: *is_star,
+                            }),
+                        );
+                    }
+
+                    self.visit_body(handler_body);
+                }
+
+                self.visit_body(orelse);
+                self.visit_body(finalbody);
+            }
            _ => {
                walk_stmt(self, stmt);
            }
@@ -563,11 +756,21 @@ where

        match expr {
            ast::Expr::Name(name_node @ ast::ExprName { id, 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(),
+                let flags = match (ctx, self.current_assignment) {
+                    (ast::ExprContext::Store, Some(CurrentAssignment::AugAssign(_))) => {
+                        // For augmented assignment, the target expression is also used.
+                        SymbolFlags::IS_DEFINED | SymbolFlags::IS_USED
+                    }
+                    (ast::ExprContext::Store, Some(CurrentAssignment::AnnAssign(ann_assign)))
+                        if ann_assign.value.is_none() =>
+                    {
+                        // An annotated assignment that doesn't assign a value is not a Definition
+                        SymbolFlags::empty()
+                    }
+                    (ast::ExprContext::Load, _) => SymbolFlags::IS_USED,
+                    (ast::ExprContext::Store, _) => SymbolFlags::IS_DEFINED,
+                    (ast::ExprContext::Del, _) => SymbolFlags::IS_DEFINED,
+                    (ast::ExprContext::Invalid, _) => SymbolFlags::empty(),
                };
                let symbol = self.add_or_update_symbol(id.clone(), flags);
                if flags.contains(SymbolFlags::IS_DEFINED) {
@@ -584,6 +787,19 @@ 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::For(node)) => {
+                            self.add_definition(
+                                symbol,
+                                ForStmtDefinitionNodeRef {
+                                    iterable: &node.iter,
+                                    target: name_node,
+                                    is_async: node.is_async,
+                                },
+                            );
+                        }
                        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
@@ -593,7 +809,21 @@ where
                        Some(CurrentAssignment::Comprehension { node, first }) => {
                            self.add_definition(
                                symbol,
-                                ComprehensionDefinitionNodeRef { node, first },
+                                ComprehensionDefinitionNodeRef {
+                                    iterable: &node.iter,
+                                    target: name_node,
+                                    first,
+                                    is_async: node.is_async,
+                                },
+                            );
+                        }
+                        Some(CurrentAssignment::WithItem(with_item)) => {
+                            self.add_definition(
+                                symbol,
+                                WithItemDefinitionNodeRef {
+                                    node: with_item,
+                                    target: name_node,
+                                },
                            );
                        }
                        None => {}
@@ -609,11 +839,11 @@ where
            }
            ast::Expr::Named(node) => {
                debug_assert!(self.current_assignment.is_none());
-                self.current_assignment = Some(node.into());
                // TODO walrus in comprehensions is implicitly nonlocal
+                self.visit_expr(&node.value);
+                self.current_assignment = Some(node.into());
                self.visit_expr(&node.target);
                self.current_assignment = None;
-                self.visit_expr(&node.value);
            }
            ast::Expr::Lambda(lambda) => {
                if let Some(parameters) = &lambda.parameters {
@@ -714,24 +944,81 @@ where
        }
    }

-    fn visit_parameters(&mut self, parameters: &'ast ruff_python_ast::Parameters) {
+    fn visit_parameters(&mut self, parameters: &'ast 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_match_case(&mut self, match_case: &'ast ast::MatchCase) {
+        debug_assert!(self.current_match_case.is_none());
+        self.current_match_case = Some(CurrentMatchCase::new(&match_case.pattern));
+        self.visit_pattern(&match_case.pattern);
+        self.current_match_case = None;
+
+        if let Some(expr) = &match_case.guard {
+            self.visit_expr(expr);
+        }
+        self.visit_body(&match_case.body);
+    }
+
+    fn visit_pattern(&mut self, pattern: &'ast ast::Pattern) {
+        if let ast::Pattern::MatchStar(ast::PatternMatchStar {
+            name: Some(name),
+            range: _,
+        }) = pattern
+        {
+            let symbol = self.add_or_update_symbol(name.id().clone(), SymbolFlags::IS_DEFINED);
+            let state = self.current_match_case.as_ref().unwrap();
+            self.add_definition(
+                symbol,
+                MatchPatternDefinitionNodeRef {
+                    pattern: state.pattern,
+                    identifier: name,
+                    index: state.index,
+                },
+            );
+        }
+
+        walk_pattern(self, pattern);
+
+        if let ast::Pattern::MatchAs(ast::PatternMatchAs {
+            name: Some(name), ..
+        })
+        | ast::Pattern::MatchMapping(ast::PatternMatchMapping {
+            rest: Some(name), ..
+        }) = pattern
+        {
+            let symbol = self.add_or_update_symbol(name.id().clone(), SymbolFlags::IS_DEFINED);
+            let state = self.current_match_case.as_ref().unwrap();
+            self.add_definition(
+                symbol,
+                MatchPatternDefinitionNodeRef {
+                    pattern: state.pattern,
+                    identifier: name,
+                    index: state.index,
+                },
+            );
+        }
+
+        self.current_match_case.as_mut().unwrap().index += 1;
+    }
 }

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

 impl<'a> From<&'a ast::StmtAssign> for CurrentAssignment<'a> {
@@ -746,8 +1033,50 @@ 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::StmtFor> for CurrentAssignment<'a> {
+    fn from(value: &'a ast::StmtFor) -> Self {
+        Self::For(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)
+    }
+}
+
+struct CurrentMatchCase<'a> {
+    /// The pattern that's part of the current match case.
+    pattern: &'a ast::Pattern,
+
+    /// The index of the sub-pattern that's being currently visited within the pattern.
+    ///
+    /// For example:
+    /// ```py
+    /// match subject:
+    ///     case a as b: ...
+    ///     case [a, b]: ...
+    ///     case a | b: ...
+    /// ```
+    ///
+    /// In all of the above cases, the index would be 0 for `a` and 1 for `b`.
+    index: u32,
+}
+
+impl<'a> CurrentMatchCase<'a> {
+    fn new(pattern: &'a ast::Pattern) -> Self {
+        Self { pattern, index: 0 }
+    }
+}
--- a/crates/red_knot_python_semantic/src/semantic_index/constraint.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/constraint.rs
@@ -0,0 +1,39 @@
+use ruff_db::files::File;
+use ruff_python_ast as ast;
+
+use crate::ast_node_ref::AstNodeRef;
+use crate::db::Db;
+use crate::semantic_index::expression::Expression;
+use crate::semantic_index::symbol::{FileScopeId, ScopeId};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Constraint<'db> {
+    Expression(Expression<'db>),
+    Pattern(PatternConstraint<'db>),
+}
+
+#[salsa::tracked]
+pub(crate) struct PatternConstraint<'db> {
+    #[id]
+    pub(crate) file: File,
+
+    #[id]
+    pub(crate) file_scope: FileScopeId,
+
+    #[no_eq]
+    #[return_ref]
+    pub(crate) subject: AstNodeRef<ast::Expr>,
+
+    #[no_eq]
+    #[return_ref]
+    pub(crate) pattern: AstNodeRef<ast::Pattern>,
+
+    #[no_eq]
+    count: countme::Count<PatternConstraint<'static>>,
+}
+
+impl<'db> PatternConstraint<'db> {
+    pub(crate) fn scope(self, db: &'db dyn Db) -> ScopeId<'db> {
+        self.file_scope(db).to_scope_id(db, self.file(db))
+    }
+}
--- a/crates/red_knot_python_semantic/src/semantic_index/definition.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/definition.rs
@@ -39,13 +39,18 @@ impl<'db> Definition<'db> {
 pub(crate) enum DefinitionNodeRef<'a> {
    Import(&'a ast::Alias),
    ImportFrom(ImportFromDefinitionNodeRef<'a>),
+    For(ForStmtDefinitionNodeRef<'a>),
    Function(&'a ast::StmtFunctionDef),
    Class(&'a ast::StmtClassDef),
    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>),
+    MatchPattern(MatchPatternDefinitionNodeRef<'a>),
+    ExceptHandler(ExceptHandlerDefinitionNodeRef<'a>),
 }

 impl<'a> From<&'a ast::StmtFunctionDef> for DefinitionNodeRef<'a> {
@@ -72,6 +77,12 @@ 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)
@@ -84,12 +95,24 @@ impl<'a> From<ImportFromDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
    }
 }

+impl<'a> From<ForStmtDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
+    fn from(value: ForStmtDefinitionNodeRef<'a>) -> Self {
+        Self::For(value)
+    }
+}
+
 impl<'a> From<AssignmentDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
    fn from(node_ref: AssignmentDefinitionNodeRef<'a>) -> Self {
        Self::Assignment(node_ref)
    }
 }

+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)
@@ -102,6 +125,12 @@ impl<'a> From<ast::AnyParameterRef<'a>> for DefinitionNodeRef<'a> {
    }
 }

+impl<'a> From<MatchPatternDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
+    fn from(node: MatchPatternDefinitionNodeRef<'a>) -> Self {
+        Self::MatchPattern(node)
+    }
+}
+
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct ImportFromDefinitionNodeRef<'a> {
    pub(crate) node: &'a ast::StmtImportFrom,
@@ -114,10 +143,42 @@ 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 ForStmtDefinitionNodeRef<'a> {
+    pub(crate) iterable: &'a ast::Expr,
+    pub(crate) target: &'a ast::ExprName,
+    pub(crate) is_async: bool,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct ExceptHandlerDefinitionNodeRef<'a> {
+    pub(crate) handler: &'a ast::ExceptHandlerExceptHandler,
+    pub(crate) is_star: bool,
+}
+
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct ComprehensionDefinitionNodeRef<'a> {
-    pub(crate) node: &'a ast::Comprehension,
+    pub(crate) iterable: &'a ast::Expr,
+    pub(crate) target: &'a ast::ExprName,
    pub(crate) first: bool,
+    pub(crate) is_async: bool,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct MatchPatternDefinitionNodeRef<'a> {
+    /// The outermost pattern node in which the identifier being defined occurs.
+    pub(crate) pattern: &'a ast::Pattern,
+    /// The identifier being defined.
+    pub(crate) identifier: &'a ast::Identifier,
+    /// The index of the identifier in the pattern when visiting the `pattern` node in evaluation
+    /// order.
+    pub(crate) index: u32,
 }

 impl DefinitionNodeRef<'_> {
@@ -151,12 +212,29 @@ impl DefinitionNodeRef<'_> {
            DefinitionNodeRef::AnnotatedAssignment(assign) => {
                DefinitionKind::AnnotatedAssignment(AstNodeRef::new(parsed, assign))
            }
-            DefinitionNodeRef::Comprehension(ComprehensionDefinitionNodeRef { node, first }) => {
-                DefinitionKind::Comprehension(ComprehensionDefinitionKind {
-                    node: AstNodeRef::new(parsed, node),
-                    first,
-                })
+            DefinitionNodeRef::AugmentedAssignment(augmented_assignment) => {
+                DefinitionKind::AugmentedAssignment(AstNodeRef::new(parsed, augmented_assignment))
            }
+            DefinitionNodeRef::For(ForStmtDefinitionNodeRef {
+                iterable,
+                target,
+                is_async,
+            }) => DefinitionKind::For(ForStmtDefinitionKind {
+                iterable: AstNodeRef::new(parsed.clone(), iterable),
+                target: AstNodeRef::new(parsed, target),
+                is_async,
+            }),
+            DefinitionNodeRef::Comprehension(ComprehensionDefinitionNodeRef {
+                iterable,
+                target,
+                first,
+                is_async,
+            }) => DefinitionKind::Comprehension(ComprehensionDefinitionKind {
+                iterable: AstNodeRef::new(parsed.clone(), iterable),
+                target: AstNodeRef::new(parsed, target),
+                first,
+                is_async,
+            }),
            DefinitionNodeRef::Parameter(parameter) => match parameter {
                ast::AnyParameterRef::Variadic(parameter) => {
                    DefinitionKind::Parameter(AstNodeRef::new(parsed, parameter))
@@ -165,6 +243,28 @@ impl DefinitionNodeRef<'_> {
                    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),
+                })
+            }
+            DefinitionNodeRef::MatchPattern(MatchPatternDefinitionNodeRef {
+                pattern,
+                identifier,
+                index,
+            }) => DefinitionKind::MatchPattern(MatchPatternDefinitionKind {
+                pattern: AstNodeRef::new(parsed.clone(), pattern),
+                identifier: AstNodeRef::new(parsed, identifier),
+                index,
+            }),
+            DefinitionNodeRef::ExceptHandler(ExceptHandlerDefinitionNodeRef {
+                handler,
+                is_star,
+            }) => DefinitionKind::ExceptHandler(ExceptHandlerDefinitionKind {
+                handler: AstNodeRef::new(parsed.clone(), handler),
+                is_star,
+            }),
        }
    }

@@ -182,11 +282,22 @@ impl DefinitionNodeRef<'_> {
                target,
            }) => target.into(),
            Self::AnnotatedAssignment(node) => node.into(),
-            Self::Comprehension(ComprehensionDefinitionNodeRef { node, first: _ }) => node.into(),
+            Self::AugmentedAssignment(node) => node.into(),
+            Self::For(ForStmtDefinitionNodeRef {
+                iterable: _,
+                target,
+                is_async: _,
+            }) => target.into(),
+            Self::Comprehension(ComprehensionDefinitionNodeRef { target, .. }) => target.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(),
+            Self::MatchPattern(MatchPatternDefinitionNodeRef { identifier, .. }) => {
+                identifier.into()
+            }
+            Self::ExceptHandler(ExceptHandlerDefinitionNodeRef { handler, .. }) => handler.into(),
        }
    }
 }
@@ -200,25 +311,58 @@ pub enum DefinitionKind {
    NamedExpression(AstNodeRef<ast::ExprNamed>),
    Assignment(AssignmentDefinitionKind),
    AnnotatedAssignment(AstNodeRef<ast::StmtAnnAssign>),
+    AugmentedAssignment(AstNodeRef<ast::StmtAugAssign>),
+    For(ForStmtDefinitionKind),
    Comprehension(ComprehensionDefinitionKind),
    Parameter(AstNodeRef<ast::Parameter>),
    ParameterWithDefault(AstNodeRef<ast::ParameterWithDefault>),
+    WithItem(WithItemDefinitionKind),
+    MatchPattern(MatchPatternDefinitionKind),
+    ExceptHandler(ExceptHandlerDefinitionKind),
+}
+
+#[derive(Clone, Debug)]
+#[allow(dead_code)]
+pub struct MatchPatternDefinitionKind {
+    pattern: AstNodeRef<ast::Pattern>,
+    identifier: AstNodeRef<ast::Identifier>,
+    index: u32,
+}
+
+impl MatchPatternDefinitionKind {
+    pub(crate) fn pattern(&self) -> &ast::Pattern {
+        self.pattern.node()
+    }
+
+    pub(crate) fn index(&self) -> u32 {
+        self.index
+    }
 }

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

 impl ComprehensionDefinitionKind {
-    pub(crate) fn node(&self) -> &ast::Comprehension {
-        self.node.node()
+    pub(crate) fn iterable(&self) -> &ast::Expr {
+        self.iterable.node()
+    }
+
+    pub(crate) fn target(&self) -> &ast::ExprName {
+        self.target.node()
    }

    pub(crate) fn is_first(&self) -> bool {
        self.first
    }
+
+    pub(crate) fn is_async(&self) -> bool {
+        self.is_async
+    }
 }

 #[derive(Clone, Debug)]
@@ -238,7 +382,6 @@ impl ImportFromDefinitionKind {
 }

 #[derive(Clone, Debug)]
-#[allow(dead_code)]
 pub struct AssignmentDefinitionKind {
    assignment: AstNodeRef<ast::StmtAssign>,
    target: AstNodeRef<ast::ExprName>,
@@ -254,6 +397,59 @@ impl AssignmentDefinitionKind {
    }
 }

+#[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(Clone, Debug)]
+pub struct ForStmtDefinitionKind {
+    iterable: AstNodeRef<ast::Expr>,
+    target: AstNodeRef<ast::ExprName>,
+    is_async: bool,
+}
+
+impl ForStmtDefinitionKind {
+    pub(crate) fn iterable(&self) -> &ast::Expr {
+        self.iterable.node()
+    }
+
+    pub(crate) fn target(&self) -> &ast::ExprName {
+        self.target.node()
+    }
+
+    pub(crate) fn is_async(&self) -> bool {
+        self.is_async
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ExceptHandlerDefinitionKind {
+    handler: AstNodeRef<ast::ExceptHandlerExceptHandler>,
+    is_star: bool,
+}
+
+impl ExceptHandlerDefinitionKind {
+    pub(crate) fn handled_exceptions(&self) -> Option<&ast::Expr> {
+        self.handler.node().type_.as_deref()
+    }
+
+    pub(crate) fn is_star(&self) -> bool {
+        self.is_star
+    }
+}
+
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub(crate) struct DefinitionNodeKey(NodeKey);

@@ -293,12 +489,18 @@ impl From<&ast::StmtAnnAssign> for DefinitionNodeKey {
    }
 }

-impl From<&ast::Comprehension> for DefinitionNodeKey {
-    fn from(node: &ast::Comprehension) -> Self {
+impl From<&ast::StmtAugAssign> for DefinitionNodeKey {
+    fn from(node: &ast::StmtAugAssign) -> Self {
        Self(NodeKey::from_node(node))
    }
 }

+impl From<&ast::StmtFor> for DefinitionNodeKey {
+    fn from(value: &ast::StmtFor) -> Self {
+        Self(NodeKey::from_node(value))
+    }
+}
+
 impl From<&ast::Parameter> for DefinitionNodeKey {
    fn from(node: &ast::Parameter) -> Self {
        Self(NodeKey::from_node(node))
@@ -310,3 +512,15 @@ impl From<&ast::ParameterWithDefault> for DefinitionNodeKey {
        Self(NodeKey::from_node(node))
    }
 }
+
+impl From<&ast::Identifier> for DefinitionNodeKey {
+    fn from(identifier: &ast::Identifier) -> Self {
+        Self(NodeKey::from_node(identifier))
+    }
+}
+
+impl From<&ast::ExceptHandlerExceptHandler> for DefinitionNodeKey {
+    fn from(handler: &ast::ExceptHandlerExceptHandler) -> Self {
+        Self(NodeKey::from_node(handler))
+    }
+}
--- a/crates/red_knot_python_semantic/src/semantic_index/symbol.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/symbol.rs
@@ -149,6 +149,10 @@ impl FileScopeId {
        FileScopeId::from_u32(0)
    }

+    pub fn is_global(self) -> bool {
+        self == FileScopeId::global()
+    }
+
    pub fn to_scope_id(self, db: &dyn Db, file: File) -> ScopeId<'_> {
        let index = semantic_index(db, file);
        index.scope_ids_by_scope[self]
--- a/crates/red_knot_python_semantic/src/semantic_index/use_def.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/use_def.rs
@@ -146,10 +146,11 @@ use self::symbol_state::{
 };
 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 super::constraint::Constraint;
+
 mod bitset;
 mod symbol_state;

@@ -159,8 +160,8 @@ pub(crate) struct UseDefMap<'db> {
    /// Array of [`Definition`] in this scope.
    all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,

-    /// Array of constraints (as [`Expression`]) in this scope.
-    all_constraints: IndexVec<ScopedConstraintId, Expression<'db>>,
+    /// Array of [`Constraint`] in this scope.
+    all_constraints: IndexVec<ScopedConstraintId, Constraint<'db>>,

    /// [`SymbolState`] visible at a [`ScopedUseId`].
    definitions_by_use: IndexVec<ScopedUseId, SymbolState>,
@@ -204,7 +205,7 @@ impl<'db> UseDefMap<'db> {
 #[derive(Debug)]
 pub(crate) struct DefinitionWithConstraintsIterator<'map, 'db> {
    all_definitions: &'map IndexVec<ScopedDefinitionId, Definition<'db>>,
-    all_constraints: &'map IndexVec<ScopedConstraintId, Expression<'db>>,
+    all_constraints: &'map IndexVec<ScopedConstraintId, Constraint<'db>>,
    inner: DefinitionIdWithConstraintsIterator<'map>,
 }

@@ -232,12 +233,12 @@ pub(crate) struct DefinitionWithConstraints<'map, 'db> {
 }

 pub(crate) struct ConstraintsIterator<'map, 'db> {
-    all_constraints: &'map IndexVec<ScopedConstraintId, Expression<'db>>,
+    all_constraints: &'map IndexVec<ScopedConstraintId, Constraint<'db>>,
    constraint_ids: ConstraintIdIterator<'map>,
 }

 impl<'map, 'db> Iterator for ConstraintsIterator<'map, 'db> {
-    type Item = Expression<'db>;
+    type Item = Constraint<'db>;

    fn next(&mut self) -> Option<Self::Item> {
        self.constraint_ids
@@ -259,8 +260,8 @@ pub(super) struct UseDefMapBuilder<'db> {
    /// Append-only array of [`Definition`]; None is unbound.
    all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,

-    /// Append-only array of constraints (as [`Expression`]).
-    all_constraints: IndexVec<ScopedConstraintId, Expression<'db>>,
+    /// Append-only array of [`Constraint`].
+    all_constraints: IndexVec<ScopedConstraintId, Constraint<'db>>,

    /// Visible definitions at each so-far-recorded use.
    definitions_by_use: IndexVec<ScopedUseId, SymbolState>,
@@ -290,7 +291,7 @@ impl<'db> UseDefMapBuilder<'db> {
        self.definitions_by_symbol[symbol] = SymbolState::with(def_id);
    }

-    pub(super) fn record_constraint(&mut self, constraint: Expression<'db>) {
+    pub(super) fn record_constraint(&mut self, constraint: Constraint<'db>) {
        let constraint_id = self.all_constraints.push(constraint);
        for definitions in &mut self.definitions_by_symbol {
            definitions.add_constraint(constraint_id);
--- 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
@@ -32,17 +32,26 @@ impl<const B: usize> BitSet<B> {
        bitset
    }

+    #[allow(unused)]
+    pub(super) fn is_empty(&self) -> bool {
+        self.blocks().iter().all(|&b| b == 0)
+    }
+
    /// 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;
+        self.resize_blocks(num_blocks_needed as usize);
+    }
+
+    fn resize_blocks(&mut self, num_blocks_needed: usize) {
        match self {
            Self::Inline(blocks) => {
                let mut vec = blocks.to_vec();
-                vec.resize(num_blocks_needed as usize, 0);
+                vec.resize(num_blocks_needed, 0);
                *self = Self::Heap(vec);
            }
            Self::Heap(vec) => {
-                vec.resize(num_blocks_needed as usize, 0);
+                vec.resize(num_blocks_needed, 0);
            }
        }
    }
@@ -89,6 +98,20 @@ impl<const B: usize> BitSet<B> {
        }
    }

+    /// Union in-place with another [`BitSet`].
+    #[allow(unused)]
+    pub(super) fn union(&mut self, other: &BitSet<B>) {
+        let mut max_len = self.blocks().len();
+        let other_len = other.blocks().len();
+        if other_len > max_len {
+            max_len = other_len;
+            self.resize_blocks(max_len);
+        }
+        for (my_block, other_block) in self.blocks_mut().iter_mut().zip(other.blocks()) {
+            *my_block |= other_block;
+        }
+    }
+
    /// Return an iterator over the values (in ascending order) in this [`BitSet`].
    pub(super) fn iter(&self) -> BitSetIterator<'_, B> {
        let blocks = self.blocks();
@@ -218,6 +241,59 @@ mod tests {
        assert_bitset(&b1, &[89]);
    }

+    #[test]
+    fn union() {
+        let mut b1 = BitSet::<1>::with(2);
+        let b2 = BitSet::<1>::with(4);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[2, 4]);
+    }
+
+    #[test]
+    fn union_mixed_1() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(89);
+        b2.insert(5);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 5, 89]);
+    }
+
+    #[test]
+    fn union_mixed_2() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(23);
+        b2.insert(89);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 23, 89]);
+    }
+
+    #[test]
+    fn union_heap() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(89);
+        b2.insert(90);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 89, 90]);
+    }
+
+    #[test]
+    fn union_heap_2() {
+        let mut b1 = BitSet::<1>::with(89);
+        let mut b2 = BitSet::<1>::with(89);
+        b1.insert(91);
+        b2.insert(90);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[89, 90, 91]);
+    }
+
    #[test]
    fn multiple_blocks() {
        let mut b = BitSet::<2>::with(120);
@@ -225,4 +301,11 @@ mod tests {
        assert!(matches!(b, BitSet::Inline(_)));
        assert_bitset(&b, &[45, 120]);
    }
+
+    #[test]
+    fn empty() {
+        let b = BitSet::<1>::default();
+
+        assert!(b.is_empty());
+    }
 }
--- a/crates/red_knot_python_semantic/src/semantic_model.rs
+++ b/crates/red_knot_python_semantic/src/semantic_model.rs
@@ -8,7 +8,7 @@ use crate::module_name::ModuleName;
 use crate::module_resolver::{resolve_module, Module};
 use crate::semantic_index::ast_ids::HasScopedAstId;
 use crate::semantic_index::semantic_index;
-use crate::types::{definition_ty, global_symbol_ty_by_name, infer_scope_types, Type};
+use crate::types::{definition_ty, global_symbol_ty, infer_scope_types, Type};
 use crate::Db;

 pub struct SemanticModel<'db> {
@@ -40,7 +40,7 @@ impl<'db> SemanticModel<'db> {
    }

    pub fn global_symbol_ty(&self, module: &Module, symbol_name: &str) -> Type<'db> {
-        global_symbol_ty_by_name(self.db, module.file(), symbol_name)
+        global_symbol_ty(self.db, module.file(), symbol_name)
    }
 }

@@ -184,14 +184,9 @@ mod tests {

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

--- a/crates/red_knot_python_semantic/src/site_packages.rs
+++ b/crates/red_knot_python_semantic/src/site_packages.rs
@@ -13,9 +13,10 @@ 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.
@@ -24,7 +25,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 struct VirtualEnvironment {
+pub(crate) struct VirtualEnvironment {
    venv_path: SysPrefixPath,
    base_executable_home_path: PythonHomePath,
    include_system_site_packages: bool,
@@ -41,7 +42,7 @@ pub struct VirtualEnvironment {
 }

 impl VirtualEnvironment {
-    pub fn new(
+    pub(crate) fn new(
        path: impl AsRef<SystemPath>,
        system: &dyn System,
    ) -> SitePackagesDiscoveryResult<Self> {
@@ -55,7 +56,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)
@@ -157,7 +158,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 fn site_packages_directories(
+    pub(crate) fn site_packages_directories(
        &self,
        system: &dyn System,
    ) -> SitePackagesDiscoveryResult<Vec<SystemPathBuf>> {
@@ -191,7 +192,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")
                );
@@ -204,7 +205,7 @@ System site-packages will not be used for module resolution.",
 }

 #[derive(Debug, thiserror::Error)]
-pub enum SitePackagesDiscoveryError {
+pub(crate) 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")]
@@ -221,7 +222,7 @@ pub enum SitePackagesDiscoveryError {

 /// The various ways in which parsing a `pyvenv.cfg` file could fail
 #[derive(Debug)]
-pub enum PyvenvCfgParseErrorKind {
+pub(crate) enum PyvenvCfgParseErrorKind {
    TooManyEquals { line_number: NonZeroUsize },
    MalformedKeyValuePair { line_number: NonZeroUsize },
    NoHomeKey,
@@ -370,7 +371,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 struct SysPrefixPath(SystemPathBuf);
+pub(crate) struct SysPrefixPath(SystemPathBuf);

 impl SysPrefixPath {
    fn new(
@@ -425,7 +426,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)
    }
 }

@@ -482,7 +483,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_python_semantic/src/stdlib.rs
+++ b/crates/red_knot_python_semantic/src/stdlib.rs
@@ -0,0 +1,77 @@
+use crate::module_name::ModuleName;
+use crate::module_resolver::resolve_module;
+use crate::semantic_index::global_scope;
+use crate::semantic_index::symbol::ScopeId;
+use crate::types::{global_symbol_ty, Type};
+use crate::Db;
+
+/// Enumeration of various core stdlib modules, for which we have dedicated Salsa queries.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum CoreStdlibModule {
+    Builtins,
+    Types,
+    Typeshed,
+}
+
+impl CoreStdlibModule {
+    fn name(self) -> ModuleName {
+        let module_name = match self {
+            Self::Builtins => "builtins",
+            Self::Types => "types",
+            Self::Typeshed => "_typeshed",
+        };
+        ModuleName::new_static(module_name)
+            .unwrap_or_else(|| panic!("{module_name} should be a valid module name!"))
+    }
+}
+
+/// Lookup the type of `symbol` in a given core module
+///
+/// Returns `Unbound` if the given core module cannot be resolved for some reason
+fn core_module_symbol_ty<'db>(
+    db: &'db dyn Db,
+    core_module: CoreStdlibModule,
+    symbol: &str,
+) -> Type<'db> {
+    resolve_module(db, core_module.name())
+        .map(|module| global_symbol_ty(db, module.file(), symbol))
+        .unwrap_or(Type::Unbound)
+}
+
+/// Lookup the type of `symbol` in the builtins namespace.
+///
+/// Returns `Unbound` if the `builtins` module isn't available for some reason.
+#[inline]
+pub(crate) fn builtins_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
+    core_module_symbol_ty(db, CoreStdlibModule::Builtins, symbol)
+}
+
+/// Lookup the type of `symbol` in the `types` module namespace.
+///
+/// Returns `Unbound` if the `types` module isn't available for some reason.
+#[inline]
+pub(crate) fn types_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
+    core_module_symbol_ty(db, CoreStdlibModule::Types, symbol)
+}
+
+/// Lookup the type of `symbol` in the `_typeshed` module namespace.
+///
+/// Returns `Unbound` if the `_typeshed` module isn't available for some reason.
+#[inline]
+pub(crate) fn typeshed_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
+    core_module_symbol_ty(db, CoreStdlibModule::Typeshed, symbol)
+}
+
+/// Get the scope of a core stdlib module.
+///
+/// Can return `None` if a custom typeshed is used that is missing the core module in question.
+fn core_module_scope(db: &dyn Db, core_module: CoreStdlibModule) -> Option<ScopeId<'_>> {
+    resolve_module(db, core_module.name()).map(|module| global_scope(db, module.file()))
+}
+
+/// Get the `builtins` module scope.
+///
+/// Can return `None` if a custom typeshed is used that is missing `builtins.pyi`.
+pub(crate) fn builtins_module_scope(db: &dyn Db) -> Option<ScopeId<'_>> {
+    core_module_scope(db, CoreStdlibModule::Builtins)
+}
--- a/crates/red_knot_python_semantic/src/types.rs
+++ b/crates/red_knot_python_semantic/src/types.rs
@@ -1,28 +1,47 @@
+use infer::TypeInferenceBuilder;
 use ruff_db::files::File;
-use ruff_python_ast::name::Name;
+use ruff_python_ast as ast;

-use crate::builtins::builtins_scope;
-use crate::semantic_index::definition::Definition;
+use crate::module_resolver::file_to_module;
+use crate::semantic_index::ast_ids::HasScopedAstId;
+use crate::semantic_index::definition::{Definition, DefinitionKind};
 use crate::semantic_index::symbol::{ScopeId, ScopedSymbolId};
 use crate::semantic_index::{
-    global_scope, symbol_table, use_def_map, DefinitionWithConstraints,
+    global_scope, semantic_index, symbol_table, use_def_map, DefinitionWithConstraints,
    DefinitionWithConstraintsIterator,
 };
+use crate::stdlib::{builtins_symbol_ty, types_symbol_ty, typeshed_symbol_ty};
 use crate::types::narrow::narrowing_constraint;
 use crate::{Db, FxOrderSet};

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

-pub(crate) use self::builder::{IntersectionBuilder, UnionBuilder};
-pub(crate) use self::infer::{
-    infer_definition_types, infer_expression_types, infer_scope_types, TypeInference,
-};
+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
+}

 /// Infer the public type of a symbol (its type as seen from outside its scope).
-pub(crate) fn symbol_ty<'db>(
+pub(crate) fn symbol_ty_by_id<'db>(
    db: &'db dyn Db,
    scope: ScopeId<'db>,
    symbol: ScopedSymbolId,
@@ -40,30 +59,17 @@ pub(crate) fn symbol_ty<'db>(
 }

 /// Shorthand for `symbol_ty` that takes a symbol name instead of an ID.
-pub(crate) fn symbol_ty_by_name<'db>(
-    db: &'db dyn Db,
-    scope: ScopeId<'db>,
-    name: &str,
-) -> Type<'db> {
+pub(crate) fn symbol_ty<'db>(db: &'db dyn Db, scope: ScopeId<'db>, name: &str) -> Type<'db> {
    let table = symbol_table(db, scope);
    table
        .symbol_id_by_name(name)
-        .map(|symbol| symbol_ty(db, scope, symbol))
+        .map(|symbol| symbol_ty_by_id(db, scope, symbol))
        .unwrap_or(Type::Unbound)
 }

 /// Shorthand for `symbol_ty` that looks up a module-global symbol by name in a file.
-pub(crate) fn global_symbol_ty_by_name<'db>(db: &'db dyn Db, file: File, name: &str) -> Type<'db> {
-    symbol_ty_by_name(db, global_scope(db, file), name)
-}
-
-/// Shorthand for `symbol_ty` that looks up a symbol in the builtins.
-///
-/// Returns `Unbound` if the builtins module isn't available for some reason.
-pub(crate) fn builtins_symbol_ty_by_name<'db>(db: &'db dyn Db, name: &str) -> Type<'db> {
-    builtins_scope(db)
-        .map(|builtins| symbol_ty_by_name(db, builtins, name))
-        .unwrap_or(Type::Unbound)
+pub(crate) fn global_symbol_ty<'db>(db: &'db dyn Db, file: File, name: &str) -> Type<'db> {
+    symbol_ty(db, global_scope(db, file), name)
 }

 /// Infer the type of a [`Definition`].
@@ -72,6 +78,24 @@ pub(crate) fn definition_ty<'db>(db: &'db dyn Db, definition: Definition<'db>) -
    inference.definition_ty(definition)
 }

+/// Infer the type of a (possibly deferred) sub-expression of a [`Definition`].
+///
+/// ## Panics
+/// If the given expression is not a sub-expression of the given [`Definition`].
+pub(crate) fn definition_expression_ty<'db>(
+    db: &'db dyn Db,
+    definition: Definition<'db>,
+    expression: &ast::Expr,
+) -> Type<'db> {
+    let expr_id = expression.scoped_ast_id(db, definition.scope(db));
+    let inference = infer_definition_types(db, definition);
+    if let Some(ty) = inference.try_expression_ty(expr_id) {
+        ty
+    } else {
+        infer_deferred_types(db, definition).expression_ty(expr_id)
+    }
+}
+
 /// 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
@@ -97,8 +121,8 @@ pub(crate) fn definitions_ty<'db>(
             definition,
             constraints,
         }| {
-            let mut constraint_tys =
-                constraints.filter_map(|test| narrowing_constraint(db, test, definition));
+            let mut constraint_tys = constraints
+                .filter_map(|constraint| narrowing_constraint(db, constraint, definition));
            let definition_ty = definition_ty(db, definition);
            if let Some(first_constraint_ty) = constraint_tys.next() {
                let mut builder = IntersectionBuilder::new(db);
@@ -116,26 +140,19 @@ pub(crate) fn definitions_ty<'db>(
    );
    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.")
-    };
+    let first = all_types
+        .next()
+        .expect("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);
-        }
-
-        builder.build()
+        UnionType::from_elements(db, [first, second].into_iter().chain(all_types))
    } else {
        first
    }
 }

 /// Unique ID for a type.
-#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Type<'db> {
    /// the dynamic type: a statically-unknown set of values
    Any,
@@ -165,6 +182,16 @@ pub enum Type<'db> {
    IntLiteral(i64),
    /// A boolean literal, either `True` or `False`.
    BooleanLiteral(bool),
+    /// A string literal
+    StringLiteral(StringLiteralType<'db>),
+    /// A string known to originate only from literal values, but whose value is not known (unlike
+    /// `StringLiteral` above).
+    LiteralString,
+    /// A bytes literal
+    BytesLiteral(BytesLiteralType<'db>),
+    /// A heterogeneous tuple type, with elements of the given types in source order.
+    // TODO: Support variable length homogeneous tuple type like `tuple[int, ...]`.
+    Tuple(TupleType<'db>),
    // TODO protocols, callable types, overloads, generics, type vars
 }

@@ -173,14 +200,82 @@ 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 const fn into_class_type(self) -> Option<ClassType<'db>> {
+        match self {
+            Type::Class(class_type) => Some(class_type),
+            _ => None,
+        }
+    }
+
+    pub fn expect_class(self) -> ClassType<'db> {
+        self.into_class_type()
+            .expect("Expected a Type::Class variant")
+    }
+
+    pub const fn into_module_type(self) -> Option<File> {
+        match self {
+            Type::Module(file) => Some(file),
+            _ => None,
+        }
+    }
+
+    pub fn expect_module(self) -> File {
+        self.into_module_type()
+            .expect("Expected a Type::Module variant")
+    }
+
+    pub const fn into_union_type(self) -> Option<UnionType<'db>> {
+        match self {
+            Type::Union(union_type) => Some(union_type),
+            _ => None,
+        }
+    }
+
+    pub fn expect_union(self) -> UnionType<'db> {
+        self.into_union_type()
+            .expect("Expected a Type::Union variant")
+    }
+
+    pub const fn into_intersection_type(self) -> Option<IntersectionType<'db>> {
+        match self {
+            Type::Intersection(intersection_type) => Some(intersection_type),
+            _ => None,
+        }
+    }
+
+    pub fn expect_intersection(self) -> IntersectionType<'db> {
+        self.into_intersection_type()
+            .expect("Expected a Type::Intersection variant")
+    }
+
+    pub const fn into_function_type(self) -> Option<FunctionType<'db>> {
+        match self {
+            Type::Function(function_type) => Some(function_type),
+            _ => None,
+        }
+    }
+
+    pub fn expect_function(self) -> FunctionType<'db> {
+        self.into_function_type()
+            .expect("Expected a Type::Function variant")
+    }
+
+    pub const fn into_int_literal_type(self) -> Option<i64> {
+        match self {
+            Type::IntLiteral(value) => Some(value),
+            _ => None,
+        }
+    }
+
+    pub fn expect_int_literal(self) -> i64 {
+        self.into_int_literal_type()
+            .expect("Expected a Type::IntLiteral variant")
+    }
+
    pub fn may_be_unbound(&self, db: &'db dyn Db) -> bool {
        match self {
            Type::Unbound => true,
@@ -195,59 +290,281 @@ impl<'db> Type<'db> {
    pub fn replace_unbound_with(&self, db: &'db dyn Db, replacement: Type<'db>) -> Type<'db> {
        match self {
            Type::Unbound => replacement,
-            Type::Union(union) => union
-                .elements(db)
-                .into_iter()
-                .fold(UnionBuilder::new(db), |builder, ty| {
-                    builder.add(ty.replace_unbound_with(db, replacement))
-                })
-                .build(),
+            Type::Union(union) => {
+                union.map(db, |element| element.replace_unbound_with(db, replacement))
+            }
            ty => *ty,
        }
    }

+    /// Return true if this type is [assignable to] type `target`.
+    ///
+    /// [assignable to]: https://typing.readthedocs.io/en/latest/spec/concepts.html#the-assignable-to-or-consistent-subtyping-relation
+    #[allow(unused)]
+    pub(crate) fn is_assignable_to(self, db: &'db dyn Db, target: Type<'db>) -> bool {
+        if self.is_equivalent_to(db, target) {
+            return true;
+        }
+        match (self, target) {
+            (Type::Unknown | Type::Any | Type::Never, _) => true,
+            (_, Type::Unknown | Type::Any) => true,
+            (Type::IntLiteral(_), Type::Instance(class))
+                if class.is_stdlib_symbol(db, "builtins", "int") =>
+            {
+                true
+            }
+            (Type::StringLiteral(_), Type::LiteralString) => true,
+            (Type::StringLiteral(_) | Type::LiteralString, Type::Instance(class))
+                if class.is_stdlib_symbol(db, "builtins", "str") =>
+            {
+                true
+            }
+            (Type::BytesLiteral(_), Type::Instance(class))
+                if class.is_stdlib_symbol(db, "builtins", "bytes") =>
+            {
+                true
+            }
+            // TODO
+            _ => false,
+        }
+    }
+
+    /// Return true if this type is equivalent to type `other`.
+    #[allow(unused)]
+    pub(crate) fn is_equivalent_to(self, _db: &'db dyn Db, other: Type<'db>) -> bool {
+        // TODO equivalent but not identical structural types, differently-ordered unions and
+        // intersections, other cases?
+        self == other
+    }
+
+    /// 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> {
+    pub fn member(&self, db: &'db dyn Db, name: &str) -> Type<'db> {
        match self {
            Type::Any => Type::Any,
-            Type::Never => todo!("attribute lookup on Never type"),
+            Type::Never => {
+                // TODO: attribute lookup on Never type
+                Type::Unknown
+            }
            Type::Unknown => Type::Unknown,
            Type::Unbound => Type::Unbound,
-            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::None => {
+                // TODO: attribute lookup on None type
+                Type::Unknown
+            }
+            Type::Function(_) => {
+                // TODO: attribute lookup on function type
+                Type::Unknown
+            }
+            Type::Module(file) => global_symbol_ty(db, *file, name),
            Type::Class(class) => class.class_member(db, name),
            Type::Instance(_) => {
                // TODO MRO? get_own_instance_member, get_instance_member
-                todo!("attribute lookup on Instance type")
+                Type::Unknown
            }
-            Type::Union(union) => union
-                .elements(db)
-                .iter()
-                .fold(UnionBuilder::new(db), |builder, element_ty| {
-                    builder.add(element_ty.member(db, name))
-                })
-                .build(),
+            Type::Union(union) => union.map(db, |element| element.member(db, name)),
            Type::Intersection(_) => {
                // TODO perform the get_member on each type in the intersection
                // TODO return the intersection of those results
-                todo!("attribute lookup on Intersection type")
+                Type::Unknown
            }
            Type::IntLiteral(_) => {
                // TODO raise error
                Type::Unknown
            }
            Type::BooleanLiteral(_) => Type::Unknown,
+            Type::StringLiteral(_) => {
+                // TODO defer to `typing.LiteralString`/`builtins.str` methods
+                // from typeshed's stubs
+                Type::Unknown
+            }
+            Type::LiteralString => {
+                // TODO defer to `typing.LiteralString`/`builtins.str` methods
+                // from typeshed's stubs
+                Type::Unknown
+            }
+            Type::BytesLiteral(_) => {
+                // TODO defer to Type::Instance(<bytes from typeshed>).member
+                Type::Unknown
+            }
+            Type::Tuple(_) => {
+                // TODO: implement tuple methods
+                Type::Unknown
+            }
        }
    }

+    /// Return the type resulting from calling an object of this type.
+    ///
+    /// Returns `None` if `self` is not a callable type.
    #[must_use]
-    pub fn instance(&self) -> Type<'db> {
+    pub fn call(&self, db: &'db dyn Db) -> Option<Type<'db>> {
+        match self {
+            Type::Function(function_type) => Some(function_type.return_type(db)),
+
+            // TODO annotated return type on `__new__` or metaclass `__call__`
+            Type::Class(class) => Some(Type::Instance(*class)),
+
+            // TODO: handle classes which implement the Callable protocol
+            Type::Instance(_instance_ty) => Some(Type::Unknown),
+
+            // `Any` is callable, and its return type is also `Any`.
+            Type::Any => Some(Type::Any),
+
+            Type::Unknown => Some(Type::Unknown),
+
+            // TODO: union and intersection types, if they reduce to `Callable`
+            Type::Union(_) => Some(Type::Unknown),
+            Type::Intersection(_) => Some(Type::Unknown),
+
+            _ => None,
+        }
+    }
+
+    /// Given the type of an object that is iterated over in some way,
+    /// return the type of objects that are yielded by that iteration.
+    ///
+    /// E.g., for the following loop, given the type of `x`, infer the type of `y`:
+    /// ```python
+    /// for y in x:
+    ///     pass
+    /// ```
+    fn iterate(&self, db: &'db dyn Db) -> IterationOutcome<'db> {
+        if let Type::Tuple(tuple_type) = self {
+            return IterationOutcome::Iterable {
+                element_ty: UnionType::from_elements(db, &**tuple_type.elements(db)),
+            };
+        }
+
+        // `self` represents the type of the iterable;
+        // `__iter__` and `__next__` are both looked up on the class of the iterable:
+        let iterable_meta_type = self.to_meta_type(db);
+
+        let dunder_iter_method = iterable_meta_type.member(db, "__iter__");
+        if !dunder_iter_method.is_unbound() {
+            let Some(iterator_ty) = dunder_iter_method.call(db) else {
+                return IterationOutcome::NotIterable {
+                    not_iterable_ty: *self,
+                };
+            };
+
+            let dunder_next_method = iterator_ty.to_meta_type(db).member(db, "__next__");
+            return dunder_next_method
+                .call(db)
+                .map(|element_ty| IterationOutcome::Iterable { element_ty })
+                .unwrap_or(IterationOutcome::NotIterable {
+                    not_iterable_ty: *self,
+                });
+        }
+
+        // Although it's not considered great practice,
+        // classes that define `__getitem__` are also iterable,
+        // even if they do not define `__iter__`.
+        //
+        // TODO(Alex) this is only valid if the `__getitem__` method is annotated as
+        // accepting `int` or `SupportsIndex`
+        let dunder_get_item_method = iterable_meta_type.member(db, "__getitem__");
+
+        dunder_get_item_method
+            .call(db)
+            .map(|element_ty| IterationOutcome::Iterable { element_ty })
+            .unwrap_or(IterationOutcome::NotIterable {
+                not_iterable_ty: *self,
+            })
+    }
+
+    #[must_use]
+    pub fn to_instance(&self, db: &'db dyn Db) -> Type<'db> {
        match self {
            Type::Any => Type::Any,
            Type::Unknown => Type::Unknown,
+            Type::Unbound => Type::Unknown,
+            Type::Never => Type::Never,
            Type::Class(class) => Type::Instance(*class),
-            _ => Type::Unknown, // TODO type errors
+            Type::Union(union) => union.map(db, |element| element.to_instance(db)),
+            // TODO: we can probably do better here: --Alex
+            Type::Intersection(_) => Type::Unknown,
+            // TODO: calling `.to_instance()` on any of these should result in a diagnostic,
+            // since they already indicate that the object is an instance of some kind:
+            Type::BooleanLiteral(_)
+            | Type::BytesLiteral(_)
+            | Type::Function(_)
+            | Type::Instance(_)
+            | Type::Module(_)
+            | Type::IntLiteral(_)
+            | Type::StringLiteral(_)
+            | Type::Tuple(_)
+            | Type::LiteralString
+            | Type::None => Type::Unknown,
+        }
+    }
+
+    /// Given a type that is assumed to represent an instance of a class,
+    /// return a type that represents that class itself.
+    #[must_use]
+    pub fn to_meta_type(&self, db: &'db dyn Db) -> Type<'db> {
+        match self {
+            Type::Unbound => Type::Unbound,
+            Type::Never => Type::Never,
+            Type::Instance(class) => Type::Class(*class),
+            Type::Union(union) => union.map(db, |ty| ty.to_meta_type(db)),
+            Type::BooleanLiteral(_) => builtins_symbol_ty(db, "bool"),
+            Type::BytesLiteral(_) => builtins_symbol_ty(db, "bytes"),
+            Type::IntLiteral(_) => builtins_symbol_ty(db, "int"),
+            Type::Function(_) => types_symbol_ty(db, "FunctionType"),
+            Type::Module(_) => types_symbol_ty(db, "ModuleType"),
+            Type::None => typeshed_symbol_ty(db, "NoneType"),
+            // TODO not accurate if there's a custom metaclass...
+            Type::Class(_) => builtins_symbol_ty(db, "type"),
+            // TODO can we do better here? `type[LiteralString]`?
+            Type::StringLiteral(_) | Type::LiteralString => builtins_symbol_ty(db, "str"),
+            // TODO: `type[Any]`?
+            Type::Any => Type::Any,
+            // TODO: `type[Unknown]`?
+            Type::Unknown => Type::Unknown,
+            // TODO intersections
+            Type::Intersection(_) => Type::Unknown,
+            Type::Tuple(_) => builtins_symbol_ty(db, "tuple"),
+        }
+    }
+}
+
+impl<'db> From<&Type<'db>> for Type<'db> {
+    fn from(value: &Type<'db>) -> Self {
+        *value
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum IterationOutcome<'db> {
+    Iterable { element_ty: Type<'db> },
+    NotIterable { not_iterable_ty: Type<'db> },
+}
+
+impl<'db> IterationOutcome<'db> {
+    fn unwrap_with_diagnostic(
+        self,
+        iterable_node: ast::AnyNodeRef,
+        inference_builder: &mut TypeInferenceBuilder<'db>,
+    ) -> Type<'db> {
+        match self {
+            Self::Iterable { element_ty } => element_ty,
+            Self::NotIterable { not_iterable_ty } => {
+                inference_builder.not_iterable_diagnostic(iterable_node, not_iterable_ty);
+                Type::Unknown
+            }
        }
    }
 }
@@ -255,7 +572,10 @@ impl<'db> Type<'db> {
 #[salsa::interned]
 pub struct FunctionType<'db> {
    /// name of the function at definition
-    pub name: Name,
+    #[return_ref]
+    pub name: ast::name::Name,
+
+    definition: Definition<'db>,

    /// types of all decorators on this function
    decorators: Vec<Type<'db>>,
@@ -265,24 +585,78 @@ impl<'db> FunctionType<'db> {
    pub fn has_decorator(self, db: &dyn Db, decorator: Type<'_>) -> bool {
        self.decorators(db).contains(&decorator)
    }
+
+    /// inferred return type for this function
+    pub fn return_type(&self, db: &'db dyn Db) -> Type<'db> {
+        let definition = self.definition(db);
+        let DefinitionKind::Function(function_stmt_node) = definition.node(db) else {
+            panic!("Function type definition must have `DefinitionKind::Function`")
+        };
+
+        // TODO if a function `bar` is decorated by `foo`,
+        // where `foo` is annotated as returning a type `X` that is a subtype of `Callable`,
+        // we need to infer the return type from `X`'s return annotation
+        // rather than from `bar`'s return annotation
+        // in order to determine the type that `bar` returns
+        if !function_stmt_node.decorator_list.is_empty() {
+            return Type::Unknown;
+        }
+
+        function_stmt_node
+            .returns
+            .as_ref()
+            .map(|returns| {
+                if function_stmt_node.is_async {
+                    // TODO: generic `types.CoroutineType`!
+                    Type::Unknown
+                } else {
+                    definition_expression_ty(db, definition, returns.as_ref())
+                }
+            })
+            .unwrap_or(Type::Unknown)
+    }
 }

 #[salsa::interned]
 pub struct ClassType<'db> {
    /// Name of the class at definition
-    pub name: Name,
+    #[return_ref]
+    pub name: ast::name::Name,

-    /// Types of all class bases
-    bases: Vec<Type<'db>>,
+    definition: Definition<'db>,

    body_scope: ScopeId<'db>,
 }

 impl<'db> ClassType<'db> {
+    /// Return true if this class is a standard library type with given module name and name.
+    #[allow(unused)]
+    pub(crate) fn is_stdlib_symbol(self, db: &'db dyn Db, module_name: &str, name: &str) -> bool {
+        name == self.name(db)
+            && file_to_module(db, self.body_scope(db).file(db)).is_some_and(|module| {
+                module.search_path().is_standard_library() && module.name() == module_name
+            })
+    }
+
+    /// Return an iterator over the types of this class's bases.
+    ///
+    /// # Panics:
+    /// If `definition` is not a `DefinitionKind::Class`.
+    pub fn bases(&self, db: &'db dyn Db) -> impl Iterator<Item = Type<'db>> {
+        let definition = self.definition(db);
+        let DefinitionKind::Class(class_stmt_node) = definition.node(db) else {
+            panic!("Class type definition must have DefinitionKind::Class");
+        };
+        class_stmt_node
+            .bases()
+            .iter()
+            .map(move |base_expr| definition_expression_ty(db, definition, base_expr))
+    }
+
    /// Returns the class member of this class named `name`.
    ///
    /// The member resolves to a member of the class itself or any of its bases.
-    pub fn class_member(self, db: &'db dyn Db, name: &Name) -> Type<'db> {
+    pub fn class_member(self, db: &'db dyn Db, name: &str) -> Type<'db> {
        let member = self.own_class_member(db, name);
        if !member.is_unbound() {
            return member;
@@ -292,12 +666,12 @@ impl<'db> ClassType<'db> {
    }

    /// Returns the inferred type of the class member named `name`.
-    pub fn own_class_member(self, db: &'db dyn Db, name: &Name) -> Type<'db> {
+    pub fn own_class_member(self, db: &'db dyn Db, name: &str) -> Type<'db> {
        let scope = self.body_scope(db);
-        symbol_ty_by_name(db, scope, name)
+        symbol_ty(db, scope, name)
    }

-    pub fn inherited_class_member(self, db: &'db dyn Db, name: &Name) -> Type<'db> {
+    pub fn inherited_class_member(self, db: &'db dyn Db, name: &str) -> Type<'db> {
        for base in self.bases(db) {
            let member = base.member(db, name);
            if !member.is_unbound() {
@@ -312,6 +686,7 @@ impl<'db> ClassType<'db> {
 #[salsa::interned]
 pub struct UnionType<'db> {
    /// The union type includes values in any of these types.
+    #[return_ref]
    elements: FxOrderSet<Type<'db>>,
 }

@@ -319,11 +694,36 @@ impl<'db> UnionType<'db> {
    pub fn contains(&self, db: &'db dyn Db, ty: Type<'db>) -> bool {
        self.elements(db).contains(&ty)
    }
+
+    /// Create a union from a list of elements
+    /// (which may be eagerly simplified into a different variant of [`Type`] altogether)
+    pub fn from_elements<T: Into<Type<'db>>>(
+        db: &'db dyn Db,
+        elements: impl IntoIterator<Item = T>,
+    ) -> Type<'db> {
+        elements
+            .into_iter()
+            .fold(UnionBuilder::new(db), |builder, element| {
+                builder.add(element.into())
+            })
+            .build()
+    }
+
+    /// Apply a transformation function to all elements of the union,
+    /// and create a new union from the resulting set of types
+    pub fn map(
+        &self,
+        db: &'db dyn Db,
+        transform_fn: impl Fn(&Type<'db>) -> Type<'db>,
+    ) -> Type<'db> {
+        Self::from_elements(db, self.elements(db).into_iter().map(transform_fn))
+    }
 }

 #[salsa::interned]
 pub struct IntersectionType<'db> {
    /// The intersection type includes only values in all of these types.
+    #[return_ref]
    positive: FxOrderSet<Type<'db>>,

    /// The intersection type does not include any value in any of these types.
@@ -331,5 +731,125 @@ pub struct IntersectionType<'db> {
    /// Negation types aren't expressible in annotations, and are most likely to arise from type
    /// narrowing along with intersections (e.g. `if not isinstance(...)`), so we represent them
    /// directly in intersections rather than as a separate type.
+    #[return_ref]
    negative: FxOrderSet<Type<'db>>,
 }
+
+#[salsa::interned]
+pub struct StringLiteralType<'db> {
+    #[return_ref]
+    value: Box<str>,
+}
+
+#[salsa::interned]
+pub struct BytesLiteralType<'db> {
+    #[return_ref]
+    value: Box<[u8]>,
+}
+
+#[salsa::interned]
+pub struct TupleType<'db> {
+    #[return_ref]
+    elements: Box<[Type<'db>]>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{builtins_symbol_ty, BytesLiteralType, StringLiteralType, Type, UnionType};
+    use crate::db::tests::TestDb;
+    use crate::program::{Program, SearchPathSettings};
+    use crate::python_version::PythonVersion;
+    use crate::ProgramSettings;
+    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
+    use test_case::test_case;
+
+    fn setup_db() -> TestDb {
+        let db = TestDb::new();
+
+        let src_root = SystemPathBuf::from("/src");
+        db.memory_file_system()
+            .create_directory_all(&src_root)
+            .unwrap();
+
+        Program::from_settings(
+            &db,
+            &ProgramSettings {
+                target_version: PythonVersion::default(),
+                search_paths: SearchPathSettings::new(src_root),
+            },
+        )
+        .expect("Valid search path settings");
+
+        db
+    }
+
+    /// A test representation of a type that can be transformed unambiguously into a real Type,
+    /// given a db.
+    #[derive(Debug)]
+    enum Ty {
+        Never,
+        Unknown,
+        Any,
+        IntLiteral(i64),
+        StringLiteral(&'static str),
+        LiteralString,
+        BytesLiteral(&'static str),
+        BuiltinInstance(&'static str),
+        Union(Vec<Ty>),
+    }
+
+    impl Ty {
+        fn into_type(self, db: &TestDb) -> Type<'_> {
+            match self {
+                Ty::Never => Type::Never,
+                Ty::Unknown => Type::Unknown,
+                Ty::Any => Type::Any,
+                Ty::IntLiteral(n) => Type::IntLiteral(n),
+                Ty::StringLiteral(s) => {
+                    Type::StringLiteral(StringLiteralType::new(db, (*s).into()))
+                }
+                Ty::LiteralString => Type::LiteralString,
+                Ty::BytesLiteral(s) => {
+                    Type::BytesLiteral(BytesLiteralType::new(db, s.as_bytes().into()))
+                }
+                Ty::BuiltinInstance(s) => builtins_symbol_ty(db, s).to_instance(db),
+                Ty::Union(tys) => {
+                    UnionType::from_elements(db, tys.into_iter().map(|ty| ty.into_type(db)))
+                }
+            }
+        }
+    }
+
+    #[test_case(Ty::Unknown, Ty::IntLiteral(1))]
+    #[test_case(Ty::Any, Ty::IntLiteral(1))]
+    #[test_case(Ty::Never, Ty::IntLiteral(1))]
+    #[test_case(Ty::IntLiteral(1), Ty::Unknown)]
+    #[test_case(Ty::IntLiteral(1), Ty::Any)]
+    #[test_case(Ty::IntLiteral(1), Ty::BuiltinInstance("int"))]
+    #[test_case(Ty::StringLiteral("foo"), Ty::BuiltinInstance("str"))]
+    #[test_case(Ty::StringLiteral("foo"), Ty::LiteralString)]
+    #[test_case(Ty::LiteralString, Ty::BuiltinInstance("str"))]
+    #[test_case(Ty::BytesLiteral("foo"), Ty::BuiltinInstance("bytes"))]
+    fn is_assignable_to(from: Ty, to: Ty) {
+        let db = setup_db();
+        assert!(from.into_type(&db).is_assignable_to(&db, to.into_type(&db)));
+    }
+
+    #[test_case(Ty::IntLiteral(1), Ty::BuiltinInstance("str"))]
+    #[test_case(Ty::BuiltinInstance("int"), Ty::BuiltinInstance("str"))]
+    #[test_case(Ty::BuiltinInstance("int"), Ty::IntLiteral(1))]
+    fn is_not_assignable_to(from: Ty, to: Ty) {
+        let db = setup_db();
+        assert!(!from.into_type(&db).is_assignable_to(&db, to.into_type(&db)));
+    }
+
+    #[test_case(
+        Ty::Union(vec![Ty::IntLiteral(1), Ty::IntLiteral(2)]),
+        Ty::Union(vec![Ty::IntLiteral(1), Ty::IntLiteral(2)])
+    )]
+    fn is_equivalent_to(from: Ty, to: Ty) {
+        let db = setup_db();
+
+        assert!(from.into_type(&db).is_equivalent_to(&db, to.into_type(&db)));
+    }
+}
--- a/crates/red_knot_python_semantic/src/types/builder.rs
+++ b/crates/red_knot_python_semantic/src/types/builder.rs
@@ -25,8 +25,9 @@
 //!   * No type in an intersection can be a supertype of any other type in the intersection (just
 //!     eliminate the supertype from the intersection).
 //!   * An intersection containing two non-overlapping types should simplify to [`Type::Never`].
-use crate::types::{IntersectionType, Type, UnionType};
+use crate::types::{builtins_symbol_ty, IntersectionType, Type, UnionType};
 use crate::{Db, FxOrderSet};
+use ordermap::set::MutableValues;

 pub(crate) struct UnionBuilder<'db> {
    elements: FxOrderSet<Type<'db>>,
@@ -45,7 +46,7 @@ impl<'db> UnionBuilder<'db> {
    pub(crate) fn add(mut self, ty: Type<'db>) -> Self {
        match ty {
            Type::Union(union) => {
-                self.elements.extend(&union.elements(self.db));
+                self.elements.extend(union.elements(self.db));
            }
            Type::Never => {}
            _ => {
@@ -56,11 +57,36 @@ impl<'db> UnionBuilder<'db> {
        self
    }

-    pub(crate) fn build(self) -> Type<'db> {
+    /// Performs the following normalizations:
+    ///     - Replaces `Literal[True,False]` with `bool`.
+    ///     - TODO For enums `E` with members `X1`,...,`Xn`, replaces
+    ///     `Literal[E.X1,...,E.Xn]` with `E`.
+    fn simplify(&mut self) {
+        if let Some(true_index) = self.elements.get_index_of(&Type::BooleanLiteral(true)) {
+            if self.elements.contains(&Type::BooleanLiteral(false)) {
+                *self.elements.get_index_mut2(true_index).unwrap() =
+                    builtins_symbol_ty(self.db, "bool");
+                self.elements.remove(&Type::BooleanLiteral(false));
+            }
+        }
+    }
+
+    pub(crate) fn build(mut self) -> Type<'db> {
        match self.elements.len() {
            0 => Type::Never,
            1 => self.elements[0],
-            _ => Type::Union(UnionType::new(self.db, self.elements)),
+            _ => {
+                self.simplify();
+
+                match self.elements.len() {
+                    0 => Type::Never,
+                    1 => self.elements[0],
+                    _ => {
+                        self.elements.shrink_to_fit();
+                        Type::Union(UnionType::new(self.db, self.elements))
+                    }
+                }
+            }
        }
    }
 }
@@ -143,11 +169,12 @@ impl<'db> IntersectionBuilder<'db> {
        if self.intersections.len() == 1 {
            self.intersections.pop().unwrap().build(self.db)
        } else {
-            let mut builder = UnionBuilder::new(self.db);
-            for inner in self.intersections {
-                builder = builder.add(inner.build(self.db));
-            }
-            builder.build()
+            UnionType::from_elements(
+                self.db,
+                self.intersections
+                    .into_iter()
+                    .map(|inner| inner.build(self.db)),
+            )
        }
    }
 }
@@ -245,27 +272,46 @@ impl<'db> InnerIntersectionBuilder<'db> {

 #[cfg(test)]
 mod tests {
-    use super::{IntersectionBuilder, IntersectionType, Type, UnionBuilder, UnionType};
+    use super::{IntersectionBuilder, IntersectionType, Type, UnionType};
    use crate::db::tests::TestDb;
-
-    fn setup_db() -> TestDb {
-        TestDb::new()
-    }
+    use crate::program::{Program, SearchPathSettings};
+    use crate::python_version::PythonVersion;
+    use crate::types::{builtins_symbol_ty, UnionBuilder};
+    use crate::ProgramSettings;
+    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};

    impl<'db> UnionType<'db> {
        fn elements_vec(self, db: &'db TestDb) -> Vec<Type<'db>> {
-            self.elements(db).into_iter().collect()
+            self.elements(db).into_iter().copied().collect()
        }
    }

+    fn setup_db() -> TestDb {
+        let db = TestDb::new();
+
+        let src_root = SystemPathBuf::from("/src");
+        db.memory_file_system()
+            .create_directory_all(&src_root)
+            .unwrap();
+
+        Program::from_settings(
+            &db,
+            &ProgramSettings {
+                target_version: PythonVersion::default(),
+                search_paths: SearchPathSettings::new(src_root),
+            },
+        )
+        .expect("Valid search path settings");
+
+        db
+    }
+
    #[test]
    fn build_union() {
        let db = setup_db();
        let t0 = Type::IntLiteral(0);
        let t1 = Type::IntLiteral(1);
-        let Type::Union(union) = UnionBuilder::new(&db).add(t0).add(t1).build() else {
-            panic!("expected a union");
-        };
+        let union = UnionType::from_elements(&db, [t0, t1]).expect_union();

        assert_eq!(union.elements_vec(&db), &[t0, t1]);
    }
@@ -274,8 +320,7 @@ mod tests {
    fn build_union_single() {
        let db = setup_db();
        let t0 = Type::IntLiteral(0);
-        let ty = UnionBuilder::new(&db).add(t0).build();
-
+        let ty = UnionType::from_elements(&db, [t0]);
        assert_eq!(ty, t0);
    }

@@ -283,7 +328,6 @@ mod tests {
    fn build_union_empty() {
        let db = setup_db();
        let ty = UnionBuilder::new(&db).build();
-
        assert_eq!(ty, Type::Never);
    }

@@ -291,32 +335,46 @@ mod tests {
    fn build_union_never() {
        let db = setup_db();
        let t0 = Type::IntLiteral(0);
-        let ty = UnionBuilder::new(&db).add(t0).add(Type::Never).build();
-
+        let ty = UnionType::from_elements(&db, [t0, Type::Never]);
        assert_eq!(ty, t0);
    }

+    #[test]
+    fn build_union_bool() {
+        let db = setup_db();
+        let bool_ty = builtins_symbol_ty(&db, "bool");
+
+        let t0 = Type::BooleanLiteral(true);
+        let t1 = Type::BooleanLiteral(true);
+        let t2 = Type::BooleanLiteral(false);
+        let t3 = Type::IntLiteral(17);
+
+        let union = UnionType::from_elements(&db, [t0, t1, t3]).expect_union();
+        assert_eq!(union.elements_vec(&db), &[t0, t3]);
+
+        let union = UnionType::from_elements(&db, [t0, t1, t2, t3]).expect_union();
+        assert_eq!(union.elements_vec(&db), &[bool_ty, t3]);
+    }
+
    #[test]
    fn build_union_flatten() {
        let db = setup_db();
        let t0 = Type::IntLiteral(0);
        let t1 = Type::IntLiteral(1);
        let t2 = Type::IntLiteral(2);
-        let u1 = UnionBuilder::new(&db).add(t0).add(t1).build();
-        let Type::Union(union) = UnionBuilder::new(&db).add(u1).add(t2).build() else {
-            panic!("expected a union");
-        };
+        let u1 = UnionType::from_elements(&db, [t0, t1]);
+        let union = UnionType::from_elements(&db, [u1, t2]).expect_union();

        assert_eq!(union.elements_vec(&db), &[t0, t1, t2]);
    }

    impl<'db> IntersectionType<'db> {
        fn pos_vec(self, db: &'db TestDb) -> Vec<Type<'db>> {
-            self.positive(db).into_iter().collect()
+            self.positive(db).into_iter().copied().collect()
        }

        fn neg_vec(self, db: &'db TestDb) -> Vec<Type<'db>> {
-            self.negative(db).into_iter().collect()
+            self.negative(db).into_iter().copied().collect()
        }
    }

@@ -325,16 +383,14 @@ mod tests {
        let db = setup_db();
        let t0 = Type::IntLiteral(0);
        let ta = Type::Any;
-        let Type::Intersection(inter) = IntersectionBuilder::new(&db)
+        let intersection = IntersectionBuilder::new(&db)
            .add_positive(ta)
            .add_negative(t0)
            .build()
-        else {
-            panic!("expected to be an intersection");
-        };
+            .expect_intersection();

-        assert_eq!(inter.pos_vec(&db), &[ta]);
-        assert_eq!(inter.neg_vec(&db), &[t0]);
+        assert_eq!(intersection.pos_vec(&db), &[ta]);
+        assert_eq!(intersection.neg_vec(&db), &[t0]);
    }

    #[test]
@@ -347,16 +403,14 @@ mod tests {
            .add_positive(ta)
            .add_negative(t1)
            .build();
-        let Type::Intersection(inter) = IntersectionBuilder::new(&db)
+        let intersection = IntersectionBuilder::new(&db)
            .add_positive(t2)
            .add_positive(i0)
            .build()
-        else {
-            panic!("expected to be an intersection");
-        };
+            .expect_intersection();

-        assert_eq!(inter.pos_vec(&db), &[t2, ta]);
-        assert_eq!(inter.neg_vec(&db), &[t1]);
+        assert_eq!(intersection.pos_vec(&db), &[t2, ta]);
+        assert_eq!(intersection.neg_vec(&db), &[t1]);
    }

    #[test]
@@ -369,16 +423,14 @@ mod tests {
            .add_positive(ta)
            .add_negative(t1)
            .build();
-        let Type::Intersection(inter) = IntersectionBuilder::new(&db)
+        let intersection = IntersectionBuilder::new(&db)
            .add_positive(t2)
            .add_negative(i0)
            .build()
-        else {
-            panic!("expected to be an intersection");
-        };
+            .expect_intersection();

-        assert_eq!(inter.pos_vec(&db), &[t2, t1]);
-        assert_eq!(inter.neg_vec(&db), &[ta]);
+        assert_eq!(intersection.pos_vec(&db), &[t2, t1]);
+        assert_eq!(intersection.neg_vec(&db), &[ta]);
    }

    #[test]
@@ -387,15 +439,13 @@ mod tests {
        let t0 = Type::IntLiteral(0);
        let t1 = Type::IntLiteral(1);
        let ta = Type::Any;
-        let u0 = UnionBuilder::new(&db).add(t0).add(t1).build();
+        let u0 = UnionType::from_elements(&db, [t0, t1]);

-        let Type::Union(union) = IntersectionBuilder::new(&db)
+        let union = IntersectionBuilder::new(&db)
            .add_positive(ta)
            .add_positive(u0)
            .build()
-        else {
-            panic!("expected a union");
-        };
+            .expect_union();
        let [Type::Intersection(i0), Type::Intersection(i1)] = union.elements_vec(&db)[..] else {
            panic!("expected a union of two intersections");
        };
--- a/crates/red_knot_python_semantic/src/types/diagnostic.rs
+++ b/crates/red_knot_python_semantic/src/types/diagnostic.rs
@@ -0,0 +1,111 @@
+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/display.rs
+++ b/crates/red_knot_python_semantic/src/types/display.rs
@@ -2,13 +2,20 @@

 use std::fmt::{Display, Formatter};

+use ruff_python_ast::str::Quote;
+use ruff_python_literal::escape::AsciiEscape;
+
 use crate::types::{IntersectionType, Type, UnionType};
-use crate::Db;
+use crate::{Db, FxOrderMap};

 impl<'db> Type<'db> {
    pub fn display(&'db self, db: &'db dyn Db) -> DisplayType<'db> {
        DisplayType { ty: self, db }
    }
+
+    fn representation(&'db self, db: &'db dyn Db) -> DisplayRepresentation<'db> {
+        DisplayRepresentation { db, ty: self }
+    }
 }

 #[derive(Copy, Clone)]
@@ -18,6 +25,39 @@ pub struct DisplayType<'db> {
 }

 impl Display for DisplayType<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let representation = self.ty.representation(self.db);
+        if matches!(
+            self.ty,
+            Type::IntLiteral(_)
+                | Type::BooleanLiteral(_)
+                | Type::StringLiteral(_)
+                | Type::BytesLiteral(_)
+                | Type::Class(_)
+                | Type::Function(_)
+        ) {
+            write!(f, "Literal[{representation}]",)
+        } else {
+            representation.fmt(f)
+        }
+    }
+}
+
+impl std::fmt::Debug for DisplayType<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
+    }
+}
+
+/// Writes the string representation of a type, which is the value displayed either as
+/// `Literal[<repr>]` or `Literal[<repr1>, <repr2>]` for literal types or as `<repr>` for
+/// non literals
+struct DisplayRepresentation<'db> {
+    ty: &'db Type<'db>,
+    db: &'db dyn Db,
+}
+
+impl std::fmt::Display for DisplayRepresentation<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self.ty {
            Type::Any => f.write_str("Any"),
@@ -29,25 +69,44 @@ impl Display for DisplayType<'_> {
                write!(f, "<module '{:?}'>", file.path(self.db))
            }
            // TODO functions and classes should display using a fully qualified name
-            Type::Class(class) => write!(f, "Literal[{}]", class.name(self.db)),
-            Type::Instance(class) => f.write_str(&class.name(self.db)),
-            Type::Function(function) => write!(f, "Literal[{}]", function.name(self.db)),
+            Type::Class(class) => f.write_str(class.name(self.db)),
+            Type::Instance(class) => f.write_str(class.name(self.db)),
+            Type::Function(function) => f.write_str(function.name(self.db)),
            Type::Union(union) => union.display(self.db).fmt(f),
            Type::Intersection(intersection) => intersection.display(self.db).fmt(f),
-            Type::IntLiteral(n) => write!(f, "Literal[{n}]"),
-            Type::BooleanLiteral(boolean) => {
-                write!(f, "Literal[{}]", if *boolean { "True" } else { "False" })
+            Type::IntLiteral(n) => write!(f, "{n}"),
+            Type::BooleanLiteral(boolean) => f.write_str(if *boolean { "True" } else { "False" }),
+            Type::StringLiteral(string) => {
+                write!(f, r#""{}""#, string.value(self.db).replace('"', r#"\""#))
+            }
+            Type::LiteralString => f.write_str("LiteralString"),
+            Type::BytesLiteral(bytes) => {
+                let escape =
+                    AsciiEscape::with_preferred_quote(bytes.value(self.db).as_ref(), Quote::Double);
+
+                escape.bytes_repr().write(f)
+            }
+            Type::Tuple(tuple) => {
+                f.write_str("tuple[")?;
+                let elements = tuple.elements(self.db);
+                if elements.is_empty() {
+                    f.write_str("()")?;
+                } else {
+                    let mut first = true;
+                    for element in &**elements {
+                        if !first {
+                            f.write_str(", ")?;
+                        }
+                        first = false;
+                        element.display(self.db).fmt(f)?;
+                    }
+                }
+                f.write_str("]")
            }
        }
    }
 }

-impl std::fmt::Debug for DisplayType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Display::fmt(self, f)
-    }
-}
-
 impl<'db> UnionType<'db> {
    fn display(&'db self, db: &'db dyn Db) -> DisplayUnionType<'db> {
        DisplayUnionType { db, ty: self }
@@ -61,45 +120,58 @@ struct DisplayUnionType<'db> {

 impl Display for DisplayUnionType<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let union = self.ty;
+        let elements = self.ty.elements(self.db);

-        let (int_literals, other_types): (Vec<Type>, Vec<Type>) = union
-            .elements(self.db)
-            .iter()
-            .copied()
-            .partition(|ty| matches!(ty, Type::IntLiteral(_)));
+        // Group literal types by kind.
+        let mut grouped_literals = FxOrderMap::default();
+
+        for element in elements {
+            if let Ok(literal_kind) = LiteralTypeKind::try_from(*element) {
+                grouped_literals
+                    .entry(literal_kind)
+                    .or_insert_with(Vec::new)
+                    .push(*element);
+            }
+        }

        let mut first = true;
-        if !int_literals.is_empty() {
-            f.write_str("Literal[")?;
-            let mut nums: Vec<_> = int_literals
-                .into_iter()
-                .filter_map(|ty| {
-                    if let Type::IntLiteral(n) = ty {
-                        Some(n)
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-            nums.sort_unstable();
-            for num in nums {
+
+        // Print all types, but write all literals together (while preserving their position).
+        for ty in elements {
+            if let Ok(literal_kind) = LiteralTypeKind::try_from(*ty) {
+                let Some(mut literals) = grouped_literals.remove(&literal_kind) else {
+                    continue;
+                };
+
                if !first {
-                    f.write_str(", ")?;
+                    f.write_str(" | ")?;
+                };
+
+                f.write_str("Literal[")?;
+
+                if literal_kind == LiteralTypeKind::IntLiteral {
+                    literals.sort_unstable_by_key(|ty| ty.expect_int_literal());
                }
-                write!(f, "{num}")?;
-                first = false;
+
+                for (i, literal_ty) in literals.iter().enumerate() {
+                    if i > 0 {
+                        f.write_str(", ")?;
+                    }
+                    literal_ty.representation(self.db).fmt(f)?;
+                }
+                f.write_str("]")?;
+            } else {
+                if !first {
+                    f.write_str(" | ")?;
+                };
+
+                ty.display(self.db).fmt(f)?;
            }
-            f.write_str("]")?;
+
+            first = false;
        }

-        for ty in other_types {
-            if !first {
-                f.write_str(" | ")?;
-            };
-            first = false;
-            write!(f, "{}", ty.display(self.db))?;
-        }
+        debug_assert!(grouped_literals.is_empty());

        Ok(())
    }
@@ -111,6 +183,30 @@ impl std::fmt::Debug for DisplayUnionType<'_> {
    }
 }

+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+enum LiteralTypeKind {
+    Class,
+    Function,
+    IntLiteral,
+    StringLiteral,
+    BytesLiteral,
+}
+
+impl TryFrom<Type<'_>> for LiteralTypeKind {
+    type Error = ();
+
+    fn try_from(value: Type<'_>) -> Result<Self, Self::Error> {
+        match value {
+            Type::Class(_) => Ok(Self::Class),
+            Type::Function(_) => Ok(Self::Function),
+            Type::IntLiteral(_) => Ok(Self::IntLiteral),
+            Type::StringLiteral(_) => Ok(Self::StringLiteral),
+            Type::BytesLiteral(_) => Ok(Self::BytesLiteral),
+            _ => Err(()),
+        }
+    }
+}
+
 impl<'db> IntersectionType<'db> {
    fn display(&'db self, db: &'db dyn Db) -> DisplayIntersectionType<'db> {
        DisplayIntersectionType { db, ty: self }
@@ -150,3 +246,86 @@ impl std::fmt::Debug for DisplayIntersectionType<'_> {
        std::fmt::Display::fmt(self, f)
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use ruff_db::files::system_path_to_file;
+    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
+
+    use crate::db::tests::TestDb;
+    use crate::types::{global_symbol_ty, BytesLiteralType, StringLiteralType, Type, UnionType};
+    use crate::{Program, ProgramSettings, PythonVersion, SearchPathSettings};
+
+    fn setup_db() -> TestDb {
+        let db = TestDb::new();
+
+        let src_root = SystemPathBuf::from("/src");
+        db.memory_file_system()
+            .create_directory_all(&src_root)
+            .unwrap();
+
+        Program::from_settings(
+            &db,
+            &ProgramSettings {
+                target_version: PythonVersion::default(),
+                search_paths: SearchPathSettings::new(src_root),
+            },
+        )
+        .expect("Valid search path settings");
+
+        db
+    }
+
+    #[test]
+    fn test_condense_literal_display_by_type() -> anyhow::Result<()> {
+        let mut db = setup_db();
+
+        db.write_dedented(
+            "src/main.py",
+            "
+            def foo(x: int) -> int:
+                return x + 1
+
+            def bar(s: str) -> str:
+                return s
+
+            class A: ...
+            class B: ...
+            ",
+        )?;
+        let mod_file = system_path_to_file(&db, "src/main.py").expect("Expected file to exist.");
+
+        let union_elements = &[
+            Type::Unknown,
+            Type::IntLiteral(-1),
+            global_symbol_ty(&db, mod_file, "A"),
+            Type::StringLiteral(StringLiteralType::new(&db, Box::from("A"))),
+            Type::BytesLiteral(BytesLiteralType::new(&db, Box::from([0]))),
+            Type::BytesLiteral(BytesLiteralType::new(&db, Box::from([7]))),
+            Type::IntLiteral(0),
+            Type::IntLiteral(1),
+            Type::StringLiteral(StringLiteralType::new(&db, Box::from("B"))),
+            global_symbol_ty(&db, mod_file, "foo"),
+            global_symbol_ty(&db, mod_file, "bar"),
+            global_symbol_ty(&db, mod_file, "B"),
+            Type::BooleanLiteral(true),
+            Type::None,
+        ];
+        let union = UnionType::from_elements(&db, union_elements).expect_union();
+        let display = format!("{}", union.display(&db));
+        assert_eq!(
+            display,
+            concat!(
+                "Unknown | ",
+                "Literal[-1, 0, 1] | ",
+                "Literal[A, B] | ",
+                "Literal[\"A\", \"B\"] | ",
+                "Literal[b\"\\x00\", b\"\\x07\"] | ",
+                "Literal[foo, bar] | ",
+                "Literal[True] | ",
+                "None"
+            )
+        );
+        Ok(())
+    }
+}
--- 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,9 +1,10 @@
 use crate::semantic_index::ast_ids::HasScopedAstId;
+use crate::semantic_index::constraint::{Constraint, PatternConstraint};
 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::types::{infer_expression_types, IntersectionBuilder, Type};
 use crate::Db;
 use ruff_python_ast as ast;
 use rustc_hash::FxHashMap;
@@ -27,62 +28,114 @@ use std::sync::Arc;
 /// 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>,
+    constraint: Constraint<'db>,
    definition: Definition<'db>,
 ) -> Option<Type<'db>> {
-    all_narrowing_constraints(db, test)
-        .get(&definition.symbol(db))
-        .copied()
+    match constraint {
+        Constraint::Expression(expression) => {
+            all_narrowing_constraints_for_expression(db, expression)
+                .get(&definition.symbol(db))
+                .copied()
+        }
+        Constraint::Pattern(pattern) => all_narrowing_constraints_for_pattern(db, pattern)
+            .get(&definition.symbol(db))
+            .copied(),
+    }
 }

 #[salsa::tracked(return_ref)]
-fn all_narrowing_constraints<'db>(
+fn all_narrowing_constraints_for_pattern<'db>(
    db: &'db dyn Db,
-    test: Expression<'db>,
+    pattern: PatternConstraint<'db>,
 ) -> NarrowingConstraints<'db> {
-    NarrowingConstraintsBuilder::new(db, test).finish()
+    NarrowingConstraintsBuilder::new(db, Constraint::Pattern(pattern)).finish()
+}
+
+#[salsa::tracked(return_ref)]
+fn all_narrowing_constraints_for_expression<'db>(
+    db: &'db dyn Db,
+    expression: Expression<'db>,
+) -> NarrowingConstraints<'db> {
+    NarrowingConstraintsBuilder::new(db, Constraint::Expression(expression)).finish()
 }

 type NarrowingConstraints<'db> = FxHashMap<ScopedSymbolId, Type<'db>>;

 struct NarrowingConstraintsBuilder<'db> {
    db: &'db dyn Db,
-    expression: Expression<'db>,
+    constraint: Constraint<'db>,
    constraints: NarrowingConstraints<'db>,
 }

 impl<'db> NarrowingConstraintsBuilder<'db> {
-    fn new(db: &'db dyn Db, expression: Expression<'db>) -> Self {
+    fn new(db: &'db dyn Db, constraint: Constraint<'db>) -> Self {
        Self {
            db,
-            expression,
+            constraint,
            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);
+        match self.constraint {
+            Constraint::Expression(expression) => self.evaluate_expression_constraint(expression),
+            Constraint::Pattern(pattern) => self.evaluate_pattern_constraint(pattern),
        }
-        // TODO other test expression kinds

        self.constraints.shrink_to_fit();
        self.constraints
    }

+    fn evaluate_expression_constraint(&mut self, expression: Expression<'db>) {
+        if let ast::Expr::Compare(expr_compare) = expression.node_ref(self.db).node() {
+            self.add_expr_compare(expr_compare, expression);
+        }
+        // TODO other test expression kinds
+    }
+
+    fn evaluate_pattern_constraint(&mut self, pattern: PatternConstraint<'db>) {
+        let subject = pattern.subject(self.db);
+
+        match pattern.pattern(self.db).node() {
+            ast::Pattern::MatchValue(_) => {
+                // TODO
+            }
+            ast::Pattern::MatchSingleton(singleton_pattern) => {
+                self.add_match_pattern_singleton(subject, singleton_pattern);
+            }
+            ast::Pattern::MatchSequence(_) => {
+                // TODO
+            }
+            ast::Pattern::MatchMapping(_) => {
+                // TODO
+            }
+            ast::Pattern::MatchClass(_) => {
+                // TODO
+            }
+            ast::Pattern::MatchStar(_) => {
+                // TODO
+            }
+            ast::Pattern::MatchAs(_) => {
+                // TODO
+            }
+            ast::Pattern::MatchOr(_) => {
+                // TODO
+            }
+        }
+    }
+
    fn symbols(&self) -> Arc<SymbolTable> {
        symbol_table(self.db, self.scope())
    }

    fn scope(&self) -> ScopeId<'db> {
-        self.expression.scope(self.db)
+        match self.constraint {
+            Constraint::Expression(expression) => expression.scope(self.db),
+            Constraint::Pattern(pattern) => pattern.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) {
+    fn add_expr_compare(&mut self, expr_compare: &ast::ExprCompare, expression: Expression<'db>) {
        let ast::ExprCompare {
            range: _,
            left,
@@ -99,7 +152,7 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
            // 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();
+            let inference = infer_expression_types(self.db, expression);
            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) {
@@ -112,4 +165,22 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
            }
        }
    }
+
+    fn add_match_pattern_singleton(
+        &mut self,
+        subject: &ast::Expr,
+        pattern: &ast::PatternMatchSingleton,
+    ) {
+        if let Some(ast::ExprName { id, .. }) = subject.as_name_expr() {
+            // SAFETY: we should always have a symbol for every Name node.
+            let symbol = self.symbols().symbol_id_by_name(id).unwrap();
+
+            let ty = match pattern.value {
+                ast::Singleton::None => Type::None,
+                ast::Singleton::True => Type::BooleanLiteral(true),
+                ast::Singleton::False => Type::BooleanLiteral(false),
+            };
+            self.constraints.insert(symbol, ty);
+        }
+    }
 }
--- 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
+23d867efb2df6de5600f64656f1aa8a83e06109e
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_ast.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_ast.pyi
@@ -1,7 +1,7 @@
 import sys
 import typing_extensions
 from typing import Any, ClassVar, Generic, Literal, TypedDict, overload
-from typing_extensions import Unpack
+from typing_extensions import Self, Unpack

 PyCF_ONLY_AST: Literal[1024]
 PyCF_TYPE_COMMENTS: Literal[4096]
@@ -34,6 +34,9 @@ class AST:
    if sys.version_info >= (3, 13):
        _field_types: ClassVar[dict[str, Any]]

+    if sys.version_info >= (3, 14):
+        def __replace__(self) -> Self: ...
+
 class mod(AST): ...
 class type_ignore(AST): ...

@@ -44,6 +47,9 @@ class TypeIgnore(type_ignore):
    tag: str
    def __init__(self, lineno: int, tag: str) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, lineno: int = ..., tag: str = ...) -> Self: ...
+
 class FunctionType(mod):
    if sys.version_info >= (3, 10):
        __match_args__ = ("argtypes", "returns")
@@ -57,6 +63,9 @@ class FunctionType(mod):
    else:
        def __init__(self, argtypes: list[expr], returns: expr) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, argtypes: list[expr] = ..., returns: expr = ...) -> Self: ...
+
 class Module(mod):
    if sys.version_info >= (3, 10):
        __match_args__ = ("body", "type_ignores")
@@ -67,6 +76,9 @@ class Module(mod):
    else:
        def __init__(self, body: list[stmt], type_ignores: list[TypeIgnore]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, body: list[stmt] = ..., type_ignores: list[TypeIgnore] = ...) -> Self: ...
+
 class Interactive(mod):
    if sys.version_info >= (3, 10):
        __match_args__ = ("body",)
@@ -76,12 +88,18 @@ class Interactive(mod):
    else:
        def __init__(self, body: list[stmt]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, body: list[stmt] = ...) -> Self: ...
+
 class Expression(mod):
    if sys.version_info >= (3, 10):
        __match_args__ = ("body",)
    body: expr
    def __init__(self, body: expr) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, body: expr = ...) -> Self: ...
+
 class stmt(AST):
    lineno: int
    col_offset: int
@@ -89,6 +107,9 @@ class stmt(AST):
    end_col_offset: int | None
    def __init__(self, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class FunctionDef(stmt):
    if sys.version_info >= (3, 12):
        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment", "type_params")
@@ -152,6 +173,19 @@ class FunctionDef(stmt):
            **kwargs: Unpack[_Attributes],
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            name: _Identifier = ...,
+            args: arguments = ...,
+            body: list[stmt] = ...,
+            decorator_list: list[expr] = ...,
+            returns: expr | None = ...,
+            type_comment: str | None = ...,
+            type_params: list[type_param] = ...,
+        ) -> Self: ...
+
 class AsyncFunctionDef(stmt):
    if sys.version_info >= (3, 12):
        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment", "type_params")
@@ -215,6 +249,19 @@ class AsyncFunctionDef(stmt):
            **kwargs: Unpack[_Attributes],
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            name: _Identifier = ...,
+            args: arguments = ...,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None,
+            type_comment: str | None,
+            type_params: list[type_param],
+        ) -> Self: ...
+
 class ClassDef(stmt):
    if sys.version_info >= (3, 12):
        __match_args__ = ("name", "bases", "keywords", "body", "decorator_list", "type_params")
@@ -260,12 +307,28 @@ class ClassDef(stmt):
            **kwargs: Unpack[_Attributes],
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            name: _Identifier,
+            bases: list[expr],
+            keywords: list[keyword],
+            body: list[stmt],
+            decorator_list: list[expr],
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
 class Return(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("value",)
    value: expr | None
    def __init__(self, value: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr | None = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Delete(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("targets",)
@@ -275,6 +338,9 @@ class Delete(stmt):
    else:
        def __init__(self, targets: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, targets: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Assign(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("targets", "value", "type_comment")
@@ -295,6 +361,11 @@ class Assign(stmt):
            self, targets: list[expr], value: expr, type_comment: str | None = None, **kwargs: Unpack[_Attributes]
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, targets: list[expr] = ..., value: expr = ..., type_comment: str | None = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class AugAssign(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("target", "op", "value")
@@ -305,6 +376,16 @@ class AugAssign(stmt):
        self, target: Name | Attribute | Subscript, op: operator, value: expr, **kwargs: Unpack[_Attributes]
    ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            target: Name | Attribute | Subscript = ...,
+            op: operator = ...,
+            value: expr = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
 class AnnAssign(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("target", "annotation", "value", "simple")
@@ -332,6 +413,17 @@ class AnnAssign(stmt):
        **kwargs: Unpack[_Attributes],
    ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            target: Name | Attribute | Subscript = ...,
+            annotation: expr = ...,
+            value: expr | None = ...,
+            simple: int = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
 class For(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("target", "iter", "body", "orelse", "type_comment")
@@ -361,6 +453,18 @@ class For(stmt):
            **kwargs: Unpack[_Attributes],
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            target: expr = ...,
+            iter: expr = ...,
+            body: list[stmt] = ...,
+            orelse: list[stmt] = ...,
+            type_comment: str | None = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
 class AsyncFor(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("target", "iter", "body", "orelse", "type_comment")
@@ -390,6 +494,18 @@ class AsyncFor(stmt):
            **kwargs: Unpack[_Attributes],
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            target: expr = ...,
+            iter: expr = ...,
+            body: list[stmt] = ...,
+            orelse: list[stmt] = ...,
+            type_comment: str | None = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
 class While(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("test", "body", "orelse")
@@ -403,6 +519,9 @@ class While(stmt):
    else:
        def __init__(self, test: expr, body: list[stmt], orelse: list[stmt], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, test: expr, body: list[stmt], orelse: list[stmt], **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class If(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("test", "body", "orelse")
@@ -416,6 +535,11 @@ class If(stmt):
    else:
        def __init__(self, test: expr, body: list[stmt], orelse: list[stmt], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, test: expr = ..., body: list[stmt] = ..., orelse: list[stmt] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class With(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("items", "body", "type_comment")
@@ -435,6 +559,16 @@ class With(stmt):
            self, items: list[withitem], body: list[stmt], type_comment: str | None = None, **kwargs: Unpack[_Attributes]
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            items: list[withitem] = ...,
+            body: list[stmt] = ...,
+            type_comment: str | None = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
 class AsyncWith(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("items", "body", "type_comment")
@@ -454,6 +588,16 @@ class AsyncWith(stmt):
            self, items: list[withitem], body: list[stmt], type_comment: str | None = None, **kwargs: Unpack[_Attributes]
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            items: list[withitem] = ...,
+            body: list[stmt] = ...,
+            type_comment: str | None = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
 class Raise(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("exc", "cause")
@@ -461,6 +605,9 @@ class Raise(stmt):
    cause: expr | None
    def __init__(self, exc: expr | None = None, cause: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, exc: expr | None = ..., cause: expr | None = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Try(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("body", "handlers", "orelse", "finalbody")
@@ -487,6 +634,17 @@ class Try(stmt):
            **kwargs: Unpack[_Attributes],
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            body: list[stmt] = ...,
+            handlers: list[ExceptHandler] = ...,
+            orelse: list[stmt] = ...,
+            finalbody: list[stmt] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
 if sys.version_info >= (3, 11):
    class TryStar(stmt):
        __match_args__ = ("body", "handlers", "orelse", "finalbody")
@@ -513,6 +671,17 @@ if sys.version_info >= (3, 11):
                **kwargs: Unpack[_Attributes],
            ) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self,
+                *,
+                body: list[stmt] = ...,
+                handlers: list[ExceptHandler] = ...,
+                orelse: list[stmt] = ...,
+                finalbody: list[stmt] = ...,
+                **kwargs: Unpack[_Attributes],
+            ) -> Self: ...
+
 class Assert(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("test", "msg")
@@ -520,6 +689,9 @@ class Assert(stmt):
    msg: expr | None
    def __init__(self, test: expr, msg: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, test: expr, msg: expr | None, **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Import(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("names",)
@@ -529,6 +701,9 @@ class Import(stmt):
    else:
        def __init__(self, names: list[alias], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, names: list[alias] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class ImportFrom(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("module", "names", "level")
@@ -550,6 +725,11 @@ class ImportFrom(stmt):
            self, module: str | None = None, *, names: list[alias], level: int, **kwargs: Unpack[_Attributes]
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, module: str | None = ..., names: list[alias] = ..., level: int = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class Global(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("names",)
@@ -559,6 +739,9 @@ class Global(stmt):
    else:
        def __init__(self, names: list[_Identifier], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, names: list[_Identifier], **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Nonlocal(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("names",)
@@ -568,12 +751,18 @@ class Nonlocal(stmt):
    else:
        def __init__(self, names: list[_Identifier], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, names: list[_Identifier] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Expr(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("value",)
    value: expr
    def __init__(self, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Pass(stmt): ...
 class Break(stmt): ...
 class Continue(stmt): ...
@@ -585,6 +774,9 @@ class expr(AST):
    end_col_offset: int | None
    def __init__(self, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class BoolOp(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("op", "values")
@@ -595,6 +787,9 @@ class BoolOp(expr):
    else:
        def __init__(self, op: boolop, values: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, op: boolop = ..., values: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class BinOp(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("left", "op", "right")
@@ -603,6 +798,11 @@ class BinOp(expr):
    right: expr
    def __init__(self, left: expr, op: operator, right: expr, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, left: expr = ..., op: operator = ..., right: expr = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class UnaryOp(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("op", "operand")
@@ -610,6 +810,9 @@ class UnaryOp(expr):
    operand: expr
    def __init__(self, op: unaryop, operand: expr, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, op: unaryop = ..., operand: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Lambda(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("args", "body")
@@ -617,6 +820,9 @@ class Lambda(expr):
    body: expr
    def __init__(self, args: arguments, body: expr, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, args: arguments = ..., body: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class IfExp(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("test", "body", "orelse")
@@ -625,6 +831,11 @@ class IfExp(expr):
    orelse: expr
    def __init__(self, test: expr, body: expr, orelse: expr, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, test: expr = ..., body: expr = ..., orelse: expr = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class Dict(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("keys", "values")
@@ -635,6 +846,11 @@ class Dict(expr):
    else:
        def __init__(self, keys: list[expr | None], values: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, keys: list[expr | None] = ..., values: list[expr] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class Set(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("elts",)
@@ -644,6 +860,9 @@ class Set(expr):
    else:
        def __init__(self, elts: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, elts: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class ListComp(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("elt", "generators")
@@ -654,6 +873,11 @@ class ListComp(expr):
    else:
        def __init__(self, elt: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, elt: expr = ..., generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class SetComp(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("elt", "generators")
@@ -664,6 +888,11 @@ class SetComp(expr):
    else:
        def __init__(self, elt: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, elt: expr = ..., generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class DictComp(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("key", "value", "generators")
@@ -677,6 +906,11 @@ class DictComp(expr):
    else:
        def __init__(self, key: expr, value: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, key: expr = ..., value: expr = ..., generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class GeneratorExp(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("elt", "generators")
@@ -687,24 +921,38 @@ class GeneratorExp(expr):
    else:
        def __init__(self, elt: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, elt: expr = ..., generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class Await(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("value",)
    value: expr
    def __init__(self, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Yield(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("value",)
    value: expr | None
    def __init__(self, value: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr | None = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class YieldFrom(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("value",)
    value: expr
    def __init__(self, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Compare(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("left", "ops", "comparators")
@@ -718,6 +966,11 @@ class Compare(expr):
    else:
        def __init__(self, left: expr, ops: list[cmpop], comparators: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, left: expr = ..., ops: list[cmpop] = ..., comparators: list[expr] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class Call(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("func", "args", "keywords")
@@ -731,6 +984,11 @@ class Call(expr):
    else:
        def __init__(self, func: expr, args: list[expr], keywords: list[keyword], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, func: expr = ..., args: list[expr] = ..., keywords: list[keyword] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class FormattedValue(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("value", "conversion", "format_spec")
@@ -739,6 +997,11 @@ class FormattedValue(expr):
    format_spec: expr | None
    def __init__(self, value: expr, conversion: int, format_spec: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, value: expr = ..., conversion: int = ..., format_spec: expr | None = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class JoinedStr(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("values",)
@@ -748,6 +1011,9 @@ class JoinedStr(expr):
    else:
        def __init__(self, values: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, values: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Constant(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("value", "kind")
@@ -760,6 +1026,9 @@ class Constant(expr):

    def __init__(self, value: Any, kind: str | None = None, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: Any = ..., kind: str | None = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class NamedExpr(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("target", "value")
@@ -767,6 +1036,9 @@ class NamedExpr(expr):
    value: expr
    def __init__(self, target: Name, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, target: Name = ..., value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Attribute(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("value", "attr", "ctx")
@@ -775,6 +1047,11 @@ class Attribute(expr):
    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
    def __init__(self, value: expr, attr: _Identifier, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, value: expr = ..., attr: _Identifier = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 if sys.version_info >= (3, 9):
    _Slice: typing_extensions.TypeAlias = expr
    _SliceAttributes: typing_extensions.TypeAlias = _Attributes
@@ -794,6 +1071,16 @@ class Slice(_Slice):
        self, lower: expr | None = None, upper: expr | None = None, step: expr | None = None, **kwargs: Unpack[_SliceAttributes]
    ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            lower: expr | None = ...,
+            upper: expr | None = ...,
+            step: expr | None = ...,
+            **kwargs: Unpack[_SliceAttributes],
+        ) -> Self: ...
+
 if sys.version_info < (3, 9):
    class ExtSlice(slice):
        dims: list[slice]
@@ -811,6 +1098,11 @@ class Subscript(expr):
    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
    def __init__(self, value: expr, slice: _Slice, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, value: expr = ..., slice: _Slice = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
 class Starred(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("value", "ctx")
@@ -818,6 +1110,9 @@ class Starred(expr):
    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
    def __init__(self, value: expr, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Name(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("id", "ctx")
@@ -825,6 +1120,9 @@ class Name(expr):
    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
    def __init__(self, id: _Identifier, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, id: _Identifier = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class List(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("elts", "ctx")
@@ -835,6 +1133,9 @@ class List(expr):
    else:
        def __init__(self, elts: list[expr], ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, elts: list[expr] = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class Tuple(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("elts", "ctx")
@@ -847,6 +1148,9 @@ class Tuple(expr):
    else:
        def __init__(self, elts: list[expr], ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, elts: list[expr] = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class expr_context(AST): ...

 if sys.version_info < (3, 9):
@@ -910,6 +1214,9 @@ class comprehension(AST):
    else:
        def __init__(self, target: expr, iter: expr, ifs: list[expr], is_async: int) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, target: expr = ..., iter: expr = ..., ifs: list[expr] = ..., is_async: int = ...) -> Self: ...
+
 class excepthandler(AST):
    lineno: int
    col_offset: int
@@ -917,6 +1224,11 @@ class excepthandler(AST):
    end_col_offset: int | None
    def __init__(self, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, lineno: int = ..., col_offset: int = ..., end_lineno: int | None = ..., end_col_offset: int | None = ...
+        ) -> Self: ...
+
 class ExceptHandler(excepthandler):
    if sys.version_info >= (3, 10):
        __match_args__ = ("type", "name", "body")
@@ -937,6 +1249,16 @@ class ExceptHandler(excepthandler):
            self, type: expr | None = None, name: _Identifier | None = None, *, body: list[stmt], **kwargs: Unpack[_Attributes]
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            type: expr | None = ...,
+            name: _Identifier | None = ...,
+            body: list[stmt] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
 class arguments(AST):
    if sys.version_info >= (3, 10):
        __match_args__ = ("posonlyargs", "args", "vararg", "kwonlyargs", "kw_defaults", "kwarg", "defaults")
@@ -995,6 +1317,19 @@ class arguments(AST):
            defaults: list[expr],
        ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            posonlyargs: list[arg] = ...,
+            args: list[arg] = ...,
+            vararg: arg | None = ...,
+            kwonlyargs: list[arg] = ...,
+            kw_defaults: list[expr | None] = ...,
+            kwarg: arg | None = ...,
+            defaults: list[expr] = ...,
+        ) -> Self: ...
+
 class arg(AST):
    lineno: int
    col_offset: int
@@ -1009,6 +1344,16 @@ class arg(AST):
        self, arg: _Identifier, annotation: expr | None = None, type_comment: str | None = None, **kwargs: Unpack[_Attributes]
    ) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            arg: _Identifier = ...,
+            annotation: expr | None = ...,
+            type_comment: str | None = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
 class keyword(AST):
    lineno: int
    col_offset: int
@@ -1023,6 +1368,9 @@ class keyword(AST):
    @overload
    def __init__(self, arg: _Identifier | None = None, *, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, arg: _Identifier | None = ..., value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class alias(AST):
    lineno: int
    col_offset: int
@@ -1034,6 +1382,9 @@ class alias(AST):
    asname: _Identifier | None
    def __init__(self, name: str, asname: _Identifier | None = None, **kwargs: Unpack[_Attributes]) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, name: str = ..., asname: _Identifier | None = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class withitem(AST):
    if sys.version_info >= (3, 10):
        __match_args__ = ("context_expr", "optional_vars")
@@ -1041,6 +1392,9 @@ class withitem(AST):
    optional_vars: expr | None
    def __init__(self, context_expr: expr, optional_vars: expr | None = None) -> None: ...

+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, context_expr: expr = ..., optional_vars: expr | None = ...) -> Self: ...
+
 if sys.version_info >= (3, 10):
    class Match(stmt):
        __match_args__ = ("subject", "cases")
@@ -1051,6 +1405,11 @@ if sys.version_info >= (3, 10):
        else:
            def __init__(self, subject: expr, cases: list[match_case], **kwargs: Unpack[_Attributes]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self, *, subject: expr = ..., cases: list[match_case] = ..., **kwargs: Unpack[_Attributes]
+            ) -> Self: ...
+
    class pattern(AST):
        lineno: int
        col_offset: int
@@ -1058,6 +1417,11 @@ if sys.version_info >= (3, 10):
        end_col_offset: int
        def __init__(self, **kwargs: Unpack[_Attributes[int]]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self, *, lineno: int = ..., col_offset: int = ..., end_lineno: int = ..., end_col_offset: int = ...
+            ) -> Self: ...
+
    # Without the alias, Pyright complains variables named pattern are recursively defined
    _Pattern: typing_extensions.TypeAlias = pattern

@@ -1074,16 +1438,25 @@ if sys.version_info >= (3, 10):
            @overload
            def __init__(self, pattern: _Pattern, guard: expr | None = None, *, body: list[stmt]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, pattern: _Pattern = ..., guard: expr | None = ..., body: list[stmt] = ...) -> Self: ...
+
    class MatchValue(pattern):
        __match_args__ = ("value",)
        value: expr
        def __init__(self, value: expr, **kwargs: Unpack[_Attributes[int]]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, value: expr = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
    class MatchSingleton(pattern):
        __match_args__ = ("value",)
        value: Literal[True, False] | None
        def __init__(self, value: Literal[True, False] | None, **kwargs: Unpack[_Attributes[int]]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, value: Literal[True, False] | None = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
    class MatchSequence(pattern):
        __match_args__ = ("patterns",)
        patterns: list[pattern]
@@ -1092,11 +1465,17 @@ if sys.version_info >= (3, 10):
        else:
            def __init__(self, patterns: list[pattern], **kwargs: Unpack[_Attributes[int]]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, patterns: list[pattern] = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
    class MatchStar(pattern):
        __match_args__ = ("name",)
        name: _Identifier | None
        def __init__(self, name: _Identifier | None, **kwargs: Unpack[_Attributes[int]]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, name: _Identifier | None = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
    class MatchMapping(pattern):
        __match_args__ = ("keys", "patterns", "rest")
        keys: list[expr]
@@ -1119,6 +1498,16 @@ if sys.version_info >= (3, 10):
                **kwargs: Unpack[_Attributes[int]],
            ) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self,
+                *,
+                keys: list[expr] = ...,
+                patterns: list[pattern] = ...,
+                rest: _Identifier | None = ...,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> Self: ...
+
    class MatchClass(pattern):
        __match_args__ = ("cls", "patterns", "kwd_attrs", "kwd_patterns")
        cls: expr
@@ -1144,6 +1533,17 @@ if sys.version_info >= (3, 10):
                **kwargs: Unpack[_Attributes[int]],
            ) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self,
+                *,
+                cls: expr = ...,
+                patterns: list[pattern] = ...,
+                kwd_attrs: list[_Identifier] = ...,
+                kwd_patterns: list[pattern] = ...,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> Self: ...
+
    class MatchAs(pattern):
        __match_args__ = ("pattern", "name")
        pattern: _Pattern | None
@@ -1152,6 +1552,11 @@ if sys.version_info >= (3, 10):
            self, pattern: _Pattern | None = None, name: _Identifier | None = None, **kwargs: Unpack[_Attributes[int]]
        ) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self, *, pattern: _Pattern | None = ..., name: _Identifier | None = ..., **kwargs: Unpack[_Attributes[int]]
+            ) -> Self: ...
+
    class MatchOr(pattern):
        __match_args__ = ("patterns",)
        patterns: list[pattern]
@@ -1160,6 +1565,9 @@ if sys.version_info >= (3, 10):
        else:
            def __init__(self, patterns: list[pattern], **kwargs: Unpack[_Attributes[int]]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, patterns: list[pattern] = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
 if sys.version_info >= (3, 12):
    class type_param(AST):
        lineno: int
@@ -1168,6 +1576,9 @@ if sys.version_info >= (3, 12):
        end_col_offset: int
        def __init__(self, **kwargs: Unpack[_Attributes[int]]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(self, **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
    class TypeVar(type_param):
        if sys.version_info >= (3, 13):
            __match_args__ = ("name", "bound", "default_value")
@@ -1187,6 +1598,16 @@ if sys.version_info >= (3, 12):
        else:
            def __init__(self, name: _Identifier, bound: expr | None = None, **kwargs: Unpack[_Attributes[int]]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self,
+                *,
+                name: _Identifier = ...,
+                bound: expr | None = ...,
+                default_value: expr | None = ...,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> Self: ...
+
    class ParamSpec(type_param):
        if sys.version_info >= (3, 13):
            __match_args__ = ("name", "default_value")
@@ -1201,6 +1622,11 @@ if sys.version_info >= (3, 12):
        else:
            def __init__(self, name: _Identifier, **kwargs: Unpack[_Attributes[int]]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self, *, name: _Identifier = ..., default_value: expr | None = ..., **kwargs: Unpack[_Attributes[int]]
+            ) -> Self: ...
+
    class TypeVarTuple(type_param):
        if sys.version_info >= (3, 13):
            __match_args__ = ("name", "default_value")
@@ -1215,6 +1641,11 @@ if sys.version_info >= (3, 12):
        else:
            def __init__(self, name: _Identifier, **kwargs: Unpack[_Attributes[int]]) -> None: ...

+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self, *, name: _Identifier = ..., default_value: expr | None = ..., **kwargs: Unpack[_Attributes[int]]
+            ) -> Self: ...
+
    class TypeAlias(stmt):
        __match_args__ = ("name", "type_params", "value")
        name: Name
@@ -1233,3 +1664,13 @@ if sys.version_info >= (3, 12):
            def __init__(
                self, name: Name, type_params: list[type_param], value: expr, **kwargs: Unpack[_Attributes[int]]
            ) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self,
+                *,
+                name: Name = ...,
+                type_params: list[type_param] = ...,
+                value: expr = ...,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> Self: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_operator.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_operator.pyi
@@ -2,7 +2,7 @@ import sys
 from _typeshed import SupportsGetItem
 from collections.abc import Callable, Container, Iterable, MutableMapping, MutableSequence, Sequence
 from typing import Any, AnyStr, Generic, Protocol, SupportsAbs, SupportsIndex, TypeVar, final, overload
-from typing_extensions import ParamSpec, TypeAlias, TypeVarTuple, Unpack
+from typing_extensions import ParamSpec, TypeAlias, TypeIs, TypeVarTuple, Unpack

 _R = TypeVar("_R")
 _T = TypeVar("_T")
@@ -145,3 +145,7 @@ if sys.version_info >= (3, 11):
    def call(obj: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...

 def _compare_digest(a: AnyStr, b: AnyStr, /) -> bool: ...
+
+if sys.version_info >= (3, 14):
+    def is_none(a: object, /) -> TypeIs[None]: ...
+    def is_not_none(a: _T | None, /) -> TypeIs[_T]: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_stat.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_stat.pyi
@@ -28,9 +28,9 @@ S_IFDIR: Final = 0o040000

 # These are 0 on systems that don't support the specific kind of file.
 # Example: Linux doesn't support door files, so S_IFDOOR is 0 on linux.
-S_IFDOOR: int
-S_IFPORT: int
-S_IFWHT: int
+S_IFDOOR: Final[int]
+S_IFPORT: Final[int]
+S_IFWHT: Final[int]

 S_ISUID: Final = 0o4000
 S_ISGID: Final = 0o2000
@@ -79,9 +79,9 @@ def S_ISWHT(mode: int, /) -> bool: ...
 def filemode(mode: int, /) -> str: ...

 if sys.platform == "win32":
-    IO_REPARSE_TAG_SYMLINK: int
-    IO_REPARSE_TAG_MOUNT_POINT: int
-    IO_REPARSE_TAG_APPEXECLINK: int
+    IO_REPARSE_TAG_SYMLINK: Final = 0xA000000C
+    IO_REPARSE_TAG_MOUNT_POINT: Final = 0xA0000003
+    IO_REPARSE_TAG_APPEXECLINK: Final = 0x8000001B

 if sys.platform == "win32":
    FILE_ATTRIBUTE_ARCHIVE: Final = 32
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_thread.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_thread.pyi
@@ -1,3 +1,4 @@
+import signal
 import sys
 from _typeshed import structseq
 from collections.abc import Callable
@@ -16,16 +17,39 @@ class LockType:
    def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
    def release(self) -> None: ...
    def locked(self) -> bool: ...
+    def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+    def release_lock(self) -> None: ...
+    def locked_lock(self) -> bool: ...
    def __enter__(self) -> bool: ...
    def __exit__(
        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
    ) -> None: ...

+if sys.version_info >= (3, 13):
+    @final
+    class _ThreadHandle:
+        ident: int
+
+        def join(self, timeout: float | None = None, /) -> None: ...
+        def is_done(self) -> bool: ...
+        def _set_done(self) -> None: ...
+
+    def start_joinable_thread(
+        function: Callable[[], object], handle: _ThreadHandle | None = None, daemon: bool = True
+    ) -> _ThreadHandle: ...
+    lock = LockType
+
@overload
 def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int: ...
@overload
 def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any], /) -> int: ...
-def interrupt_main() -> None: ...
+
+if sys.version_info >= (3, 10):
+    def interrupt_main(signum: signal.Signals = ..., /) -> None: ...
+
+else:
+    def interrupt_main() -> None: ...
+
 def exit() -> NoReturn: ...
 def allocate_lock() -> LockType: ...
 def get_ident() -> int: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_tkinter.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_tkinter.pyi
@@ -106,8 +106,8 @@ EXCEPTION: Final = 8
 READABLE: Final = 2
 WRITABLE: Final = 4

-TCL_VERSION: str
-TK_VERSION: str
+TCL_VERSION: Final[str]
+TK_VERSION: Final[str]

@final
 class TkttType:
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/builtins.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/builtins.pyi
@@ -33,7 +33,8 @@ from collections.abc import Awaitable, Callable, Iterable, Iterator, MutableSet,
 from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
 from types import CellType, CodeType, TracebackType

-# mypy crashes if any of {ByteString, Sequence, MutableSequence, Mapping, MutableMapping} are imported from collections.abc in builtins.pyi
+# mypy crashes if any of {ByteString, Sequence, MutableSequence, Mapping, MutableMapping}
+# are imported from collections.abc in builtins.pyi
 from typing import (  # noqa: Y022
    IO,
    Any,
@@ -967,7 +968,9 @@ class tuple(Sequence[_T_co]):
    if sys.version_info >= (3, 9):
        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...

-# Doesn't exist at runtime, but deleting this breaks mypy. See #2999
+# Doesn't exist at runtime, but deleting this breaks mypy and pyright. See:
+# https://github.com/python/typeshed/issues/7580
+# https://github.com/python/mypy/issues/8240
@final
@type_check_only
 class function:
@@ -1084,7 +1087,8 @@ class dict(MutableMapping[_KT, _VT]):
    def keys(self) -> dict_keys[_KT, _VT]: ...
    def values(self) -> dict_values[_KT, _VT]: ...
    def items(self) -> dict_items[_KT, _VT]: ...
-    # Signature of `dict.fromkeys` should be kept identical to `fromkeys` methods of `OrderedDict`/`ChainMap`/`UserDict` in `collections`
+    # Signature of `dict.fromkeys` should be kept identical to
+    # `fromkeys` methods of `OrderedDict`/`ChainMap`/`UserDict` in `collections`
    # TODO: the true signature of `dict.fromkeys` is not expressible in the current type system.
    # See #3800 & https://github.com/python/typing/issues/548#issuecomment-683336963.
    @classmethod
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/cmd.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/cmd.pyi
@@ -1,10 +1,11 @@
 from collections.abc import Callable
 from typing import IO, Any, Final
+from typing_extensions import LiteralString

 __all__ = ["Cmd"]

 PROMPT: Final = "(Cmd) "
-IDENTCHARS: str  # Too big to be `Literal`
+IDENTCHARS: Final[LiteralString]  # Too big to be `Literal`

 class Cmd:
    prompt: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/collections/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/collections/init.pyi
@@ -345,15 +345,15 @@ class _OrderedDictValuesView(ValuesView[_VT_co], Reversible[_VT_co]):
 # but they are not exposed anywhere)
 # pyright doesn't have a specific error code for subclassing error!
@final
-class _odict_keys(dict_keys[_KT_co, _VT_co], Reversible[_KT_co]):  # type: ignore[misc]  # pyright: ignore
+class _odict_keys(dict_keys[_KT_co, _VT_co], Reversible[_KT_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
    def __reversed__(self) -> Iterator[_KT_co]: ...

@final
-class _odict_items(dict_items[_KT_co, _VT_co], Reversible[tuple[_KT_co, _VT_co]]):  # type: ignore[misc]  # pyright: ignore
+class _odict_items(dict_items[_KT_co, _VT_co], Reversible[tuple[_KT_co, _VT_co]]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
    def __reversed__(self) -> Iterator[tuple[_KT_co, _VT_co]]: ...

@final
-class _odict_values(dict_values[_KT_co, _VT_co], Reversible[_VT_co], Generic[_KT_co, _VT_co]):  # type: ignore[misc]  # pyright: ignore
+class _odict_values(dict_values[_KT_co, _VT_co], Reversible[_VT_co], Generic[_KT_co, _VT_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
    def __reversed__(self) -> Iterator[_VT_co]: ...

 class OrderedDict(dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]):
@@ -475,7 +475,8 @@ class ChainMap(MutableMapping[_KT, _VT]):
    def pop(self, key: _KT, default: _T) -> _VT | _T: ...
    def copy(self) -> Self: ...
    __copy__ = copy
-    # All arguments to `fromkeys` are passed to `dict.fromkeys` at runtime, so the signature should be kept in line with `dict.fromkeys`.
+    # All arguments to `fromkeys` are passed to `dict.fromkeys` at runtime,
+    # so the signature should be kept in line with `dict.fromkeys`.
    @classmethod
    @overload
    def fromkeys(cls, iterable: Iterable[_T]) -> ChainMap[_T, Any | None]: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/crypt.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/crypt.pyi
@@ -1,12 +1,13 @@
 import sys
+from typing import Final

 if sys.platform != "win32":
    class _Method: ...
-    METHOD_CRYPT: _Method
-    METHOD_MD5: _Method
-    METHOD_SHA256: _Method
-    METHOD_SHA512: _Method
-    METHOD_BLOWFISH: _Method
+    METHOD_CRYPT: Final[_Method]
+    METHOD_MD5: Final[_Method]
+    METHOD_SHA256: Final[_Method]
+    METHOD_SHA512: Final[_Method]
+    METHOD_BLOWFISH: Final[_Method]
    methods: list[_Method]
    def mksalt(method: _Method | None = None, *, rounds: int | None = None) -> str: ...
    def crypt(word: str, salt: str | _Method | None = None) -> str: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ctypes/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ctypes/init.pyi
@@ -185,3 +185,8 @@ if sys.version_info >= (3, 12):
    c_time_t: type[c_int32 | c_int64]  # alias for one or the other at runtime

 class py_object(_CanCastTo, _SimpleCData[_T]): ...
+
+if sys.version_info >= (3, 14):
+    class c_float_complex(_SimpleCData[complex]): ...
+    class c_double_complex(_SimpleCData[complex]): ...
+    class c_longdouble_complex(_SimpleCData[complex]): ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/dataclasses.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/dataclasses.pyi
@@ -229,18 +229,17 @@ if sys.version_info >= (3, 9):
 else:
    class _InitVarMeta(type):
        # Not used, instead `InitVar.__class_getitem__` is called.
-        # pyright ignore is needed because pyright (not unreasonably) thinks this
-        # is an invalid use of InitVar.
-        def __getitem__(self, params: Any) -> InitVar[Any]: ...  # pyright: ignore
+        # pyright (not unreasonably) thinks this is an invalid use of InitVar.
+        def __getitem__(self, params: Any) -> InitVar[Any]: ...  # pyright: ignore[reportInvalidTypeForm]

 class InitVar(Generic[_T], metaclass=_InitVarMeta):
    type: Type[_T]
    def __init__(self, type: Type[_T]) -> None: ...
    if sys.version_info >= (3, 9):
        @overload
-        def __class_getitem__(cls, type: Type[_T]) -> InitVar[_T]: ...  # pyright: ignore
+        def __class_getitem__(cls, type: Type[_T]) -> InitVar[_T]: ...  # pyright: ignore[reportInvalidTypeForm]
        @overload
-        def __class_getitem__(cls, type: Any) -> InitVar[Any]: ...  # pyright: ignore
+        def __class_getitem__(cls, type: Any) -> InitVar[Any]: ...  # pyright: ignore[reportInvalidTypeForm]

 if sys.version_info >= (3, 12):
    def make_dataclass(
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/datetime.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/datetime.pyi
@@ -265,12 +265,12 @@ class datetime(date):
        def fromtimestamp(cls, timestamp: float, /, tz: _TzInfo | None = ...) -> Self: ...

    @classmethod
-    @deprecated("Use timezone-aware objects to represent datetimes in UTC; e.g. by calling .fromtimestamp(datetime.UTC)")
+    @deprecated("Use timezone-aware objects to represent datetimes in UTC; e.g. by calling .fromtimestamp(datetime.timezone.utc)")
    def utcfromtimestamp(cls, t: float, /) -> Self: ...
    @classmethod
    def now(cls, tz: _TzInfo | None = None) -> Self: ...
    @classmethod
-    @deprecated("Use timezone-aware objects to represent datetimes in UTC; e.g. by calling .now(datetime.UTC)")
+    @deprecated("Use timezone-aware objects to represent datetimes in UTC; e.g. by calling .now(datetime.timezone.utc)")
    def utcnow(cls) -> Self: ...
    @classmethod
    def combine(cls, date: _Date, time: _Time, tzinfo: _TzInfo | None = ...) -> Self: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/cmd.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/cmd.pyi
@@ -30,6 +30,7 @@ _CommandT = TypeVar("_CommandT", bound=Command)
 _Ts = TypeVarTuple("_Ts")

 class Command:
+    dry_run: Literal[0, 1]  # Exposed from __getattr_. Same as Distribution.dry_run
    distribution: Distribution
    # Any to work around variance issues
    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/check.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/check.pyi
@@ -1,4 +1,4 @@
-from typing import Any, ClassVar, Literal
+from typing import Any, ClassVar, Final, Literal
 from typing_extensions import TypeAlias

 from ..cmd import Command
@@ -22,7 +22,7 @@ class SilentReporter(_Reporter):
    ) -> None: ...
    def system_message(self, level, message, *children, **kwargs): ...

-HAS_DOCUTILS: bool
+HAS_DOCUTILS: Final[bool]

 class check(Command):
    description: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/config.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/config.pyi
@@ -1,12 +1,12 @@
 from _typeshed import StrOrBytesPath
 from collections.abc import Sequence
 from re import Pattern
-from typing import Any, ClassVar, Literal
+from typing import Any, ClassVar, Final, Literal

 from ..ccompiler import CCompiler
 from ..cmd import Command

-LANG_EXT: dict[str, str]
+LANG_EXT: Final[dict[str, str]]

 class config(Command):
    description: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/install.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/install.pyi
@@ -1,11 +1,16 @@
+import sys
 from collections.abc import Callable
-from typing import Any, ClassVar
+from typing import Any, ClassVar, Final, Literal

 from ..cmd import Command

-HAS_USER_SITE: bool
-SCHEME_KEYS: tuple[str, ...]
-INSTALL_SCHEMES: dict[str, dict[Any, Any]]
+HAS_USER_SITE: Final[bool]
+
+SCHEME_KEYS: Final[tuple[Literal["purelib"], Literal["platlib"], Literal["headers"], Literal["scripts"], Literal["data"]]]
+INSTALL_SCHEMES: Final[dict[str, dict[str, str]]]
+
+if sys.version_info < (3, 10):
+    WINDOWS_SCHEME: Final[dict[str, str]]

 class install(Command):
    description: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/install_lib.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/install_lib.pyi
@@ -1,8 +1,8 @@
-from typing import Any, ClassVar
+from typing import Any, ClassVar, Final

 from ..cmd import Command

-PYTHON_SOURCE_EXTENSION: str
+PYTHON_SOURCE_EXTENSION: Final = ".py"

 class install_lib(Command):
    description: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/core.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/core.pyi
@@ -3,9 +3,9 @@ from collections.abc import Mapping
 from distutils.cmd import Command as Command
 from distutils.dist import Distribution as Distribution
 from distutils.extension import Extension as Extension
-from typing import Any, Literal
+from typing import Any, Final, Literal

-USAGE: str
+USAGE: Final[str]

 def gen_usage(script_name: StrOrBytesPath) -> str: ...

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/cygwinccompiler.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/cygwinccompiler.pyi
@@ -1,20 +1,20 @@
 from distutils.unixccompiler import UnixCCompiler
 from distutils.version import LooseVersion
 from re import Pattern
-from typing import Literal
+from typing import Final, Literal

 def get_msvcr() -> list[str] | None: ...

 class CygwinCCompiler(UnixCCompiler): ...
 class Mingw32CCompiler(CygwinCCompiler): ...

-CONFIG_H_OK: str
-CONFIG_H_NOTOK: str
-CONFIG_H_UNCERTAIN: str
+CONFIG_H_OK: Final = "ok"
+CONFIG_H_NOTOK: Final = "not ok"
+CONFIG_H_UNCERTAIN: Final = "uncertain"

 def check_config_h() -> tuple[Literal["ok", "not ok", "uncertain"], str]: ...

-RE_VERSION: Pattern[bytes]
+RE_VERSION: Final[Pattern[bytes]]

 def get_versions() -> tuple[LooseVersion | None, ...]: ...
 def is_cygwingcc() -> bool: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/debug.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/debug.pyi
@@ -1 +1,3 @@
-DEBUG: bool | None
+from typing import Final
+
+DEBUG: Final[str | None]
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/dist.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/dist.pyi
@@ -88,9 +88,9 @@ class Distribution:
    display_options: ClassVar[_OptionsList]
    display_option_names: ClassVar[list[str]]
    negative_opt: ClassVar[dict[str, str]]
-    verbose: int
-    dry_run: int
-    help: int
+    verbose: Literal[0, 1]
+    dry_run: Literal[0, 1]
+    help: Literal[0, 1]
    command_packages: list[str] | None
    script_name: str | None
    script_args: list[str] | None
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/fancy_getopt.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/fancy_getopt.pyi
@@ -1,15 +1,15 @@
 from collections.abc import Iterable, Mapping
 from re import Pattern
-from typing import Any, overload
+from typing import Any, Final, overload
 from typing_extensions import TypeAlias

 _Option: TypeAlias = tuple[str, str | None, str]
 _GR: TypeAlias = tuple[list[str], OptionDummy]

-longopt_pat: str
-longopt_re: Pattern[str]
-neg_alias_re: Pattern[str]
-longopt_xlate: dict[int, int]
+longopt_pat: Final = r"[a-zA-Z](?:[a-zA-Z0-9-]*)"
+longopt_re: Final[Pattern[str]]
+neg_alias_re: Final[Pattern[str]]
+longopt_xlate: Final[dict[int, int]]

 class FancyGetopt:
    def __init__(self, option_table: list[_Option] | None = None) -> None: ...
@@ -25,7 +25,7 @@ def fancy_getopt(
    options: list[_Option], negative_opt: Mapping[_Option, _Option], object: Any, args: list[str] | None
 ) -> list[str] | _GR: ...

-WS_TRANS: dict[int, str]
+WS_TRANS: Final[dict[int, str]]

 def wrap_text(text: str, width: int) -> list[str]: ...
 def translate_longopt(opt: str) -> str: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/log.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/log.pyi
@@ -1,10 +1,10 @@
-from typing import Any
+from typing import Any, Final

-DEBUG: int
-INFO: int
-WARN: int
-ERROR: int
-FATAL: int
+DEBUG: Final = 1
+INFO: Final = 2
+WARN: Final = 3
+ERROR: Final = 4
+FATAL: Final = 5

 class Log:
    def __init__(self, threshold: int = 3) -> None: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/sysconfig.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/sysconfig.pyi
@@ -1,15 +1,15 @@
 import sys
 from collections.abc import Mapping
 from distutils.ccompiler import CCompiler
-from typing import Literal, overload
+from typing import Final, Literal, overload
 from typing_extensions import deprecated

-PREFIX: str
-EXEC_PREFIX: str
-BASE_PREFIX: str
-BASE_EXEC_PREFIX: str
-project_base: str
-python_build: bool
+PREFIX: Final[str]
+EXEC_PREFIX: Final[str]
+BASE_PREFIX: Final[str]
+BASE_EXEC_PREFIX: Final[str]
+project_base: Final[str]
+python_build: Final[bool]

 def expand_makefile_vars(s: str, vars: Mapping[str, str]) -> str: ...
@overload
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/message.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/message.pyi
@@ -50,7 +50,8 @@ class Message(Generic[_HeaderT, _HeaderParamT]):
    def get_payload(self, i: None = None, *, decode: Literal[True]) -> _EncodedPayloadType | Any: ...
    @overload  # not multipart, IDEM but w/o kwarg
    def get_payload(self, i: None, decode: Literal[True]) -> _EncodedPayloadType | Any: ...
-    # If `charset=None` and payload supports both `encode` AND `decode`, then an invalid payload could be passed, but this is unlikely
+    # If `charset=None` and payload supports both `encode` AND `decode`,
+    # then an invalid payload could be passed, but this is unlikely
    # Not[_SupportsEncodeToPayload]
    @overload
    def set_payload(
@@ -146,7 +147,11 @@ class Message(Generic[_HeaderT, _HeaderParamT]):
 class MIMEPart(Message[_HeaderRegistryT, _HeaderRegistryParamT]):
    def __init__(self, policy: Policy | None = None) -> None: ...
    def get_body(self, preferencelist: Sequence[str] = ("related", "html", "plain")) -> MIMEPart[_HeaderRegistryT] | None: ...
-    def iter_attachments(self) -> Iterator[MIMEPart[_HeaderRegistryT]]: ...
+    def attach(self, payload: Self) -> None: ...  # type: ignore[override]
+    # The attachments are created via type(self) in the attach method. It's theoretically
+    # possible to sneak other attachment types into a MIMEPart instance, but could cause
+    # cause unforseen consequences.
+    def iter_attachments(self) -> Iterator[Self]: ...
    def iter_parts(self) -> Iterator[MIMEPart[_HeaderRegistryT]]: ...
    def get_content(self, *args: Any, content_manager: ContentManager | None = None, **kw: Any) -> Any: ...
    def set_content(self, *args: Any, content_manager: ContentManager | None = None, **kw: Any) -> None: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ftplib.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ftplib.pyi
@@ -86,7 +86,7 @@ class FTP:
    def makeport(self) -> socket: ...
    def makepasv(self) -> tuple[str, int]: ...
    def login(self, user: str = "", passwd: str = "", acct: str = "") -> str: ...
-    # In practice, `rest` rest can actually be anything whose str() is an integer sequence, so to make it simple we allow integers.
+    # In practice, `rest` can actually be anything whose str() is an integer sequence, so to make it simple we allow integers
    def ntransfercmd(self, cmd: str, rest: int | str | None = None) -> tuple[socket, int | None]: ...
    def transfercmd(self, cmd: str, rest: int | str | None = None) -> socket: ...
    def retrbinary(
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/json/encoder.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/json/encoder.pyi
@@ -1,12 +1,12 @@
 from collections.abc import Callable, Iterator
 from re import Pattern
-from typing import Any
+from typing import Any, Final

-ESCAPE: Pattern[str]
-ESCAPE_ASCII: Pattern[str]
-HAS_UTF8: Pattern[bytes]
-ESCAPE_DCT: dict[str, str]
-INFINITY: float
+ESCAPE: Final[Pattern[str]]
+ESCAPE_ASCII: Final[Pattern[str]]
+HAS_UTF8: Final[Pattern[bytes]]
+ESCAPE_DCT: Final[dict[str, str]]
+INFINITY: Final[float]

 def py_encode_basestring(s: str) -> str: ...  # undocumented
 def py_encode_basestring_ascii(s: str) -> str: ...  # undocumented
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/operator.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/operator.pyi
@@ -61,6 +61,9 @@ __all__ = [
 if sys.version_info >= (3, 11):
    __all__ += ["call"]

+if sys.version_info >= (3, 14):
+    __all__ += ["is_none", "is_not_none"]
+
 __lt__ = lt
 __le__ = le
 __eq__ = eq
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/os/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/os/init.pyi
@@ -365,7 +365,9 @@ class stat_result(structseq[float], tuple[int, int, int, int, int, int, int, flo
    if sys.version_info >= (3, 12) and sys.platform == "win32":
        @property
        @deprecated(
-            "Use st_birthtime instead to retrieve the file creation time. In the future, this property will contain the last metadata change time."
+            """\
+Use st_birthtime instead to retrieve the file creation time. \
+In the future, this property will contain the last metadata change time."""
        )
        def st_ctime(self) -> float: ...
    else:
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/poplib.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/poplib.pyi
@@ -67,5 +67,6 @@ class POP3_SSL(POP3):
            timeout: float = ...,
            context: ssl.SSLContext | None = None,
        ) -> None: ...
-        # "context" is actually the last argument, but that breaks LSP and it doesn't really matter because all the arguments are ignored
+        # "context" is actually the last argument,
+        # but that breaks LSP and it doesn't really matter because all the arguments are ignored
        def stls(self, context: Any = None, keyfile: Any = None, certfile: Any = None) -> NoReturn: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/init.pyi
@@ -15,9 +15,9 @@ class ExpatError(Exception):
    offset: int

 error = ExpatError
-XML_PARAM_ENTITY_PARSING_NEVER: int
-XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE: int
-XML_PARAM_ENTITY_PARSING_ALWAYS: int
+XML_PARAM_ENTITY_PARSING_NEVER: Final = 0
+XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE: Final = 1
+XML_PARAM_ENTITY_PARSING_ALWAYS: Final = 2

 _Model: TypeAlias = tuple[int, int, str | None, tuple[Any, ...]]

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/errors.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/errors.pyi
@@ -1,49 +1,51 @@
 import sys
+from typing import Final
+from typing_extensions import LiteralString

 codes: dict[str, int]
 messages: dict[int, str]

-XML_ERROR_ABORTED: str
-XML_ERROR_ASYNC_ENTITY: str
-XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF: str
-XML_ERROR_BAD_CHAR_REF: str
-XML_ERROR_BINARY_ENTITY_REF: str
-XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING: str
-XML_ERROR_DUPLICATE_ATTRIBUTE: str
-XML_ERROR_ENTITY_DECLARED_IN_PE: str
-XML_ERROR_EXTERNAL_ENTITY_HANDLING: str
-XML_ERROR_FEATURE_REQUIRES_XML_DTD: str
-XML_ERROR_FINISHED: str
-XML_ERROR_INCOMPLETE_PE: str
-XML_ERROR_INCORRECT_ENCODING: str
-XML_ERROR_INVALID_TOKEN: str
-XML_ERROR_JUNK_AFTER_DOC_ELEMENT: str
-XML_ERROR_MISPLACED_XML_PI: str
-XML_ERROR_NOT_STANDALONE: str
-XML_ERROR_NOT_SUSPENDED: str
-XML_ERROR_NO_ELEMENTS: str
-XML_ERROR_NO_MEMORY: str
-XML_ERROR_PARAM_ENTITY_REF: str
-XML_ERROR_PARTIAL_CHAR: str
-XML_ERROR_PUBLICID: str
-XML_ERROR_RECURSIVE_ENTITY_REF: str
-XML_ERROR_SUSPENDED: str
-XML_ERROR_SUSPEND_PE: str
-XML_ERROR_SYNTAX: str
-XML_ERROR_TAG_MISMATCH: str
-XML_ERROR_TEXT_DECL: str
-XML_ERROR_UNBOUND_PREFIX: str
-XML_ERROR_UNCLOSED_CDATA_SECTION: str
-XML_ERROR_UNCLOSED_TOKEN: str
-XML_ERROR_UNDECLARING_PREFIX: str
-XML_ERROR_UNDEFINED_ENTITY: str
-XML_ERROR_UNEXPECTED_STATE: str
-XML_ERROR_UNKNOWN_ENCODING: str
-XML_ERROR_XML_DECL: str
+XML_ERROR_ABORTED: Final[LiteralString]
+XML_ERROR_ASYNC_ENTITY: Final[LiteralString]
+XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF: Final[LiteralString]
+XML_ERROR_BAD_CHAR_REF: Final[LiteralString]
+XML_ERROR_BINARY_ENTITY_REF: Final[LiteralString]
+XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING: Final[LiteralString]
+XML_ERROR_DUPLICATE_ATTRIBUTE: Final[LiteralString]
+XML_ERROR_ENTITY_DECLARED_IN_PE: Final[LiteralString]
+XML_ERROR_EXTERNAL_ENTITY_HANDLING: Final[LiteralString]
+XML_ERROR_FEATURE_REQUIRES_XML_DTD: Final[LiteralString]
+XML_ERROR_FINISHED: Final[LiteralString]
+XML_ERROR_INCOMPLETE_PE: Final[LiteralString]
+XML_ERROR_INCORRECT_ENCODING: Final[LiteralString]
+XML_ERROR_INVALID_TOKEN: Final[LiteralString]
+XML_ERROR_JUNK_AFTER_DOC_ELEMENT: Final[LiteralString]
+XML_ERROR_MISPLACED_XML_PI: Final[LiteralString]
+XML_ERROR_NOT_STANDALONE: Final[LiteralString]
+XML_ERROR_NOT_SUSPENDED: Final[LiteralString]
+XML_ERROR_NO_ELEMENTS: Final[LiteralString]
+XML_ERROR_NO_MEMORY: Final[LiteralString]
+XML_ERROR_PARAM_ENTITY_REF: Final[LiteralString]
+XML_ERROR_PARTIAL_CHAR: Final[LiteralString]
+XML_ERROR_PUBLICID: Final[LiteralString]
+XML_ERROR_RECURSIVE_ENTITY_REF: Final[LiteralString]
+XML_ERROR_SUSPENDED: Final[LiteralString]
+XML_ERROR_SUSPEND_PE: Final[LiteralString]
+XML_ERROR_SYNTAX: Final[LiteralString]
+XML_ERROR_TAG_MISMATCH: Final[LiteralString]
+XML_ERROR_TEXT_DECL: Final[LiteralString]
+XML_ERROR_UNBOUND_PREFIX: Final[LiteralString]
+XML_ERROR_UNCLOSED_CDATA_SECTION: Final[LiteralString]
+XML_ERROR_UNCLOSED_TOKEN: Final[LiteralString]
+XML_ERROR_UNDECLARING_PREFIX: Final[LiteralString]
+XML_ERROR_UNDEFINED_ENTITY: Final[LiteralString]
+XML_ERROR_UNEXPECTED_STATE: Final[LiteralString]
+XML_ERROR_UNKNOWN_ENCODING: Final[LiteralString]
+XML_ERROR_XML_DECL: Final[LiteralString]
 if sys.version_info >= (3, 11):
-    XML_ERROR_RESERVED_PREFIX_XML: str
-    XML_ERROR_RESERVED_PREFIX_XMLNS: str
-    XML_ERROR_RESERVED_NAMESPACE_URI: str
-    XML_ERROR_INVALID_ARGUMENT: str
-    XML_ERROR_NO_BUFFER: str
-    XML_ERROR_AMPLIFICATION_LIMIT_BREACH: str
+    XML_ERROR_RESERVED_PREFIX_XML: Final[LiteralString]
+    XML_ERROR_RESERVED_PREFIX_XMLNS: Final[LiteralString]
+    XML_ERROR_RESERVED_NAMESPACE_URI: Final[LiteralString]
+    XML_ERROR_INVALID_ARGUMENT: Final[LiteralString]
+    XML_ERROR_NO_BUFFER: Final[LiteralString]
+    XML_ERROR_AMPLIFICATION_LIMIT_BREACH: Final[LiteralString]
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/model.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/model.pyi
@@ -1,11 +1,13 @@
-XML_CTYPE_ANY: int
-XML_CTYPE_CHOICE: int
-XML_CTYPE_EMPTY: int
-XML_CTYPE_MIXED: int
-XML_CTYPE_NAME: int
-XML_CTYPE_SEQ: int
+from typing import Final

-XML_CQUANT_NONE: int
-XML_CQUANT_OPT: int
-XML_CQUANT_PLUS: int
-XML_CQUANT_REP: int
+XML_CTYPE_ANY: Final = 2
+XML_CTYPE_EMPTY: Final = 1
+XML_CTYPE_MIXED: Final = 3
+XML_CTYPE_NAME: Final = 4
+XML_CTYPE_CHOICE: Final = 5
+XML_CTYPE_SEQ: Final = 6
+
+XML_CQUANT_NONE: Final = 0
+XML_CQUANT_OPT: Final = 1
+XML_CQUANT_REP: Final = 2
+XML_CQUANT_PLUS: Final = 3
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/socketserver.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/socketserver.pyi
@@ -3,8 +3,9 @@ import types
 from _socket import _Address, _RetAddress
 from _typeshed import ReadableBuffer
 from collections.abc import Callable
+from io import BufferedIOBase
 from socket import socket as _socket
-from typing import Any, BinaryIO, ClassVar
+from typing import Any, ClassVar
 from typing_extensions import Self, TypeAlias

 __all__ = [
@@ -158,11 +159,11 @@ class StreamRequestHandler(BaseRequestHandler):
    timeout: ClassVar[float | None]  # undocumented
    disable_nagle_algorithm: ClassVar[bool]  # undocumented
    connection: Any  # undocumented
-    rfile: BinaryIO
-    wfile: BinaryIO
+    rfile: BufferedIOBase
+    wfile: BufferedIOBase

 class DatagramRequestHandler(BaseRequestHandler):
-    packet: _socket  # undocumented
+    packet: bytes  # undocumented
    socket: _socket  # undocumented
-    rfile: BinaryIO
-    wfile: BinaryIO
+    rfile: BufferedIOBase
+    wfile: BufferedIOBase
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/constants.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/constants.pyi
@@ -1,12 +1,12 @@
 from typing import Final

 # These are not actually bools. See #4669
-NO: bool
-YES: bool
-TRUE: bool
-FALSE: bool
-ON: bool
-OFF: bool
+NO: Final[bool]
+YES: Final[bool]
+TRUE: Final[bool]
+FALSE: Final[bool]
+ON: Final[bool]
+OFF: Final[bool]
 N: Final = "n"
 S: Final = "s"
 W: Final = "w"
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/dialog.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/dialog.pyi
@@ -2,12 +2,12 @@ import sys
 from _typeshed import Incomplete
 from collections.abc import Mapping
 from tkinter import Widget
-from typing import Any
+from typing import Any, Final

 if sys.version_info >= (3, 9):
    __all__ = ["Dialog"]

-DIALOG_ICON: str
+DIALOG_ICON: Final = "questhead"

 class Dialog(Widget):
    widgetName: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/messagebox.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/messagebox.pyi
@@ -1,6 +1,6 @@
 import sys
 from tkinter.commondialog import Dialog
-from typing import ClassVar
+from typing import ClassVar, Final

 if sys.version_info >= (3, 9):
    __all__ = [
@@ -14,22 +14,22 @@ if sys.version_info >= (3, 9):
        "askretrycancel",
    ]

-ERROR: str
-INFO: str
-QUESTION: str
-WARNING: str
-ABORTRETRYIGNORE: str
-OK: str
-OKCANCEL: str
-RETRYCANCEL: str
-YESNO: str
-YESNOCANCEL: str
-ABORT: str
-RETRY: str
-IGNORE: str
-CANCEL: str
-YES: str
-NO: str
+ERROR: Final = "error"
+INFO: Final = "info"
+QUESTION: Final = "question"
+WARNING: Final = "warning"
+ABORTRETRYIGNORE: Final = "abortretryignore"
+OK: Final = "ok"
+OKCANCEL: Final = "okcancel"
+RETRYCANCEL: Final = "retrycancel"
+YESNO: Final = "yesno"
+YESNOCANCEL: Final = "yesnocancel"
+ABORT: Final = "abort"
+RETRY: Final = "retry"
+IGNORE: Final = "ignore"
+CANCEL: Final = "cancel"
+YES: Final = "yes"
+NO: Final = "no"

 class Message(Dialog):
    command: ClassVar[str]
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/ttk.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/ttk.pyi
@@ -556,7 +556,9 @@ class Notebook(Widget):
        sticky: str = ...,  # consists of letters 'n', 's', 'w', 'e', no repeats, may be empty
        padding: _Padding = ...,
        text: str = ...,
-        image=...,  # Sequence of an image name, followed by zero or more (sequences of one or more state names followed by an image name)
+        # `image` is a sequence of an image name, followed by zero or more
+        # (sequences of one or more state names followed by an image name)
+        image=...,
        compound: tkinter._Compound = ...,
        underline: int = ...,
    ) -> None: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/typing.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/typing.pyi
@@ -2,7 +2,7 @@
 # ruff: noqa: F811
 # TODO: The collections import is required, otherwise mypy crashes.
 # https://github.com/python/mypy/issues/16744
-import collections  # noqa: F401  # pyright: ignore
+import collections  # noqa: F401  # pyright: ignore[reportUnusedImport]
 import sys
 import typing_extensions
 from _collections_abc import dict_items, dict_keys, dict_values
@@ -800,18 +800,12 @@ class IO(Iterator[AnyStr]):
    def writable(self) -> bool: ...
    @abstractmethod
    @overload
-    def write(self: IO[str], s: str, /) -> int: ...
-    @abstractmethod
-    @overload
    def write(self: IO[bytes], s: ReadableBuffer, /) -> int: ...
    @abstractmethod
    @overload
    def write(self, s: AnyStr, /) -> int: ...
    @abstractmethod
    @overload
-    def writelines(self: IO[str], lines: Iterable[str], /) -> None: ...
-    @abstractmethod
-    @overload
    def writelines(self: IO[bytes], lines: Iterable[ReadableBuffer], /) -> None: ...
    @abstractmethod
    @overload
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/unittest/runner.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/unittest/runner.pyi
@@ -2,36 +2,52 @@ import sys
 import unittest.case
 import unittest.result
 import unittest.suite
-from _typeshed import Incomplete
+from _typeshed import SupportsFlush, SupportsWrite
 from collections.abc import Callable, Iterable
-from typing import TextIO
-from typing_extensions import TypeAlias
+from typing import Any, Generic, Protocol, TypeVar
+from typing_extensions import Never, TypeAlias

-_ResultClassType: TypeAlias = Callable[[TextIO, bool, int], unittest.result.TestResult]
+_ResultClassType: TypeAlias = Callable[[_TextTestStream, bool, int], TextTestResult]

-class TextTestResult(unittest.result.TestResult):
+class _SupportsWriteAndFlush(SupportsWrite[str], SupportsFlush, Protocol): ...
+
+# All methods used by unittest.runner.TextTestResult's stream
+class _TextTestStream(_SupportsWriteAndFlush, Protocol):
+    def writeln(self, arg: str | None = None) -> str: ...
+
+# _WritelnDecorator should have all the same attrs as its stream param.
+# But that's not feasible to do Generically
+# We can expand the attributes if requested
+class _WritelnDecorator(_TextTestStream):
+    def __init__(self, stream: _TextTestStream) -> None: ...
+    def __getattr__(self, attr: str) -> Any: ...  # Any attribute from the stream type passed to __init__
+    # These attributes are prevented by __getattr__
+    stream: Never
+    __getstate__: Never
+
+_StreamT = TypeVar("_StreamT", bound=_TextTestStream, default=_WritelnDecorator)
+
+class TextTestResult(unittest.result.TestResult, Generic[_StreamT]):
    descriptions: bool  # undocumented
    dots: bool  # undocumented
    separator1: str
    separator2: str
    showAll: bool  # undocumented
-    stream: TextIO  # undocumented
+    stream: _StreamT  # undocumented
    if sys.version_info >= (3, 12):
        durations: unittest.result._DurationsType | None
        def __init__(
-            self, stream: TextIO, descriptions: bool, verbosity: int, *, durations: unittest.result._DurationsType | None = None
+            self, stream: _StreamT, descriptions: bool, verbosity: int, *, durations: unittest.result._DurationsType | None = None
        ) -> None: ...
    else:
-        def __init__(self, stream: TextIO, descriptions: bool, verbosity: int) -> None: ...
+        def __init__(self, stream: _StreamT, descriptions: bool, verbosity: int) -> None: ...

    def getDescription(self, test: unittest.case.TestCase) -> str: ...
    def printErrorList(self, flavour: str, errors: Iterable[tuple[unittest.case.TestCase, str]]) -> None: ...

 class TextTestRunner:
    resultclass: _ResultClassType
-    # TODO: add `_WritelnDecorator` type
-    # stream: _WritelnDecorator
-    stream: Incomplete
+    stream: _WritelnDecorator
    descriptions: bool
    verbosity: int
    failfast: bool
@@ -43,7 +59,7 @@ class TextTestRunner:
        durations: unittest.result._DurationsType | None
        def __init__(
            self,
-            stream: TextIO | None = None,
+            stream: _SupportsWriteAndFlush | None = None,
            descriptions: bool = True,
            verbosity: int = 1,
            failfast: bool = False,
@@ -57,7 +73,7 @@ class TextTestRunner:
    else:
        def __init__(
            self,
-            stream: TextIO | None = None,
+            stream: _SupportsWriteAndFlush | None = None,
            descriptions: bool = True,
            verbosity: int = 1,
            failfast: bool = False,
@@ -68,5 +84,5 @@ class TextTestRunner:
            tb_locals: bool = False,
        ) -> None: ...

-    def _makeResult(self) -> unittest.result.TestResult: ...
-    def run(self, test: unittest.suite.TestSuite | unittest.case.TestCase) -> unittest.result.TestResult: ...
+    def _makeResult(self) -> TextTestResult: ...
+    def run(self, test: unittest.suite.TestSuite | unittest.case.TestCase) -> TextTestResult: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/zipfile/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/zipfile/init.pyi
@@ -304,6 +304,7 @@ else:

    class Path:
        root: CompleteDirs
+        at: str
        def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
        @property
        def name(self) -> str: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/zipfile/_path.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/zipfile/_path.pyi
@@ -31,6 +31,7 @@ if sys.version_info >= (3, 12):

    class Path:
        root: CompleteDirs
+        at: str
        def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
        @property
        def name(self) -> str: ...
--- a/crates/red_knot_server/Cargo.toml
+++ b/crates/red_knot_server/Cargo.toml
@@ -11,10 +11,8 @@ 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,11 +3,11 @@
 use std::num::NonZeroUsize;
 use std::panic::PanicInfo;

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

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

-        let mut workspace_for_url = |url: lsp_types::Url| {
+        let mut workspace_for_url = |url: Url| {
            let Some(workspace_settings) = workspace_settings.as_mut() else {
                return (url, ClientSettings::default());
            };
@@ -93,13 +93,18 @@ 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 = types::Url::from_file_path(std::env::current_dir().ok()?).ok()?;
+                let uri = Url::from_file_path(std::env::current_dir().ok()?).ok()?;
                Some(vec![workspace_for_url(uri)])
            })
            .ok_or_else(|| {
                anyhow::anyhow!("Failed to get the current working directory while creating a default workspace.")
            })?;

+        if workspaces.len() > 1 {
+            // TODO(dhruvmanila): Support multi-root workspaces
+            anyhow::bail!("Multi-root workspaces are not supported yet");
+        }
+
        Ok(Self {
            connection,
            worker_threads,
@@ -149,7 +154,7 @@ impl Server {
            try_show_message(
                "The Ruff language server exited with a panic. See the logs for more details."
                    .to_string(),
-                lsp_types::MessageType::ERROR,
+                MessageType::ERROR,
            )
            .ok();
        }));
@@ -182,9 +187,9 @@ impl Server {
                break;
            }
            let task = match msg {
-                lsp::Message::Request(req) => api::request(req),
-                lsp::Message::Notification(notification) => api::notification(notification),
-                lsp::Message::Response(response) => scheduler.response(response),
+                Message::Request(req) => api::request(req),
+                Message::Notification(notification) => api::notification(notification),
+                Message::Response(response) => scheduler.response(response),
            };
            scheduler.dispatch(task);
        }
@@ -206,28 +211,17 @@ impl Server {
            .unwrap_or_default()
    }

-    fn server_capabilities(position_encoding: PositionEncoding) -> types::ServerCapabilities {
-        types::ServerCapabilities {
+    fn server_capabilities(position_encoding: PositionEncoding) -> ServerCapabilities {
+        ServerCapabilities {
            position_encoding: Some(position_encoding.into()),
-            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(),
+            diagnostic_provider: Some(DiagnosticServerCapabilities::Options(DiagnosticOptions {
+                identifier: Some(crate::DIAGNOSTIC_NAME.into()),
+                ..Default::default()
            })),
            text_document_sync: Some(TextDocumentSyncCapability::Options(
                TextDocumentSyncOptions {
                    open_close: Some(true),
+                    change: Some(TextDocumentSyncKind::INCREMENTAL),
                    ..Default::default()
                },
            )),
--- a/crates/red_knot_server/src/server/api.rs
+++ b/crates/red_knot_server/src/server/api.rs
@@ -1,13 +1,15 @@
-use crate::{server::schedule::Task, session::Session, system::url_to_system_path};
 use lsp_server as server;

+use crate::server::schedule::Task;
+use crate::session::Session;
+use crate::system::{url_to_any_system_path, AnySystemPath};
+
 mod diagnostics;
 mod notifications;
 mod requests;
 mod traits;

 use notifications as notification;
-use red_knot_workspace::db::RootDatabase;
 use requests as request;

 use self::traits::{NotificationHandler, RequestHandler};
@@ -43,6 +45,7 @@ pub(super) fn notification<'a>(notif: server::Notification) -> Task<'a> {
    match notif.method.as_str() {
        notification::DidCloseTextDocumentHandler::METHOD => local_notification_task::<notification::DidCloseTextDocumentHandler>(notif),
        notification::DidOpenTextDocumentHandler::METHOD => local_notification_task::<notification::DidOpenTextDocumentHandler>(notif),
+        notification::DidChangeTextDocumentHandler::METHOD => local_notification_task::<notification::DidChangeTextDocumentHandler>(notif),
        notification::DidOpenNotebookHandler::METHOD => {
            local_notification_task::<notification::DidOpenNotebookHandler>(notif)
        }
@@ -82,12 +85,18 @@ fn background_request_task<'a, R: traits::BackgroundDocumentRequestHandler>(
    Ok(Task::background(schedule, move |session: &Session| {
        let url = R::document_url(&params).into_owned();

-        let Ok(path) = url_to_system_path(&url) else {
+        let Ok(path) = url_to_any_system_path(&url) else {
            return Box::new(|_, _| {});
        };
-        let db = session
-            .workspace_db_for_path(path.as_std_path())
-            .map(RootDatabase::snapshot);
+        let db = match path {
+            AnySystemPath::System(path) => {
+                match session.workspace_db_for_path(path.as_std_path()) {
+                    Some(db) => db.snapshot(),
+                    None => session.default_workspace_db().snapshot(),
+                }
+            }
+            AnySystemPath::SystemVirtual(_) => session.default_workspace_db().snapshot(),
+        };

        let Some(snapshot) = session.take_snapshot(url) else {
            return Box::new(|_, _| {});
--- a/crates/red_knot_server/src/server/api/notifications.rs
+++ b/crates/red_knot_server/src/server/api/notifications.rs
@@ -1,9 +1,11 @@
+mod did_change;
 mod did_close;
 mod did_close_notebook;
 mod did_open;
 mod did_open_notebook;
 mod set_trace;

+pub(super) use did_change::DidChangeTextDocumentHandler;
 pub(super) use did_close::DidCloseTextDocumentHandler;
 pub(super) use did_close_notebook::DidCloseNotebookHandler;
 pub(super) use did_open::DidOpenTextDocumentHandler;
--- a/crates/red_knot_server/src/server/api/notifications/did_change.rs
+++ b/crates/red_knot_server/src/server/api/notifications/did_change.rs
@@ -0,0 +1,55 @@
+use lsp_server::ErrorCode;
+use lsp_types::notification::DidChangeTextDocument;
+use lsp_types::DidChangeTextDocumentParams;
+
+use red_knot_workspace::watch::ChangeEvent;
+
+use crate::server::api::traits::{NotificationHandler, SyncNotificationHandler};
+use crate::server::api::LSPResult;
+use crate::server::client::{Notifier, Requester};
+use crate::server::Result;
+use crate::session::Session;
+use crate::system::{url_to_any_system_path, AnySystemPath};
+
+pub(crate) struct DidChangeTextDocumentHandler;
+
+impl NotificationHandler for DidChangeTextDocumentHandler {
+    type NotificationType = DidChangeTextDocument;
+}
+
+impl SyncNotificationHandler for DidChangeTextDocumentHandler {
+    fn run(
+        session: &mut Session,
+        _notifier: Notifier,
+        _requester: &mut Requester,
+        params: DidChangeTextDocumentParams,
+    ) -> Result<()> {
+        let Ok(path) = url_to_any_system_path(&params.text_document.uri) else {
+            return Ok(());
+        };
+
+        let key = session.key_from_url(params.text_document.uri);
+
+        session
+            .update_text_document(&key, params.content_changes, params.text_document.version)
+            .with_failure_code(ErrorCode::InternalError)?;
+
+        match path {
+            AnySystemPath::System(path) => {
+                let db = match session.workspace_db_for_path_mut(path.as_std_path()) {
+                    Some(db) => db,
+                    None => session.default_workspace_db_mut(),
+                };
+                db.apply_changes(vec![ChangeEvent::file_content_changed(path)], None);
+            }
+            AnySystemPath::SystemVirtual(virtual_path) => {
+                let db = session.default_workspace_db_mut();
+                db.apply_changes(vec![ChangeEvent::ChangedVirtual(virtual_path)], None);
+            }
+        }
+
+        // TODO(dhruvmanila): Publish diagnostics if the client doesnt support pull diagnostics
+
+        Ok(())
+    }
+}
--- a/crates/red_knot_server/src/server/api/notifications/did_close.rs
+++ b/crates/red_knot_server/src/server/api/notifications/did_close.rs
@@ -1,8 +1,7 @@
 use lsp_server::ErrorCode;
 use lsp_types::notification::DidCloseTextDocument;
 use lsp_types::DidCloseTextDocumentParams;
-
-use ruff_db::files::File;
+use red_knot_workspace::watch::ChangeEvent;

 use crate::server::api::diagnostics::clear_diagnostics;
 use crate::server::api::traits::{NotificationHandler, SyncNotificationHandler};
@@ -10,7 +9,7 @@ use crate::server::api::LSPResult;
 use crate::server::client::{Notifier, Requester};
 use crate::server::Result;
 use crate::session::Session;
-use crate::system::url_to_system_path;
+use crate::system::{url_to_any_system_path, AnySystemPath};

 pub(crate) struct DidCloseTextDocumentHandler;

@@ -25,7 +24,7 @@ impl SyncNotificationHandler for DidCloseTextDocumentHandler {
        _requester: &mut Requester,
        params: DidCloseTextDocumentParams,
    ) -> Result<()> {
-        let Ok(path) = url_to_system_path(&params.text_document.uri) else {
+        let Ok(path) = url_to_any_system_path(&params.text_document.uri) else {
            return Ok(());
        };

@@ -34,8 +33,9 @@ impl SyncNotificationHandler for DidCloseTextDocumentHandler {
            .close_document(&key)
            .with_failure_code(ErrorCode::InternalError)?;

-        if let Some(db) = session.workspace_db_for_path_mut(path.as_std_path()) {
-            File::sync_path(db, &path);
+        if let AnySystemPath::SystemVirtual(virtual_path) = path {
+            let db = session.default_workspace_db_mut();
+            db.apply_changes(vec![ChangeEvent::DeletedVirtual(virtual_path)], None);
        }

        clear_diagnostics(key.url(), &notifier)?;
--- a/crates/red_knot_server/src/server/api/notifications/did_close_notebook.rs
+++ b/crates/red_knot_server/src/server/api/notifications/did_close_notebook.rs
@@ -1,14 +1,14 @@
 use lsp_types::notification::DidCloseNotebookDocument;
 use lsp_types::DidCloseNotebookDocumentParams;

-use ruff_db::files::File;
+use red_knot_workspace::watch::ChangeEvent;

 use crate::server::api::traits::{NotificationHandler, SyncNotificationHandler};
 use crate::server::api::LSPResult;
 use crate::server::client::{Notifier, Requester};
 use crate::server::Result;
 use crate::session::Session;
-use crate::system::url_to_system_path;
+use crate::system::{url_to_any_system_path, AnySystemPath};

 pub(crate) struct DidCloseNotebookHandler;

@@ -23,7 +23,7 @@ impl SyncNotificationHandler for DidCloseNotebookHandler {
        _requester: &mut Requester,
        params: DidCloseNotebookDocumentParams,
    ) -> Result<()> {
-        let Ok(path) = url_to_system_path(&params.notebook_document.uri) else {
+        let Ok(path) = url_to_any_system_path(&params.notebook_document.uri) else {
            return Ok(());
        };

@@ -32,8 +32,9 @@ impl SyncNotificationHandler for DidCloseNotebookHandler {
            .close_document(&key)
            .with_failure_code(lsp_server::ErrorCode::InternalError)?;

-        if let Some(db) = session.workspace_db_for_path_mut(path.as_std_path()) {
-            File::sync_path(db, &path);
+        if let AnySystemPath::SystemVirtual(virtual_path) = path {
+            let db = session.default_workspace_db_mut();
+            db.apply_changes(vec![ChangeEvent::DeletedVirtual(virtual_path)], None);
        }

        Ok(())
--- a/crates/red_knot_server/src/server/api/notifications/did_open.rs
+++ b/crates/red_knot_server/src/server/api/notifications/did_open.rs
@@ -1,13 +1,14 @@
 use lsp_types::notification::DidOpenTextDocument;
 use lsp_types::DidOpenTextDocumentParams;

-use ruff_db::files::system_path_to_file;
+use red_knot_workspace::watch::ChangeEvent;
+use ruff_db::Db;

 use crate::server::api::traits::{NotificationHandler, SyncNotificationHandler};
 use crate::server::client::{Notifier, Requester};
 use crate::server::Result;
 use crate::session::Session;
-use crate::system::url_to_system_path;
+use crate::system::{url_to_any_system_path, AnySystemPath};
 use crate::TextDocument;

 pub(crate) struct DidOpenTextDocumentHandler;
@@ -23,17 +24,25 @@ impl SyncNotificationHandler for DidOpenTextDocumentHandler {
        _requester: &mut Requester,
        params: DidOpenTextDocumentParams,
    ) -> Result<()> {
-        let Ok(path) = url_to_system_path(&params.text_document.uri) else {
+        let Ok(path) = url_to_any_system_path(&params.text_document.uri) else {
            return Ok(());
        };

        let document = TextDocument::new(params.text_document.text, params.text_document.version);
        session.open_text_document(params.text_document.uri, document);

-        if let Some(db) = session.workspace_db_for_path_mut(path.as_std_path()) {
-            // TODO(dhruvmanila): Store the `file` in `DocumentController`
-            let file = system_path_to_file(db, &path).unwrap();
-            file.sync(db);
+        match path {
+            AnySystemPath::System(path) => {
+                let db = match session.workspace_db_for_path_mut(path.as_std_path()) {
+                    Some(db) => db,
+                    None => session.default_workspace_db_mut(),
+                };
+                db.apply_changes(vec![ChangeEvent::Opened(path)], None);
+            }
+            AnySystemPath::SystemVirtual(virtual_path) => {
+                let db = session.default_workspace_db_mut();
+                db.files().virtual_file(db, &virtual_path);
+            }
        }

        // TODO(dhruvmanila): Publish diagnostics if the client doesn't support pull diagnostics
--- a/crates/red_knot_server/src/server/api/notifications/did_open_notebook.rs
+++ b/crates/red_knot_server/src/server/api/notifications/did_open_notebook.rs
@@ -2,7 +2,8 @@ use lsp_server::ErrorCode;
 use lsp_types::notification::DidOpenNotebookDocument;
 use lsp_types::DidOpenNotebookDocumentParams;

-use ruff_db::files::system_path_to_file;
+use red_knot_workspace::watch::ChangeEvent;
+use ruff_db::Db;

 use crate::edit::NotebookDocument;
 use crate::server::api::traits::{NotificationHandler, SyncNotificationHandler};
@@ -10,7 +11,7 @@ use crate::server::api::LSPResult;
 use crate::server::client::{Notifier, Requester};
 use crate::server::Result;
 use crate::session::Session;
-use crate::system::url_to_system_path;
+use crate::system::{url_to_any_system_path, AnySystemPath};

 pub(crate) struct DidOpenNotebookHandler;

@@ -25,7 +26,7 @@ impl SyncNotificationHandler for DidOpenNotebookHandler {
        _requester: &mut Requester,
        params: DidOpenNotebookDocumentParams,
    ) -> Result<()> {
-        let Ok(path) = url_to_system_path(&params.notebook_document.uri) else {
+        let Ok(path) = url_to_any_system_path(&params.notebook_document.uri) else {
            return Ok(());
        };

@@ -38,10 +39,18 @@ impl SyncNotificationHandler for DidOpenNotebookHandler {
        .with_failure_code(ErrorCode::InternalError)?;
        session.open_notebook_document(params.notebook_document.uri.clone(), notebook);

-        if let Some(db) = session.workspace_db_for_path_mut(path.as_std_path()) {
-            // TODO(dhruvmanila): Store the `file` in `DocumentController`
-            let file = system_path_to_file(db, &path).unwrap();
-            file.sync(db);
+        match path {
+            AnySystemPath::System(path) => {
+                let db = match session.workspace_db_for_path_mut(path.as_std_path()) {
+                    Some(db) => db,
+                    None => session.default_workspace_db_mut(),
+                };
+                db.apply_changes(vec![ChangeEvent::Opened(path)], None);
+            }
+            AnySystemPath::SystemVirtual(virtual_path) => {
+                let db = session.default_workspace_db_mut();
+                db.files().virtual_file(db, &virtual_path);
+            }
        }

        // TODO(dhruvmanila): Publish diagnostics if the client doesn't support pull diagnostics
--- a/crates/red_knot_server/src/server/api/requests/diagnostic.rs
+++ b/crates/red_knot_server/src/server/api/requests/diagnostic.rs
@@ -26,13 +26,11 @@ impl BackgroundDocumentRequestHandler for DocumentDiagnosticRequestHandler {

    fn run_with_snapshot(
        snapshot: DocumentSnapshot,
-        db: Option<RootDatabase>,
+        db: RootDatabase,
        _notifier: Notifier,
        _params: DocumentDiagnosticParams,
    ) -> Result<DocumentDiagnosticReportResult> {
-        let diagnostics = db
-            .map(|db| compute_diagnostics(&snapshot, &db))
-            .unwrap_or_default();
+        let diagnostics = compute_diagnostics(&snapshot, &db);

        Ok(DocumentDiagnosticReportResult::Report(
            DocumentDiagnosticReport::Full(RelatedFullDocumentDiagnosticReport {
@@ -48,10 +46,19 @@ impl BackgroundDocumentRequestHandler for DocumentDiagnosticRequestHandler {

 fn compute_diagnostics(snapshot: &DocumentSnapshot, db: &RootDatabase) -> Vec<Diagnostic> {
    let Some(file) = snapshot.file(db) else {
+        tracing::info!(
+            "No file found for snapshot for '{}'",
+            snapshot.query().file_url()
+        );
        return vec![];
    };
-    let Ok(diagnostics) = db.check_file(file) else {
-        return vec![];
+
+    let diagnostics = match db.check_file(file) {
+        Ok(diagnostics) => diagnostics,
+        Err(cancelled) => {
+            tracing::info!("Diagnostics computation {cancelled}");
+            return vec![];
+        }
    };

    diagnostics
@@ -65,12 +72,12 @@ fn to_lsp_diagnostic(message: &str) -> Diagnostic {
    let words = message.split(':').collect::<Vec<_>>();

    let (range, message) = match words.as_slice() {
-        [_filename, line, column, message] => {
-            let line = line.parse::<u32>().unwrap_or_default();
+        [_, _, line, column, message] | [_, line, column, message] => {
+            let line = line.parse::<u32>().unwrap_or_default().saturating_sub(1);
            let column = column.parse::<u32>().unwrap_or_default();
            (
                Range::new(
-                    Position::new(line.saturating_sub(1), column.saturating_sub(1)),
+                    Position::new(line, column.saturating_sub(1)),
                    Position::new(line, column),
                ),
                message.trim(),
--- a/crates/red_knot_server/src/server/api/traits.rs
+++ b/crates/red_knot_server/src/server/api/traits.rs
@@ -34,7 +34,7 @@ pub(super) trait BackgroundDocumentRequestHandler: RequestHandler {

    fn run_with_snapshot(
        snapshot: DocumentSnapshot,
-        db: Option<RootDatabase>,
+        db: RootDatabase,
        notifier: Notifier,
        params: <<Self as RequestHandler>::RequestType as Request>::Params,
    ) -> super::Result<<<Self as RequestHandler>::RequestType as Request>::Result>;
--- a/crates/red_knot_server/src/session.rs
+++ b/crates/red_knot_server/src/session.rs
@@ -6,16 +6,16 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;

 use anyhow::anyhow;
-use lsp_types::{ClientCapabilities, Url};
+use lsp_types::{ClientCapabilities, TextDocumentContentChangeEvent, 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};
 use ruff_db::system::SystemPath;
+use ruff_db::Db;

-use crate::edit::{DocumentKey, NotebookDocument};
-use crate::system::{url_to_system_path, LSPSystem};
+use crate::edit::{DocumentKey, DocumentVersion, NotebookDocument};
+use crate::system::{url_to_any_system_path, AnySystemPath, LSPSystem};
 use crate::{PositionEncoding, TextDocument};

 pub(crate) use self::capabilities::ResolvedClientCapabilities;
@@ -67,19 +67,10 @@ 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 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,
-                },
-            };
+            let metadata = WorkspaceMetadata::from_path(system_path, &system, None)?;
            // TODO(micha): Handle the case where the program settings are incorrect more gracefully.
-            workspaces.insert(path, RootDatabase::new(metadata, program_settings, system)?);
+            workspaces.insert(path, RootDatabase::new(metadata, system)?);
        }

        Ok(Self {
@@ -92,6 +83,12 @@ impl Session {
        })
    }

+    // TODO(dhruvmanila): Ideally, we should have a single method for `workspace_db_for_path_mut`
+    // and `default_workspace_db_mut` but the borrow checker doesn't allow that.
+    // https://github.com/astral-sh/ruff/pull/13041#discussion_r1726725437
+
+    /// Returns a reference to the workspace [`RootDatabase`] corresponding to the given path, if
+    /// any.
    pub(crate) fn workspace_db_for_path(&self, path: impl AsRef<Path>) -> Option<&RootDatabase> {
        self.workspaces
            .range(..=path.as_ref().to_path_buf())
@@ -99,6 +96,8 @@ impl Session {
            .map(|(_, db)| db)
    }

+    /// Returns a mutable reference to the workspace [`RootDatabase`] corresponding to the given
+    /// path, if any.
    pub(crate) fn workspace_db_for_path_mut(
        &mut self,
        path: impl AsRef<Path>,
@@ -109,6 +108,19 @@ impl Session {
            .map(|(_, db)| db)
    }

+    /// Returns a reference to the default workspace [`RootDatabase`]. The default workspace is the
+    /// minimum root path in the workspace map.
+    pub(crate) fn default_workspace_db(&self) -> &RootDatabase {
+        // SAFETY: Currently, red knot only support a single workspace.
+        self.workspaces.values().next().unwrap()
+    }
+
+    /// Returns a mutable reference to the default workspace [`RootDatabase`].
+    pub(crate) fn default_workspace_db_mut(&mut self) -> &mut RootDatabase {
+        // SAFETY: Currently, red knot only support a single workspace.
+        self.workspaces.values_mut().next().unwrap()
+    }
+
    pub fn key_from_url(&self, url: Url) -> DocumentKey {
        self.index().key_from_url(url)
    }
@@ -135,6 +147,20 @@ impl Session {
        self.index_mut().open_text_document(url, document);
    }

+    /// Updates a text document at the associated `key`.
+    ///
+    /// The document key must point to a text document, or this will throw an error.
+    pub(crate) fn update_text_document(
+        &mut self,
+        key: &DocumentKey,
+        content_changes: Vec<TextDocumentContentChangeEvent>,
+        new_version: DocumentVersion,
+    ) -> crate::Result<()> {
+        let position_encoding = self.position_encoding;
+        self.index_mut()
+            .update_text_document(key, content_changes, new_version, position_encoding)
+    }
+
    /// De-registers a document, specified by its key.
    /// Calling this multiple times for the same document is a logic error.
    pub(crate) fn close_document(&mut self, key: &DocumentKey) -> crate::Result<()> {
@@ -221,6 +247,7 @@ impl Drop for MutIndexGuard<'_> {

 /// An immutable snapshot of `Session` that references
 /// a specific document.
+#[derive(Debug)]
 pub struct DocumentSnapshot {
    resolved_client_capabilities: Arc<ResolvedClientCapabilities>,
    document_ref: index::DocumentQuery,
@@ -241,7 +268,12 @@ impl DocumentSnapshot {
    }

    pub(crate) fn file(&self, db: &RootDatabase) -> Option<File> {
-        let path = url_to_system_path(self.document_ref.file_url()).ok()?;
-        system_path_to_file(db, path).ok()
+        match url_to_any_system_path(self.document_ref.file_url()).ok()? {
+            AnySystemPath::System(path) => system_path_to_file(db, path).ok(),
+            AnySystemPath::SystemVirtual(virtual_path) => db
+                .files()
+                .try_virtual_file(&virtual_path)
+                .map(|virtual_file| virtual_file.file()),
+        }
    }
 }
--- a/crates/red_knot_server/src/session/capabilities.rs
+++ b/crates/red_knot_server/src/session/capabilities.rs
@@ -1,5 +1,4 @@
 use lsp_types::ClientCapabilities;
-use ruff_linter::display_settings;

 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 #[allow(clippy::struct_excessive_bools)]
@@ -66,20 +65,3 @@ 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,18 +278,6 @@ 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_server/src/system.rs
+++ b/crates/red_knot_server/src/system.rs
@@ -8,27 +8,40 @@ use ruff_db::file_revision::FileRevision;
 use ruff_db::system::walk_directory::WalkDirectoryBuilder;
 use ruff_db::system::{
    DirectoryEntry, FileType, Metadata, OsSystem, Result, System, SystemPath, SystemPathBuf,
-    SystemVirtualPath,
+    SystemVirtualPath, SystemVirtualPathBuf,
 };
 use ruff_notebook::{Notebook, NotebookError};

 use crate::session::index::Index;
 use crate::DocumentQuery;

-/// Converts the given [`Url`] to a [`SystemPathBuf`].
+/// Converts the given [`Url`] to an [`AnySystemPath`].
+///
+/// If the URL scheme is `file`, then the path is converted to a [`SystemPathBuf`]. Otherwise, the
+/// URL is converted to a [`SystemVirtualPathBuf`].
 ///
 /// This fails in the following cases:
-/// * The URL scheme is not `file`.
 /// * The URL cannot be converted to a file path (refer to [`Url::to_file_path`]).
 /// * If the URL is not a valid UTF-8 string.
-pub(crate) fn url_to_system_path(url: &Url) -> std::result::Result<SystemPathBuf, ()> {
+pub(crate) fn url_to_any_system_path(url: &Url) -> std::result::Result<AnySystemPath, ()> {
    if url.scheme() == "file" {
-        Ok(SystemPathBuf::from_path_buf(url.to_file_path()?).map_err(|_| ())?)
+        Ok(AnySystemPath::System(
+            SystemPathBuf::from_path_buf(url.to_file_path()?).map_err(|_| ())?,
+        ))
    } else {
-        Err(())
+        Ok(AnySystemPath::SystemVirtual(
+            SystemVirtualPath::new(url.as_str()).to_path_buf(),
+        ))
    }
 }

+/// Represents either a [`SystemPath`] or a [`SystemVirtualPath`].
+#[derive(Debug)]
+pub(crate) enum AnySystemPath {
+    System(SystemPathBuf),
+    SystemVirtual(SystemVirtualPathBuf),
+}
+
 #[derive(Debug)]
 pub(crate) struct LSPSystem {
    /// A read-only copy of the index where the server stores all the open documents and settings.
@@ -144,19 +157,6 @@ impl System for LSPSystem {
        }
    }

-    fn virtual_path_metadata(&self, path: &SystemVirtualPath) -> Result<Metadata> {
-        // Virtual paths only exists in the LSP system, so we don't need to check the OS system.
-        let document = self
-            .system_virtual_path_to_document_ref(path)?
-            .ok_or_else(|| virtual_path_not_found(path))?;
-
-        Ok(Metadata::new(
-            document_revision(&document),
-            None,
-            FileType::File,
-        ))
-    }
-
    fn read_virtual_path_to_string(&self, path: &SystemVirtualPath) -> Result<String> {
        let document = self
            .system_virtual_path_to_document_ref(path)?
--- a/Show More
+++ b/Show More