Move docs

Tested on Fedora 40 with Podman 5.1.1 and ruff "0.5.0" and "latest".
source: https://unix.stackexchange.com/q/651198

.github/CODEOWNERS

@@ -17,5 +17,4 @@
 /scripts/fuzz-parser/ @AlexWaygood
 
 # red-knot
-/crates/red_knot* @carljm @MichaReiser @AlexWaygood
-/crates/ruff_db/ @carljm @MichaReiser @AlexWaygood
+/crates/red_knot/ @carljm @MichaReiser

.github/workflows/build-docker.yml

@@ -56,7 +56,7 @@ jobs:
           fi
 
       - name: "Build and push Docker image"
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v5
         with:
           context: .
           platforms: linux/amd64,linux/arm64

.github/workflows/publish-docs.yaml

@@ -0,0 +1,62 @@
+# Publish the Ruff documentation.
+#
+# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a post-announce
+# job within `cargo-dist`.
+name: mkdocs
+
+on:
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: "The commit SHA, tag, or branch to publish. Uses the default branch if not specified."
+        default: ""
+        type: string
+  workflow_call:
+    inputs:
+      plan:
+        required: true
+        type: string
+
+jobs:
+  mkdocs:
+    runs-on: ubuntu-latest
+    env:
+      CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
+      MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref }}
+      - uses: actions/setup-python@v5
+      - name: "Add SSH key"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        uses: webfactory/ssh-agent@v0.9.0
+        with:
+          ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - uses: Swatinem/rust-cache@v2
+      - name: "Install Insiders dependencies"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        run: pip install -r docs/requirements-insiders.txt
+      - name: "Install dependencies"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
+        run: pip install -r docs/requirements.txt
+      - name: "Copy README File"
+        run: |
+          python scripts/transform_readme.py --target mkdocs
+          python scripts/generate_mkdocs.py
+      - name: "Build Insiders docs"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        run: mkdocs build --strict -f mkdocs.insiders.yml
+      - name: "Build docs"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
+        run: mkdocs build --strict -f mkdocs.public.yml
+      - name: "Deploy to Cloudflare Pages"
+        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
+        uses: cloudflare/wrangler-action@v3.6.1
+        with:
+          apiToken: ${{ secrets.CF_API_TOKEN }}
+          accountId: ${{ secrets.CF_ACCOUNT_ID }}
+          # `github.head_ref` is only set during pull requests and for manual runs or tags we use `main` to deploy to production
+          command: pages deploy site --project-name=astral-docs --branch ${{ github.head_ref || 'main' }} --commit-hash ${GITHUB_SHA}

.github/workflows/publish-docs.yml

@@ -1,151 +0,0 @@
-# Publish the Ruff documentation.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a post-announce
-# job within `cargo-dist`.
-name: mkdocs
-
-on:
-  workflow_dispatch:
-    inputs:
-      ref:
-        description: "The commit SHA, tag, or branch to publish. Uses the default branch if not specified."
-        default: ""
-        type: string
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-jobs:
-  mkdocs:
-    runs-on: ubuntu-latest
-    env:
-      MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ inputs.ref }}
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: 3.12
-
-      - 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
-          fi
-
-          # Use version as display name for now
-          display_name="$version"
-
-          echo "version=$version" >> $GITHUB_ENV
-          echo "display_name=$display_name" >> $GITHUB_ENV
-
-      - name: "Set branch name"
-        run: |
-          version="${{ env.version }}"
-          display_name="${{ env.display_name }}"
-          timestamp="$(date +%s)"
-
-          # create branch_display_name from display_name by replacing all
-          # characters disallowed in git branch names with hyphens
-          branch_display_name="$(echo "$display_name" | tr -c '[:alnum:]._' '-' | tr -s '-')"
-
-          echo "branch_name=update-docs-$branch_display_name-$timestamp" >> $GITHUB_ENV
-          echo "timestamp=$timestamp" >> $GITHUB_ENV
-
-      - name: "Add SSH key"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        uses: webfactory/ssh-agent@v0.9.0
-        with:
-          ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
-
-      - name: "Install Rust toolchain"
-        run: rustup show
-
-      - uses: Swatinem/rust-cache@v2
-
-      - name: "Install Insiders dependencies"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        run: pip install -r docs/requirements-insiders.txt
-
-      - name: "Install dependencies"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
-        run: pip install -r docs/requirements.txt
-
-      - name: "Copy README File"
-        run: |
-          python scripts/transform_readme.py --target mkdocs
-          python scripts/generate_mkdocs.py
-
-      - name: "Build Insiders docs"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        run: mkdocs build --strict -f mkdocs.insiders.yml
-
-      - name: "Build docs"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
-        run: mkdocs build --strict -f mkdocs.public.yml
-
-      - name: "Clone docs repo"
-        run: |
-          version="${{ env.version }}"
-          git clone https://${{ secrets.ASTRAL_DOCS_PAT }}@github.com/astral-sh/docs.git astral-docs
-
-      - name: "Copy docs"
-        run: rm -rf astral-docs/site/ruff && mkdir -p astral-docs/site && cp -r site/ruff astral-docs/site/
-
-      - name: "Commit docs"
-        working-directory: astral-docs
-        run: |
-          branch_name="${{ env.branch_name }}"
-
-          git config user.name "$GITHUB_ACTOR"
-          git config user.email "$GITHUB_ACTOR@users.noreply.github.com"
-
-          git checkout -b $branch_name
-          git add site/ruff
-          git commit -m "Update ruff documentation for $version"
-
-      - name: "Create Pull Request"
-        working-directory: astral-docs
-        env:
-          GITHUB_TOKEN: ${{ secrets.ASTRAL_DOCS_PAT }}
-        run: |
-          version="${{ env.version }}"
-          display_name="${{ env.display_name }}"
-          branch_name="${{ env.branch_name }}"
-
-          # set the PR title
-          pull_request_title="Update ruff documentation for $display_name"
-
-          # Delete any existing pull requests that are open for this version
-          # by checking against pull_request_title because the new PR will
-          # supersede the old one.
-          gh pr list --state open --json title --jq '.[] | select(.title == "$pull_request_title") | .number' | \
-            xargs -I {} gh pr close {}
-
-          # push the branch to GitHub
-          git push origin $branch_name
-
-          # create the PR
-          gh pr create --base main --head $branch_name \
-            --title "$pull_request_title" \
-            --body "Automated documentation update for $display_name" \
-            --label "documentation"
-
-      - name: "Merge Pull Request"
-        if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-        working-directory: astral-docs
-        env:
-          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
-          gh pr merge --squash $branch_name

.github/workflows/publish-playground.yaml

@@ -47,7 +47,7 @@ jobs:
         working-directory: playground
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.7.0
+        uses: cloudflare/wrangler-action@v3.6.1
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/publish-wasm.yml

@@ -1,55 +0,0 @@
-# Build and publish ruff-api for wasm.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a publish
-# job within `cargo-dist`.
-name: "Build and publish wasm"
-
-on:
-  workflow_dispatch:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-
-jobs:
-  ruff_wasm:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    strategy:
-      matrix:
-        target: [web, bundler, nodejs]
-      fail-fast: false
-    steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup target add wasm32-unknown-unknown
-      - uses: jetli/wasm-pack-action@v0.4.0
-      - uses: jetli/wasm-bindgen-action@v0.2.0
-      - name: "Run wasm-pack build"
-        run: wasm-pack build --target ${{ matrix.target }} crates/ruff_wasm
-      - name: "Rename generated package"
-        run: | # Replace the package name w/ jq
-          jq '.name="@astral-sh/ruff-wasm-${{ matrix.target }}"' crates/ruff_wasm/pkg/package.json > /tmp/package.json
-          mv /tmp/package.json crates/ruff_wasm/pkg
-      - run: cp LICENSE crates/ruff_wasm/pkg # wasm-pack does not put the LICENSE file in the pkg
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 18
-          registry-url: "https://registry.npmjs.org"
-      - name: "Publish (dry-run)"
-        if: ${{ inputs.plan == '' || fromJson(inputs.plan).announcement_tag_is_implicit }}
-        run: npm publish --dry-run crates/ruff_wasm/pkg
-      - name: "Publish"
-        if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-        run: npm publish --provenance --access public crates/ruff_wasm/pkg
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/release.yml

@@ -12,8 +12,9 @@
 # title/body based on your changelogs.
 
 name: Release
+
 permissions:
-  "contents": "write"
+  contents: write
 
 # This task will run whenever you workflow_dispatch with a tag that looks like a version
 # like "1.0.0", "v0.1.0-prerelease.1", "my-app/0.1.0", "releases/v1.0.0", etc.
@@ -48,7 +49,7 @@ on:
 jobs:
   # Run 'cargo dist plan' (or host) to determine what tasks we need to do
   plan:
-    runs-on: "ubuntu-20.04"
+    runs-on: ubuntu-latest
     outputs:
       val: ${{ steps.plan.outputs.manifest }}
       tag: ${{ (inputs.tag != 'dry-run' && inputs.tag) || '' }}
@@ -64,12 +65,7 @@ jobs:
         # we specify bash to get pipefail; it guards against the `curl` command
         # failing. otherwise `sh` won't catch that `curl` returned non-0
         shell: bash
-        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.18.0/cargo-dist-installer.sh | sh"
-      - name: Cache cargo-dist
-        uses: actions/upload-artifact@v4
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/cargo-dist
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.14.0/cargo-dist-installer.sh | sh"
       # sure would be cool if github gave us proper conditionals...
       # so here's a doubly-nested ternary-via-truthiness to try to provide the best possible
       # functionality based on whether this is a pull_request, and whether it's from a fork.
@@ -105,8 +101,8 @@ jobs:
       plan: ${{ needs.plan.outputs.val }}
     secrets: inherit
     permissions:
-      "contents": "read"
-      "packages": "write"
+      packages: write
+      contents: read
 
   # Build and package all the platform-agnostic(ish) things
   build-global-artifacts:
@@ -122,12 +118,9 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      - name: Install cached cargo-dist
-        uses: actions/download-artifact@v4
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/cargo-dist
+      - name: Install cargo-dist
+        shell: bash
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.14.0/cargo-dist-installer.sh | sh"
       # Get all the local artifacts for the global tasks to use (for e.g. checksums)
       - name: Fetch local artifacts
         uses: actions/download-artifact@v4
@@ -172,12 +165,8 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      - name: Install cached cargo-dist
-        uses: actions/download-artifact@v4
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/cargo-dist
+      - name: Install cargo-dist
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.14.0/cargo-dist-installer.sh | sh"
       # Fetch artifacts from scratch-storage
       - name: Fetch artifacts
         uses: actions/download-artifact@v4
@@ -211,23 +200,8 @@ jobs:
     secrets: inherit
     # publish jobs get escalated permissions
     permissions:
-      "id-token": "write"
-      "packages": "write"
-
-  custom-publish-wasm:
-    needs:
-      - plan
-      - host
-    if: ${{ !fromJson(needs.plan.outputs.val).announcement_is_prerelease || fromJson(needs.plan.outputs.val).publish_prereleases }}
-    uses: ./.github/workflows/publish-wasm.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-    # publish jobs get escalated permissions
-    permissions:
-      "contents": "read"
-      "id-token": "write"
-      "packages": "write"
+      id-token: write
+      packages: write
 
   # Create a GitHub Release while uploading all files to it
   announce:
@@ -235,11 +209,10 @@ jobs:
       - plan
       - host
       - custom-publish-pypi
-      - custom-publish-wasm
     # use "always() && ..." to allow us to wait for all publish jobs while
     # still allowing individual publish jobs to skip themselves (for prereleases).
     # "host" however must run to completion, no skipping allowed!
-    if: ${{ always() && needs.host.result == 'success' && (needs.custom-publish-pypi.result == 'skipped' || needs.custom-publish-pypi.result == 'success') && (needs.custom-publish-wasm.result == 'skipped' || needs.custom-publish-wasm.result == 'success') }}
+    if: ${{ always() && needs.host.result == 'success' && (needs.custom-publish-pypi.result == 'skipped' || needs.custom-publish-pypi.result == 'success') }}
     runs-on: "ubuntu-20.04"
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -247,7 +220,6 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      # Create a GitHub Release while uploading all files to it
       - name: "Download GitHub Artifacts"
         uses: actions/download-artifact@v4
         with:
@@ -259,16 +231,13 @@ jobs:
           # Remove the granular manifests
           rm -f artifacts/*-dist-manifest.json
       - name: Create GitHub Release
-        env:
-          PRERELEASE_FLAG: "${{ fromJson(needs.host.outputs.val).announcement_is_prerelease && '--prerelease' || '' }}"
-          ANNOUNCEMENT_TITLE: "${{ fromJson(needs.host.outputs.val).announcement_title }}"
-          ANNOUNCEMENT_BODY: "${{ fromJson(needs.host.outputs.val).announcement_github_body }}"
-          RELEASE_COMMIT: "${{ github.sha }}"
-        run: |
-          # Write and read notes from a file to avoid quoting breaking things
-          echo "$ANNOUNCEMENT_BODY" > $RUNNER_TEMP/notes.txt
-
-          gh release create "${{ needs.plan.outputs.tag }}" --target "$RELEASE_COMMIT" $PRERELEASE_FLAG --title "$ANNOUNCEMENT_TITLE" --notes-file "$RUNNER_TEMP/notes.txt" artifacts/*
+        uses: ncipollo/release-action@v1
+        with:
+          tag: ${{ needs.plan.outputs.tag }}
+          name: ${{ fromJson(needs.host.outputs.val).announcement_title }}
+          body: ${{ fromJson(needs.host.outputs.val).announcement_github_body }}
+          prerelease: ${{ fromJson(needs.host.outputs.val).announcement_is_prerelease }}
+          artifacts: "artifacts/*"
 
   custom-notify-dependents:
     needs:

.pre-commit-config.yaml

@@ -42,7 +42,7 @@ repos:
           )$
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.23.2
+    rev: v1.22.9
     hooks:
       - id: typos
 
@@ -56,7 +56,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.5.2
+    rev: v0.4.10
     hooks:
       - id: ruff-format
       - id: ruff

CHANGELOG.md

@@ -1,129 +1,5 @@
 # Changelog
 
-## 0.5.3
-
-**Ruff 0.5.3 marks the stable release of the Ruff language server and introduces revamped
-[documentation](https://docs.astral.sh/ruff/editors), including [setup guides for your editor of
-choice](https://docs.astral.sh/ruff/editors/setup) and [the language server
-itself](https://docs.astral.sh/ruff/editors/settings)**.
-
-### Preview features
-
-- Formatter: Insert empty line between suite and alternative branch after function/class definition ([#12294](https://github.com/astral-sh/ruff/pull/12294))
-- \[`pyupgrade`\] Implement `unnecessary-default-type-args` (`UP043`) ([#12371](https://github.com/astral-sh/ruff/pull/12371))
-
-### Rule changes
-
-- \[`flake8-bugbear`\] Detect enumerate iterations in `loop-iterator-mutation` (`B909`) ([#12366](https://github.com/astral-sh/ruff/pull/12366))
-- \[`flake8-bugbear`\] Remove `discard`, `remove`, and `pop` allowance for `loop-iterator-mutation` (`B909`) ([#12365](https://github.com/astral-sh/ruff/pull/12365))
-- \[`pylint`\] Allow `repeated-equality-comparison` for mixed operations (`PLR1714`) ([#12369](https://github.com/astral-sh/ruff/pull/12369))
-- \[`pylint`\] Ignore `self` and `cls` when counting arguments (`PLR0913`) ([#12367](https://github.com/astral-sh/ruff/pull/12367))
-- \[`pylint`\] Use UTF-8 as default encoding in `unspecified-encoding` fix (`PLW1514`) ([#12370](https://github.com/astral-sh/ruff/pull/12370))
-
-### Server
-
-- Build settings index in parallel for the native server ([#12299](https://github.com/astral-sh/ruff/pull/12299))
-- Use fallback settings when indexing the project ([#12362](https://github.com/astral-sh/ruff/pull/12362))
-- Consider `--preview` flag for `server` subcommand for the linter and formatter ([#12208](https://github.com/astral-sh/ruff/pull/12208))
-
-### Bug fixes
-
-- \[`flake8-comprehensions`\] Allow additional arguments for `sum` and `max` comprehensions (`C419`) ([#12364](https://github.com/astral-sh/ruff/pull/12364))
-- \[`pylint`\] Avoid dropping extra boolean operations in `repeated-equality-comparison` (`PLR1714`) ([#12368](https://github.com/astral-sh/ruff/pull/12368))
-- \[`pylint`\] Consider expression before statement when determining binding kind (`PLR1704`) ([#12346](https://github.com/astral-sh/ruff/pull/12346))
-
-### Documentation
-
-- Add docs for Ruff language server ([#12344](https://github.com/astral-sh/ruff/pull/12344))
-- Migrate to standalone docs repo ([#12341](https://github.com/astral-sh/ruff/pull/12341))
-- Update versioning policy for editor integration ([#12375](https://github.com/astral-sh/ruff/pull/12375))
-
-### Other changes
-
-- Publish Wasm API to npm ([#12317](https://github.com/astral-sh/ruff/pull/12317))
-
-## 0.5.2
-
-### Preview features
-
-- Use `space` separator before parenthesized expressions in comprehensions with leading comments ([#12282](https://github.com/astral-sh/ruff/pull/12282))
-- \[`flake8-async`\] Update `ASYNC100` to include `anyio` and `asyncio` ([#12221](https://github.com/astral-sh/ruff/pull/12221))
-- \[`flake8-async`\] Update `ASYNC109` to include `anyio` and `asyncio` ([#12236](https://github.com/astral-sh/ruff/pull/12236))
-- \[`flake8-async`\] Update `ASYNC110` to include `anyio` and `asyncio` ([#12261](https://github.com/astral-sh/ruff/pull/12261))
-- \[`flake8-async`\] Update `ASYNC115` to include `anyio` and `asyncio` ([#12262](https://github.com/astral-sh/ruff/pull/12262))
-- \[`flake8-async`\] Update `ASYNC116` to include `anyio` and `asyncio` ([#12266](https://github.com/astral-sh/ruff/pull/12266))
-
-### Rule changes
-
-- \[`flake8-return`\] Exempt properties from explicit return rule (`RET501`) ([#12243](https://github.com/astral-sh/ruff/pull/12243))
-- \[`numpy`\] Add `np.NAN`-to-`np.nan` diagnostic ([#12292](https://github.com/astral-sh/ruff/pull/12292))
-- \[`refurb`\] Make `list-reverse-copy` an unsafe fix ([#12303](https://github.com/astral-sh/ruff/pull/12303))
-
-### Server
-
-- Consider `include` and `extend-include` settings in native server ([#12252](https://github.com/astral-sh/ruff/pull/12252))
-- Include nested configurations in settings reloading ([#12253](https://github.com/astral-sh/ruff/pull/12253))
-
-### CLI
-
-- Omit code frames for fixes with empty ranges ([#12304](https://github.com/astral-sh/ruff/pull/12304))
-- Warn about formatter incompatibility for `D203` ([#12238](https://github.com/astral-sh/ruff/pull/12238))
-
-### Bug fixes
-
-- Make cache-write failures non-fatal on Windows ([#12302](https://github.com/astral-sh/ruff/pull/12302))
-- Treat `not` operations as boolean tests ([#12301](https://github.com/astral-sh/ruff/pull/12301))
-- \[`flake8-bandit`\] Avoid `S310` violations for HTTP-safe f-strings ([#12305](https://github.com/astral-sh/ruff/pull/12305))
-- \[`flake8-bandit`\] Support explicit string concatenations in S310 HTTP detection ([#12315](https://github.com/astral-sh/ruff/pull/12315))
-- \[`flake8-bandit`\] fix S113 false positive for httpx without `timeout` argument ([#12213](https://github.com/astral-sh/ruff/pull/12213))
-- \[`pycodestyle`\] Remove "non-obvious" allowance for E721 ([#12300](https://github.com/astral-sh/ruff/pull/12300))
-- \[`pyflakes`\] Consider `with` blocks as single-item branches for redefinition analysis ([#12311](https://github.com/astral-sh/ruff/pull/12311))
-- \[`refurb`\] Restrict forwarding for `newline` argument in `open()` calls to Python versions >= 3.10 ([#12244](https://github.com/astral-sh/ruff/pull/12244))
-
-### Documentation
-
-- Update help and documentation to reflect `--output-format full` default ([#12248](https://github.com/astral-sh/ruff/pull/12248))
-
-### Performance
-
-- Use more threads when discovering Python files ([#12258](https://github.com/astral-sh/ruff/pull/12258))
-
-## 0.5.1
-
-### Preview features
-
-- \[`flake8-bugbear`\] Implement mutable-contextvar-default (B039) ([#12113](https://github.com/astral-sh/ruff/pull/12113))
-- \[`pycodestyle`\] Whitespace after decorator (`E204`) ([#12140](https://github.com/astral-sh/ruff/pull/12140))
-- \[`pytest`\] Reverse `PT001` and `PT0023` defaults ([#12106](https://github.com/astral-sh/ruff/pull/12106))
-
-### Rule changes
-
-- Enable token-based rules on source with syntax errors ([#11950](https://github.com/astral-sh/ruff/pull/11950))
-- \[`flake8-bandit`\] Detect `httpx` for `S113` ([#12174](https://github.com/astral-sh/ruff/pull/12174))
-- \[`numpy`\] Update `NPY201` to include exception deprecations ([#12065](https://github.com/astral-sh/ruff/pull/12065))
-- \[`pylint`\] Generate autofix for `duplicate-bases` (`PLE0241`) ([#12105](https://github.com/astral-sh/ruff/pull/12105))
-
-### Server
-
-- Avoid syntax error notification for source code actions ([#12148](https://github.com/astral-sh/ruff/pull/12148))
-- Consider the content of the new cells during notebook sync ([#12203](https://github.com/astral-sh/ruff/pull/12203))
-- Fix replacement edit range computation ([#12171](https://github.com/astral-sh/ruff/pull/12171))
-
-### Bug fixes
-
-- Disable auto-fix when source has syntax errors ([#12134](https://github.com/astral-sh/ruff/pull/12134))
-- Fix cache key collisions for paths with separators ([#12159](https://github.com/astral-sh/ruff/pull/12159))
-- Make `requires-python` inference robust to `==` ([#12091](https://github.com/astral-sh/ruff/pull/12091))
-- Use char-wise width instead of `str`-width ([#12135](https://github.com/astral-sh/ruff/pull/12135))
-- \[`pycodestyle`\] Avoid `E275` if keyword followed by comma ([#12136](https://github.com/astral-sh/ruff/pull/12136))
-- \[`pycodestyle`\] Avoid `E275` if keyword is followed by a semicolon ([#12095](https://github.com/astral-sh/ruff/pull/12095))
-- \[`pylint`\] Skip [dummy variables](https://docs.astral.sh/ruff/settings/#lint_dummy-variable-rgx) for `PLR1704` ([#12190](https://github.com/astral-sh/ruff/pull/12190))
-
-### Performance
-
-- Remove allocation in `parse_identifier` ([#12103](https://github.com/astral-sh/ruff/pull/12103))
-- Use `CompactString` for `Identifier` AST node ([#12101](https://github.com/astral-sh/ruff/pull/12101))
-
 ## 0.5.0
 
 Check out the [blog post](https://astral.sh/blog/ruff-v0.5.0) for a migration guide and overview of the changes!
@@ -180,7 +56,7 @@ The following rules have been stabilized and are no longer in preview:
 - [`bad-open-mode`](https://docs.astral.sh/ruff/rules/bad-open-mode/) (`PLW1501`)
 - [`empty-comment`](https://docs.astral.sh/ruff/rules/empty-comment/) (`PLR2044`)
 - [`global-at-module-level`](https://docs.astral.sh/ruff/rules/global-at-module-level/) (`PLW0604`)
-- [`misplaced-bare-raise`](https://docs.astral.sh/ruff/rules/misplaced-bare-raise/) (`PLE0744`)
+- [`misplaced-bare-raise`](https://docs.astral.sh/ruff/rules/misplaced-bare-raise%60/) (`PLE0744`)
 - [`non-ascii-import-name`](https://docs.astral.sh/ruff/rules/non-ascii-import-name/) (`PLC2403`)
 - [`non-ascii-name`](https://docs.astral.sh/ruff/rules/non-ascii-name/) (`PLC2401`)
 - [`nonlocal-and-global`](https://docs.astral.sh/ruff/rules/nonlocal-and-global/) (`PLE0115`)

CONTRIBUTING.md

@@ -280,7 +280,7 @@ These represent, respectively: the schema used to parse the `pyproject.toml` fil
 intermediate representation; and the final, internal representation used to power Ruff.
 
 To add a new configuration option, you'll likely want to modify these latter few files (along with
-`args.rs`, if appropriate). If you want to pattern-match against an existing example, grep for
+`arg.rs`, if appropriate). If you want to pattern-match against an existing example, grep for
 `dummy_variable_rgx`, which defines a regular expression to match against acceptable unused
 variables (e.g., `_`).
 
@@ -333,7 +333,7 @@ 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:
+1. Run `./scripts/release/bump.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`

Cargo.lock

@@ -184,9 +184,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.6.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
 
 [[package]]
 name = "bstr"
@@ -232,15 +232,6 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
-[[package]]
-name = "castaway"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0abae9be0aaf9ea96a3b1b8b1b55c602ca751eba1b1500220cea4ecbafe7c0d5"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "cc"
 version = "1.0.95"
@@ -314,9 +305,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.9"
+version = "4.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64acc1846d54c1fe936a78dc189c34e28d3f5afc348403f28ecf53660b9b8462"
+checksum = "5db83dced34638ad474f39f250d7fea9598bdd239eaced1bdf45d597da0f433f"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -324,9 +315,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.9"
+version = "4.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8393d67ba2e7bfaf28a23458e4e2b543cc73a99595511eb207fdb8aede942"
+checksum = "f7e204572485eb3fbf28f871612191521df159bc3e15a9f5064c66dba3a8c05f"
 dependencies = [
  "anstream",
  "anstyle",
@@ -346,20 +337,31 @@ dependencies = [
 
 [[package]]
 name = "clap_complete_command"
-version = "0.6.1"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da8e198c052315686d36371e8a3c5778b7852fc75cc313e4e11eeb7a644a1b62"
+checksum = "183495371ea78d4c9ff638bfc6497d46fed2396e4f9c50aebc1278a4a9919a3d"
 dependencies = [
  "clap",
  "clap_complete",
+ "clap_complete_fig",
  "clap_complete_nushell",
 ]
 
 [[package]]
-name = "clap_complete_nushell"
-version = "4.5.2"
+name = "clap_complete_fig"
+version = "4.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1accf1b463dee0d3ab2be72591dccdab8bef314958340447c882c4c72acfe2a3"
+checksum = "54b3e65f91fabdd23cac3d57d39d5d938b4daabd070c335c006dccb866a61110"
+dependencies = [
+ "clap",
+ "clap_complete",
+]
+
+[[package]]
+name = "clap_complete_nushell"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d02bc8b1a18ee47c4d2eec3fb5ac034dc68ebea6125b1509e9ccdffcddce66e"
 dependencies = [
  "clap",
  "clap_complete",
@@ -367,11 +369,11 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.8"
+version = "4.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bac35c6dafb060fd4d275d9a4ffae97917c13a6327903a8be2153cd964f7085"
+checksum = "c780290ccf4fb26629baa7a1081e68ced113f1d3ec302fa5948f1c381ebf06c6"
 dependencies = [
- "heck",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
  "syn",
@@ -434,21 +436,6 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
-[[package]]
-name = "compact_str"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6050c3a16ddab2e412160b31f2c871015704239bca62f72f6e5f0be631d3f644"
-dependencies = [
- "castaway",
- "cfg-if",
- "itoa",
- "rustversion",
- "ryu",
- "serde",
- "static_assertions",
-]
-
 [[package]]
 name = "console"
 version = "0.15.8"
@@ -493,11 +480,6 @@ name = "countme"
 version = "3.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7704b5fdd17b18ae31c4c1da5a2e0305a2bf17b5249300a9ee9ed7b72114c636"
-dependencies = [
- "dashmap 5.5.3",
- "once_cell",
- "rustc-hash 1.1.0",
-]
 
 [[package]]
 name = "crc32fast"
@@ -656,21 +638,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
 dependencies = [
  "cfg-if",
- "hashbrown",
- "lock_api",
- "once_cell",
- "parking_lot_core",
-]
-
-[[package]]
-name = "dashmap"
-version = "6.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "804c8821570c3f8b70230c2ba75ffa5c0f9a4189b9a432b6656c536712acae28"
-dependencies = [
- "cfg-if",
- "crossbeam-utils",
- "hashbrown",
+ "hashbrown 0.14.5",
  "lock_api",
  "once_cell",
  "parking_lot_core",
@@ -797,6 +765,16 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "eyre"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd915d99f24784cdc19fd37ef22b97e3ff0ae756c7e492e9fbfe897d61e2aec"
+dependencies = [
+ "indenter",
+ "once_cell",
+]
+
 [[package]]
 name = "fastrand"
 version = "2.0.2"
@@ -918,6 +896,12 @@ dependencies = [
  "crunchy",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
 [[package]]
 name = "hashbrown"
 version = "0.14.5"
@@ -934,9 +918,15 @@ version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
 dependencies = [
- "hashbrown",
+ "hashbrown 0.14.5",
 ]
 
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -1021,12 +1011,12 @@ dependencies = [
 
 [[package]]
 name = "imara-diff"
-version = "0.1.6"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af13c8ceb376860ff0c6a66d83a8cdd4ecd9e464da24621bbffcd02b49619434"
+checksum = "e98c1d0ad70fc91b8b9654b1f33db55e59579d3b3de2bffdced0fdb810570cb8"
 dependencies = [
  "ahash",
- "hashbrown",
+ "hashbrown 0.12.3",
 ]
 
 [[package]]
@@ -1039,6 +1029,12 @@ dependencies = [
  "rust-stemmers",
 ]
 
+[[package]]
+name = "indenter"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683"
+
 [[package]]
 name = "indexmap"
 version = "2.2.6"
@@ -1046,7 +1042,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
  "equivalent",
- "hashbrown",
+ "hashbrown 0.14.5",
  "serde",
 ]
 
@@ -1289,7 +1285,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.5.0",
  "libc",
 ]
 
@@ -1317,9 +1313,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.22"
+version = "0.4.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
 
 [[package]]
 name = "lsp-server"
@@ -1362,9 +1358,9 @@ checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
 
 [[package]]
 name = "matchit"
-version = "0.8.4"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
+checksum = "540f1c43aed89909c0cc0cc604e3bb2f7e7a341a3728a9e6cfe760e733cd11ed"
 
 [[package]]
 name = "memchr"
@@ -1429,7 +1425,7 @@ version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.5.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -1451,7 +1447,7 @@ version = "6.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.5.0",
  "crossbeam-channel",
  "filetime",
  "fsevent-sys",
@@ -1516,15 +1512,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
-[[package]]
-name = "ordermap"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5a8e22be64dfa1123429350872e7be33594dbf5ae5212c90c5890e71966d1d"
-dependencies = [
- "indexmap",
-]
-
 [[package]]
 name = "os_str_bytes"
 version = "6.6.1"
@@ -1851,21 +1838,28 @@ dependencies = [
 
 [[package]]
 name = "red_knot"
-version = "0.0.0"
+version = "0.1.0"
 dependencies = [
  "anyhow",
- "clap",
- "countme",
+ "bitflags 2.5.0",
  "crossbeam",
  "ctrlc",
+ "dashmap",
+ "hashbrown 0.14.5",
+ "indexmap",
+ "is-macro",
  "notify",
+ "parking_lot",
  "rayon",
  "red_knot_module_resolver",
- "red_knot_python_semantic",
- "ruff_db",
+ "ruff_index",
+ "ruff_notebook",
  "ruff_python_ast",
+ "ruff_python_parser",
+ "ruff_text_size",
  "rustc-hash 2.0.0",
- "salsa",
+ "smol_str",
+ "tempfile",
  "tracing",
  "tracing-subscriber",
  "tracing-tree",
@@ -1876,15 +1870,13 @@ name = "red_knot_module_resolver"
 version = "0.0.0"
 dependencies = [
  "anyhow",
- "camino",
- "compact_str",
  "insta",
- "once_cell",
  "path-slash",
  "ruff_db",
  "ruff_python_stdlib",
  "rustc-hash 2.0.0",
  "salsa",
+ "smol_str",
  "tempfile",
  "tracing",
  "walkdir",
@@ -1896,18 +1888,19 @@ name = "red_knot_python_semantic"
 version = "0.0.0"
 dependencies = [
  "anyhow",
- "bitflags 2.6.0",
- "hashbrown",
- "ordermap",
+ "bitflags 2.5.0",
+ "hashbrown 0.14.5",
+ "indexmap",
  "red_knot_module_resolver",
  "ruff_db",
  "ruff_index",
  "ruff_python_ast",
  "ruff_python_parser",
- "ruff_python_trivia",
  "ruff_text_size",
  "rustc-hash 2.0.0",
  "salsa",
+ "smallvec",
+ "smol_str",
  "tracing",
 ]
 
@@ -1992,12 +1985,12 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.5.3"
+version = "0.5.0"
 dependencies = [
  "anyhow",
  "argfile",
  "bincode",
- "bitflags 2.6.0",
+ "bitflags 2.5.0",
  "cachedir",
  "chrono",
  "clap",
@@ -2050,8 +2043,6 @@ dependencies = [
  "criterion",
  "mimalloc",
  "once_cell",
- "red_knot",
- "ruff_db",
  "ruff_linter",
  "ruff_python_ast",
  "ruff_python_formatter",
@@ -2083,19 +2074,16 @@ version = "0.0.0"
 dependencies = [
  "camino",
  "countme",
- "dashmap 6.0.1",
+ "dashmap",
  "filetime",
- "ignore",
  "insta",
- "ruff_cache",
- "ruff_notebook",
+ "once_cell",
  "ruff_python_ast",
  "ruff_python_parser",
  "ruff_source_file",
  "ruff_text_size",
  "rustc-hash 2.0.0",
  "salsa",
- "tempfile",
  "tracing",
  "zip",
 ]
@@ -2176,12 +2164,12 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.5.3"
+version = "0.5.0"
 dependencies = [
  "aho-corasick",
  "annotate-snippets 0.9.2",
  "anyhow",
- "bitflags 2.6.0",
+ "bitflags 2.5.0",
  "chrono",
  "clap",
  "colored",
@@ -2270,18 +2258,14 @@ name = "ruff_python_ast"
 version = "0.0.0"
 dependencies = [
  "aho-corasick",
- "bitflags 2.6.0",
- "compact_str",
+ "bitflags 2.5.0",
  "is-macro",
  "itertools 0.13.0",
  "once_cell",
- "ruff_cache",
- "ruff_macros",
  "ruff_python_trivia",
  "ruff_source_file",
  "ruff_text_size",
  "rustc-hash 2.0.0",
- "schemars",
  "serde",
 ]
 
@@ -2354,7 +2338,7 @@ dependencies = [
 name = "ruff_python_literal"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.5.0",
  "itertools 0.13.0",
  "ruff_python_ast",
  "unic-ucd-category",
@@ -2366,9 +2350,8 @@ version = "0.0.0"
 dependencies = [
  "annotate-snippets 0.9.2",
  "anyhow",
- "bitflags 2.6.0",
+ "bitflags 2.5.0",
  "bstr",
- "compact_str",
  "insta",
  "memchr",
  "ruff_python_ast",
@@ -2397,7 +2380,7 @@ dependencies = [
 name = "ruff_python_semantic"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.5.0",
  "is-macro",
  "ruff_index",
  "ruff_python_ast",
@@ -2442,7 +2425,7 @@ version = "0.2.2"
 dependencies = [
  "anyhow",
  "crossbeam",
- "ignore",
+ "globset",
  "insta",
  "jod-thread",
  "libc",
@@ -2467,6 +2450,7 @@ dependencies = [
  "shellexpand",
  "tracing",
  "tracing-subscriber",
+ "walkdir",
 ]
 
 [[package]]
@@ -2491,7 +2475,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.5.3"
+version = "0.0.0"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -2576,7 +2560,7 @@ version = "0.38.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.5.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -2585,12 +2569,11 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.10"
+version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05cff451f60db80f490f3c182b77c35260baace73209e9cdbbe526bfe3a4d402"
+checksum = "bf4ef73721ac7bcd79b2b315da7779d8fc09718c6b3d2d1b2d94850eb8c18432"
 dependencies = [
  "log",
- "once_cell",
  "ring",
  "rustls-pki-types",
  "rustls-webpki",
@@ -2600,15 +2583,15 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.7.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976295e77ce332211c0d24d92c0e83e50f5c5f046d11082cea19f3df13a3562d"
+checksum = "beb461507cee2c2ff151784c52762cf4d9ff6a61f3e80968600ed24fa837fa54"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.102.5"
+version = "0.102.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9a6fccd794a42c2c105b513a2f62bc3fd8f3ba57a4593677ceb0bd035164d78"
+checksum = "f3bce581c0dd41bce533ce695a1437fa16a7ab5ac3ccfa99fe1a620a7885eabf"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -2630,11 +2613,12 @@ checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
 [[package]]
 name = "salsa"
 version = "0.18.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=a1bf3a613f451af7fc0a59411c56abc47fe8e8e1#a1bf3a613f451af7fc0a59411c56abc47fe8e8e1"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=f706aa2d32d473ee633a77c1af01d180c85da308#f706aa2d32d473ee633a77c1af01d180c85da308"
 dependencies = [
  "arc-swap",
  "crossbeam",
- "dashmap 5.5.3",
+ "crossbeam-utils",
+ "dashmap",
  "hashlink",
  "indexmap",
  "log",
@@ -2647,8 +2631,10 @@ dependencies = [
 [[package]]
 name = "salsa-macros"
 version = "0.18.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=a1bf3a613f451af7fc0a59411c56abc47fe8e8e1#a1bf3a613f451af7fc0a59411c56abc47fe8e8e1"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=f706aa2d32d473ee633a77c1af01d180c85da308#f706aa2d32d473ee633a77c1af01d180c85da308"
 dependencies = [
+ "eyre",
+ "heck 0.4.1",
  "proc-macro2",
  "quote",
  "syn",
@@ -2708,9 +2694,9 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
 
 [[package]]
 name = "serde"
-version = "1.0.204"
+version = "1.0.203"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
+checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
 dependencies = [
  "serde_derive",
 ]
@@ -2728,9 +2714,9 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.204"
+version = "1.0.203"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
+checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2750,9 +2736,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.120"
+version = "1.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e0d21c9a8cae1235ad58a00c11cb40d4b1e5c784f1ef2c537876ed6ffd8b7c5"
+checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"
 dependencies = [
  "itoa",
  "ryu",
@@ -2790,9 +2776,9 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.9.0"
+version = "3.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69cecfa94848272156ea67b2b1a53f20fc7bc638c4a46d2f8abde08f05f4b857"
+checksum = "0ad483d2ab0149d5a5ebcd9972a3852711e0153d863bf5a5d0391d28883c4a20"
 dependencies = [
  "serde",
  "serde_derive",
@@ -2801,9 +2787,9 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.9.0"
+version = "3.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8fee4991ef4f274617a51ad4af30519438dacb2f56ac773b08a1922ff743350"
+checksum = "65569b702f41443e8bc8bbb1c5779bd0450bbe723b56198980e80ec45780bce2"
 dependencies = [
  "darling",
  "proc-macro2",
@@ -2847,6 +2833,15 @@ version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
+[[package]]
+name = "smol_str"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -2895,7 +2890,7 @@ version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
 dependencies = [
- "heck",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
  "rustversion",
@@ -2910,9 +2905,9 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
 
 [[package]]
 name = "syn"
-version = "2.0.71"
+version = "2.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b146dcf730474b4bcd16c311627b31ede9ab149045db4d6088b3becaea046462"
+checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3000,18 +2995,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.62"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2675633b1499176c2dff06b0856a27976a8f9d436737b4cf4f312d4d91d8bbb"
+checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.62"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d20468752b09f49e909e55a5d338caa8bedf615594e9d80bc4c565d30faf798c"
+checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3030,9 +3025,9 @@ dependencies = [
 
 [[package]]
 name = "tikv-jemalloc-sys"
-version = "0.6.0+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
+version = "0.5.4+5.3.0-patched"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd3c60906412afa9c2b5b5a48ca6a5abe5736aec9eb48ad05037a677e52e4e2d"
+checksum = "9402443cb8fd499b6f327e40565234ff34dbda27460c5b47db0db77443dd85d1"
 dependencies = [
  "cc",
  "libc",
@@ -3040,9 +3035,9 @@ dependencies = [
 
 [[package]]
 name = "tikv-jemallocator"
-version = "0.6.0"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cec5ff18518d81584f477e9bfdf957f5bb0979b0bac3af4ca30b5b3ae2d2865"
+checksum = "965fe0c26be5c56c94e38ba547249074803efd52adfb66de62107d95aab3eaca"
 dependencies = [
  "libc",
  "tikv-jemalloc-sys",
@@ -3304,9 +3299,9 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "ureq"
-version = "2.10.0"
+version = "2.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72139d247e5f97a3eff96229a7ae85ead5328a39efe76f8bf5a06313d505b6ea"
+checksum = "d11a831e3c0b56e438a28308e7c810799e3c118417f342d30ecec080105395cd"
 dependencies = [
  "base64",
  "flate2",
@@ -3314,6 +3309,7 @@ dependencies = [
  "once_cell",
  "rustls",
  "rustls-pki-types",
+ "rustls-webpki",
  "url",
  "webpki-roots",
 ]
@@ -3338,9 +3334,9 @@ checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
 
 [[package]]
 name = "uuid"
-version = "1.9.1"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5de17fd2f7da591098415cff336e12965a28061ddace43b59cb3c430179c9439"
+checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
 dependencies = [
  "getrandom",
  "rand",
@@ -3350,9 +3346,9 @@ dependencies = [
 
 [[package]]
 name = "uuid-macro-internal"
-version = "1.9.1"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3ff64d5cde1e2cb5268bdb497235b6bd255ba8244f910dbc3574e59593de68c"
+checksum = "9881bea7cbe687e36c9ab3b778c36cd0487402e270304e8b1296d5085303c1a2"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

@@ -35,9 +35,7 @@ ruff_source_file = { path = "crates/ruff_source_file" }
 ruff_text_size = { path = "crates/ruff_text_size" }
 ruff_workspace = { path = "crates/ruff_workspace" }
 
-red_knot = { path = "crates/red_knot" }
 red_knot_module_resolver = { path = "crates/red_knot_module_resolver" }
-red_knot_python_semantic = { path = "crates/red_knot_python_semantic" }
 
 aho-corasick = { version = "1.1.3" }
 annotate-snippets = { version = "0.9.2", features = ["color"] }
@@ -50,17 +48,16 @@ cachedir = { version = "0.3.1" }
 camino = { version = "1.1.7" }
 chrono = { version = "0.4.35", default-features = false, features = ["clock"] }
 clap = { version = "4.5.3", features = ["derive"] }
-clap_complete_command = { version = "0.6.0" }
+clap_complete_command = { version = "0.5.1" }
 clearscreen = { version = "3.0.0" }
 codspeed-criterion-compat = { version = "2.6.0", default-features = false }
 colored = { version = "2.1.0" }
 console_error_panic_hook = { version = "0.1.7" }
 console_log = { version = "1.0.0" }
 countme = { version = "3.0.1" }
-compact_str = "0.8.0"
 criterion = { version = "0.5.1", default-features = false }
 crossbeam = { version = "0.8.4" }
-dashmap = { version = "6.0.1" }
+dashmap = { version = "5.5.3" }
 drop_bomb = { version = "0.1.5" }
 env_logger = { version = "0.11.0" }
 etcetera = { version = "0.8.0" }
@@ -72,6 +69,7 @@ hashbrown = "0.14.3"
 ignore = { version = "0.4.22" }
 imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
+indexmap = { version = "2.2.6" }
 indicatif = { version = "0.17.8" }
 indoc = { version = "2.0.4" }
 insta = { version = "1.35.1" }
@@ -94,10 +92,10 @@ mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
 notify = { version = "6.1.1" }
 once_cell = { version = "1.19.0" }
-ordermap = { version = "0.5.0" }
 path-absolutize = { version = "3.1.1" }
 path-slash = { version = "0.2.1" }
 pathdiff = { version = "0.2.1" }
+parking_lot = "0.12.1"
 pep440_rs = { version = "0.6.0", features = ["serde"] }
 pretty_assertions = "1.3.0"
 proc-macro2 = { version = "1.0.79" }
@@ -108,7 +106,7 @@ rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "a1bf3a613f451af7fc0a59411c56abc47fe8e8e1" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "f706aa2d32d473ee633a77c1af01d180c85da308" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -121,6 +119,7 @@ serde_with = { version = "3.6.0", default-features = false, features = [
 shellexpand = { version = "3.0.0" }
 similar = { version = "2.4.0", features = ["inline"] }
 smallvec = { version = "1.13.2" }
+smol_str = { version = "0.2.2" }
 static_assertions = "1.1.0"
 strum = { version = "0.26.0", features = ["strum_macros"] }
 strum_macros = { version = "0.26.0" }
@@ -128,7 +127,7 @@ syn = { version = "2.0.55" }
 tempfile = { version = "3.9.0" }
 test-case = { version = "3.3.1" }
 thiserror = { version = "1.0.58" }
-tikv-jemallocator = { version = "0.6.0" }
+tikv-jemallocator = { version = "0.5.0" }
 toml = { version = "0.8.11" }
 tracing = { version = "0.1.40" }
 tracing-indicatif = { version = "0.3.6" }
@@ -228,7 +227,7 @@ inherits = "release"
 # Config for 'cargo dist'
 [workspace.metadata.dist]
 # The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax)
-cargo-dist-version = "0.18.0"
+cargo-dist-version = "0.14.0"
 # CI backends to support
 ci = ["github"]
 # The installers to generate for each app
@@ -259,23 +258,21 @@ targets = [
 ]
 # Whether to auto-include files like READMEs, LICENSEs, and CHANGELOGs (default true)
 auto-includes = false
-# Whether cargo-dist should create a GitHub Release or use an existing draft
+# Whether cargo-dist should create a Github Release or use an existing draft
 create-release = true
 # Publish jobs to run in CI
 pr-run-mode = "skip"
 # Whether CI should trigger releases with dispatches instead of tag pushes
 dispatch-releases = true
-# The stage during which the GitHub Release should be created
-github-release = "announce"
 # Whether CI should include auto-generated code to build local artifacts
 build-local-artifacts = false
 # Local artifacts jobs to run in CI
 local-artifacts-jobs = ["./build-binaries", "./build-docker"]
 # Publish jobs to run in CI
-publish-jobs = ["./publish-pypi", "./publish-wasm"]
+publish-jobs = ["./publish-pypi"]
 # Announcement jobs to run in CI
 post-announce-jobs = ["./notify-dependents", "./publish-docs", "./publish-playground"]
-# Custom permissions for GitHub Jobs
-github-custom-job-permissions = { "build-docker" = { packages = "write", contents = "read" }, "publish-wasm" = { contents = "read", id-token = "write", packages = "write" } }
+# Skip checking whether the specified configuration files are up to date
+allow-dirty = ["ci"]
 # Whether to install an updater program
 install-updater = false

README.md

@@ -119,25 +119,7 @@ For more, see the [documentation](https://docs.astral.sh/ruff/).
 Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 
 ```shell
-# With pip.
 pip install ruff
-
-# With pipx.
-pipx install ruff
-```
-
-Starting with version `0.5.0`, Ruff can be installed with our standalone installers:
-
-```shell
-# On macOS and Linux.
-curl -LsSf https://astral.sh/ruff/install.sh | sh
-
-# On Windows.
-powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
-
-# For a specific version.
-curl -LsSf https://astral.sh/ruff/0.5.3/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.5.3/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 +152,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.5.3
+  rev: v0.5.0
   hooks:
     # Run the linter.
     - id: ruff

crates/red_knot/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "red_knot"
-version = "0.0.0"
+version = "0.1.0"
 edition.workspace = true
 rust-version.workspace = true
 homepage.workspace = true
@@ -13,24 +13,32 @@ license.workspace = true
 
 [dependencies]
 red_knot_module_resolver = { workspace = true }
-red_knot_python_semantic = { workspace = true }
 
-ruff_db = { workspace = true, features = ["os", "cache"] }
+ruff_python_parser = { workspace = true }
 ruff_python_ast = { workspace = true }
+ruff_text_size = { workspace = true }
+ruff_index = { workspace = true }
+ruff_notebook = { workspace = true }
 
 anyhow = { workspace = true }
-clap = { workspace = true, features = ["wrap_help"] }
-countme = { workspace = true, features = ["enable"] }
+bitflags = { workspace = true }
 crossbeam = { workspace = true }
 ctrlc = { version = "3.4.4" }
+dashmap = { workspace = true }
+hashbrown = { workspace = true }
+indexmap = { workspace = true }
+is-macro = { workspace = true }
 notify = { workspace = true }
+parking_lot = { workspace = true }
 rayon = { workspace = true }
 rustc-hash = { workspace = true }
-salsa = { workspace = true }
+smol_str = { version = "0.2.1" }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 tracing-tree = { workspace = true }
 
+[dev-dependencies]
+tempfile = { workspace = true }
 
 [lints]
 workspace = true

crates/red_knot/src/ast_ids.rs

@@ -0,0 +1,418 @@
+use std::any::type_name;
+use std::fmt::{Debug, Formatter};
+use std::hash::{Hash, Hasher};
+use std::marker::PhantomData;
+
+use rustc_hash::FxHashMap;
+
+use ruff_index::{Idx, IndexVec};
+use ruff_python_ast::visitor::source_order;
+use ruff_python_ast::visitor::source_order::{SourceOrderVisitor, TraversalSignal};
+use ruff_python_ast::{
+    AnyNodeRef, AstNode, ExceptHandler, ExceptHandlerExceptHandler, Expr, MatchCase, ModModule,
+    NodeKind, Parameter, Stmt, StmtAnnAssign, StmtAssign, StmtAugAssign, StmtClassDef,
+    StmtFunctionDef, StmtGlobal, StmtImport, StmtImportFrom, StmtNonlocal, StmtTypeAlias,
+    TypeParam, TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple, WithItem,
+};
+use ruff_text_size::{Ranged, TextRange};
+
+/// A type agnostic ID that uniquely identifies an AST node in a file.
+#[ruff_index::newtype_index]
+pub struct AstId;
+
+/// A typed ID that uniquely identifies an AST node in a file.
+///
+/// This is different from [`AstId`] in that it is a combination of ID and the type of the node the ID identifies.
+/// Typing the ID prevents mixing IDs of different node types and allows to restrict the API to only accept
+/// nodes for which an ID has been created (not all AST nodes get an ID).
+pub struct TypedAstId<N: HasAstId> {
+    erased: AstId,
+    _marker: PhantomData<fn() -> N>,
+}
+
+impl<N: HasAstId> TypedAstId<N> {
+    /// Upcasts this ID from a more specific node type to a more general node type.
+    pub fn upcast<M: HasAstId>(self) -> TypedAstId<M>
+    where
+        N: Into<M>,
+    {
+        TypedAstId {
+            erased: self.erased,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<N: HasAstId> Copy for TypedAstId<N> {}
+impl<N: HasAstId> Clone for TypedAstId<N> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<N: HasAstId> PartialEq for TypedAstId<N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.erased == other.erased
+    }
+}
+
+impl<N: HasAstId> Eq for TypedAstId<N> {}
+impl<N: HasAstId> Hash for TypedAstId<N> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.erased.hash(state);
+    }
+}
+
+impl<N: HasAstId> Debug for TypedAstId<N> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("TypedAstId")
+            .field(&self.erased)
+            .field(&type_name::<N>())
+            .finish()
+    }
+}
+
+pub struct AstIds {
+    ids: IndexVec<AstId, NodeKey>,
+    reverse: FxHashMap<NodeKey, AstId>,
+}
+
+impl AstIds {
+    // TODO rust analyzer doesn't allocate an ID for every node. It only allocates ids for
+    //  nodes with a corresponding HIR element, that is nodes that are definitions.
+    pub fn from_module(module: &ModModule) -> Self {
+        let mut visitor = AstIdsVisitor::default();
+
+        // TODO: visit_module?
+        // Make sure we visit the root
+        visitor.create_id(module);
+        visitor.visit_body(&module.body);
+
+        while let Some(deferred) = visitor.deferred.pop() {
+            match deferred {
+                DeferredNode::FunctionDefinition(def) => {
+                    def.visit_source_order(&mut visitor);
+                }
+                DeferredNode::ClassDefinition(def) => def.visit_source_order(&mut visitor),
+            }
+        }
+
+        AstIds {
+            ids: visitor.ids,
+            reverse: visitor.reverse,
+        }
+    }
+
+    /// Returns the ID to the root node.
+    pub fn root(&self) -> NodeKey {
+        self.ids[AstId::new(0)]
+    }
+
+    /// Returns the [`TypedAstId`] for a node.
+    pub fn ast_id<N: HasAstId>(&self, node: &N) -> TypedAstId<N> {
+        let key = node.syntax_node_key();
+        TypedAstId {
+            erased: self.reverse.get(&key).copied().unwrap(),
+            _marker: PhantomData,
+        }
+    }
+
+    /// Returns the [`TypedAstId`] for the node identified with the given [`TypedNodeKey`].
+    pub fn ast_id_for_key<N: HasAstId>(&self, node: &TypedNodeKey<N>) -> TypedAstId<N> {
+        let ast_id = self.ast_id_for_node_key(node.inner);
+
+        TypedAstId {
+            erased: ast_id,
+            _marker: PhantomData,
+        }
+    }
+
+    /// Returns the untyped [`AstId`] for the node identified by the given `node` key.
+    pub fn ast_id_for_node_key(&self, node: NodeKey) -> AstId {
+        self.reverse
+            .get(&node)
+            .copied()
+            .expect("Can't find node in AstIds map.")
+    }
+
+    /// Returns the [`TypedNodeKey`] for the node identified by the given [`TypedAstId`].
+    pub fn key<N: HasAstId>(&self, id: TypedAstId<N>) -> TypedNodeKey<N> {
+        let syntax_key = self.ids[id.erased];
+
+        TypedNodeKey::new(syntax_key).unwrap()
+    }
+
+    pub fn node_key<H: HasAstId>(&self, id: TypedAstId<H>) -> NodeKey {
+        self.ids[id.erased]
+    }
+}
+
+impl std::fmt::Debug for AstIds {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let mut map = f.debug_map();
+        for (key, value) in self.ids.iter_enumerated() {
+            map.entry(&key, &value);
+        }
+
+        map.finish()
+    }
+}
+
+impl PartialEq for AstIds {
+    fn eq(&self, other: &Self) -> bool {
+        self.ids == other.ids
+    }
+}
+
+impl Eq for AstIds {}
+
+#[derive(Default)]
+struct AstIdsVisitor<'a> {
+    ids: IndexVec<AstId, NodeKey>,
+    reverse: FxHashMap<NodeKey, AstId>,
+    deferred: Vec<DeferredNode<'a>>,
+}
+
+impl<'a> AstIdsVisitor<'a> {
+    fn create_id<A: HasAstId>(&mut self, node: &A) {
+        let node_key = node.syntax_node_key();
+
+        let id = self.ids.push(node_key);
+        self.reverse.insert(node_key, id);
+    }
+}
+
+impl<'a> SourceOrderVisitor<'a> for AstIdsVisitor<'a> {
+    fn visit_stmt(&mut self, stmt: &'a Stmt) {
+        match stmt {
+            Stmt::FunctionDef(def) => {
+                self.create_id(def);
+                self.deferred.push(DeferredNode::FunctionDefinition(def));
+                return;
+            }
+            // TODO defer visiting the assignment body, type alias parameters etc?
+            Stmt::ClassDef(def) => {
+                self.create_id(def);
+                self.deferred.push(DeferredNode::ClassDefinition(def));
+                return;
+            }
+            Stmt::Expr(_) => {
+                // Skip
+                return;
+            }
+            Stmt::Return(_) => {}
+            Stmt::Delete(_) => {}
+            Stmt::Assign(assignment) => self.create_id(assignment),
+            Stmt::AugAssign(assignment) => {
+                self.create_id(assignment);
+            }
+            Stmt::AnnAssign(assignment) => self.create_id(assignment),
+            Stmt::TypeAlias(assignment) => self.create_id(assignment),
+            Stmt::For(_) => {}
+            Stmt::While(_) => {}
+            Stmt::If(_) => {}
+            Stmt::With(_) => {}
+            Stmt::Match(_) => {}
+            Stmt::Raise(_) => {}
+            Stmt::Try(_) => {}
+            Stmt::Assert(_) => {}
+            Stmt::Import(import) => self.create_id(import),
+            Stmt::ImportFrom(import_from) => self.create_id(import_from),
+            Stmt::Global(global) => self.create_id(global),
+            Stmt::Nonlocal(non_local) => self.create_id(non_local),
+            Stmt::Pass(_) => {}
+            Stmt::Break(_) => {}
+            Stmt::Continue(_) => {}
+            Stmt::IpyEscapeCommand(_) => {}
+        }
+
+        source_order::walk_stmt(self, stmt);
+    }
+
+    fn visit_expr(&mut self, _expr: &'a Expr) {}
+
+    fn visit_parameter(&mut self, parameter: &'a Parameter) {
+        self.create_id(parameter);
+        source_order::walk_parameter(self, parameter);
+    }
+
+    fn visit_except_handler(&mut self, except_handler: &'a ExceptHandler) {
+        match except_handler {
+            ExceptHandler::ExceptHandler(except_handler) => {
+                self.create_id(except_handler);
+            }
+        }
+
+        source_order::walk_except_handler(self, except_handler);
+    }
+
+    fn visit_with_item(&mut self, with_item: &'a WithItem) {
+        self.create_id(with_item);
+        source_order::walk_with_item(self, with_item);
+    }
+
+    fn visit_match_case(&mut self, match_case: &'a MatchCase) {
+        self.create_id(match_case);
+        source_order::walk_match_case(self, match_case);
+    }
+
+    fn visit_type_param(&mut self, type_param: &'a TypeParam) {
+        self.create_id(type_param);
+    }
+}
+
+enum DeferredNode<'a> {
+    FunctionDefinition(&'a StmtFunctionDef),
+    ClassDefinition(&'a StmtClassDef),
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub struct TypedNodeKey<N: AstNode> {
+    /// The type erased node key.
+    inner: NodeKey,
+    _marker: PhantomData<fn() -> N>,
+}
+
+impl<N: AstNode> TypedNodeKey<N> {
+    pub fn from_node(node: &N) -> Self {
+        let inner = NodeKey::from_node(node.as_any_node_ref());
+        Self {
+            inner,
+            _marker: PhantomData,
+        }
+    }
+
+    pub fn new(node_key: NodeKey) -> Option<Self> {
+        N::can_cast(node_key.kind).then_some(TypedNodeKey {
+            inner: node_key,
+            _marker: PhantomData,
+        })
+    }
+
+    pub fn resolve<'a>(&self, root: AnyNodeRef<'a>) -> Option<N::Ref<'a>> {
+        let node_ref = self.inner.resolve(root)?;
+
+        Some(N::cast_ref(node_ref).unwrap())
+    }
+
+    pub fn resolve_unwrap<'a>(&self, root: AnyNodeRef<'a>) -> N::Ref<'a> {
+        self.resolve(root).expect("node should resolve")
+    }
+
+    pub fn erased(&self) -> &NodeKey {
+        &self.inner
+    }
+}
+
+struct FindNodeKeyVisitor<'a> {
+    key: NodeKey,
+    result: Option<AnyNodeRef<'a>>,
+}
+
+impl<'a> SourceOrderVisitor<'a> for FindNodeKeyVisitor<'a> {
+    fn enter_node(&mut self, node: AnyNodeRef<'a>) -> TraversalSignal {
+        if self.result.is_some() {
+            return TraversalSignal::Skip;
+        }
+
+        if node.range() == self.key.range && node.kind() == self.key.kind {
+            self.result = Some(node);
+            TraversalSignal::Skip
+        } else if node.range().contains_range(self.key.range) {
+            TraversalSignal::Traverse
+        } else {
+            TraversalSignal::Skip
+        }
+    }
+
+    fn visit_body(&mut self, body: &'a [Stmt]) {
+        // TODO it would be more efficient to use binary search instead of linear
+        for stmt in body {
+            if stmt.range().start() > self.key.range.end() {
+                break;
+            }
+
+            self.visit_stmt(stmt);
+        }
+    }
+}
+
+// TODO an alternative to this is to have a `NodeId` on each node (in increasing order depending on the position).
+//  This would allow to reduce the size of this to a u32.
+//  What would be nice if we could use an `Arc::weak_ref` here but that only works if we use
+//   `Arc` internally
+// TODO: Implement the logic to resolve a node, given a db (and the correct file).
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub struct NodeKey {
+    kind: NodeKind,
+    range: TextRange,
+}
+
+impl NodeKey {
+    pub fn from_node(node: AnyNodeRef) -> Self {
+        NodeKey {
+            kind: node.kind(),
+            range: node.range(),
+        }
+    }
+    pub fn resolve<'a>(&self, root: AnyNodeRef<'a>) -> Option<AnyNodeRef<'a>> {
+        // We need to do a binary search here. Only traverse into a node if the range is withint the node
+        let mut visitor = FindNodeKeyVisitor {
+            key: *self,
+            result: None,
+        };
+
+        if visitor.enter_node(root) == TraversalSignal::Traverse {
+            root.visit_preorder(&mut visitor);
+        }
+
+        visitor.result
+    }
+}
+
+/// Marker trait implemented by AST nodes for which we extract the `AstId`.
+pub trait HasAstId: AstNode {
+    fn node_key(&self) -> TypedNodeKey<Self>
+    where
+        Self: Sized,
+    {
+        TypedNodeKey {
+            inner: self.syntax_node_key(),
+            _marker: PhantomData,
+        }
+    }
+
+    fn syntax_node_key(&self) -> NodeKey {
+        NodeKey {
+            kind: self.as_any_node_ref().kind(),
+            range: self.range(),
+        }
+    }
+}
+
+impl HasAstId for StmtFunctionDef {}
+impl HasAstId for StmtClassDef {}
+impl HasAstId for StmtAnnAssign {}
+impl HasAstId for StmtAugAssign {}
+impl HasAstId for StmtAssign {}
+impl HasAstId for StmtTypeAlias {}
+
+impl HasAstId for ModModule {}
+
+impl HasAstId for StmtImport {}
+
+impl HasAstId for StmtImportFrom {}
+
+impl HasAstId for Parameter {}
+
+impl HasAstId for TypeParam {}
+impl HasAstId for Stmt {}
+impl HasAstId for TypeParamTypeVar {}
+impl HasAstId for TypeParamTypeVarTuple {}
+impl HasAstId for TypeParamParamSpec {}
+impl HasAstId for StmtGlobal {}
+impl HasAstId for StmtNonlocal {}
+
+impl HasAstId for ExceptHandlerExceptHandler {}
+impl HasAstId for WithItem {}
+impl HasAstId for MatchCase {}

crates/red_knot/src/cache.rs

@@ -0,0 +1,165 @@
+use std::fmt::Formatter;
+use std::hash::Hash;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use crate::db::QueryResult;
+use dashmap::mapref::entry::Entry;
+
+use crate::FxDashMap;
+
+/// Simple key value cache that locks on a per-key level.
+pub struct KeyValueCache<K, V> {
+    map: FxDashMap<K, V>,
+    statistics: CacheStatistics,
+}
+
+impl<K, V> KeyValueCache<K, V>
+where
+    K: Eq + Hash + Clone,
+    V: Clone,
+{
+    pub fn try_get(&self, key: &K) -> Option<V> {
+        if let Some(existing) = self.map.get(key) {
+            self.statistics.hit();
+            Some(existing.clone())
+        } else {
+            self.statistics.miss();
+            None
+        }
+    }
+
+    pub fn get<F>(&self, key: &K, compute: F) -> QueryResult<V>
+    where
+        F: FnOnce(&K) -> QueryResult<V>,
+    {
+        Ok(match self.map.entry(key.clone()) {
+            Entry::Occupied(cached) => {
+                self.statistics.hit();
+
+                cached.get().clone()
+            }
+            Entry::Vacant(vacant) => {
+                self.statistics.miss();
+
+                let value = compute(key)?;
+                vacant.insert(value.clone());
+                value
+            }
+        })
+    }
+
+    pub fn set(&mut self, key: K, value: V) {
+        self.map.insert(key, value);
+    }
+
+    pub fn remove(&mut self, key: &K) -> Option<V> {
+        self.map.remove(key).map(|(_, value)| value)
+    }
+
+    pub fn clear(&mut self) {
+        self.map.clear();
+        self.map.shrink_to_fit();
+    }
+
+    pub fn statistics(&self) -> Option<Statistics> {
+        self.statistics.to_statistics()
+    }
+}
+
+impl<K, V> Default for KeyValueCache<K, V>
+where
+    K: Eq + Hash,
+    V: Clone,
+{
+    fn default() -> Self {
+        Self {
+            map: FxDashMap::default(),
+            statistics: CacheStatistics::default(),
+        }
+    }
+}
+
+impl<K, V> std::fmt::Debug for KeyValueCache<K, V>
+where
+    K: std::fmt::Debug + Eq + Hash,
+    V: std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let mut debug = f.debug_map();
+
+        for entry in &self.map {
+            debug.entry(&entry.value(), &entry.key());
+        }
+
+        debug.finish()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Statistics {
+    pub hits: usize,
+    pub misses: usize,
+}
+
+impl Statistics {
+    #[allow(clippy::cast_precision_loss)]
+    pub fn hit_rate(&self) -> Option<f64> {
+        if self.hits + self.misses == 0 {
+            return None;
+        }
+
+        Some((self.hits as f64) / (self.hits + self.misses) as f64)
+    }
+}
+
+#[cfg(debug_assertions)]
+pub type CacheStatistics = DebugStatistics;
+
+#[cfg(not(debug_assertions))]
+pub type CacheStatistics = ReleaseStatistics;
+
+pub trait StatisticsRecorder {
+    fn hit(&self);
+    fn miss(&self);
+    fn to_statistics(&self) -> Option<Statistics>;
+}
+
+#[derive(Debug, Default)]
+pub struct DebugStatistics {
+    hits: AtomicUsize,
+    misses: AtomicUsize,
+}
+
+impl StatisticsRecorder for DebugStatistics {
+    // TODO figure out appropriate Ordering
+    fn hit(&self) {
+        self.hits.fetch_add(1, Ordering::SeqCst);
+    }
+
+    fn miss(&self) {
+        self.misses.fetch_add(1, Ordering::SeqCst);
+    }
+
+    fn to_statistics(&self) -> Option<Statistics> {
+        let hits = self.hits.load(Ordering::SeqCst);
+        let misses = self.misses.load(Ordering::SeqCst);
+
+        Some(Statistics { hits, misses })
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct ReleaseStatistics;
+
+impl StatisticsRecorder for ReleaseStatistics {
+    #[inline]
+    fn hit(&self) {}
+
+    #[inline]
+    fn miss(&self) {}
+
+    #[inline]
+    fn to_statistics(&self) -> Option<Statistics> {
+        None
+    }
+}

crates/red_knot/src/cancellation.rs

@@ -0,0 +1,42 @@
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+
+#[derive(Debug, Clone, Default)]
+pub struct CancellationTokenSource {
+    signal: Arc<AtomicBool>,
+}
+
+impl CancellationTokenSource {
+    pub fn new() -> Self {
+        Self {
+            signal: Arc::new(AtomicBool::new(false)),
+        }
+    }
+
+    #[tracing::instrument(level = "trace", skip_all)]
+    pub fn cancel(&self) {
+        self.signal.store(true, std::sync::atomic::Ordering::SeqCst);
+    }
+
+    pub fn is_cancelled(&self) -> bool {
+        self.signal.load(std::sync::atomic::Ordering::SeqCst)
+    }
+
+    pub fn token(&self) -> CancellationToken {
+        CancellationToken {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct CancellationToken {
+    signal: Arc<AtomicBool>,
+}
+
+impl CancellationToken {
+    /// Returns `true` if cancellation has been requested.
+    pub fn is_cancelled(&self) -> bool {
+        self.signal.load(std::sync::atomic::Ordering::SeqCst)
+    }
+}

crates/red_knot/src/cli/mod.rs

@@ -1,2 +0,0 @@
-pub(crate) mod target_version;
-pub(crate) mod verbosity;

crates/red_knot/src/cli/target_version.rs

@@ -1,34 +0,0 @@
-/// Enumeration of all supported Python versions
-///
-/// TODO: unify with the `PythonVersion` enum in the linter/formatter crates?
-#[derive(Copy, Clone, Hash, Debug, PartialEq, Eq, PartialOrd, Ord, Default, clap::ValueEnum)]
-pub enum TargetVersion {
-    Py37,
-    #[default]
-    Py38,
-    Py39,
-    Py310,
-    Py311,
-    Py312,
-    Py313,
-}
-
-impl std::fmt::Display for TargetVersion {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        ruff_db::program::TargetVersion::from(*self).fmt(f)
-    }
-}
-
-impl From<TargetVersion> for ruff_db::program::TargetVersion {
-    fn from(value: TargetVersion) -> Self {
-        match value {
-            TargetVersion::Py37 => Self::Py37,
-            TargetVersion::Py38 => Self::Py38,
-            TargetVersion::Py39 => Self::Py39,
-            TargetVersion::Py310 => Self::Py310,
-            TargetVersion::Py311 => Self::Py311,
-            TargetVersion::Py312 => Self::Py312,
-            TargetVersion::Py313 => Self::Py313,
-        }
-    }
-}

crates/red_knot/src/cli/verbosity.rs

@@ -1,34 +0,0 @@
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-pub(crate) enum VerbosityLevel {
-    Info,
-    Debug,
-    Trace,
-}
-
-/// Logging flags to `#[command(flatten)]` into your CLI
-#[derive(clap::Args, Debug, Clone, Default)]
-#[command(about = None, long_about = None)]
-pub(crate) struct Verbosity {
-    #[arg(
-        long,
-        short = 'v',
-        help = "Use verbose output (or `-vv` and `-vvv` for more verbose output)",
-        action = clap::ArgAction::Count,
-        global = true,
-    )]
-    verbose: u8,
-}
-
-impl Verbosity {
-    /// Returns the verbosity level based on the number of `-v` flags.
-    ///
-    /// Returns `None` if the user did not specify any verbosity flags.
-    pub(crate) fn level(&self) -> Option<VerbosityLevel> {
-        match self.verbose {
-            0 => None,
-            1 => Some(VerbosityLevel::Info),
-            2 => Some(VerbosityLevel::Debug),
-            _ => Some(VerbosityLevel::Trace),
-        }
-    }
-}

crates/red_knot/src/db.rs

@@ -1,200 +1,248 @@
-use std::panic::{AssertUnwindSafe, RefUnwindSafe};
 use std::sync::Arc;
 
-use salsa::{Cancelled, Database, DbWithJar};
+pub use jars::{HasJar, HasJars};
+pub use query::{QueryError, QueryResult};
+pub use runtime::DbRuntime;
+pub use storage::JarsStorage;
 
-use red_knot_module_resolver::{vendored_typeshed_stubs, Db as ResolverDb, Jar as ResolverJar};
-use red_knot_python_semantic::{Db as SemanticDb, Jar as SemanticJar};
-use ruff_db::files::{system_path_to_file, File, Files};
-use ruff_db::program::{Program, ProgramSettings};
-use ruff_db::system::System;
-use ruff_db::vendored::VendoredFileSystem;
-use ruff_db::{Db as SourceDb, Jar as SourceJar, Upcast};
+use crate::files::FileId;
+use crate::lint::{LintSemanticStorage, LintSyntaxStorage};
+use crate::module::ModuleResolver;
+use crate::parse::ParsedStorage;
+use crate::semantic::SemanticIndexStorage;
+use crate::semantic::TypeStore;
+use crate::source::SourceStorage;
 
-use crate::lint::{lint_semantic, lint_syntax, unwind_if_cancelled, Diagnostics};
-use crate::watch::{FileChangeKind, FileWatcherChange};
-use crate::workspace::{check_file, Package, Workspace, WorkspaceMetadata};
+mod jars;
+mod query;
+mod runtime;
+mod storage;
 
-pub trait Db: DbWithJar<Jar> + SemanticDb + Upcast<dyn SemanticDb> {}
+pub trait Database {
+    /// Returns a reference to the runtime of the current worker.
+    fn runtime(&self) -> &DbRuntime;
 
-#[salsa::jar(db=Db)]
-pub struct Jar(
-    Workspace,
-    Package,
-    lint_syntax,
-    lint_semantic,
-    unwind_if_cancelled,
-);
+    /// Returns a mutable reference to the runtime. Only one worker can hold a mutable reference to the runtime.
+    fn runtime_mut(&mut self) -> &mut DbRuntime;
 
-#[salsa::db(SourceJar, ResolverJar, SemanticJar, Jar)]
-pub struct RootDatabase {
-    workspace: Option<Workspace>,
-    storage: salsa::Storage<RootDatabase>,
-    files: Files,
-    system: Arc<dyn System + Send + Sync + RefUnwindSafe>,
+    /// Returns `Ok` if the queries have not been cancelled and `Err(QueryError::Cancelled)` otherwise.
+    fn cancelled(&self) -> QueryResult<()> {
+        self.runtime().cancelled()
+    }
+
+    /// Returns `true` if the queries have been cancelled.
+    fn is_cancelled(&self) -> bool {
+        self.runtime().is_cancelled()
+    }
 }
 
-impl RootDatabase {
-    pub fn new<S>(workspace: WorkspaceMetadata, settings: ProgramSettings, system: S) -> Self
-    where
-        S: System + 'static + Send + Sync + RefUnwindSafe,
-    {
-        let mut db = Self {
-            workspace: None,
-            storage: salsa::Storage::default(),
-            files: Files::default(),
-            system: Arc::new(system),
-        };
+/// Database that supports running queries from multiple threads.
+pub trait ParallelDatabase: Database + Send {
+    /// Creates a snapshot of the database state that can be used to query the database in another thread.
+    ///
+    /// The snapshot is a read-only view of the database but query results are shared between threads.
+    /// All queries will be automatically cancelled when applying any mutations (calling [`HasJars::jars_mut`])
+    /// to the database (not the snapshot, because they're readonly).
+    ///
+    /// ## Creating a snapshot
+    ///
+    /// Creating a snapshot of the database's jars is cheap but creating a snapshot of
+    /// other state stored on the database might require deep-cloning data. That's why you should
+    /// avoid creating snapshots in a hot function (e.g. don't create a snapshot for each file, instead
+    /// create a snapshot when scheduling the check of an entire program).
+    ///
+    /// ## Salsa compatibility
+    /// Salsa prohibits creating a snapshot while running a local query (it's fine if other workers run a query) [[source](https://github.com/salsa-rs/salsa/issues/80)].
+    /// We should avoid creating snapshots while running a query because we might want to adopt Salsa in the future (if we can figure out persistent caching).
+    /// Unfortunately, the infrastructure doesn't provide an automated way of knowing when a query is run, that's
+    /// why we have to "enforce" this constraint manually.
+    #[must_use]
+    fn snapshot(&self) -> Snapshot<Self>;
+}
 
-        let workspace = Workspace::from_metadata(&db, workspace);
-        // Initialize the `Program` singleton
-        Program::from_settings(&db, settings);
+pub trait DbWithJar<Jar>: Database + HasJar<Jar> {}
 
-        db.workspace = Some(workspace);
-        db
+/// Readonly snapshot of a database.
+///
+/// ## Dead locks
+/// A snapshot should always be dropped as soon as it is no longer necessary to run queries.
+/// Storing the snapshot without running a query or periodically checking if cancellation was requested
+/// can lead to deadlocks because mutating the [`Database`] requires cancels all pending queries
+/// and waiting for all [`Snapshot`]s to be dropped.
+#[derive(Debug)]
+pub struct Snapshot<DB: ?Sized>
+where
+    DB: ParallelDatabase,
+{
+    db: DB,
+}
+
+impl<DB> Snapshot<DB>
+where
+    DB: ParallelDatabase,
+{
+    pub fn new(db: DB) -> Self {
+        Snapshot { db }
+    }
+}
+
+impl<DB> std::ops::Deref for Snapshot<DB>
+where
+    DB: ParallelDatabase,
+{
+    type Target = DB;
+
+    fn deref(&self) -> &DB {
+        &self.db
+    }
+}
+
+pub trait Upcast<T: ?Sized> {
+    fn upcast(&self) -> &T;
+}
+
+// Red knot specific databases code.
+
+pub trait SourceDb: DbWithJar<SourceJar> {
+    // queries
+    fn file_id(&self, path: &std::path::Path) -> FileId;
+
+    fn file_path(&self, file_id: FileId) -> Arc<std::path::Path>;
+}
+
+pub trait SemanticDb: SourceDb + DbWithJar<SemanticJar> + Upcast<dyn SourceDb> {}
+
+pub trait LintDb: SemanticDb + DbWithJar<LintJar> + Upcast<dyn SemanticDb> {}
+
+pub trait Db: LintDb + Upcast<dyn LintDb> {}
+
+#[derive(Debug, Default)]
+pub struct SourceJar {
+    pub sources: SourceStorage,
+    pub parsed: ParsedStorage,
+}
+
+#[derive(Debug, Default)]
+pub struct SemanticJar {
+    pub module_resolver: ModuleResolver,
+    pub semantic_indices: SemanticIndexStorage,
+    pub type_store: TypeStore,
+}
+
+#[derive(Debug, Default)]
+pub struct LintJar {
+    pub lint_syntax: LintSyntaxStorage,
+    pub lint_semantic: LintSemanticStorage,
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use std::path::Path;
+    use std::sync::Arc;
+
+    use crate::db::{
+        Database, DbRuntime, DbWithJar, HasJar, HasJars, JarsStorage, LintDb, LintJar, QueryResult,
+        SourceDb, SourceJar, Upcast,
+    };
+    use crate::files::{FileId, Files};
+
+    use super::{SemanticDb, SemanticJar};
+
+    // This can be a partial database used in a single crate for testing.
+    // It would hold fewer data than the full database.
+    #[derive(Debug, Default)]
+    pub(crate) struct TestDb {
+        files: Files,
+        jars: JarsStorage<Self>,
     }
 
-    pub fn workspace(&self) -> Workspace {
-        // SAFETY: The workspace is always initialized in `new`.
-        self.workspace.unwrap()
-    }
-
-    #[tracing::instrument(level = "debug", skip(self, changes))]
-    pub fn apply_changes(&mut self, changes: Vec<FileWatcherChange>) {
-        let workspace = self.workspace();
-        let workspace_path = workspace.root(self).to_path_buf();
-
-        // TODO: Optimize change tracking by only reloading a package if a file that is part of the package was changed.
-        let mut structural_change = false;
-        for change in changes {
-            if matches!(
-                change.path.file_name(),
-                Some(".gitignore" | ".ignore" | "ruff.toml" | ".ruff.toml" | "pyproject.toml")
-            ) {
-                // Changes to ignore files or settings can change the workspace structure or add/remove files
-                // from packages.
-                structural_change = true;
-            } else {
-                match change.kind {
-                    FileChangeKind::Created => {
-                        // Reload the package when a new file was added. This is necessary because the file might be excluded
-                        // by a gitignore.
-                        if workspace.package(self, &change.path).is_some() {
-                            structural_change = true;
-                        }
-                    }
-                    FileChangeKind::Modified => {}
-                    FileChangeKind::Deleted => {
-                        if let Some(package) = workspace.package(self, &change.path) {
-                            if let Some(file) = system_path_to_file(self, &change.path) {
-                                package.remove_file(self, file);
-                            }
-                        }
-                    }
-                }
-            }
-
-            File::touch_path(self, &change.path);
+    impl HasJar<SourceJar> for TestDb {
+        fn jar(&self) -> QueryResult<&SourceJar> {
+            Ok(&self.jars()?.0)
         }
 
-        if structural_change {
-            match WorkspaceMetadata::from_path(&workspace_path, self.system()) {
-                Ok(metadata) => {
-                    tracing::debug!("Reload workspace after structural change.");
-                    // TODO: Handle changes in the program settings.
-                    workspace.reload(self, metadata);
-                }
-                Err(error) => {
-                    tracing::error!("Failed to load workspace, keep old workspace: {error}");
-                }
-            }
+        fn jar_mut(&mut self) -> &mut SourceJar {
+            &mut self.jars_mut().0
         }
     }
 
-    /// Checks all open files in the workspace and its dependencies.
-    pub fn check(&self) -> Result<Vec<String>, Cancelled> {
-        self.with_db(|db| db.workspace().check(db))
+    impl HasJar<SemanticJar> for TestDb {
+        fn jar(&self) -> QueryResult<&SemanticJar> {
+            Ok(&self.jars()?.1)
+        }
+
+        fn jar_mut(&mut self) -> &mut SemanticJar {
+            &mut self.jars_mut().1
+        }
     }
 
-    pub fn check_file(&self, file: File) -> Result<Diagnostics, Cancelled> {
-        self.with_db(|db| check_file(db, file))
+    impl HasJar<LintJar> for TestDb {
+        fn jar(&self) -> QueryResult<&LintJar> {
+            Ok(&self.jars()?.2)
+        }
+
+        fn jar_mut(&mut self) -> &mut LintJar {
+            &mut self.jars_mut().2
+        }
     }
 
-    pub(crate) fn with_db<F, T>(&self, f: F) -> Result<T, Cancelled>
-    where
-        F: FnOnce(&RootDatabase) -> T + std::panic::UnwindSafe,
-    {
-        // The `AssertUnwindSafe` here looks scary, but is a consequence of Salsa's design.
-        // Salsa uses panics to implement cancellation and to recover from cycles. However, the Salsa
-        // storage isn't `UnwindSafe` or `RefUnwindSafe` because its dependencies `DashMap` and `parking_lot::*` aren't
-        // unwind safe.
-        //
-        // Having to use `AssertUnwindSafe` isn't as big as a deal as it might seem because
-        // the `UnwindSafe` and `RefUnwindSafe` traits are designed to catch logical bugs.
-        // They don't protect against [UB](https://internals.rust-lang.org/t/pre-rfc-deprecating-unwindsafe/15974).
-        // On top of that, `Cancelled` only catches specific Salsa-panics and propagates all other panics.
-        //
-        // That still leaves us with possible logical bugs in two sources:
-        // * In Salsa itself: This must be considered a bug in Salsa and needs fixing upstream.
-        //   Reviewing Salsa code specifically around unwind safety seems doable.
-        // * Our code: This is the main concern. Luckily, it only involves code that uses internal mutability
-        //     and calls into Salsa queries when mutating the internal state. Using `AssertUnwindSafe`
-        //     certainly makes it harder to catch these issues in our user code.
-        //
-        // For now, this is the only solution at hand unless Salsa decides to change its design.
-        // [Zulip support thread](https://salsa.zulipchat.com/#narrow/stream/145099-general/topic/How.20to.20use.20.60Cancelled.3A.3Acatch.60)
-        let db = &AssertUnwindSafe(self);
-        Cancelled::catch(|| f(db))
-    }
-}
-
-impl Upcast<dyn SemanticDb> for RootDatabase {
-    fn upcast(&self) -> &(dyn SemanticDb + 'static) {
-        self
-    }
-}
-
-impl Upcast<dyn SourceDb> for RootDatabase {
-    fn upcast(&self) -> &(dyn SourceDb + 'static) {
-        self
-    }
-}
-
-impl Upcast<dyn ResolverDb> for RootDatabase {
-    fn upcast(&self) -> &(dyn ResolverDb + 'static) {
-        self
-    }
-}
-
-impl ResolverDb for RootDatabase {}
-
-impl SemanticDb for RootDatabase {}
-
-impl SourceDb for RootDatabase {
-    fn vendored(&self) -> &VendoredFileSystem {
-        vendored_typeshed_stubs()
-    }
-
-    fn system(&self) -> &dyn System {
-        &*self.system
-    }
-
-    fn files(&self) -> &Files {
-        &self.files
-    }
-}
-
-impl Database for RootDatabase {}
-
-impl Db for RootDatabase {}
-
-impl salsa::ParallelDatabase for RootDatabase {
-    fn snapshot(&self) -> salsa::Snapshot<Self> {
-        salsa::Snapshot::new(Self {
-            workspace: self.workspace,
-            storage: self.storage.snapshot(),
-            files: self.files.snapshot(),
-            system: self.system.clone(),
-        })
+    impl SourceDb for TestDb {
+        fn file_id(&self, path: &Path) -> FileId {
+            self.files.intern(path)
+        }
+
+        fn file_path(&self, file_id: FileId) -> Arc<Path> {
+            self.files.path(file_id)
+        }
+    }
+
+    impl DbWithJar<SourceJar> for TestDb {}
+
+    impl Upcast<dyn SourceDb> for TestDb {
+        fn upcast(&self) -> &(dyn SourceDb + 'static) {
+            self
+        }
+    }
+
+    impl SemanticDb for TestDb {}
+
+    impl DbWithJar<SemanticJar> for TestDb {}
+
+    impl Upcast<dyn SemanticDb> for TestDb {
+        fn upcast(&self) -> &(dyn SemanticDb + 'static) {
+            self
+        }
+    }
+
+    impl LintDb for TestDb {}
+
+    impl Upcast<dyn LintDb> for TestDb {
+        fn upcast(&self) -> &(dyn LintDb + 'static) {
+            self
+        }
+    }
+
+    impl DbWithJar<LintJar> for TestDb {}
+
+    impl HasJars for TestDb {
+        type Jars = (SourceJar, SemanticJar, LintJar);
+
+        fn jars(&self) -> QueryResult<&Self::Jars> {
+            self.jars.jars()
+        }
+
+        fn jars_mut(&mut self) -> &mut Self::Jars {
+            self.jars.jars_mut()
+        }
+    }
+
+    impl Database for TestDb {
+        fn runtime(&self) -> &DbRuntime {
+            self.jars.runtime()
+        }
+
+        fn runtime_mut(&mut self) -> &mut DbRuntime {
+            self.jars.runtime_mut()
+        }
     }
 }

crates/red_knot/src/db/jars.rs

@@ -0,0 +1,37 @@
+use crate::db::query::QueryResult;
+
+/// Gives access to a specific jar in the database.
+///
+/// Nope, the terminology isn't borrowed from Java but from Salsa <https://salsa-rs.github.io/salsa/>,
+/// which is an analogy to storing the salsa in different jars.
+///
+/// The basic idea is that each crate can define its own jar and the jars can be combined to a single
+/// database in the top level crate. Each crate also defines its own `Database` trait. The combination of
+/// `Database` trait and the jar allows to write queries in isolation without having to know how they get composed at the upper levels.
+///
+/// Salsa further defines a `HasIngredient` trait which slices the jar to a specific storage (e.g. a specific cache).
+/// We don't need this just yet because we write our queries by hand. We may want a similar trait if we decide
+/// to use a macro to generate the queries.
+pub trait HasJar<T> {
+    /// Gives a read-only reference to the jar.
+    fn jar(&self) -> QueryResult<&T>;
+
+    /// Gives a mutable reference to the jar.
+    fn jar_mut(&mut self) -> &mut T;
+}
+
+/// Gives access to the jars in a database.
+pub trait HasJars {
+    /// A type storing the jars.
+    ///
+    /// Most commonly, this is a tuple where each jar is a tuple element.
+    type Jars: Default;
+
+    /// Gives access to the underlying jars but tests if the queries have been cancelled.
+    ///
+    /// Returns `Err(QueryError::Cancelled)` if the queries have been cancelled.
+    fn jars(&self) -> QueryResult<&Self::Jars>;
+
+    /// Gives mutable access to the underlying jars.
+    fn jars_mut(&mut self) -> &mut Self::Jars;
+}

crates/red_knot/src/db/query.rs

@@ -0,0 +1,20 @@
+use std::fmt::{Display, Formatter};
+
+/// Reason why a db query operation failed.
+#[derive(Debug, Clone, Copy)]
+pub enum QueryError {
+    /// The query was cancelled because the DB was mutated or the query was cancelled by the host (e.g. on a file change or when pressing CTRL+C).
+    Cancelled,
+}
+
+impl Display for QueryError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            QueryError::Cancelled => f.write_str("query was cancelled"),
+        }
+    }
+}
+
+impl std::error::Error for QueryError {}
+
+pub type QueryResult<T> = Result<T, QueryError>;

crates/red_knot/src/db/runtime.rs

@@ -0,0 +1,41 @@
+use crate::cancellation::CancellationTokenSource;
+use crate::db::{QueryError, QueryResult};
+
+/// Holds the jar agnostic state of the database.
+#[derive(Debug, Default)]
+pub struct DbRuntime {
+    /// The cancellation token source used to signal other works that the queries should be aborted and
+    /// exit at the next possible point.
+    cancellation_token: CancellationTokenSource,
+}
+
+impl DbRuntime {
+    pub(super) fn snapshot(&self) -> Self {
+        Self {
+            cancellation_token: self.cancellation_token.clone(),
+        }
+    }
+
+    /// Cancels the pending queries of other workers. The current worker cannot have any pending
+    /// queries because we're holding a mutable reference to the runtime.
+    pub(super) fn cancel_other_workers(&mut self) {
+        self.cancellation_token.cancel();
+        // Set a new cancellation token so that we're in a non-cancelled state again when running the next
+        // query.
+        self.cancellation_token = CancellationTokenSource::default();
+    }
+
+    /// Returns `Ok` if the queries have not been cancelled and `Err(QueryError::Cancelled)` otherwise.
+    pub(super) fn cancelled(&self) -> QueryResult<()> {
+        if self.cancellation_token.is_cancelled() {
+            Err(QueryError::Cancelled)
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Returns `true` if the queries have been cancelled.
+    pub(super) fn is_cancelled(&self) -> bool {
+        self.cancellation_token.is_cancelled()
+    }
+}

crates/red_knot/src/db/storage.rs

@@ -0,0 +1,117 @@
+use std::fmt::Formatter;
+use std::sync::Arc;
+
+use crossbeam::sync::WaitGroup;
+
+use crate::db::query::QueryResult;
+use crate::db::runtime::DbRuntime;
+use crate::db::{HasJars, ParallelDatabase};
+
+/// Stores the jars of a database and the state for each worker.
+///
+/// Today, all state is shared across all workers, but it may be desired to store data per worker in the future.
+pub struct JarsStorage<T>
+where
+    T: HasJars + Sized,
+{
+    // It's important that `jars_wait_group` is declared after `jars` to ensure that `jars` is dropped first.
+    // See https://doc.rust-lang.org/reference/destructors.html
+    /// Stores the jars of the database.
+    jars: Arc<T::Jars>,
+
+    /// Used to count the references to `jars`. Allows implementing `jars_mut` without requiring to clone `jars`.
+    jars_wait_group: WaitGroup,
+
+    /// The data agnostic state.
+    runtime: DbRuntime,
+}
+
+impl<Db> JarsStorage<Db>
+where
+    Db: HasJars,
+{
+    pub(super) fn new() -> Self {
+        Self {
+            jars: Arc::new(Db::Jars::default()),
+            jars_wait_group: WaitGroup::default(),
+            runtime: DbRuntime::default(),
+        }
+    }
+
+    /// Creates a snapshot of the jars.
+    ///
+    /// Creating the snapshot is cheap because it doesn't clone the jars, it only increments a ref counter.
+    #[must_use]
+    pub fn snapshot(&self) -> JarsStorage<Db>
+    where
+        Db: ParallelDatabase,
+    {
+        Self {
+            jars: self.jars.clone(),
+            jars_wait_group: self.jars_wait_group.clone(),
+            runtime: self.runtime.snapshot(),
+        }
+    }
+
+    pub(crate) fn jars(&self) -> QueryResult<&Db::Jars> {
+        self.runtime.cancelled()?;
+        Ok(&self.jars)
+    }
+
+    /// Returns a mutable reference to the jars without cloning their content.
+    ///
+    /// The method cancels any pending queries of other works and waits for them to complete so that
+    /// this instance is the only instance holding a reference to the jars.
+    pub(crate) fn jars_mut(&mut self) -> &mut Db::Jars {
+        // We have a mutable ref here, so no more workers can be spawned between calling this function and taking the mut ref below.
+        self.cancel_other_workers();
+
+        // Now all other references to `self.jars` should have been released. We can now safely return a mutable reference
+        // to the Arc's content.
+        let jars =
+            Arc::get_mut(&mut self.jars).expect("All references to jars should have been released");
+
+        jars
+    }
+
+    pub(crate) fn runtime(&self) -> &DbRuntime {
+        &self.runtime
+    }
+
+    pub(crate) fn runtime_mut(&mut self) -> &mut DbRuntime {
+        // Note: This method may need to use a similar trick to `jars_mut` if `DbRuntime` is ever to store data that is shared between workers.
+        &mut self.runtime
+    }
+
+    #[tracing::instrument(level = "trace", skip(self))]
+    fn cancel_other_workers(&mut self) {
+        self.runtime.cancel_other_workers();
+
+        // Wait for all other works to complete.
+        let existing_wait = std::mem::take(&mut self.jars_wait_group);
+        existing_wait.wait();
+    }
+}
+
+impl<Db> Default for JarsStorage<Db>
+where
+    Db: HasJars,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T> std::fmt::Debug for JarsStorage<T>
+where
+    T: HasJars,
+    <T as HasJars>::Jars: std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SharedStorage")
+            .field("jars", &self.jars)
+            .field("jars_wait_group", &self.jars_wait_group)
+            .field("runtime", &self.runtime)
+            .finish()
+    }
+}

crates/red_knot/src/files.rs

@@ -0,0 +1,180 @@
+use std::fmt::{Debug, Formatter};
+use std::hash::{Hash, Hasher};
+use std::path::Path;
+use std::sync::Arc;
+
+use hashbrown::hash_map::RawEntryMut;
+use parking_lot::RwLock;
+use rustc_hash::FxHasher;
+
+use ruff_index::{newtype_index, IndexVec};
+
+type Map<K, V> = hashbrown::HashMap<K, V, ()>;
+
+#[newtype_index]
+pub struct FileId;
+
+// TODO we'll need a higher level virtual file system abstraction that allows testing if a file exists
+//  or retrieving its content (ideally lazily and in a way that the memory can be retained later)
+//  I suspect that we'll end up with a FileSystem trait and our own Path abstraction.
+#[derive(Default)]
+pub struct Files {
+    inner: Arc<RwLock<FilesInner>>,
+}
+
+impl Files {
+    #[tracing::instrument(level = "debug", skip(self))]
+    pub fn intern(&self, path: &Path) -> FileId {
+        self.inner.write().intern(path)
+    }
+
+    pub fn try_get(&self, path: &Path) -> Option<FileId> {
+        self.inner.read().try_get(path)
+    }
+
+    #[tracing::instrument(level = "debug", skip(self))]
+    pub fn path(&self, id: FileId) -> Arc<Path> {
+        self.inner.read().path(id)
+    }
+
+    /// Snapshots files for a new database snapshot.
+    ///
+    /// This method should not be used outside a database snapshot.
+    #[must_use]
+    pub fn snapshot(&self) -> Files {
+        Files {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl Debug for Files {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let files = self.inner.read();
+        let mut debug = f.debug_map();
+        for item in files.iter() {
+            debug.entry(&item.0, &item.1);
+        }
+
+        debug.finish()
+    }
+}
+
+impl PartialEq for Files {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner.read().eq(&other.inner.read())
+    }
+}
+
+impl Eq for Files {}
+
+#[derive(Default)]
+struct FilesInner {
+    by_path: Map<FileId, ()>,
+    // TODO should we use a map here to reclaim the space for removed files?
+    // TODO I think we should use our own path abstraction here to avoid having to normalize paths
+    //  and dealing with non-utf paths everywhere.
+    by_id: IndexVec<FileId, Arc<Path>>,
+}
+
+impl FilesInner {
+    /// Inserts the path and returns a new id for it or returns the id if it is an existing path.
+    // TODO should this accept Path or PathBuf?
+    pub(crate) fn intern(&mut self, path: &Path) -> FileId {
+        let hash = FilesInner::hash_path(path);
+
+        let entry = self
+            .by_path
+            .raw_entry_mut()
+            .from_hash(hash, |existing_file| &*self.by_id[*existing_file] == path);
+
+        match entry {
+            RawEntryMut::Occupied(entry) => *entry.key(),
+            RawEntryMut::Vacant(entry) => {
+                let id = self.by_id.push(Arc::from(path));
+                entry.insert_with_hasher(hash, id, (), |file| {
+                    FilesInner::hash_path(&self.by_id[*file])
+                });
+                id
+            }
+        }
+    }
+
+    fn hash_path(path: &Path) -> u64 {
+        let mut hasher = FxHasher::default();
+        path.hash(&mut hasher);
+        hasher.finish()
+    }
+
+    pub(crate) fn try_get(&self, path: &Path) -> Option<FileId> {
+        let mut hasher = FxHasher::default();
+        path.hash(&mut hasher);
+        let hash = hasher.finish();
+
+        Some(
+            *self
+                .by_path
+                .raw_entry()
+                .from_hash(hash, |existing_file| &*self.by_id[*existing_file] == path)?
+                .0,
+        )
+    }
+
+    /// Returns the path for the file with the given id.
+    pub(crate) fn path(&self, id: FileId) -> Arc<Path> {
+        self.by_id[id].clone()
+    }
+
+    pub(crate) fn iter(&self) -> impl Iterator<Item = (FileId, Arc<Path>)> + '_ {
+        self.by_path.keys().map(|id| (*id, self.by_id[*id].clone()))
+    }
+}
+
+impl PartialEq for FilesInner {
+    fn eq(&self, other: &Self) -> bool {
+        self.by_id == other.by_id
+    }
+}
+
+impl Eq for FilesInner {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn insert_path_twice_same_id() {
+        let files = Files::default();
+        let path = PathBuf::from("foo/bar");
+        let id1 = files.intern(&path);
+        let id2 = files.intern(&path);
+        assert_eq!(id1, id2);
+    }
+
+    #[test]
+    fn insert_different_paths_different_ids() {
+        let files = Files::default();
+        let path1 = PathBuf::from("foo/bar");
+        let path2 = PathBuf::from("foo/bar/baz");
+        let id1 = files.intern(&path1);
+        let id2 = files.intern(&path2);
+        assert_ne!(id1, id2);
+    }
+
+    #[test]
+    fn four_files() {
+        let files = Files::default();
+        let foo_path = PathBuf::from("foo");
+        let foo_id = files.intern(&foo_path);
+        let bar_path = PathBuf::from("bar");
+        files.intern(&bar_path);
+        let baz_path = PathBuf::from("baz");
+        files.intern(&baz_path);
+        let qux_path = PathBuf::from("qux");
+        files.intern(&qux_path);
+
+        let foo_id_2 = files.try_get(&foo_path).expect("foo_path to be found");
+        assert_eq!(foo_id_2, foo_id);
+    }
+}

crates/red_knot/src/hir.rs

@@ -0,0 +1,67 @@
+//! Key observations
+//!
+//! The HIR (High-Level Intermediate Representation) avoids allocations to large extends by:
+//! * Using an arena per node type
+//! * using ids and id ranges to reference items.
+//!
+//! Using separate arena per node type has the advantage that the IDs are relatively stable, because
+//! they only change when a node of the same kind has been added or removed. (What's unclear is if that matters or if
+//! it still triggers a re-compute because the AST-id in the node has changed).
+//!
+//! The HIR does not store all details. It mainly stores the *public* interface. There's a reference
+//! back to the AST node to get more details.
+//!
+//!
+
+use crate::ast_ids::{HasAstId, TypedAstId};
+use crate::files::FileId;
+use std::fmt::Formatter;
+use std::hash::{Hash, Hasher};
+
+pub struct HirAstId<N: HasAstId> {
+    file_id: FileId,
+    node_id: TypedAstId<N>,
+}
+
+impl<N: HasAstId> Copy for HirAstId<N> {}
+impl<N: HasAstId> Clone for HirAstId<N> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<N: HasAstId> PartialEq for HirAstId<N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.file_id == other.file_id && self.node_id == other.node_id
+    }
+}
+
+impl<N: HasAstId> Eq for HirAstId<N> {}
+
+impl<N: HasAstId> std::fmt::Debug for HirAstId<N> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("HirAstId")
+            .field("file_id", &self.file_id)
+            .field("node_id", &self.node_id)
+            .finish()
+    }
+}
+
+impl<N: HasAstId> Hash for HirAstId<N> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.file_id.hash(state);
+        self.node_id.hash(state);
+    }
+}
+
+impl<N: HasAstId> HirAstId<N> {
+    pub fn upcast<M: HasAstId>(self) -> HirAstId<M>
+    where
+        N: Into<M>,
+    {
+        HirAstId {
+            file_id: self.file_id,
+            node_id: self.node_id.upcast(),
+        }
+    }
+}

crates/red_knot/src/hir/definition.rs

@@ -0,0 +1,556 @@
+use std::ops::{Index, Range};
+
+use ruff_index::{newtype_index, IndexVec};
+use ruff_python_ast::visitor::preorder;
+use ruff_python_ast::visitor::preorder::PreorderVisitor;
+use ruff_python_ast::{
+    Decorator, ExceptHandler, ExceptHandlerExceptHandler, Expr, MatchCase, ModModule, Stmt,
+    StmtAnnAssign, StmtAssign, StmtClassDef, StmtFunctionDef, StmtGlobal, StmtImport,
+    StmtImportFrom, StmtNonlocal, StmtTypeAlias, TypeParam, TypeParamParamSpec, TypeParamTypeVar,
+    TypeParamTypeVarTuple, WithItem,
+};
+
+use crate::ast_ids::{AstIds, HasAstId};
+use crate::files::FileId;
+use crate::hir::HirAstId;
+use crate::Name;
+
+#[newtype_index]
+pub struct FunctionId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Function {
+    ast_id: HirAstId<StmtFunctionDef>,
+    name: Name,
+    parameters: Range<ParameterId>,
+    type_parameters: Range<TypeParameterId>, // TODO: type_parameters, return expression, decorators
+}
+
+#[newtype_index]
+pub struct ParameterId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Parameter {
+    kind: ParameterKind,
+    name: Name,
+    default: Option<()>, // TODO use expression HIR
+    ast_id: HirAstId<ruff_python_ast::Parameter>,
+}
+
+// TODO or should `Parameter` be an enum?
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum ParameterKind {
+    PositionalOnly,
+    Arguments,
+    Vararg,
+    KeywordOnly,
+    Kwarg,
+}
+
+#[newtype_index]
+pub struct ClassId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Class {
+    name: Name,
+    ast_id: HirAstId<StmtClassDef>,
+    // TODO type parameters, inheritance, decorators, members
+}
+
+#[newtype_index]
+pub struct AssignmentId;
+
+// This can have more than one name...
+// but that means we can't implement `name()` on `ModuleItem`.
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Assignment {
+    // TODO: Handle multiple names  / targets
+    name: Name,
+    ast_id: HirAstId<StmtAssign>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct AnnotatedAssignment {
+    name: Name,
+    ast_id: HirAstId<StmtAnnAssign>,
+}
+
+#[newtype_index]
+pub struct AnnotatedAssignmentId;
+
+#[newtype_index]
+pub struct TypeAliasId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct TypeAlias {
+    name: Name,
+    ast_id: HirAstId<StmtTypeAlias>,
+    parameters: Range<TypeParameterId>,
+}
+
+#[newtype_index]
+pub struct TypeParameterId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum TypeParameter {
+    TypeVar(TypeParameterTypeVar),
+    ParamSpec(TypeParameterParamSpec),
+    TypeVarTuple(TypeParameterTypeVarTuple),
+}
+
+impl TypeParameter {
+    pub fn ast_id(&self) -> HirAstId<TypeParam> {
+        match self {
+            TypeParameter::TypeVar(type_var) => type_var.ast_id.upcast(),
+            TypeParameter::ParamSpec(param_spec) => param_spec.ast_id.upcast(),
+            TypeParameter::TypeVarTuple(type_var_tuple) => type_var_tuple.ast_id.upcast(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct TypeParameterTypeVar {
+    name: Name,
+    ast_id: HirAstId<TypeParamTypeVar>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct TypeParameterParamSpec {
+    name: Name,
+    ast_id: HirAstId<TypeParamParamSpec>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct TypeParameterTypeVarTuple {
+    name: Name,
+    ast_id: HirAstId<TypeParamTypeVarTuple>,
+}
+
+#[newtype_index]
+pub struct GlobalId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Global {
+    // TODO track names
+    ast_id: HirAstId<StmtGlobal>,
+}
+
+#[newtype_index]
+pub struct NonLocalId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct NonLocal {
+    // TODO track names
+    ast_id: HirAstId<StmtNonlocal>,
+}
+
+pub enum DefinitionId {
+    Function(FunctionId),
+    Parameter(ParameterId),
+    Class(ClassId),
+    Assignment(AssignmentId),
+    AnnotatedAssignment(AnnotatedAssignmentId),
+    Global(GlobalId),
+    NonLocal(NonLocalId),
+    TypeParameter(TypeParameterId),
+    TypeAlias(TypeAlias),
+}
+
+pub enum DefinitionItem {
+    Function(Function),
+    Parameter(Parameter),
+    Class(Class),
+    Assignment(Assignment),
+    AnnotatedAssignment(AnnotatedAssignment),
+    Global(Global),
+    NonLocal(NonLocal),
+    TypeParameter(TypeParameter),
+    TypeAlias(TypeAlias),
+}
+
+// The closest is rust-analyzers item-tree. It only represents "Items" which make the public interface of a module
+// (it excludes any other statement or expressions). rust-analyzer uses it as the main input to the name resolution
+// algorithm
+// > It is the input to the name resolution algorithm, as well as to the queries defined in `adt.rs`,
+// > `data.rs`, and most things in `attr.rs`.
+//
+// > One important purpose of this layer is to provide an "invalidation barrier" for incremental
+// > computations: when typing inside an item body, the `ItemTree` of the modified file is typically
+// > unaffected, so we don't have to recompute name resolution results or item data (see `data.rs`).
+//
+// I haven't fully figured this out but I think that this composes the "public" interface of a module?
+// But maybe that's too optimistic.
+//
+//
+#[derive(Debug, Clone, Default, Eq, PartialEq)]
+pub struct Definitions {
+    functions: IndexVec<FunctionId, Function>,
+    parameters: IndexVec<ParameterId, Parameter>,
+    classes: IndexVec<ClassId, Class>,
+    assignments: IndexVec<AssignmentId, Assignment>,
+    annotated_assignments: IndexVec<AnnotatedAssignmentId, AnnotatedAssignment>,
+    type_aliases: IndexVec<TypeAliasId, TypeAlias>,
+    type_parameters: IndexVec<TypeParameterId, TypeParameter>,
+    globals: IndexVec<GlobalId, Global>,
+    non_locals: IndexVec<NonLocalId, NonLocal>,
+}
+
+impl Definitions {
+    pub fn from_module(module: &ModModule, ast_ids: &AstIds, file_id: FileId) -> Self {
+        let mut visitor = DefinitionsVisitor {
+            definitions: Definitions::default(),
+            ast_ids,
+            file_id,
+        };
+
+        visitor.visit_body(&module.body);
+
+        visitor.definitions
+    }
+}
+
+impl Index<FunctionId> for Definitions {
+    type Output = Function;
+
+    fn index(&self, index: FunctionId) -> &Self::Output {
+        &self.functions[index]
+    }
+}
+
+impl Index<ParameterId> for Definitions {
+    type Output = Parameter;
+
+    fn index(&self, index: ParameterId) -> &Self::Output {
+        &self.parameters[index]
+    }
+}
+
+impl Index<ClassId> for Definitions {
+    type Output = Class;
+
+    fn index(&self, index: ClassId) -> &Self::Output {
+        &self.classes[index]
+    }
+}
+
+impl Index<AssignmentId> for Definitions {
+    type Output = Assignment;
+
+    fn index(&self, index: AssignmentId) -> &Self::Output {
+        &self.assignments[index]
+    }
+}
+
+impl Index<AnnotatedAssignmentId> for Definitions {
+    type Output = AnnotatedAssignment;
+
+    fn index(&self, index: AnnotatedAssignmentId) -> &Self::Output {
+        &self.annotated_assignments[index]
+    }
+}
+
+impl Index<TypeAliasId> for Definitions {
+    type Output = TypeAlias;
+
+    fn index(&self, index: TypeAliasId) -> &Self::Output {
+        &self.type_aliases[index]
+    }
+}
+
+impl Index<GlobalId> for Definitions {
+    type Output = Global;
+
+    fn index(&self, index: GlobalId) -> &Self::Output {
+        &self.globals[index]
+    }
+}
+
+impl Index<NonLocalId> for Definitions {
+    type Output = NonLocal;
+
+    fn index(&self, index: NonLocalId) -> &Self::Output {
+        &self.non_locals[index]
+    }
+}
+
+impl Index<TypeParameterId> for Definitions {
+    type Output = TypeParameter;
+
+    fn index(&self, index: TypeParameterId) -> &Self::Output {
+        &self.type_parameters[index]
+    }
+}
+
+struct DefinitionsVisitor<'a> {
+    definitions: Definitions,
+    ast_ids: &'a AstIds,
+    file_id: FileId,
+}
+
+impl DefinitionsVisitor<'_> {
+    fn ast_id<N: HasAstId>(&self, node: &N) -> HirAstId<N> {
+        HirAstId {
+            file_id: self.file_id,
+            node_id: self.ast_ids.ast_id(node),
+        }
+    }
+
+    fn lower_function_def(&mut self, function: &StmtFunctionDef) -> FunctionId {
+        let name = Name::new(&function.name);
+
+        let first_type_parameter_id = self.definitions.type_parameters.next_index();
+        let mut last_type_parameter_id = first_type_parameter_id;
+
+        if let Some(type_params) = &function.type_params {
+            for parameter in &type_params.type_params {
+                let id = self.lower_type_parameter(parameter);
+                last_type_parameter_id = id;
+            }
+        }
+
+        let parameters = self.lower_parameters(&function.parameters);
+
+        self.definitions.functions.push(Function {
+            name,
+            ast_id: self.ast_id(function),
+            parameters,
+            type_parameters: first_type_parameter_id..last_type_parameter_id,
+        })
+    }
+
+    fn lower_parameters(&mut self, parameters: &ruff_python_ast::Parameters) -> Range<ParameterId> {
+        let first_parameter_id = self.definitions.parameters.next_index();
+        let mut last_parameter_id = first_parameter_id;
+
+        for parameter in &parameters.posonlyargs {
+            last_parameter_id = self.definitions.parameters.push(Parameter {
+                kind: ParameterKind::PositionalOnly,
+                name: Name::new(&parameter.parameter.name),
+                default: None,
+                ast_id: self.ast_id(&parameter.parameter),
+            });
+        }
+
+        if let Some(vararg) = &parameters.vararg {
+            last_parameter_id = self.definitions.parameters.push(Parameter {
+                kind: ParameterKind::Vararg,
+                name: Name::new(&vararg.name),
+                default: None,
+                ast_id: self.ast_id(vararg),
+            });
+        }
+
+        for parameter in &parameters.kwonlyargs {
+            last_parameter_id = self.definitions.parameters.push(Parameter {
+                kind: ParameterKind::KeywordOnly,
+                name: Name::new(&parameter.parameter.name),
+                default: None,
+                ast_id: self.ast_id(&parameter.parameter),
+            });
+        }
+
+        if let Some(kwarg) = &parameters.kwarg {
+            last_parameter_id = self.definitions.parameters.push(Parameter {
+                kind: ParameterKind::KeywordOnly,
+                name: Name::new(&kwarg.name),
+                default: None,
+                ast_id: self.ast_id(kwarg),
+            });
+        }
+
+        first_parameter_id..last_parameter_id
+    }
+
+    fn lower_class_def(&mut self, class: &StmtClassDef) -> ClassId {
+        let name = Name::new(&class.name);
+
+        self.definitions.classes.push(Class {
+            name,
+            ast_id: self.ast_id(class),
+        })
+    }
+
+    fn lower_assignment(&mut self, assignment: &StmtAssign) {
+        // FIXME handle multiple names
+        if let Some(Expr::Name(name)) = assignment.targets.first() {
+            self.definitions.assignments.push(Assignment {
+                name: Name::new(&name.id),
+                ast_id: self.ast_id(assignment),
+            });
+        }
+    }
+
+    fn lower_annotated_assignment(&mut self, annotated_assignment: &StmtAnnAssign) {
+        if let Expr::Name(name) = &*annotated_assignment.target {
+            self.definitions
+                .annotated_assignments
+                .push(AnnotatedAssignment {
+                    name: Name::new(&name.id),
+                    ast_id: self.ast_id(annotated_assignment),
+                });
+        }
+    }
+
+    fn lower_type_alias(&mut self, type_alias: &StmtTypeAlias) {
+        if let Expr::Name(name) = &*type_alias.name {
+            let name = Name::new(&name.id);
+
+            let lower_parameters_id = self.definitions.type_parameters.next_index();
+            let mut last_parameter_id = lower_parameters_id;
+
+            if let Some(type_params) = &type_alias.type_params {
+                for type_parameter in &type_params.type_params {
+                    let id = self.lower_type_parameter(type_parameter);
+                    last_parameter_id = id;
+                }
+            }
+
+            self.definitions.type_aliases.push(TypeAlias {
+                name,
+                ast_id: self.ast_id(type_alias),
+                parameters: lower_parameters_id..last_parameter_id,
+            });
+        }
+    }
+
+    fn lower_type_parameter(&mut self, type_parameter: &TypeParam) -> TypeParameterId {
+        match type_parameter {
+            TypeParam::TypeVar(type_var) => {
+                self.definitions
+                    .type_parameters
+                    .push(TypeParameter::TypeVar(TypeParameterTypeVar {
+                        name: Name::new(&type_var.name),
+                        ast_id: self.ast_id(type_var),
+                    }))
+            }
+            TypeParam::ParamSpec(param_spec) => {
+                self.definitions
+                    .type_parameters
+                    .push(TypeParameter::ParamSpec(TypeParameterParamSpec {
+                        name: Name::new(&param_spec.name),
+                        ast_id: self.ast_id(param_spec),
+                    }))
+            }
+            TypeParam::TypeVarTuple(type_var_tuple) => {
+                self.definitions
+                    .type_parameters
+                    .push(TypeParameter::TypeVarTuple(TypeParameterTypeVarTuple {
+                        name: Name::new(&type_var_tuple.name),
+                        ast_id: self.ast_id(type_var_tuple),
+                    }))
+            }
+        }
+    }
+
+    fn lower_import(&mut self, _import: &StmtImport) {
+        // TODO
+    }
+
+    fn lower_import_from(&mut self, _import_from: &StmtImportFrom) {
+        // TODO
+    }
+
+    fn lower_global(&mut self, global: &StmtGlobal) -> GlobalId {
+        self.definitions.globals.push(Global {
+            ast_id: self.ast_id(global),
+        })
+    }
+
+    fn lower_non_local(&mut self, non_local: &StmtNonlocal) -> NonLocalId {
+        self.definitions.non_locals.push(NonLocal {
+            ast_id: self.ast_id(non_local),
+        })
+    }
+
+    fn lower_except_handler(&mut self, _except_handler: &ExceptHandlerExceptHandler) {
+        // TODO
+    }
+
+    fn lower_with_item(&mut self, _with_item: &WithItem) {
+        // TODO
+    }
+
+    fn lower_match_case(&mut self, _match_case: &MatchCase) {
+        // TODO
+    }
+}
+
+impl PreorderVisitor<'_> for DefinitionsVisitor<'_> {
+    fn visit_stmt(&mut self, stmt: &Stmt) {
+        match stmt {
+            // Definition statements
+            Stmt::FunctionDef(definition) => {
+                self.lower_function_def(definition);
+                self.visit_body(&definition.body);
+            }
+            Stmt::ClassDef(definition) => {
+                self.lower_class_def(definition);
+                self.visit_body(&definition.body);
+            }
+            Stmt::Assign(assignment) => {
+                self.lower_assignment(assignment);
+            }
+            Stmt::AnnAssign(annotated_assignment) => {
+                self.lower_annotated_assignment(annotated_assignment);
+            }
+            Stmt::TypeAlias(type_alias) => {
+                self.lower_type_alias(type_alias);
+            }
+
+            Stmt::Import(import) => self.lower_import(import),
+            Stmt::ImportFrom(import_from) => self.lower_import_from(import_from),
+            Stmt::Global(global) => {
+                self.lower_global(global);
+            }
+            Stmt::Nonlocal(non_local) => {
+                self.lower_non_local(non_local);
+            }
+
+            // Visit the compound statement bodies because they can contain other definitions.
+            Stmt::For(_)
+            | Stmt::While(_)
+            | Stmt::If(_)
+            | Stmt::With(_)
+            | Stmt::Match(_)
+            | Stmt::Try(_) => {
+                preorder::walk_stmt(self, stmt);
+            }
+
+            // Skip over simple statements because they can't contain any other definitions.
+            Stmt::Return(_)
+            | Stmt::Delete(_)
+            | Stmt::AugAssign(_)
+            | Stmt::Raise(_)
+            | Stmt::Assert(_)
+            | Stmt::Expr(_)
+            | Stmt::Pass(_)
+            | Stmt::Break(_)
+            | Stmt::Continue(_)
+            | Stmt::IpyEscapeCommand(_) => {
+                // No op
+            }
+        }
+    }
+
+    fn visit_expr(&mut self, _: &'_ Expr) {}
+
+    fn visit_decorator(&mut self, _decorator: &'_ Decorator) {}
+
+    fn visit_except_handler(&mut self, except_handler: &'_ ExceptHandler) {
+        match except_handler {
+            ExceptHandler::ExceptHandler(except_handler) => {
+                self.lower_except_handler(except_handler);
+            }
+        }
+    }
+
+    fn visit_with_item(&mut self, with_item: &'_ WithItem) {
+        self.lower_with_item(with_item);
+    }
+
+    fn visit_match_case(&mut self, match_case: &'_ MatchCase) {
+        self.lower_match_case(match_case);
+        self.visit_body(&match_case.body);
+    }
+}

crates/red_knot/src/lib.rs

@@ -1,6 +1,108 @@
-use crate::db::Jar;
+use std::fmt::Formatter;
+use std::hash::BuildHasherDefault;
+use std::ops::Deref;
+use std::path::{Path, PathBuf};
 
+use rustc_hash::{FxHashSet, FxHasher};
+
+use crate::files::FileId;
+
+pub mod ast_ids;
+pub mod cache;
+pub mod cancellation;
 pub mod db;
+pub mod files;
+pub mod hir;
 pub mod lint;
+pub mod module;
+mod parse;
+pub mod program;
+mod semantic;
+pub mod source;
 pub mod watch;
-pub mod workspace;
+
+pub(crate) type FxDashMap<K, V> = dashmap::DashMap<K, V, BuildHasherDefault<FxHasher>>;
+#[allow(unused)]
+pub(crate) type FxDashSet<V> = dashmap::DashSet<V, BuildHasherDefault<FxHasher>>;
+pub(crate) type FxIndexSet<V> = indexmap::set::IndexSet<V, BuildHasherDefault<FxHasher>>;
+
+#[derive(Debug, Clone)]
+pub struct Workspace {
+    /// TODO this should be a resolved path. We should probably use a newtype wrapper that guarantees that
+    /// PATH is a UTF-8 path and is normalized.
+    root: PathBuf,
+    /// The files that are open in the workspace.
+    ///
+    /// * Editor: The files that are actively being edited in the editor (the user has a tab open with the file).
+    /// * CLI: The resolved files passed as arguments to the CLI.
+    open_files: FxHashSet<FileId>,
+}
+
+impl Workspace {
+    pub fn new(root: PathBuf) -> Self {
+        Self {
+            root,
+            open_files: FxHashSet::default(),
+        }
+    }
+
+    pub fn root(&self) -> &Path {
+        self.root.as_path()
+    }
+
+    // TODO having the content in workspace feels wrong.
+    pub fn open_file(&mut self, file_id: FileId) {
+        self.open_files.insert(file_id);
+    }
+
+    pub fn close_file(&mut self, file_id: FileId) {
+        self.open_files.remove(&file_id);
+    }
+
+    // TODO introduce an `OpenFile` type instead of using an anonymous tuple.
+    pub fn open_files(&self) -> impl Iterator<Item = FileId> + '_ {
+        self.open_files.iter().copied()
+    }
+
+    pub fn is_file_open(&self, file_id: FileId) -> bool {
+        self.open_files.contains(&file_id)
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct Name(smol_str::SmolStr);
+
+impl Name {
+    #[inline]
+    pub fn new(name: &str) -> Self {
+        Self(smol_str::SmolStr::new(name))
+    }
+
+    pub fn as_str(&self) -> &str {
+        self.0.as_str()
+    }
+}
+
+impl Deref for Name {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.as_str()
+    }
+}
+
+impl<T> From<T> for Name
+where
+    T: Into<smol_str::SmolStr>,
+{
+    fn from(value: T) -> Self {
+        Self(value.into())
+    }
+}
+
+impl std::fmt::Display for Name {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}

crates/red_knot/src/lint.rs

@@ -1,59 +1,60 @@
 use std::cell::RefCell;
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
 use std::time::Duration;
 
-use tracing::trace_span;
+use ruff_python_ast::visitor::Visitor;
+use ruff_python_ast::{ModModule, StringLiteral};
+use ruff_python_parser::Parsed;
 
-use red_knot_module_resolver::ModuleName;
-use red_knot_python_semantic::types::Type;
-use red_knot_python_semantic::{HasTy, SemanticModel};
-use ruff_db::files::File;
-use ruff_db::parsed::{parsed_module, ParsedModule};
-use ruff_db::source::{source_text, SourceText};
-use ruff_python_ast as ast;
-use ruff_python_ast::visitor::{walk_stmt, Visitor};
+use crate::cache::KeyValueCache;
+use crate::db::{LintDb, LintJar, QueryResult};
+use crate::files::FileId;
+use crate::module::{resolve_module, ModuleName};
+use crate::parse::parse;
+use crate::semantic::{infer_definition_type, infer_symbol_public_type, Type};
+use crate::semantic::{
+    resolve_global_symbol, semantic_index, Definition, GlobalSymbolId, SemanticIndex, SymbolId,
+};
+use crate::source::{source_text, Source};
 
-use crate::db::Db;
+#[tracing::instrument(level = "debug", skip(db))]
+pub(crate) fn lint_syntax(db: &dyn LintDb, file_id: FileId) -> QueryResult<Diagnostics> {
+    let lint_jar: &LintJar = db.jar()?;
+    let storage = &lint_jar.lint_syntax;
 
-/// Workaround query to test for if the computation should be cancelled.
-/// Ideally, push for Salsa to expose an API for testing if cancellation was requested.
-#[salsa::tracked]
-#[allow(unused_variables)]
-pub(crate) fn unwind_if_cancelled(db: &dyn Db) {}
-
-#[salsa::tracked(return_ref)]
-pub(crate) fn lint_syntax(db: &dyn Db, file_id: File) -> Diagnostics {
     #[allow(clippy::print_stdout)]
     if std::env::var("RED_KNOT_SLOW_LINT").is_ok() {
         for i in 0..10 {
-            unwind_if_cancelled(db);
-
+            db.cancelled()?;
             println!("RED_KNOT_SLOW_LINT is set, sleeping for {i}/10 seconds");
             std::thread::sleep(Duration::from_secs(1));
         }
     }
 
-    let mut diagnostics = Vec::new();
+    storage.get(&file_id, |file_id| {
+        let mut diagnostics = Vec::new();
 
-    let source = source_text(db.upcast(), file_id);
-    lint_lines(&source, &mut diagnostics);
+        let source = source_text(db.upcast(), *file_id)?;
+        lint_lines(source.text(), &mut diagnostics);
 
-    let parsed = parsed_module(db.upcast(), file_id);
+        let parsed = parse(db.upcast(), *file_id)?;
 
-    if parsed.errors().is_empty() {
-        let ast = parsed.syntax();
+        if parsed.errors().is_empty() {
+            let ast = parsed.syntax();
 
-        let mut visitor = SyntaxLintVisitor {
-            diagnostics,
-            source: &source,
-        };
-        visitor.visit_body(&ast.body);
-        diagnostics = visitor.diagnostics;
-    } else {
-        diagnostics.extend(parsed.errors().iter().map(ToString::to_string));
-    }
+            let mut visitor = SyntaxLintVisitor {
+                diagnostics,
+                source: source.text(),
+            };
+            visitor.visit_body(&ast.body);
+            diagnostics = visitor.diagnostics;
+        } else {
+            diagnostics.extend(parsed.errors().iter().map(std::string::ToString::to_string));
+        }
 
-    Diagnostics::from(diagnostics)
+        Ok(Diagnostics::from(diagnostics))
+    })
 }
 
 fn lint_lines(source: &str, diagnostics: &mut Vec<String>) {
@@ -73,125 +74,177 @@ fn lint_lines(source: &str, diagnostics: &mut Vec<String>) {
     }
 }
 
-#[salsa::tracked(return_ref)]
-pub(crate) fn lint_semantic(db: &dyn Db, file_id: File) -> Diagnostics {
-    let _span = trace_span!("lint_semantic", ?file_id).entered();
+#[tracing::instrument(level = "debug", skip(db))]
+pub(crate) fn lint_semantic(db: &dyn LintDb, file_id: FileId) -> QueryResult<Diagnostics> {
+    let lint_jar: &LintJar = db.jar()?;
+    let storage = &lint_jar.lint_semantic;
 
-    let source = source_text(db.upcast(), file_id);
-    let parsed = parsed_module(db.upcast(), file_id);
-    let semantic = SemanticModel::new(db.upcast(), file_id);
+    storage.get(&file_id, |file_id| {
+        let source = source_text(db.upcast(), *file_id)?;
+        let parsed = parse(db.upcast(), *file_id)?;
+        let semantic_index = semantic_index(db.upcast(), *file_id)?;
 
-    if !parsed.is_valid() {
-        return Diagnostics::Empty;
-    }
-
-    let context = SemanticLintContext {
-        source,
-        parsed,
-        semantic,
-        diagnostics: RefCell::new(Vec::new()),
-    };
-
-    SemanticVisitor { context: &context }.visit_body(parsed.suite());
-
-    Diagnostics::from(context.diagnostics.take())
-}
-
-fn lint_unresolved_imports(context: &SemanticLintContext, import: AnyImportRef) {
-    match import {
-        AnyImportRef::Import(import) => {
-            for alias in &import.names {
-                let ty = alias.ty(&context.semantic);
-
-                if ty.is_unbound() {
-                    context.push_diagnostic(format!("Unresolved import '{}'", &alias.name));
-                }
-            }
-        }
-        AnyImportRef::ImportFrom(import) => {
-            for alias in &import.names {
-                let ty = alias.ty(&context.semantic);
-
-                if ty.is_unbound() {
-                    context.push_diagnostic(format!("Unresolved import '{}'", &alias.name));
-                }
-            }
-        }
-    }
-}
-
-fn lint_bad_override(context: &SemanticLintContext, class: &ast::StmtClassDef) {
-    let semantic = &context.semantic;
-
-    // TODO we should have a special marker on the real typing module (from typeshed) so if you
-    //   have your own "typing" module in your project, we don't consider it THE typing module (and
-    //   same for other stdlib modules that our lint rules care about)
-    let Some(typing) = semantic.resolve_module(ModuleName::new("typing").unwrap()) else {
-        return;
-    };
-
-    let override_ty = semantic.global_symbol_ty(&typing, "override");
-
-    let Type::Class(class_ty) = class.ty(semantic) else {
-        return;
-    };
-
-    for function in class
-        .body
-        .iter()
-        .filter_map(|stmt| stmt.as_function_def_stmt())
-    {
-        let Type::Function(ty) = function.ty(semantic) else {
-            return;
+        let context = SemanticLintContext {
+            file_id: *file_id,
+            source,
+            parsed: &parsed,
+            semantic_index,
+            db,
+            diagnostics: RefCell::new(Vec::new()),
         };
 
-        // TODO this shouldn't make direct use of the Db; see comment on SemanticModel::db
-        let db = semantic.db();
+        lint_unresolved_imports(&context)?;
+        lint_bad_overrides(&context)?;
 
-        if ty.has_decorator(db, override_ty) {
-            let method_name = ty.name(db);
-            if class_ty
-                .inherited_class_member(db, &method_name)
-                .is_unbound()
+        Ok(Diagnostics::from(context.diagnostics.take()))
+    })
+}
+
+fn lint_unresolved_imports(context: &SemanticLintContext) -> QueryResult<()> {
+    // TODO: Consider iterating over the dependencies (imports) only instead of all definitions.
+    for (symbol, definition) in context.semantic_index().symbol_table().all_definitions() {
+        match definition {
+            Definition::Import(import) => {
+                let ty = context.infer_symbol_public_type(symbol)?;
+
+                if ty.is_unknown() {
+                    context.push_diagnostic(format!("Unresolved module {}", import.module));
+                }
+            }
+            Definition::ImportFrom(import) => {
+                let ty = context.infer_symbol_public_type(symbol)?;
+
+                if ty.is_unknown() {
+                    let module_name = import.module().map(Deref::deref).unwrap_or_default();
+                    let message = if import.level() > 0 {
+                        format!(
+                            "Unresolved relative import '{}' from {}{}",
+                            import.name(),
+                            ".".repeat(import.level() as usize),
+                            module_name
+                        )
+                    } else {
+                        format!(
+                            "Unresolved import '{}' from '{}'",
+                            import.name(),
+                            module_name
+                        )
+                    };
+
+                    context.push_diagnostic(message);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    Ok(())
+}
+
+fn lint_bad_overrides(context: &SemanticLintContext) -> QueryResult<()> {
+    // TODO we should have a special marker on the real typing module (from typeshed) so if you
+    // have your own "typing" module in your project, we don't consider it THE typing module (and
+    // same for other stdlib modules that our lint rules care about)
+    let Some(typing_override) = context.resolve_global_symbol("typing", "override")? else {
+        // TODO once we bundle typeshed, this should be unreachable!()
+        return Ok(());
+    };
+
+    // TODO we should maybe index definitions by type instead of iterating all, or else iterate all
+    // just once, match, and branch to all lint rules that care about a type of definition
+    for (symbol, definition) in context.semantic_index().symbol_table().all_definitions() {
+        if !matches!(definition, Definition::FunctionDef(_)) {
+            continue;
+        }
+        let ty = infer_definition_type(
+            context.db.upcast(),
+            GlobalSymbolId {
+                file_id: context.file_id,
+                symbol_id: symbol,
+            },
+            definition.clone(),
+        )?;
+        let Type::Function(func) = ty else {
+            unreachable!("type of a FunctionDef should always be a Function");
+        };
+        let Some(class) = func.get_containing_class(context.db.upcast())? else {
+            // not a method of a class
+            continue;
+        };
+        if func.has_decorator(context.db.upcast(), typing_override)? {
+            let method_name = func.name(context.db.upcast())?;
+            if class
+                .get_super_class_member(context.db.upcast(), &method_name)?
+                .is_none()
             {
                 // TODO should have a qualname() method to support nested classes
                 context.push_diagnostic(
                     format!(
                         "Method {}.{} is decorated with `typing.override` but does not override any base class method",
-                        class_ty.name(db),
+                        class.name(context.db.upcast())?,
                         method_name,
                     ));
             }
         }
     }
+    Ok(())
 }
 
-pub(crate) struct SemanticLintContext<'a> {
-    source: SourceText,
-    parsed: &'a ParsedModule,
-    semantic: SemanticModel<'a>,
+pub struct SemanticLintContext<'a> {
+    file_id: FileId,
+    source: Source,
+    parsed: &'a Parsed<ModModule>,
+    semantic_index: Arc<SemanticIndex>,
+    db: &'a dyn LintDb,
     diagnostics: RefCell<Vec<String>>,
 }
 
-impl<'db> SemanticLintContext<'db> {
-    #[allow(unused)]
-    pub(crate) fn source_text(&self) -> &str {
-        self.source.as_str()
+impl<'a> SemanticLintContext<'a> {
+    pub fn source_text(&self) -> &str {
+        self.source.text()
     }
 
-    #[allow(unused)]
-    pub(crate) fn ast(&self) -> &'db ast::ModModule {
+    pub fn file_id(&self) -> FileId {
+        self.file_id
+    }
+
+    pub fn ast(&self) -> &'a ModModule {
         self.parsed.syntax()
     }
 
-    pub(crate) fn push_diagnostic(&self, diagnostic: String) {
+    pub fn semantic_index(&self) -> &SemanticIndex {
+        &self.semantic_index
+    }
+
+    pub fn infer_symbol_public_type(&self, symbol_id: SymbolId) -> QueryResult<Type> {
+        infer_symbol_public_type(
+            self.db.upcast(),
+            GlobalSymbolId {
+                file_id: self.file_id,
+                symbol_id,
+            },
+        )
+    }
+
+    pub fn push_diagnostic(&self, diagnostic: String) {
         self.diagnostics.borrow_mut().push(diagnostic);
     }
 
-    #[allow(unused)]
-    pub(crate) fn extend_diagnostics(&mut self, diagnostics: impl IntoIterator<Item = String>) {
+    pub fn extend_diagnostics(&mut self, diagnostics: impl IntoIterator<Item = String>) {
         self.diagnostics.get_mut().extend(diagnostics);
     }
+
+    pub fn resolve_global_symbol(
+        &self,
+        module: &str,
+        symbol_name: &str,
+    ) -> QueryResult<Option<GlobalSymbolId>> {
+        let Some(module) = resolve_module(self.db.upcast(), ModuleName::new(module))? else {
+            return Ok(None);
+        };
+
+        resolve_global_symbol(self.db.upcast(), module, symbol_name)
+    }
 }
 
 #[derive(Debug)]
@@ -201,7 +254,7 @@ struct SyntaxLintVisitor<'a> {
 }
 
 impl Visitor<'_> for SyntaxLintVisitor<'_> {
-    fn visit_string_literal(&mut self, string_literal: &'_ ast::StringLiteral) {
+    fn visit_string_literal(&mut self, string_literal: &'_ StringLiteral) {
         // A very naive implementation of use double quotes
         let text = &self.source[string_literal.range];
 
@@ -212,33 +265,10 @@ impl Visitor<'_> for SyntaxLintVisitor<'_> {
     }
 }
 
-struct SemanticVisitor<'a> {
-    context: &'a SemanticLintContext<'a>,
-}
-
-impl Visitor<'_> for SemanticVisitor<'_> {
-    fn visit_stmt(&mut self, stmt: &ast::Stmt) {
-        match stmt {
-            ast::Stmt::ClassDef(class) => {
-                lint_bad_override(self.context, class);
-            }
-            ast::Stmt::Import(import) => {
-                lint_unresolved_imports(self.context, AnyImportRef::Import(import));
-            }
-            ast::Stmt::ImportFrom(import) => {
-                lint_unresolved_imports(self.context, AnyImportRef::ImportFrom(import));
-            }
-            _ => {}
-        }
-
-        walk_stmt(self, stmt);
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone)]
 pub enum Diagnostics {
     Empty,
-    List(Vec<String>),
+    List(Arc<Vec<String>>),
 }
 
 impl Diagnostics {
@@ -262,13 +292,41 @@ impl From<Vec<String>> for Diagnostics {
         if value.is_empty() {
             Diagnostics::Empty
         } else {
-            Diagnostics::List(value)
+            Diagnostics::List(Arc::new(value))
         }
     }
 }
 
-#[derive(Copy, Clone, Debug)]
-enum AnyImportRef<'a> {
-    Import(&'a ast::StmtImport),
-    ImportFrom(&'a ast::StmtImportFrom),
+#[derive(Default, Debug)]
+pub struct LintSyntaxStorage(KeyValueCache<FileId, Diagnostics>);
+
+impl Deref for LintSyntaxStorage {
+    type Target = KeyValueCache<FileId, Diagnostics>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for LintSyntaxStorage {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct LintSemanticStorage(KeyValueCache<FileId, Diagnostics>);
+
+impl Deref for LintSemanticStorage {
+    type Target = KeyValueCache<FileId, Diagnostics>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for LintSemanticStorage {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
 }

crates/red_knot/src/main.rs

@@ -1,8 +1,9 @@
+#![allow(clippy::dbg_macro)]
+
+use std::path::Path;
 use std::sync::Mutex;
 
-use clap::Parser;
 use crossbeam::channel as crossbeam_channel;
-use salsa::ParallelDatabase;
 use tracing::subscriber::Interest;
 use tracing::{Level, Metadata};
 use tracing_subscriber::filter::LevelFilter;
@@ -10,102 +11,55 @@ use tracing_subscriber::layer::{Context, Filter, SubscriberExt};
 use tracing_subscriber::{Layer, Registry};
 use tracing_tree::time::Uptime;
 
-use red_knot::db::RootDatabase;
+use red_knot::db::{HasJar, ParallelDatabase, QueryError, SourceDb, SourceJar};
+use red_knot::module::{set_module_search_paths, ModuleResolutionInputs};
+use red_knot::program::check::ExecutionMode;
+use red_knot::program::{FileWatcherChange, Program};
 use red_knot::watch::FileWatcher;
-use red_knot::watch::FileWatcherChange;
-use red_knot::workspace::WorkspaceMetadata;
-use ruff_db::program::{ProgramSettings, SearchPathSettings};
-use ruff_db::system::{OsSystem, System, SystemPathBuf};
+use red_knot::Workspace;
 
-use cli::target_version::TargetVersion;
-use cli::verbosity::{Verbosity, VerbosityLevel};
+#[allow(clippy::print_stdout, clippy::unnecessary_wraps, clippy::print_stderr)]
+fn main() -> anyhow::Result<()> {
+    setup_tracing();
 
-mod cli;
+    let arguments: Vec<_> = std::env::args().collect();
 
-#[derive(Debug, Parser)]
-#[command(
-    author,
-    name = "red-knot",
-    about = "An experimental multifile analysis backend for Ruff"
-)]
-#[command(version)]
-struct Args {
-    #[arg(
-        long,
-        help = "Changes the current working directory.",
-        long_help = "Changes the current working directory before any specified operations. This affects the workspace and configuration discovery.",
-        value_name = "PATH"
-    )]
-    current_directory: Option<SystemPathBuf>,
+    if arguments.len() < 2 {
+        eprintln!("Usage: red_knot <path>");
+        return Err(anyhow::anyhow!("Invalid arguments"));
+    }
 
-    #[arg(
-        long,
-        value_name = "DIRECTORY",
-        help = "Custom directory to use for stdlib typeshed stubs"
-    )]
-    custom_typeshed_dir: Option<SystemPathBuf>,
+    let entry_point = Path::new(&arguments[1]);
 
-    #[arg(
-        long,
-        value_name = "PATH",
-        help = "Additional path to use as a module-resolution source (can be passed multiple times)"
-    )]
-    extra_search_path: Vec<SystemPathBuf>,
+    if !entry_point.exists() {
+        eprintln!("The entry point does not exist.");
+        return Err(anyhow::anyhow!("Invalid arguments"));
+    }
 
-    #[arg(long, help = "Python version to assume when resolving types", default_value_t = TargetVersion::default(), value_name="VERSION")]
-    target_version: TargetVersion,
+    if !entry_point.is_file() {
+        eprintln!("The entry point is not a file.");
+        return Err(anyhow::anyhow!("Invalid arguments"));
+    }
 
-    #[clap(flatten)]
-    verbosity: Verbosity,
-}
+    let workspace_folder = entry_point.parent().unwrap();
+    let workspace = Workspace::new(workspace_folder.to_path_buf());
 
-#[allow(
-    clippy::print_stdout,
-    clippy::unnecessary_wraps,
-    clippy::print_stderr,
-    clippy::dbg_macro
-)]
-pub fn main() -> anyhow::Result<()> {
-    let Args {
-        current_directory,
-        custom_typeshed_dir,
-        extra_search_path: extra_paths,
-        target_version,
-        verbosity,
-    } = Args::parse_from(std::env::args().collect::<Vec<_>>());
+    let workspace_search_path = workspace.root().to_path_buf();
 
-    let verbosity = verbosity.level();
-    countme::enable(verbosity == Some(VerbosityLevel::Trace));
-    setup_tracing(verbosity);
-
-    let cwd = if let Some(cwd) = current_directory {
-        let canonicalized = cwd.as_utf8_path().canonicalize_utf8().unwrap();
-        SystemPathBuf::from_utf8_path_buf(canonicalized)
-    } else {
-        let cwd = std::env::current_dir().unwrap();
-        SystemPathBuf::from_path_buf(cwd).unwrap()
+    let search_paths = ModuleResolutionInputs {
+        extra_paths: vec![],
+        workspace_root: workspace_search_path,
+        site_packages: None,
+        custom_typeshed: None,
     };
 
-    let system = OsSystem::new(cwd.clone());
-    let workspace_metadata =
-        WorkspaceMetadata::from_path(system.current_directory(), &system).unwrap();
+    let mut program = Program::new(workspace);
+    set_module_search_paths(&mut program, search_paths);
 
-    // 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,
-            workspace_root: workspace_metadata.root().to_path_buf(),
-            custom_typeshed: custom_typeshed_dir,
-            site_packages: None,
-        },
-    };
+    let entry_id = program.file_id(entry_point);
+    program.workspace_mut().open_file(entry_id);
 
-    // 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 (main_loop, main_loop_cancellation_token) = MainLoop::new(verbosity);
+    let (main_loop, main_loop_cancellation_token) = MainLoop::new();
 
     // Listen to Ctrl+C and abort the watch mode.
     let main_loop_cancellation_token = Mutex::new(Some(main_loop_cancellation_token));
@@ -124,29 +78,31 @@ pub fn main() -> anyhow::Result<()> {
         file_changes_notifier.notify(changes);
     })?;
 
-    file_watcher.watch_folder(db.workspace().root(&db).as_std_path())?;
+    file_watcher.watch_folder(workspace_folder)?;
 
-    main_loop.run(&mut db);
+    main_loop.run(&mut program);
 
-    println!("{}", countme::get_all());
+    let source_jar: &SourceJar = program.jar().unwrap();
+
+    dbg!(source_jar.parsed.statistics());
+    dbg!(source_jar.sources.statistics());
 
     Ok(())
 }
 
 struct MainLoop {
-    verbosity: Option<VerbosityLevel>,
-    orchestrator: crossbeam_channel::Sender<OrchestratorMessage>,
-    receiver: crossbeam_channel::Receiver<MainLoopMessage>,
+    orchestrator_sender: crossbeam_channel::Sender<OrchestratorMessage>,
+    main_loop_receiver: crossbeam_channel::Receiver<MainLoopMessage>,
 }
 
 impl MainLoop {
-    fn new(verbosity: Option<VerbosityLevel>) -> (Self, MainLoopCancellationToken) {
+    fn new() -> (Self, MainLoopCancellationToken) {
         let (orchestrator_sender, orchestrator_receiver) = crossbeam_channel::bounded(1);
         let (main_loop_sender, main_loop_receiver) = crossbeam_channel::bounded(1);
 
         let mut orchestrator = Orchestrator {
             receiver: orchestrator_receiver,
-            main_loop: main_loop_sender.clone(),
+            sender: main_loop_sender.clone(),
             revision: 0,
         };
 
@@ -156,9 +112,8 @@ impl MainLoop {
 
         (
             Self {
-                verbosity,
-                orchestrator: orchestrator_sender,
-                receiver: main_loop_receiver,
+                orchestrator_sender,
+                main_loop_receiver,
             },
             MainLoopCancellationToken {
                 sender: main_loop_sender,
@@ -168,49 +123,45 @@ impl MainLoop {
 
     fn file_changes_notifier(&self) -> FileChangesNotifier {
         FileChangesNotifier {
-            sender: self.orchestrator.clone(),
+            sender: self.orchestrator_sender.clone(),
         }
     }
 
-    #[allow(clippy::print_stderr)]
-    fn run(self, db: &mut RootDatabase) {
-        self.orchestrator.send(OrchestratorMessage::Run).unwrap();
+    fn run(self, program: &mut Program) {
+        self.orchestrator_sender
+            .send(OrchestratorMessage::Run)
+            .unwrap();
 
-        for message in &self.receiver {
+        for message in &self.main_loop_receiver {
             tracing::trace!("Main Loop: Tick");
 
             match message {
-                MainLoopMessage::CheckWorkspace { revision } => {
-                    let db = db.snapshot();
-                    let orchestrator = self.orchestrator.clone();
+                MainLoopMessage::CheckProgram { revision } => {
+                    let program = program.snapshot();
+                    let sender = self.orchestrator_sender.clone();
 
-                    // Spawn a new task that checks the workspace. This needs to be done in a separate thread
+                    // Spawn a new task that checks the program. This needs to be done in a separate thread
                     // to prevent blocking the main loop here.
-                    rayon::spawn(move || {
-                        if let Ok(result) = db.check() {
-                            orchestrator
-                                .send(OrchestratorMessage::CheckCompleted {
+                    rayon::spawn(move || match program.check(ExecutionMode::ThreadPool) {
+                        Ok(result) => {
+                            sender
+                                .send(OrchestratorMessage::CheckProgramCompleted {
                                     diagnostics: result,
                                     revision,
                                 })
                                 .unwrap();
                         }
+                        Err(QueryError::Cancelled) => {}
                     });
                 }
                 MainLoopMessage::ApplyChanges(changes) => {
                     // Automatically cancels any pending queries and waits for them to complete.
-                    db.apply_changes(changes);
+                    program.apply_changes(changes);
                 }
                 MainLoopMessage::CheckCompleted(diagnostics) => {
-                    eprintln!("{}", diagnostics.join("\n"));
-                    if self.verbosity == Some(VerbosityLevel::Trace) {
-                        eprintln!("{}", countme::get_all());
-                    }
+                    dbg!(diagnostics);
                 }
                 MainLoopMessage::Exit => {
-                    if self.verbosity == Some(VerbosityLevel::Trace) {
-                        eprintln!("{}", countme::get_all());
-                    }
                     return;
                 }
             }
@@ -220,7 +171,7 @@ impl MainLoop {
 
 impl Drop for MainLoop {
     fn drop(&mut self) {
-        self.orchestrator
+        self.orchestrator_sender
             .send(OrchestratorMessage::Shutdown)
             .unwrap();
     }
@@ -252,32 +203,31 @@ impl MainLoopCancellationToken {
 
 struct Orchestrator {
     /// Sends messages to the main loop.
-    main_loop: crossbeam_channel::Sender<MainLoopMessage>,
+    sender: crossbeam_channel::Sender<MainLoopMessage>,
     /// Receives messages from the main loop.
     receiver: crossbeam_channel::Receiver<OrchestratorMessage>,
     revision: usize,
 }
 
 impl Orchestrator {
-    #[allow(clippy::print_stderr)]
     fn run(&mut self) {
         while let Ok(message) = self.receiver.recv() {
             match message {
                 OrchestratorMessage::Run => {
-                    self.main_loop
-                        .send(MainLoopMessage::CheckWorkspace {
+                    self.sender
+                        .send(MainLoopMessage::CheckProgram {
                             revision: self.revision,
                         })
                         .unwrap();
                 }
 
-                OrchestratorMessage::CheckCompleted {
+                OrchestratorMessage::CheckProgramCompleted {
                     diagnostics,
                     revision,
                 } => {
                     // Only take the diagnostics if they are for the latest revision.
                     if self.revision == revision {
-                        self.main_loop
+                        self.sender
                             .send(MainLoopMessage::CheckCompleted(diagnostics))
                             .unwrap();
                     } else {
@@ -312,7 +262,7 @@ impl Orchestrator {
                             changes.extend(file_changes);
                         }
 
-                        Ok(OrchestratorMessage::CheckCompleted { .. })=> {
+                        Ok(OrchestratorMessage::CheckProgramCompleted { .. })=> {
                             // disregard any outdated completion message.
                         }
                         Ok(OrchestratorMessage::Run) => unreachable!("The orchestrator is already running."),
@@ -325,8 +275,8 @@ impl Orchestrator {
                 },
                 default(std::time::Duration::from_millis(10)) => {
                     // No more file changes after 10 ms, send the changes and schedule a new analysis
-                    self.main_loop.send(MainLoopMessage::ApplyChanges(changes)).unwrap();
-                    self.main_loop.send(MainLoopMessage::CheckWorkspace { revision: self.revision}).unwrap();
+                    self.sender.send(MainLoopMessage::ApplyChanges(changes)).unwrap();
+                    self.sender.send(MainLoopMessage::CheckProgram { revision: self.revision}).unwrap();
                     return;
                 }
             }
@@ -342,7 +292,7 @@ impl Orchestrator {
 /// Message sent from the orchestrator to the main loop.
 #[derive(Debug)]
 enum MainLoopMessage {
-    CheckWorkspace { revision: usize },
+    CheckProgram { revision: usize },
     CheckCompleted(Vec<String>),
     ApplyChanges(Vec<FileWatcherChange>),
     Exit,
@@ -353,7 +303,7 @@ enum OrchestratorMessage {
     Run,
     Shutdown,
 
-    CheckCompleted {
+    CheckProgramCompleted {
         diagnostics: Vec<String>,
         revision: usize,
     },
@@ -361,14 +311,7 @@ enum OrchestratorMessage {
     FileChanges(Vec<FileWatcherChange>),
 }
 
-fn setup_tracing(verbosity: Option<VerbosityLevel>) {
-    let trace_level = match verbosity {
-        None => Level::WARN,
-        Some(VerbosityLevel::Info) => Level::INFO,
-        Some(VerbosityLevel::Debug) => Level::DEBUG,
-        Some(VerbosityLevel::Trace) => Level::TRACE,
-    };
-
+fn setup_tracing() {
     let subscriber = Registry::default().with(
         tracing_tree::HierarchicalLayer::default()
             .with_indent_lines(true)
@@ -378,7 +321,9 @@ fn setup_tracing(verbosity: Option<VerbosityLevel>) {
             .with_targets(true)
             .with_writer(|| Box::new(std::io::stderr()))
             .with_timer(Uptime::default())
-            .with_filter(LoggingFilter { trace_level }),
+            .with_filter(LoggingFilter {
+                trace_level: Level::TRACE,
+            }),
     );
 
     tracing::subscriber::set_global_default(subscriber).unwrap();

crates/red_knot/src/parse.rs

@@ -0,0 +1,41 @@
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+
+use ruff_python_ast::ModModule;
+use ruff_python_parser::Parsed;
+
+use crate::cache::KeyValueCache;
+use crate::db::{QueryResult, SourceDb};
+use crate::files::FileId;
+use crate::source::source_text;
+
+#[tracing::instrument(level = "debug", skip(db))]
+pub(crate) fn parse(db: &dyn SourceDb, file_id: FileId) -> QueryResult<Arc<Parsed<ModModule>>> {
+    let jar = db.jar()?;
+
+    jar.parsed.get(&file_id, |file_id| {
+        let source = source_text(db, *file_id)?;
+
+        Ok(Arc::new(ruff_python_parser::parse_unchecked_source(
+            source.text(),
+            source.kind().into(),
+        )))
+    })
+}
+
+#[derive(Debug, Default)]
+pub struct ParsedStorage(KeyValueCache<FileId, Arc<Parsed<ModModule>>>);
+
+impl Deref for ParsedStorage {
+    type Target = KeyValueCache<FileId, Arc<Parsed<ModModule>>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for ParsedStorage {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}

crates/red_knot/src/program/check.rs

@@ -0,0 +1,413 @@
+use rayon::{current_num_threads, yield_local};
+use rustc_hash::FxHashSet;
+
+use crate::db::{Database, QueryError, QueryResult};
+use crate::files::FileId;
+use crate::lint::{lint_semantic, lint_syntax, Diagnostics};
+use crate::module::{file_to_module, resolve_module};
+use crate::program::Program;
+use crate::semantic::{semantic_index, Dependency};
+
+impl Program {
+    /// Checks all open files in the workspace and its dependencies.
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub fn check(&self, mode: ExecutionMode) -> QueryResult<Vec<String>> {
+        self.cancelled()?;
+
+        let mut context = CheckContext::new(self);
+
+        match mode {
+            ExecutionMode::SingleThreaded => SingleThreadedExecutor.run(&mut context)?,
+            ExecutionMode::ThreadPool => ThreadPoolExecutor.run(&mut context)?,
+        };
+
+        Ok(context.finish())
+    }
+
+    #[tracing::instrument(level = "debug", skip(self, context))]
+    fn check_file(&self, file: FileId, context: &CheckFileContext) -> QueryResult<Diagnostics> {
+        self.cancelled()?;
+
+        let index = semantic_index(self, file)?;
+        let dependencies = index.symbol_table().dependencies();
+
+        if !dependencies.is_empty() {
+            let module = file_to_module(self, file)?;
+
+            // TODO scheduling all dependencies here is wasteful if we don't infer any types on them
+            //  but I think that's unlikely, so it is okay?
+            //  Anyway, we need to figure out a way to retrieve the dependencies of a module
+            //  from the persistent cache. So maybe it should be a separate query after all.
+            for dependency in dependencies {
+                let dependency_name = match dependency {
+                    Dependency::Module(name) => Some(name.clone()),
+                    Dependency::Relative { .. } => match &module {
+                        Some(module) => module.resolve_dependency(self, dependency)?,
+                        None => None,
+                    },
+                };
+
+                if let Some(dependency_name) = dependency_name {
+                    // TODO We may want to have a different check functions for non-first-party
+                    //   files because we only need to index them and not check them.
+                    //   Supporting non-first-party code also requires supporting typing stubs.
+                    if let Some(dependency) = resolve_module(self, dependency_name)? {
+                        if dependency.path(self)?.root().kind().is_first_party() {
+                            context.schedule_dependency(dependency.path(self)?.file());
+                        }
+                    }
+                }
+            }
+        }
+
+        let mut diagnostics = Vec::new();
+
+        if self.workspace().is_file_open(file) {
+            diagnostics.extend_from_slice(&lint_syntax(self, file)?);
+            diagnostics.extend_from_slice(&lint_semantic(self, file)?);
+        }
+
+        Ok(Diagnostics::from(diagnostics))
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum ExecutionMode {
+    SingleThreaded,
+    ThreadPool,
+}
+
+/// Context that stores state information about the entire check operation.
+struct CheckContext<'a> {
+    /// IDs of the files that have been queued for checking.
+    ///
+    /// Used to avoid queuing the same file twice.
+    scheduled_files: FxHashSet<FileId>,
+
+    /// Reference to the program that is checked.
+    program: &'a Program,
+
+    /// The aggregated diagnostics
+    diagnostics: Vec<String>,
+}
+
+impl<'a> CheckContext<'a> {
+    fn new(program: &'a Program) -> Self {
+        Self {
+            scheduled_files: FxHashSet::default(),
+            program,
+            diagnostics: Vec::new(),
+        }
+    }
+
+    /// Returns the tasks to check all open files in the workspace.
+    fn check_open_files(&mut self) -> Vec<CheckOpenFileTask> {
+        self.scheduled_files
+            .extend(self.program.workspace().open_files());
+
+        self.program
+            .workspace()
+            .open_files()
+            .map(|file_id| CheckOpenFileTask { file_id })
+            .collect()
+    }
+
+    /// Returns the task to check a dependency.
+    fn check_dependency(&mut self, file_id: FileId) -> Option<CheckDependencyTask> {
+        if self.scheduled_files.insert(file_id) {
+            Some(CheckDependencyTask { file_id })
+        } else {
+            None
+        }
+    }
+
+    /// Pushes the result for a single file check operation
+    fn push_diagnostics(&mut self, diagnostics: &Diagnostics) {
+        self.diagnostics.extend_from_slice(diagnostics);
+    }
+
+    /// Returns a reference to the program that is being checked.
+    fn program(&self) -> &'a Program {
+        self.program
+    }
+
+    /// Creates a task context that is used to check a single file.
+    fn task_context<'b, S>(&self, dependency_scheduler: &'b S) -> CheckTaskContext<'a, 'b, S>
+    where
+        S: ScheduleDependency,
+    {
+        CheckTaskContext {
+            program: self.program,
+            dependency_scheduler,
+        }
+    }
+
+    fn finish(self) -> Vec<String> {
+        self.diagnostics
+    }
+}
+
+/// Trait that abstracts away how a dependency of a file gets scheduled for checking.
+trait ScheduleDependency {
+    /// Schedules the file with the given ID for checking.
+    fn schedule(&self, file_id: FileId);
+}
+
+impl<T> ScheduleDependency for T
+where
+    T: Fn(FileId),
+{
+    fn schedule(&self, file_id: FileId) {
+        let f = self;
+        f(file_id);
+    }
+}
+
+/// Context that is used to run a single file check task.
+///
+/// The task is generic over `S` because it is passed across thread boundaries and
+/// we don't want to add the requirement that [`ScheduleDependency`] must be [`Send`].
+struct CheckTaskContext<'a, 'scheduler, S>
+where
+    S: ScheduleDependency,
+{
+    dependency_scheduler: &'scheduler S,
+    program: &'a Program,
+}
+
+impl<'a, 'scheduler, S> CheckTaskContext<'a, 'scheduler, S>
+where
+    S: ScheduleDependency,
+{
+    fn as_file_context(&self) -> CheckFileContext<'scheduler> {
+        CheckFileContext {
+            dependency_scheduler: self.dependency_scheduler,
+        }
+    }
+}
+
+/// Context passed when checking a single file.
+///
+/// This is a trimmed down version of [`CheckTaskContext`] with the type parameter `S` erased
+/// to avoid monomorphization of [`Program:check_file`].
+struct CheckFileContext<'a> {
+    dependency_scheduler: &'a dyn ScheduleDependency,
+}
+
+impl<'a> CheckFileContext<'a> {
+    fn schedule_dependency(&self, file_id: FileId) {
+        self.dependency_scheduler.schedule(file_id);
+    }
+}
+
+#[derive(Debug)]
+enum CheckFileTask {
+    OpenFile(CheckOpenFileTask),
+    Dependency(CheckDependencyTask),
+}
+
+impl CheckFileTask {
+    /// Runs the task and returns the results for checking this file.
+    fn run<S>(&self, context: &CheckTaskContext<S>) -> QueryResult<Diagnostics>
+    where
+        S: ScheduleDependency,
+    {
+        match self {
+            Self::OpenFile(task) => task.run(context),
+            Self::Dependency(task) => task.run(context),
+        }
+    }
+
+    fn file_id(&self) -> FileId {
+        match self {
+            CheckFileTask::OpenFile(task) => task.file_id,
+            CheckFileTask::Dependency(task) => task.file_id,
+        }
+    }
+}
+
+/// Task to check an open file.
+
+#[derive(Debug)]
+struct CheckOpenFileTask {
+    file_id: FileId,
+}
+
+impl CheckOpenFileTask {
+    fn run<S>(&self, context: &CheckTaskContext<S>) -> QueryResult<Diagnostics>
+    where
+        S: ScheduleDependency,
+    {
+        context
+            .program
+            .check_file(self.file_id, &context.as_file_context())
+    }
+}
+
+/// Task to check a dependency file.
+#[derive(Debug)]
+struct CheckDependencyTask {
+    file_id: FileId,
+}
+
+impl CheckDependencyTask {
+    fn run<S>(&self, context: &CheckTaskContext<S>) -> QueryResult<Diagnostics>
+    where
+        S: ScheduleDependency,
+    {
+        context
+            .program
+            .check_file(self.file_id, &context.as_file_context())
+    }
+}
+
+/// Executor that schedules the checking of individual program files.
+trait CheckExecutor {
+    fn run(self, context: &mut CheckContext) -> QueryResult<()>;
+}
+
+/// Executor that runs all check operations on the current thread.
+///
+/// The executor does not schedule dependencies for checking.
+/// The main motivation for scheduling dependencies
+/// in a multithreaded environment is to parse and index the dependencies concurrently.
+/// However, that doesn't make sense in a single threaded environment, because the dependencies then compute
+/// with checking the open files. Checking dependencies in a single threaded environment is more likely
+/// to hurt performance because we end up analyzing files in their entirety, even if we only need to type check parts of them.
+#[derive(Debug, Default)]
+struct SingleThreadedExecutor;
+
+impl CheckExecutor for SingleThreadedExecutor {
+    fn run(self, context: &mut CheckContext) -> QueryResult<()> {
+        let mut queue = context.check_open_files();
+
+        let noop_schedule_dependency = |_| {};
+
+        while let Some(file) = queue.pop() {
+            context.program().cancelled()?;
+
+            let task_context = context.task_context(&noop_schedule_dependency);
+            context.push_diagnostics(&file.run(&task_context)?);
+        }
+
+        Ok(())
+    }
+}
+
+/// Executor that runs the check operations on a thread pool.
+///
+/// The executor runs each check operation as its own task using a thread pool.
+///
+/// Other than [`SingleThreadedExecutor`], this executor schedules dependencies for checking. It
+/// even schedules dependencies for checking when the thread pool size is 1 for a better debugging experience.
+#[derive(Debug, Default)]
+struct ThreadPoolExecutor;
+
+impl CheckExecutor for ThreadPoolExecutor {
+    fn run(self, context: &mut CheckContext) -> QueryResult<()> {
+        let num_threads = current_num_threads();
+        let single_threaded = num_threads == 1;
+        let span = tracing::trace_span!("ThreadPoolExecutor::run", num_threads);
+        let _ = span.enter();
+
+        let mut queue: Vec<_> = context
+            .check_open_files()
+            .into_iter()
+            .map(CheckFileTask::OpenFile)
+            .collect();
+
+        let (sender, receiver) = if single_threaded {
+            // Use an unbounded queue for single threaded execution to prevent deadlocks
+            // when a single file schedules multiple dependencies.
+            crossbeam::channel::unbounded()
+        } else {
+            // Use a bounded queue to apply backpressure when the orchestration thread isn't able to keep
+            // up processing messages from the worker threads.
+            crossbeam::channel::bounded(num_threads)
+        };
+
+        let schedule_sender = sender.clone();
+        let schedule_dependency = move |file_id| {
+            schedule_sender
+                .send(ThreadPoolMessage::ScheduleDependency(file_id))
+                .unwrap();
+        };
+
+        let result = rayon::in_place_scope(|scope| {
+            let mut pending = 0usize;
+
+            loop {
+                context.program().cancelled()?;
+
+                // 1. Try to get a queued message to ensure that we have always remaining space in the channel to prevent blocking the worker threads.
+                // 2. Try to process a queued file
+                // 3. If there's no queued file wait for the next incoming message.
+                // 4. Exit if there are no more messages and no senders.
+                let message = if let Ok(message) = receiver.try_recv() {
+                    message
+                } else if let Some(task) = queue.pop() {
+                    pending += 1;
+
+                    let task_context = context.task_context(&schedule_dependency);
+                    let sender = sender.clone();
+                    let task_span = tracing::trace_span!(
+                        parent: &span,
+                        "CheckFileTask::run",
+                        file_id = task.file_id().as_u32(),
+                    );
+
+                    scope.spawn(move |_| {
+                        task_span.in_scope(|| match task.run(&task_context) {
+                            Ok(result) => {
+                                sender.send(ThreadPoolMessage::Completed(result)).unwrap();
+                            }
+                            Err(err) => sender.send(ThreadPoolMessage::Errored(err)).unwrap(),
+                        });
+                    });
+
+                    // If this is a single threaded rayon thread pool, yield the current thread
+                    // or we never start processing the work items.
+                    if single_threaded {
+                        yield_local();
+                    }
+
+                    continue;
+                } else if let Ok(message) = receiver.recv() {
+                    message
+                } else {
+                    break;
+                };
+
+                match message {
+                    ThreadPoolMessage::ScheduleDependency(dependency) => {
+                        if let Some(task) = context.check_dependency(dependency) {
+                            queue.push(CheckFileTask::Dependency(task));
+                        }
+                    }
+                    ThreadPoolMessage::Completed(diagnostics) => {
+                        context.push_diagnostics(&diagnostics);
+                        pending -= 1;
+
+                        if pending == 0 && queue.is_empty() {
+                            break;
+                        }
+                    }
+                    ThreadPoolMessage::Errored(err) => {
+                        return Err(err);
+                    }
+                }
+            }
+
+            Ok(())
+        });
+
+        result
+    }
+}
+
+#[derive(Debug)]
+enum ThreadPoolMessage {
+    ScheduleDependency(FileId),
+    Completed(Diagnostics),
+    Errored(QueryError),
+}

crates/red_knot/src/program/mod.rs

@@ -0,0 +1,275 @@
+use std::collections::hash_map::Entry;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use rustc_hash::FxHashMap;
+
+use crate::db::{
+    Database, Db, DbRuntime, DbWithJar, HasJar, HasJars, JarsStorage, LintDb, LintJar,
+    ParallelDatabase, QueryResult, SemanticDb, SemanticJar, Snapshot, SourceDb, SourceJar, Upcast,
+};
+use crate::files::{FileId, Files};
+use crate::Workspace;
+
+pub mod check;
+
+#[derive(Debug)]
+pub struct Program {
+    jars: JarsStorage<Program>,
+    files: Files,
+    workspace: Workspace,
+}
+
+impl Program {
+    pub fn new(workspace: Workspace) -> Self {
+        Self {
+            jars: JarsStorage::default(),
+            files: Files::default(),
+            workspace,
+        }
+    }
+
+    pub fn apply_changes<I>(&mut self, changes: I)
+    where
+        I: IntoIterator<Item = FileWatcherChange>,
+    {
+        let mut aggregated_changes = AggregatedChanges::default();
+
+        aggregated_changes.extend(changes.into_iter().map(|change| FileChange {
+            id: self.files.intern(&change.path),
+            kind: change.kind,
+        }));
+
+        let (source, semantic, lint) = self.jars_mut();
+        for change in aggregated_changes.iter() {
+            semantic.module_resolver.remove_module_by_file(change.id);
+            semantic.semantic_indices.remove(&change.id);
+            source.sources.remove(&change.id);
+            source.parsed.remove(&change.id);
+            // TODO: remove all dependent modules as well
+            semantic.type_store.remove_module(change.id);
+            lint.lint_syntax.remove(&change.id);
+            lint.lint_semantic.remove(&change.id);
+        }
+    }
+
+    pub fn files(&self) -> &Files {
+        &self.files
+    }
+
+    pub fn workspace(&self) -> &Workspace {
+        &self.workspace
+    }
+
+    pub fn workspace_mut(&mut self) -> &mut Workspace {
+        &mut self.workspace
+    }
+}
+
+impl SourceDb for Program {
+    fn file_id(&self, path: &Path) -> FileId {
+        self.files.intern(path)
+    }
+
+    fn file_path(&self, file_id: FileId) -> Arc<Path> {
+        self.files.path(file_id)
+    }
+}
+
+impl DbWithJar<SourceJar> for Program {}
+
+impl SemanticDb for Program {}
+
+impl DbWithJar<SemanticJar> for Program {}
+
+impl LintDb for Program {}
+
+impl DbWithJar<LintJar> for Program {}
+
+impl Upcast<dyn SemanticDb> for Program {
+    fn upcast(&self) -> &(dyn SemanticDb + 'static) {
+        self
+    }
+}
+
+impl Upcast<dyn SourceDb> for Program {
+    fn upcast(&self) -> &(dyn SourceDb + 'static) {
+        self
+    }
+}
+
+impl Upcast<dyn LintDb> for Program {
+    fn upcast(&self) -> &(dyn LintDb + 'static) {
+        self
+    }
+}
+
+impl Db for Program {}
+
+impl Database for Program {
+    fn runtime(&self) -> &DbRuntime {
+        self.jars.runtime()
+    }
+
+    fn runtime_mut(&mut self) -> &mut DbRuntime {
+        self.jars.runtime_mut()
+    }
+}
+
+impl ParallelDatabase for Program {
+    fn snapshot(&self) -> Snapshot<Self> {
+        Snapshot::new(Self {
+            jars: self.jars.snapshot(),
+            files: self.files.snapshot(),
+            workspace: self.workspace.clone(),
+        })
+    }
+}
+
+impl HasJars for Program {
+    type Jars = (SourceJar, SemanticJar, LintJar);
+
+    fn jars(&self) -> QueryResult<&Self::Jars> {
+        self.jars.jars()
+    }
+
+    fn jars_mut(&mut self) -> &mut Self::Jars {
+        self.jars.jars_mut()
+    }
+}
+
+impl HasJar<SourceJar> for Program {
+    fn jar(&self) -> QueryResult<&SourceJar> {
+        Ok(&self.jars()?.0)
+    }
+
+    fn jar_mut(&mut self) -> &mut SourceJar {
+        &mut self.jars_mut().0
+    }
+}
+
+impl HasJar<SemanticJar> for Program {
+    fn jar(&self) -> QueryResult<&SemanticJar> {
+        Ok(&self.jars()?.1)
+    }
+
+    fn jar_mut(&mut self) -> &mut SemanticJar {
+        &mut self.jars_mut().1
+    }
+}
+
+impl HasJar<LintJar> for Program {
+    fn jar(&self) -> QueryResult<&LintJar> {
+        Ok(&self.jars()?.2)
+    }
+
+    fn jar_mut(&mut self) -> &mut LintJar {
+        &mut self.jars_mut().2
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct FileWatcherChange {
+    path: PathBuf,
+    kind: FileChangeKind,
+}
+
+impl FileWatcherChange {
+    pub fn new(path: PathBuf, kind: FileChangeKind) -> Self {
+        Self { path, kind }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+struct FileChange {
+    id: FileId,
+    kind: FileChangeKind,
+}
+
+impl FileChange {
+    fn file_id(self) -> FileId {
+        self.id
+    }
+
+    fn kind(self) -> FileChangeKind {
+        self.kind
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum FileChangeKind {
+    Created,
+    Modified,
+    Deleted,
+}
+
+#[derive(Default, Debug)]
+struct AggregatedChanges {
+    changes: FxHashMap<FileId, FileChangeKind>,
+}
+
+impl AggregatedChanges {
+    fn add(&mut self, change: FileChange) {
+        match self.changes.entry(change.file_id()) {
+            Entry::Occupied(mut entry) => {
+                let merged = entry.get_mut();
+
+                match (merged, change.kind()) {
+                    (FileChangeKind::Created, FileChangeKind::Deleted) => {
+                        // Deletion after creations means that ruff never saw the file.
+                        entry.remove();
+                    }
+                    (FileChangeKind::Created, FileChangeKind::Modified) => {
+                        // No-op, for ruff, modifying a file that it doesn't yet know that it exists is still considered a creation.
+                    }
+
+                    (FileChangeKind::Modified, FileChangeKind::Created) => {
+                        // Uhh, that should probably not happen. Continue considering it a modification.
+                    }
+
+                    (FileChangeKind::Modified, FileChangeKind::Deleted) => {
+                        *entry.get_mut() = FileChangeKind::Deleted;
+                    }
+
+                    (FileChangeKind::Deleted, FileChangeKind::Created) => {
+                        *entry.get_mut() = FileChangeKind::Modified;
+                    }
+
+                    (FileChangeKind::Deleted, FileChangeKind::Modified) => {
+                        // That's weird, but let's consider it a modification.
+                        *entry.get_mut() = FileChangeKind::Modified;
+                    }
+
+                    (FileChangeKind::Created, FileChangeKind::Created)
+                    | (FileChangeKind::Modified, FileChangeKind::Modified)
+                    | (FileChangeKind::Deleted, FileChangeKind::Deleted) => {
+                        // No-op transitions. Some of them should be impossible but we handle them anyway.
+                    }
+                }
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(change.kind());
+            }
+        }
+    }
+
+    fn extend<I>(&mut self, changes: I)
+    where
+        I: IntoIterator<Item = FileChange>,
+    {
+        let iter = changes.into_iter();
+        let (lower, _) = iter.size_hint();
+        self.changes.reserve(lower);
+
+        for change in iter {
+            self.add(change);
+        }
+    }
+
+    fn iter(&self) -> impl Iterator<Item = FileChange> + '_ {
+        self.changes.iter().map(|(id, kind)| FileChange {
+            id: *id,
+            kind: *kind,
+        })
+    }
+}

crates/red_knot/src/semantic.rs

@@ -0,0 +1,882 @@
+use std::num::NonZeroU32;
+
+use ruff_python_ast as ast;
+use ruff_python_ast::visitor::source_order::SourceOrderVisitor;
+use ruff_python_ast::AstNode;
+
+use crate::ast_ids::{NodeKey, TypedNodeKey};
+use crate::cache::KeyValueCache;
+use crate::db::{QueryResult, SemanticDb, SemanticJar};
+use crate::files::FileId;
+use crate::module::Module;
+use crate::module::ModuleName;
+use crate::parse::parse;
+use crate::Name;
+pub(crate) use definitions::Definition;
+use definitions::{ImportDefinition, ImportFromDefinition};
+pub(crate) use flow_graph::ConstrainedDefinition;
+use flow_graph::{FlowGraph, FlowGraphBuilder, FlowNodeId, ReachableDefinitionsIterator};
+use ruff_index::{newtype_index, IndexVec};
+use rustc_hash::FxHashMap;
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+pub(crate) use symbol_table::{Dependency, SymbolId};
+use symbol_table::{ScopeId, ScopeKind, SymbolFlags, SymbolTable, SymbolTableBuilder};
+pub(crate) use types::{infer_definition_type, infer_symbol_public_type, Type, TypeStore};
+
+mod definitions;
+mod flow_graph;
+mod symbol_table;
+mod types;
+
+#[tracing::instrument(level = "debug", skip(db))]
+pub fn semantic_index(db: &dyn SemanticDb, file_id: FileId) -> QueryResult<Arc<SemanticIndex>> {
+    let jar: &SemanticJar = db.jar()?;
+
+    jar.semantic_indices.get(&file_id, |_| {
+        let parsed = parse(db.upcast(), file_id)?;
+        Ok(Arc::from(SemanticIndex::from_ast(parsed.syntax())))
+    })
+}
+
+#[tracing::instrument(level = "debug", skip(db))]
+pub fn resolve_global_symbol(
+    db: &dyn SemanticDb,
+    module: Module,
+    name: &str,
+) -> QueryResult<Option<GlobalSymbolId>> {
+    let file_id = module.path(db)?.file();
+    let symbol_table = &semantic_index(db, file_id)?.symbol_table;
+    let Some(symbol_id) = symbol_table.root_symbol_id_by_name(name) else {
+        return Ok(None);
+    };
+    Ok(Some(GlobalSymbolId { file_id, symbol_id }))
+}
+
+#[newtype_index]
+pub struct ExpressionId;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct GlobalSymbolId {
+    pub(crate) file_id: FileId,
+    pub(crate) symbol_id: SymbolId,
+}
+
+#[derive(Debug)]
+pub struct SemanticIndex {
+    symbol_table: SymbolTable,
+    flow_graph: FlowGraph,
+    expressions: FxHashMap<NodeKey, ExpressionId>,
+    expressions_by_id: IndexVec<ExpressionId, NodeKey>,
+}
+
+impl SemanticIndex {
+    pub fn from_ast(module: &ast::ModModule) -> Self {
+        let root_scope_id = SymbolTable::root_scope_id();
+        let mut indexer = SemanticIndexer {
+            symbol_table_builder: SymbolTableBuilder::new(),
+            flow_graph_builder: FlowGraphBuilder::new(),
+            scopes: vec![ScopeState {
+                scope_id: root_scope_id,
+                current_flow_node_id: FlowGraph::start(),
+            }],
+            expressions: FxHashMap::default(),
+            expressions_by_id: IndexVec::default(),
+            current_definition: None,
+        };
+        indexer.visit_body(&module.body);
+        indexer.finish()
+    }
+
+    fn resolve_expression_id<'a>(
+        &self,
+        ast: &'a ast::ModModule,
+        expression_id: ExpressionId,
+    ) -> ast::AnyNodeRef<'a> {
+        let node_key = self.expressions_by_id[expression_id];
+        node_key
+            .resolve(ast.as_any_node_ref())
+            .expect("node to resolve")
+    }
+
+    /// Return an iterator over all definitions of `symbol_id` reachable from `use_expr`. The value
+    /// of `symbol_id` in `use_expr` must originate from one of the iterated definitions (or from
+    /// an external reassignment of the name outside of this scope).
+    pub fn reachable_definitions(
+        &self,
+        symbol_id: SymbolId,
+        use_expr: &ast::Expr,
+    ) -> ReachableDefinitionsIterator {
+        let expression_id = self.expression_id(use_expr);
+        ReachableDefinitionsIterator::new(
+            &self.flow_graph,
+            symbol_id,
+            self.flow_graph.for_expr(expression_id),
+        )
+    }
+
+    pub fn expression_id(&self, expression: &ast::Expr) -> ExpressionId {
+        self.expressions[&NodeKey::from_node(expression.into())]
+    }
+
+    pub fn symbol_table(&self) -> &SymbolTable {
+        &self.symbol_table
+    }
+}
+
+#[derive(Debug)]
+struct ScopeState {
+    scope_id: ScopeId,
+    current_flow_node_id: FlowNodeId,
+}
+
+#[derive(Debug)]
+struct SemanticIndexer {
+    symbol_table_builder: SymbolTableBuilder,
+    flow_graph_builder: FlowGraphBuilder,
+    scopes: Vec<ScopeState>,
+    /// the definition whose target(s) we are currently walking
+    current_definition: Option<Definition>,
+    expressions: FxHashMap<NodeKey, ExpressionId>,
+    expressions_by_id: IndexVec<ExpressionId, NodeKey>,
+}
+
+impl SemanticIndexer {
+    pub(crate) fn finish(mut self) -> SemanticIndex {
+        let SemanticIndexer {
+            flow_graph_builder,
+            symbol_table_builder,
+            ..
+        } = self;
+        self.expressions.shrink_to_fit();
+        self.expressions_by_id.shrink_to_fit();
+        SemanticIndex {
+            flow_graph: flow_graph_builder.finish(),
+            symbol_table: symbol_table_builder.finish(),
+            expressions: self.expressions,
+            expressions_by_id: self.expressions_by_id,
+        }
+    }
+
+    fn set_current_flow_node(&mut self, new_flow_node_id: FlowNodeId) {
+        let scope_state = self.scopes.last_mut().expect("scope stack is never empty");
+        scope_state.current_flow_node_id = new_flow_node_id;
+    }
+
+    fn current_flow_node(&self) -> FlowNodeId {
+        self.scopes
+            .last()
+            .expect("scope stack is never empty")
+            .current_flow_node_id
+    }
+
+    fn add_or_update_symbol(&mut self, identifier: &str, flags: SymbolFlags) -> SymbolId {
+        self.symbol_table_builder
+            .add_or_update_symbol(self.cur_scope(), identifier, flags)
+    }
+
+    fn add_or_update_symbol_with_def(
+        &mut self,
+        identifier: &str,
+        definition: Definition,
+    ) -> SymbolId {
+        let symbol_id = self.add_or_update_symbol(identifier, SymbolFlags::IS_DEFINED);
+        self.symbol_table_builder
+            .add_definition(symbol_id, definition.clone());
+        let new_flow_node_id =
+            self.flow_graph_builder
+                .add_definition(symbol_id, definition, self.current_flow_node());
+        self.set_current_flow_node(new_flow_node_id);
+        symbol_id
+    }
+
+    fn push_scope(
+        &mut self,
+        name: &str,
+        kind: ScopeKind,
+        definition: Option<Definition>,
+        defining_symbol: Option<SymbolId>,
+    ) -> ScopeId {
+        let scope_id = self.symbol_table_builder.add_child_scope(
+            self.cur_scope(),
+            name,
+            kind,
+            definition,
+            defining_symbol,
+        );
+        self.scopes.push(ScopeState {
+            scope_id,
+            current_flow_node_id: FlowGraph::start(),
+        });
+        scope_id
+    }
+
+    fn pop_scope(&mut self) -> ScopeId {
+        self.scopes
+            .pop()
+            .expect("Scope stack should never be empty")
+            .scope_id
+    }
+
+    fn cur_scope(&self) -> ScopeId {
+        self.scopes
+            .last()
+            .expect("Scope stack should never be empty")
+            .scope_id
+    }
+
+    fn record_scope_for_node(&mut self, node_key: NodeKey, scope_id: ScopeId) {
+        self.symbol_table_builder
+            .record_scope_for_node(node_key, scope_id);
+    }
+
+    fn insert_constraint(&mut self, expr: &ast::Expr) {
+        let node_key = NodeKey::from_node(expr.into());
+        let expression_id = self.expressions[&node_key];
+        let constraint = self
+            .flow_graph_builder
+            .add_constraint(self.current_flow_node(), expression_id);
+        self.set_current_flow_node(constraint);
+    }
+
+    fn with_type_params(
+        &mut self,
+        name: &str,
+        params: &Option<Box<ast::TypeParams>>,
+        definition: Option<Definition>,
+        defining_symbol: Option<SymbolId>,
+        nested: impl FnOnce(&mut Self) -> ScopeId,
+    ) -> ScopeId {
+        if let Some(type_params) = params {
+            self.push_scope(name, ScopeKind::Annotation, definition, defining_symbol);
+            for type_param in &type_params.type_params {
+                let name = match type_param {
+                    ast::TypeParam::TypeVar(ast::TypeParamTypeVar { name, .. }) => name,
+                    ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, .. }) => name,
+                    ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple { name, .. }) => name,
+                };
+                self.add_or_update_symbol(name, SymbolFlags::IS_DEFINED);
+            }
+        }
+        let scope_id = nested(self);
+        if params.is_some() {
+            self.pop_scope();
+        }
+        scope_id
+    }
+}
+
+impl SourceOrderVisitor<'_> for SemanticIndexer {
+    fn visit_expr(&mut self, expr: &ast::Expr) {
+        let node_key = NodeKey::from_node(expr.into());
+        let expression_id = self.expressions_by_id.push(node_key);
+
+        let flow_expression_id = self
+            .flow_graph_builder
+            .record_expr(self.current_flow_node());
+        debug_assert_eq!(expression_id, flow_expression_id);
+
+        let symbol_expression_id = self
+            .symbol_table_builder
+            .record_expression(self.cur_scope());
+
+        debug_assert_eq!(expression_id, symbol_expression_id);
+
+        self.expressions.insert(node_key, expression_id);
+
+        match expr {
+            ast::Expr::Name(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(),
+                };
+                self.add_or_update_symbol(id, flags);
+                if flags.contains(SymbolFlags::IS_DEFINED) {
+                    if let Some(curdef) = self.current_definition.clone() {
+                        self.add_or_update_symbol_with_def(id, curdef);
+                    }
+                }
+                ast::visitor::source_order::walk_expr(self, expr);
+            }
+            ast::Expr::Named(node) => {
+                debug_assert!(self.current_definition.is_none());
+                self.current_definition =
+                    Some(Definition::NamedExpr(TypedNodeKey::from_node(node)));
+                // TODO walrus in comprehensions is implicitly nonlocal
+                self.visit_expr(&node.target);
+                self.current_definition = None;
+                self.visit_expr(&node.value);
+            }
+            ast::Expr::If(ast::ExprIf {
+                body, test, orelse, ..
+            }) => {
+                // TODO detect statically known truthy or falsy test (via type inference, not naive
+                // AST inspection, so we can't simplify here, need to record test expression in CFG
+                // for later checking)
+
+                self.visit_expr(test);
+
+                let if_branch = self.flow_graph_builder.add_branch(self.current_flow_node());
+
+                self.set_current_flow_node(if_branch);
+                self.insert_constraint(test);
+                self.visit_expr(body);
+
+                let post_body = self.current_flow_node();
+
+                self.set_current_flow_node(if_branch);
+                self.visit_expr(orelse);
+
+                let post_else = self
+                    .flow_graph_builder
+                    .add_phi(self.current_flow_node(), post_body);
+
+                self.set_current_flow_node(post_else);
+            }
+            _ => {
+                ast::visitor::source_order::walk_expr(self, expr);
+            }
+        }
+    }
+
+    fn visit_stmt(&mut self, stmt: &ast::Stmt) {
+        // TODO need to capture more definition statements here
+        match stmt {
+            ast::Stmt::ClassDef(node) => {
+                let node_key = TypedNodeKey::from_node(node);
+                let def = Definition::ClassDef(node_key.clone());
+                let symbol_id = self.add_or_update_symbol_with_def(&node.name, def.clone());
+                for decorator in &node.decorator_list {
+                    self.visit_decorator(decorator);
+                }
+                let scope_id = self.with_type_params(
+                    &node.name,
+                    &node.type_params,
+                    Some(def.clone()),
+                    Some(symbol_id),
+                    |indexer| {
+                        if let Some(arguments) = &node.arguments {
+                            indexer.visit_arguments(arguments);
+                        }
+                        let scope_id = indexer.push_scope(
+                            &node.name,
+                            ScopeKind::Class,
+                            Some(def.clone()),
+                            Some(symbol_id),
+                        );
+                        indexer.visit_body(&node.body);
+                        indexer.pop_scope();
+                        scope_id
+                    },
+                );
+                self.record_scope_for_node(*node_key.erased(), scope_id);
+            }
+            ast::Stmt::FunctionDef(node) => {
+                let node_key = TypedNodeKey::from_node(node);
+                let def = Definition::FunctionDef(node_key.clone());
+                let symbol_id = self.add_or_update_symbol_with_def(&node.name, def.clone());
+                for decorator in &node.decorator_list {
+                    self.visit_decorator(decorator);
+                }
+                let scope_id = self.with_type_params(
+                    &node.name,
+                    &node.type_params,
+                    Some(def.clone()),
+                    Some(symbol_id),
+                    |indexer| {
+                        indexer.visit_parameters(&node.parameters);
+                        for expr in &node.returns {
+                            indexer.visit_annotation(expr);
+                        }
+                        let scope_id = indexer.push_scope(
+                            &node.name,
+                            ScopeKind::Function,
+                            Some(def.clone()),
+                            Some(symbol_id),
+                        );
+                        indexer.visit_body(&node.body);
+                        indexer.pop_scope();
+                        scope_id
+                    },
+                );
+                self.record_scope_for_node(*node_key.erased(), scope_id);
+            }
+            ast::Stmt::Import(ast::StmtImport { names, .. }) => {
+                for alias in names {
+                    let symbol_name = if let Some(asname) = &alias.asname {
+                        asname.id.as_str()
+                    } else {
+                        alias.name.id.split('.').next().unwrap()
+                    };
+
+                    let module = ModuleName::new(&alias.name.id);
+
+                    let def = Definition::Import(ImportDefinition {
+                        module: module.clone(),
+                    });
+                    self.add_or_update_symbol_with_def(symbol_name, def);
+                    self.symbol_table_builder
+                        .add_dependency(Dependency::Module(module));
+                }
+            }
+            ast::Stmt::ImportFrom(ast::StmtImportFrom {
+                module,
+                names,
+                level,
+                ..
+            }) => {
+                let module = module.as_ref().map(|m| ModuleName::new(&m.id));
+
+                for alias in names {
+                    let symbol_name = if let Some(asname) = &alias.asname {
+                        asname.id.as_str()
+                    } else {
+                        alias.name.id.as_str()
+                    };
+                    let def = Definition::ImportFrom(ImportFromDefinition {
+                        module: module.clone(),
+                        name: Name::new(&alias.name.id),
+                        level: *level,
+                    });
+                    self.add_or_update_symbol_with_def(symbol_name, def);
+                }
+
+                let dependency = if let Some(module) = module {
+                    match NonZeroU32::new(*level) {
+                        Some(level) => Dependency::Relative {
+                            level,
+                            module: Some(module),
+                        },
+                        None => Dependency::Module(module),
+                    }
+                } else {
+                    Dependency::Relative {
+                        level: NonZeroU32::new(*level)
+                            .expect("Import without a module to have a level > 0"),
+                        module,
+                    }
+                };
+
+                self.symbol_table_builder.add_dependency(dependency);
+            }
+            ast::Stmt::Assign(node) => {
+                debug_assert!(self.current_definition.is_none());
+                self.visit_expr(&node.value);
+                self.current_definition =
+                    Some(Definition::Assignment(TypedNodeKey::from_node(node)));
+                for expr in &node.targets {
+                    self.visit_expr(expr);
+                }
+
+                self.current_definition = None;
+            }
+            ast::Stmt::If(node) => {
+                // TODO detect statically known truthy or falsy test (via type inference, not naive
+                // AST inspection, so we can't simplify here, need to record test expression in CFG
+                // for later checking)
+
+                // we visit the if "test" condition first regardless
+                self.visit_expr(&node.test);
+
+                // create branch node: does the if test pass or not?
+                let if_branch = self.flow_graph_builder.add_branch(self.current_flow_node());
+
+                // visit the body of the `if` clause
+                self.set_current_flow_node(if_branch);
+                self.insert_constraint(&node.test);
+                self.visit_body(&node.body);
+
+                // Flow node for the last if/elif condition branch; represents the "no branch
+                // taken yet" possibility (where "taking a branch" means that the condition in an
+                // if or elif evaluated to true and control flow went into that clause).
+                let mut prior_branch = if_branch;
+
+                // Flow node for the state after the prior if/elif/else clause; represents "we have
+                // taken one of the branches up to this point." Initially set to the post-if-clause
+                // state, later will be set to the phi node joining that possible path with the
+                // possibility that we took a later if/elif/else clause instead.
+                let mut post_prior_clause = self.current_flow_node();
+
+                // Flag to mark if the final clause is an "else" -- if so, that means the "match no
+                // clauses" path is not possible, we have to go through one of the clauses.
+                let mut last_branch_is_else = false;
+
+                for clause in &node.elif_else_clauses {
+                    if let Some(test) = &clause.test {
+                        self.visit_expr(test);
+                        // This is an elif clause. Create a new branch node. Its predecessor is the
+                        // previous branch node, because we can only take one branch in an entire
+                        // if/elif/else chain, so if we take this branch, it can only be because we
+                        // didn't take the previous one.
+                        prior_branch = self.flow_graph_builder.add_branch(prior_branch);
+                        self.set_current_flow_node(prior_branch);
+                        self.insert_constraint(test);
+                    } else {
+                        // This is an else clause. No need to create a branch node; there's no
+                        // branch here, if we haven't taken any previous branch, we definitely go
+                        // into the "else" clause.
+                        self.set_current_flow_node(prior_branch);
+                        last_branch_is_else = true;
+                    }
+                    self.visit_elif_else_clause(clause);
+                    // Update `post_prior_clause` to a new phi node joining the possibility that we
+                    // took any of the previous branches with the possibility that we took the one
+                    // just visited.
+                    post_prior_clause = self
+                        .flow_graph_builder
+                        .add_phi(self.current_flow_node(), post_prior_clause);
+                }
+
+                if !last_branch_is_else {
+                    // Final branch was not an "else", which means it's possible we took zero
+                    // branches in the entire if/elif chain, so we need one more phi node to join
+                    // the "no branches taken" possibility.
+                    post_prior_clause = self
+                        .flow_graph_builder
+                        .add_phi(post_prior_clause, prior_branch);
+                }
+
+                // Onward, with current flow node set to our final Phi node.
+                self.set_current_flow_node(post_prior_clause);
+            }
+            _ => {
+                ast::visitor::source_order::walk_stmt(self, stmt);
+            }
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct SemanticIndexStorage(KeyValueCache<FileId, Arc<SemanticIndex>>);
+
+impl Deref for SemanticIndexStorage {
+    type Target = KeyValueCache<FileId, Arc<SemanticIndex>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for SemanticIndexStorage {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::semantic::symbol_table::{Symbol, SymbolIterator};
+    use ruff_python_ast as ast;
+    use ruff_python_ast::ModModule;
+    use ruff_python_parser::{Mode, Parsed};
+
+    use super::{Definition, ScopeKind, SemanticIndex, SymbolId};
+
+    fn parse(code: &str) -> Parsed<ModModule> {
+        ruff_python_parser::parse_unchecked(code, Mode::Module)
+            .try_into_module()
+            .unwrap()
+    }
+
+    fn names<I>(it: SymbolIterator<I>) -> Vec<&str>
+    where
+        I: Iterator<Item = SymbolId>,
+    {
+        let mut symbols: Vec<_> = it.map(Symbol::name).collect();
+        symbols.sort_unstable();
+        symbols
+    }
+
+    #[test]
+    fn empty() {
+        let parsed = parse("");
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()).len(), 0);
+    }
+
+    #[test]
+    fn simple() {
+        let parsed = parse("x");
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["x"]);
+        assert_eq!(
+            table
+                .definitions(table.root_symbol_id_by_name("x").unwrap())
+                .len(),
+            0
+        );
+    }
+
+    #[test]
+    fn annotation_only() {
+        let parsed = parse("x: int");
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["int", "x"]);
+        // TODO record definition
+    }
+
+    #[test]
+    fn import() {
+        let parsed = parse("import foo");
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["foo"]);
+        assert_eq!(
+            table
+                .definitions(table.root_symbol_id_by_name("foo").unwrap())
+                .len(),
+            1
+        );
+    }
+
+    #[test]
+    fn import_sub() {
+        let parsed = parse("import foo.bar");
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["foo"]);
+    }
+
+    #[test]
+    fn import_as() {
+        let parsed = parse("import foo.bar as baz");
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["baz"]);
+    }
+
+    #[test]
+    fn import_from() {
+        let parsed = parse("from bar import foo");
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["foo"]);
+        assert_eq!(
+            table
+                .definitions(table.root_symbol_id_by_name("foo").unwrap())
+                .len(),
+            1
+        );
+        assert!(
+            table.root_symbol_id_by_name("foo").is_some_and(|sid| {
+                let s = sid.symbol(&table);
+                s.is_defined() || !s.is_used()
+            }),
+            "symbols that are defined get the defined flag"
+        );
+    }
+
+    #[test]
+    fn assign() {
+        let parsed = parse("x = foo");
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["foo", "x"]);
+        assert_eq!(
+            table
+                .definitions(table.root_symbol_id_by_name("x").unwrap())
+                .len(),
+            1
+        );
+        assert!(
+            table.root_symbol_id_by_name("foo").is_some_and(|sid| {
+                let s = sid.symbol(&table);
+                !s.is_defined() && s.is_used()
+            }),
+            "a symbol used but not defined in a scope should have only the used flag"
+        );
+    }
+
+    #[test]
+    fn class_scope() {
+        let parsed = parse(
+            "
+                class C:
+                    x = 1
+                y = 2
+                ",
+        );
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["C", "y"]);
+        let scopes = table.root_child_scope_ids();
+        assert_eq!(scopes.len(), 1);
+        let c_scope = scopes[0].scope(&table);
+        assert_eq!(c_scope.kind(), ScopeKind::Class);
+        assert_eq!(c_scope.name(), "C");
+        assert_eq!(names(table.symbols_for_scope(scopes[0])), vec!["x"]);
+        assert_eq!(
+            table
+                .definitions(table.root_symbol_id_by_name("C").unwrap())
+                .len(),
+            1
+        );
+    }
+
+    #[test]
+    fn func_scope() {
+        let parsed = parse(
+            "
+                def func():
+                    x = 1
+                y = 2
+                ",
+        );
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["func", "y"]);
+        let scopes = table.root_child_scope_ids();
+        assert_eq!(scopes.len(), 1);
+        let func_scope = scopes[0].scope(&table);
+        assert_eq!(func_scope.kind(), ScopeKind::Function);
+        assert_eq!(func_scope.name(), "func");
+        assert_eq!(names(table.symbols_for_scope(scopes[0])), vec!["x"]);
+        assert_eq!(
+            table
+                .definitions(table.root_symbol_id_by_name("func").unwrap())
+                .len(),
+            1
+        );
+    }
+
+    #[test]
+    fn dupes() {
+        let parsed = parse(
+            "
+                def func():
+                    x = 1
+                def func():
+                    y = 2
+                ",
+        );
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["func"]);
+        let scopes = table.root_child_scope_ids();
+        assert_eq!(scopes.len(), 2);
+        let func_scope_1 = scopes[0].scope(&table);
+        let func_scope_2 = scopes[1].scope(&table);
+        assert_eq!(func_scope_1.kind(), ScopeKind::Function);
+        assert_eq!(func_scope_1.name(), "func");
+        assert_eq!(func_scope_2.kind(), ScopeKind::Function);
+        assert_eq!(func_scope_2.name(), "func");
+        assert_eq!(names(table.symbols_for_scope(scopes[0])), vec!["x"]);
+        assert_eq!(names(table.symbols_for_scope(scopes[1])), vec!["y"]);
+        assert_eq!(
+            table
+                .definitions(table.root_symbol_id_by_name("func").unwrap())
+                .len(),
+            2
+        );
+    }
+
+    #[test]
+    fn generic_func() {
+        let parsed = parse(
+            "
+                def func[T]():
+                    x = 1
+                ",
+        );
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["func"]);
+        let scopes = table.root_child_scope_ids();
+        assert_eq!(scopes.len(), 1);
+        let ann_scope_id = scopes[0];
+        let ann_scope = ann_scope_id.scope(&table);
+        assert_eq!(ann_scope.kind(), ScopeKind::Annotation);
+        assert_eq!(ann_scope.name(), "func");
+        assert_eq!(names(table.symbols_for_scope(ann_scope_id)), vec!["T"]);
+        let scopes = table.child_scope_ids_of(ann_scope_id);
+        assert_eq!(scopes.len(), 1);
+        let func_scope_id = scopes[0];
+        let func_scope = func_scope_id.scope(&table);
+        assert_eq!(func_scope.kind(), ScopeKind::Function);
+        assert_eq!(func_scope.name(), "func");
+        assert_eq!(names(table.symbols_for_scope(func_scope_id)), vec!["x"]);
+    }
+
+    #[test]
+    fn generic_class() {
+        let parsed = parse(
+            "
+                class C[T]:
+                    x = 1
+                ",
+        );
+        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
+        assert_eq!(names(table.root_symbols()), vec!["C"]);
+        let scopes = table.root_child_scope_ids();
+        assert_eq!(scopes.len(), 1);
+        let ann_scope_id = scopes[0];
+        let ann_scope = ann_scope_id.scope(&table);
+        assert_eq!(ann_scope.kind(), ScopeKind::Annotation);
+        assert_eq!(ann_scope.name(), "C");
+        assert_eq!(names(table.symbols_for_scope(ann_scope_id)), vec!["T"]);
+        assert!(
+            table
+                .symbol_by_name(ann_scope_id, "T")
+                .is_some_and(|s| s.is_defined() && !s.is_used()),
+            "type parameters are defined by the scope that introduces them"
+        );
+        let scopes = table.child_scope_ids_of(ann_scope_id);
+        assert_eq!(scopes.len(), 1);
+        let func_scope_id = scopes[0];
+        let func_scope = func_scope_id.scope(&table);
+        assert_eq!(func_scope.kind(), ScopeKind::Class);
+        assert_eq!(func_scope.name(), "C");
+        assert_eq!(names(table.symbols_for_scope(func_scope_id)), vec!["x"]);
+    }
+
+    #[test]
+    fn reachability_trivial() {
+        let parsed = parse("x = 1; x");
+        let ast = parsed.syntax();
+        let index = SemanticIndex::from_ast(ast);
+        let table = &index.symbol_table;
+        let x_sym = table
+            .root_symbol_id_by_name("x")
+            .expect("x symbol should exist");
+        let ast::Stmt::Expr(ast::StmtExpr { value: x_use, .. }) = &ast.body[1] else {
+            panic!("should be an expr")
+        };
+        let x_defs: Vec<_> = index
+            .reachable_definitions(x_sym, x_use)
+            .map(|constrained_definition| constrained_definition.definition)
+            .collect();
+        assert_eq!(x_defs.len(), 1);
+        let Definition::Assignment(node_key) = &x_defs[0] else {
+            panic!("def should be an assignment")
+        };
+        let Some(def_node) = node_key.resolve(ast.into()) else {
+            panic!("node key should resolve")
+        };
+        let ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
+            value: ast::Number::Int(num),
+            ..
+        }) = &*def_node.value
+        else {
+            panic!("should be a number literal")
+        };
+        assert_eq!(*num, 1);
+    }
+
+    #[test]
+    fn expression_scope() {
+        let parsed = parse("x = 1;\ndef test():\n  y = 4");
+        let ast = parsed.syntax();
+        let index = SemanticIndex::from_ast(ast);
+        let table = &index.symbol_table;
+
+        let x_sym = table
+            .root_symbol_by_name("x")
+            .expect("x symbol should exist");
+
+        let x_stmt = ast.body[0].as_assign_stmt().unwrap();
+
+        let x_id = index.expression_id(&x_stmt.targets[0]);
+
+        assert_eq!(table.scope_of_expression(x_id).kind(), ScopeKind::Module);
+        assert_eq!(table.scope_id_of_expression(x_id), x_sym.scope_id());
+
+        let def = ast.body[1].as_function_def_stmt().unwrap();
+        let y_stmt = def.body[0].as_assign_stmt().unwrap();
+        let y_id = index.expression_id(&y_stmt.targets[0]);
+
+        assert_eq!(table.scope_of_expression(y_id).kind(), ScopeKind::Function);
+    }
+}

crates/red_knot/src/semantic/definitions.rs

@@ -0,0 +1,52 @@
+use crate::ast_ids::TypedNodeKey;
+use crate::semantic::ModuleName;
+use crate::Name;
+use ruff_python_ast as ast;
+
+// TODO storing TypedNodeKey for definitions means we have to search to find them again in the AST;
+// this is at best O(log n). If looking up definitions is a bottleneck we should look for
+// alternatives here.
+// TODO intern Definitions in SymbolTable and reference using IDs?
+#[derive(Clone, Debug)]
+pub enum Definition {
+    // For the import cases, we don't need reference to any arbitrary AST subtrees (annotations,
+    // RHS), and referencing just the import statement node is imprecise (a single import statement
+    // can assign many symbols, we'd have to re-search for the one we care about), so we just copy
+    // the small amount of information we need from the AST.
+    Import(ImportDefinition),
+    ImportFrom(ImportFromDefinition),
+    ClassDef(TypedNodeKey<ast::StmtClassDef>),
+    FunctionDef(TypedNodeKey<ast::StmtFunctionDef>),
+    Assignment(TypedNodeKey<ast::StmtAssign>),
+    AnnotatedAssignment(TypedNodeKey<ast::StmtAnnAssign>),
+    NamedExpr(TypedNodeKey<ast::ExprNamed>),
+    /// represents the implicit initial definition of every name as "unbound"
+    Unbound,
+    // TODO with statements, except handlers, function args...
+}
+
+#[derive(Clone, Debug)]
+pub struct ImportDefinition {
+    pub module: ModuleName,
+}
+
+#[derive(Clone, Debug)]
+pub struct ImportFromDefinition {
+    pub module: Option<ModuleName>,
+    pub name: Name,
+    pub level: u32,
+}
+
+impl ImportFromDefinition {
+    pub fn module(&self) -> Option<&ModuleName> {
+        self.module.as_ref()
+    }
+
+    pub fn name(&self) -> &Name {
+        &self.name
+    }
+
+    pub fn level(&self) -> u32 {
+        self.level
+    }
+}

crates/red_knot/src/semantic/flow_graph.rs

@@ -0,0 +1,270 @@
+use super::symbol_table::SymbolId;
+use crate::semantic::{Definition, ExpressionId};
+use ruff_index::{newtype_index, IndexVec};
+use std::iter::FusedIterator;
+use std::ops::Range;
+
+#[newtype_index]
+pub struct FlowNodeId;
+
+#[derive(Debug)]
+pub(crate) enum FlowNode {
+    Start,
+    Definition(DefinitionFlowNode),
+    Branch(BranchFlowNode),
+    Phi(PhiFlowNode),
+    Constraint(ConstraintFlowNode),
+}
+
+/// A point in control flow where a symbol is defined
+#[derive(Debug)]
+pub(crate) struct DefinitionFlowNode {
+    symbol_id: SymbolId,
+    definition: Definition,
+    predecessor: FlowNodeId,
+}
+
+/// A branch in control flow
+#[derive(Debug)]
+pub(crate) struct BranchFlowNode {
+    predecessor: FlowNodeId,
+}
+
+/// A join point where control flow paths come together
+#[derive(Debug)]
+pub(crate) struct PhiFlowNode {
+    first_predecessor: FlowNodeId,
+    second_predecessor: FlowNodeId,
+}
+
+/// A branch test which may apply constraints to a symbol's type
+#[derive(Debug)]
+pub(crate) struct ConstraintFlowNode {
+    predecessor: FlowNodeId,
+    test_expression: ExpressionId,
+}
+
+#[derive(Debug)]
+pub struct FlowGraph {
+    flow_nodes_by_id: IndexVec<FlowNodeId, FlowNode>,
+    expression_map: IndexVec<ExpressionId, FlowNodeId>,
+}
+
+impl FlowGraph {
+    pub fn start() -> FlowNodeId {
+        FlowNodeId::from_usize(0)
+    }
+
+    pub fn for_expr(&self, expr: ExpressionId) -> FlowNodeId {
+        self.expression_map[expr]
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct FlowGraphBuilder {
+    flow_graph: FlowGraph,
+}
+
+impl FlowGraphBuilder {
+    pub(crate) fn new() -> Self {
+        let mut graph = FlowGraph {
+            flow_nodes_by_id: IndexVec::default(),
+            expression_map: IndexVec::default(),
+        };
+        graph.flow_nodes_by_id.push(FlowNode::Start);
+        Self { flow_graph: graph }
+    }
+
+    pub(crate) fn add(&mut self, node: FlowNode) -> FlowNodeId {
+        self.flow_graph.flow_nodes_by_id.push(node)
+    }
+
+    pub(crate) fn add_definition(
+        &mut self,
+        symbol_id: SymbolId,
+        definition: Definition,
+        predecessor: FlowNodeId,
+    ) -> FlowNodeId {
+        self.add(FlowNode::Definition(DefinitionFlowNode {
+            symbol_id,
+            definition,
+            predecessor,
+        }))
+    }
+
+    pub(crate) fn add_branch(&mut self, predecessor: FlowNodeId) -> FlowNodeId {
+        self.add(FlowNode::Branch(BranchFlowNode { predecessor }))
+    }
+
+    pub(crate) fn add_phi(
+        &mut self,
+        first_predecessor: FlowNodeId,
+        second_predecessor: FlowNodeId,
+    ) -> FlowNodeId {
+        self.add(FlowNode::Phi(PhiFlowNode {
+            first_predecessor,
+            second_predecessor,
+        }))
+    }
+
+    pub(crate) fn add_constraint(
+        &mut self,
+        predecessor: FlowNodeId,
+        test_expression: ExpressionId,
+    ) -> FlowNodeId {
+        self.add(FlowNode::Constraint(ConstraintFlowNode {
+            predecessor,
+            test_expression,
+        }))
+    }
+
+    pub(super) fn record_expr(&mut self, node_id: FlowNodeId) -> ExpressionId {
+        self.flow_graph.expression_map.push(node_id)
+    }
+
+    pub(super) fn finish(mut self) -> FlowGraph {
+        self.flow_graph.flow_nodes_by_id.shrink_to_fit();
+        self.flow_graph.expression_map.shrink_to_fit();
+        self.flow_graph
+    }
+}
+
+/// A definition, and the set of constraints between a use and the definition
+#[derive(Debug, Clone)]
+pub struct ConstrainedDefinition {
+    pub definition: Definition,
+    pub constraints: Vec<ExpressionId>,
+}
+
+/// A flow node and the constraints we passed through to reach it
+#[derive(Debug)]
+struct FlowState {
+    node_id: FlowNodeId,
+    constraints_range: Range<usize>,
+}
+
+#[derive(Debug)]
+pub struct ReachableDefinitionsIterator<'a> {
+    flow_graph: &'a FlowGraph,
+    symbol_id: SymbolId,
+    pending: Vec<FlowState>,
+    constraints: Vec<ExpressionId>,
+}
+
+impl<'a> ReachableDefinitionsIterator<'a> {
+    pub fn new(flow_graph: &'a FlowGraph, symbol_id: SymbolId, start_node_id: FlowNodeId) -> Self {
+        Self {
+            flow_graph,
+            symbol_id,
+            pending: vec![FlowState {
+                node_id: start_node_id,
+                constraints_range: 0..0,
+            }],
+            constraints: vec![],
+        }
+    }
+}
+
+impl<'a> Iterator for ReachableDefinitionsIterator<'a> {
+    type Item = ConstrainedDefinition;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let FlowState {
+            mut node_id,
+            mut constraints_range,
+        } = self.pending.pop()?;
+        self.constraints.truncate(constraints_range.end + 1);
+        loop {
+            match &self.flow_graph.flow_nodes_by_id[node_id] {
+                FlowNode::Start => {
+                    // constraints on unbound are irrelevant
+                    return Some(ConstrainedDefinition {
+                        definition: Definition::Unbound,
+                        constraints: vec![],
+                    });
+                }
+                FlowNode::Definition(def_node) => {
+                    if def_node.symbol_id == self.symbol_id {
+                        return Some(ConstrainedDefinition {
+                            definition: def_node.definition.clone(),
+                            constraints: self.constraints[constraints_range].to_vec(),
+                        });
+                    }
+                    node_id = def_node.predecessor;
+                }
+                FlowNode::Branch(branch_node) => {
+                    node_id = branch_node.predecessor;
+                }
+                FlowNode::Phi(phi_node) => {
+                    self.pending.push(FlowState {
+                        node_id: phi_node.first_predecessor,
+                        constraints_range: constraints_range.clone(),
+                    });
+                    node_id = phi_node.second_predecessor;
+                }
+                FlowNode::Constraint(constraint_node) => {
+                    node_id = constraint_node.predecessor;
+                    self.constraints.push(constraint_node.test_expression);
+                    constraints_range.end += 1;
+                }
+            }
+        }
+    }
+}
+
+impl<'a> FusedIterator for ReachableDefinitionsIterator<'a> {}
+
+impl std::fmt::Display for FlowGraph {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        writeln!(f, "flowchart TD")?;
+        for (id, node) in self.flow_nodes_by_id.iter_enumerated() {
+            write!(f, "  id{}", id.as_u32())?;
+            match node {
+                FlowNode::Start => writeln!(f, r"[\Start/]")?,
+                FlowNode::Definition(def_node) => {
+                    writeln!(f, r"(Define symbol {})", def_node.symbol_id.as_u32())?;
+                    writeln!(
+                        f,
+                        r"  id{}-->id{}",
+                        def_node.predecessor.as_u32(),
+                        id.as_u32()
+                    )?;
+                }
+                FlowNode::Branch(branch_node) => {
+                    writeln!(f, r"{{Branch}}")?;
+                    writeln!(
+                        f,
+                        r"  id{}-->id{}",
+                        branch_node.predecessor.as_u32(),
+                        id.as_u32()
+                    )?;
+                }
+                FlowNode::Phi(phi_node) => {
+                    writeln!(f, r"((Phi))")?;
+                    writeln!(
+                        f,
+                        r"  id{}-->id{}",
+                        phi_node.second_predecessor.as_u32(),
+                        id.as_u32()
+                    )?;
+                    writeln!(
+                        f,
+                        r"  id{}-->id{}",
+                        phi_node.first_predecessor.as_u32(),
+                        id.as_u32()
+                    )?;
+                }
+                FlowNode::Constraint(constraint_node) => {
+                    writeln!(f, r"((Constraint))")?;
+                    writeln!(
+                        f,
+                        r"  id{}-->id{}",
+                        constraint_node.predecessor.as_u32(),
+                        id.as_u32()
+                    )?;
+                }
+            }
+        }
+        Ok(())
+    }
+}

crates/red_knot/src/semantic/symbol_table.rs

@@ -0,0 +1,560 @@
+#![allow(dead_code)]
+
+use std::hash::{Hash, Hasher};
+use std::iter::{Copied, DoubleEndedIterator, FusedIterator};
+use std::num::NonZeroU32;
+
+use bitflags::bitflags;
+use hashbrown::hash_map::{Keys, RawEntryMut};
+use rustc_hash::{FxHashMap, FxHasher};
+
+use ruff_index::{newtype_index, IndexVec};
+
+use crate::ast_ids::NodeKey;
+use crate::module::ModuleName;
+use crate::semantic::{Definition, ExpressionId};
+use crate::Name;
+
+type Map<K, V> = hashbrown::HashMap<K, V, ()>;
+
+#[newtype_index]
+pub struct ScopeId;
+
+impl ScopeId {
+    pub fn scope(self, table: &SymbolTable) -> &Scope {
+        &table.scopes_by_id[self]
+    }
+}
+
+#[newtype_index]
+pub struct SymbolId;
+
+impl SymbolId {
+    pub fn symbol(self, table: &SymbolTable) -> &Symbol {
+        &table.symbols_by_id[self]
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum ScopeKind {
+    Module,
+    Annotation,
+    Class,
+    Function,
+}
+
+#[derive(Debug)]
+pub struct Scope {
+    name: Name,
+    kind: ScopeKind,
+    parent: Option<ScopeId>,
+    children: Vec<ScopeId>,
+    /// the definition (e.g. class or function) that created this scope
+    definition: Option<Definition>,
+    /// the symbol (e.g. class or function) that owns this scope
+    defining_symbol: Option<SymbolId>,
+    /// symbol IDs, hashed by symbol name
+    symbols_by_name: Map<SymbolId, ()>,
+}
+
+impl Scope {
+    pub fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    pub fn kind(&self) -> ScopeKind {
+        self.kind
+    }
+
+    pub fn definition(&self) -> Option<Definition> {
+        self.definition.clone()
+    }
+
+    pub fn defining_symbol(&self) -> Option<SymbolId> {
+        self.defining_symbol
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum Kind {
+    FreeVar,
+    CellVar,
+    CellVarAssigned,
+    ExplicitGlobal,
+    ImplicitGlobal,
+}
+
+bitflags! {
+    #[derive(Copy,Clone,Debug)]
+    pub struct SymbolFlags: u8 {
+        const IS_USED         = 1 << 0;
+        const IS_DEFINED      = 1 << 1;
+        /// TODO: This flag is not yet set by anything
+        const MARKED_GLOBAL   = 1 << 2;
+        /// TODO: This flag is not yet set by anything
+        const MARKED_NONLOCAL = 1 << 3;
+    }
+}
+
+#[derive(Debug)]
+pub struct Symbol {
+    name: Name,
+    flags: SymbolFlags,
+    scope_id: ScopeId,
+    // kind: Kind,
+}
+
+impl Symbol {
+    pub fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    pub fn scope_id(&self) -> ScopeId {
+        self.scope_id
+    }
+
+    /// Is the symbol used in its containing scope?
+    pub fn is_used(&self) -> bool {
+        self.flags.contains(SymbolFlags::IS_USED)
+    }
+
+    /// Is the symbol defined in its containing scope?
+    pub fn is_defined(&self) -> bool {
+        self.flags.contains(SymbolFlags::IS_DEFINED)
+    }
+
+    // TODO: implement Symbol.kind 2-pass analysis to categorize as: free-var, cell-var,
+    // explicit-global, implicit-global and implement Symbol.kind by modifying the preorder
+    // traversal code
+}
+
+#[derive(Debug, Clone)]
+pub enum Dependency {
+    Module(ModuleName),
+    Relative {
+        level: NonZeroU32,
+        module: Option<ModuleName>,
+    },
+}
+
+/// Table of all symbols in all scopes for a module.
+#[derive(Debug)]
+pub struct SymbolTable {
+    scopes_by_id: IndexVec<ScopeId, Scope>,
+    symbols_by_id: IndexVec<SymbolId, Symbol>,
+    /// the definitions for each symbol
+    defs: FxHashMap<SymbolId, Vec<Definition>>,
+    /// map of AST node (e.g. class/function def) to sub-scope it creates
+    scopes_by_node: FxHashMap<NodeKey, ScopeId>,
+    /// Maps expressions to their enclosing scope.
+    expression_scopes: IndexVec<ExpressionId, ScopeId>,
+    /// dependencies of this module
+    dependencies: Vec<Dependency>,
+}
+
+impl SymbolTable {
+    pub fn dependencies(&self) -> &[Dependency] {
+        &self.dependencies
+    }
+
+    pub const fn root_scope_id() -> ScopeId {
+        ScopeId::from_usize(0)
+    }
+
+    pub fn root_scope(&self) -> &Scope {
+        &self.scopes_by_id[SymbolTable::root_scope_id()]
+    }
+
+    pub fn symbol_ids_for_scope(&self, scope_id: ScopeId) -> Copied<Keys<SymbolId, ()>> {
+        self.scopes_by_id[scope_id].symbols_by_name.keys().copied()
+    }
+
+    pub fn symbols_for_scope(
+        &self,
+        scope_id: ScopeId,
+    ) -> SymbolIterator<Copied<Keys<SymbolId, ()>>> {
+        SymbolIterator {
+            table: self,
+            ids: self.symbol_ids_for_scope(scope_id),
+        }
+    }
+
+    pub fn root_symbol_ids(&self) -> Copied<Keys<SymbolId, ()>> {
+        self.symbol_ids_for_scope(SymbolTable::root_scope_id())
+    }
+
+    pub fn root_symbols(&self) -> SymbolIterator<Copied<Keys<SymbolId, ()>>> {
+        self.symbols_for_scope(SymbolTable::root_scope_id())
+    }
+
+    pub fn child_scope_ids_of(&self, scope_id: ScopeId) -> &[ScopeId] {
+        &self.scopes_by_id[scope_id].children
+    }
+
+    pub fn child_scopes_of(&self, scope_id: ScopeId) -> ScopeIterator<&[ScopeId]> {
+        ScopeIterator {
+            table: self,
+            ids: self.child_scope_ids_of(scope_id),
+        }
+    }
+
+    pub fn root_child_scope_ids(&self) -> &[ScopeId] {
+        self.child_scope_ids_of(SymbolTable::root_scope_id())
+    }
+
+    pub fn root_child_scopes(&self) -> ScopeIterator<&[ScopeId]> {
+        self.child_scopes_of(SymbolTable::root_scope_id())
+    }
+
+    pub fn symbol_id_by_name(&self, scope_id: ScopeId, name: &str) -> Option<SymbolId> {
+        let scope = &self.scopes_by_id[scope_id];
+        let hash = SymbolTable::hash_name(name);
+        let name = Name::new(name);
+        Some(
+            *scope
+                .symbols_by_name
+                .raw_entry()
+                .from_hash(hash, |symid| self.symbols_by_id[*symid].name == name)?
+                .0,
+        )
+    }
+
+    pub fn symbol_by_name(&self, scope_id: ScopeId, name: &str) -> Option<&Symbol> {
+        Some(&self.symbols_by_id[self.symbol_id_by_name(scope_id, name)?])
+    }
+
+    pub fn root_symbol_id_by_name(&self, name: &str) -> Option<SymbolId> {
+        self.symbol_id_by_name(SymbolTable::root_scope_id(), name)
+    }
+
+    pub fn root_symbol_by_name(&self, name: &str) -> Option<&Symbol> {
+        self.symbol_by_name(SymbolTable::root_scope_id(), name)
+    }
+
+    pub fn scope_id_of_symbol(&self, symbol_id: SymbolId) -> ScopeId {
+        self.symbols_by_id[symbol_id].scope_id
+    }
+
+    pub fn scope_of_symbol(&self, symbol_id: SymbolId) -> &Scope {
+        &self.scopes_by_id[self.scope_id_of_symbol(symbol_id)]
+    }
+
+    pub fn scope_id_of_expression(&self, expression: ExpressionId) -> ScopeId {
+        self.expression_scopes[expression]
+    }
+
+    pub fn scope_of_expression(&self, expr_id: ExpressionId) -> &Scope {
+        &self.scopes_by_id[self.scope_id_of_expression(expr_id)]
+    }
+
+    pub fn parent_scopes(
+        &self,
+        scope_id: ScopeId,
+    ) -> ScopeIterator<impl Iterator<Item = ScopeId> + '_> {
+        ScopeIterator {
+            table: self,
+            ids: std::iter::successors(Some(scope_id), |scope| self.scopes_by_id[*scope].parent),
+        }
+    }
+
+    pub fn parent_scope(&self, scope_id: ScopeId) -> Option<ScopeId> {
+        self.scopes_by_id[scope_id].parent
+    }
+
+    pub fn scope_id_for_node(&self, node_key: &NodeKey) -> ScopeId {
+        self.scopes_by_node[node_key]
+    }
+
+    pub fn definitions(&self, symbol_id: SymbolId) -> &[Definition] {
+        self.defs
+            .get(&symbol_id)
+            .map(std::vec::Vec::as_slice)
+            .unwrap_or_default()
+    }
+
+    pub fn all_definitions(&self) -> impl Iterator<Item = (SymbolId, &Definition)> + '_ {
+        self.defs
+            .iter()
+            .flat_map(|(sym_id, defs)| defs.iter().map(move |def| (*sym_id, def)))
+    }
+
+    fn hash_name(name: &str) -> u64 {
+        let mut hasher = FxHasher::default();
+        name.hash(&mut hasher);
+        hasher.finish()
+    }
+}
+
+pub struct SymbolIterator<'a, I> {
+    table: &'a SymbolTable,
+    ids: I,
+}
+
+impl<'a, I> Iterator for SymbolIterator<'a, I>
+where
+    I: Iterator<Item = SymbolId>,
+{
+    type Item = &'a Symbol;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let id = self.ids.next()?;
+        Some(&self.table.symbols_by_id[id])
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.ids.size_hint()
+    }
+}
+
+impl<'a, I> FusedIterator for SymbolIterator<'a, I> where
+    I: Iterator<Item = SymbolId> + FusedIterator
+{
+}
+
+impl<'a, I> DoubleEndedIterator for SymbolIterator<'a, I>
+where
+    I: Iterator<Item = SymbolId> + DoubleEndedIterator,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let id = self.ids.next_back()?;
+        Some(&self.table.symbols_by_id[id])
+    }
+}
+
+// TODO maybe get rid of this and just do all data access via methods on ScopeId?
+pub struct ScopeIterator<'a, I> {
+    table: &'a SymbolTable,
+    ids: I,
+}
+
+/// iterate (`ScopeId`, `Scope`) pairs for given `ScopeId` iterator
+impl<'a, I> Iterator for ScopeIterator<'a, I>
+where
+    I: Iterator<Item = ScopeId>,
+{
+    type Item = (ScopeId, &'a Scope);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let id = self.ids.next()?;
+        Some((id, &self.table.scopes_by_id[id]))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.ids.size_hint()
+    }
+}
+
+impl<'a, I> FusedIterator for ScopeIterator<'a, I> where I: Iterator<Item = ScopeId> + FusedIterator {}
+
+impl<'a, I> DoubleEndedIterator for ScopeIterator<'a, I>
+where
+    I: Iterator<Item = ScopeId> + DoubleEndedIterator,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let id = self.ids.next_back()?;
+        Some((id, &self.table.scopes_by_id[id]))
+    }
+}
+
+#[derive(Debug)]
+pub(super) struct SymbolTableBuilder {
+    symbol_table: SymbolTable,
+}
+
+impl SymbolTableBuilder {
+    pub(super) fn new() -> Self {
+        let mut table = SymbolTable {
+            scopes_by_id: IndexVec::new(),
+            symbols_by_id: IndexVec::new(),
+            defs: FxHashMap::default(),
+            scopes_by_node: FxHashMap::default(),
+            expression_scopes: IndexVec::new(),
+            dependencies: Vec::new(),
+        };
+        table.scopes_by_id.push(Scope {
+            name: Name::new("<module>"),
+            kind: ScopeKind::Module,
+            parent: None,
+            children: Vec::new(),
+            definition: None,
+            defining_symbol: None,
+            symbols_by_name: Map::default(),
+        });
+        Self {
+            symbol_table: table,
+        }
+    }
+
+    pub(super) fn finish(self) -> SymbolTable {
+        let mut symbol_table = self.symbol_table;
+        symbol_table.scopes_by_id.shrink_to_fit();
+        symbol_table.symbols_by_id.shrink_to_fit();
+        symbol_table.defs.shrink_to_fit();
+        symbol_table.scopes_by_node.shrink_to_fit();
+        symbol_table.expression_scopes.shrink_to_fit();
+        symbol_table.dependencies.shrink_to_fit();
+        symbol_table
+    }
+
+    pub(super) fn add_or_update_symbol(
+        &mut self,
+        scope_id: ScopeId,
+        name: &str,
+        flags: SymbolFlags,
+    ) -> SymbolId {
+        let hash = SymbolTable::hash_name(name);
+        let scope = &mut self.symbol_table.scopes_by_id[scope_id];
+        let name = Name::new(name);
+
+        let entry = scope
+            .symbols_by_name
+            .raw_entry_mut()
+            .from_hash(hash, |existing| {
+                self.symbol_table.symbols_by_id[*existing].name == name
+            });
+
+        match entry {
+            RawEntryMut::Occupied(entry) => {
+                if let Some(symbol) = self.symbol_table.symbols_by_id.get_mut(*entry.key()) {
+                    symbol.flags.insert(flags);
+                };
+                *entry.key()
+            }
+            RawEntryMut::Vacant(entry) => {
+                let id = self.symbol_table.symbols_by_id.push(Symbol {
+                    name,
+                    flags,
+                    scope_id,
+                });
+                entry.insert_with_hasher(hash, id, (), |symid| {
+                    SymbolTable::hash_name(&self.symbol_table.symbols_by_id[*symid].name)
+                });
+                id
+            }
+        }
+    }
+
+    pub(super) fn add_definition(&mut self, symbol_id: SymbolId, definition: Definition) {
+        self.symbol_table
+            .defs
+            .entry(symbol_id)
+            .or_default()
+            .push(definition);
+    }
+
+    pub(super) fn add_child_scope(
+        &mut self,
+        parent_scope_id: ScopeId,
+        name: &str,
+        kind: ScopeKind,
+        definition: Option<Definition>,
+        defining_symbol: Option<SymbolId>,
+    ) -> ScopeId {
+        let new_scope_id = self.symbol_table.scopes_by_id.push(Scope {
+            name: Name::new(name),
+            kind,
+            parent: Some(parent_scope_id),
+            children: Vec::new(),
+            definition,
+            defining_symbol,
+            symbols_by_name: Map::default(),
+        });
+        let parent_scope = &mut self.symbol_table.scopes_by_id[parent_scope_id];
+        parent_scope.children.push(new_scope_id);
+        new_scope_id
+    }
+
+    pub(super) fn record_scope_for_node(&mut self, node_key: NodeKey, scope_id: ScopeId) {
+        self.symbol_table.scopes_by_node.insert(node_key, scope_id);
+    }
+
+    pub(super) fn add_dependency(&mut self, dependency: Dependency) {
+        self.symbol_table.dependencies.push(dependency);
+    }
+
+    /// Records the scope for the current expression
+    pub(super) fn record_expression(&mut self, scope: ScopeId) -> ExpressionId {
+        self.symbol_table.expression_scopes.push(scope)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{ScopeKind, SymbolFlags, SymbolTable, SymbolTableBuilder};
+
+    #[test]
+    fn insert_same_name_symbol_twice() {
+        let mut builder = SymbolTableBuilder::new();
+        let root_scope_id = SymbolTable::root_scope_id();
+        let symbol_id_1 =
+            builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::IS_DEFINED);
+        let symbol_id_2 = builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::IS_USED);
+        let table = builder.finish();
+
+        assert_eq!(symbol_id_1, symbol_id_2);
+        assert!(symbol_id_1.symbol(&table).is_used(), "flags must merge");
+        assert!(symbol_id_1.symbol(&table).is_defined(), "flags must merge");
+    }
+
+    #[test]
+    fn insert_different_named_symbols() {
+        let mut builder = SymbolTableBuilder::new();
+        let root_scope_id = SymbolTable::root_scope_id();
+        let symbol_id_1 = builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::empty());
+        let symbol_id_2 = builder.add_or_update_symbol(root_scope_id, "bar", SymbolFlags::empty());
+
+        assert_ne!(symbol_id_1, symbol_id_2);
+    }
+
+    #[test]
+    fn add_child_scope_with_symbol() {
+        let mut builder = SymbolTableBuilder::new();
+        let root_scope_id = SymbolTable::root_scope_id();
+        let foo_symbol_top =
+            builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::empty());
+        let c_scope = builder.add_child_scope(root_scope_id, "C", ScopeKind::Class, None, None);
+        let foo_symbol_inner = builder.add_or_update_symbol(c_scope, "foo", SymbolFlags::empty());
+
+        assert_ne!(foo_symbol_top, foo_symbol_inner);
+    }
+
+    #[test]
+    fn scope_from_id() {
+        let table = SymbolTableBuilder::new().finish();
+        let root_scope_id = SymbolTable::root_scope_id();
+        let scope = root_scope_id.scope(&table);
+
+        assert_eq!(scope.name.as_str(), "<module>");
+        assert_eq!(scope.kind, ScopeKind::Module);
+    }
+
+    #[test]
+    fn symbol_from_id() {
+        let mut builder = SymbolTableBuilder::new();
+        let root_scope_id = SymbolTable::root_scope_id();
+        let foo_symbol_id =
+            builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::empty());
+        let table = builder.finish();
+        let symbol = foo_symbol_id.symbol(&table);
+
+        assert_eq!(symbol.name(), "foo");
+    }
+
+    #[test]
+    fn bigger_symbol_table() {
+        let mut builder = SymbolTableBuilder::new();
+        let root_scope_id = SymbolTable::root_scope_id();
+        let foo_symbol_id =
+            builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::empty());
+        builder.add_or_update_symbol(root_scope_id, "bar", SymbolFlags::empty());
+        builder.add_or_update_symbol(root_scope_id, "baz", SymbolFlags::empty());
+        builder.add_or_update_symbol(root_scope_id, "qux", SymbolFlags::empty());
+        let table = builder.finish();
+
+        let foo_symbol_id_2 = table
+            .root_symbol_id_by_name("foo")
+            .expect("foo symbol to be found");
+
+        assert_eq!(foo_symbol_id_2, foo_symbol_id);
+    }
+}

crates/red_knot/src/semantic/types/infer.rs

@@ -0,0 +1,762 @@
+#![allow(dead_code)]
+
+use ruff_python_ast as ast;
+use ruff_python_ast::AstNode;
+use std::fmt::Debug;
+
+use crate::db::{QueryResult, SemanticDb, SemanticJar};
+
+use crate::module::{resolve_module, ModuleName};
+use crate::parse::parse;
+use crate::semantic::types::{ModuleTypeId, Type};
+use crate::semantic::{
+    resolve_global_symbol, semantic_index, ConstrainedDefinition, Definition, GlobalSymbolId,
+    ImportDefinition, ImportFromDefinition,
+};
+use crate::{FileId, Name};
+
+// FIXME: Figure out proper dead-lock free synchronisation now that this takes `&db` instead of `&mut db`.
+/// Resolve the public-facing type for a symbol (the type seen by other scopes: other modules, or
+/// nested functions). Because calls to nested functions and imports can occur anywhere in control
+/// flow, this type must be conservative and consider all definitions of the symbol that could
+/// possibly be seen by another scope. Currently we take the most conservative approach, which is
+/// the union of all definitions. We may be able to narrow this in future to eliminate definitions
+/// which can't possibly (or at least likely) be seen by any other scope, so that e.g. we could
+/// infer `Literal["1"]` instead of `Literal[1] | Literal["1"]` for `x` in `x = x; x = str(x);`.
+#[tracing::instrument(level = "trace", skip(db))]
+pub fn infer_symbol_public_type(db: &dyn SemanticDb, symbol: GlobalSymbolId) -> QueryResult<Type> {
+    let index = semantic_index(db, symbol.file_id)?;
+    let defs = index.symbol_table().definitions(symbol.symbol_id).to_vec();
+    let jar: &SemanticJar = db.jar()?;
+
+    if let Some(ty) = jar.type_store.get_cached_symbol_public_type(symbol) {
+        return Ok(ty);
+    }
+
+    let ty = infer_type_from_definitions(db, symbol, defs.iter().cloned())?;
+
+    jar.type_store.cache_symbol_public_type(symbol, ty);
+
+    // TODO record dependencies
+    Ok(ty)
+}
+
+/// Infer type of a symbol as union of the given `Definitions`.
+fn infer_type_from_definitions<T>(
+    db: &dyn SemanticDb,
+    symbol: GlobalSymbolId,
+    definitions: T,
+) -> QueryResult<Type>
+where
+    T: Debug + IntoIterator<Item = Definition>,
+{
+    infer_type_from_constrained_definitions(
+        db,
+        symbol,
+        definitions
+            .into_iter()
+            .map(|definition| ConstrainedDefinition {
+                definition,
+                constraints: vec![],
+            }),
+    )
+}
+
+/// Infer type of a symbol as union of the given `ConstrainedDefinitions`.
+fn infer_type_from_constrained_definitions<T>(
+    db: &dyn SemanticDb,
+    symbol: GlobalSymbolId,
+    constrained_definitions: T,
+) -> QueryResult<Type>
+where
+    T: IntoIterator<Item = ConstrainedDefinition>,
+{
+    let jar: &SemanticJar = db.jar()?;
+    let mut tys = constrained_definitions
+        .into_iter()
+        .map(|def| infer_constrained_definition_type(db, symbol, def.clone()))
+        .peekable();
+    if let Some(first) = tys.next() {
+        if tys.peek().is_some() {
+            Ok(jar.type_store.add_union(
+                symbol.file_id,
+                &Iterator::chain(std::iter::once(first), tys).collect::<QueryResult<Vec<_>>>()?,
+            ))
+        } else {
+            first
+        }
+    } else {
+        Ok(Type::Unknown)
+    }
+}
+
+/// Infer type for a ConstrainedDefinition (intersection of the definition type and the
+/// constraints)
+#[tracing::instrument(level = "trace", skip(db))]
+pub fn infer_constrained_definition_type(
+    db: &dyn SemanticDb,
+    symbol: GlobalSymbolId,
+    constrained_definition: ConstrainedDefinition,
+) -> QueryResult<Type> {
+    let ConstrainedDefinition {
+        definition,
+        constraints,
+    } = constrained_definition;
+    let index = semantic_index(db, symbol.file_id)?;
+    let parsed = parse(db.upcast(), symbol.file_id)?;
+    let mut intersected_types = vec![infer_definition_type(db, symbol, definition)?];
+    for constraint in constraints {
+        if let Some(constraint_type) = infer_constraint_type(
+            db,
+            symbol,
+            index.resolve_expression_id(parsed.syntax(), constraint),
+        )? {
+            intersected_types.push(constraint_type);
+        }
+    }
+    let jar: &SemanticJar = db.jar()?;
+    Ok(jar
+        .type_store
+        .add_intersection(symbol.file_id, &intersected_types, &[]))
+}
+
+/// Infer a type for a Definition
+#[tracing::instrument(level = "trace", skip(db))]
+pub fn infer_definition_type(
+    db: &dyn SemanticDb,
+    symbol: GlobalSymbolId,
+    definition: Definition,
+) -> QueryResult<Type> {
+    let jar: &SemanticJar = db.jar()?;
+    let type_store = &jar.type_store;
+    let file_id = symbol.file_id;
+
+    match definition {
+        Definition::Unbound => Ok(Type::Unbound),
+        Definition::Import(ImportDefinition {
+            module: module_name,
+        }) => {
+            if let Some(module) = resolve_module(db, module_name.clone())? {
+                Ok(Type::Module(ModuleTypeId { module, file_id }))
+            } else {
+                Ok(Type::Unknown)
+            }
+        }
+        Definition::ImportFrom(ImportFromDefinition {
+            module,
+            name,
+            level,
+        }) => {
+            // TODO relative imports
+            assert!(matches!(level, 0));
+            let module_name = ModuleName::new(module.as_ref().expect("TODO relative imports"));
+            let Some(module) = resolve_module(db, module_name.clone())? else {
+                return Ok(Type::Unknown);
+            };
+
+            if let Some(remote_symbol) = resolve_global_symbol(db, module, &name)? {
+                infer_symbol_public_type(db, remote_symbol)
+            } else {
+                Ok(Type::Unknown)
+            }
+        }
+        Definition::ClassDef(node_key) => {
+            if let Some(ty) = type_store.get_cached_node_type(file_id, node_key.erased()) {
+                Ok(ty)
+            } else {
+                let parsed = parse(db.upcast(), file_id)?;
+                let ast = parsed.syntax();
+                let index = semantic_index(db, file_id)?;
+                let node = node_key.resolve_unwrap(ast.as_any_node_ref());
+
+                let mut bases = Vec::with_capacity(node.bases().len());
+
+                for base in node.bases() {
+                    bases.push(infer_expr_type(db, file_id, base)?);
+                }
+                let scope_id = index.symbol_table().scope_id_for_node(node_key.erased());
+                let ty = type_store.add_class(file_id, &node.name.id, scope_id, bases);
+                type_store.cache_node_type(file_id, *node_key.erased(), ty);
+                Ok(ty)
+            }
+        }
+        Definition::FunctionDef(node_key) => {
+            if let Some(ty) = type_store.get_cached_node_type(file_id, node_key.erased()) {
+                Ok(ty)
+            } else {
+                let parsed = parse(db.upcast(), file_id)?;
+                let ast = parsed.syntax();
+                let index = semantic_index(db, file_id)?;
+                let node = node_key
+                    .resolve(ast.as_any_node_ref())
+                    .expect("node key should resolve");
+
+                let decorator_tys = node
+                    .decorator_list
+                    .iter()
+                    .map(|decorator| infer_expr_type(db, file_id, &decorator.expression))
+                    .collect::<QueryResult<_>>()?;
+                let scope_id = index.symbol_table().scope_id_for_node(node_key.erased());
+                let ty = type_store.add_function(
+                    file_id,
+                    &node.name.id,
+                    symbol.symbol_id,
+                    scope_id,
+                    decorator_tys,
+                );
+                type_store.cache_node_type(file_id, *node_key.erased(), ty);
+                Ok(ty)
+            }
+        }
+        Definition::Assignment(node_key) => {
+            let parsed = parse(db.upcast(), file_id)?;
+            let ast = parsed.syntax();
+            let node = node_key.resolve_unwrap(ast.as_any_node_ref());
+            // TODO handle unpacking assignment
+            infer_expr_type(db, file_id, &node.value)
+        }
+        Definition::AnnotatedAssignment(node_key) => {
+            let parsed = parse(db.upcast(), file_id)?;
+            let ast = parsed.syntax();
+            let node = node_key.resolve_unwrap(ast.as_any_node_ref());
+            // TODO actually look at the annotation
+            let Some(value) = &node.value else {
+                return Ok(Type::Unknown);
+            };
+            // TODO handle unpacking assignment
+            infer_expr_type(db, file_id, value)
+        }
+        Definition::NamedExpr(node_key) => {
+            let parsed = parse(db.upcast(), file_id)?;
+            let ast = parsed.syntax();
+            let node = node_key.resolve_unwrap(ast.as_any_node_ref());
+            infer_expr_type(db, file_id, &node.value)
+        }
+    }
+}
+
+/// Return the type that the given constraint (an expression from a control-flow test) requires the
+/// given symbol to have. For example, returns the Type "~None" as the constraint type if given the
+/// symbol ID for x and the expression ID for `x is not None`. Returns (Rust) None if the given
+/// expression applies no constraints on the given symbol.
+#[tracing::instrument(level = "trace", skip(db))]
+fn infer_constraint_type(
+    db: &dyn SemanticDb,
+    symbol_id: GlobalSymbolId,
+    // TODO this should preferably take an &ast::Expr instead of AnyNodeRef
+    expression: ast::AnyNodeRef,
+) -> QueryResult<Option<Type>> {
+    let file_id = symbol_id.file_id;
+    let index = semantic_index(db, file_id)?;
+    let jar: &SemanticJar = db.jar()?;
+    let symbol_name = symbol_id.symbol_id.symbol(&index.symbol_table).name();
+    // TODO narrowing attributes
+    // TODO narrowing dict keys
+    // TODO isinstance, ==/!=, type(...), literals, bools...
+    match expression {
+        ast::AnyNodeRef::ExprCompare(ast::ExprCompare {
+            left,
+            ops,
+            comparators,
+            ..
+        }) => {
+            // TODO chained comparisons
+            match left.as_ref() {
+                ast::Expr::Name(ast::ExprName { id, .. }) if id == symbol_name => match ops[0] {
+                    ast::CmpOp::Is | ast::CmpOp::IsNot => {
+                        Ok(match infer_expr_type(db, file_id, &comparators[0])? {
+                            Type::None => Some(Type::None),
+                            _ => None,
+                        }
+                        .map(|ty| {
+                            if matches!(ops[0], ast::CmpOp::IsNot) {
+                                jar.type_store.add_intersection(file_id, &[], &[ty])
+                            } else {
+                                ty
+                            }
+                        }))
+                    }
+                    _ => Ok(None),
+                },
+                _ => Ok(None),
+            }
+        }
+        _ => Ok(None),
+    }
+}
+
+/// Infer type of the given expression.
+fn infer_expr_type(db: &dyn SemanticDb, file_id: FileId, expr: &ast::Expr) -> QueryResult<Type> {
+    // TODO cache the resolution of the type on the node
+    let index = semantic_index(db, file_id)?;
+    match expr {
+        ast::Expr::NoneLiteral(_) => Ok(Type::None),
+        ast::Expr::NumberLiteral(ast::ExprNumberLiteral { value, .. }) => {
+            match value {
+                ast::Number::Int(n) => {
+                    // TODO support big int literals
+                    Ok(n.as_i64().map(Type::IntLiteral).unwrap_or(Type::Unknown))
+                }
+                // TODO builtins.float or builtins.complex
+                _ => Ok(Type::Unknown),
+            }
+        }
+        ast::Expr::Name(name) => {
+            // TODO look up in the correct scope, don't assume global
+            if let Some(symbol_id) = index.symbol_table().root_symbol_id_by_name(&name.id) {
+                infer_type_from_constrained_definitions(
+                    db,
+                    GlobalSymbolId { file_id, symbol_id },
+                    index.reachable_definitions(symbol_id, expr),
+                )
+            } else {
+                Ok(Type::Unknown)
+            }
+        }
+        ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
+            let value_type = infer_expr_type(db, file_id, value)?;
+            let attr_name = &Name::new(&attr.id);
+            value_type
+                .get_member(db, attr_name)
+                .map(|ty| ty.unwrap_or(Type::Unknown))
+        }
+        ast::Expr::BinOp(ast::ExprBinOp {
+            left, op, right, ..
+        }) => {
+            let left_ty = infer_expr_type(db, file_id, left)?;
+            let right_ty = infer_expr_type(db, file_id, right)?;
+            // TODO add reverse bin op support if right <: left
+            left_ty.resolve_bin_op(db, *op, right_ty)
+        }
+        ast::Expr::Named(ast::ExprNamed { value, .. }) => infer_expr_type(db, file_id, value),
+        ast::Expr::If(ast::ExprIf { body, orelse, .. }) => {
+            // TODO detect statically known truthy or falsy test
+            let body_ty = infer_expr_type(db, file_id, body)?;
+            let else_ty = infer_expr_type(db, file_id, orelse)?;
+            let jar: &SemanticJar = db.jar()?;
+            Ok(jar.type_store.add_union(file_id, &[body_ty, else_ty]))
+        }
+        _ => todo!("expression type resolution for {:?}", expr),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use std::path::PathBuf;
+
+    use crate::db::tests::TestDb;
+    use crate::db::{HasJar, SemanticJar};
+    use crate::module::{
+        resolve_module, set_module_search_paths, ModuleName, ModuleResolutionInputs,
+    };
+    use crate::semantic::{infer_symbol_public_type, resolve_global_symbol, Type};
+    use crate::Name;
+
+    // TODO with virtual filesystem we shouldn't have to write files to disk for these
+    // tests
+
+    struct TestCase {
+        temp_dir: tempfile::TempDir,
+        db: TestDb,
+
+        src: PathBuf,
+    }
+
+    fn create_test() -> std::io::Result<TestCase> {
+        let temp_dir = tempfile::tempdir()?;
+
+        let src = temp_dir.path().join("src");
+        std::fs::create_dir(&src)?;
+        let src = src.canonicalize()?;
+
+        let search_paths = ModuleResolutionInputs {
+            extra_paths: vec![],
+            workspace_root: src.clone(),
+            site_packages: None,
+            custom_typeshed: None,
+        };
+
+        let mut db = TestDb::default();
+        set_module_search_paths(&mut db, search_paths);
+
+        Ok(TestCase { temp_dir, db, src })
+    }
+
+    fn write_to_path(case: &TestCase, relative_path: &str, contents: &str) -> anyhow::Result<()> {
+        let path = case.src.join(relative_path);
+        std::fs::write(path, contents)?;
+        Ok(())
+    }
+
+    fn get_public_type(
+        case: &TestCase,
+        module_name: &str,
+        variable_name: &str,
+    ) -> anyhow::Result<Type> {
+        let db = &case.db;
+        let module = resolve_module(db, ModuleName::new(module_name))?.expect("Module to exist");
+        let symbol = resolve_global_symbol(db, module, variable_name)?.expect("symbol to exist");
+
+        Ok(infer_symbol_public_type(db, symbol)?)
+    }
+
+    fn assert_public_type(
+        case: &TestCase,
+        module_name: &str,
+        variable_name: &str,
+        type_name: &str,
+    ) -> anyhow::Result<()> {
+        let ty = get_public_type(case, module_name, variable_name)?;
+
+        let jar = HasJar::<SemanticJar>::jar(&case.db)?;
+        assert_eq!(format!("{}", ty.display(&jar.type_store)), type_name);
+        Ok(())
+    }
+
+    #[test]
+    fn follow_import_to_class() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(&case, "a.py", "from b import C as D; E = D")?;
+        write_to_path(&case, "b.py", "class C: pass")?;
+
+        assert_public_type(&case, "a", "E", "Literal[C]")
+    }
+
+    #[test]
+    fn resolve_base_class_by_name() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "mod.py",
+            "
+                class Base: pass
+                class Sub(Base): pass
+            ",
+        )?;
+
+        let ty = get_public_type(&case, "mod", "Sub")?;
+
+        let Type::Class(class_id) = ty else {
+            panic!("Sub is not a Class")
+        };
+        let jar = HasJar::<SemanticJar>::jar(&case.db)?;
+        let base_names: Vec<_> = jar
+            .type_store
+            .get_class(class_id)
+            .bases()
+            .iter()
+            .map(|base_ty| format!("{}", base_ty.display(&jar.type_store)))
+            .collect();
+
+        assert_eq!(base_names, vec!["Literal[Base]"]);
+
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_method() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "mod.py",
+            "
+                class C:
+                    def f(self): pass
+            ",
+        )?;
+
+        let ty = get_public_type(&case, "mod", "C")?;
+
+        let Type::Class(class_id) = ty else {
+            panic!("C is not a Class");
+        };
+
+        let member_ty = class_id
+            .get_own_class_member(&case.db, &Name::new("f"))
+            .expect("C.f to resolve");
+
+        let Some(Type::Function(func_id)) = member_ty else {
+            panic!("C.f is not a Function");
+        };
+
+        let jar = HasJar::<SemanticJar>::jar(&case.db)?;
+        let function = jar.type_store.get_function(func_id);
+        assert_eq!(function.name(), "f");
+
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_module_member() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(&case, "a.py", "import b; D = b.C")?;
+        write_to_path(&case, "b.py", "class C: pass")?;
+
+        assert_public_type(&case, "a", "D", "Literal[C]")
+    }
+
+    #[test]
+    fn resolve_literal() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(&case, "a.py", "x = 1")?;
+
+        assert_public_type(&case, "a", "x", "Literal[1]")
+    }
+
+    #[test]
+    fn resolve_union() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                if flag:
+                    x = 1
+                else:
+                    x = 2
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "x", "Literal[1, 2]")
+    }
+
+    #[test]
+    fn resolve_visible_def() -> anyhow::Result<()> {
+        let case = create_test()?;
+        write_to_path(&case, "a.py", "y = 1; y = 2; x = y")?;
+        assert_public_type(&case, "a", "x", "Literal[2]")
+    }
+
+    #[test]
+    fn join_paths() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                y = 1
+                y = 2
+                if flag:
+                    y = 3
+                x = y
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "x", "Literal[2, 3]")
+    }
+
+    #[test]
+    fn maybe_unbound() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                if flag:
+                    y = 1
+                x = y
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "x", "Literal[1] | Unbound")
+    }
+
+    #[test]
+    fn if_elif_else() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                y = 1
+                y = 2
+                if flag:
+                    y = 3
+                elif flag2:
+                    y = 4
+                else:
+                    r = y
+                    y = 5
+                    s = y
+                x = y
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "x", "Literal[3, 4, 5]")?;
+        assert_public_type(&case, "a", "r", "Literal[2]")?;
+        assert_public_type(&case, "a", "s", "Literal[5]")
+    }
+
+    #[test]
+    fn if_elif() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                y = 1
+                y = 2
+                if flag:
+                    y = 3
+                elif flag2:
+                    y = 4
+                x = y
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "x", "Literal[2, 3, 4]")
+    }
+
+    #[test]
+    fn literal_int_arithmetic() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                a = 2 + 1
+                b = a - 4
+                c = a * b
+                d = c / 3
+                e = 5 % 3
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "a", "Literal[3]")?;
+        assert_public_type(&case, "a", "b", "Literal[-1]")?;
+        assert_public_type(&case, "a", "c", "Literal[-3]")?;
+        assert_public_type(&case, "a", "d", "Literal[-1]")?;
+        assert_public_type(&case, "a", "e", "Literal[2]")
+    }
+
+    #[test]
+    fn walrus() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                x = (y := 1) + 1
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "x", "Literal[2]")?;
+        assert_public_type(&case, "a", "y", "Literal[1]")
+    }
+
+    #[test]
+    fn ifexpr() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                x = 1 if flag else 2
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "x", "Literal[1, 2]")
+    }
+
+    #[test]
+    fn ifexpr_walrus() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                y = z = 0
+                x = (y := 1) if flag else (z := 2)
+                a = y
+                b = z
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "x", "Literal[1, 2]")?;
+        assert_public_type(&case, "a", "a", "Literal[0, 1]")?;
+        assert_public_type(&case, "a", "b", "Literal[0, 2]")
+    }
+
+    #[test]
+    fn ifexpr_walrus_2() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                y = 0
+                (y := 1) if flag else (y := 2)
+                a = y
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "a", "Literal[1, 2]")
+    }
+
+    #[test]
+    fn ifexpr_nested() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                x = 1 if flag else 2 if flag2 else 3
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "x", "Literal[1, 2, 3]")
+    }
+
+    #[test]
+    fn none() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                x = 1 if flag else None
+            ",
+        )?;
+
+        assert_public_type(&case, "a", "x", "Literal[1] | None")
+    }
+
+    #[test]
+    fn narrow_none() -> anyhow::Result<()> {
+        let case = create_test()?;
+
+        write_to_path(
+            &case,
+            "a.py",
+            "
+                x = 1 if flag else None
+                y = 0
+                if x is not None:
+                    y = x
+                z = y
+            ",
+        )?;
+
+        // TODO normalization of unions and intersections: this type is technically correct but
+        // begging for normalization
+        assert_public_type(&case, "a", "z", "Literal[0] | Literal[1] | None & ~None")
+    }
+}

crates/red_knot/src/source.rs

@@ -0,0 +1,105 @@
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+
+use ruff_notebook::Notebook;
+use ruff_python_ast::PySourceType;
+
+use crate::cache::KeyValueCache;
+use crate::db::{QueryResult, SourceDb};
+use crate::files::FileId;
+
+#[tracing::instrument(level = "debug", skip(db))]
+pub(crate) fn source_text(db: &dyn SourceDb, file_id: FileId) -> QueryResult<Source> {
+    let jar = db.jar()?;
+    let sources = &jar.sources;
+
+    sources.get(&file_id, |file_id| {
+        let path = db.file_path(*file_id);
+
+        let source_text = std::fs::read_to_string(&path).unwrap_or_else(|err| {
+            tracing::error!("Failed to read file '{path:?}: {err}'. Falling back to empty text");
+            String::new()
+        });
+
+        let python_ty = PySourceType::from(&path);
+
+        let kind = match python_ty {
+            PySourceType::Python => {
+                SourceKind::Python(Arc::from(source_text))
+            }
+            PySourceType::Stub => SourceKind::Stub(Arc::from(source_text)),
+            PySourceType::Ipynb => {
+                let notebook = Notebook::from_source_code(&source_text).unwrap_or_else(|err| {
+                    // TODO should this be changed to never fail?
+                    // or should we instead add a diagnostic somewhere? But what would we return in this case?
+                    tracing::error!(
+                        "Failed to parse notebook '{path:?}: {err}'. Falling back to an empty notebook"
+                    );
+                    Notebook::from_source_code("").unwrap()
+                });
+
+                SourceKind::IpyNotebook(Arc::new(notebook))
+            }
+        };
+
+        Ok(Source { kind })
+    })
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum SourceKind {
+    Python(Arc<str>),
+    Stub(Arc<str>),
+    IpyNotebook(Arc<Notebook>),
+}
+
+impl<'a> From<&'a SourceKind> for PySourceType {
+    fn from(value: &'a SourceKind) -> Self {
+        match value {
+            SourceKind::Python(_) => PySourceType::Python,
+            SourceKind::Stub(_) => PySourceType::Stub,
+            SourceKind::IpyNotebook(_) => PySourceType::Ipynb,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Source {
+    kind: SourceKind,
+}
+
+impl Source {
+    pub fn python<T: Into<Arc<str>>>(source: T) -> Self {
+        Self {
+            kind: SourceKind::Python(source.into()),
+        }
+    }
+    pub fn kind(&self) -> &SourceKind {
+        &self.kind
+    }
+
+    pub fn text(&self) -> &str {
+        match &self.kind {
+            SourceKind::Python(text) => text,
+            SourceKind::Stub(text) => text,
+            SourceKind::IpyNotebook(notebook) => notebook.source_code(),
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct SourceStorage(pub(crate) KeyValueCache<FileId, Source>);
+
+impl Deref for SourceStorage {
+    type Target = KeyValueCache<FileId, Source>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for SourceStorage {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}

crates/red_knot/src/watch.rs

@@ -1,10 +1,10 @@
 use std::path::Path;
 
 use anyhow::Context;
-use notify::event::{CreateKind, ModifyKind, RemoveKind};
+use notify::event::{CreateKind, RemoveKind};
 use notify::{recommended_watcher, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
 
-use ruff_db::system::{SystemPath, SystemPathBuf};
+use crate::program::{FileChangeKind, FileWatcherChange};
 
 pub struct FileWatcher {
     watcher: RecommendedWatcher,
@@ -33,25 +33,12 @@ impl FileWatcher {
     }
 
     fn from_handler(handler: Box<dyn EventHandler>) -> anyhow::Result<Self> {
-        let watcher = recommended_watcher(move |event: notify::Result<Event>| {
-            match event {
+        let watcher = recommended_watcher(move |changes: notify::Result<Event>| {
+            match changes {
                 Ok(event) => {
                     // TODO verify that this handles all events correctly
                     let change_kind = match event.kind {
                         EventKind::Create(CreateKind::File) => FileChangeKind::Created,
-                        EventKind::Modify(ModifyKind::Name(notify::event::RenameMode::From)) => {
-                            FileChangeKind::Deleted
-                        }
-                        EventKind::Modify(ModifyKind::Name(notify::event::RenameMode::To)) => {
-                            FileChangeKind::Created
-                        }
-                        EventKind::Modify(ModifyKind::Name(notify::event::RenameMode::Any)) => {
-                            // TODO Introduce a better catch all event for cases that we don't understand.
-                            FileChangeKind::Created
-                        }
-                        EventKind::Modify(ModifyKind::Name(notify::event::RenameMode::Both)) => {
-                            todo!("Handle both create and delete event.");
-                        }
                         EventKind::Modify(_) => FileChangeKind::Modified,
                         EventKind::Remove(RemoveKind::File) => FileChangeKind::Deleted,
                         _ => {
@@ -62,9 +49,8 @@ impl FileWatcher {
                     let mut changes = Vec::new();
 
                     for path in event.paths {
-                        if let Some(fs_path) = SystemPath::from_std_path(&path) {
-                            changes
-                                .push(FileWatcherChange::new(fs_path.to_path_buf(), change_kind));
+                        if path.is_file() {
+                            changes.push(FileWatcherChange::new(path, change_kind));
                         }
                     }
 
@@ -89,23 +75,3 @@ impl FileWatcher {
         Ok(())
     }
 }
-
-#[derive(Clone, Debug)]
-pub struct FileWatcherChange {
-    pub path: SystemPathBuf,
-    #[allow(unused)]
-    pub kind: FileChangeKind,
-}
-
-impl FileWatcherChange {
-    pub fn new(path: SystemPathBuf, kind: FileChangeKind) -> Self {
-        Self { path, kind }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum FileChangeKind {
-    Created,
-    Modified,
-    Deleted,
-}

crates/red_knot/src/workspace.rs

@@ -1,344 +0,0 @@
-// TODO: Fix clippy warnings created by salsa macros
-#![allow(clippy::used_underscore_binding)]
-
-use std::{collections::BTreeMap, sync::Arc};
-
-use rustc_hash::{FxBuildHasher, FxHashSet};
-
-pub use metadata::{PackageMetadata, WorkspaceMetadata};
-use ruff_db::{
-    files::{system_path_to_file, File},
-    system::{walk_directory::WalkState, SystemPath, SystemPathBuf},
-};
-use ruff_python_ast::{name::Name, PySourceType};
-
-use crate::{
-    db::Db,
-    lint::{lint_semantic, lint_syntax, Diagnostics},
-};
-
-mod metadata;
-
-/// The project workspace as a Salsa ingredient.
-///
-/// A workspace consists of one or multiple packages. Packages can be nested. A file in a workspace
-/// belongs to no or exactly one package (files can't belong to multiple packages).
-///
-/// How workspaces and packages are discovered is TBD. For now, a workspace can be any directory,
-/// and it always contains a single package which has the same root as the workspace.
-///
-/// ## Examples
-///
-/// ```text
-/// app-1/
-///     pyproject.toml
-///     src/
-///         ... python files
-///
-/// app-2/
-///     pyproject.toml
-///     src/
-///         ... python files
-///
-/// shared/
-///     pyproject.toml
-///     src/
-///         ... python files
-///
-/// pyproject.toml
-/// ```
-///
-/// The above project structure has three packages: `app-1`, `app-2`, and `shared`.
-/// Each of the packages can define their own settings in their `pyproject.toml` file, but
-/// they must be compatible. For example, each package can define a different `requires-python` range,
-/// but the ranges must overlap.
-///
-/// ## How is a workspace different from a program?
-/// There are two (related) motivations:
-///
-/// 1. Program is defined in `ruff_db` and it can't reference the settings types for the linter and formatter
-///    without introducing a cyclic dependency. The workspace is defined in a higher level crate
-///    where it can reference these setting types.
-/// 2. Running `ruff check` with different target versions results in different programs (settings) but
-///    it remains the same workspace. That's why program is a narrowed view of the workspace only
-///    holding on to the most fundamental settings required for checking.
-#[salsa::input]
-pub struct Workspace {
-    #[id]
-    #[return_ref]
-    root_buf: SystemPathBuf,
-
-    /// The files that are open in the workspace.
-    ///
-    /// Setting the open files to a non-`None` value changes `check` to only check the
-    /// open files rather than all files in the workspace.
-    #[return_ref]
-    open_file_set: Option<Arc<FxHashSet<File>>>,
-
-    /// The (first-party) packages in this workspace.
-    #[return_ref]
-    package_tree: BTreeMap<SystemPathBuf, Package>,
-}
-
-/// A first-party package in a workspace.
-#[salsa::input]
-pub struct Package {
-    #[return_ref]
-    pub name: Name,
-
-    /// The path to the root directory of the package.
-    #[id]
-    #[return_ref]
-    root_buf: SystemPathBuf,
-
-    /// The files that are part of this package.
-    #[return_ref]
-    file_set: Arc<FxHashSet<File>>,
-    // TODO: Add the loaded settings.
-}
-
-impl Workspace {
-    /// Discovers the closest workspace at `path` and returns its metadata.
-    pub fn from_metadata(db: &dyn Db, metadata: WorkspaceMetadata) -> Self {
-        let mut packages = BTreeMap::new();
-
-        for package in metadata.packages {
-            packages.insert(package.root.clone(), Package::from_metadata(db, package));
-        }
-
-        Workspace::new(db, metadata.root, None, packages)
-    }
-
-    pub fn root(self, db: &dyn Db) -> &SystemPath {
-        self.root_buf(db)
-    }
-
-    pub fn packages(self, db: &dyn Db) -> impl Iterator<Item = Package> + '_ {
-        self.package_tree(db).values().copied()
-    }
-
-    pub fn reload(self, db: &mut dyn Db, metadata: WorkspaceMetadata) {
-        assert_eq!(self.root(db), metadata.root());
-
-        let mut old_packages = self.package_tree(db).clone();
-        let mut new_packages = BTreeMap::new();
-
-        for package_metadata in metadata.packages {
-            let path = package_metadata.root().to_path_buf();
-
-            let package = if let Some(old_package) = old_packages.remove(&path) {
-                old_package.update(db, package_metadata);
-                old_package
-            } else {
-                Package::from_metadata(db, package_metadata)
-            };
-
-            new_packages.insert(path, package);
-        }
-
-        self.set_package_tree(db).to(new_packages);
-    }
-
-    pub fn update_package(self, db: &mut dyn Db, metadata: PackageMetadata) -> anyhow::Result<()> {
-        let path = metadata.root().to_path_buf();
-
-        if let Some(package) = self.package_tree(db).get(&path).copied() {
-            package.update(db, metadata);
-            Ok(())
-        } else {
-            Err(anyhow::anyhow!("Package {path} not found"))
-        }
-    }
-
-    /// Returns the closest package to which the first-party `path` belongs.
-    ///
-    /// Returns `None` if the `path` is outside of any package or if `file` isn't a first-party file
-    /// (e.g. third-party dependencies or `excluded`).
-    pub fn package(self, db: &dyn Db, path: &SystemPath) -> Option<Package> {
-        let packages = self.package_tree(db);
-
-        let (package_path, package) = packages.range(..path.to_path_buf()).next_back()?;
-
-        if path.starts_with(package_path) {
-            Some(*package)
-        } else {
-            None
-        }
-    }
-
-    /// Checks all open files in the workspace and its dependencies.
-    #[tracing::instrument(level = "debug", skip_all)]
-    pub fn check(self, db: &dyn Db) -> Vec<String> {
-        let mut result = Vec::new();
-
-        if let Some(open_files) = self.open_files(db) {
-            for file in open_files {
-                result.extend_from_slice(&check_file(db, *file));
-            }
-        } else {
-            for package in self.packages(db) {
-                result.extend(package.check(db));
-            }
-        }
-
-        result
-    }
-
-    /// Opens a file in the workspace.
-    ///
-    /// This changes the behavior of `check` to only check the open files rather than all files in the workspace.
-    #[tracing::instrument(level = "debug", skip(self, db))]
-    pub fn open_file(self, db: &mut dyn Db, file: File) {
-        let mut open_files = self.take_open_files(db);
-        open_files.insert(file);
-        self.set_open_files(db, open_files);
-    }
-
-    /// Closes a file in the workspace.
-    #[tracing::instrument(level = "debug", skip(self, db))]
-    pub fn close_file(self, db: &mut dyn Db, file: File) -> bool {
-        let mut open_files = self.take_open_files(db);
-        let removed = open_files.remove(&file);
-
-        if removed {
-            self.set_open_files(db, open_files);
-        }
-
-        removed
-    }
-
-    /// Returns the open files in the workspace or `None` if the entire workspace should be checked.
-    pub fn open_files(self, db: &dyn Db) -> Option<&FxHashSet<File>> {
-        self.open_file_set(db).as_deref()
-    }
-
-    /// Sets the open files in the workspace.
-    ///
-    /// This changes the behavior of `check` to only check the open files rather than all files in the workspace.
-    #[tracing::instrument(level = "debug", skip(self, db))]
-    pub fn set_open_files(self, db: &mut dyn Db, open_files: FxHashSet<File>) {
-        self.set_open_file_set(db).to(Some(Arc::new(open_files)));
-    }
-
-    /// This takes the open files from the workspace and returns them.
-    ///
-    /// This changes the behavior of `check` to check all files in the workspace instead of just the open files.
-    pub fn take_open_files(self, db: &mut dyn Db) -> FxHashSet<File> {
-        let open_files = self.open_file_set(db).clone();
-
-        if let Some(open_files) = open_files {
-            // Salsa will cancel any pending queries and remove its own reference to `open_files`
-            // so that the reference counter to `open_files` now drops to 1.
-            self.set_open_file_set(db).to(None);
-
-            Arc::try_unwrap(open_files).unwrap()
-        } else {
-            FxHashSet::default()
-        }
-    }
-}
-
-impl Package {
-    pub fn root(self, db: &dyn Db) -> &SystemPath {
-        self.root_buf(db)
-    }
-
-    /// Returns `true` if `file` is a first-party file part of this package.
-    pub fn contains_file(self, db: &dyn Db, file: File) -> bool {
-        self.files(db).contains(&file)
-    }
-
-    pub fn files(self, db: &dyn Db) -> &FxHashSet<File> {
-        self.file_set(db)
-    }
-
-    pub fn remove_file(self, db: &mut dyn Db, file: File) -> bool {
-        let mut files_arc = self.file_set(db).clone();
-
-        // Set a dummy value. Salsa will cancel any pending queries and remove its own reference to `files`
-        // so that the reference counter to `files` now drops to 1.
-        self.set_file_set(db).to(Arc::new(FxHashSet::default()));
-
-        let files = Arc::get_mut(&mut files_arc).unwrap();
-        let removed = files.remove(&file);
-        self.set_file_set(db).to(files_arc);
-
-        removed
-    }
-
-    pub(crate) fn check(self, db: &dyn Db) -> Vec<String> {
-        let mut result = Vec::new();
-        for file in self.files(db) {
-            let diagnostics = check_file(db, *file);
-            result.extend_from_slice(&diagnostics);
-        }
-
-        result
-    }
-
-    fn from_metadata(db: &dyn Db, metadata: PackageMetadata) -> Self {
-        let files = discover_package_files(db, metadata.root());
-
-        Self::new(db, metadata.name, metadata.root, Arc::new(files))
-    }
-
-    fn update(self, db: &mut dyn Db, metadata: PackageMetadata) {
-        let root = self.root(db);
-        assert_eq!(root, metadata.root());
-
-        let files = discover_package_files(db, root);
-
-        self.set_name(db).to(metadata.name);
-        self.set_file_set(db).to(Arc::new(files));
-    }
-}
-
-pub(super) fn check_file(db: &dyn Db, file: File) -> Diagnostics {
-    let mut diagnostics = Vec::new();
-    diagnostics.extend_from_slice(lint_syntax(db, file));
-    diagnostics.extend_from_slice(lint_semantic(db, file));
-    Diagnostics::from(diagnostics)
-}
-
-fn discover_package_files(db: &dyn Db, path: &SystemPath) -> FxHashSet<File> {
-    let paths = std::sync::Mutex::new(Vec::new());
-
-    db.system().walk_directory(path).run(|| {
-        Box::new(|entry| {
-            match entry {
-                Ok(entry) => {
-                    // Skip over any non python files to avoid creating too many entries in `Files`.
-                    if entry.file_type().is_file()
-                        && entry
-                            .path()
-                            .extension()
-                            .and_then(PySourceType::try_from_extension)
-                            .is_some()
-                    {
-                        let mut paths = paths.lock().unwrap();
-                        paths.push(entry.into_path());
-                    }
-                }
-                Err(error) => {
-                    // TODO Handle error
-                    tracing::error!("Failed to walk path: {error}");
-                }
-            }
-
-            WalkState::Continue
-        })
-    });
-
-    let paths = paths.into_inner().unwrap();
-    let mut files = FxHashSet::with_capacity_and_hasher(paths.len(), FxBuildHasher);
-
-    for path in paths {
-        // If this returns `None`, then the file was deleted between the `walk_directory` call and now.
-        // We can ignore this.
-        if let Some(file) = system_path_to_file(db.upcast(), &path) {
-            files.insert(file);
-        }
-    }
-
-    files
-}

crates/red_knot/src/workspace/metadata.rs

@@ -1,68 +0,0 @@
-use ruff_db::system::{System, SystemPath, SystemPathBuf};
-use ruff_python_ast::name::Name;
-
-#[derive(Debug)]
-pub struct WorkspaceMetadata {
-    pub(super) root: SystemPathBuf,
-
-    /// The (first-party) packages in this workspace.
-    pub(super) packages: Vec<PackageMetadata>,
-}
-
-/// A first-party package in a workspace.
-#[derive(Debug)]
-pub struct PackageMetadata {
-    pub(super) name: Name,
-
-    /// The path to the root directory of the package.
-    pub(super) root: SystemPathBuf,
-    // TODO: Add the loaded package configuration (not the nested ruff settings)
-}
-
-impl WorkspaceMetadata {
-    /// Discovers the closest workspace at `path` and returns its metadata.
-    pub fn from_path(path: &SystemPath, system: &dyn System) -> anyhow::Result<WorkspaceMetadata> {
-        let root = if system.is_file(path) {
-            path.parent().unwrap().to_path_buf()
-        } else {
-            path.to_path_buf()
-        };
-
-        if !system.is_directory(&root) {
-            anyhow::bail!("no workspace found at {:?}", root);
-        }
-
-        // TODO: Discover package name from `pyproject.toml`.
-        let package_name: Name = path.file_name().unwrap_or("<root>").into();
-
-        let package = PackageMetadata {
-            name: package_name,
-            root: root.clone(),
-        };
-
-        let workspace = WorkspaceMetadata {
-            root,
-            packages: vec![package],
-        };
-
-        Ok(workspace)
-    }
-
-    pub fn root(&self) -> &SystemPath {
-        &self.root
-    }
-
-    pub fn packages(&self) -> &[PackageMetadata] {
-        &self.packages
-    }
-}
-
-impl PackageMetadata {
-    pub fn name(&self) -> &Name {
-        &self.name
-    }
-
-    pub fn root(&self) -> &SystemPath {
-        &self.root
-    }
-}

crates/red_knot_module_resolver/Cargo.toml

@@ -14,11 +14,9 @@ license = { workspace = true }
 ruff_db = { workspace = true }
 ruff_python_stdlib = { workspace = true }
 
-compact_str = { workspace = true }
-camino = { workspace = true }
-once_cell = { workspace = true }
 rustc-hash = { workspace = true }
 salsa = { workspace = true }
+smol_str = { workspace = true }
 tracing = { workspace = true }
 zip = { workspace = true }
 
@@ -28,8 +26,6 @@ walkdir = { workspace = true }
 zip = { workspace = true }
 
 [dev-dependencies]
-ruff_db = { workspace = true, features = ["os"] }
-
 anyhow = { workspace = true }
 insta = { workspace = true }
 tempfile = { workspace = true }

crates/red_knot_module_resolver/src/db.rs

@@ -1,61 +1,83 @@
 use ruff_db::Upcast;
 
 use crate::resolver::{
-    editable_install_resolution_paths, file_to_module, internal::ModuleNameIngredient,
-    module_resolution_settings, resolve_module_query,
+    file_to_module,
+    internal::{ModuleNameIngredient, ModuleResolverSearchPaths},
+    resolve_module_query,
 };
-use crate::typeshed::parse_typeshed_versions;
 
 #[salsa::jar(db=Db)]
 pub struct Jar(
     ModuleNameIngredient<'_>,
-    module_resolution_settings,
-    editable_install_resolution_paths,
+    ModuleResolverSearchPaths,
     resolve_module_query,
     file_to_module,
-    parse_typeshed_versions,
 );
 
 pub trait Db: salsa::DbWithJar<Jar> + ruff_db::Db + Upcast<dyn ruff_db::Db> {}
 
-#[cfg(test)]
 pub(crate) mod tests {
     use std::sync;
 
     use salsa::DebugWithDb;
 
-    use ruff_db::files::Files;
-    use ruff_db::system::{DbWithTestSystem, TestSystem};
-    use ruff_db::vendored::VendoredFileSystem;
-
-    use crate::vendored_typeshed_stubs;
+    use ruff_db::file_system::{FileSystem, MemoryFileSystem, OsFileSystem};
+    use ruff_db::vfs::Vfs;
 
     use super::*;
 
     #[salsa::db(Jar, ruff_db::Jar)]
     pub(crate) struct TestDb {
         storage: salsa::Storage<Self>,
-        system: TestSystem,
-        vendored: VendoredFileSystem,
-        files: Files,
+        file_system: TestFileSystem,
         events: sync::Arc<sync::Mutex<Vec<salsa::Event>>>,
+        vfs: Vfs,
     }
 
     impl TestDb {
+        #[allow(unused)]
         pub(crate) fn new() -> Self {
             Self {
                 storage: salsa::Storage::default(),
-                system: TestSystem::default(),
-                vendored: vendored_typeshed_stubs().snapshot(),
+                file_system: TestFileSystem::Memory(MemoryFileSystem::default()),
                 events: sync::Arc::default(),
-                files: Files::default(),
+                vfs: Vfs::with_stubbed_vendored(),
             }
         }
 
+        /// Returns the memory file system.
+        ///
+        /// ## Panics
+        /// If this test db isn't using a memory file system.
+        #[allow(unused)]
+        pub(crate) fn memory_file_system(&self) -> &MemoryFileSystem {
+            if let TestFileSystem::Memory(fs) = &self.file_system {
+                fs
+            } else {
+                panic!("The test db is not using a memory file system");
+            }
+        }
+
+        /// Uses the real file system instead of the memory file system.
+        ///
+        /// This useful for testing advanced file system features like permissions, symlinks, etc.
+        ///
+        /// Note that any files written to the memory file system won't be copied over.
+        #[allow(unused)]
+        pub(crate) fn with_os_file_system(&mut self) {
+            self.file_system = TestFileSystem::Os(OsFileSystem);
+        }
+
+        #[allow(unused)]
+        pub(crate) fn vfs_mut(&mut self) -> &mut Vfs {
+            &mut self.vfs
+        }
+
         /// Takes the salsa events.
         ///
         /// ## Panics
         /// If there are any pending salsa snapshots.
+        #[allow(unused)]
         pub(crate) fn take_salsa_events(&mut self) -> Vec<salsa::Event> {
             let inner = sync::Arc::get_mut(&mut self.events).expect("no pending salsa snapshots");
 
@@ -67,6 +89,7 @@ pub(crate) mod tests {
         ///
         /// ## Panics
         /// If there are any pending salsa snapshots.
+        #[allow(unused)]
         pub(crate) fn clear_salsa_events(&mut self) {
             self.take_salsa_events();
         }
@@ -79,31 +102,17 @@ pub(crate) mod tests {
     }
 
     impl ruff_db::Db for TestDb {
-        fn vendored(&self) -> &VendoredFileSystem {
-            &self.vendored
+        fn file_system(&self) -> &dyn ruff_db::file_system::FileSystem {
+            self.file_system.inner()
         }
 
-        fn system(&self) -> &dyn ruff_db::system::System {
-            &self.system
-        }
-
-        fn files(&self) -> &Files {
-            &self.files
+        fn vfs(&self) -> &ruff_db::vfs::Vfs {
+            &self.vfs
         }
     }
 
     impl Db for TestDb {}
 
-    impl DbWithTestSystem for TestDb {
-        fn test_system(&self) -> &TestSystem {
-            &self.system
-        }
-
-        fn test_system_mut(&mut self) -> &mut TestSystem {
-            &mut self.system
-        }
-    }
-
     impl salsa::Database for TestDb {
         fn salsa_event(&self, event: salsa::Event) {
             tracing::trace!("event: {:?}", event.debug(self));
@@ -116,11 +125,32 @@ pub(crate) mod tests {
         fn snapshot(&self) -> salsa::Snapshot<Self> {
             salsa::Snapshot::new(Self {
                 storage: self.storage.snapshot(),
-                system: self.system.snapshot(),
-                vendored: self.vendored.snapshot(),
-                files: self.files.snapshot(),
+                file_system: self.file_system.snapshot(),
                 events: self.events.clone(),
+                vfs: self.vfs.snapshot(),
             })
         }
     }
+
+    enum TestFileSystem {
+        Memory(MemoryFileSystem),
+        #[allow(unused)]
+        Os(OsFileSystem),
+    }
+
+    impl TestFileSystem {
+        fn inner(&self) -> &dyn FileSystem {
+            match self {
+                Self::Memory(inner) => inner,
+                Self::Os(inner) => inner,
+            }
+        }
+
+        fn snapshot(&self) -> Self {
+            match self {
+                Self::Memory(inner) => Self::Memory(inner.snapshot()),
+                Self::Os(inner) => Self::Os(inner.snapshot()),
+            }
+        }
+    }
 }

crates/red_knot_module_resolver/src/lib.rs

@@ -1,18 +1,9 @@
 mod db;
 mod module;
-mod module_name;
-mod path;
 mod resolver;
-mod state;
 mod typeshed;
 
-#[cfg(test)]
-mod testing;
-
 pub use db::{Db, Jar};
-pub use module::{Module, ModuleKind};
-pub use module_name::ModuleName;
-pub use resolver::resolve_module;
-pub use typeshed::{
-    vendored_typeshed_stubs, TypeshedVersionsParseError, TypeshedVersionsParseErrorKind,
-};
+pub use module::{ModuleKind, ModuleName};
+pub use resolver::{resolve_module, set_module_resolution_settings, ModuleResolutionSettings};
+pub use typeshed::versions::TypeshedVersions;

crates/red_knot_module_resolver/src/module.rs

@@ -1,11 +1,191 @@
 use std::fmt::Formatter;
+use std::ops::Deref;
 use std::sync::Arc;
 
-use ruff_db::files::File;
+use ruff_db::file_system::FileSystemPath;
+use ruff_db::vfs::{VfsFile, VfsPath};
+use ruff_python_stdlib::identifiers::is_identifier;
 
-use crate::db::Db;
-use crate::module_name::ModuleName;
-use crate::path::{ModuleResolutionPathBuf, ModuleResolutionPathRef};
+use crate::Db;
+
+/// A module name, e.g. `foo.bar`.
+///
+/// Always normalized to the absolute form (never a relative module name, i.e., never `.foo`).
+#[derive(Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]
+pub struct ModuleName(smol_str::SmolStr);
+
+impl ModuleName {
+    /// Creates a new module name for `name`. Returns `Some` if `name` is a valid, absolute
+    /// module name and `None` otherwise.
+    ///
+    /// The module name is invalid if:
+    ///
+    /// * The name is empty
+    /// * The name is relative
+    /// * The name ends with a `.`
+    /// * The name contains a sequence of multiple dots
+    /// * A component of a name (the part between two dots) isn't a valid python identifier.
+    #[inline]
+    pub fn new(name: &str) -> Option<Self> {
+        Self::new_from_smol(smol_str::SmolStr::new(name))
+    }
+
+    /// Creates a new module name for `name` where `name` is a static string.
+    /// Returns `Some` if `name` is a valid, absolute module name and `None` otherwise.
+    ///
+    /// The module name is invalid if:
+    ///
+    /// * The name is empty
+    /// * The name is relative
+    /// * The name ends with a `.`
+    /// * The name contains a sequence of multiple dots
+    /// * A component of a name (the part between two dots) isn't a valid python identifier.
+    ///
+    /// ## Examples
+    ///
+    /// ```
+    /// use red_knot_module_resolver::ModuleName;
+    ///
+    /// assert_eq!(ModuleName::new_static("foo.bar").as_deref(), Some("foo.bar"));
+    /// assert_eq!(ModuleName::new_static(""), None);
+    /// assert_eq!(ModuleName::new_static("..foo"), None);
+    /// assert_eq!(ModuleName::new_static(".foo"), None);
+    /// assert_eq!(ModuleName::new_static("foo."), None);
+    /// assert_eq!(ModuleName::new_static("foo..bar"), None);
+    /// assert_eq!(ModuleName::new_static("2000"), None);
+    /// ```
+    #[inline]
+    pub fn new_static(name: &'static str) -> Option<Self> {
+        Self::new_from_smol(smol_str::SmolStr::new_static(name))
+    }
+
+    fn new_from_smol(name: smol_str::SmolStr) -> Option<Self> {
+        if name.is_empty() {
+            return None;
+        }
+
+        if name.split('.').all(is_identifier) {
+            Some(Self(name))
+        } else {
+            None
+        }
+    }
+
+    /// An iterator over the components of the module name:
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use red_knot_module_resolver::ModuleName;
+    ///
+    /// assert_eq!(ModuleName::new_static("foo.bar.baz").unwrap().components().collect::<Vec<_>>(), vec!["foo", "bar", "baz"]);
+    /// ```
+    pub fn components(&self) -> impl DoubleEndedIterator<Item = &str> {
+        self.0.split('.')
+    }
+
+    /// The name of this module's immediate parent, if it has a parent.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use red_knot_module_resolver::ModuleName;
+    ///
+    /// assert_eq!(ModuleName::new_static("foo.bar").unwrap().parent(), Some(ModuleName::new_static("foo").unwrap()));
+    /// assert_eq!(ModuleName::new_static("foo.bar.baz").unwrap().parent(), Some(ModuleName::new_static("foo.bar").unwrap()));
+    /// assert_eq!(ModuleName::new_static("root").unwrap().parent(), None);
+    /// ```
+    pub fn parent(&self) -> Option<ModuleName> {
+        let (parent, _) = self.0.rsplit_once('.')?;
+
+        Some(Self(smol_str::SmolStr::new(parent)))
+    }
+
+    /// Returns `true` if the name starts with `other`.
+    ///
+    /// This is equivalent to checking if `self` is a sub-module of `other`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use red_knot_module_resolver::ModuleName;
+    ///
+    /// assert!(ModuleName::new_static("foo.bar").unwrap().starts_with(&ModuleName::new_static("foo").unwrap()));
+    ///
+    /// assert!(!ModuleName::new_static("foo.bar").unwrap().starts_with(&ModuleName::new_static("bar").unwrap()));
+    /// assert!(!ModuleName::new_static("foo_bar").unwrap().starts_with(&ModuleName::new_static("foo").unwrap()));
+    /// ```
+    pub fn starts_with(&self, other: &ModuleName) -> bool {
+        let mut self_components = self.components();
+        let other_components = other.components();
+
+        for other_component in other_components {
+            if self_components.next() != Some(other_component) {
+                return false;
+            }
+        }
+
+        true
+    }
+
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+
+    pub(crate) fn from_relative_path(path: &FileSystemPath) -> Option<Self> {
+        let path = if path.ends_with("__init__.py") || path.ends_with("__init__.pyi") {
+            path.parent()?
+        } else {
+            path
+        };
+
+        let name = if let Some(parent) = path.parent() {
+            let mut name = String::with_capacity(path.as_str().len());
+
+            for component in parent.components() {
+                name.push_str(component.as_os_str().to_str()?);
+                name.push('.');
+            }
+
+            // SAFETY: Unwrap is safe here or `parent` would have returned `None`.
+            name.push_str(path.file_stem().unwrap());
+
+            smol_str::SmolStr::from(name)
+        } else {
+            smol_str::SmolStr::new(path.file_stem()?)
+        };
+
+        Some(Self(name))
+    }
+}
+
+impl Deref for ModuleName {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.as_str()
+    }
+}
+
+impl PartialEq<str> for ModuleName {
+    fn eq(&self, other: &str) -> bool {
+        self.as_str() == other
+    }
+}
+
+impl PartialEq<ModuleName> for str {
+    fn eq(&self, other: &ModuleName) -> bool {
+        self == other.as_str()
+    }
+}
+
+impl std::fmt::Display for ModuleName {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.0)
+    }
+}
 
 /// Representation of a Python module.
 #[derive(Clone, PartialEq, Eq)]
@@ -17,8 +197,8 @@ impl Module {
     pub(crate) fn new(
         name: ModuleName,
         kind: ModuleKind,
-        search_path: Arc<ModuleResolutionPathBuf>,
-        file: File,
+        search_path: ModuleSearchPath,
+        file: VfsFile,
     ) -> Self {
         Self {
             inner: Arc::new(ModuleInner {
@@ -36,13 +216,13 @@ impl Module {
     }
 
     /// The file to the source code that defines this module
-    pub fn file(&self) -> File {
+    pub fn file(&self) -> VfsFile {
         self.inner.file
     }
 
     /// The search path from which the module was resolved.
-    pub(crate) fn search_path(&self) -> ModuleResolutionPathRef {
-        ModuleResolutionPathRef::from(&*self.inner.search_path)
+    pub fn search_path(&self) -> &ModuleSearchPath {
+        &self.inner.search_path
     }
 
     /// Determine whether this module is a single-file module or a package
@@ -77,8 +257,8 @@ impl salsa::DebugWithDb<dyn Db> for Module {
 struct ModuleInner {
     name: ModuleName,
     kind: ModuleKind,
-    search_path: Arc<ModuleResolutionPathBuf>,
-    file: File,
+    search_path: ModuleSearchPath,
+    file: VfsFile,
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
@@ -89,3 +269,78 @@ pub enum ModuleKind {
     /// A python package (`foo/__init__.py` or `foo/__init__.pyi`)
     Package,
 }
+
+/// A search path in which to search modules.
+/// Corresponds to a path in [`sys.path`](https://docs.python.org/3/library/sys_path_init.html) at runtime.
+///
+/// Cloning a search path is cheap because it's an `Arc`.
+#[derive(Clone, PartialEq, Eq)]
+pub struct ModuleSearchPath {
+    inner: Arc<ModuleSearchPathInner>,
+}
+
+impl ModuleSearchPath {
+    pub fn new<P>(path: P, kind: ModuleSearchPathKind) -> Self
+    where
+        P: Into<VfsPath>,
+    {
+        Self {
+            inner: Arc::new(ModuleSearchPathInner {
+                path: path.into(),
+                kind,
+            }),
+        }
+    }
+
+    /// Determine whether this is a first-party, third-party or standard-library search path
+    pub fn kind(&self) -> ModuleSearchPathKind {
+        self.inner.kind
+    }
+
+    /// Return the location of the search path on the file system
+    pub fn path(&self) -> &VfsPath {
+        &self.inner.path
+    }
+}
+
+impl std::fmt::Debug for ModuleSearchPath {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ModuleSearchPath")
+            .field("path", &self.inner.path)
+            .field("kind", &self.kind())
+            .finish()
+    }
+}
+
+#[derive(Eq, PartialEq)]
+struct ModuleSearchPathInner {
+    path: VfsPath,
+    kind: ModuleSearchPathKind,
+}
+
+/// Enumeration of the different kinds of search paths type checkers are expected to support.
+///
+/// N.B. Although we don't implement `Ord` for this enum, they are ordered in terms of the
+/// priority that we want to give these modules when resolving them.
+/// This is roughly [the order given in the typing spec], but typeshed's stubs
+/// for the standard library are moved higher up to match Python's semantics at runtime.
+///
+/// [the order given in the typing spec]: https://typing.readthedocs.io/en/latest/spec/distributing.html#import-resolution-ordering
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum ModuleSearchPathKind {
+    /// "Extra" paths provided by the user in a config file, env var or CLI flag.
+    /// E.g. mypy's `MYPYPATH` env var, or pyright's `stubPath` configuration setting
+    Extra,
+
+    /// Files in the project we're directly being invoked on
+    FirstParty,
+
+    /// The `stdlib` directory of typeshed (either vendored or custom)
+    StandardLibrary,
+
+    /// Stubs or runtime modules installed in site-packages
+    SitePackagesThirdParty,
+
+    /// Vendored third-party stubs from typeshed
+    VendoredThirdParty,
+}

crates/red_knot_module_resolver/src/module_name.rs

@@ -1,198 +0,0 @@
-use std::fmt;
-use std::ops::Deref;
-
-use compact_str::{CompactString, ToCompactString};
-
-use ruff_python_stdlib::identifiers::is_identifier;
-
-/// A module name, e.g. `foo.bar`.
-///
-/// Always normalized to the absolute form (never a relative module name, i.e., never `.foo`).
-#[derive(Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]
-pub struct ModuleName(compact_str::CompactString);
-
-impl ModuleName {
-    /// Creates a new module name for `name`. Returns `Some` if `name` is a valid, absolute
-    /// module name and `None` otherwise.
-    ///
-    /// The module name is invalid if:
-    ///
-    /// * The name is empty
-    /// * The name is relative
-    /// * The name ends with a `.`
-    /// * The name contains a sequence of multiple dots
-    /// * A component of a name (the part between two dots) isn't a valid python identifier.
-    #[inline]
-    #[must_use]
-    pub fn new(name: &str) -> Option<Self> {
-        Self::is_valid_name(name).then(|| Self(CompactString::from(name)))
-    }
-
-    /// Creates a new module name for `name` where `name` is a static string.
-    /// Returns `Some` if `name` is a valid, absolute module name and `None` otherwise.
-    ///
-    /// The module name is invalid if:
-    ///
-    /// * The name is empty
-    /// * The name is relative
-    /// * The name ends with a `.`
-    /// * The name contains a sequence of multiple dots
-    /// * A component of a name (the part between two dots) isn't a valid python identifier.
-    ///
-    /// ## Examples
-    ///
-    /// ```
-    /// use red_knot_module_resolver::ModuleName;
-    ///
-    /// assert_eq!(ModuleName::new_static("foo.bar").as_deref(), Some("foo.bar"));
-    /// assert_eq!(ModuleName::new_static(""), None);
-    /// assert_eq!(ModuleName::new_static("..foo"), None);
-    /// assert_eq!(ModuleName::new_static(".foo"), None);
-    /// assert_eq!(ModuleName::new_static("foo."), None);
-    /// assert_eq!(ModuleName::new_static("foo..bar"), None);
-    /// assert_eq!(ModuleName::new_static("2000"), None);
-    /// ```
-    #[inline]
-    #[must_use]
-    pub fn new_static(name: &'static str) -> Option<Self> {
-        Self::is_valid_name(name).then(|| Self(CompactString::const_new(name)))
-    }
-
-    #[must_use]
-    fn is_valid_name(name: &str) -> bool {
-        !name.is_empty() && name.split('.').all(is_identifier)
-    }
-
-    /// An iterator over the components of the module name:
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use red_knot_module_resolver::ModuleName;
-    ///
-    /// assert_eq!(ModuleName::new_static("foo.bar.baz").unwrap().components().collect::<Vec<_>>(), vec!["foo", "bar", "baz"]);
-    /// ```
-    #[must_use]
-    pub fn components(&self) -> impl DoubleEndedIterator<Item = &str> {
-        self.0.split('.')
-    }
-
-    /// The name of this module's immediate parent, if it has a parent.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use red_knot_module_resolver::ModuleName;
-    ///
-    /// assert_eq!(ModuleName::new_static("foo.bar").unwrap().parent(), Some(ModuleName::new_static("foo").unwrap()));
-    /// assert_eq!(ModuleName::new_static("foo.bar.baz").unwrap().parent(), Some(ModuleName::new_static("foo.bar").unwrap()));
-    /// assert_eq!(ModuleName::new_static("root").unwrap().parent(), None);
-    /// ```
-    #[must_use]
-    pub fn parent(&self) -> Option<ModuleName> {
-        let (parent, _) = self.0.rsplit_once('.')?;
-        Some(Self(parent.to_compact_string()))
-    }
-
-    /// Returns `true` if the name starts with `other`.
-    ///
-    /// This is equivalent to checking if `self` is a sub-module of `other`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use red_knot_module_resolver::ModuleName;
-    ///
-    /// assert!(ModuleName::new_static("foo.bar").unwrap().starts_with(&ModuleName::new_static("foo").unwrap()));
-    ///
-    /// assert!(!ModuleName::new_static("foo.bar").unwrap().starts_with(&ModuleName::new_static("bar").unwrap()));
-    /// assert!(!ModuleName::new_static("foo_bar").unwrap().starts_with(&ModuleName::new_static("foo").unwrap()));
-    /// ```
-    #[must_use]
-    pub fn starts_with(&self, other: &ModuleName) -> bool {
-        let mut self_components = self.components();
-        let other_components = other.components();
-
-        for other_component in other_components {
-            if self_components.next() != Some(other_component) {
-                return false;
-            }
-        }
-
-        true
-    }
-
-    #[must_use]
-    #[inline]
-    pub fn as_str(&self) -> &str {
-        &self.0
-    }
-
-    /// Construct a [`ModuleName`] from a sequence of parts.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use red_knot_module_resolver::ModuleName;
-    ///
-    /// assert_eq!(&*ModuleName::from_components(["a"]).unwrap(), "a");
-    /// assert_eq!(&*ModuleName::from_components(["a", "b"]).unwrap(), "a.b");
-    /// assert_eq!(&*ModuleName::from_components(["a", "b", "c"]).unwrap(), "a.b.c");
-    ///
-    /// assert_eq!(ModuleName::from_components(["a-b"]), None);
-    /// assert_eq!(ModuleName::from_components(["a", "a-b"]), None);
-    /// assert_eq!(ModuleName::from_components(["a", "b", "a-b-c"]), None);
-    /// ```
-    #[must_use]
-    pub fn from_components<'a>(components: impl IntoIterator<Item = &'a str>) -> Option<Self> {
-        let mut components = components.into_iter();
-        let first_part = components.next()?;
-        if !is_identifier(first_part) {
-            return None;
-        }
-        let name = if let Some(second_part) = components.next() {
-            if !is_identifier(second_part) {
-                return None;
-            }
-            let mut name = format!("{first_part}.{second_part}");
-            for part in components {
-                if !is_identifier(part) {
-                    return None;
-                }
-                name.push('.');
-                name.push_str(part);
-            }
-            CompactString::from(&name)
-        } else {
-            CompactString::from(first_part)
-        };
-        Some(Self(name))
-    }
-}
-
-impl Deref for ModuleName {
-    type Target = str;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        self.as_str()
-    }
-}
-
-impl PartialEq<str> for ModuleName {
-    fn eq(&self, other: &str) -> bool {
-        self.as_str() == other
-    }
-}
-
-impl PartialEq<ModuleName> for str {
-    fn eq(&self, other: &ModuleName) -> bool {
-        self == other.as_str()
-    }
-}
-
-impl std::fmt::Display for ModuleName {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&self.0)
-    }
-}

crates/red_knot_module_resolver/src/state.rs

@@ -1,30 +0,0 @@
-use ruff_db::program::TargetVersion;
-use ruff_db::system::System;
-use ruff_db::vendored::VendoredFileSystem;
-
-use crate::db::Db;
-use crate::typeshed::LazyTypeshedVersions;
-
-pub(crate) struct ResolverState<'db> {
-    pub(crate) db: &'db dyn Db,
-    pub(crate) typeshed_versions: LazyTypeshedVersions<'db>,
-    pub(crate) target_version: TargetVersion,
-}
-
-impl<'db> ResolverState<'db> {
-    pub(crate) fn new(db: &'db dyn Db, target_version: TargetVersion) -> Self {
-        Self {
-            db,
-            typeshed_versions: LazyTypeshedVersions::new(),
-            target_version,
-        }
-    }
-
-    pub(crate) fn system(&self) -> &dyn System {
-        self.db.system()
-    }
-
-    pub(crate) fn vendored(&self) -> &VendoredFileSystem {
-        self.db.vendored()
-    }
-}

crates/red_knot_module_resolver/src/testing.rs

@@ -1,289 +0,0 @@
-use ruff_db::program::{Program, SearchPathSettings, TargetVersion};
-use ruff_db::system::{DbWithTestSystem, SystemPath, SystemPathBuf};
-use ruff_db::vendored::VendoredPathBuf;
-
-use crate::db::tests::TestDb;
-
-/// A test case for the module resolver.
-///
-/// You generally shouldn't construct instances of this struct directly;
-/// instead, use the [`TestCaseBuilder`].
-pub(crate) struct TestCase<T> {
-    pub(crate) db: TestDb,
-    pub(crate) src: SystemPathBuf,
-    pub(crate) stdlib: T,
-    pub(crate) site_packages: SystemPathBuf,
-    pub(crate) target_version: TargetVersion,
-}
-
-/// A `(file_name, file_contents)` tuple
-pub(crate) type FileSpec = (&'static str, &'static str);
-
-/// Specification for a typeshed mock to be created as part of a test
-#[derive(Debug, Clone, Copy, Default)]
-pub(crate) struct MockedTypeshed {
-    /// The stdlib files to be created in the typeshed mock
-    pub(crate) stdlib_files: &'static [FileSpec],
-
-    /// The contents of the `stdlib/VERSIONS` file
-    /// to be created in the typeshed mock
-    pub(crate) versions: &'static str,
-}
-
-#[derive(Debug)]
-pub(crate) struct VendoredTypeshed;
-
-#[derive(Debug)]
-pub(crate) struct UnspecifiedTypeshed;
-
-/// A builder for a module-resolver test case.
-///
-/// The builder takes care of creating a [`TestDb`]
-/// instance, applying the module resolver settings,
-/// and creating mock directories for the stdlib, `site-packages`,
-/// first-party code, etc.
-///
-/// For simple tests that do not involve typeshed,
-/// test cases can be created as follows:
-///
-/// ```rs
-/// let test_case = TestCaseBuilder::new()
-///     .with_src_files(...)
-///     .build();
-///
-/// let test_case2 = TestCaseBuilder::new()
-///     .with_site_packages_files(...)
-///     .build();
-/// ```
-///
-/// Any tests can specify the target Python version that should be used
-/// in the module resolver settings:
-///
-/// ```rs
-/// let test_case = TestCaseBuilder::new()
-///     .with_src_files(...)
-///     .with_target_version(...)
-///     .build();
-/// ```
-///
-/// For tests checking that standard-library module resolution is working
-/// correctly, you should usually create a [`MockedTypeshed`] instance
-/// and pass it to the [`TestCaseBuilder::with_custom_typeshed`] method.
-/// If you need to check something that involves the vendored typeshed stubs
-/// we include as part of the binary, you can instead use the
-/// [`TestCaseBuilder::with_vendored_typeshed`] method.
-/// For either of these, you should almost always try to be explicit
-/// about the Python version you want to be specified in the module-resolver
-/// settings for the test:
-///
-/// ```rs
-/// const TYPESHED = MockedTypeshed { ... };
-///
-/// let test_case = resolver_test_case()
-///     .with_custom_typeshed(TYPESHED)
-///     .with_target_version(...)
-///     .build();
-///
-/// let test_case2 = resolver_test_case()
-///     .with_vendored_typeshed()
-///     .with_target_version(...)
-///     .build();
-/// ```
-///
-/// If you have not called one of those options, the `stdlib` field
-/// on the [`TestCase`] instance created from `.build()` will be set
-/// to `()`.
-pub(crate) struct TestCaseBuilder<T> {
-    typeshed_option: T,
-    target_version: TargetVersion,
-    first_party_files: Vec<FileSpec>,
-    site_packages_files: Vec<FileSpec>,
-}
-
-impl<T> TestCaseBuilder<T> {
-    /// Specify files to be created in the `src` mock directory
-    pub(crate) fn with_src_files(mut self, files: &[FileSpec]) -> Self {
-        self.first_party_files.extend(files.iter().copied());
-        self
-    }
-
-    /// Specify files to be created in the `site-packages` mock directory
-    pub(crate) fn with_site_packages_files(mut self, files: &[FileSpec]) -> Self {
-        self.site_packages_files.extend(files.iter().copied());
-        self
-    }
-
-    /// Specify the target Python version the module resolver should assume
-    pub(crate) fn with_target_version(mut self, target_version: TargetVersion) -> Self {
-        self.target_version = target_version;
-        self
-    }
-
-    fn write_mock_directory(
-        db: &mut TestDb,
-        location: impl AsRef<SystemPath>,
-        files: impl IntoIterator<Item = FileSpec>,
-    ) -> SystemPathBuf {
-        let root = location.as_ref().to_path_buf();
-        db.write_files(
-            files
-                .into_iter()
-                .map(|(relative_path, contents)| (root.join(relative_path), contents)),
-        )
-        .unwrap();
-        root
-    }
-}
-
-impl TestCaseBuilder<UnspecifiedTypeshed> {
-    pub(crate) fn new() -> TestCaseBuilder<UnspecifiedTypeshed> {
-        Self {
-            typeshed_option: UnspecifiedTypeshed,
-            target_version: TargetVersion::default(),
-            first_party_files: vec![],
-            site_packages_files: vec![],
-        }
-    }
-
-    /// Use the vendored stdlib stubs included in the Ruff binary for this test case
-    pub(crate) fn with_vendored_typeshed(self) -> TestCaseBuilder<VendoredTypeshed> {
-        let TestCaseBuilder {
-            typeshed_option: _,
-            target_version,
-            first_party_files,
-            site_packages_files,
-        } = self;
-        TestCaseBuilder {
-            typeshed_option: VendoredTypeshed,
-            target_version,
-            first_party_files,
-            site_packages_files,
-        }
-    }
-
-    /// Use a mock typeshed directory for this test case
-    pub(crate) fn with_custom_typeshed(
-        self,
-        typeshed: MockedTypeshed,
-    ) -> TestCaseBuilder<MockedTypeshed> {
-        let TestCaseBuilder {
-            typeshed_option: _,
-            target_version,
-            first_party_files,
-            site_packages_files,
-        } = self;
-        TestCaseBuilder {
-            typeshed_option: typeshed,
-            target_version,
-            first_party_files,
-            site_packages_files,
-        }
-    }
-
-    pub(crate) fn build(self) -> TestCase<()> {
-        let TestCase {
-            db,
-            src,
-            stdlib: _,
-            site_packages,
-            target_version,
-        } = self.with_custom_typeshed(MockedTypeshed::default()).build();
-        TestCase {
-            db,
-            src,
-            stdlib: (),
-            site_packages,
-            target_version,
-        }
-    }
-}
-
-impl TestCaseBuilder<MockedTypeshed> {
-    pub(crate) fn build(self) -> TestCase<SystemPathBuf> {
-        let TestCaseBuilder {
-            typeshed_option,
-            target_version,
-            first_party_files,
-            site_packages_files,
-        } = self;
-
-        let mut db = TestDb::new();
-
-        let site_packages =
-            Self::write_mock_directory(&mut db, "/site-packages", site_packages_files);
-        let src = Self::write_mock_directory(&mut db, "/src", first_party_files);
-        let typeshed = Self::build_typeshed_mock(&mut db, &typeshed_option);
-
-        Program::new(
-            &db,
-            target_version,
-            SearchPathSettings {
-                extra_paths: vec![],
-                workspace_root: src.clone(),
-                custom_typeshed: Some(typeshed.clone()),
-                site_packages: Some(site_packages.clone()),
-            },
-        );
-
-        TestCase {
-            db,
-            src,
-            stdlib: typeshed.join("stdlib"),
-            site_packages,
-            target_version,
-        }
-    }
-
-    fn build_typeshed_mock(db: &mut TestDb, typeshed_to_build: &MockedTypeshed) -> SystemPathBuf {
-        let typeshed = SystemPathBuf::from("/typeshed");
-        let MockedTypeshed {
-            stdlib_files,
-            versions,
-        } = typeshed_to_build;
-        Self::write_mock_directory(
-            db,
-            typeshed.join("stdlib"),
-            stdlib_files
-                .iter()
-                .copied()
-                .chain(std::iter::once(("VERSIONS", *versions))),
-        );
-        typeshed
-    }
-}
-
-impl TestCaseBuilder<VendoredTypeshed> {
-    pub(crate) fn build(self) -> TestCase<VendoredPathBuf> {
-        let TestCaseBuilder {
-            typeshed_option: VendoredTypeshed,
-            target_version,
-            first_party_files,
-            site_packages_files,
-        } = self;
-
-        let mut db = TestDb::new();
-
-        let site_packages =
-            Self::write_mock_directory(&mut db, "/site-packages", site_packages_files);
-        let src = Self::write_mock_directory(&mut db, "/src", first_party_files);
-
-        Program::new(
-            &db,
-            target_version,
-            SearchPathSettings {
-                extra_paths: vec![],
-                workspace_root: src.clone(),
-                custom_typeshed: None,
-                site_packages: Some(site_packages.clone()),
-            },
-        );
-
-        TestCase {
-            db,
-            src,
-            stdlib: VendoredPathBuf::from("stdlib"),
-            site_packages,
-            target_version,
-        }
-    }
-}

crates/red_knot_module_resolver/src/typeshed.rs

@@ -1,8 +1,91 @@
-pub use self::vendored::vendored_typeshed_stubs;
-pub(crate) use self::versions::{
-    parse_typeshed_versions, LazyTypeshedVersions, TypeshedVersionsQueryResult,
-};
-pub use self::versions::{TypeshedVersionsParseError, TypeshedVersionsParseErrorKind};
+pub(crate) mod versions;
 
-mod vendored;
-mod versions;
+#[cfg(test)]
+mod tests {
+    use std::io::{self, Read};
+    use std::path::Path;
+
+    use ruff_db::vendored::VendoredFileSystem;
+    use ruff_db::vfs::VendoredPath;
+
+    // The file path here is hardcoded in this crate's `build.rs` script.
+    // Luckily this crate will fail to build if this file isn't available at build time.
+    const TYPESHED_ZIP_BYTES: &[u8] =
+        include_bytes!(concat!(env!("OUT_DIR"), "/zipped_typeshed.zip"));
+
+    #[test]
+    fn typeshed_zip_created_at_build_time() {
+        let mut typeshed_zip_archive =
+            zip::ZipArchive::new(io::Cursor::new(TYPESHED_ZIP_BYTES)).unwrap();
+
+        let mut functools_module_stub = typeshed_zip_archive
+            .by_name("stdlib/functools.pyi")
+            .unwrap();
+        assert!(functools_module_stub.is_file());
+
+        let mut functools_module_stub_source = String::new();
+        functools_module_stub
+            .read_to_string(&mut functools_module_stub_source)
+            .unwrap();
+
+        assert!(functools_module_stub_source.contains("def update_wrapper("));
+    }
+
+    #[test]
+    fn typeshed_vfs_consistent_with_vendored_stubs() {
+        let vendored_typeshed_dir = Path::new("vendor/typeshed").canonicalize().unwrap();
+        let vendored_typeshed_stubs = VendoredFileSystem::new(TYPESHED_ZIP_BYTES).unwrap();
+
+        let mut empty_iterator = true;
+        for entry in walkdir::WalkDir::new(&vendored_typeshed_dir).min_depth(1) {
+            empty_iterator = false;
+            let entry = entry.unwrap();
+            let absolute_path = entry.path();
+            let file_type = entry.file_type();
+
+            let relative_path = absolute_path
+                .strip_prefix(&vendored_typeshed_dir)
+                .unwrap_or_else(|_| {
+                    panic!("Expected {absolute_path:?} to be a child of {vendored_typeshed_dir:?}")
+                });
+
+            let vendored_path = <&VendoredPath>::try_from(relative_path)
+                .unwrap_or_else(|_| panic!("Expected {relative_path:?} to be valid UTF-8"));
+
+            assert!(
+                vendored_typeshed_stubs.exists(vendored_path),
+                "Expected {vendored_path:?} to exist in the `VendoredFileSystem`!
+
+                Vendored file system:
+
+                {vendored_typeshed_stubs:#?}
+                "
+            );
+
+            let vendored_path_kind = vendored_typeshed_stubs
+                .metadata(vendored_path)
+                .unwrap_or_else(|| {
+                    panic!(
+                        "Expected metadata for {vendored_path:?} to be retrievable from the `VendoredFileSystem!
+
+                        Vendored file system:
+
+                        {vendored_typeshed_stubs:#?}
+                        "
+                    )
+                })
+                .kind();
+
+            assert_eq!(
+                vendored_path_kind.is_directory(),
+                file_type.is_dir(),
+                "{vendored_path:?} had type {vendored_path_kind:?}, inconsistent with fs path {relative_path:?}: {file_type:?}"
+            );
+        }
+
+        assert!(
+            !empty_iterator,
+            "Expected there to be at least one file or directory in the vendored typeshed stubs!"
+        );
+    }
+}

crates/red_knot_module_resolver/src/typeshed/vendored.rs

@@ -1,99 +0,0 @@
-use once_cell::sync::Lazy;
-
-use ruff_db::vendored::VendoredFileSystem;
-
-// The file path here is hardcoded in this crate's `build.rs` script.
-// Luckily this crate will fail to build if this file isn't available at build time.
-static TYPESHED_ZIP_BYTES: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/zipped_typeshed.zip"));
-
-pub fn vendored_typeshed_stubs() -> &'static VendoredFileSystem {
-    static VENDORED_TYPESHED_STUBS: Lazy<VendoredFileSystem> =
-        Lazy::new(|| VendoredFileSystem::new_static(TYPESHED_ZIP_BYTES).unwrap());
-    &VENDORED_TYPESHED_STUBS
-}
-
-#[cfg(test)]
-mod tests {
-    use std::io::{self, Read};
-    use std::path::Path;
-
-    use ruff_db::vendored::VendoredPath;
-
-    use super::*;
-
-    #[test]
-    fn typeshed_zip_created_at_build_time() {
-        let mut typeshed_zip_archive =
-            zip::ZipArchive::new(io::Cursor::new(TYPESHED_ZIP_BYTES)).unwrap();
-
-        let mut functools_module_stub = typeshed_zip_archive
-            .by_name("stdlib/functools.pyi")
-            .unwrap();
-        assert!(functools_module_stub.is_file());
-
-        let mut functools_module_stub_source = String::new();
-        functools_module_stub
-            .read_to_string(&mut functools_module_stub_source)
-            .unwrap();
-
-        assert!(functools_module_stub_source.contains("def update_wrapper("));
-    }
-
-    #[test]
-    fn typeshed_vfs_consistent_with_vendored_stubs() {
-        let vendored_typeshed_dir = Path::new("vendor/typeshed").canonicalize().unwrap();
-        let vendored_typeshed_stubs = vendored_typeshed_stubs();
-
-        let mut empty_iterator = true;
-        for entry in walkdir::WalkDir::new(&vendored_typeshed_dir).min_depth(1) {
-            empty_iterator = false;
-            let entry = entry.unwrap();
-            let absolute_path = entry.path();
-            let file_type = entry.file_type();
-
-            let relative_path = absolute_path
-                .strip_prefix(&vendored_typeshed_dir)
-                .unwrap_or_else(|_| {
-                    panic!("Expected {absolute_path:?} to be a child of {vendored_typeshed_dir:?}")
-                });
-
-            let vendored_path = <&VendoredPath>::try_from(relative_path)
-                .unwrap_or_else(|_| panic!("Expected {relative_path:?} to be valid UTF-8"));
-
-            assert!(
-                vendored_typeshed_stubs.exists(vendored_path),
-                "Expected {vendored_path:?} to exist in the `VendoredFileSystem`!
-
-                Vendored file system:
-
-                {vendored_typeshed_stubs:#?}
-                "
-            );
-
-            let vendored_path_kind = vendored_typeshed_stubs
-                .metadata(vendored_path)
-                .unwrap_or_else(|_| {
-                    panic!(
-                        "Expected metadata for {vendored_path:?} to be retrievable from the `VendoredFileSystem!
-
-                        Vendored file system:
-
-                        {vendored_typeshed_stubs:#?}
-                        "
-                    )
-                })
-                .kind();
-
-            assert_eq!(
-                vendored_path_kind.is_directory(),
-                file_type.is_dir(),
-                "{vendored_path:?} had type {vendored_path_kind:?}, inconsistent with fs path {relative_path:?}: {file_type:?}"
-            );
-        }
-
-        assert!(
-            !empty_iterator,
-            "Expected there to be at least one file or directory in the vendored typeshed stubs!"
-        );
-    }
-}

crates/red_knot_module_resolver/src/typeshed/versions.rs

@@ -1,97 +1,16 @@
-use std::cell::OnceCell;
 use std::collections::BTreeMap;
 use std::fmt;
 use std::num::{NonZeroU16, NonZeroUsize};
 use std::ops::{RangeFrom, RangeInclusive};
 use std::str::FromStr;
 
-use once_cell::sync::Lazy;
-use ruff_db::program::TargetVersion;
-use ruff_db::system::SystemPath;
 use rustc_hash::FxHashMap;
 
-use ruff_db::files::{system_path_to_file, File};
+use crate::module::ModuleName;
 
-use crate::db::Db;
-use crate::module_name::ModuleName;
-
-use super::vendored::vendored_typeshed_stubs;
-
-#[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: TargetVersion,
-    ) -> 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 Some(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, PyVersion::from(target_version))
-    }
-}
-
-#[salsa::tracked(return_ref)]
-pub(crate) fn parse_typeshed_versions(
-    db: &dyn Db,
-    versions_file: File,
-) -> Result<TypeshedVersions, TypeshedVersionsParseError> {
-    // TODO: Handle IO errors
-    let file_content = versions_file
-        .read_to_string(db.upcast())
-        .unwrap_or_default();
-    file_content.parse()
-}
-
-static VENDORED_VERSIONS: Lazy<TypeshedVersions> = Lazy::new(|| {
-    TypeshedVersions::from_str(
-        &vendored_typeshed_stubs()
-            .read_to_string("stdlib/VERSIONS")
-            .unwrap(),
-    )
-    .unwrap()
-});
-
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct TypeshedVersionsParseError {
-    line_number: Option<NonZeroU16>,
+    line_number: NonZeroU16,
     reason: TypeshedVersionsParseErrorKind,
 }
 
@@ -101,14 +20,10 @@ impl fmt::Display for TypeshedVersionsParseError {
             line_number,
             reason,
         } = self;
-        if let Some(line_number) = line_number {
-            write!(
-                f,
-                "Error while parsing line {line_number} of typeshed's VERSIONS file: {reason}"
-            )
-        } else {
-            write!(f, "Error while parsing typeshed's VERSIONS file: {reason}")
-        }
+        write!(
+            f,
+            "Error while parsing line {line_number} of typeshed's VERSIONS file: {reason}"
+        )
     }
 }
 
@@ -122,7 +37,7 @@ impl std::error::Error for TypeshedVersionsParseError {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum TypeshedVersionsParseErrorKind {
     TooManyLines(NonZeroUsize),
     UnexpectedNumberOfColons,
@@ -166,94 +81,38 @@ impl fmt::Display for TypeshedVersionsParseErrorKind {
 }
 
 #[derive(Debug, PartialEq, Eq)]
-pub(crate) struct TypeshedVersions(FxHashMap<ModuleName, PyVersionRange>);
+pub struct TypeshedVersions(FxHashMap<ModuleName, PyVersionRange>);
 
 impl TypeshedVersions {
-    #[must_use]
-    fn exact(&self, module_name: &ModuleName) -> Option<&PyVersionRange> {
-        self.0.get(module_name)
+    pub fn len(&self) -> usize {
+        self.0.len()
     }
 
-    #[must_use]
-    fn query_module(
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    pub fn contains_module(&self, module_name: &ModuleName) -> bool {
+        self.0.contains_key(module_name)
+    }
+
+    pub fn module_exists_on_version(
         &self,
-        module: &ModuleName,
-        target_version: PyVersion,
-    ) -> TypeshedVersionsQueryResult {
-        if let Some(range) = self.exact(module) {
-            if range.contains(target_version) {
-                TypeshedVersionsQueryResult::Exists
-            } else {
-                TypeshedVersionsQueryResult::DoesNotExist
+        module: ModuleName,
+        version: impl Into<PyVersion>,
+    ) -> bool {
+        let version = version.into();
+        let mut module: Option<ModuleName> = Some(module);
+        while let Some(module_to_try) = module {
+            if let Some(range) = self.0.get(&module_to_try) {
+                return range.contains(version);
             }
-        } else {
-            let mut module = module.parent();
-            while let Some(module_to_try) = module {
-                if let Some(range) = self.exact(&module_to_try) {
-                    return {
-                        if range.contains(target_version) {
-                            TypeshedVersionsQueryResult::MaybeExists
-                        } else {
-                            TypeshedVersionsQueryResult::DoesNotExist
-                        }
-                    };
-                }
-                module = module_to_try.parent();
-            }
-            TypeshedVersionsQueryResult::DoesNotExist
+            module = module_to_try.parent();
         }
+        false
     }
 }
 
-/// Possible answers [`LazyTypeshedVersions::query_module()`] could give to the question:
-/// "Does this module exist in the stdlib at runtime on a certain target version?"
-#[derive(Debug, Copy, PartialEq, Eq, Clone, Hash)]
-pub(crate) enum TypeshedVersionsQueryResult {
-    /// The module definitely exists in the stdlib at runtime on the user-specified target version.
-    ///
-    /// For example:
-    /// - The target version is Python 3.8
-    /// - We're querying whether the `asyncio.tasks` module exists in the stdlib
-    /// - The VERSIONS file contains the line `asyncio.tasks: 3.8-`
-    Exists,
-
-    /// The module definitely does not exist in the stdlib on the user-specified target version.
-    ///
-    /// For example:
-    /// - We're querying whether the `foo` module exists in the stdlib
-    /// - There is no top-level `foo` module in VERSIONS
-    ///
-    /// OR:
-    /// - The target version is Python 3.8
-    /// - We're querying whether the module `importlib.abc` exists in the stdlib
-    /// - The VERSIONS file contains the line `importlib.abc: 3.10-`,
-    ///   indicating that the module was added in 3.10
-    ///
-    /// OR:
-    /// - The target version is Python 3.8
-    /// - We're querying whether the module `collections.abc` exists in the stdlib
-    /// - The VERSIONS file does not contain any information about the `collections.abc` submodule,
-    ///   but *does* contain the line `collections: 3.10-`,
-    ///   indicating that the entire `collections` package was added in Python 3.10.
-    DoesNotExist,
-
-    /// The module potentially exists in the stdlib and, if it does,
-    /// it definitely exists on the user-specified target version.
-    ///
-    /// This variant is only relevant for submodules,
-    /// for which the typeshed VERSIONS file does not provide comprehensive information.
-    /// (The VERSIONS file is guaranteed to provide information about all top-level stdlib modules and packages,
-    /// but not necessarily about all submodules within each top-level package.)
-    ///
-    /// For example:
-    /// - The target version is Python 3.8
-    /// - We're querying whether the `asyncio.staggered` module exists in the stdlib
-    /// - The typeshed VERSIONS file contains the line `asyncio: 3.8`,
-    ///   indicating that the `asyncio` package was added in Python 3.8,
-    ///   but does not contain any explicit information about the `asyncio.staggered` submodule.
-    MaybeExists,
-}
-
 impl FromStr for TypeshedVersions {
     type Err = TypeshedVersionsParseError;
 
@@ -266,7 +125,7 @@ impl FromStr for TypeshedVersions {
 
             let Ok(line_number) = NonZeroU16::try_from(line_number) else {
                 return Err(TypeshedVersionsParseError {
-                    line_number: None,
+                    line_number: NonZeroU16::MAX,
                     reason: TypeshedVersionsParseErrorKind::TooManyLines(line_number),
                 });
             };
@@ -282,14 +141,14 @@ impl FromStr for TypeshedVersions {
             let (Some(module_name), Some(rest), None) = (parts.next(), parts.next(), parts.next())
             else {
                 return Err(TypeshedVersionsParseError {
-                    line_number: Some(line_number),
+                    line_number,
                     reason: TypeshedVersionsParseErrorKind::UnexpectedNumberOfColons,
                 });
             };
 
             let Some(module_name) = ModuleName::new(module_name) else {
                 return Err(TypeshedVersionsParseError {
-                    line_number: Some(line_number),
+                    line_number,
                     reason: TypeshedVersionsParseErrorKind::InvalidModuleName(
                         module_name.to_string(),
                     ),
@@ -300,7 +159,7 @@ impl FromStr for TypeshedVersions {
                 Ok(version) => map.insert(module_name, version),
                 Err(reason) => {
                     return Err(TypeshedVersionsParseError {
-                        line_number: Some(line_number),
+                        line_number,
                         reason,
                     })
                 }
@@ -321,14 +180,13 @@ impl fmt::Display for TypeshedVersions {
     }
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 enum PyVersionRange {
     AvailableFrom(RangeFrom<PyVersion>),
     AvailableWithin(RangeInclusive<PyVersion>),
 }
 
 impl PyVersionRange {
-    #[must_use]
     fn contains(&self, version: PyVersion) -> bool {
         match self {
             Self::AvailableFrom(inner) => inner.contains(&version),
@@ -364,7 +222,7 @@ impl fmt::Display for PyVersionRange {
 }
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
-struct PyVersion {
+pub struct PyVersion {
     major: u8,
     minor: u8,
 }
@@ -408,25 +266,38 @@ impl fmt::Display for PyVersion {
     }
 }
 
-impl From<TargetVersion> for PyVersion {
-    fn from(value: TargetVersion) -> Self {
+// TODO: unify with the PythonVersion enum in the linter/formatter crates?
+#[derive(Copy, Clone, Hash, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
+pub enum SupportedPyVersion {
+    Py37,
+    #[default]
+    Py38,
+    Py39,
+    Py310,
+    Py311,
+    Py312,
+    Py313,
+}
+
+impl From<SupportedPyVersion> for PyVersion {
+    fn from(value: SupportedPyVersion) -> Self {
         match value {
-            TargetVersion::Py37 => PyVersion { major: 3, minor: 7 },
-            TargetVersion::Py38 => PyVersion { major: 3, minor: 8 },
-            TargetVersion::Py39 => PyVersion { major: 3, minor: 9 },
-            TargetVersion::Py310 => PyVersion {
+            SupportedPyVersion::Py37 => PyVersion { major: 3, minor: 7 },
+            SupportedPyVersion::Py38 => PyVersion { major: 3, minor: 8 },
+            SupportedPyVersion::Py39 => PyVersion { major: 3, minor: 9 },
+            SupportedPyVersion::Py310 => PyVersion {
                 major: 3,
                 minor: 10,
             },
-            TargetVersion::Py311 => PyVersion {
+            SupportedPyVersion::Py311 => PyVersion {
                 major: 3,
                 minor: 11,
             },
-            TargetVersion::Py312 => PyVersion {
+            SupportedPyVersion::Py312 => PyVersion {
                 major: 3,
                 minor: 12,
             },
-            TargetVersion::Py313 => PyVersion {
+            SupportedPyVersion::Py313 => PyVersion {
                 major: 3,
                 minor: 13,
             },
@@ -439,27 +310,14 @@ mod tests {
     use std::num::{IntErrorKind, NonZeroU16};
     use std::path::Path;
 
-    use insta::assert_snapshot;
-    use ruff_db::program::TargetVersion;
-
     use super::*;
 
+    use insta::assert_snapshot;
+
     const TYPESHED_STDLIB_DIR: &str = "stdlib";
 
     #[allow(unsafe_code)]
-    const ONE: Option<NonZeroU16> = Some(unsafe { NonZeroU16::new_unchecked(1) });
-
-    impl TypeshedVersions {
-        #[must_use]
-        fn contains_exact(&self, module: &ModuleName) -> bool {
-            self.exact(module).is_some()
-        }
-
-        #[must_use]
-        fn len(&self) -> usize {
-            self.0.len()
-        }
-    }
+    const ONE: NonZeroU16 = unsafe { NonZeroU16::new_unchecked(1) };
 
     #[test]
     fn can_parse_vendored_versions_file() {
@@ -476,31 +334,18 @@ mod tests {
         let asyncio_staggered = ModuleName::new_static("asyncio.staggered").unwrap();
         let audioop = ModuleName::new_static("audioop").unwrap();
 
-        assert!(versions.contains_exact(&asyncio));
-        assert_eq!(
-            versions.query_module(&asyncio, TargetVersion::Py310.into()),
-            TypeshedVersionsQueryResult::Exists
-        );
+        assert!(versions.contains_module(&asyncio));
+        assert!(versions.module_exists_on_version(asyncio, SupportedPyVersion::Py310));
 
-        assert!(versions.contains_exact(&asyncio_staggered));
-        assert_eq!(
-            versions.query_module(&asyncio_staggered, TargetVersion::Py38.into()),
-            TypeshedVersionsQueryResult::Exists
-        );
-        assert_eq!(
-            versions.query_module(&asyncio_staggered, TargetVersion::Py37.into()),
-            TypeshedVersionsQueryResult::DoesNotExist
+        assert!(versions.contains_module(&asyncio_staggered));
+        assert!(
+            versions.module_exists_on_version(asyncio_staggered.clone(), SupportedPyVersion::Py38)
         );
+        assert!(!versions.module_exists_on_version(asyncio_staggered, SupportedPyVersion::Py37));
 
-        assert!(versions.contains_exact(&audioop));
-        assert_eq!(
-            versions.query_module(&audioop, TargetVersion::Py312.into()),
-            TypeshedVersionsQueryResult::Exists
-        );
-        assert_eq!(
-            versions.query_module(&audioop, TargetVersion::Py313.into()),
-            TypeshedVersionsQueryResult::DoesNotExist
-        );
+        assert!(versions.contains_module(&audioop));
+        assert!(versions.module_exists_on_version(audioop.clone(), SupportedPyVersion::Py312));
+        assert!(!versions.module_exists_on_version(audioop, SupportedPyVersion::Py313));
     }
 
     #[test]
@@ -548,7 +393,7 @@ mod tests {
             let top_level_module = ModuleName::new(top_level_module)
                 .unwrap_or_else(|| panic!("{top_level_module:?} was not a valid module name!"));
 
-            assert!(vendored_typeshed_versions.contains_exact(&top_level_module));
+            assert!(vendored_typeshed_versions.contains_module(&top_level_module));
         }
 
         assert!(
@@ -581,102 +426,30 @@ foo: 3.8-   # trailing comment
         foo: 3.8-
         "###
         );
-    }
 
-    #[test]
-    fn version_within_range_parsed_correctly() {
-        let parsed_versions = TypeshedVersions::from_str("bar: 2.7-3.10").unwrap();
-        let bar = ModuleName::new_static("bar").unwrap();
-
-        assert!(parsed_versions.contains_exact(&bar));
-        assert_eq!(
-            parsed_versions.query_module(&bar, TargetVersion::Py37.into()),
-            TypeshedVersionsQueryResult::Exists
-        );
-        assert_eq!(
-            parsed_versions.query_module(&bar, TargetVersion::Py310.into()),
-            TypeshedVersionsQueryResult::Exists
-        );
-        assert_eq!(
-            parsed_versions.query_module(&bar, TargetVersion::Py311.into()),
-            TypeshedVersionsQueryResult::DoesNotExist
-        );
-    }
-
-    #[test]
-    fn version_from_range_parsed_correctly() {
-        let parsed_versions = TypeshedVersions::from_str("foo: 3.8-").unwrap();
         let foo = ModuleName::new_static("foo").unwrap();
-
-        assert!(parsed_versions.contains_exact(&foo));
-        assert_eq!(
-            parsed_versions.query_module(&foo, TargetVersion::Py37.into()),
-            TypeshedVersionsQueryResult::DoesNotExist
-        );
-        assert_eq!(
-            parsed_versions.query_module(&foo, TargetVersion::Py38.into()),
-            TypeshedVersionsQueryResult::Exists
-        );
-        assert_eq!(
-            parsed_versions.query_module(&foo, TargetVersion::Py311.into()),
-            TypeshedVersionsQueryResult::Exists
-        );
-    }
-
-    #[test]
-    fn explicit_submodule_parsed_correctly() {
-        let parsed_versions = TypeshedVersions::from_str("bar.baz: 3.1-3.9").unwrap();
+        let bar = ModuleName::new_static("bar").unwrap();
         let bar_baz = ModuleName::new_static("bar.baz").unwrap();
-
-        assert!(parsed_versions.contains_exact(&bar_baz));
-        assert_eq!(
-            parsed_versions.query_module(&bar_baz, TargetVersion::Py37.into()),
-            TypeshedVersionsQueryResult::Exists
-        );
-        assert_eq!(
-            parsed_versions.query_module(&bar_baz, TargetVersion::Py39.into()),
-            TypeshedVersionsQueryResult::Exists
-        );
-        assert_eq!(
-            parsed_versions.query_module(&bar_baz, TargetVersion::Py310.into()),
-            TypeshedVersionsQueryResult::DoesNotExist
-        );
-    }
-
-    #[test]
-    fn implicit_submodule_queried_correctly() {
-        let parsed_versions = TypeshedVersions::from_str("bar: 2.7-3.10").unwrap();
-        let bar_eggs = ModuleName::new_static("bar.eggs").unwrap();
-
-        assert!(!parsed_versions.contains_exact(&bar_eggs));
-        assert_eq!(
-            parsed_versions.query_module(&bar_eggs, TargetVersion::Py37.into()),
-            TypeshedVersionsQueryResult::MaybeExists
-        );
-        assert_eq!(
-            parsed_versions.query_module(&bar_eggs, TargetVersion::Py310.into()),
-            TypeshedVersionsQueryResult::MaybeExists
-        );
-        assert_eq!(
-            parsed_versions.query_module(&bar_eggs, TargetVersion::Py311.into()),
-            TypeshedVersionsQueryResult::DoesNotExist
-        );
-    }
-
-    #[test]
-    fn nonexistent_module_queried_correctly() {
-        let parsed_versions = TypeshedVersions::from_str("eggs: 3.8-").unwrap();
         let spam = ModuleName::new_static("spam").unwrap();
 
-        assert!(!parsed_versions.contains_exact(&spam));
-        assert_eq!(
-            parsed_versions.query_module(&spam, TargetVersion::Py37.into()),
-            TypeshedVersionsQueryResult::DoesNotExist
-        );
-        assert_eq!(
-            parsed_versions.query_module(&spam, TargetVersion::Py313.into()),
-            TypeshedVersionsQueryResult::DoesNotExist
-        );
+        assert!(parsed_versions.contains_module(&foo));
+        assert!(!parsed_versions.module_exists_on_version(foo.clone(), SupportedPyVersion::Py37));
+        assert!(parsed_versions.module_exists_on_version(foo.clone(), SupportedPyVersion::Py38));
+        assert!(parsed_versions.module_exists_on_version(foo, SupportedPyVersion::Py311));
+
+        assert!(parsed_versions.contains_module(&bar));
+        assert!(parsed_versions.module_exists_on_version(bar.clone(), SupportedPyVersion::Py37));
+        assert!(parsed_versions.module_exists_on_version(bar.clone(), SupportedPyVersion::Py310));
+        assert!(!parsed_versions.module_exists_on_version(bar, SupportedPyVersion::Py311));
+
+        assert!(parsed_versions.contains_module(&bar_baz));
+        assert!(parsed_versions.module_exists_on_version(bar_baz.clone(), SupportedPyVersion::Py37));
+        assert!(parsed_versions.module_exists_on_version(bar_baz.clone(), SupportedPyVersion::Py39));
+        assert!(!parsed_versions.module_exists_on_version(bar_baz, SupportedPyVersion::Py310));
+
+        assert!(!parsed_versions.contains_module(&spam));
+        assert!(!parsed_versions.module_exists_on_version(spam.clone(), SupportedPyVersion::Py37));
+        assert!(!parsed_versions.module_exists_on_version(spam, SupportedPyVersion::Py313));
     }
 
     #[test]
@@ -692,7 +465,7 @@ foo: 3.8-   # trailing comment
         assert_eq!(
             TypeshedVersions::from_str(&massive_versions_file),
             Err(TypeshedVersionsParseError {
-                line_number: None,
+                line_number: NonZeroU16::MAX,
                 reason: TypeshedVersionsParseErrorKind::TooManyLines(
                     NonZeroUsize::new(too_many + 1 - offset).unwrap()
                 )

crates/red_knot_module_resolver/vendor/typeshed/source_commit.txt

@@ -1 +1 @@
-f863db6bc5242348ceaa6a3bca4e59aa9e62faaa
+114409d49b43ba62a179ebb856fa70a5161f751e

crates/red_knot_module_resolver/vendor/typeshed/stdlib/VERSIONS

@@ -34,9 +34,6 @@ _dummy_thread: 3.0-3.8
 _dummy_threading: 3.0-3.8
 _heapq: 3.0-
 _imp: 3.0-
-_interpchannels: 3.13-
-_interpqueues: 3.13-
-_interpreters: 3.13-
 _json: 3.0-
 _locale: 3.0-
 _lsprof: 3.0-
@@ -114,7 +111,6 @@ curses: 3.0-
 dataclasses: 3.7-
 datetime: 3.0-
 dbm: 3.0-
-dbm.sqlite3: 3.13-
 decimal: 3.0-
 difflib: 3.0-
 dis: 3.0-
@@ -158,7 +154,6 @@ importlib: 3.0-
 importlib._abc: 3.10-
 importlib.metadata: 3.8-
 importlib.metadata._meta: 3.10-
-importlib.metadata.diagnose: 3.13-
 importlib.readers: 3.10-
 importlib.resources: 3.7-
 importlib.resources.abc: 3.11-

crates/red_knot_module_resolver/vendor/typeshed/stdlib/_collections_abc.pyi

@@ -70,8 +70,6 @@ _VT_co = TypeVar("_VT_co", covariant=True)  # Value type covariant containers.
 @final
 class dict_keys(KeysView[_KT_co], Generic[_KT_co, _VT_co]):  # undocumented
     def __eq__(self, value: object, /) -> bool: ...
-    if sys.version_info >= (3, 13):
-        def isdisjoint(self, other: Iterable[_KT_co], /) -> bool: ...
     if sys.version_info >= (3, 10):
         @property
         def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
@@ -85,8 +83,6 @@ class dict_values(ValuesView[_VT_co], Generic[_KT_co, _VT_co]):  # undocumented
 @final
 class dict_items(ItemsView[_KT_co, _VT_co]):  # undocumented
     def __eq__(self, value: object, /) -> bool: ...
-    if sys.version_info >= (3, 13):
-        def isdisjoint(self, other: Iterable[tuple[_KT_co, _VT_co]], /) -> bool: ...
     if sys.version_info >= (3, 10):
         @property
         def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/_ctypes.pyi

@@ -64,6 +64,7 @@ class _CData(metaclass=_CDataMeta):
     # Structure.from_buffer(...)  # valid at runtime
     # Structure(...).from_buffer(...)  # invalid at runtime
     #
+
     @classmethod
     def from_buffer(cls, source: WriteableBuffer, offset: int = ...) -> Self: ...
     @classmethod
@@ -99,8 +100,8 @@ class _Pointer(_PointerLike, _CData, Generic[_CT]):
     def __getitem__(self, key: slice, /) -> list[Any]: ...
     def __setitem__(self, key: int, value: Any, /) -> None: ...
 
-def POINTER(type: type[_CT], /) -> type[_Pointer[_CT]]: ...
-def pointer(obj: _CT, /) -> _Pointer[_CT]: ...
+def POINTER(type: type[_CT]) -> type[_Pointer[_CT]]: ...
+def pointer(arg: _CT, /) -> _Pointer[_CT]: ...
 
 class _CArgObject: ...
 
@@ -202,9 +203,9 @@ class Array(_CData, Generic[_CT]):
     if sys.version_info >= (3, 9):
         def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-def addressof(obj: _CData, /) -> int: ...
-def alignment(obj_or_type: _CData | type[_CData], /) -> int: ...
+def addressof(obj: _CData) -> int: ...
+def alignment(obj_or_type: _CData | type[_CData]) -> int: ...
 def get_errno() -> int: ...
-def resize(obj: _CData, size: int, /) -> None: ...
-def set_errno(value: int, /) -> int: ...
-def sizeof(obj_or_type: _CData | type[_CData], /) -> int: ...
+def resize(obj: _CData, size: int) -> None: ...
+def set_errno(value: int) -> int: ...
+def sizeof(obj_or_type: _CData | type[_CData]) -> int: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/_interpchannels.pyi

@@ -1,84 +0,0 @@
-from _typeshed import structseq
-from typing import Final, Literal, SupportsIndex, final
-from typing_extensions import Buffer, Self
-
-class ChannelError(RuntimeError): ...
-class ChannelClosedError(ChannelError): ...
-class ChannelEmptyError(ChannelError): ...
-class ChannelNotEmptyError(ChannelError): ...
-class ChannelNotFoundError(ChannelError): ...
-
-# Mark as final, since instantiating ChannelID is not supported.
-@final
-class ChannelID:
-    @property
-    def end(self) -> Literal["send", "recv", "both"]: ...
-    @property
-    def send(self) -> Self: ...
-    @property
-    def recv(self) -> Self: ...
-    def __eq__(self, other: object) -> bool: ...
-    def __ge__(self, other: ChannelID) -> bool: ...
-    def __gt__(self, other: ChannelID) -> bool: ...
-    def __hash__(self) -> int: ...
-    def __index__(self) -> int: ...
-    def __int__(self) -> int: ...
-    def __le__(self, other: ChannelID) -> bool: ...
-    def __lt__(self, other: ChannelID) -> bool: ...
-    def __ne__(self, other: object) -> bool: ...
-
-@final
-class ChannelInfo(structseq[int], tuple[bool, bool, bool, int, int, int, int, int]):
-    __match_args__: Final = (
-        "open",
-        "closing",
-        "closed",
-        "count",
-        "num_interp_send",
-        "num_interp_send_released",
-        "num_interp_recv",
-        "num_interp_recv_released",
-    )
-    @property
-    def open(self) -> bool: ...
-    @property
-    def closing(self) -> bool: ...
-    @property
-    def closed(self) -> bool: ...
-    @property
-    def count(self) -> int: ...  # type: ignore[override]
-    @property
-    def num_interp_send(self) -> int: ...
-    @property
-    def num_interp_send_released(self) -> int: ...
-    @property
-    def num_interp_recv(self) -> int: ...
-    @property
-    def num_interp_recv_released(self) -> int: ...
-    @property
-    def num_interp_both(self) -> int: ...
-    @property
-    def num_interp_both_recv_released(self) -> int: ...
-    @property
-    def num_interp_both_send_released(self) -> int: ...
-    @property
-    def num_interp_both_released(self) -> int: ...
-    @property
-    def recv_associated(self) -> bool: ...
-    @property
-    def recv_released(self) -> bool: ...
-    @property
-    def send_associated(self) -> bool: ...
-    @property
-    def send_released(self) -> bool: ...
-
-def create() -> ChannelID: ...
-def destroy(cid: SupportsIndex) -> None: ...
-def list_all() -> list[ChannelID]: ...
-def list_interpreters(cid: SupportsIndex, *, send: bool) -> list[int]: ...
-def send(cid: SupportsIndex, obj: object, *, blocking: bool = True, timeout: float | None = None) -> None: ...
-def send_buffer(cid: SupportsIndex, obj: Buffer, *, blocking: bool = True, timeout: float | None = None) -> None: ...
-def recv(cid: SupportsIndex, default: object = ...) -> object: ...
-def close(cid: SupportsIndex, *, send: bool = False, recv: bool = False) -> None: ...
-def get_info(cid: SupportsIndex) -> ChannelInfo: ...
-def release(cid: SupportsIndex, *, send: bool = False, recv: bool = False, force: bool = False) -> None: ...

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

@@ -1,16 +0,0 @@
-from typing import Any, SupportsIndex
-
-class QueueError(RuntimeError): ...
-class QueueNotFoundError(QueueError): ...
-
-def bind(qid: SupportsIndex) -> None: ...
-def create(maxsize: SupportsIndex, fmt: SupportsIndex) -> int: ...
-def destroy(qid: SupportsIndex) -> None: ...
-def get(qid: SupportsIndex) -> tuple[Any, int]: ...
-def get_count(qid: SupportsIndex) -> int: ...
-def get_maxsize(qid: SupportsIndex) -> int: ...
-def get_queue_defaults(qid: SupportsIndex) -> tuple[int]: ...
-def is_full(qid: SupportsIndex) -> bool: ...
-def list_all() -> list[tuple[int, int]]: ...
-def put(qid: SupportsIndex, obj: Any, fmt: SupportsIndex) -> None: ...
-def release(qid: SupportsIndex) -> None: ...

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

@@ -1,50 +0,0 @@
-import types
-from collections.abc import Callable, Mapping
-from typing import Final, Literal, SupportsIndex
-from typing_extensions import TypeAlias
-
-_Configs: TypeAlias = Literal["default", "isolated", "legacy", "empty", ""]
-
-class InterpreterError(Exception): ...
-class InterpreterNotFoundError(InterpreterError): ...
-class NotShareableError(Exception): ...
-
-class CrossInterpreterBufferView:
-    def __buffer__(self, flags: int, /) -> memoryview: ...
-
-def new_config(name: _Configs = "isolated", /, **overides: object) -> types.SimpleNamespace: ...
-def create(config: types.SimpleNamespace | _Configs | None = "isolated", *, reqrefs: bool = False) -> int: ...
-def destroy(id: SupportsIndex, *, restrict: bool = False) -> None: ...
-def list_all(*, require_ready: bool) -> list[tuple[int, int]]: ...
-def get_current() -> tuple[int, int]: ...
-def get_main() -> tuple[int, int]: ...
-def is_running(id: SupportsIndex, *, restrict: bool = False) -> bool: ...
-def get_config(id: SupportsIndex, *, restrict: bool = False) -> types.SimpleNamespace: ...
-def whence(id: SupportsIndex) -> int: ...
-def exec(id: SupportsIndex, code: str, shared: bool | None = None, *, restrict: bool = False) -> None: ...
-def call(
-    id: SupportsIndex,
-    callable: Callable[..., object],
-    args: tuple[object, ...] | None = None,
-    kwargs: dict[str, object] | None = None,
-    *,
-    restrict: bool = False,
-) -> object: ...
-def run_string(
-    id: SupportsIndex, script: str | types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
-) -> None: ...
-def run_func(
-    id: SupportsIndex, func: types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
-) -> None: ...
-def set___main___attrs(id: SupportsIndex, updates: Mapping[str, object], *, restrict: bool = False) -> None: ...
-def incref(id: SupportsIndex, *, implieslink: bool = False, restrict: bool = False) -> None: ...
-def decref(id: SupportsIndex, *, restrict: bool = False) -> None: ...
-def is_shareable(obj: object) -> bool: ...
-def capture_exception(exc: BaseException | None = None) -> types.SimpleNamespace: ...
-
-WHENCE_UNKNOWN: Final = 0
-WHENCE_RUNTIME: Final = 1
-WHENCE_LEGACY_CAPI: Final = 2
-WHENCE_CAPI: Final = 3
-WHENCE_XI: Final = 4
-WHENCE_STDLIB: Final = 5

crates/red_knot_module_resolver/vendor/typeshed/stdlib/_thread.pyi

@@ -13,7 +13,7 @@ error = RuntimeError
 def _count() -> int: ...
 @final
 class LockType:
-    def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
     def release(self) -> None: ...
     def locked(self) -> bool: ...
     def __enter__(self) -> bool: ...
@@ -22,14 +22,14 @@ class LockType:
     ) -> None: ...
 
 @overload
-def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int: ...
+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 start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any]) -> int: ...
 def interrupt_main() -> None: ...
 def exit() -> NoReturn: ...
 def allocate_lock() -> LockType: ...
 def get_ident() -> int: ...
-def stack_size(size: int = 0, /) -> int: ...
+def stack_size(size: int = ...) -> int: ...
 
 TIMEOUT_MAX: float
 

crates/red_knot_module_resolver/vendor/typeshed/stdlib/_weakref.pyi

@@ -21,9 +21,8 @@ class ProxyType(Generic[_T]):  # "weakproxy"
     def __getattr__(self, attr: str) -> Any: ...
 
 class ReferenceType(Generic[_T]):
-    __callback__: Callable[[Self], Any]
-    def __new__(cls, o: _T, callback: Callable[[Self], Any] | None = ..., /) -> Self: ...
-    def __init__(self, o: _T, callback: Callable[[Self], Any] | None = ..., /) -> None: ...
+    __callback__: Callable[[ReferenceType[_T]], Any]
+    def __new__(cls, o: _T, callback: Callable[[ReferenceType[_T]], Any] | None = ..., /) -> Self: ...
     def __call__(self) -> _T | None: ...
     def __eq__(self, value: object, /) -> bool: ...
     def __hash__(self) -> int: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/abc.pyi

@@ -28,17 +28,17 @@ class ABCMeta(type):
     def register(cls: ABCMeta, subclass: type[_T]) -> type[_T]: ...
 
 def abstractmethod(funcobj: _FuncT) -> _FuncT: ...
-@deprecated("Use 'classmethod' with 'abstractmethod' instead")
+@deprecated("Deprecated, use 'classmethod' with 'abstractmethod' instead")
 class abstractclassmethod(classmethod[_T, _P, _R_co]):
     __isabstractmethod__: Literal[True]
     def __init__(self, callable: Callable[Concatenate[type[_T], _P], _R_co]) -> None: ...
 
-@deprecated("Use 'staticmethod' with 'abstractmethod' instead")
+@deprecated("Deprecated, use 'staticmethod' with 'abstractmethod' instead")
 class abstractstaticmethod(staticmethod[_P, _R_co]):
     __isabstractmethod__: Literal[True]
     def __init__(self, callable: Callable[_P, _R_co]) -> None: ...
 
-@deprecated("Use 'property' with 'abstractmethod' instead")
+@deprecated("Deprecated, use 'property' with 'abstractmethod' instead")
 class abstractproperty(property):
     __isabstractmethod__: Literal[True]
 

crates/red_knot_module_resolver/vendor/typeshed/stdlib/argparse.pyi

@@ -32,7 +32,6 @@ _T = TypeVar("_T")
 _ActionT = TypeVar("_ActionT", bound=Action)
 _ArgumentParserT = TypeVar("_ArgumentParserT", bound=ArgumentParser)
 _N = TypeVar("_N")
-_ActionType: TypeAlias = Callable[[str], Any] | FileType | str
 # more precisely, Literal["store", "store_const", "store_true",
 # "store_false", "append", "append_const", "count", "help", "version",
 # "extend"], but using this would make it hard to annotate callers
@@ -90,7 +89,7 @@ class _ActionsContainer:
         nargs: int | _NArgsStr | _SUPPRESS_T | None = None,
         const: Any = ...,
         default: Any = ...,
-        type: _ActionType = ...,
+        type: Callable[[str], _T] | FileType = ...,
         choices: Iterable[_T] | None = ...,
         required: bool = ...,
         help: str | None = ...,
@@ -314,7 +313,7 @@ class Action(_AttributeHolder):
     nargs: int | str | None
     const: Any
     default: Any
-    type: _ActionType | None
+    type: Callable[[str], Any] | FileType | None
     choices: Iterable[Any] | None
     required: bool
     help: str | None
@@ -700,7 +699,6 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             add_help: bool = ...,
             allow_abbrev: bool = ...,
             exit_on_error: bool = ...,
-            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
     elif sys.version_info >= (3, 9):
         def add_parser(
@@ -723,7 +721,6 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             add_help: bool = ...,
             allow_abbrev: bool = ...,
             exit_on_error: bool = ...,
-            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
     else:
         def add_parser(
@@ -745,7 +742,6 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             conflict_handler: str = ...,
             add_help: bool = ...,
             allow_abbrev: bool = ...,
-            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
 
     def _get_subactions(self) -> list[Action]: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/base_events.pyi

@@ -49,10 +49,6 @@ class Server(AbstractServer):
             ssl_handshake_timeout: float | None,
         ) -> None: ...
 
-    if sys.version_info >= (3, 13):
-        def close_clients(self) -> None: ...
-        def abort_clients(self) -> None: ...
-
     def get_loop(self) -> AbstractEventLoop: ...
     def is_serving(self) -> bool: ...
     async def start_serving(self) -> None: ...
@@ -226,121 +222,43 @@ class BaseEventLoop(AbstractEventLoop):
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
-
-    if sys.version_info >= (3, 13):
-        # 3.13 added `keep_alive`.
-        @overload
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: str | Sequence[str] | None = None,
-            port: int = ...,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: None = None,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            keep_alive: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-        @overload
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: None = None,
-            port: None = None,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: socket = ...,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            keep_alive: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-    elif sys.version_info >= (3, 11):
-        @overload
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: str | Sequence[str] | None = None,
-            port: int = ...,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: None = None,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-        @overload
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: None = None,
-            port: None = None,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: socket = ...,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-    else:
-        @overload
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: str | Sequence[str] | None = None,
-            port: int = ...,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: None = None,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-        @overload
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: None = None,
-            port: None = None,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: socket = ...,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-
     if sys.version_info >= (3, 11):
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str | Sequence[str] | None = None,
+            port: int = ...,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: None = None,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = None,
+            port: None = None,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: socket = ...,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
         async def start_tls(
             self,
             transport: BaseTransport,
@@ -362,6 +280,40 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_shutdown_timeout: float | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
     else:
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str | Sequence[str] | None = None,
+            port: int = ...,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: None = None,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = None,
+            port: None = None,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: socket = ...,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
         async def start_tls(
             self,
             transport: BaseTransport,

crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/events.pyi

@@ -16,40 +16,23 @@ from .tasks import Task
 from .transports import BaseTransport, DatagramTransport, ReadTransport, SubprocessTransport, Transport, WriteTransport
 from .unix_events import AbstractChildWatcher
 
-if sys.version_info >= (3, 14):
-    __all__ = (
-        "AbstractEventLoopPolicy",
-        "AbstractEventLoop",
-        "AbstractServer",
-        "Handle",
-        "TimerHandle",
-        "get_event_loop_policy",
-        "set_event_loop_policy",
-        "get_event_loop",
-        "set_event_loop",
-        "new_event_loop",
-        "_set_running_loop",
-        "get_running_loop",
-        "_get_running_loop",
-    )
-else:
-    __all__ = (
-        "AbstractEventLoopPolicy",
-        "AbstractEventLoop",
-        "AbstractServer",
-        "Handle",
-        "TimerHandle",
-        "get_event_loop_policy",
-        "set_event_loop_policy",
-        "get_event_loop",
-        "set_event_loop",
-        "new_event_loop",
-        "get_child_watcher",
-        "set_child_watcher",
-        "_set_running_loop",
-        "get_running_loop",
-        "_get_running_loop",
-    )
+__all__ = (
+    "AbstractEventLoopPolicy",
+    "AbstractEventLoop",
+    "AbstractServer",
+    "Handle",
+    "TimerHandle",
+    "get_event_loop_policy",
+    "set_event_loop_policy",
+    "get_event_loop",
+    "set_event_loop",
+    "new_event_loop",
+    "get_child_watcher",
+    "set_child_watcher",
+    "_set_running_loop",
+    "get_running_loop",
+    "_get_running_loop",
+)
 
 _T = TypeVar("_T")
 _Ts = TypeVarTuple("_Ts")
@@ -94,12 +77,6 @@ class TimerHandle(Handle):
 class AbstractServer:
     @abstractmethod
     def close(self) -> None: ...
-    if sys.version_info >= (3, 13):
-        @abstractmethod
-        def close_clients(self) -> None: ...
-        @abstractmethod
-        def abort_clients(self) -> None: ...
-
     async def __aenter__(self) -> Self: ...
     async def __aexit__(self, *exc: Unused) -> None: ...
     @abstractmethod
@@ -278,127 +255,45 @@ class AbstractEventLoop:
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
-
-    if sys.version_info >= (3, 13):
-        # 3.13 added `keep_alive`.
-        @overload
-        @abstractmethod
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: str | Sequence[str] | None = None,
-            port: int = ...,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: None = None,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            keep_alive: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-        @overload
-        @abstractmethod
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: None = None,
-            port: None = None,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: socket = ...,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            keep_alive: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-    elif sys.version_info >= (3, 11):
-        @overload
-        @abstractmethod
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: str | Sequence[str] | None = None,
-            port: int = ...,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: None = None,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-        @overload
-        @abstractmethod
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: None = None,
-            port: None = None,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: socket = ...,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-    else:
-        @overload
-        @abstractmethod
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: str | Sequence[str] | None = None,
-            port: int = ...,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: None = None,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-        @overload
-        @abstractmethod
-        async def create_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            host: None = None,
-            port: None = None,
-            *,
-            family: int = ...,
-            flags: int = ...,
-            sock: socket = ...,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            reuse_address: bool | None = None,
-            reuse_port: bool | None = None,
-            ssl_handshake_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
-
     if sys.version_info >= (3, 11):
+        @overload
+        @abstractmethod
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str | Sequence[str] | None = None,
+            port: int = ...,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: None = None,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+        @overload
+        @abstractmethod
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = None,
+            port: None = None,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: socket = ...,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
         @abstractmethod
         async def start_tls(
             self,
@@ -424,6 +319,42 @@ class AbstractEventLoop:
             start_serving: bool = True,
         ) -> Server: ...
     else:
+        @overload
+        @abstractmethod
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str | Sequence[str] | None = None,
+            port: int = ...,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: None = None,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+        @overload
+        @abstractmethod
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = None,
+            port: None = None,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: socket = ...,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
         @abstractmethod
         async def start_tls(
             self,
@@ -446,7 +377,6 @@ class AbstractEventLoop:
             ssl_handshake_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
-
     if sys.version_info >= (3, 11):
         async def connect_accepted_socket(
             self,
@@ -611,19 +541,18 @@ class AbstractEventLoopPolicy:
     @abstractmethod
     def new_event_loop(self) -> AbstractEventLoop: ...
     # Child processes handling (Unix only).
-    if sys.version_info < (3, 14):
-        if sys.version_info >= (3, 12):
-            @abstractmethod
-            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-            def get_child_watcher(self) -> AbstractChildWatcher: ...
-            @abstractmethod
-            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-            def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
-        else:
-            @abstractmethod
-            def get_child_watcher(self) -> AbstractChildWatcher: ...
-            @abstractmethod
-            def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
+    if sys.version_info >= (3, 12):
+        @abstractmethod
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        def get_child_watcher(self) -> AbstractChildWatcher: ...
+        @abstractmethod
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
+    else:
+        @abstractmethod
+        def get_child_watcher(self) -> AbstractChildWatcher: ...
+        @abstractmethod
+        def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
 
 class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy, metaclass=ABCMeta):
     def get_event_loop(self) -> AbstractEventLoop: ...
@@ -636,16 +565,15 @@ def get_event_loop() -> AbstractEventLoop: ...
 def set_event_loop(loop: AbstractEventLoop | None) -> None: ...
 def new_event_loop() -> AbstractEventLoop: ...
 
-if sys.version_info < (3, 14):
-    if sys.version_info >= (3, 12):
-        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-        def get_child_watcher() -> AbstractChildWatcher: ...
-        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-        def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
+if sys.version_info >= (3, 12):
+    @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+    def get_child_watcher() -> AbstractChildWatcher: ...
+    @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+    def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
 
-    else:
-        def get_child_watcher() -> AbstractChildWatcher: ...
-        def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
+else:
+    def get_child_watcher() -> AbstractChildWatcher: ...
+    def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
 
 def _set_running_loop(loop: AbstractEventLoop | None, /) -> None: ...
 def _get_running_loop() -> AbstractEventLoop: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/format_helpers.pyi

@@ -1,5 +1,4 @@
 import functools
-import sys
 import traceback
 from collections.abc import Iterable
 from types import FrameType, FunctionType
@@ -15,17 +14,7 @@ _FuncType: TypeAlias = FunctionType | _HasWrapper | functools.partial[Any] | fun
 def _get_function_source(func: _FuncType) -> tuple[str, int]: ...
 @overload
 def _get_function_source(func: object) -> tuple[str, int] | None: ...
-
-if sys.version_info >= (3, 13):
-    def _format_callback_source(func: object, args: Iterable[Any], *, debug: bool = False) -> str: ...
-    def _format_args_and_kwargs(args: Iterable[Any], kwargs: dict[str, Any], *, debug: bool = False) -> str: ...
-    def _format_callback(
-        func: object, args: Iterable[Any], kwargs: dict[str, Any], *, debug: bool = False, suffix: str = ""
-    ) -> str: ...
-
-else:
-    def _format_callback_source(func: object, args: Iterable[Any]) -> str: ...
-    def _format_args_and_kwargs(args: Iterable[Any], kwargs: dict[str, Any]) -> str: ...
-    def _format_callback(func: object, args: Iterable[Any], kwargs: dict[str, Any], suffix: str = "") -> str: ...
-
+def _format_callback_source(func: object, args: Iterable[Any]) -> str: ...
+def _format_args_and_kwargs(args: Iterable[Any], kwargs: dict[str, Any]) -> str: ...
+def _format_callback(func: object, args: Iterable[Any], kwargs: dict[str, Any], suffix: str = "") -> str: ...
 def extract_stack(f: FrameType | None = None, limit: int | None = None) -> traceback.StackSummary: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/queues.pyi

@@ -10,20 +10,13 @@ if sys.version_info >= (3, 10):
 else:
     _LoopBoundMixin = object
 
+__all__ = ("Queue", "PriorityQueue", "LifoQueue", "QueueFull", "QueueEmpty")
+
 class QueueEmpty(Exception): ...
 class QueueFull(Exception): ...
 
-if sys.version_info >= (3, 13):
-    __all__ = ("Queue", "PriorityQueue", "LifoQueue", "QueueFull", "QueueEmpty", "QueueShutDown")
-
-else:
-    __all__ = ("Queue", "PriorityQueue", "LifoQueue", "QueueFull", "QueueEmpty")
-
 _T = TypeVar("_T")
 
-if sys.version_info >= (3, 13):
-    class QueueShutDown(Exception): ...
-
 # If Generic[_T] is last and _LoopBoundMixin is object, pyright is unhappy.
 # We can remove the noqa pragma when dropping 3.9 support.
 class Queue(Generic[_T], _LoopBoundMixin):  # noqa: Y059
@@ -49,8 +42,6 @@ class Queue(Generic[_T], _LoopBoundMixin):  # noqa: Y059
     def task_done(self) -> None: ...
     if sys.version_info >= (3, 9):
         def __class_getitem__(cls, type: Any, /) -> GenericAlias: ...
-    if sys.version_info >= (3, 13):
-        def shutdown(self, immediate: bool = False) -> None: ...
 
 class PriorityQueue(Queue[_T]): ...
 class LifoQueue(Queue[_T]): ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/streams.pyi

@@ -2,7 +2,6 @@ import ssl
 import sys
 from _typeshed import ReadableBuffer, StrPath
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence, Sized
-from types import ModuleType
 from typing import Any, Protocol, SupportsIndex
 from typing_extensions import Self, TypeAlias
 
@@ -131,10 +130,7 @@ class StreamWriter:
         async def start_tls(
             self, sslcontext: ssl.SSLContext, *, server_hostname: str | None = None, ssl_handshake_timeout: float | None = None
         ) -> None: ...
-
-    if sys.version_info >= (3, 13):
-        def __del__(self, warnings: ModuleType = ...) -> None: ...
-    elif sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 11):
         def __del__(self) -> None: ...
 
 class StreamReader(AsyncIterator[bytes]):

crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/tasks.pyi

@@ -70,10 +70,7 @@ _T4 = TypeVar("_T4")
 _T5 = TypeVar("_T5")
 _T6 = TypeVar("_T6")
 _FT = TypeVar("_FT", bound=Future[Any])
-if sys.version_info >= (3, 12):
-    _FutureLike: TypeAlias = Future[_T] | Awaitable[_T]
-else:
-    _FutureLike: TypeAlias = Future[_T] | Generator[Any, None, _T] | Awaitable[_T]
+_FutureLike: TypeAlias = Future[_T] | Generator[Any, None, _T] | Awaitable[_T]
 _TaskYieldType: TypeAlias = Future[object] | None
 
 FIRST_COMPLETED = concurrent.futures.FIRST_COMPLETED

crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/unix_events.pyi

@@ -1,251 +1,196 @@
 import sys
 import types
-from _typeshed import StrPath
 from abc import ABCMeta, abstractmethod
 from collections.abc import Callable
-from socket import socket
 from typing import Literal
 from typing_extensions import Self, TypeVarTuple, Unpack, deprecated
 
-from .base_events import Server, _ProtocolFactory, _SSLContext
 from .events import AbstractEventLoop, BaseDefaultEventLoopPolicy
 from .selector_events import BaseSelectorEventLoop
 
 _Ts = TypeVarTuple("_Ts")
 
-if sys.platform != "win32":
-    if sys.version_info >= (3, 14):
-        __all__ = ("SelectorEventLoop", "DefaultEventLoopPolicy", "EventLoop")
-    elif sys.version_info >= (3, 13):
-        __all__ = (
-            "SelectorEventLoop",
-            "AbstractChildWatcher",
-            "SafeChildWatcher",
-            "FastChildWatcher",
-            "PidfdChildWatcher",
-            "MultiLoopChildWatcher",
-            "ThreadedChildWatcher",
-            "DefaultEventLoopPolicy",
-            "EventLoop",
-        )
-    elif sys.version_info >= (3, 9):
-        __all__ = (
-            "SelectorEventLoop",
-            "AbstractChildWatcher",
-            "SafeChildWatcher",
-            "FastChildWatcher",
-            "PidfdChildWatcher",
-            "MultiLoopChildWatcher",
-            "ThreadedChildWatcher",
-            "DefaultEventLoopPolicy",
-        )
-    else:
-        __all__ = (
-            "SelectorEventLoop",
-            "AbstractChildWatcher",
-            "SafeChildWatcher",
-            "FastChildWatcher",
-            "MultiLoopChildWatcher",
-            "ThreadedChildWatcher",
-            "DefaultEventLoopPolicy",
-        )
-
 # This is also technically not available on Win,
 # but other parts of typeshed need this definition.
 # So, it is special cased.
-if sys.version_info < (3, 14):
-    if sys.version_info >= (3, 12):
-        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-        class AbstractChildWatcher:
-            @abstractmethod
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            @abstractmethod
-            def remove_child_handler(self, pid: int) -> bool: ...
-            @abstractmethod
-            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-            @abstractmethod
-            def close(self) -> None: ...
-            @abstractmethod
-            def __enter__(self) -> Self: ...
-            @abstractmethod
-            def __exit__(
-                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
-            ) -> None: ...
-            @abstractmethod
-            def is_active(self) -> bool: ...
+if sys.version_info >= (3, 12):
+    @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+    class AbstractChildWatcher:
+        @abstractmethod
+        def add_child_handler(
+            self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+        ) -> None: ...
+        @abstractmethod
+        def remove_child_handler(self, pid: int) -> bool: ...
+        @abstractmethod
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+        @abstractmethod
+        def close(self) -> None: ...
+        @abstractmethod
+        def __enter__(self) -> Self: ...
+        @abstractmethod
+        def __exit__(
+            self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+        ) -> None: ...
+        @abstractmethod
+        def is_active(self) -> bool: ...
 
-    else:
-        class AbstractChildWatcher:
-            @abstractmethod
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            @abstractmethod
-            def remove_child_handler(self, pid: int) -> bool: ...
-            @abstractmethod
-            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-            @abstractmethod
-            def close(self) -> None: ...
-            @abstractmethod
-            def __enter__(self) -> Self: ...
-            @abstractmethod
-            def __exit__(
-                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
-            ) -> None: ...
-            @abstractmethod
-            def is_active(self) -> bool: ...
+else:
+    class AbstractChildWatcher:
+        @abstractmethod
+        def add_child_handler(
+            self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+        ) -> None: ...
+        @abstractmethod
+        def remove_child_handler(self, pid: int) -> bool: ...
+        @abstractmethod
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+        @abstractmethod
+        def close(self) -> None: ...
+        @abstractmethod
+        def __enter__(self) -> Self: ...
+        @abstractmethod
+        def __exit__(
+            self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+        ) -> None: ...
+        @abstractmethod
+        def is_active(self) -> bool: ...
 
 if sys.platform != "win32":
-    if sys.version_info < (3, 14):
-        if sys.version_info >= (3, 12):
-            # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
-            # See discussion in #7412
-            class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
-                def close(self) -> None: ...
-                def is_active(self) -> bool: ...
-                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+    if sys.version_info >= (3, 9):
+        __all__ = (
+            "SelectorEventLoop",
+            "AbstractChildWatcher",
+            "SafeChildWatcher",
+            "FastChildWatcher",
+            "PidfdChildWatcher",
+            "MultiLoopChildWatcher",
+            "ThreadedChildWatcher",
+            "DefaultEventLoopPolicy",
+        )
+    else:
+        __all__ = (
+            "SelectorEventLoop",
+            "AbstractChildWatcher",
+            "SafeChildWatcher",
+            "FastChildWatcher",
+            "MultiLoopChildWatcher",
+            "ThreadedChildWatcher",
+            "DefaultEventLoopPolicy",
+        )
 
-            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-            class SafeChildWatcher(BaseChildWatcher):
-                def __enter__(self) -> Self: ...
-                def __exit__(
-                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
-                ) -> None: ...
-                def add_child_handler(
-                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-                ) -> None: ...
-                def remove_child_handler(self, pid: int) -> bool: ...
+    # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
+    # See discussion in #7412
+    class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
+        def close(self) -> None: ...
+        def is_active(self) -> bool: ...
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
 
-            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-            class FastChildWatcher(BaseChildWatcher):
-                def __enter__(self) -> Self: ...
-                def __exit__(
-                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
-                ) -> None: ...
-                def add_child_handler(
-                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-                ) -> None: ...
-                def remove_child_handler(self, pid: int) -> bool: ...
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class SafeChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
 
-        else:
-            # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
-            # See discussion in #7412
-            class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
-                def close(self) -> None: ...
-                def is_active(self) -> bool: ...
-                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class FastChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
 
-            class SafeChildWatcher(BaseChildWatcher):
-                def __enter__(self) -> Self: ...
-                def __exit__(
-                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
-                ) -> None: ...
-                def add_child_handler(
-                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-                ) -> None: ...
-                def remove_child_handler(self, pid: int) -> bool: ...
+    else:
+        class SafeChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
 
-            class FastChildWatcher(BaseChildWatcher):
-                def __enter__(self) -> Self: ...
-                def __exit__(
-                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
-                ) -> None: ...
-                def add_child_handler(
-                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-                ) -> None: ...
-                def remove_child_handler(self, pid: int) -> bool: ...
+        class FastChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
 
-    class _UnixSelectorEventLoop(BaseSelectorEventLoop):
-        if sys.version_info >= (3, 13):
-            async def create_unix_server(  # type: ignore[override]
-                self,
-                protocol_factory: _ProtocolFactory,
-                path: StrPath | None = None,
-                *,
-                sock: socket | None = None,
-                backlog: int = 100,
-                ssl: _SSLContext = None,
-                ssl_handshake_timeout: float | None = None,
-                ssl_shutdown_timeout: float | None = None,
-                start_serving: bool = True,
-                cleanup_socket: bool = True,
-            ) -> Server: ...
+    class _UnixSelectorEventLoop(BaseSelectorEventLoop): ...
 
     class _UnixDefaultEventLoopPolicy(BaseDefaultEventLoopPolicy):
-        if sys.version_info < (3, 14):
-            if sys.version_info >= (3, 12):
-                @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-                def get_child_watcher(self) -> AbstractChildWatcher: ...
-                @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
-            else:
-                def get_child_watcher(self) -> AbstractChildWatcher: ...
-                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+        if sys.version_info >= (3, 12):
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            def get_child_watcher(self) -> AbstractChildWatcher: ...
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+        else:
+            def get_child_watcher(self) -> AbstractChildWatcher: ...
+            def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
 
     SelectorEventLoop = _UnixSelectorEventLoop
 
     DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
 
-    if sys.version_info >= (3, 13):
-        EventLoop = SelectorEventLoop
-
-    if sys.version_info < (3, 14):
-        if sys.version_info >= (3, 12):
-            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-            class MultiLoopChildWatcher(AbstractChildWatcher):
-                def is_active(self) -> bool: ...
-                def close(self) -> None: ...
-                def __enter__(self) -> Self: ...
-                def __exit__(
-                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-                ) -> None: ...
-                def add_child_handler(
-                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-                ) -> None: ...
-                def remove_child_handler(self, pid: int) -> bool: ...
-                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-
-        else:
-            class MultiLoopChildWatcher(AbstractChildWatcher):
-                def is_active(self) -> bool: ...
-                def close(self) -> None: ...
-                def __enter__(self) -> Self: ...
-                def __exit__(
-                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-                ) -> None: ...
-                def add_child_handler(
-                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-                ) -> None: ...
-                def remove_child_handler(self, pid: int) -> bool: ...
-                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-
-    if sys.version_info < (3, 14):
-        class ThreadedChildWatcher(AbstractChildWatcher):
-            def is_active(self) -> Literal[True]: ...
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class MultiLoopChildWatcher(AbstractChildWatcher):
+            def is_active(self) -> bool: ...
             def close(self) -> None: ...
             def __enter__(self) -> Self: ...
             def __exit__(
                 self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
             ) -> None: ...
-            def __del__(self) -> None: ...
             def add_child_handler(
                 self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
             ) -> None: ...
             def remove_child_handler(self, pid: int) -> bool: ...
             def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
 
-        if sys.version_info >= (3, 9):
-            class PidfdChildWatcher(AbstractChildWatcher):
-                def __enter__(self) -> Self: ...
-                def __exit__(
-                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-                ) -> None: ...
-                def is_active(self) -> bool: ...
-                def close(self) -> None: ...
-                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-                def add_child_handler(
-                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-                ) -> None: ...
-                def remove_child_handler(self, pid: int) -> bool: ...
+    else:
+        class MultiLoopChildWatcher(AbstractChildWatcher):
+            def is_active(self) -> bool: ...
+            def close(self) -> None: ...
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+            ) -> None: ...
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+    class ThreadedChildWatcher(AbstractChildWatcher):
+        def is_active(self) -> Literal[True]: ...
+        def close(self) -> None: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+        ) -> None: ...
+        def __del__(self) -> None: ...
+        def add_child_handler(
+            self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+        ) -> None: ...
+        def remove_child_handler(self, pid: int) -> bool: ...
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+    if sys.version_info >= (3, 9):
+        class PidfdChildWatcher(AbstractChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+            ) -> None: ...
+            def is_active(self) -> bool: ...
+            def close(self) -> None: ...
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/windows_events.pyi

@@ -7,26 +7,14 @@ from typing import IO, Any, ClassVar, Literal, NoReturn
 from . import events, futures, proactor_events, selector_events, streams, windows_utils
 
 if sys.platform == "win32":
-    if sys.version_info >= (3, 13):
-        # 3.13 added `EventLoop`.
-        __all__ = (
-            "SelectorEventLoop",
-            "ProactorEventLoop",
-            "IocpProactor",
-            "DefaultEventLoopPolicy",
-            "WindowsSelectorEventLoopPolicy",
-            "WindowsProactorEventLoopPolicy",
-            "EventLoop",
-        )
-    else:
-        __all__ = (
-            "SelectorEventLoop",
-            "ProactorEventLoop",
-            "IocpProactor",
-            "DefaultEventLoopPolicy",
-            "WindowsSelectorEventLoopPolicy",
-            "WindowsProactorEventLoopPolicy",
-        )
+    __all__ = (
+        "SelectorEventLoop",
+        "ProactorEventLoop",
+        "IocpProactor",
+        "DefaultEventLoopPolicy",
+        "WindowsSelectorEventLoopPolicy",
+        "WindowsProactorEventLoopPolicy",
+    )
 
     NULL: Literal[0]
     INFINITE: Literal[0xFFFFFFFF]
@@ -86,9 +74,8 @@ if sys.platform == "win32":
 
     class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
         _loop_factory: ClassVar[type[SelectorEventLoop]]
-        if sys.version_info < (3, 14):
-            def get_child_watcher(self) -> NoReturn: ...
-            def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+        def get_child_watcher(self) -> NoReturn: ...
+        def set_child_watcher(self, watcher: Any) -> NoReturn: ...
 
     class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
         _loop_factory: ClassVar[type[ProactorEventLoop]]
@@ -96,5 +83,3 @@ if sys.platform == "win32":
         def set_child_watcher(self, watcher: Any) -> NoReturn: ...
 
     DefaultEventLoopPolicy = WindowsSelectorEventLoopPolicy
-    if sys.version_info >= (3, 13):
-        EventLoop = ProactorEventLoop

crates/red_knot_module_resolver/vendor/typeshed/stdlib/bdb.pyi

@@ -1,5 +1,5 @@
 import sys
-from _typeshed import ExcInfo, TraceFunction, Unused
+from _typeshed import ExcInfo, TraceFunction
 from collections.abc import Callable, Iterable, Mapping
 from types import CodeType, FrameType, TracebackType
 from typing import IO, Any, Literal, SupportsInt, TypeVar
@@ -32,9 +32,6 @@ class Bdb:
     def dispatch_call(self, frame: FrameType, arg: None) -> TraceFunction: ...
     def dispatch_return(self, frame: FrameType, arg: Any) -> TraceFunction: ...
     def dispatch_exception(self, frame: FrameType, arg: ExcInfo) -> TraceFunction: ...
-    if sys.version_info >= (3, 13):
-        def dispatch_opcode(self, frame: FrameType, arg: Unused) -> Callable[[FrameType, str, Any], TraceFunction]: ...
-
     def is_skipped_module(self, module_name: str) -> bool: ...
     def stop_here(self, frame: FrameType) -> bool: ...
     def break_here(self, frame: FrameType) -> bool: ...
@@ -45,13 +42,7 @@ class Bdb:
     def user_return(self, frame: FrameType, return_value: Any) -> None: ...
     def user_exception(self, frame: FrameType, exc_info: ExcInfo) -> None: ...
     def set_until(self, frame: FrameType, lineno: int | None = None) -> None: ...
-    if sys.version_info >= (3, 13):
-        def user_opcode(self, frame: FrameType) -> None: ...  # undocumented
-
     def set_step(self) -> None: ...
-    if sys.version_info >= (3, 13):
-        def set_stepinstr(self) -> None: ...  # undocumented
-
     def set_next(self, frame: FrameType) -> None: ...
     def set_return(self, frame: FrameType) -> None: ...
     def set_trace(self, frame: FrameType | None = None) -> None: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/builtins.pyi

@@ -75,7 +75,6 @@ if sys.version_info >= (3, 9):
     from types import GenericAlias
 
 _T = TypeVar("_T")
-_I = TypeVar("_I", default=int)
 _T_co = TypeVar("_T_co", covariant=True)
 _T_contra = TypeVar("_T_contra", contravariant=True)
 _R_co = TypeVar("_R_co", covariant=True)
@@ -824,12 +823,8 @@ class bytearray(MutableSequence[int]):
     def __buffer__(self, flags: int, /) -> memoryview: ...
     def __release_buffer__(self, buffer: memoryview, /) -> None: ...
 
-_IntegerFormats: TypeAlias = Literal[
-    "b", "B", "@b", "@B", "h", "H", "@h", "@H", "i", "I", "@i", "@I", "l", "L", "@l", "@L", "q", "Q", "@q", "@Q", "P", "@P"
-]
-
 @final
-class memoryview(Sequence[_I]):
+class memoryview(Sequence[int]):
     @property
     def format(self) -> str: ...
     @property
@@ -859,20 +854,13 @@ class memoryview(Sequence[_I]):
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
     ) -> None: ...
+    def cast(self, format: str, shape: list[int] | tuple[int, ...] = ...) -> memoryview: ...
     @overload
-    def cast(self, format: Literal["c", "@c"], shape: list[int] | tuple[int, ...] = ...) -> memoryview[bytes]: ...
+    def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], /) -> int: ...
     @overload
-    def cast(self, format: Literal["f", "@f", "d", "@d"], shape: list[int] | tuple[int, ...] = ...) -> memoryview[float]: ...
-    @overload
-    def cast(self, format: Literal["?"], shape: list[int] | tuple[int, ...] = ...) -> memoryview[bool]: ...
-    @overload
-    def cast(self, format: _IntegerFormats, shape: list[int] | tuple[int, ...] = ...) -> memoryview: ...
-    @overload
-    def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], /) -> _I: ...
-    @overload
-    def __getitem__(self, key: slice, /) -> memoryview[_I]: ...
+    def __getitem__(self, key: slice, /) -> memoryview: ...
     def __contains__(self, x: object, /) -> bool: ...
-    def __iter__(self) -> Iterator[_I]: ...
+    def __iter__(self) -> Iterator[int]: ...
     def __len__(self) -> int: ...
     def __eq__(self, value: object, /) -> bool: ...
     def __hash__(self) -> int: ...
@@ -1685,9 +1673,9 @@ def pow(base: float, exp: complex | _SupportsSomeKindOfPow, mod: None = None) ->
 @overload
 def pow(base: complex, exp: complex | _SupportsSomeKindOfPow, mod: None = None) -> complex: ...
 @overload
-def pow(base: _SupportsPow2[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
+def pow(base: _SupportsPow2[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...
 @overload
-def pow(base: _SupportsPow3NoneOnly[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
+def pow(base: _SupportsPow3NoneOnly[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...
 @overload
 def pow(base: _SupportsPow3[_E, _M, _T_co], exp: _E, mod: _M) -> _T_co: ...
 @overload
@@ -2018,9 +2006,9 @@ if sys.version_info >= (3, 10):
     class EncodingWarning(Warning): ...
 
 if sys.version_info >= (3, 11):
-    _BaseExceptionT_co = TypeVar("_BaseExceptionT_co", bound=BaseException, covariant=True, default=BaseException)
+    _BaseExceptionT_co = TypeVar("_BaseExceptionT_co", bound=BaseException, covariant=True)
     _BaseExceptionT = TypeVar("_BaseExceptionT", bound=BaseException)
-    _ExceptionT_co = TypeVar("_ExceptionT_co", bound=Exception, covariant=True, default=Exception)
+    _ExceptionT_co = TypeVar("_ExceptionT_co", bound=Exception, covariant=True)
     _ExceptionT = TypeVar("_ExceptionT", bound=Exception)
 
     # See `check_exception_group.py` for use-cases and comments.
@@ -2084,4 +2072,5 @@ if sys.version_info >= (3, 11):
         ) -> tuple[ExceptionGroup[_ExceptionT_co] | None, ExceptionGroup[_ExceptionT_co] | None]: ...
 
 if sys.version_info >= (3, 13):
+    class IncompleteInputError(SyntaxError): ...
     class PythonFinalizationError(RuntimeError): ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/concurrent/futures/__init__.pyi

@@ -1,5 +1,3 @@
-import sys
-
 from ._base import (
     ALL_COMPLETED as ALL_COMPLETED,
     FIRST_COMPLETED as FIRST_COMPLETED,
@@ -16,36 +14,19 @@ from ._base import (
 from .process import ProcessPoolExecutor as ProcessPoolExecutor
 from .thread import ThreadPoolExecutor as ThreadPoolExecutor
 
-if sys.version_info >= (3, 13):
-    __all__ = (
-        "FIRST_COMPLETED",
-        "FIRST_EXCEPTION",
-        "ALL_COMPLETED",
-        "CancelledError",
-        "TimeoutError",
-        "InvalidStateError",
-        "BrokenExecutor",
-        "Future",
-        "Executor",
-        "wait",
-        "as_completed",
-        "ProcessPoolExecutor",
-        "ThreadPoolExecutor",
-    )
-else:
-    __all__ = (
-        "FIRST_COMPLETED",
-        "FIRST_EXCEPTION",
-        "ALL_COMPLETED",
-        "CancelledError",
-        "TimeoutError",
-        "BrokenExecutor",
-        "Future",
-        "Executor",
-        "wait",
-        "as_completed",
-        "ProcessPoolExecutor",
-        "ThreadPoolExecutor",
-    )
+__all__ = (
+    "FIRST_COMPLETED",
+    "FIRST_EXCEPTION",
+    "ALL_COMPLETED",
+    "CancelledError",
+    "TimeoutError",
+    "BrokenExecutor",
+    "Future",
+    "Executor",
+    "wait",
+    "as_completed",
+    "ProcessPoolExecutor",
+    "ThreadPoolExecutor",
+)
 
 def __dir__() -> tuple[str, ...]: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/dataclasses.pyi

@@ -108,7 +108,7 @@ class _DefaultFactory(Protocol[_T_co]):
 
 class Field(Generic[_T]):
     name: str
-    type: Type[_T] | str | Any
+    type: Type[_T]
     default: _T | Literal[_MISSING_TYPE.MISSING]
     default_factory: _DefaultFactory[_T] | Literal[_MISSING_TYPE.MISSING]
     repr: bool

crates/red_knot_module_resolver/vendor/typeshed/stdlib/dbm/gnu.pyi

@@ -19,9 +19,6 @@ if sys.platform != "win32":
         def reorganize(self) -> None: ...
         def sync(self) -> None: ...
         def close(self) -> None: ...
-        if sys.version_info >= (3, 13):
-            def clear(self) -> None: ...
-
         def __getitem__(self, item: _KeyType) -> bytes: ...
         def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
         def __delitem__(self, key: _KeyType) -> None: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/dbm/ndbm.pyi

@@ -15,9 +15,6 @@ if sys.platform != "win32":
     # Actual typename dbm, not exposed by the implementation
     class _dbm:
         def close(self) -> None: ...
-        if sys.version_info >= (3, 13):
-            def clear(self) -> None: ...
-
         def __getitem__(self, item: _KeyType) -> bytes: ...
         def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
         def __delitem__(self, key: _KeyType) -> None: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/dbm/sqlite3.pyi

@@ -1,29 +0,0 @@
-from _typeshed import ReadableBuffer, StrOrBytesPath, Unused
-from collections.abc import Generator, MutableMapping
-from typing import Final, Literal
-from typing_extensions import LiteralString, Self, TypeAlias
-
-BUILD_TABLE: Final[LiteralString]
-GET_SIZE: Final[LiteralString]
-LOOKUP_KEY: Final[LiteralString]
-STORE_KV: Final[LiteralString]
-DELETE_KEY: Final[LiteralString]
-ITER_KEYS: Final[LiteralString]
-
-_SqliteData: TypeAlias = str | ReadableBuffer | int | float
-
-class error(OSError): ...
-
-class _Database(MutableMapping[bytes, bytes]):
-    def __init__(self, path: StrOrBytesPath, /, *, flag: Literal["r", "w", "c", "n"], mode: int) -> None: ...
-    def __len__(self) -> int: ...
-    def __getitem__(self, key: _SqliteData) -> bytes: ...
-    def __setitem__(self, key: _SqliteData, value: _SqliteData) -> None: ...
-    def __delitem__(self, key: _SqliteData) -> None: ...
-    def __iter__(self) -> Generator[bytes]: ...
-    def close(self) -> None: ...
-    def keys(self) -> list[bytes]: ...  # type: ignore[override]
-    def __enter__(self) -> Self: ...
-    def __exit__(self, *args: Unused) -> None: ...
-
-def open(filename: StrOrBytesPath, /, flag: Literal["r", "w,", "c", "n"] = "r", mode: int = 0o666) -> _Database: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/dis.pyi

@@ -31,9 +31,6 @@ __all__ = [
     "EXTENDED_ARG",
     "stack_effect",
 ]
-if sys.version_info >= (3, 13):
-    __all__ += ["hasjump"]
-
 if sys.version_info >= (3, 12):
     __all__ += ["hasarg", "hasexc"]
 else:
@@ -89,41 +86,12 @@ else:
         is_jump_target: bool
 
 class Instruction(_Instruction):
-    if sys.version_info < (3, 13):
-        def _disassemble(self, lineno_width: int = 3, mark_as_current: bool = False, offset_width: int = 4) -> str: ...
-    if sys.version_info >= (3, 13):
-        @property
-        def oparg(self) -> int: ...
-        @property
-        def baseopcode(self) -> int: ...
-        @property
-        def baseopname(self) -> str: ...
-        @property
-        def cache_offset(self) -> int: ...
-        @property
-        def end_offset(self) -> int: ...
-        @property
-        def jump_target(self) -> int: ...
-        @property
-        def is_jump_target(self) -> bool: ...
+    def _disassemble(self, lineno_width: int = 3, mark_as_current: bool = False, offset_width: int = 4) -> str: ...
 
 class Bytecode:
     codeobj: types.CodeType
     first_line: int
-    if sys.version_info >= (3, 13):
-        show_offsets: bool
-        # 3.13 added `show_offsets`
-        def __init__(
-            self,
-            x: _HaveCodeType | str,
-            *,
-            first_line: int | None = None,
-            current_offset: int | None = None,
-            show_caches: bool = False,
-            adaptive: bool = False,
-            show_offsets: bool = False,
-        ) -> None: ...
-    elif sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 11):
         def __init__(
             self,
             x: _HaveCodeType | str,
@@ -133,15 +101,12 @@ class Bytecode:
             show_caches: bool = False,
             adaptive: bool = False,
         ) -> None: ...
+        @classmethod
+        def from_traceback(cls, tb: types.TracebackType, *, show_caches: bool = False, adaptive: bool = False) -> Self: ...
     else:
         def __init__(
             self, x: _HaveCodeType | str, *, first_line: int | None = None, current_offset: int | None = None
         ) -> None: ...
-
-    if sys.version_info >= (3, 11):
-        @classmethod
-        def from_traceback(cls, tb: types.TracebackType, *, show_caches: bool = False, adaptive: bool = False) -> Self: ...
-    else:
         @classmethod
         def from_traceback(cls, tb: types.TracebackType) -> Self: ...
 
@@ -156,8 +121,7 @@ def findlinestarts(code: _HaveCodeType) -> Iterator[tuple[int, int]]: ...
 def pretty_flags(flags: int) -> str: ...
 def code_info(x: _HaveCodeType | str) -> str: ...
 
-if sys.version_info >= (3, 13):
-    # 3.13 added `show_offsets`
+if sys.version_info >= (3, 11):
     def dis(
         x: _HaveCodeType | str | bytes | bytearray | None = None,
         *,
@@ -165,43 +129,20 @@ if sys.version_info >= (3, 13):
         depth: int | None = None,
         show_caches: bool = False,
         adaptive: bool = False,
-        show_offsets: bool = False,
     ) -> None: ...
-    def disassemble(
-        co: _HaveCodeType,
-        lasti: int = -1,
-        *,
-        file: IO[str] | None = None,
-        show_caches: bool = False,
-        adaptive: bool = False,
-        show_offsets: bool = False,
-    ) -> None: ...
-    def distb(
-        tb: types.TracebackType | None = None,
-        *,
-        file: IO[str] | None = None,
-        show_caches: bool = False,
-        adaptive: bool = False,
-        show_offsets: bool = False,
-    ) -> None: ...
-    # 3.13 made `show_cache` `None` by default
-    def get_instructions(
-        x: _HaveCodeType, *, first_line: int | None = None, show_caches: bool | None = None, adaptive: bool = False
-    ) -> Iterator[Instruction]: ...
 
-elif sys.version_info >= (3, 11):
-    # 3.11 added `show_caches` and `adaptive`
+else:
     def dis(
-        x: _HaveCodeType | str | bytes | bytearray | None = None,
-        *,
-        file: IO[str] | None = None,
-        depth: int | None = None,
-        show_caches: bool = False,
-        adaptive: bool = False,
+        x: _HaveCodeType | str | bytes | bytearray | None = None, *, file: IO[str] | None = None, depth: int | None = None
     ) -> None: ...
+
+if sys.version_info >= (3, 11):
     def disassemble(
         co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
     ) -> None: ...
+    def disco(
+        co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
+    ) -> None: ...
     def distb(
         tb: types.TracebackType | None = None, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
     ) -> None: ...
@@ -210,13 +151,9 @@ elif sys.version_info >= (3, 11):
     ) -> Iterator[Instruction]: ...
 
 else:
-    def dis(
-        x: _HaveCodeType | str | bytes | bytearray | None = None, *, file: IO[str] | None = None, depth: int | None = None
-    ) -> None: ...
     def disassemble(co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None) -> None: ...
+    def disco(co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None) -> None: ...
     def distb(tb: types.TracebackType | None = None, *, file: IO[str] | None = None) -> None: ...
     def get_instructions(x: _HaveCodeType, *, first_line: int | None = None) -> Iterator[Instruction]: ...
 
 def show_code(co: _HaveCodeType, *, file: IO[str] | None = None) -> None: ...
-
-disco = disassemble

crates/red_knot_module_resolver/vendor/typeshed/stdlib/email/utils.pyi

@@ -1,7 +1,6 @@
 import datetime
 import sys
 from _typeshed import Unused
-from collections.abc import Iterable
 from email import _ParamType
 from email.charset import Charset
 from typing import overload
@@ -29,21 +28,9 @@ _PDTZ: TypeAlias = tuple[int, int, int, int, int, int, int, int, int, int | None
 
 def quote(str: str) -> str: ...
 def unquote(str: str) -> str: ...
-
-if sys.version_info >= (3, 13):
-    def parseaddr(addr: str | list[str], *, strict: bool = True) -> tuple[str, str]: ...
-
-else:
-    def parseaddr(addr: str) -> tuple[str, str]: ...
-
+def parseaddr(addr: str | None) -> tuple[str, str]: ...
 def formataddr(pair: tuple[str | None, str], charset: str | Charset = "utf-8") -> str: ...
-
-if sys.version_info >= (3, 13):
-    def getaddresses(fieldvalues: Iterable[str], *, strict: bool = True) -> list[tuple[str, str]]: ...
-
-else:
-    def getaddresses(fieldvalues: Iterable[str]) -> list[tuple[str, str]]: ...
-
+def getaddresses(fieldvalues: list[str]) -> list[tuple[str, str]]: ...
 @overload
 def parsedate(data: None) -> None: ...
 @overload

crates/red_knot_module_resolver/vendor/typeshed/stdlib/importlib/metadata/__init__.pyi

@@ -1,7 +1,6 @@
 import abc
 import pathlib
 import sys
-import types
 from _collections_abc import dict_keys, dict_values
 from _typeshed import StrPath
 from collections.abc import Iterable, Iterator, Mapping
@@ -37,8 +36,11 @@ if sys.version_info >= (3, 10):
     from importlib.metadata._meta import PackageMetadata as PackageMetadata, SimplePath
     def packages_distributions() -> Mapping[str, list[str]]: ...
 
-    _SimplePath: TypeAlias = SimplePath
-
+    if sys.version_info >= (3, 12):
+        # It's generic but shouldn't be
+        _SimplePath: TypeAlias = SimplePath[Any]
+    else:
+        _SimplePath: TypeAlias = SimplePath
 else:
     _SimplePath: TypeAlias = Path
 
@@ -46,9 +48,7 @@ class PackageNotFoundError(ModuleNotFoundError):
     @property
     def name(self) -> str: ...  # type: ignore[override]
 
-if sys.version_info >= (3, 13):
-    _EntryPointBase = object
-elif sys.version_info >= (3, 11):
+if sys.version_info >= (3, 11):
     class DeprecatedTuple:
         def __getitem__(self, item: int) -> str: ...
 
@@ -226,9 +226,6 @@ class Distribution(_distribution_parent):
     if sys.version_info >= (3, 10):
         @property
         def name(self) -> str: ...
-    if sys.version_info >= (3, 13):
-        @property
-        def origin(self) -> types.SimpleNamespace: ...
 
 class DistributionFinder(MetaPathFinder):
     class Context:

crates/red_knot_module_resolver/vendor/typeshed/stdlib/importlib/metadata/_meta.pyi

@@ -1,12 +1,9 @@
 import sys
-from _typeshed import StrPath
 from collections.abc import Iterator
-from os import PathLike
-from typing import Any, Protocol, overload
-from typing_extensions import TypeVar
+from typing import Any, Protocol, TypeVar, overload
 
 _T = TypeVar("_T")
-_T_co = TypeVar("_T_co", covariant=True, default=Any)
+_T_co = TypeVar("_T_co", covariant=True)
 
 class PackageMetadata(Protocol):
     def __len__(self) -> int: ...
@@ -25,18 +22,7 @@ class PackageMetadata(Protocol):
         @overload
         def get(self, name: str, failobj: _T) -> _T | str: ...
 
-if sys.version_info >= (3, 13):
-    class SimplePath(Protocol):
-        def joinpath(self, other: StrPath, /) -> SimplePath: ...
-        def __truediv__(self, other: StrPath, /) -> SimplePath: ...
-        # Incorrect at runtime
-        @property
-        def parent(self) -> PathLike[str]: ...
-        def read_text(self, encoding: str | None = None) -> str: ...
-        def read_bytes(self) -> bytes: ...
-        def exists(self) -> bool: ...
-
-elif sys.version_info >= (3, 12):
+if sys.version_info >= (3, 12):
     class SimplePath(Protocol[_T_co]):
         # At runtime this is defined as taking `str | _T`, but that causes trouble.
         # See #11436.

crates/red_knot_module_resolver/vendor/typeshed/stdlib/importlib/metadata/diagnose.pyi

@@ -1,2 +0,0 @@
-def inspect(path: str) -> None: ...
-def run() -> None: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/inspect.pyi

@@ -176,24 +176,20 @@ TPFLAGS_IS_ABSTRACT: Literal[1048576]
 modulesbyfile: dict[str, Any]
 
 _GetMembersPredicateTypeGuard: TypeAlias = Callable[[Any], TypeGuard[_T]]
-_GetMembersPredicateTypeIs: TypeAlias = Callable[[Any], TypeIs[_T]]
 _GetMembersPredicate: TypeAlias = Callable[[Any], bool]
-_GetMembersReturn: TypeAlias = list[tuple[str, _T]]
+_GetMembersReturnTypeGuard: TypeAlias = list[tuple[str, _T]]
+_GetMembersReturn: TypeAlias = list[tuple[str, Any]]
 
 @overload
-def getmembers(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturn[_T]: ...
+def getmembers(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturnTypeGuard[_T]: ...
 @overload
-def getmembers(object: object, predicate: _GetMembersPredicateTypeIs[_T]) -> _GetMembersReturn[_T]: ...
-@overload
-def getmembers(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn[Any]: ...
+def getmembers(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn: ...
 
 if sys.version_info >= (3, 11):
     @overload
-    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturn[_T]: ...
+    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturnTypeGuard[_T]: ...
     @overload
-    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeIs[_T]) -> _GetMembersReturn[_T]: ...
-    @overload
-    def getmembers_static(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn[Any]: ...
+    def getmembers_static(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn: ...
 
 def getmodulename(path: StrPath) -> str | None: ...
 def ismodule(object: object) -> TypeIs[ModuleType]: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/io.pyi

@@ -6,7 +6,7 @@ from _typeshed import FileDescriptorOrPath, ReadableBuffer, WriteableBuffer
 from collections.abc import Callable, Iterable, Iterator
 from os import _Opener
 from types import TracebackType
-from typing import IO, Any, BinaryIO, Generic, Literal, Protocol, TextIO, TypeVar, overload, type_check_only
+from typing import IO, Any, BinaryIO, Literal, Protocol, TextIO, TypeVar, overload, type_check_only
 from typing_extensions import Self
 
 __all__ = [
@@ -173,12 +173,12 @@ class _WrappedBuffer(Protocol):
     # def seek(self, offset: Literal[0], whence: Literal[2]) -> int: ...
     # def tell(self) -> int: ...
 
-_BufferT_co = TypeVar("_BufferT_co", bound=_WrappedBuffer, default=_WrappedBuffer, covariant=True)
-
-class TextIOWrapper(TextIOBase, TextIO, Generic[_BufferT_co]):  # type: ignore[misc]  # incompatible definitions of write in the base classes
+# TODO: Should be generic over the buffer type, but needs to wait for
+# TypeVar defaults.
+class TextIOWrapper(TextIOBase, TextIO):  # type: ignore[misc]  # incompatible definitions of write in the base classes
     def __init__(
         self,
-        buffer: _BufferT_co,
+        buffer: _WrappedBuffer,
         encoding: str | None = None,
         errors: str | None = None,
         newline: str | None = None,
@@ -187,7 +187,7 @@ class TextIOWrapper(TextIOBase, TextIO, Generic[_BufferT_co]):  # type: ignore[m
     ) -> None: ...
     # Equals the "buffer" argument passed in to the constructor.
     @property
-    def buffer(self) -> _BufferT_co: ...  # type: ignore[override]
+    def buffer(self) -> BinaryIO: ...
     @property
     def closed(self) -> bool: ...
     @property
@@ -211,7 +211,7 @@ class TextIOWrapper(TextIOBase, TextIO, Generic[_BufferT_co]):  # type: ignore[m
     def readline(self, size: int = -1, /) -> str: ...  # type: ignore[override]
     def readlines(self, hint: int = -1, /) -> list[str]: ...  # type: ignore[override]
     # Equals the "buffer" argument passed in to the constructor.
-    def detach(self) -> _BufferT_co: ...  # type: ignore[override]
+    def detach(self) -> BinaryIO: ...
     # TextIOWrapper's version of seek only supports a limited subset of
     # operations.
     def seek(self, cookie: int, whence: int = 0, /) -> int: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/itertools.pyi

@@ -326,10 +326,6 @@ if sys.version_info >= (3, 10):
 
 if sys.version_info >= (3, 12):
     class batched(Iterator[tuple[_T_co, ...]], Generic[_T_co]):
-        if sys.version_info >= (3, 13):
-            def __new__(cls, iterable: Iterable[_T_co], n: int, *, strict: bool = False) -> Self: ...
-        else:
-            def __new__(cls, iterable: Iterable[_T_co], n: int) -> Self: ...
-
+        def __new__(cls, iterable: Iterable[_T_co], n: int) -> Self: ...
         def __iter__(self) -> Self: ...
         def __next__(self) -> tuple[_T_co, ...]: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/logging/__init__.pyi

@@ -8,7 +8,7 @@ from string import Template
 from time import struct_time
 from types import FrameType, TracebackType
 from typing import Any, ClassVar, Generic, Literal, Protocol, TextIO, TypeVar, overload
-from typing_extensions import Self, TypeAlias, deprecated
+from typing_extensions import Self, TypeAlias
 
 if sys.version_info >= (3, 11):
     from types import GenericAlias
@@ -574,8 +574,11 @@ def disable(level: int = 50) -> None: ...
 def addLevelName(level: int, levelName: str) -> None: ...
 @overload
 def getLevelName(level: int) -> str: ...
+
+# The str -> int case is considered a mistake, but retained for backward
+# compatibility.  See
+# https://docs.python.org/3/library/logging.html#logging.getLevelName.
 @overload
-@deprecated("The str -> int case is considered a mistake.")
 def getLevelName(level: str) -> Any: ...
 
 if sys.version_info >= (3, 11):

crates/red_knot_module_resolver/vendor/typeshed/stdlib/mailbox.pyi

@@ -115,14 +115,6 @@ class Maildir(Mailbox[MaildirMessage]):
     def get_message(self, key: str) -> MaildirMessage: ...
     def get_bytes(self, key: str) -> bytes: ...
     def get_file(self, key: str) -> _ProxyFile[bytes]: ...
-    if sys.version_info >= (3, 13):
-        def get_info(self, key: str) -> str: ...
-        def set_info(self, key: str, info: str) -> None: ...
-        def get_flags(self, key: str) -> str: ...
-        def set_flags(self, key: str, flags: str) -> None: ...
-        def add_flag(self, key: str, flag: str) -> None: ...
-        def remove_flag(self, key: str, flag: str) -> None: ...
-
     def iterkeys(self) -> Iterator[str]: ...
     def __contains__(self, key: str) -> bool: ...
     def __len__(self) -> int: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/mimetypes.pyi

@@ -45,7 +45,6 @@ class MimeTypes:
     types_map: tuple[dict[str, str], dict[str, str]]
     types_map_inv: tuple[dict[str, str], dict[str, str]]
     def __init__(self, filenames: tuple[str, ...] = (), strict: bool = True) -> None: ...
-    def add_type(self, type: str, ext: str, strict: bool = True) -> None: ...
     def guess_extension(self, type: str, strict: bool = True) -> str | None: ...
     def guess_type(self, url: StrPath, strict: bool = True) -> tuple[str | None, str | None]: ...
     def guess_all_extensions(self, type: str, strict: bool = True) -> list[str]: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/mmap.pyi

@@ -1,7 +1,7 @@
 import sys
 from _typeshed import ReadableBuffer, Unused
 from collections.abc import Iterable, Iterator, Sized
-from typing import Final, Literal, NoReturn, overload
+from typing import Final, NoReturn, overload
 from typing_extensions import Self
 
 ACCESS_DEFAULT: int
@@ -77,7 +77,7 @@ class mmap(Iterable[int], Sized):
     def __buffer__(self, flags: int, /) -> memoryview: ...
     def __release_buffer__(self, buffer: memoryview, /) -> None: ...
     if sys.version_info >= (3, 13):
-        def seekable(self) -> Literal[True]: ...
+        def seekable(self) -> bool: ...
 
 if sys.platform != "win32":
     MADV_NORMAL: int

crates/red_knot_module_resolver/vendor/typeshed/stdlib/multiprocessing/context.pyi

@@ -92,21 +92,17 @@ class BaseContext:
     @overload
     def Value(self, typecode_or_type: str | type[_CData], *args: Any, lock: bool | _LockLike = True) -> Any: ...
     @overload
-    def Array(
-        self, typecode_or_type: type[_SimpleCData[_T]], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]
-    ) -> SynchronizedArray[_T]: ...
-    @overload
     def Array(
         self, typecode_or_type: type[c_char], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
     ) -> SynchronizedString: ...
     @overload
     def Array(
-        self,
-        typecode_or_type: type[_SimpleCData[_T]],
-        size_or_initializer: int | Sequence[Any],
-        *,
-        lock: Literal[True] | _LockLike = True,
-    ) -> SynchronizedArray[_T]: ...
+        self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]
+    ) -> SynchronizedArray[_CT]: ...
+    @overload
+    def Array(
+        self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
+    ) -> SynchronizedArray[_CT]: ...
     @overload
     def Array(
         self, typecode_or_type: str, size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True

crates/red_knot_module_resolver/vendor/typeshed/stdlib/multiprocessing/sharedctypes.pyi

@@ -39,20 +39,12 @@ def Array(
 ) -> _CT: ...
 @overload
 def Array(
-    typecode_or_type: type[c_char],
+    typecode_or_type: type[_CT],
     size_or_initializer: int | Sequence[Any],
     *,
     lock: Literal[True] | _LockLike = True,
     ctx: BaseContext | None = None,
-) -> SynchronizedString: ...
-@overload
-def Array(
-    typecode_or_type: type[_SimpleCData[_T]],
-    size_or_initializer: int | Sequence[Any],
-    *,
-    lock: Literal[True] | _LockLike = True,
-    ctx: BaseContext | None = None,
-) -> SynchronizedArray[_T]: ...
+) -> SynchronizedArray[_CT]: ...
 @overload
 def Array(
     typecode_or_type: str,
@@ -73,11 +65,9 @@ def copy(obj: _CT) -> _CT: ...
 @overload
 def synchronized(obj: _SimpleCData[_T], lock: _LockLike | None = None, ctx: Any | None = None) -> Synchronized[_T]: ...
 @overload
-def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...  # type: ignore
+def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...
 @overload
-def synchronized(
-    obj: ctypes.Array[_SimpleCData[_T]], lock: _LockLike | None = None, ctx: Any | None = None
-) -> SynchronizedArray[_T]: ...
+def synchronized(obj: ctypes.Array[_CT], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedArray[_CT]: ...
 @overload
 def synchronized(obj: _CT, lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedBase[_CT]: ...
 
@@ -99,30 +89,19 @@ class SynchronizedBase(Generic[_CT]):
 class Synchronized(SynchronizedBase[_SimpleCData[_T]], Generic[_T]):
     value: _T
 
-class SynchronizedArray(SynchronizedBase[ctypes.Array[_SimpleCData[_T]]], Generic[_T]):
+class SynchronizedArray(SynchronizedBase[ctypes.Array[_CT]], Generic[_CT]):
     def __len__(self) -> int: ...
     @overload
-    def __getitem__(self, i: slice) -> list[_T]: ...
+    def __getitem__(self, i: slice) -> list[_CT]: ...
     @overload
-    def __getitem__(self, i: int) -> _T: ...
+    def __getitem__(self, i: int) -> _CT: ...
     @overload
-    def __setitem__(self, i: slice, value: Iterable[_T]) -> None: ...
+    def __setitem__(self, i: slice, value: Iterable[_CT]) -> None: ...
     @overload
-    def __setitem__(self, i: int, value: _T) -> None: ...
-    def __getslice__(self, start: int, stop: int) -> list[_T]: ...
-    def __setslice__(self, start: int, stop: int, values: Iterable[_T]) -> None: ...
-
-class SynchronizedString(SynchronizedArray[bytes]):
-    @overload  # type: ignore[override]
-    def __getitem__(self, i: slice) -> bytes: ...
-    @overload  # type: ignore[override]
-    def __getitem__(self, i: int) -> bytes: ...
-    @overload  # type: ignore[override]
-    def __setitem__(self, i: slice, value: bytes) -> None: ...
-    @overload  # type: ignore[override]
-    def __setitem__(self, i: int, value: bytes) -> None: ...  # type: ignore[override]
-    def __getslice__(self, start: int, stop: int) -> bytes: ...  # type: ignore[override]
-    def __setslice__(self, start: int, stop: int, values: bytes) -> None: ...  # type: ignore[override]
+    def __setitem__(self, i: int, value: _CT) -> None: ...
+    def __getslice__(self, start: int, stop: int) -> list[_CT]: ...
+    def __setslice__(self, start: int, stop: int, values: Iterable[_CT]) -> None: ...
 
+class SynchronizedString(SynchronizedArray[c_char]):
     value: bytes
     raw: bytes

crates/red_knot_module_resolver/vendor/typeshed/stdlib/os/__init__.pyi

@@ -914,8 +914,8 @@ if sys.platform != "win32":
     def forkpty() -> tuple[int, int]: ...  # some flavors of Unix
     def killpg(pgid: int, signal: int, /) -> None: ...
     def nice(increment: int, /) -> int: ...
-    if sys.platform != "darwin" and sys.platform != "linux":
-        def plock(op: int, /) -> None: ...
+    if sys.platform != "darwin":
+        def plock(op: int, /) -> None: ...  # ???op is int?
 
 class _wrap_close(_TextIOWrapper):
     def __init__(self, stream: _TextIOWrapper, proc: Popen[str]) -> None: ...
@@ -1141,16 +1141,16 @@ if sys.version_info >= (3, 10) and sys.platform == "linux":
 if sys.version_info >= (3, 12) and sys.platform == "linux":
     CLONE_FILES: int
     CLONE_FS: int
-    CLONE_NEWCGROUP: int  # Linux 4.6+
-    CLONE_NEWIPC: int  # Linux 2.6.19+
-    CLONE_NEWNET: int  # Linux 2.6.24+
+    CLONE_NEWCGROUP: int
+    CLONE_NEWIPC: int
+    CLONE_NEWNET: int
     CLONE_NEWNS: int
-    CLONE_NEWPID: int  # Linux 3.8+
-    CLONE_NEWTIME: int  # Linux 5.6+
-    CLONE_NEWUSER: int  # Linux 3.8+
-    CLONE_NEWUTS: int  # Linux 2.6.19+
+    CLONE_NEWPID: int
+    CLONE_NEWTIME: int
+    CLONE_NEWUSER: int
+    CLONE_NEWUTS: int
     CLONE_SIGHAND: int
-    CLONE_SYSVSEM: int  # Linux 2.6.26+
+    CLONE_SYSVSEM: int
     CLONE_THREAD: int
     CLONE_VM: int
     def unshare(flags: int) -> None: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/pathlib.pyi

@@ -113,7 +113,7 @@ class Path(PurePath):
 
     if sys.version_info >= (3, 13):
         @classmethod
-        def from_uri(cls, uri: str) -> Self: ...
+        def from_uri(cls, uri: str) -> Path: ...
         def is_dir(self, *, follow_symlinks: bool = True) -> bool: ...
         def is_file(self, *, follow_symlinks: bool = True) -> bool: ...
         def read_text(self, encoding: str | None = None, errors: str | None = None, newline: str | None = None) -> str: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/pdb.pyi

@@ -5,7 +5,7 @@ from cmd import Cmd
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from inspect import _SourceObjectType
 from types import CodeType, FrameType, TracebackType
-from typing import IO, Any, ClassVar, Final, TypeVar
+from typing import IO, Any, ClassVar, TypeVar
 from typing_extensions import ParamSpec, Self
 
 __all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace", "post_mortem", "help"]
@@ -30,9 +30,6 @@ class Pdb(Bdb, Cmd):
 
     commands_resuming: ClassVar[list[str]]
 
-    if sys.version_info >= (3, 13):
-        MAX_CHAINED_EXCEPTION_DEPTH: Final = 999
-
     aliases: dict[str, str]
     mainpyfile: str
     _wait_for_mainpyfile: bool
@@ -61,16 +58,8 @@ class Pdb(Bdb, Cmd):
     if sys.version_info < (3, 11):
         def execRcLines(self) -> None: ...
 
-    if sys.version_info >= (3, 13):
-        user_opcode = Bdb.user_line
-
     def bp_commands(self, frame: FrameType) -> bool: ...
-
-    if sys.version_info >= (3, 13):
-        def interaction(self, frame: FrameType | None, tb_or_exc: TracebackType | BaseException | None) -> None: ...
-    else:
-        def interaction(self, frame: FrameType | None, traceback: TracebackType | None) -> None: ...
-
+    def interaction(self, frame: FrameType | None, traceback: TracebackType | None) -> None: ...
     def displayhook(self, obj: object) -> None: ...
     def handle_command_def(self, line: str) -> bool: ...
     def defaultFile(self) -> str: ...
@@ -83,9 +72,6 @@ class Pdb(Bdb, Cmd):
     if sys.version_info < (3, 11):
         def _runscript(self, filename: str) -> None: ...
 
-    if sys.version_info >= (3, 13):
-        def completedefault(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...  # type: ignore[override]
-
     def do_commands(self, arg: str) -> bool | None: ...
     def do_break(self, arg: str, temporary: bool = ...) -> bool | None: ...
     def do_tbreak(self, arg: str) -> bool | None: ...
@@ -95,9 +81,6 @@ class Pdb(Bdb, Cmd):
     def do_ignore(self, arg: str) -> bool | None: ...
     def do_clear(self, arg: str) -> bool | None: ...
     def do_where(self, arg: str) -> bool | None: ...
-    if sys.version_info >= (3, 13):
-        def do_exceptions(self, arg: str) -> bool | None: ...
-
     def do_up(self, arg: str) -> bool | None: ...
     def do_down(self, arg: str) -> bool | None: ...
     def do_until(self, arg: str) -> bool | None: ...
@@ -142,14 +125,8 @@ class Pdb(Bdb, Cmd):
     def help_exec(self) -> None: ...
     def help_pdb(self) -> None: ...
     def sigint_handler(self, signum: signal.Signals, frame: FrameType) -> None: ...
-    if sys.version_info >= (3, 13):
-        def message(self, msg: str, end: str = "\n") -> None: ...
-    else:
-        def message(self, msg: str) -> None: ...
-
+    def message(self, msg: str) -> None: ...
     def error(self, msg: str) -> None: ...
-    if sys.version_info >= (3, 13):
-        def completenames(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...  # type: ignore[override]
     if sys.version_info >= (3, 12):
         def set_convenience_variable(self, frame: FrameType, name: str, value: Any) -> None: ...