[red-knot] Explicitly test that no duplicate editable search paths are ever added

## Summary

<!-- What's the purpose of the change? What does it do, and why? -->

Renames the rule
[RUF007](https://docs.astral.sh/ruff/rules/pairwise-over-zipped/) from
`pairwise-over-zipped` to `zip-instead-of-pairwise`. This closes #12397.

Specifically, in this PR:

- The file containing the rule was renamed
- The struct was renamed
- The function implementing the rule was renamed

## Testing

<!-- How was it tested? -->

- `cargo test`
- Docs re-built locally and verified that new rule name is displayed.
(Screenshots below).

<img width="939" alt="New rule name in rule summary"
src="https://github.com/user-attachments/assets/bf638bc9-1b7a-4675-99bf-e4de88fec167">

<img width="805" alt="New rule name in rule details"
src="https://github.com/user-attachments/assets/6fffd745-2568-424a-84e5-f94a41351022">

.github/CODEOWNERS

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

.github/workflows/build-docker.yml

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

.github/workflows/publish-docs.yaml

@@ -1,62 +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:
-      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

@@ -0,0 +1,151 @@
+# 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.yml

@@ -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.6.1
+        uses: cloudflare/wrangler-action@v3.7.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/publish-wasm.yml

@@ -0,0 +1,55 @@
+# 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,9 +12,8 @@
 # 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.
@@ -49,7 +48,7 @@ on:
 jobs:
   # Run 'cargo dist plan' (or host) to determine what tasks we need to do
   plan:
-    runs-on: ubuntu-latest
+    runs-on: "ubuntu-20.04"
     outputs:
       val: ${{ steps.plan.outputs.manifest }}
       tag: ${{ (inputs.tag != 'dry-run' && inputs.tag) || '' }}
@@ -65,7 +64,12 @@ 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.14.0/cargo-dist-installer.sh | sh"
+        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
       # 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.
@@ -101,8 +105,8 @@ jobs:
       plan: ${{ needs.plan.outputs.val }}
     secrets: inherit
     permissions:
-      packages: write
-      contents: read
+      "contents": "read"
+      "packages": "write"
 
   # Build and package all the platform-agnostic(ish) things
   build-global-artifacts:
@@ -118,9 +122,12 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      - 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"
+      - 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
       # Get all the local artifacts for the global tasks to use (for e.g. checksums)
       - name: Fetch local artifacts
         uses: actions/download-artifact@v4
@@ -165,8 +172,12 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      - 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"
+      - 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
       # Fetch artifacts from scratch-storage
       - name: Fetch artifacts
         uses: actions/download-artifact@v4
@@ -200,8 +211,23 @@ jobs:
     secrets: inherit
     # publish jobs get escalated permissions
     permissions:
-      id-token: write
-      packages: write
+      "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"
 
   # Create a GitHub Release while uploading all files to it
   announce:
@@ -209,10 +235,11 @@ 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') }}
+    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') }}
     runs-on: "ubuntu-20.04"
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -220,6 +247,7 @@ 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:
@@ -231,13 +259,16 @@ jobs:
           # Remove the granular manifests
           rm -f artifacts/*-dist-manifest.json
       - name: Create GitHub Release
-        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/*"
+        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/*
 
   custom-notify-dependents:
     needs:

.pre-commit-config.yaml

@@ -42,7 +42,7 @@ repos:
           )$
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.22.9
+    rev: v1.23.2
     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.4.10
+    rev: v0.5.2
     hooks:
       - id: ruff-format
       - id: ruff

CHANGELOG.md

@@ -1,5 +1,129 @@
 # 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!
@@ -56,7 +180,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%60/) (`PLE0744`)
+- [`misplaced-bare-raise`](https://docs.astral.sh/ruff/rules/misplaced-bare-raise/) (`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
-`arg.rs`, if appropriate). If you want to pattern-match against an existing example, grep for
+`args.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/bump.sh`; this command will:
+1. Run `./scripts/release.sh`; this command will:
     - Generate a temporary virtual environment with `rooster`
     - Generate a changelog entry in `CHANGELOG.md`
     - Update versions in `pyproject.toml` and `Cargo.toml`

Cargo.lock

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

Cargo.toml

@@ -35,7 +35,9 @@ 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"] }
@@ -48,16 +50,17 @@ 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.5.1" }
+clap_complete_command = { version = "0.6.0" }
 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 = "5.5.3" }
+dashmap = { version = "6.0.1" }
 drop_bomb = { version = "0.1.5" }
 env_logger = { version = "0.11.0" }
 etcetera = { version = "0.8.0" }
@@ -69,7 +72,6 @@ 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" }
@@ -92,10 +94,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" }
@@ -106,7 +108,7 @@ rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "f706aa2d32d473ee633a77c1af01d180c85da308" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "a1bf3a613f451af7fc0a59411c56abc47fe8e8e1" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -119,7 +121,6 @@ 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" }
@@ -127,7 +128,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.5.0" }
+tikv-jemallocator = { version = "0.6.0" }
 toml = { version = "0.8.11" }
 tracing = { version = "0.1.40" }
 tracing-indicatif = { version = "0.3.6" }
@@ -227,7 +228,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.14.0"
+cargo-dist-version = "0.18.0"
 # CI backends to support
 ci = ["github"]
 # The installers to generate for each app
@@ -258,21 +259,23 @@ 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-jobs = ["./publish-pypi", "./publish-wasm"]
 # Announcement jobs to run in CI
 post-announce-jobs = ["./notify-dependents", "./publish-docs", "./publish-playground"]
-# Skip checking whether the specified configuration files are up to date
-allow-dirty = ["ci"]
+# Custom permissions for GitHub Jobs
+github-custom-job-permissions = { "build-docker" = { packages = "write", contents = "read" }, "publish-wasm" = { contents = "read", id-token = "write", packages = "write" } }
 # Whether to install an updater program
 install-updater = false

README.md

@@ -119,7 +119,25 @@ 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),
@@ -152,7 +170,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.5.0
+  rev: v0.5.3
   hooks:
     # Run the linter.
     - id: ruff

crates/red_knot/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "red_knot"
-version = "0.1.0"
+version = "0.0.0"
 edition.workspace = true
 rust-version.workspace = true
 homepage.workspace = true
@@ -13,32 +13,24 @@ license.workspace = true
 
 [dependencies]
 red_knot_module_resolver = { workspace = true }
+red_knot_python_semantic = { workspace = true }
 
-ruff_python_parser = { workspace = true }
+ruff_db = { workspace = true, features = ["os", "cache"] }
 ruff_python_ast = { workspace = true }
-ruff_text_size = { workspace = true }
-ruff_index = { workspace = true }
-ruff_notebook = { workspace = true }
 
 anyhow = { workspace = true }
-bitflags = { workspace = true }
+clap = { workspace = true, features = ["wrap_help"] }
+countme = { workspace = true, features = ["enable"] }
 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 }
-smol_str = { version = "0.2.1" }
+salsa = { workspace = true }
 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

@@ -1,418 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

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

crates/red_knot/src/cli/target_version.rs

@@ -0,0 +1,34 @@
+/// 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

@@ -0,0 +1,34 @@
+#[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,248 +1,200 @@
+use std::panic::{AssertUnwindSafe, RefUnwindSafe};
 use std::sync::Arc;
 
-pub use jars::{HasJar, HasJars};
-pub use query::{QueryError, QueryResult};
-pub use runtime::DbRuntime;
-pub use storage::JarsStorage;
+use salsa::{Cancelled, Database, DbWithJar};
 
-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 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};
 
-mod jars;
-mod query;
-mod runtime;
-mod storage;
+use crate::lint::{lint_semantic, lint_syntax, unwind_if_cancelled, Diagnostics};
+use crate::watch::{FileChangeKind, FileWatcherChange};
+use crate::workspace::{check_file, Package, Workspace, WorkspaceMetadata};
 
-pub trait Database {
-    /// Returns a reference to the runtime of the current worker.
-    fn runtime(&self) -> &DbRuntime;
+pub trait Db: DbWithJar<Jar> + SemanticDb + Upcast<dyn SemanticDb> {}
 
-    /// 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::jar(db=Db)]
+pub struct Jar(
+    Workspace,
+    Package,
+    lint_syntax,
+    lint_semantic,
+    unwind_if_cancelled,
+);
 
-    /// Returns `Ok` if the queries have not been cancelled and `Err(QueryError::Cancelled)` otherwise.
-    fn cancelled(&self) -> QueryResult<()> {
-        self.runtime().cancelled()
+#[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>,
+}
+
+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),
+        };
+
+        let workspace = Workspace::from_metadata(&db, workspace);
+        // Initialize the `Program` singleton
+        Program::from_settings(&db, settings);
+
+        db.workspace = Some(workspace);
+        db
     }
 
-    /// Returns `true` if the queries have been cancelled.
-    fn is_cancelled(&self) -> bool {
-        self.runtime().is_cancelled()
+    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);
+        }
+
+        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}");
+                }
+            }
+        }
+    }
+
+    /// 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))
+    }
+
+    pub fn check_file(&self, file: File) -> Result<Diagnostics, Cancelled> {
+        self.with_db(|db| check_file(db, file))
+    }
+
+    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))
     }
 }
 
-/// 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>;
-}
-
-pub trait DbWithJar<Jar>: Database + HasJar<Jar> {}
-
-/// 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 Upcast<dyn SemanticDb> for RootDatabase {
+    fn upcast(&self) -> &(dyn SemanticDb + 'static) {
+        self
     }
 }
 
-impl<DB> std::ops::Deref for Snapshot<DB>
-where
-    DB: ParallelDatabase,
-{
-    type Target = DB;
-
-    fn deref(&self) -> &DB {
-        &self.db
+impl Upcast<dyn SourceDb> for RootDatabase {
+    fn upcast(&self) -> &(dyn SourceDb + 'static) {
+        self
     }
 }
 
-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>,
-    }
-
-    impl HasJar<SourceJar> for TestDb {
-        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 TestDb {
-        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 TestDb {
-        fn jar(&self) -> QueryResult<&LintJar> {
-            Ok(&self.jars()?.2)
-        }
-
-        fn jar_mut(&mut self) -> &mut LintJar {
-            &mut self.jars_mut().2
-        }
-    }
-
-    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()
-        }
+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(),
+        })
     }
 }

crates/red_knot/src/db/jars.rs

@@ -1,37 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,180 +0,0 @@
-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

@@ -1,67 +0,0 @@
-//! 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

@@ -1,556 +0,0 @@
-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,108 +1,6 @@
-use std::fmt::Formatter;
-use std::hash::BuildHasherDefault;
-use std::ops::Deref;
-use std::path::{Path, PathBuf};
+use crate::db::Jar;
 
-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(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())
-    }
-}
+pub mod workspace;

crates/red_knot/src/lint.rs

@@ -1,60 +1,59 @@
 use std::cell::RefCell;
-use std::ops::{Deref, DerefMut};
-use std::sync::Arc;
+use std::ops::Deref;
 use std::time::Duration;
 
-use ruff_python_ast::visitor::Visitor;
-use ruff_python_ast::{ModModule, StringLiteral};
-use ruff_python_parser::Parsed;
+use tracing::trace_span;
 
-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 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};
 
-#[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;
+use crate::db::Db;
 
+/// 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 {
-            db.cancelled()?;
+            unwind_if_cancelled(db);
+
             println!("RED_KNOT_SLOW_LINT is set, sleeping for {i}/10 seconds");
             std::thread::sleep(Duration::from_secs(1));
         }
     }
 
-    storage.get(&file_id, |file_id| {
-        let mut diagnostics = Vec::new();
+    let mut diagnostics = Vec::new();
 
-        let source = source_text(db.upcast(), *file_id)?;
-        lint_lines(source.text(), &mut diagnostics);
+    let source = source_text(db.upcast(), file_id);
+    lint_lines(&source, &mut diagnostics);
 
-        let parsed = parse(db.upcast(), *file_id)?;
+    let parsed = parsed_module(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.text(),
-            };
-            visitor.visit_body(&ast.body);
-            diagnostics = visitor.diagnostics;
-        } else {
-            diagnostics.extend(parsed.errors().iter().map(std::string::ToString::to_string));
-        }
+        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));
+    }
 
-        Ok(Diagnostics::from(diagnostics))
-    })
+    Diagnostics::from(diagnostics)
 }
 
 fn lint_lines(source: &str, diagnostics: &mut Vec<String>) {
@@ -74,177 +73,125 @@ fn lint_lines(source: &str, diagnostics: &mut Vec<String>) {
     }
 }
 
-#[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;
+#[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();
 
-    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)?;
+    let source = source_text(db.upcast(), file_id);
+    let parsed = parsed_module(db.upcast(), file_id);
+    let semantic = SemanticModel::new(db.upcast(), file_id);
 
-        let context = SemanticLintContext {
-            file_id: *file_id,
-            source,
-            parsed: &parsed,
-            semantic_index,
-            db,
-            diagnostics: RefCell::new(Vec::new()),
-        };
-
-        lint_unresolved_imports(&context)?;
-        lint_bad_overrides(&context)?;
-
-        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);
-                }
-            }
-            _ => {}
-        }
+    if !parsed.is_valid() {
+        return Diagnostics::Empty;
     }
 
-    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(());
+    let context = SemanticLintContext {
+        source,
+        parsed,
+        semantic,
+        diagnostics: RefCell::new(Vec::new()),
     };
 
-    // 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;
+    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));
+                }
+            }
         }
-        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");
+        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 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 this shouldn't make direct use of the Db; see comment on SemanticModel::db
+        let db = semantic.db();
+
+        if ty.has_decorator(db, override_ty) {
+            let method_name = ty.name(db);
+            if class_ty
+                .inherited_class_member(db, &method_name)
+                .is_unbound()
             {
                 // 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.name(context.db.upcast())?,
+                        class_ty.name(db),
                         method_name,
                     ));
             }
         }
     }
-    Ok(())
 }
 
-pub struct SemanticLintContext<'a> {
-    file_id: FileId,
-    source: Source,
-    parsed: &'a Parsed<ModModule>,
-    semantic_index: Arc<SemanticIndex>,
-    db: &'a dyn LintDb,
+pub(crate) struct SemanticLintContext<'a> {
+    source: SourceText,
+    parsed: &'a ParsedModule,
+    semantic: SemanticModel<'a>,
     diagnostics: RefCell<Vec<String>>,
 }
 
-impl<'a> SemanticLintContext<'a> {
-    pub fn source_text(&self) -> &str {
-        self.source.text()
+impl<'db> SemanticLintContext<'db> {
+    #[allow(unused)]
+    pub(crate) fn source_text(&self) -> &str {
+        self.source.as_str()
     }
 
-    pub fn file_id(&self) -> FileId {
-        self.file_id
-    }
-
-    pub fn ast(&self) -> &'a ModModule {
+    #[allow(unused)]
+    pub(crate) fn ast(&self) -> &'db ast::ModModule {
         self.parsed.syntax()
     }
 
-    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) {
+    pub(crate) fn push_diagnostic(&self, diagnostic: String) {
         self.diagnostics.borrow_mut().push(diagnostic);
     }
 
-    pub fn extend_diagnostics(&mut self, diagnostics: impl IntoIterator<Item = String>) {
+    #[allow(unused)]
+    pub(crate) 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)]
@@ -254,7 +201,7 @@ struct SyntaxLintVisitor<'a> {
 }
 
 impl Visitor<'_> for SyntaxLintVisitor<'_> {
-    fn visit_string_literal(&mut self, string_literal: &'_ StringLiteral) {
+    fn visit_string_literal(&mut self, string_literal: &'_ ast::StringLiteral) {
         // A very naive implementation of use double quotes
         let text = &self.source[string_literal.range];
 
@@ -265,10 +212,33 @@ impl Visitor<'_> for SyntaxLintVisitor<'_> {
     }
 }
 
-#[derive(Debug, Clone)]
+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)]
 pub enum Diagnostics {
     Empty,
-    List(Arc<Vec<String>>),
+    List(Vec<String>),
 }
 
 impl Diagnostics {
@@ -292,41 +262,13 @@ impl From<Vec<String>> for Diagnostics {
         if value.is_empty() {
             Diagnostics::Empty
         } else {
-            Diagnostics::List(Arc::new(value))
+            Diagnostics::List(value)
         }
     }
 }
 
-#[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
-    }
+#[derive(Copy, Clone, Debug)]
+enum AnyImportRef<'a> {
+    Import(&'a ast::StmtImport),
+    ImportFrom(&'a ast::StmtImportFrom),
 }

crates/red_knot/src/main.rs

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

crates/red_knot/src/parse.rs

@@ -1,41 +0,0 @@
-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

@@ -1,413 +0,0 @@
-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

@@ -1,275 +0,0 @@
-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

@@ -1,882 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,270 +0,0 @@
-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

@@ -1,560 +0,0 @@
-#![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

@@ -1,762 +0,0 @@
-#![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

@@ -1,105 +0,0 @@
-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, RemoveKind};
+use notify::event::{CreateKind, ModifyKind, RemoveKind};
 use notify::{recommended_watcher, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
 
-use crate::program::{FileChangeKind, FileWatcherChange};
+use ruff_db::system::{SystemPath, SystemPathBuf};
 
 pub struct FileWatcher {
     watcher: RecommendedWatcher,
@@ -33,12 +33,25 @@ impl FileWatcher {
     }
 
     fn from_handler(handler: Box<dyn EventHandler>) -> anyhow::Result<Self> {
-        let watcher = recommended_watcher(move |changes: notify::Result<Event>| {
-            match changes {
+        let watcher = recommended_watcher(move |event: notify::Result<Event>| {
+            match event {
                 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,
                         _ => {
@@ -49,8 +62,9 @@ impl FileWatcher {
                     let mut changes = Vec::new();
 
                     for path in event.paths {
-                        if path.is_file() {
-                            changes.push(FileWatcherChange::new(path, change_kind));
+                        if let Some(fs_path) = SystemPath::from_std_path(&path) {
+                            changes
+                                .push(FileWatcherChange::new(fs_path.to_path_buf(), change_kind));
                         }
                     }
 
@@ -75,3 +89,23 @@ 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

@@ -0,0 +1,344 @@
+// 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

@@ -0,0 +1,68 @@
+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,9 +14,11 @@ 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 }
 
@@ -26,6 +28,8 @@ 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,83 +1,61 @@
 use ruff_db::Upcast;
 
 use crate::resolver::{
-    file_to_module,
-    internal::{ModuleNameIngredient, ModuleResolverSearchPaths},
-    resolve_module_query,
+    editable_install_resolution_paths, file_to_module, internal::ModuleNameIngredient,
+    module_resolution_settings, resolve_module_query,
 };
+use crate::typeshed::parse_typeshed_versions;
 
 #[salsa::jar(db=Db)]
 pub struct Jar(
     ModuleNameIngredient<'_>,
-    ModuleResolverSearchPaths,
+    module_resolution_settings,
+    editable_install_resolution_paths,
     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::file_system::{FileSystem, MemoryFileSystem, OsFileSystem};
-    use ruff_db::vfs::Vfs;
+    use ruff_db::files::Files;
+    use ruff_db::system::{DbWithTestSystem, TestSystem};
+    use ruff_db::vendored::VendoredFileSystem;
+
+    use crate::vendored_typeshed_stubs;
 
     use super::*;
 
     #[salsa::db(Jar, ruff_db::Jar)]
     pub(crate) struct TestDb {
         storage: salsa::Storage<Self>,
-        file_system: TestFileSystem,
+        system: TestSystem,
+        vendored: VendoredFileSystem,
+        files: Files,
         events: sync::Arc<sync::Mutex<Vec<salsa::Event>>>,
-        vfs: Vfs,
     }
 
     impl TestDb {
-        #[allow(unused)]
         pub(crate) fn new() -> Self {
             Self {
                 storage: salsa::Storage::default(),
-                file_system: TestFileSystem::Memory(MemoryFileSystem::default()),
+                system: TestSystem::default(),
+                vendored: vendored_typeshed_stubs().snapshot(),
                 events: sync::Arc::default(),
-                vfs: Vfs::with_stubbed_vendored(),
+                files: Files::default(),
             }
         }
 
-        /// 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");
 
@@ -89,7 +67,6 @@ 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();
         }
@@ -102,17 +79,31 @@ pub(crate) mod tests {
     }
 
     impl ruff_db::Db for TestDb {
-        fn file_system(&self) -> &dyn ruff_db::file_system::FileSystem {
-            self.file_system.inner()
+        fn vendored(&self) -> &VendoredFileSystem {
+            &self.vendored
         }
 
-        fn vfs(&self) -> &ruff_db::vfs::Vfs {
-            &self.vfs
+        fn system(&self) -> &dyn ruff_db::system::System {
+            &self.system
+        }
+
+        fn files(&self) -> &Files {
+            &self.files
         }
     }
 
     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));
@@ -125,32 +116,11 @@ pub(crate) mod tests {
         fn snapshot(&self) -> salsa::Snapshot<Self> {
             salsa::Snapshot::new(Self {
                 storage: self.storage.snapshot(),
-                file_system: self.file_system.snapshot(),
+                system: self.system.snapshot(),
+                vendored: self.vendored.snapshot(),
+                files: self.files.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,9 +1,18 @@
 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::{ModuleKind, ModuleName};
-pub use resolver::{resolve_module, set_module_resolution_settings, ModuleResolutionSettings};
-pub use typeshed::versions::TypeshedVersions;
+pub use module::{Module, ModuleKind};
+pub use module_name::ModuleName;
+pub use resolver::resolve_module;
+pub use typeshed::{
+    vendored_typeshed_stubs, TypeshedVersionsParseError, TypeshedVersionsParseErrorKind,
+};

crates/red_knot_module_resolver/src/module.rs

@@ -1,191 +1,11 @@
 use std::fmt::Formatter;
-use std::ops::Deref;
 use std::sync::Arc;
 
-use ruff_db::file_system::FileSystemPath;
-use ruff_db::vfs::{VfsFile, VfsPath};
-use ruff_python_stdlib::identifiers::is_identifier;
+use ruff_db::files::File;
 
-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)
-    }
-}
+use crate::db::Db;
+use crate::module_name::ModuleName;
+use crate::path::{ModuleResolutionPathBuf, ModuleResolutionPathRef};
 
 /// Representation of a Python module.
 #[derive(Clone, PartialEq, Eq)]
@@ -197,8 +17,8 @@ impl Module {
     pub(crate) fn new(
         name: ModuleName,
         kind: ModuleKind,
-        search_path: ModuleSearchPath,
-        file: VfsFile,
+        search_path: Arc<ModuleResolutionPathBuf>,
+        file: File,
     ) -> Self {
         Self {
             inner: Arc::new(ModuleInner {
@@ -216,13 +36,13 @@ impl Module {
     }
 
     /// The file to the source code that defines this module
-    pub fn file(&self) -> VfsFile {
+    pub fn file(&self) -> File {
         self.inner.file
     }
 
     /// The search path from which the module was resolved.
-    pub fn search_path(&self) -> &ModuleSearchPath {
-        &self.inner.search_path
+    pub(crate) fn search_path(&self) -> ModuleResolutionPathRef {
+        ModuleResolutionPathRef::from(&*self.inner.search_path)
     }
 
     /// Determine whether this module is a single-file module or a package
@@ -257,8 +77,8 @@ impl salsa::DebugWithDb<dyn Db> for Module {
 struct ModuleInner {
     name: ModuleName,
     kind: ModuleKind,
-    search_path: ModuleSearchPath,
-    file: VfsFile,
+    search_path: Arc<ModuleResolutionPathBuf>,
+    file: File,
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
@@ -269,78 +89,3 @@ 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

@@ -0,0 +1,198 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,289 @@
+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,91 +1,8 @@
-pub(crate) mod versions;
+pub use self::vendored::vendored_typeshed_stubs;
+pub(crate) use self::versions::{
+    parse_typeshed_versions, LazyTypeshedVersions, TypeshedVersionsQueryResult,
+};
+pub use self::versions::{TypeshedVersionsParseError, TypeshedVersionsParseErrorKind};
 
-#[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!"
-        );
-    }
-}
+mod vendored;
+mod versions;

crates/red_knot_module_resolver/src/typeshed/vendored.rs

@@ -0,0 +1,99 @@
+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,16 +1,97 @@
+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 crate::module::ModuleName;
+use ruff_db::files::{system_path_to_file, File};
 
-#[derive(Debug, PartialEq, Eq)]
+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)]
 pub struct TypeshedVersionsParseError {
-    line_number: NonZeroU16,
+    line_number: Option<NonZeroU16>,
     reason: TypeshedVersionsParseErrorKind,
 }
 
@@ -20,10 +101,14 @@ impl fmt::Display for TypeshedVersionsParseError {
             line_number,
             reason,
         } = self;
-        write!(
-            f,
-            "Error while parsing line {line_number} of typeshed's VERSIONS file: {reason}"
-        )
+        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}")
+        }
     }
 }
 
@@ -37,7 +122,7 @@ impl std::error::Error for TypeshedVersionsParseError {
     }
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum TypeshedVersionsParseErrorKind {
     TooManyLines(NonZeroUsize),
     UnexpectedNumberOfColons,
@@ -81,38 +166,94 @@ impl fmt::Display for TypeshedVersionsParseErrorKind {
 }
 
 #[derive(Debug, PartialEq, Eq)]
-pub struct TypeshedVersions(FxHashMap<ModuleName, PyVersionRange>);
+pub(crate) struct TypeshedVersions(FxHashMap<ModuleName, PyVersionRange>);
 
 impl TypeshedVersions {
-    pub fn len(&self) -> usize {
-        self.0.len()
+    #[must_use]
+    fn exact(&self, module_name: &ModuleName) -> Option<&PyVersionRange> {
+        self.0.get(module_name)
     }
 
-    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(
+    #[must_use]
+    fn query_module(
         &self,
-        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);
+        module: &ModuleName,
+        target_version: PyVersion,
+    ) -> TypeshedVersionsQueryResult {
+        if let Some(range) = self.exact(module) {
+            if range.contains(target_version) {
+                TypeshedVersionsQueryResult::Exists
+            } else {
+                TypeshedVersionsQueryResult::DoesNotExist
             }
-            module = module_to_try.parent();
+        } 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
         }
-        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;
 
@@ -125,7 +266,7 @@ impl FromStr for TypeshedVersions {
 
             let Ok(line_number) = NonZeroU16::try_from(line_number) else {
                 return Err(TypeshedVersionsParseError {
-                    line_number: NonZeroU16::MAX,
+                    line_number: None,
                     reason: TypeshedVersionsParseErrorKind::TooManyLines(line_number),
                 });
             };
@@ -141,14 +282,14 @@ impl FromStr for TypeshedVersions {
             let (Some(module_name), Some(rest), None) = (parts.next(), parts.next(), parts.next())
             else {
                 return Err(TypeshedVersionsParseError {
-                    line_number,
+                    line_number: Some(line_number),
                     reason: TypeshedVersionsParseErrorKind::UnexpectedNumberOfColons,
                 });
             };
 
             let Some(module_name) = ModuleName::new(module_name) else {
                 return Err(TypeshedVersionsParseError {
-                    line_number,
+                    line_number: Some(line_number),
                     reason: TypeshedVersionsParseErrorKind::InvalidModuleName(
                         module_name.to_string(),
                     ),
@@ -159,7 +300,7 @@ impl FromStr for TypeshedVersions {
                 Ok(version) => map.insert(module_name, version),
                 Err(reason) => {
                     return Err(TypeshedVersionsParseError {
-                        line_number,
+                        line_number: Some(line_number),
                         reason,
                     })
                 }
@@ -180,13 +321,14 @@ impl fmt::Display for TypeshedVersions {
     }
 }
 
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
 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),
@@ -222,7 +364,7 @@ impl fmt::Display for PyVersionRange {
 }
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
-pub struct PyVersion {
+struct PyVersion {
     major: u8,
     minor: u8,
 }
@@ -266,38 +408,25 @@ impl fmt::Display for PyVersion {
     }
 }
 
-// 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 {
+impl From<TargetVersion> for PyVersion {
+    fn from(value: TargetVersion) -> Self {
         match value {
-            SupportedPyVersion::Py37 => PyVersion { major: 3, minor: 7 },
-            SupportedPyVersion::Py38 => PyVersion { major: 3, minor: 8 },
-            SupportedPyVersion::Py39 => PyVersion { major: 3, minor: 9 },
-            SupportedPyVersion::Py310 => PyVersion {
+            TargetVersion::Py37 => PyVersion { major: 3, minor: 7 },
+            TargetVersion::Py38 => PyVersion { major: 3, minor: 8 },
+            TargetVersion::Py39 => PyVersion { major: 3, minor: 9 },
+            TargetVersion::Py310 => PyVersion {
                 major: 3,
                 minor: 10,
             },
-            SupportedPyVersion::Py311 => PyVersion {
+            TargetVersion::Py311 => PyVersion {
                 major: 3,
                 minor: 11,
             },
-            SupportedPyVersion::Py312 => PyVersion {
+            TargetVersion::Py312 => PyVersion {
                 major: 3,
                 minor: 12,
             },
-            SupportedPyVersion::Py313 => PyVersion {
+            TargetVersion::Py313 => PyVersion {
                 major: 3,
                 minor: 13,
             },
@@ -310,14 +439,27 @@ mod tests {
     use std::num::{IntErrorKind, NonZeroU16};
     use std::path::Path;
 
-    use super::*;
-
     use insta::assert_snapshot;
+    use ruff_db::program::TargetVersion;
+
+    use super::*;
 
     const TYPESHED_STDLIB_DIR: &str = "stdlib";
 
     #[allow(unsafe_code)]
-    const ONE: NonZeroU16 = unsafe { NonZeroU16::new_unchecked(1) };
+    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()
+        }
+    }
 
     #[test]
     fn can_parse_vendored_versions_file() {
@@ -334,18 +476,31 @@ mod tests {
         let asyncio_staggered = ModuleName::new_static("asyncio.staggered").unwrap();
         let audioop = ModuleName::new_static("audioop").unwrap();
 
-        assert!(versions.contains_module(&asyncio));
-        assert!(versions.module_exists_on_version(asyncio, SupportedPyVersion::Py310));
-
-        assert!(versions.contains_module(&asyncio_staggered));
-        assert!(
-            versions.module_exists_on_version(asyncio_staggered.clone(), SupportedPyVersion::Py38)
+        assert!(versions.contains_exact(&asyncio));
+        assert_eq!(
+            versions.query_module(&asyncio, TargetVersion::Py310.into()),
+            TypeshedVersionsQueryResult::Exists
         );
-        assert!(!versions.module_exists_on_version(asyncio_staggered, SupportedPyVersion::Py37));
 
-        assert!(versions.contains_module(&audioop));
-        assert!(versions.module_exists_on_version(audioop.clone(), SupportedPyVersion::Py312));
-        assert!(!versions.module_exists_on_version(audioop, SupportedPyVersion::Py313));
+        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_exact(&audioop));
+        assert_eq!(
+            versions.query_module(&audioop, TargetVersion::Py312.into()),
+            TypeshedVersionsQueryResult::Exists
+        );
+        assert_eq!(
+            versions.query_module(&audioop, TargetVersion::Py313.into()),
+            TypeshedVersionsQueryResult::DoesNotExist
+        );
     }
 
     #[test]
@@ -393,7 +548,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_module(&top_level_module));
+            assert!(vendored_typeshed_versions.contains_exact(&top_level_module));
         }
 
         assert!(
@@ -426,30 +581,102 @@ foo: 3.8-   # trailing comment
         foo: 3.8-
         "###
         );
+    }
 
-        let foo = ModuleName::new_static("foo").unwrap();
+    #[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_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_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));
+        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
+        );
     }
 
     #[test]
@@ -465,7 +692,7 @@ foo: 3.8-   # trailing comment
         assert_eq!(
             TypeshedVersions::from_str(&massive_versions_file),
             Err(TypeshedVersionsParseError {
-                line_number: NonZeroU16::MAX,
+                line_number: None,
                 reason: TypeshedVersionsParseErrorKind::TooManyLines(
                     NonZeroUsize::new(too_many + 1 - offset).unwrap()
                 )

crates/red_knot_module_resolver/vendor/typeshed/source_commit.txt

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

crates/red_knot_module_resolver/vendor/typeshed/stdlib/VERSIONS

@@ -34,6 +34,9 @@ _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-
@@ -111,6 +114,7 @@ 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-
@@ -154,6 +158,7 @@ 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,6 +70,8 @@ _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]: ...
@@ -83,6 +85,8 @@ 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,7 +64,6 @@ 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
@@ -100,8 +99,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(arg: _CT, /) -> _Pointer[_CT]: ...
+def POINTER(type: type[_CT], /) -> type[_Pointer[_CT]]: ...
+def pointer(obj: _CT, /) -> _Pointer[_CT]: ...
 
 class _CArgObject: ...
 
@@ -203,9 +202,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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,50 @@
+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 = ..., timeout: float = ...) -> bool: ...
+    def acquire(self, blocking: bool = True, timeout: float = -1) -> 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 = ...) -> int: ...
+def stack_size(size: int = 0, /) -> int: ...
 
 TIMEOUT_MAX: float
 

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

@@ -21,8 +21,9 @@ class ProxyType(Generic[_T]):  # "weakproxy"
     def __getattr__(self, attr: str) -> Any: ...
 
 class ReferenceType(Generic[_T]):
-    __callback__: Callable[[ReferenceType[_T]], Any]
-    def __new__(cls, o: _T, callback: Callable[[ReferenceType[_T]], Any] | None = ..., /) -> Self: ...
+    __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: ...
     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("Deprecated, use 'classmethod' with 'abstractmethod' instead")
+@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("Deprecated, use 'staticmethod' with 'abstractmethod' instead")
+@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("Deprecated, use 'property' with 'abstractmethod' instead")
+@deprecated("Use 'property' with 'abstractmethod' instead")
 class abstractproperty(property):
     __isabstractmethod__: Literal[True]
 

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

@@ -32,6 +32,7 @@ _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
@@ -89,7 +90,7 @@ class _ActionsContainer:
         nargs: int | _NArgsStr | _SUPPRESS_T | None = None,
         const: Any = ...,
         default: Any = ...,
-        type: Callable[[str], _T] | FileType = ...,
+        type: _ActionType = ...,
         choices: Iterable[_T] | None = ...,
         required: bool = ...,
         help: str | None = ...,
@@ -313,7 +314,7 @@ class Action(_AttributeHolder):
     nargs: int | str | None
     const: Any
     default: Any
-    type: Callable[[str], Any] | FileType | None
+    type: _ActionType | None
     choices: Iterable[Any] | None
     required: bool
     help: str | None
@@ -699,6 +700,7 @@ 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(
@@ -721,6 +723,7 @@ 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(
@@ -742,6 +745,7 @@ 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,6 +49,10 @@ 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: ...
@@ -222,7 +226,48 @@ class BaseEventLoop(AbstractEventLoop):
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
-    if sys.version_info >= (3, 11):
+
+    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,
@@ -259,26 +304,6 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_shutdown_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
-        async def start_tls(
-            self,
-            transport: BaseTransport,
-            protocol: BaseProtocol,
-            sslcontext: ssl.SSLContext,
-            *,
-            server_side: bool = False,
-            server_hostname: str | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-        ) -> Transport | None: ...
-        async def connect_accepted_socket(
-            self,
-            protocol_factory: Callable[[], _ProtocolT],
-            sock: socket,
-            *,
-            ssl: _SSLContext = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-        ) -> tuple[Transport, _ProtocolT]: ...
     else:
         @overload
         async def create_server(
@@ -314,6 +339,29 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_handshake_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
+
+    if sys.version_info >= (3, 11):
+        async def start_tls(
+            self,
+            transport: BaseTransport,
+            protocol: BaseProtocol,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_side: bool = False,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> Transport | None: ...
+        async def connect_accepted_socket(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            sock: socket,
+            *,
+            ssl: _SSLContext = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> tuple[Transport, _ProtocolT]: ...
+    else:
         async def start_tls(
             self,
             transport: BaseTransport,

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

@@ -16,23 +16,40 @@ from .tasks import Task
 from .transports import BaseTransport, DatagramTransport, ReadTransport, SubprocessTransport, Transport, WriteTransport
 from .unix_events import AbstractChildWatcher
 
-__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",
-)
+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",
+    )
 
 _T = TypeVar("_T")
 _Ts = TypeVarTuple("_Ts")
@@ -77,6 +94,12 @@ 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
@@ -255,7 +278,50 @@ class AbstractEventLoop:
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
-    if sys.version_info >= (3, 11):
+
+    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(
@@ -294,30 +360,6 @@ class AbstractEventLoop:
             ssl_shutdown_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
-        @abstractmethod
-        async def start_tls(
-            self,
-            transport: WriteTransport,
-            protocol: BaseProtocol,
-            sslcontext: ssl.SSLContext,
-            *,
-            server_side: bool = False,
-            server_hostname: str | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-        ) -> Transport | None: ...
-        async def create_unix_server(
-            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,
-        ) -> Server: ...
     else:
         @overload
         @abstractmethod
@@ -355,6 +397,33 @@ class AbstractEventLoop:
             ssl_handshake_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
+
+    if sys.version_info >= (3, 11):
+        @abstractmethod
+        async def start_tls(
+            self,
+            transport: WriteTransport,
+            protocol: BaseProtocol,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_side: bool = False,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> Transport | None: ...
+        async def create_unix_server(
+            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,
+        ) -> Server: ...
+    else:
         @abstractmethod
         async def start_tls(
             self,
@@ -377,6 +446,7 @@ 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,
@@ -541,18 +611,19 @@ class AbstractEventLoopPolicy:
     @abstractmethod
     def new_event_loop(self) -> AbstractEventLoop: ...
     # Child processes handling (Unix only).
-    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, 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: ...
 
 class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy, metaclass=ABCMeta):
     def get_event_loop(self) -> AbstractEventLoop: ...
@@ -565,15 +636,16 @@ def get_event_loop() -> AbstractEventLoop: ...
 def set_event_loop(loop: AbstractEventLoop | None) -> None: ...
 def new_event_loop() -> AbstractEventLoop: ...
 
-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, 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: ...
 
-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,4 +1,5 @@
 import functools
+import sys
 import traceback
 from collections.abc import Iterable
 from types import FrameType, FunctionType
@@ -14,7 +15,17 @@ _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: ...
-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: ...
+
+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 extract_stack(f: FrameType | None = None, limit: int | None = None) -> traceback.StackSummary: ...

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

@@ -10,13 +10,20 @@ 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
@@ -42,6 +49,8 @@ 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,6 +2,7 @@ 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
 
@@ -130,7 +131,10 @@ 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, 11):
+
+    if sys.version_info >= (3, 13):
+        def __del__(self, warnings: ModuleType = ...) -> None: ...
+    elif 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,7 +70,10 @@ _T4 = TypeVar("_T4")
 _T5 = TypeVar("_T5")
 _T6 = TypeVar("_T6")
 _FT = TypeVar("_FT", bound=Future[Any])
-_FutureLike: TypeAlias = Future[_T] | Generator[Any, None, _T] | Awaitable[_T]
+if sys.version_info >= (3, 12):
+    _FutureLike: TypeAlias = Future[_T] | Awaitable[_T]
+else:
+    _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,63 +1,34 @@
 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")
 
-# 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, 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: ...
-
 if sys.platform != "win32":
-    if sys.version_info >= (3, 9):
+    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",
@@ -79,118 +50,202 @@ if sys.platform != "win32":
             "DefaultEventLoopPolicy",
         )
 
-    # 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: ...
-
+# 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 SafeChildWatcher(BaseChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
+        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: ...
-
-        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-        class FastChildWatcher(BaseChildWatcher):
+            @abstractmethod
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            @abstractmethod
+            def close(self) -> None: ...
+            @abstractmethod
             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]
+            @abstractmethod
+            def __exit__(
+                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
             ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
+            @abstractmethod
+            def is_active(self) -> bool: ...
 
     else:
-        class SafeChildWatcher(BaseChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
+        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: ...
-
-        class FastChildWatcher(BaseChildWatcher):
+            @abstractmethod
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            @abstractmethod
+            def close(self) -> None: ...
+            @abstractmethod
             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]
+            @abstractmethod
+            def __exit__(
+                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
             ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
+            @abstractmethod
+            def is_active(self) -> bool: ...
 
-    class _UnixSelectorEventLoop(BaseSelectorEventLoop): ...
+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: ...
+
+            @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: ...
+
+            @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: ...
+
+        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: ...
+
+            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 _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 _UnixDefaultEventLoopPolicy(BaseDefaultEventLoopPolicy):
-        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, 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: ...
 
     SelectorEventLoop = _UnixSelectorEventLoop
 
     DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
 
-    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: ...
+    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]: ...
             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: ...
 
-    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: ...
+        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,14 +7,26 @@ from typing import IO, Any, ClassVar, Literal, NoReturn
 from . import events, futures, proactor_events, selector_events, streams, windows_utils
 
 if sys.platform == "win32":
-    __all__ = (
-        "SelectorEventLoop",
-        "ProactorEventLoop",
-        "IocpProactor",
-        "DefaultEventLoopPolicy",
-        "WindowsSelectorEventLoopPolicy",
-        "WindowsProactorEventLoopPolicy",
-    )
+    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",
+        )
 
     NULL: Literal[0]
     INFINITE: Literal[0xFFFFFFFF]
@@ -74,8 +86,9 @@ if sys.platform == "win32":
 
     class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
         _loop_factory: ClassVar[type[SelectorEventLoop]]
-        def get_child_watcher(self) -> NoReturn: ...
-        def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+        if sys.version_info < (3, 14):
+            def get_child_watcher(self) -> NoReturn: ...
+            def set_child_watcher(self, watcher: Any) -> NoReturn: ...
 
     class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
         _loop_factory: ClassVar[type[ProactorEventLoop]]
@@ -83,3 +96,5 @@ 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
+from _typeshed import ExcInfo, TraceFunction, Unused
 from collections.abc import Callable, Iterable, Mapping
 from types import CodeType, FrameType, TracebackType
 from typing import IO, Any, Literal, SupportsInt, TypeVar
@@ -32,6 +32,9 @@ 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: ...
@@ -42,7 +45,13 @@ 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,6 +75,7 @@ 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)
@@ -823,8 +824,12 @@ 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[int]):
+class memoryview(Sequence[_I]):
     @property
     def format(self) -> str: ...
     @property
@@ -854,13 +859,20 @@ class memoryview(Sequence[int]):
     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 __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], /) -> int: ...
+    def cast(self, format: Literal["c", "@c"], shape: list[int] | tuple[int, ...] = ...) -> memoryview[bytes]: ...
     @overload
-    def __getitem__(self, key: slice, /) -> memoryview: ...
+    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 __contains__(self, x: object, /) -> bool: ...
-    def __iter__(self) -> Iterator[int]: ...
+    def __iter__(self) -> Iterator[_I]: ...
     def __len__(self) -> int: ...
     def __eq__(self, value: object, /) -> bool: ...
     def __hash__(self) -> int: ...
@@ -1673,9 +1685,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: ...
+def pow(base: _SupportsPow2[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
 @overload
-def pow(base: _SupportsPow3NoneOnly[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...
+def pow(base: _SupportsPow3NoneOnly[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
 @overload
 def pow(base: _SupportsPow3[_E, _M, _T_co], exp: _E, mod: _M) -> _T_co: ...
 @overload
@@ -2006,9 +2018,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)
+    _BaseExceptionT_co = TypeVar("_BaseExceptionT_co", bound=BaseException, covariant=True, default=BaseException)
     _BaseExceptionT = TypeVar("_BaseExceptionT", bound=BaseException)
-    _ExceptionT_co = TypeVar("_ExceptionT_co", bound=Exception, covariant=True)
+    _ExceptionT_co = TypeVar("_ExceptionT_co", bound=Exception, covariant=True, default=Exception)
     _ExceptionT = TypeVar("_ExceptionT", bound=Exception)
 
     # See `check_exception_group.py` for use-cases and comments.
@@ -2072,5 +2084,4 @@ 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,3 +1,5 @@
+import sys
+
 from ._base import (
     ALL_COMPLETED as ALL_COMPLETED,
     FIRST_COMPLETED as FIRST_COMPLETED,
@@ -14,19 +16,36 @@ from ._base import (
 from .process import ProcessPoolExecutor as ProcessPoolExecutor
 from .thread import ThreadPoolExecutor as ThreadPoolExecutor
 
-__all__ = (
-    "FIRST_COMPLETED",
-    "FIRST_EXCEPTION",
-    "ALL_COMPLETED",
-    "CancelledError",
-    "TimeoutError",
-    "BrokenExecutor",
-    "Future",
-    "Executor",
-    "wait",
-    "as_completed",
-    "ProcessPoolExecutor",
-    "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",
+    )
 
 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]
+    type: Type[_T] | str | Any
     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,6 +19,9 @@ 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,6 +15,9 @@ 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

@@ -0,0 +1,29 @@
+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,6 +31,9 @@ __all__ = [
     "EXTENDED_ARG",
     "stack_effect",
 ]
+if sys.version_info >= (3, 13):
+    __all__ += ["hasjump"]
+
 if sys.version_info >= (3, 12):
     __all__ += ["hasarg", "hasexc"]
 else:
@@ -86,12 +89,41 @@ else:
         is_jump_target: bool
 
 class Instruction(_Instruction):
-    def _disassemble(self, lineno_width: int = 3, mark_as_current: bool = False, offset_width: int = 4) -> str: ...
+    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: ...
 
 class Bytecode:
     codeobj: types.CodeType
     first_line: int
-    if sys.version_info >= (3, 11):
+    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):
         def __init__(
             self,
             x: _HaveCodeType | str,
@@ -101,12 +133,15 @@ 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: ...
 
@@ -121,7 +156,41 @@ 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, 11):
+if sys.version_info >= (3, 13):
+    # 3.13 added `show_offsets`
+    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,
+        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`
     def dis(
         x: _HaveCodeType | str | bytes | bytearray | None = None,
         *,
@@ -130,19 +199,9 @@ if sys.version_info >= (3, 11):
         show_caches: bool = False,
         adaptive: bool = False,
     ) -> None: ...
-
-else:
-    def dis(
-        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: ...
@@ -151,9 +210,13 @@ if 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,6 +1,7 @@
 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
@@ -28,9 +29,21 @@ _PDTZ: TypeAlias = tuple[int, int, int, int, int, int, int, int, int, int | None
 
 def quote(str: str) -> str: ...
 def unquote(str: str) -> str: ...
-def parseaddr(addr: str | None) -> tuple[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 formataddr(pair: tuple[str | None, str], charset: str | Charset = "utf-8") -> str: ...
-def getaddresses(fieldvalues: list[str]) -> list[tuple[str, 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]]: ...
+
 @overload
 def parsedate(data: None) -> None: ...
 @overload

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

@@ -1,6 +1,7 @@
 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
@@ -36,11 +37,8 @@ if sys.version_info >= (3, 10):
     from importlib.metadata._meta import PackageMetadata as PackageMetadata, SimplePath
     def packages_distributions() -> Mapping[str, list[str]]: ...
 
-    if sys.version_info >= (3, 12):
-        # It's generic but shouldn't be
-        _SimplePath: TypeAlias = SimplePath[Any]
-    else:
-        _SimplePath: TypeAlias = SimplePath
+    _SimplePath: TypeAlias = SimplePath
+
 else:
     _SimplePath: TypeAlias = Path
 
@@ -48,7 +46,9 @@ class PackageNotFoundError(ModuleNotFoundError):
     @property
     def name(self) -> str: ...  # type: ignore[override]
 
-if sys.version_info >= (3, 11):
+if sys.version_info >= (3, 13):
+    _EntryPointBase = object
+elif sys.version_info >= (3, 11):
     class DeprecatedTuple:
         def __getitem__(self, item: int) -> str: ...
 
@@ -226,6 +226,9 @@ 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,9 +1,12 @@
 import sys
+from _typeshed import StrPath
 from collections.abc import Iterator
-from typing import Any, Protocol, TypeVar, overload
+from os import PathLike
+from typing import Any, Protocol, overload
+from typing_extensions import TypeVar
 
 _T = TypeVar("_T")
-_T_co = TypeVar("_T_co", covariant=True)
+_T_co = TypeVar("_T_co", covariant=True, default=Any)
 
 class PackageMetadata(Protocol):
     def __len__(self) -> int: ...
@@ -22,7 +25,18 @@ class PackageMetadata(Protocol):
         @overload
         def get(self, name: str, failobj: _T) -> _T | str: ...
 
-if sys.version_info >= (3, 12):
+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):
     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

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

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

@@ -176,20 +176,24 @@ 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]
-_GetMembersReturnTypeGuard: TypeAlias = list[tuple[str, _T]]
-_GetMembersReturn: TypeAlias = list[tuple[str, Any]]
+_GetMembersReturn: TypeAlias = list[tuple[str, _T]]
 
 @overload
-def getmembers(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturnTypeGuard[_T]: ...
+def getmembers(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturn[_T]: ...
 @overload
-def getmembers(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn: ...
+def getmembers(object: object, predicate: _GetMembersPredicateTypeIs[_T]) -> _GetMembersReturn[_T]: ...
+@overload
+def getmembers(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn[Any]: ...
 
 if sys.version_info >= (3, 11):
     @overload
-    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturnTypeGuard[_T]: ...
+    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturn[_T]: ...
     @overload
-    def getmembers_static(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn: ...
+    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeIs[_T]) -> _GetMembersReturn[_T]: ...
+    @overload
+    def getmembers_static(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn[Any]: ...
 
 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, Literal, Protocol, TextIO, TypeVar, overload, type_check_only
+from typing import IO, Any, BinaryIO, Generic, 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: ...
 
-# 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
+_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
     def __init__(
         self,
-        buffer: _WrappedBuffer,
+        buffer: _BufferT_co,
         encoding: str | None = None,
         errors: str | None = None,
         newline: str | None = None,
@@ -187,7 +187,7 @@ class TextIOWrapper(TextIOBase, TextIO):  # type: ignore[misc]  # incompatible d
     ) -> None: ...
     # Equals the "buffer" argument passed in to the constructor.
     @property
-    def buffer(self) -> BinaryIO: ...
+    def buffer(self) -> _BufferT_co: ...  # type: ignore[override]
     @property
     def closed(self) -> bool: ...
     @property
@@ -211,7 +211,7 @@ class TextIOWrapper(TextIOBase, TextIO):  # type: ignore[misc]  # incompatible d
     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) -> BinaryIO: ...
+    def detach(self) -> _BufferT_co: ...  # type: ignore[override]
     # 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,6 +326,10 @@ if sys.version_info >= (3, 10):
 
 if sys.version_info >= (3, 12):
     class batched(Iterator[tuple[_T_co, ...]], Generic[_T_co]):
-        def __new__(cls, iterable: Iterable[_T_co], n: int) -> Self: ...
+        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 __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
+from typing_extensions import Self, TypeAlias, deprecated
 
 if sys.version_info >= (3, 11):
     from types import GenericAlias
@@ -574,11 +574,8 @@ 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,6 +115,14 @@ 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,6 +45,7 @@ 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, NoReturn, overload
+from typing import Final, Literal, 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) -> bool: ...
+        def seekable(self) -> Literal[True]: ...
 
 if sys.platform != "win32":
     MADV_NORMAL: int

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

@@ -92,17 +92,21 @@ 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[_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]: ...
+        self,
+        typecode_or_type: type[_SimpleCData[_T]],
+        size_or_initializer: int | Sequence[Any],
+        *,
+        lock: Literal[True] | _LockLike = True,
+    ) -> SynchronizedArray[_T]: ...
     @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,12 +39,20 @@ def Array(
 ) -> _CT: ...
 @overload
 def Array(
-    typecode_or_type: type[_CT],
+    typecode_or_type: type[c_char],
     size_or_initializer: int | Sequence[Any],
     *,
     lock: Literal[True] | _LockLike = True,
     ctx: BaseContext | None = None,
-) -> SynchronizedArray[_CT]: ...
+) -> 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]: ...
 @overload
 def Array(
     typecode_or_type: str,
@@ -65,9 +73,11 @@ def copy(obj: _CT) -> _CT: ...
 @overload
 def synchronized(obj: _SimpleCData[_T], lock: _LockLike | None = None, ctx: Any | None = None) -> Synchronized[_T]: ...
 @overload
-def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...
+def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...  # type: ignore
 @overload
-def synchronized(obj: ctypes.Array[_CT], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedArray[_CT]: ...
+def synchronized(
+    obj: ctypes.Array[_SimpleCData[_T]], lock: _LockLike | None = None, ctx: Any | None = None
+) -> SynchronizedArray[_T]: ...
 @overload
 def synchronized(obj: _CT, lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedBase[_CT]: ...
 
@@ -89,19 +99,30 @@ class SynchronizedBase(Generic[_CT]):
 class Synchronized(SynchronizedBase[_SimpleCData[_T]], Generic[_T]):
     value: _T
 
-class SynchronizedArray(SynchronizedBase[ctypes.Array[_CT]], Generic[_CT]):
+class SynchronizedArray(SynchronizedBase[ctypes.Array[_SimpleCData[_T]]], Generic[_T]):
     def __len__(self) -> int: ...
     @overload
-    def __getitem__(self, i: slice) -> list[_CT]: ...
+    def __getitem__(self, i: slice) -> list[_T]: ...
     @overload
-    def __getitem__(self, i: int) -> _CT: ...
+    def __getitem__(self, i: int) -> _T: ...
     @overload
-    def __setitem__(self, i: slice, value: Iterable[_CT]) -> None: ...
+    def __setitem__(self, i: slice, value: Iterable[_T]) -> None: ...
     @overload
-    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: ...
+    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]
 
-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":
-        def plock(op: int, /) -> None: ...  # ???op is int?
+    if sys.platform != "darwin" and sys.platform != "linux":
+        def plock(op: int, /) -> None: ...
 
 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
-    CLONE_NEWIPC: int
-    CLONE_NEWNET: int
+    CLONE_NEWCGROUP: int  # Linux 4.6+
+    CLONE_NEWIPC: int  # Linux 2.6.19+
+    CLONE_NEWNET: int  # Linux 2.6.24+
     CLONE_NEWNS: int
-    CLONE_NEWPID: int
-    CLONE_NEWTIME: int
-    CLONE_NEWUSER: int
-    CLONE_NEWUTS: 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_SIGHAND: int
-    CLONE_SYSVSEM: int
+    CLONE_SYSVSEM: int  # Linux 2.6.26+
     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) -> Path: ...
+        def from_uri(cls, uri: str) -> Self: ...
         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, TypeVar
+from typing import IO, Any, ClassVar, Final, TypeVar
 from typing_extensions import ParamSpec, Self
 
 __all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace", "post_mortem", "help"]
@@ -30,6 +30,9 @@ 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
@@ -58,8 +61,16 @@ 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: ...
-    def interaction(self, frame: FrameType | None, traceback: TracebackType | None) -> None: ...
+
+    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 displayhook(self, obj: object) -> None: ...
     def handle_command_def(self, line: str) -> bool: ...
     def defaultFile(self) -> str: ...
@@ -72,6 +83,9 @@ 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: ...
@@ -81,6 +95,9 @@ 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: ...
@@ -125,8 +142,14 @@ class Pdb(Bdb, Cmd):
     def help_exec(self) -> None: ...
     def help_pdb(self) -> None: ...
     def sigint_handler(self, signum: signal.Signals, frame: FrameType) -> None: ...
-    def message(self, msg: str) -> None: ...
+    if sys.version_info >= (3, 13):
+        def message(self, msg: str, end: str = "\n") -> None: ...
+    else:
+        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: ...