Rename publish workflow file extension (yaml -> yml) (#12206)

## Summary

This PR fixes the bug where the server was not considering the
`cells.structure.didOpen` field to sync up the new content of the newly
added cells.

The parameters corresponding to this request provides two fields to get
the newly added cells:
1. `cells.structure.array.cells`: This is a list of `NotebookCell` which
doesn't contain any cell content. The only useful information from this
array is the cell kind and the cell document URI which we use to
initialize the new cell in the index.
2. `cells.structure.didOpen`: This is a list of `TextDocumentItem` which
corresponds to the newly added cells. This actually contains the text
content and the version.

This wasn't a problem before because we initialize the cell with an
empty string and this isn't a problem when someone just creates an empty
cell. But, when someone copy-pastes a cell, the cell needs to be
initialized with the content.

fixes: #12201 

## Test Plan

First, let's see the panic in action:

1. Press <kbd>Esc</kbd> to allow using the keyboard to perform cell
actions (move around, copy, paste, etc.)
2. Copy the second cell with <kbd>c</kbd> key
3. Delete the second cell with <kbd>dd</kbd> key
4. Paste the copied cell with <kbd>p</kbd> key

You can see that the content isn't synced up because the `unused-import`
for `sys` is still being highlighted but it's being used in the second
cell. And, the hover isn't working either. Then, as I start editing the
second cell, it panics.


https://github.com/astral-sh/ruff/assets/67177269/fc58364c-c8fc-4c11-a917-71b6dd90c1ef

Now, here's the preview of the fixed version:


https://github.com/astral-sh/ruff/assets/67177269/207872dd-dca6-49ee-8b6e-80435c7ef22e

.cargo/config.toml

@@ -1,3 +1,10 @@
 [alias]
 dev = "run --package ruff_dev --bin ruff_dev"
 benchmark = "bench -p ruff_benchmark --bench linter --bench formatter --"
+
+# statically link the C runtime so the executable does not depend on
+# that shared/dynamic library.
+#
+# See: https://github.com/astral-sh/ruff/issues/11503
+[target.'cfg(all(target_env="msvc", target_os = "windows"))']
+rustflags = ["-C", "target-feature=+crt-static"]

.gitattributes

@@ -8,6 +8,10 @@ crates/ruff_linter/resources/test/fixtures/pycodestyle/W391_3.py text eol=crlf
 crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples_crlf.py text eol=crlf
 crates/ruff_python_formatter/tests/snapshots/format@docstring_code_examples_crlf.py.snap text eol=crlf
 
+crates/ruff_python_parser/resources/invalid/re_lexing/line_continuation_windows_eol.py text eol=crlf
+crates/ruff_python_parser/resources/invalid/re_lex_logical_token_windows_eol.py text eol=crlf
+crates/ruff_python_parser/resources/invalid/re_lex_logical_token_mac_eol.py text eol=cr
+
 crates/ruff_python_parser/resources/inline linguist-generated=true
 
 ruff.schema.json linguist-generated=true text=auto eol=lf

.github/CODEOWNERS

@@ -15,3 +15,7 @@
 
 # Script for fuzzing the parser
 /scripts/fuzz-parser/ @AlexWaygood
+
+# red-knot
+/crates/red_knot* @carljm @MichaReiser @AlexWaygood
+/crates/ruff_db/ @carljm @MichaReiser @AlexWaygood

.github/renovate.json5

@@ -41,6 +41,13 @@
       description: "Disable PRs updating GitHub runners (e.g. 'runs-on: macos-14')",
       enabled: false,
     },
+    {
+      // Disable updates of `zip-rs`; intentionally pinned for now due to ownership change
+      // See: https://github.com/astral-sh/uv/issues/3642
+      matchPackagePatterns: ["zip"],
+      matchManagers: ["cargo"],
+      enabled: false,
+    },
     {
       groupName: "pre-commit dependencies",
       matchManagers: ["pre-commit"],

.github/workflows/build-binaries.yml

@@ -1,21 +1,23 @@
-name: "[ruff] Release"
+# Build ruff on all platforms.
+#
+# Generates both wheels (for PyPI) and archived binaries (for GitHub releases).
+#
+# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a local
+# artifacts job within `cargo-dist`.
+name: "Build binaries"
 
 on:
-  workflow_dispatch:
+  workflow_call:
     inputs:
-      tag:
-        description: "The version to tag, without the leading 'v'. If omitted, will initiate a dry run (no uploads)."
-        type: string
-      sha:
-        description: "The full sha of the commit to be released. If omitted, the latest commit on the default branch will be used."
-        default: ""
+      plan:
+        required: true
         type: string
   pull_request:
     paths:
-      # When we change pyproject.toml, we want to ensure that the maturin builds still work
+      # When we change pyproject.toml, we want to ensure that the maturin builds still work.
       - pyproject.toml
       # And when we change this workflow itself...
-      - .github/workflows/release.yaml
+      - .github/workflows/build-binaries.yml
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -23,6 +25,7 @@ concurrency:
 
 env:
   PACKAGE_NAME: ruff
+  MODULE_NAME: ruff
   PYTHON_VERSION: "3.11"
   CARGO_INCREMENTAL: 0
   CARGO_NET_RETRY: 10
@@ -31,11 +34,12 @@ env:
 
 jobs:
   sdist:
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
         with:
-          ref: ${{ inputs.sha }}
+          submodules: recursive
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -49,8 +53,8 @@ jobs:
       - name: "Test sdist"
         run: |
           pip install dist/${{ env.PACKAGE_NAME }}-*.tar.gz --force-reinstall
-          ruff --help
-          python -m ruff --help
+          ${{ env.MODULE_NAME }} --help
+          python -m ${{ env.MODULE_NAME }} --help
       - name: "Upload sdist"
         uses: actions/upload-artifact@v4
         with:
@@ -58,11 +62,12 @@ jobs:
           path: dist
 
   macos-x86_64:
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
     runs-on: macos-12
     steps:
       - uses: actions/checkout@v4
         with:
-          ref: ${{ inputs.sha }}
+          submodules: recursive
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -74,11 +79,6 @@ jobs:
         with:
           target: x86_64
           args: --release --locked --out dist
-      - name: "Test wheel - x86_64"
-        run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-          ruff --help
-          python -m ruff --help
       - name: "Upload wheels"
         uses: actions/upload-artifact@v4
         with:
@@ -86,23 +86,29 @@ jobs:
           path: dist
       - name: "Archive binary"
         run: |
-          ARCHIVE_FILE=ruff-${{ inputs.tag }}-x86_64-apple-darwin.tar.gz
-          tar czvf $ARCHIVE_FILE -C target/x86_64-apple-darwin/release ruff
+          TARGET=x86_64-apple-darwin
+          ARCHIVE_NAME=ruff-$TARGET
+          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
+
+          mkdir -p $ARCHIVE_NAME
+          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
+          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
         uses: actions/upload-artifact@v4
         with:
-          name: binaries-macos-x86_64
+          name: artifacts-macos-x86_64
           path: |
             *.tar.gz
             *.sha256
 
   macos-aarch64:
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
     runs-on: macos-14
     steps:
       - uses: actions/checkout@v4
         with:
-          ref: ${{ inputs.sha }}
+          submodules: recursive
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -126,18 +132,24 @@ jobs:
           path: dist
       - name: "Archive binary"
         run: |
-          ARCHIVE_FILE=ruff-${{ inputs.tag }}-aarch64-apple-darwin.tar.gz
-          tar czvf $ARCHIVE_FILE -C target/aarch64-apple-darwin/release ruff
+          TARGET=aarch64-apple-darwin
+          ARCHIVE_NAME=ruff-$TARGET
+          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
+
+          mkdir -p $ARCHIVE_NAME
+          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
+          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
         uses: actions/upload-artifact@v4
         with:
-          name: binaries-aarch64-apple-darwin
+          name: artifacts-aarch64-apple-darwin
           path: |
             *.tar.gz
             *.sha256
 
   windows:
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
     runs-on: windows-latest
     strategy:
       matrix:
@@ -151,7 +163,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with:
-          ref: ${{ inputs.sha }}
+          submodules: recursive
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -163,13 +175,16 @@ jobs:
         with:
           target: ${{ matrix.platform.target }}
           args: --release --locked --out dist
+        env:
+          # aarch64 build fails, see https://github.com/PyO3/maturin/issues/2110
+          XWIN_VERSION: 16
       - name: "Test wheel"
         if: ${{ !startsWith(matrix.platform.target, 'aarch64') }}
         shell: bash
         run: |
           python -m pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-          ruff --help
-          python -m ruff --help
+          ${{ env.MODULE_NAME }} --help
+          python -m ${{ env.MODULE_NAME }} --help
       - name: "Upload wheels"
         uses: actions/upload-artifact@v4
         with:
@@ -178,18 +193,19 @@ jobs:
       - name: "Archive binary"
         shell: bash
         run: |
-          ARCHIVE_FILE=ruff-${{ inputs.tag }}-${{ matrix.platform.target }}.zip
+          ARCHIVE_FILE=ruff-${{ matrix.platform.target }}.zip
           7z a $ARCHIVE_FILE ./target/${{ matrix.platform.target }}/release/ruff.exe
           sha256sum $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
         uses: actions/upload-artifact@v4
         with:
-          name: binaries-${{ matrix.platform.target }}
+          name: artifacts-${{ matrix.platform.target }}
           path: |
             *.zip
             *.sha256
 
   linux:
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -199,7 +215,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with:
-          ref: ${{ inputs.sha }}
+          submodules: recursive
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -216,27 +232,36 @@ jobs:
         if: ${{ startsWith(matrix.target, 'x86_64') }}
         run: |
           pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-          ruff --help
-          python -m ruff --help
+          ${{ env.MODULE_NAME }} --help
+          python -m ${{ env.MODULE_NAME }} --help
       - name: "Upload wheels"
         uses: actions/upload-artifact@v4
         with:
           name: wheels-${{ matrix.target }}
           path: dist
       - name: "Archive binary"
+        shell: bash
         run: |
-          ARCHIVE_FILE=ruff-${{ inputs.tag }}-${{ matrix.target }}.tar.gz
-          tar czvf $ARCHIVE_FILE -C target/${{ matrix.target }}/release ruff
+          set -euo pipefail
+
+          TARGET=${{ matrix.target }}
+          ARCHIVE_NAME=ruff-$TARGET
+          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
+
+          mkdir -p $ARCHIVE_NAME
+          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
+          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
         uses: actions/upload-artifact@v4
         with:
-          name: binaries-${{ matrix.target }}
+          name: artifacts-${{ matrix.target }}
           path: |
             *.tar.gz
             *.sha256
 
   linux-cross:
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -258,11 +283,13 @@ jobs:
             arch: ppc64
             # see https://github.com/astral-sh/ruff/issues/10073
             maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
+          - target: arm-unknown-linux-musleabihf
+            arch: arm
 
     steps:
       - uses: actions/checkout@v4
         with:
-          ref: ${{ inputs.sha }}
+          submodules: recursive
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -279,8 +306,8 @@ jobs:
         if: matrix.platform.arch != 'ppc64'
         name: Test wheel
         with:
-          arch: ${{ matrix.platform.arch }}
-          distro: ubuntu20.04
+          arch: ${{ matrix.platform.arch == 'arm' && 'armv6' || matrix.platform.arch }}
+          distro: ${{ matrix.platform.arch == 'arm' && 'bullseye' || 'ubuntu20.04' }}
           githubToken: ${{ github.token }}
           install: |
             apt-get update
@@ -295,19 +322,28 @@ jobs:
           name: wheels-${{ matrix.platform.target }}
           path: dist
       - name: "Archive binary"
+        shell: bash
         run: |
-          ARCHIVE_FILE=ruff-${{ inputs.tag }}-${{ matrix.platform.target }}.tar.gz
-          tar czvf $ARCHIVE_FILE -C target/${{ matrix.platform.target }}/release ruff
+          set -euo pipefail
+
+          TARGET=${{ matrix.platform.target }}
+          ARCHIVE_NAME=ruff-$TARGET
+          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
+
+          mkdir -p $ARCHIVE_NAME
+          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
+          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
         uses: actions/upload-artifact@v4
         with:
-          name: binaries-${{ matrix.platform.target }}
+          name: artifacts-${{ matrix.platform.target }}
           path: |
             *.tar.gz
             *.sha256
 
   musllinux:
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -317,7 +353,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with:
-          ref: ${{ inputs.sha }}
+          submodules: recursive
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -340,26 +376,35 @@ jobs:
             apk add python3
             python -m venv .venv
             .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
-            .venv/bin/ruff check --help
+            .venv/bin/${{ env.MODULE_NAME }} --help
       - name: "Upload wheels"
         uses: actions/upload-artifact@v4
         with:
           name: wheels-${{ matrix.target }}
           path: dist
       - name: "Archive binary"
+        shell: bash
         run: |
-          ARCHIVE_FILE=ruff-${{ inputs.tag }}-${{ matrix.target }}.tar.gz
-          tar czvf $ARCHIVE_FILE -C target/${{ matrix.target }}/release ruff
+          set -euo pipefail
+
+          TARGET=${{ matrix.target }}
+          ARCHIVE_NAME=ruff-$TARGET
+          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
+
+          mkdir -p $ARCHIVE_NAME
+          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
+          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
         uses: actions/upload-artifact@v4
         with:
-          name: binaries-${{ matrix.target }}
+          name: artifacts-${{ matrix.target }}
           path: |
             *.tar.gz
             *.sha256
 
   musllinux-cross:
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -373,7 +418,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with:
-          ref: ${{ inputs.sha }}
+          submodules: recursive
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -397,204 +442,29 @@ jobs:
           run: |
             python -m venv .venv
             .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
-            .venv/bin/ruff check --help
+            .venv/bin/${{ env.MODULE_NAME }} --help
       - name: "Upload wheels"
         uses: actions/upload-artifact@v4
         with:
           name: wheels-${{ matrix.platform.target }}
           path: dist
       - name: "Archive binary"
+        shell: bash
         run: |
-          ARCHIVE_FILE=ruff-${{ inputs.tag }}-${{ matrix.platform.target }}.tar.gz
-          tar czvf $ARCHIVE_FILE -C target/${{ matrix.platform.target }}/release ruff
+          set -euo pipefail
+
+          TARGET=${{ matrix.platform.target }}
+          ARCHIVE_NAME=ruff-$TARGET
+          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
+
+          mkdir -p $ARCHIVE_NAME
+          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
+          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
         uses: actions/upload-artifact@v4
         with:
-          name: binaries-${{ matrix.platform.target }}
+          name: artifacts-${{ matrix.platform.target }}
           path: |
             *.tar.gz
             *.sha256
-
-  validate-tag:
-    name: Validate tag
-    runs-on: ubuntu-latest
-    # If you don't set an input tag, it's a dry run (no uploads).
-    if: ${{ inputs.tag }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: main # We checkout the main branch to check for the commit
-      - name: Check main branch
-        if: ${{ inputs.sha }}
-        run: |
-          # Fetch the main branch since a shallow checkout is used by default
-          git fetch origin main --unshallow
-          if ! git branch --contains ${{ inputs.sha }} | grep -E '(^|\s)main$'; then
-            echo "The specified sha is not on the main branch" >&2
-            exit 1
-          fi
-      - name: Check tag consistency
-        run: |
-          # Switch to the commit we want to release
-          git checkout ${{ inputs.sha }}
-          version=$(grep "version = " pyproject.toml | sed -e 's/version = "\(.*\)"/\1/g')
-          if [ "${{ inputs.tag }}" != "${version}" ]; then
-            echo "The input tag does not match the version from pyproject.toml:" >&2
-            echo "${{ inputs.tag }}" >&2
-            echo "${version}" >&2
-            exit 1
-          else
-            echo "Releasing ${version}"
-          fi
-
-  upload-release:
-    name: Upload to PyPI
-    runs-on: ubuntu-latest
-    needs:
-      - macos-aarch64
-      - macos-x86_64
-      - windows
-      - linux
-      - linux-cross
-      - musllinux
-      - musllinux-cross
-      - validate-tag
-    # If you don't set an input tag, it's a dry run (no uploads).
-    if: ${{ inputs.tag }}
-    environment:
-      name: release
-    permissions:
-      # For pypi trusted publishing
-      id-token: write
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: wheels-*
-          path: wheels
-          merge-multiple: true
-      - name: Publish to PyPi
-        uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          skip-existing: true
-          packages-dir: wheels
-          verbose: true
-
-  tag-release:
-    name: Tag release
-    runs-on: ubuntu-latest
-    needs: upload-release
-    # If you don't set an input tag, it's a dry run (no uploads).
-    if: ${{ inputs.tag }}
-    permissions:
-      # For git tag
-      contents: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ inputs.sha }}
-      - name: git tag
-        run: |
-          git config user.email "hey@astral.sh"
-          git config user.name "Ruff Release CI"
-          git tag -m "v${{ inputs.tag }}" "v${{ inputs.tag }}"
-          # If there is duplicate tag, this will fail. The publish to pypi action will have been a noop (due to skip
-          # existing), so we make a non-destructive exit here
-          git push --tags
-
-  publish-release:
-    name: Publish to GitHub
-    runs-on: ubuntu-latest
-    needs: tag-release
-    # If you don't set an input tag, it's a dry run (no uploads).
-    if: ${{ inputs.tag }}
-    permissions:
-      # For GitHub release publishing
-      contents: write
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: binaries-*
-          path: binaries
-          merge-multiple: true
-      - name: "Publish to GitHub"
-        uses: softprops/action-gh-release@v2
-        with:
-          draft: true
-          files: binaries/*
-          tag_name: v${{ inputs.tag }}
-
-  docker-publish:
-    # This action doesn't need to wait on any other task, it's easy to re-tag if something failed and we're validating
-    # the tag here also
-    name: Push Docker image ghcr.io/astral-sh/ruff
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    permissions:
-      # For the docker push
-      packages: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ inputs.sha }}
-
-      - uses: docker/setup-buildx-action@v3
-
-      - uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ghcr.io/astral-sh/ruff
-
-      - name: Check tag consistency
-        # Unlike validate-tag we don't check if the commit is on the main branch, but it seems good enough since we can
-        # change docker tags
-        if: ${{ inputs.tag }}
-        run: |
-          version=$(grep "version = " pyproject.toml | sed -e 's/version = "\(.*\)"/\1/g')
-          if [ "${{ inputs.tag }}" != "${version}" ]; then
-            echo "The input tag does not match the version from pyproject.toml:" >&2
-            echo "${{ inputs.tag }}" >&2
-            echo "${version}" >&2
-            exit 1
-          else
-            echo "Releasing ${version}"
-          fi
-
-      - name: "Build and push Docker image"
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          platforms: linux/amd64,linux/arm64
-          # Reuse the builder
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-          push: ${{ inputs.tag != '' }}
-          tags: ghcr.io/astral-sh/ruff:latest,ghcr.io/astral-sh/ruff:${{ inputs.tag || 'dry-run' }}
-          labels: ${{ steps.meta.outputs.labels }}
-
-  # After the release has been published, we update downstream repositories
-  # This is separate because if this fails the release is still fine, we just need to do some manual workflow triggers
-  update-dependents:
-    name: Update dependents
-    runs-on: ubuntu-latest
-    needs: publish-release
-    steps:
-      - name: "Update pre-commit mirror"
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.RUFF_PRE_COMMIT_PAT }}
-          script: |
-            github.rest.actions.createWorkflowDispatch({
-              owner: 'astral-sh',
-              repo: 'ruff-pre-commit',
-              workflow_id: 'main.yml',
-              ref: 'main',
-            })

.github/workflows/build-docker.yml

@@ -0,0 +1,68 @@
+# Build and publish a Docker image.
+#
+# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a local
+# artifacts job within `cargo-dist`.
+#
+# TODO(charlie): Ideally, the publish step would happen as a publish job within `cargo-dist`, but
+# sharing the built image as an artifact between jobs is challenging.
+name: "[ruff] Build Docker image"
+
+on:
+  workflow_call:
+    inputs:
+      plan:
+        required: true
+        type: string
+  pull_request:
+    paths:
+      - .github/workflows/build-docker.yml
+
+jobs:
+  docker-publish:
+    name: Build Docker image (ghcr.io/astral-sh/ruff)
+    runs-on: ubuntu-latest
+    environment:
+      name: release
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - uses: docker/setup-buildx-action@v3
+
+      - uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ghcr.io/astral-sh/ruff
+
+      - name: Check tag consistency
+        if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
+        run: |
+          version=$(grep "version = " pyproject.toml | sed -e 's/version = "\(.*\)"/\1/g')
+          if [ "${{ fromJson(inputs.plan).announcement_tag }}" != "${version}" ]; then
+            echo "The input tag does not match the version from pyproject.toml:" >&2
+            echo "${{ fromJson(inputs.plan).announcement_tag }}" >&2
+            echo "${version}" >&2
+            exit 1
+          else
+            echo "Releasing ${version}"
+          fi
+
+      - name: "Build and push Docker image"
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          # Reuse the builder
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+          push: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
+          tags: ghcr.io/astral-sh/ruff:latest,ghcr.io/astral-sh/ruff:${{ (inputs.plan != '' && fromJson(inputs.plan).announcement_tag) || 'dry-run' }}
+          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/ci.yaml

@@ -167,6 +167,9 @@ jobs:
       - uses: Swatinem/rust-cache@v2
       - name: "Run tests"
         shell: bash
+        env:
+          # Workaround for <https://github.com/nextest-rs/nextest/issues/1493>.
+          RUSTUP_WINDOWS_PATH_ADD_BIN: 1
         run: |
           cargo nextest run --all-features --profile ci
           cargo test --all-features --doc
@@ -209,6 +212,38 @@ jobs:
       - name: "Build"
         run: cargo build --release --locked
 
+  cargo-build-msrv:
+    name: "cargo build (msrv)"
+    runs-on: ubuntu-latest
+    needs: determine_changes
+    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+      - uses: SebRollen/toml-action@v1.2.0
+        id: msrv
+        with:
+          file: "Cargo.toml"
+          field: "workspace.package.rust-version"
+      - name: "Install Rust toolchain"
+        run: rustup default ${{ steps.msrv.outputs.value }}
+      - name: "Install mold"
+        uses: rui314/setup-mold@v1
+      - name: "Install cargo nextest"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-nextest
+      - name: "Install cargo insta"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-insta
+      - uses: Swatinem/rust-cache@v2
+      - name: "Run tests"
+        shell: bash
+        env:
+          NEXTEST_PROFILE: "ci"
+        run: cargo +${{ steps.msrv.outputs.value }} insta test --all-features --unreferenced reject --test-runner nextest
+
   cargo-fuzz:
     name: "cargo fuzz"
     runs-on: ubuntu-latest
@@ -222,10 +257,13 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with:
           workspaces: "fuzz -> target"
-      - name: "Install cargo-fuzz"
-        uses: taiki-e/install-action@v2
+      - name: "Install cargo-binstall"
+        uses: cargo-bins/cargo-binstall@main
         with:
           tool: cargo-fuzz@0.11.2
+      - name: "Install cargo-fuzz"
+        # Download the latest version from quick install and not the github releases because github releases only has MUSL targets.
+        run: cargo binstall cargo-fuzz --force  --disable-strategies crate-meta-data --no-confirm
       - run: cargo fuzz build -s none
 
   fuzz-parser:
@@ -303,7 +341,7 @@ jobs:
           name: ruff
           path: target/debug
 
-      - uses: dawidd6/action-download-artifact@v3
+      - uses: dawidd6/action-download-artifact@v6
         name: Download baseline Ruff binary
         with:
           name: ruff

.github/workflows/notify-dependents.yml

@@ -0,0 +1,29 @@
+# Notify downstream repositories of a new release.
+#
+# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a post-announce
+# job within `cargo-dist`.
+name: "[ruff] Notify dependents"
+
+on:
+  workflow_call:
+    inputs:
+      plan:
+        required: true
+        type: string
+
+jobs:
+  update-dependents:
+    name: Notify dependents
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Update pre-commit mirror"
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.RUFF_PRE_COMMIT_PAT }}
+          script: |
+            github.rest.actions.createWorkflowDispatch({
+              owner: 'astral-sh',
+              repo: 'ruff-pre-commit',
+              workflow_id: 'main.yml',
+              ref: 'main',
+            })

.github/workflows/pr-comment.yaml

@@ -17,7 +17,7 @@ jobs:
   comment:
     runs-on: ubuntu-latest
     steps:
-      - uses: dawidd6/action-download-artifact@v3
+      - uses: dawidd6/action-download-artifact@v6
         name: Download pull request number
         with:
           name: pr-number
@@ -32,7 +32,7 @@ jobs:
             echo "pr-number=$(<pr-number)" >> $GITHUB_OUTPUT
           fi
 
-      - uses: dawidd6/action-download-artifact@v3
+      - uses: dawidd6/action-download-artifact@v6
         name: "Download ecosystem results"
         id: download-ecosystem-result
         if: steps.pr-number.outputs.pr-number
@@ -48,6 +48,14 @@ jobs:
         id: generate-comment
         if: steps.download-ecosystem-result.outputs.found_artifact == 'true'
         run: |
+          # Guard against malicious ecosystem results that symlink to a secret
+          # file on this runner
+          if [[ -L pr/ecosystem/ecosystem-result ]]
+          then
+              echo "Error: ecosystem-result cannot be a symlink"
+              exit 1
+          fi
+
           # Note this identifier is used to find the comment to update on
           # subsequent runs
           echo '<!-- generated-comment ecosystem -->' >> comment.txt

.github/workflows/publish-docs.yml

@@ -1,3 +1,7 @@
+# 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:
@@ -7,8 +11,11 @@ on:
         description: "The commit SHA, tag, or branch to publish. Uses the default branch if not specified."
         default: ""
         type: string
-  release:
-    types: [published]
+  workflow_call:
+    inputs:
+      plan:
+        required: true
+        type: string
 
 jobs:
   mkdocs:
@@ -47,7 +54,7 @@ jobs:
         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.5.0
+        uses: cloudflare/wrangler-action@v3.6.1
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/publish-playground.yml

@@ -1,9 +1,16 @@
+# Publish the Ruff playground.
+#
+# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a post-announce
+# job within `cargo-dist`.
 name: "[Playground] Release"
 
 on:
   workflow_dispatch:
-  release:
-    types: [published]
+  workflow_call:
+    inputs:
+      plan:
+        required: true
+        type: string
 
 env:
   CARGO_INCREMENTAL: 0
@@ -40,7 +47,7 @@ jobs:
         working-directory: playground
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.5.0
+        uses: cloudflare/wrangler-action@v3.6.1
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/publish-pypi.yml

@@ -0,0 +1,34 @@
+# Publish a release to PyPI.
+#
+# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a publish job
+# within `cargo-dist`.
+name: "[ruff] Publish to PyPI"
+
+on:
+  workflow_call:
+    inputs:
+      plan:
+        required: true
+        type: string
+
+jobs:
+  pypi-publish:
+    name: Upload to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: release
+    permissions:
+      # For PyPI's trusted publishing.
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          path: wheels
+          merge-multiple: true
+      - name: Publish to PyPi
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true
+          packages-dir: wheels
+          verbose: true

.github/workflows/release.yml

@@ -0,0 +1,282 @@
+# Copyright 2022-2024, axodotdev
+# SPDX-License-Identifier: MIT or Apache-2.0
+#
+# CI that:
+#
+# * checks for a Git Tag that looks like a release
+# * builds artifacts with cargo-dist (archives, installers, hashes)
+# * uploads those artifacts to temporary workflow zip
+# * on success, uploads the artifacts to a GitHub Release
+#
+# Note that the GitHub Release will be created with a generated
+# title/body based on your changelogs.
+
+name: Release
+permissions:
+  "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.
+# Various formats will be parsed into a VERSION and an optional PACKAGE_NAME, where
+# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION
+# must be a Cargo-style SemVer Version (must have at least major.minor.patch).
+#
+# If PACKAGE_NAME is specified, then the announcement will be for that
+# package (erroring out if it doesn't have the given version or isn't cargo-dist-able).
+#
+# If PACKAGE_NAME isn't specified, then the announcement will be for all
+# (cargo-dist-able) packages in the workspace with that version (this mode is
+# intended for workspaces with only one dist-able package, or with all dist-able
+# packages versioned/released in lockstep).
+#
+# If you push multiple tags at once, separate instances of this workflow will
+# spin up, creating an independent announcement for each one. However, GitHub
+# will hard limit this to 3 tags per commit, as it will assume more tags is a
+# mistake.
+#
+# If there's a prerelease-style suffix to the version, then the release(s)
+# will be marked as a prerelease.
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Release Tag
+        required: true
+        default: dry-run
+        type: string
+
+jobs:
+  # Run 'cargo dist plan' (or host) to determine what tasks we need to do
+  plan:
+    runs-on: "ubuntu-20.04"
+    outputs:
+      val: ${{ steps.plan.outputs.manifest }}
+      tag: ${{ (inputs.tag != 'dry-run' && inputs.tag) || '' }}
+      tag-flag: ${{ inputs.tag && inputs.tag != 'dry-run' && format('--tag={0}', inputs.tag) || '' }}
+      publishing: ${{ inputs.tag && inputs.tag != 'dry-run' }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cargo-dist
+        # we specify bash to get pipefail; it guards against the `curl` command
+        # failing. otherwise `sh` won't catch that `curl` returned non-0
+        shell: bash
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.18.0/cargo-dist-installer.sh | sh"
+      - name: Cache cargo-dist
+        uses: actions/upload-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/cargo-dist
+      # 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.
+      # (PRs run on the *source* but secrets are usually on the *target* -- that's *good*
+      # but also really annoying to build CI around when it needs secrets to work right.)
+      - id: plan
+        run: |
+          cargo dist ${{ (inputs.tag && inputs.tag != 'dry-run' && format('host --steps=create --tag={0}', inputs.tag)) || 'plan' }} --output-format=json > plan-dist-manifest.json
+          echo "cargo dist ran successfully"
+          cat plan-dist-manifest.json
+          echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
+      - name: "Upload dist-manifest.json"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-plan-dist-manifest
+          path: plan-dist-manifest.json
+
+  custom-build-binaries:
+    needs:
+      - plan
+    if: ${{ needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload' || inputs.tag == 'dry-run' }}
+    uses: ./.github/workflows/build-binaries.yml
+    with:
+      plan: ${{ needs.plan.outputs.val }}
+    secrets: inherit
+
+  custom-build-docker:
+    needs:
+      - plan
+    if: ${{ needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload' || inputs.tag == 'dry-run' }}
+    uses: ./.github/workflows/build-docker.yml
+    with:
+      plan: ${{ needs.plan.outputs.val }}
+    secrets: inherit
+    permissions:
+      "contents": "read"
+      "packages": "write"
+
+  # Build and package all the platform-agnostic(ish) things
+  build-global-artifacts:
+    needs:
+      - plan
+      - custom-build-binaries
+      - custom-build-docker
+    runs-on: "ubuntu-20.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cached cargo-dist
+        uses: actions/download-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/
+      - run: chmod +x ~/.cargo/bin/cargo-dist
+      # Get all the local artifacts for the global tasks to use (for e.g. checksums)
+      - name: Fetch local artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - id: cargo-dist
+        shell: bash
+        run: |
+          cargo dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
+          echo "cargo dist ran successfully"
+
+          # Parse out what we just built and upload it to scratch storage
+          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
+          jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
+      - name: "Upload artifacts"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-build-global
+          path: |
+            ${{ steps.cargo-dist.outputs.paths }}
+            ${{ env.BUILD_MANIFEST_NAME }}
+  # Determines if we should publish/announce
+  host:
+    needs:
+      - plan
+      - custom-build-binaries
+      - custom-build-docker
+      - build-global-artifacts
+    # Only run if we're "publishing", and only if local and global didn't fail (skipped is fine)
+    if: ${{ always() && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.custom-build-binaries.result == 'skipped' || needs.custom-build-binaries.result == 'success') && (needs.custom-build-docker.result == 'skipped' || needs.custom-build-docker.result == 'success') }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    runs-on: "ubuntu-20.04"
+    outputs:
+      val: ${{ steps.host.outputs.manifest }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cached cargo-dist
+        uses: actions/download-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/
+      - run: chmod +x ~/.cargo/bin/cargo-dist
+      # Fetch artifacts from scratch-storage
+      - name: Fetch artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      # This is a harmless no-op for GitHub Releases, hosting for that happens in "announce"
+      - id: host
+        shell: bash
+        run: |
+          cargo dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
+          echo "artifacts uploaded and released successfully"
+          cat dist-manifest.json
+          echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
+      - name: "Upload dist-manifest.json"
+        uses: actions/upload-artifact@v4
+        with:
+          # Overwrite the previous copy
+          name: artifacts-dist-manifest
+          path: dist-manifest.json
+
+  custom-publish-pypi:
+    needs:
+      - plan
+      - host
+    if: ${{ !fromJson(needs.plan.outputs.val).announcement_is_prerelease || fromJson(needs.plan.outputs.val).publish_prereleases }}
+    uses: ./.github/workflows/publish-pypi.yml
+    with:
+      plan: ${{ needs.plan.outputs.val }}
+    secrets: inherit
+    # publish jobs get escalated permissions
+    permissions:
+      "id-token": "write"
+      "packages": "write"
+
+  # Create a GitHub Release while uploading all files to it
+  announce:
+    needs:
+      - plan
+      - host
+      - custom-publish-pypi
+    # 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') }}
+    runs-on: "ubuntu-20.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - 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:
+          pattern: artifacts-*
+          path: artifacts
+          merge-multiple: true
+      - name: Cleanup
+        run: |
+          # Remove the granular manifests
+          rm -f artifacts/*-dist-manifest.json
+      - name: Create GitHub Release
+        env:
+          PRERELEASE_FLAG: "${{ fromJson(needs.host.outputs.val).announcement_is_prerelease && '--prerelease' || '' }}"
+          ANNOUNCEMENT_TITLE: "${{ fromJson(needs.host.outputs.val).announcement_title }}"
+          ANNOUNCEMENT_BODY: "${{ fromJson(needs.host.outputs.val).announcement_github_body }}"
+          RELEASE_COMMIT: "${{ github.sha }}"
+        run: |
+          # Write and read notes from a file to avoid quoting breaking things
+          echo "$ANNOUNCEMENT_BODY" > $RUNNER_TEMP/notes.txt
+
+          gh release create "${{ needs.plan.outputs.tag }}" --target "$RELEASE_COMMIT" $PRERELEASE_FLAG --title "$ANNOUNCEMENT_TITLE" --notes-file "$RUNNER_TEMP/notes.txt" artifacts/*
+
+  custom-notify-dependents:
+    needs:
+      - plan
+      - announce
+    uses: ./.github/workflows/notify-dependents.yml
+    with:
+      plan: ${{ needs.plan.outputs.val }}
+    secrets: inherit
+
+  custom-publish-docs:
+    needs:
+      - plan
+      - announce
+    uses: ./.github/workflows/publish-docs.yml
+    with:
+      plan: ${{ needs.plan.outputs.val }}
+    secrets: inherit
+
+  custom-publish-playground:
+    needs:
+      - plan
+      - announce
+    uses: ./.github/workflows/publish-playground.yml
+    with:
+      plan: ${{ needs.plan.outputs.val }}
+    secrets: inherit

.github/workflows/sync_typeshed.yaml

@@ -37,13 +37,13 @@ jobs:
       - name: Sync typeshed
         id: sync
         run: |
-          rm -rf ruff/crates/red_knot/vendor/typeshed
-          mkdir ruff/crates/red_knot/vendor/typeshed
-          cp typeshed/README.md ruff/crates/red_knot/vendor/typeshed
-          cp typeshed/LICENSE ruff/crates/red_knot/vendor/typeshed
-          cp -r typeshed/stdlib ruff/crates/red_knot/vendor/typeshed/stdlib
-          rm -rf ruff/crates/red_knot/vendor/typeshed/stdlib/@tests
-          git -C typeshed rev-parse HEAD > ruff/crates/red_knot/vendor/typeshed/source_commit.txt
+          rm -rf ruff/crates/red_knot_module_resolver/vendor/typeshed
+          mkdir ruff/crates/red_knot_module_resolver/vendor/typeshed
+          cp typeshed/README.md ruff/crates/red_knot_module_resolver/vendor/typeshed
+          cp typeshed/LICENSE ruff/crates/red_knot_module_resolver/vendor/typeshed
+          cp -r typeshed/stdlib ruff/crates/red_knot_module_resolver/vendor/typeshed/stdlib
+          rm -rf ruff/crates/red_knot_module_resolver/vendor/typeshed/stdlib/@tests
+          git -C typeshed rev-parse HEAD > ruff/crates/red_knot_module_resolver/vendor/typeshed/source_commit.txt
       - name: Commit the changes
         id: commit
         if: ${{ steps.sync.outcome == 'success' }}

.pre-commit-config.yaml

@@ -2,7 +2,7 @@ fail_fast: true
 
 exclude: |
   (?x)^(
-    crates/red_knot/vendor/.*|
+    crates/red_knot_module_resolver/vendor/.*|
     crates/ruff_linter/resources/.*|
     crates/ruff_linter/src/rules/.*/snapshots/.*|
     crates/ruff/resources/.*|
@@ -14,7 +14,7 @@ exclude: |
 
 repos:
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.17
+    rev: v0.18
     hooks:
       - id: validate-pyproject
 
@@ -32,7 +32,7 @@ repos:
           )$
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.40.0
+    rev: v0.41.0
     hooks:
       - id: markdownlint-fix
         exclude: |
@@ -42,7 +42,7 @@ repos:
           )$
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.21.0
+    rev: v1.22.9
     hooks:
       - id: typos
 
@@ -56,7 +56,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.4
+    rev: v0.5.0
     hooks:
       - id: ruff-format
       - id: ruff

.prettierignore

@@ -0,0 +1,2 @@
+# Auto-generated by `cargo-dist`.
+.github/workflows/release.yml

.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+    "recommendations": [
+        "rust-lang.rust-analyzer"
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "rust-analyzer.check.extraArgs": [
+        "--all-features"
+    ],
+    "rust-analyzer.check.command": "clippy",
+}

BREAKING_CHANGES.md

@@ -1,5 +1,12 @@
 # Breaking Changes
 
+## 0.5.0
+
+- Follow the XDG specification to discover user-level configurations on macOS (same as on other Unix platforms)
+- Selecting `ALL` now excludes deprecated rules
+- The released archives now include an extra level of nesting, which can be removed with `--strip-components=1` when untarring.
+- The release artifact's file name no longer includes the version tag. This enables users to install via `/latest` URLs on GitHub.
+
 ## 0.3.0
 
 ### Ruff 2024.2 style

CHANGELOG.md

@@ -1,5 +1,390 @@
 # Changelog
 
+## 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!
+
+### Breaking changes
+
+See also, the "Remapped rules" section which may result in disabled rules.
+
+- Follow the XDG specification to discover user-level configurations on macOS (same as on other Unix platforms)
+- Selecting `ALL` now excludes deprecated rules
+- The released archives now include an extra level of nesting, which can be removed with `--strip-components=1` when untarring.
+- The release artifact's file name no longer includes the version tag. This enables users to install via `/latest` URLs on GitHub.
+- The diagnostic ranges for some `flake8-bandit` rules were modified ([#10667](https://github.com/astral-sh/ruff/pull/10667)).
+
+### Deprecations
+
+The following rules are now deprecated:
+
+- [`syntax-error`](https://docs.astral.sh/ruff/rules/syntax-error/) (`E999`): Syntax errors are now always shown
+
+### Remapped rules
+
+The following rules have been remapped to new rule codes:
+
+- [`blocking-http-call-in-async-function`](https://docs.astral.sh/ruff/rules/blocking-http-call-in-async-function/): `ASYNC100` to `ASYNC210`
+- [`open-sleep-or-subprocess-in-async-function`](https://docs.astral.sh/ruff/rules/open-sleep-or-subprocess-in-async-function/): `ASYNC101` split into `ASYNC220`, `ASYNC221`, `ASYNC230`, and `ASYNC251`
+- [`blocking-os-call-in-async-function`](https://docs.astral.sh/ruff/rules/blocking-os-call-in-async-function/): `ASYNC102` has been merged into `ASYNC220` and `ASYNC221`
+- [`trio-timeout-without-await`](https://docs.astral.sh/ruff/rules/trio-timeout-without-await/): `TRIO100` to `ASYNC100`
+- [`trio-sync-call`](https://docs.astral.sh/ruff/rules/trio-sync-call/): `TRIO105` to `ASYNC105`
+- [`trio-async-function-with-timeout`](https://docs.astral.sh/ruff/rules/trio-async-function-with-timeout/): `TRIO109` to `ASYNC109`
+- [`trio-unneeded-sleep`](https://docs.astral.sh/ruff/rules/trio-unneeded-sleep/): `TRIO110` to `ASYNC110`
+- [`trio-zero-sleep-call`](https://docs.astral.sh/ruff/rules/trio-zero-sleep-call/): `TRIO115` to `ASYNC115`
+- [`repeated-isinstance-calls`](https://docs.astral.sh/ruff/rules/repeated-isinstance-calls/): `PLR1701` to `SIM101`
+
+### Stabilization
+
+The following rules have been stabilized and are no longer in preview:
+
+- [`mutable-fromkeys-value`](https://docs.astral.sh/ruff/rules/mutable-fromkeys-value/) (`RUF024`)
+- [`default-factory-kwarg`](https://docs.astral.sh/ruff/rules/default-factory-kwarg/) (`RUF026`)
+- [`django-extra`](https://docs.astral.sh/ruff/rules/django-extra/) (`S610`)
+- [`manual-dict-comprehension`](https://docs.astral.sh/ruff/rules/manual-dict-comprehension/) (`PERF403`)
+- [`print-empty-string`](https://docs.astral.sh/ruff/rules/print-empty-string/) (`FURB105`)
+- [`readlines-in-for`](https://docs.astral.sh/ruff/rules/readlines-in-for/) (`FURB129`)
+- [`if-expr-min-max`](https://docs.astral.sh/ruff/rules/if-expr-min-max/) (`FURB136`)
+- [`bit-count`](https://docs.astral.sh/ruff/rules/bit-count/) (`FURB161`)
+- [`redundant-log-base`](https://docs.astral.sh/ruff/rules/redundant-log-base/) (`FURB163`)
+- [`regex-flag-alias`](https://docs.astral.sh/ruff/rules/regex-flag-alias/) (`FURB167`)
+- [`isinstance-type-none`](https://docs.astral.sh/ruff/rules/isinstance-type-none/) (`FURB168`)
+- [`type-none-comparison`](https://docs.astral.sh/ruff/rules/type-none-comparison/) (`FURB169`)
+- [`implicit-cwd`](https://docs.astral.sh/ruff/rules/implicit-cwd/) (`FURB177`)
+- [`hashlib-digest-hex`](https://docs.astral.sh/ruff/rules/hashlib-digest-hex/) (`FURB181`)
+- [`list-reverse-copy`](https://docs.astral.sh/ruff/rules/list-reverse-copy/) (`FURB187`)
+- [`bad-open-mode`](https://docs.astral.sh/ruff/rules/bad-open-mode/) (`PLW1501`)
+- [`empty-comment`](https://docs.astral.sh/ruff/rules/empty-comment/) (`PLR2044`)
+- [`global-at-module-level`](https://docs.astral.sh/ruff/rules/global-at-module-level/) (`PLW0604`)
+- [`misplaced-bare-raise`](https://docs.astral.sh/ruff/rules/misplaced-bare-raise/) (`PLE0744`)
+- [`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`)
+- [`potential-index-error`](https://docs.astral.sh/ruff/rules/potential-index-error/) (`PLE0643`)
+- [`redeclared-assigned-name`](https://docs.astral.sh/ruff/rules/redeclared-assigned-name/) (`PLW0128`)
+- [`redefined-argument-from-local`](https://docs.astral.sh/ruff/rules/redefined-argument-from-local/) (`PLR1704`)
+- [`repeated-keyword-argument`](https://docs.astral.sh/ruff/rules/repeated-keyword-argument/) (`PLE1132`)
+- [`super-without-brackets`](https://docs.astral.sh/ruff/rules/super-without-brackets/) (`PLW0245`)
+- [`unnecessary-list-index-lookup`](https://docs.astral.sh/ruff/rules/unnecessary-list-index-lookup/) (`PLR1736`)
+- [`useless-exception-statement`](https://docs.astral.sh/ruff/rules/useless-exception-statement/) (`PLW0133`)
+- [`useless-with-lock`](https://docs.astral.sh/ruff/rules/useless-with-lock/) (`PLW2101`)
+
+The following behaviors have been stabilized:
+
+- [`is-literal`](https://docs.astral.sh/ruff/rules/is-literal/) (`F632`) now warns for identity checks against list, set or dictionary literals
+- [`needless-bool`](https://docs.astral.sh/ruff/rules/needless-bool/) (`SIM103`) now detects `if` expressions with implicit `else` branches
+- [`module-import-not-at-top-of-file`](https://docs.astral.sh/ruff/rules/module-import-not-at-top-of-file/) (`E402`) now allows `os.environ` modifications between import statements
+- [`type-comparison`](https://docs.astral.sh/ruff/rules/type-comparison/) (`E721`) now allows idioms such as `type(x) is int`
+- [`yoda-condition`](https://docs.astral.sh/ruff/rules/yoda-conditions/) (`SIM300`) now flags a wider range of expressions
+
+### Removals
+
+The following deprecated settings have been removed:
+
+- `output-format=text`; use `output-format=concise` or `output-format=full`
+- `tab-size`; use `indent-width`
+
+The following deprecated CLI options have been removed:
+
+- `--show-source`; use `--output-format=full`
+- `--no-show-source`; use `--output-format=concise`
+
+The following deprecated CLI commands have been removed:
+
+- `ruff <path>`; use `ruff check <path>`
+- `ruff --clean`; use `ruff clean`
+- `ruff --generate-shell-completion`; use `ruff generate-shell-completion`
+
+### Preview features
+
+- \[`ruff`\] Add `assert-with-print-message` rule ([#11981](https://github.com/astral-sh/ruff/pull/11981))
+
+### CLI
+
+- Use rule name rather than message in `--statistics` ([#11697](https://github.com/astral-sh/ruff/pull/11697))
+- Use the output format `full` by default ([#12010](https://github.com/astral-sh/ruff/pull/12010))
+- Don't log syntax errors to the console ([#11902](https://github.com/astral-sh/ruff/pull/11902))
+
+### Rule changes
+
+- \[`ruff`\] Fix false positives if `gettext` is imported using an alias (`RUF027`) ([#12025](https://github.com/astral-sh/ruff/pull/12025))
+- \[`numpy`\] Update `trapz` and `in1d` deprecation (`NPY201`) ([#11948](https://github.com/astral-sh/ruff/pull/11948))
+- \[`flake8-bandit`\] Modify diagnostic ranges for shell-related rules ([#10667](https://github.com/astral-sh/ruff/pull/10667))
+
+### Server
+
+- Closing an untitled, unsaved notebook document no longer throws an error ([#11942](https://github.com/astral-sh/ruff/pull/11942))
+- Support the usage of tildes and environment variables in `logFile` ([#11945](https://github.com/astral-sh/ruff/pull/11945))
+- Add option to configure whether to show syntax errors ([#12059](https://github.com/astral-sh/ruff/pull/12059))
+
+### Bug fixes
+
+- \[`pycodestyle`\] Avoid `E203` for f-string debug expression ([#12024](https://github.com/astral-sh/ruff/pull/12024))
+- \[`pep8-naming`\] Match import-name ignores against both name and alias (`N812`, `N817`) ([#12033](https://github.com/astral-sh/ruff/pull/12033))
+- \[`pyflakes`\] Detect assignments that shadow definitions (`F811`) ([#11961](https://github.com/astral-sh/ruff/pull/11961))
+
+### Parser
+
+- Emit a syntax error for an empty type parameter list ([#12030](https://github.com/astral-sh/ruff/pull/12030))
+- Avoid consuming the newline for unterminated strings ([#12067](https://github.com/astral-sh/ruff/pull/12067))
+- Do not include the newline in the unterminated string range ([#12017](https://github.com/astral-sh/ruff/pull/12017))
+- Use the correct range to highlight line continuation errors ([#12016](https://github.com/astral-sh/ruff/pull/12016))
+- Consider 2-character EOL before line continuations ([#12035](https://github.com/astral-sh/ruff/pull/12035))
+- Consider line continuation character for re-lexing ([#12008](https://github.com/astral-sh/ruff/pull/12008))
+
+### Other changes
+
+- Upgrade the Unicode table used for measuring the line-length ([#11194](https://github.com/astral-sh/ruff/pull/11194))
+- Remove the deprecation error message for the nursery selector ([#10172](https://github.com/astral-sh/ruff/pull/10172))
+
+## 0.4.10
+
+### Parser
+
+- Implement re-lexing logic for better error recovery ([#11845](https://github.com/astral-sh/ruff/pull/11845))
+
+### Rule changes
+
+- \[`flake8-copyright`\] Update `CPY001` to check the first 4096 bytes instead of 1024 ([#11927](https://github.com/astral-sh/ruff/pull/11927))
+- \[`pycodestyle`\] Update `E999` to show all syntax errors instead of just the first one ([#11900](https://github.com/astral-sh/ruff/pull/11900))
+
+### Server
+
+- Add tracing setup guide to Helix documentation ([#11883](https://github.com/astral-sh/ruff/pull/11883))
+- Add tracing setup guide to Neovim documentation ([#11884](https://github.com/astral-sh/ruff/pull/11884))
+- Defer notebook cell deletion to avoid an error message ([#11864](https://github.com/astral-sh/ruff/pull/11864))
+
+### Security
+
+- Guard against malicious ecosystem comment artifacts ([#11879](https://github.com/astral-sh/ruff/pull/11879))
+
+## 0.4.9
+
+### Preview features
+
+- \[`pylint`\] Implement `consider-dict-items` (`C0206`) ([#11688](https://github.com/astral-sh/ruff/pull/11688))
+- \[`refurb`\] Implement `repeated-global` (`FURB154`) ([#11187](https://github.com/astral-sh/ruff/pull/11187))
+
+### Rule changes
+
+- \[`pycodestyle`\] Adapt fix for `E203` to work identical to `ruff format` ([#10999](https://github.com/astral-sh/ruff/pull/10999))
+
+### Formatter
+
+- Fix formatter instability for lines only consisting of zero-width characters ([#11748](https://github.com/astral-sh/ruff/pull/11748))
+
+### Server
+
+- Add supported commands in server capabilities ([#11850](https://github.com/astral-sh/ruff/pull/11850))
+- Use real file path when available in `ruff server` ([#11800](https://github.com/astral-sh/ruff/pull/11800))
+- Improve error message when a command is run on an unavailable document ([#11823](https://github.com/astral-sh/ruff/pull/11823))
+- Introduce the `ruff.printDebugInformation` command ([#11831](https://github.com/astral-sh/ruff/pull/11831))
+- Tracing system now respects log level and trace level, with options to log to a file ([#11747](https://github.com/astral-sh/ruff/pull/11747))
+
+### CLI
+
+- Handle non-printable characters in diff view ([#11687](https://github.com/astral-sh/ruff/pull/11687))
+
+### Bug fixes
+
+- \[`refurb`\] Avoid suggesting starmap when arguments are used outside call (`FURB140`) ([#11830](https://github.com/astral-sh/ruff/pull/11830))
+- \[`flake8-bugbear`\] Avoid panic in `B909` when checking large loop blocks ([#11772](https://github.com/astral-sh/ruff/pull/11772))
+- \[`refurb`\] Fix misbehavior of `operator.itemgetter` when getter param is a tuple (`FURB118`) ([#11774](https://github.com/astral-sh/ruff/pull/11774))
+
+## 0.4.8
+
+### Performance
+
+- Linter performance has been improved by around 10% on some microbenchmarks by refactoring the lexer and parser to maintain synchronicity between them ([#11457](https://github.com/astral-sh/ruff/pull/11457))
+
+### Preview features
+
+- \[`flake8-bugbear`\] Implement `return-in-generator` (`B901`) ([#11644](https://github.com/astral-sh/ruff/pull/11644))
+- \[`flake8-pyi`\] Implement `PYI063` ([#11699](https://github.com/astral-sh/ruff/pull/11699))
+- \[`pygrep_hooks`\] Check blanket ignores via file-level pragmas (`PGH004`) ([#11540](https://github.com/astral-sh/ruff/pull/11540))
+
+### Rule changes
+
+- \[`pyupgrade`\] Update `UP035` for Python 3.13 and the latest version of `typing_extensions` ([#11693](https://github.com/astral-sh/ruff/pull/11693))
+- \[`numpy`\] Update `NPY001` rule for NumPy 2.0 ([#11735](https://github.com/astral-sh/ruff/pull/11735))
+
+### Server
+
+- Formatting a document with syntax problems no longer spams a visible error popup ([#11745](https://github.com/astral-sh/ruff/pull/11745))
+
+### CLI
+
+- Add RDJson support for `--output-format` flag ([#11682](https://github.com/astral-sh/ruff/pull/11682))
+
+### Bug fixes
+
+- \[`pyupgrade`\] Write empty string in lieu of panic when fixing `UP032` ([#11696](https://github.com/astral-sh/ruff/pull/11696))
+- \[`flake8-simplify`\] Simplify double negatives in `SIM103` ([#11684](https://github.com/astral-sh/ruff/pull/11684))
+- Ensure the expression generator adds a newline before `type` statements ([#11720](https://github.com/astral-sh/ruff/pull/11720))
+- Respect per-file ignores for blanket and redirected noqa rules ([#11728](https://github.com/astral-sh/ruff/pull/11728))
+
+## 0.4.7
+
+### Preview features
+
+- \[`flake8-pyi`\] Implement `PYI064` ([#11325](https://github.com/astral-sh/ruff/pull/11325))
+- \[`flake8-pyi`\] Implement `PYI066` ([#11541](https://github.com/astral-sh/ruff/pull/11541))
+- \[`flake8-pyi`\] Implement `PYI057` ([#11486](https://github.com/astral-sh/ruff/pull/11486))
+- \[`pyflakes`\] Enable `F822` in `__init__.py` files by default ([#11370](https://github.com/astral-sh/ruff/pull/11370))
+
+### Formatter
+
+- Fix incorrect placement of trailing stub function comments ([#11632](https://github.com/astral-sh/ruff/pull/11632))
+
+### Server
+
+- Respect file exclusions in `ruff server` ([#11590](https://github.com/astral-sh/ruff/pull/11590))
+- Add support for documents not exist on disk ([#11588](https://github.com/astral-sh/ruff/pull/11588))
+- Add Vim and Kate setup guide for `ruff server` ([#11615](https://github.com/astral-sh/ruff/pull/11615))
+
+### Bug fixes
+
+- Avoid removing newlines between docstring headers and rST blocks ([#11609](https://github.com/astral-sh/ruff/pull/11609))
+- Infer indentation with imports when logical indent is absent ([#11608](https://github.com/astral-sh/ruff/pull/11608))
+- Use char index rather than position for indent slice ([#11645](https://github.com/astral-sh/ruff/pull/11645))
+- \[`flake8-comprehension`\] Strip parentheses around generators in `C400` ([#11607](https://github.com/astral-sh/ruff/pull/11607))
+- Mark `repeated-isinstance-calls` as unsafe on Python 3.10 and later ([#11622](https://github.com/astral-sh/ruff/pull/11622))
+
+## 0.4.6
+
+### Breaking changes
+
+- Use project-relative paths when calculating GitLab fingerprints ([#11532](https://github.com/astral-sh/ruff/pull/11532))
+- Bump minimum supported Windows version to Windows 10 ([#11613](https://github.com/astral-sh/ruff/pull/11613))
+
+### Preview features
+
+- \[`flake8-async`\] Sleep with >24 hour interval should usually sleep forever (`ASYNC116`) ([#11498](https://github.com/astral-sh/ruff/pull/11498))
+
+### Rule changes
+
+- \[`numpy`\] Add missing functions to NumPy 2.0 migration rule ([#11528](https://github.com/astral-sh/ruff/pull/11528))
+- \[`mccabe`\] Consider irrefutable pattern similar to `if .. else` for `C901` ([#11565](https://github.com/astral-sh/ruff/pull/11565))
+- Consider `match`-`case` statements for `C901`, `PLR0912`, and `PLR0915` ([#11521](https://github.com/astral-sh/ruff/pull/11521))
+- Remove empty strings when converting to f-string (`UP032`) ([#11524](https://github.com/astral-sh/ruff/pull/11524))
+- \[`flake8-bandit`\] `request-without-timeout` should warn for `requests.request` ([#11548](https://github.com/astral-sh/ruff/pull/11548))
+- \[`flake8-self`\] Ignore sunder accesses in `flake8-self` rules ([#11546](https://github.com/astral-sh/ruff/pull/11546))
+- \[`pyupgrade`\] Lint for `TypeAliasType` usages (`UP040`) ([#11530](https://github.com/astral-sh/ruff/pull/11530))
+
+### Server
+
+- Respect excludes in `ruff server` configuration discovery ([#11551](https://github.com/astral-sh/ruff/pull/11551))
+- Use default settings if initialization options is empty or not provided ([#11566](https://github.com/astral-sh/ruff/pull/11566))
+- `ruff server` correctly treats `.pyi` files as stub files ([#11535](https://github.com/astral-sh/ruff/pull/11535))
+- `ruff server` searches for configuration in parent directories ([#11537](https://github.com/astral-sh/ruff/pull/11537))
+- `ruff server`: An empty code action filter no longer returns notebook source actions ([#11526](https://github.com/astral-sh/ruff/pull/11526))
+
+### Bug fixes
+
+- \[`flake8-logging-format`\] Fix autofix title in `logging-warn` (`G010`) ([#11514](https://github.com/astral-sh/ruff/pull/11514))
+- \[`refurb`\] Avoid recommending `operator.itemgetter` with dependence on lambda arguments ([#11574](https://github.com/astral-sh/ruff/pull/11574))
+- \[`flake8-simplify`\] Avoid recommending context manager in `__enter__` implementations ([#11575](https://github.com/astral-sh/ruff/pull/11575))
+- Create intermediary directories for `--output-file` ([#11550](https://github.com/astral-sh/ruff/pull/11550))
+- Propagate reads on global variables ([#11584](https://github.com/astral-sh/ruff/pull/11584))
+- Treat all `singledispatch` arguments as runtime-required ([#11523](https://github.com/astral-sh/ruff/pull/11523))
+
+## 0.4.5
+
+### Ruff's language server is now in Beta
+
+`v0.4.5` marks the official Beta release of `ruff server`, an integrated language server built into Ruff.
+`ruff server` supports the same feature set as `ruff-lsp`, powering linting, formatting, and
+code fixes in Ruff's editor integrations -- but with superior performance and
+no installation required. We'd love your feedback!
+
+You can enable `ruff server` in the [VS Code extension](https://github.com/astral-sh/ruff-vscode?tab=readme-ov-file#enabling-the-rust-based-language-server) today.
+
+To read more about this exciting milestone, check out our [blog post](https://astral.sh/blog/ruff-v0.4.5)!
+
+### Rule changes
+
+- \[`flake8-future-annotations`\] Reword `future-rewritable-type-annotation` (`FA100`) message ([#11381](https://github.com/astral-sh/ruff/pull/11381))
+- \[`isort`\] Expanded the set of standard-library modules to include `_string`, etc. ([#11374](https://github.com/astral-sh/ruff/pull/11374))
+- \[`pycodestyle`\] Consider soft keywords for `E27` rules ([#11446](https://github.com/astral-sh/ruff/pull/11446))
+- \[`pyflakes`\] Recommend adding unused import bindings to `__all__` ([#11314](https://github.com/astral-sh/ruff/pull/11314))
+- \[`pyflakes`\] Update documentation and deprecate `ignore_init_module_imports` ([#11436](https://github.com/astral-sh/ruff/pull/11436))
+- \[`pyupgrade`\] Mark quotes as unnecessary for non-evaluated annotations ([#11485](https://github.com/astral-sh/ruff/pull/11485))
+
+### Formatter
+
+- Avoid multiline quotes warning with `quote-style = preserve` ([#11490](https://github.com/astral-sh/ruff/pull/11490))
+
+### Server
+
+- Support Jupyter Notebook files ([#11206](https://github.com/astral-sh/ruff/pull/11206))
+- Support `noqa` comment code actions ([#11276](https://github.com/astral-sh/ruff/pull/11276))
+- Fix automatic configuration reloading ([#11492](https://github.com/astral-sh/ruff/pull/11492))
+- Fix several issues with configuration in Neovim and Helix ([#11497](https://github.com/astral-sh/ruff/pull/11497))
+
+### CLI
+
+- Add `--output-format` as a CLI option for `ruff config` ([#11438](https://github.com/astral-sh/ruff/pull/11438))
+
+### Bug fixes
+
+- Avoid `PLE0237` for property with setter ([#11377](https://github.com/astral-sh/ruff/pull/11377))
+- Avoid `TCH005` for `if` stmt with `elif`/`else` block ([#11376](https://github.com/astral-sh/ruff/pull/11376))
+- Avoid flagging `__future__` annotations as required for non-evaluated type annotations ([#11414](https://github.com/astral-sh/ruff/pull/11414))
+- Check for ruff executable in 'bin' directory as installed by 'pip install --target'. ([#11450](https://github.com/astral-sh/ruff/pull/11450))
+- Sort edits prior to deduplicating in quotation fix ([#11452](https://github.com/astral-sh/ruff/pull/11452))
+- Treat escaped newline as valid sequence ([#11465](https://github.com/astral-sh/ruff/pull/11465))
+- \[`flake8-pie`\] Preserve parentheses in `unnecessary-dict-kwargs` ([#11372](https://github.com/astral-sh/ruff/pull/11372))
+- \[`pylint`\] Ignore `__slots__` with dynamic values ([#11488](https://github.com/astral-sh/ruff/pull/11488))
+- \[`pylint`\] Remove `try` body from branch counting ([#11487](https://github.com/astral-sh/ruff/pull/11487))
+- \[`refurb`\] Respect operator precedence in `FURB110` ([#11464](https://github.com/astral-sh/ruff/pull/11464))
+
+### Documentation
+
+- Add `--preview` to the README ([#11395](https://github.com/astral-sh/ruff/pull/11395))
+- Add Python 3.13 to list of allowed Python versions ([#11411](https://github.com/astral-sh/ruff/pull/11411))
+- Simplify Neovim setup documentation ([#11489](https://github.com/astral-sh/ruff/pull/11489))
+- Update CONTRIBUTING.md to reflect the new parser ([#11434](https://github.com/astral-sh/ruff/pull/11434))
+- Update server documentation with new migration guide ([#11499](https://github.com/astral-sh/ruff/pull/11499))
+- \[`pycodestyle`\] Clarify motivation for `E713` and `E714` ([#11483](https://github.com/astral-sh/ruff/pull/11483))
+- \[`pyflakes`\] Update docs to describe WAI behavior (F541) ([#11362](https://github.com/astral-sh/ruff/pull/11362))
+- \[`pylint`\] Clearly indicate what is counted as a branch ([#11423](https://github.com/astral-sh/ruff/pull/11423))
+
 ## 0.4.4
 
 ### Preview features
@@ -74,6 +459,10 @@
 - Avoid allocations for isort module names ([#11251](https://github.com/astral-sh/ruff/pull/11251))
 - Build a separate ARM wheel for macOS ([#11149](https://github.com/astral-sh/ruff/pull/11149))
 
+### Windows
+
+- Increase the minimum requirement to Windows 10.
+
 ## 0.4.2
 
 ### Rule changes

CONTRIBUTING.md

@@ -101,6 +101,8 @@ pre-commit run --all-files --show-diff-on-failure  # Rust and Python formatting,
 These checks will run on GitHub Actions when you open your pull request, but running them locally
 will save you time and expedite the merge process.
 
+If you're using VS Code, you can also install the recommended [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer) extension to get these checks while editing.
+
 Note that many code changes also require updating the snapshot tests, which is done interactively
 after running `cargo test` like so:
 
@@ -278,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., `_`).
 
@@ -331,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`
@@ -344,22 +346,21 @@ even patch releases may contain [non-backwards-compatible changes](https://semve
 1. Run `cargo check`. This should update the lock file with new versions.
 1. Create a pull request with the changelog and version updates
 1. Merge the PR
-1. Run the [release workflow](https://github.com/astral-sh/ruff/actions/workflows/release.yaml) with:
+1. Run the [release workflow](https://github.com/astral-sh/ruff/actions/workflows/release.yml) with:
     - The new version number (without starting `v`)
-    - The commit hash of the merged release pull request on `main`
 1. The release workflow will do the following:
     1. Build all the assets. If this fails (even though we tested in step 4), we haven't tagged or
-        uploaded anything, you can restart after pushing a fix.
+        uploaded anything, you can restart after pushing a fix. If you just need to rerun the build,
+        make sure you're [re-running all the failed
+        jobs](https://docs.github.com/en/actions/managing-workflow-runs/re-running-workflows-and-jobs#re-running-failed-jobs-in-a-workflow) and not just a single failed job.
     1. Upload to PyPI.
     1. Create and push the Git tag (as extracted from `pyproject.toml`). We create the Git tag only
         after building the wheels and uploading to PyPI, since we can't delete or modify the tag ([#4468](https://github.com/astral-sh/ruff/issues/4468)).
     1. Attach artifacts to draft GitHub release
     1. Trigger downstream repositories. This can fail non-catastrophically, as we can run any
         downstream jobs manually if needed.
-1. Publish the GitHub release
-    1. Open the draft release in the GitHub release section
-    1. Copy the changelog for the release into the GitHub release
-        - See previous releases for formatting of section headers
+1. Verify the GitHub release:
+    1. The Changelog should match the content of `CHANGELOG.md`
     1. Append the contributors from the `bump.sh` script
 1. If needed, [update the schemastore](https://github.com/astral-sh/ruff/blob/main/scripts/update_schemastore.py).
     1. One can determine if an update is needed when

Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-rust-version = "1.71"
+rust-version = "1.75"
 homepage = "https://docs.astral.sh/ruff"
 documentation = "https://docs.astral.sh/ruff"
 repository = "https://github.com/astral-sh/ruff"
@@ -14,6 +14,7 @@ license = "MIT"
 [workspace.dependencies]
 ruff = { path = "crates/ruff" }
 ruff_cache = { path = "crates/ruff_cache" }
+ruff_db = { path = "crates/ruff_db" }
 ruff_diagnostics = { path = "crates/ruff_diagnostics" }
 ruff_formatter = { path = "crates/ruff_formatter" }
 ruff_index = { path = "crates/ruff_index" }
@@ -34,6 +35,10 @@ 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"] }
 anyhow = { version = "1.0.80" }
@@ -42,6 +47,7 @@ bincode = { version = "1.3.3" }
 bitflags = { version = "2.5.0" }
 bstr = { version = "1.9.1" }
 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" }
@@ -51,37 +57,38 @@ 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.7.1"
 criterion = { version = "0.5.1", default-features = false }
 crossbeam = { version = "0.8.4" }
-dashmap = { version = "5.5.3" }
-dirs = { version = "5.0.0" }
+dashmap = { version = "6.0.1" }
 drop_bomb = { version = "0.1.5" }
 env_logger = { version = "0.11.0" }
+etcetera = { version = "0.8.0" }
 fern = { version = "0.6.1" }
 filetime = { version = "0.2.23" }
 glob = { version = "0.3.1" }
 globset = { version = "0.4.14" }
 hashbrown = "0.14.3"
-hexf-parse = { version = "0.2.1" }
 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", feature = ["filters", "glob"] }
+insta = { version = "1.35.1" }
 insta-cmd = { version = "0.6.0" }
 is-macro = { version = "0.3.5" }
 is-wsl = { version = "0.4.0" }
-itertools = { version = "0.12.1" }
+itertools = { version = "0.13.0" }
 js-sys = { version = "0.3.69" }
 jod-thread = { version = "0.1.2" }
-lexical-parse-float = { version = "0.8.0", features = ["format"] }
 libc = { version = "0.2.153" }
 libcst = { version = "1.1.0", default-features = false }
 log = { version = "0.4.17" }
 lsp-server = { version = "0.7.6" }
-lsp-types = { version = "0.95.0", features = ["proposed"] }
+lsp-types = { git = "https://github.com/astral-sh/lsp-types.git", rev = "3512a9f", features = [
+  "proposed",
+] }
 matchit = { version = "0.8.1" }
 memchr = { version = "2.7.1" }
 mimalloc = { version = "0.1.39" }
@@ -91,7 +98,6 @@ once_cell = { version = "1.19.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" }
@@ -101,15 +107,17 @@ quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
-result-like = { version = "0.5.0" }
-rustc-hash = { version = "1.1.0" }
+rustc-hash = { version = "2.0.0" }
+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"] }
 serde-wasm-bindgen = { version = "0.6.4" }
 serde_json = { version = "1.0.113" }
 serde_test = { version = "1.0.152" }
-serde_with = { version = "3.6.0", default-features = false, features = ["macros"] }
+serde_with = { version = "3.6.0", default-features = false, features = [
+  "macros",
+] }
 shellexpand = { version = "3.0.0" }
 similar = { version = "2.4.0", features = ["inline"] }
 smallvec = { version = "1.13.2" }
@@ -134,11 +142,17 @@ unicode_names2 = { version = "1.2.2" }
 unicode-normalization = { version = "0.1.23" }
 ureq = { version = "2.9.6" }
 url = { version = "2.5.0" }
-uuid = { version = "1.6.1", features = ["v4", "fast-rng", "macro-diagnostics", "js"] }
+uuid = { version = "1.6.1", features = [
+  "v4",
+  "fast-rng",
+  "macro-diagnostics",
+  "js",
+] }
 walkdir = { version = "2.3.2" }
 wasm-bindgen = { version = "0.2.92" }
 wasm-bindgen-test = { version = "0.3.42" }
 wild = { version = "2" }
+zip = { version = "0.6.6", default-features = false, features = ["zstd"] }
 
 [workspace.lints.rust]
 unsafe_code = "warn"
@@ -206,3 +220,62 @@ opt-level = 1
 [profile.profiling]
 inherits = "release"
 debug = 1
+
+# The profile that 'cargo dist' will build with.
+[profile.dist]
+inherits = "release"
+
+# Config for 'cargo dist'
+[workspace.metadata.dist]
+# The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax)
+cargo-dist-version = "0.18.0"
+# CI backends to support
+ci = ["github"]
+# The installers to generate for each app
+installers = ["shell", "powershell"]
+# The archive format to use for windows builds (defaults .zip)
+windows-archive = ".zip"
+# The archive format to use for non-windows builds (defaults .tar.xz)
+unix-archive = ".tar.gz"
+# Target platforms to build apps for (Rust target-triple syntax)
+targets = [
+  "aarch64-apple-darwin",
+  "aarch64-pc-windows-msvc",
+  "aarch64-unknown-linux-gnu",
+  "aarch64-unknown-linux-musl",
+  "arm-unknown-linux-musleabihf",
+  "armv7-unknown-linux-gnueabihf",
+  "armv7-unknown-linux-musleabihf",
+  "i686-pc-windows-msvc",
+  "i686-unknown-linux-gnu",
+  "i686-unknown-linux-musl",
+  "powerpc64-unknown-linux-gnu",
+  "powerpc64le-unknown-linux-gnu",
+  "s390x-unknown-linux-gnu",
+  "x86_64-apple-darwin",
+  "x86_64-pc-windows-msvc",
+  "x86_64-unknown-linux-gnu",
+  "x86_64-unknown-linux-musl",
+]
+# 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
+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"]
+# Announcement jobs to run in CI
+post-announce-jobs = ["./notify-dependents", "./publish-docs", "./publish-playground"]
+# Custom permissions for GitHub Jobs
+github-custom-job-permissions = { "build-docker" = { packages = "write", contents = "read" } }
+# Whether to install an updater program
+install-updater = false

README.md

@@ -28,7 +28,7 @@ An extremely fast Python linter and code formatter, written in Rust.
 - ⚡️ 10-100x faster than existing linters (like Flake8) and formatters (like Black)
 - 🐍 Installable via `pip`
 - 🛠️ `pyproject.toml` support
-- 🤝 Python 3.12 compatibility
+- 🤝 Python 3.13 compatibility
 - ⚖️ Drop-in parity with [Flake8](https://docs.astral.sh/ruff/faq/#how-does-ruff-compare-to-flake8), isort, and Black
 - 📦 Built-in caching, to avoid re-analyzing unchanged files
 - 🔧 Fix support, for automatic error correction (e.g., automatically remove unused imports)
@@ -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.1/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.5.1/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.4.4
+  rev: v0.5.1
   hooks:
     # Run the linter.
     - id: ruff
@@ -334,7 +352,6 @@ quality tools, including:
 - [flake8-super](https://pypi.org/project/flake8-super/)
 - [flake8-tidy-imports](https://pypi.org/project/flake8-tidy-imports/)
 - [flake8-todos](https://pypi.org/project/flake8-todos/)
-- [flake8-trio](https://pypi.org/project/flake8-trio/)
 - [flake8-type-checking](https://pypi.org/project/flake8-type-checking/)
 - [flake8-use-pathlib](https://pypi.org/project/flake8-use-pathlib/)
 - [flynt](https://pypi.org/project/flynt/) ([#2102](https://github.com/astral-sh/ruff/issues/2102))
@@ -408,6 +425,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [Dagster](https://github.com/dagster-io/dagster)
 - Databricks ([MLflow](https://github.com/mlflow/mlflow))
 - [FastAPI](https://github.com/tiangolo/fastapi)
+- [Godot](https://github.com/godotengine/godot)
 - [Gradio](https://github.com/gradio-app/gradio)
 - [Great Expectations](https://github.com/great-expectations/great_expectations)
 - [HTTPX](https://github.com/encode/httpx)
@@ -433,6 +451,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - Modern Treasury ([Python SDK](https://github.com/Modern-Treasury/modern-treasury-python))
 - Mozilla ([Firefox](https://github.com/mozilla/gecko-dev))
 - [Mypy](https://github.com/python/mypy)
+- [Nautobot](https://github.com/nautobot/nautobot)
 - Netflix ([Dispatch](https://github.com/Netflix/dispatch))
 - [Neon](https://github.com/neondatabase/neon)
 - [Nokia](https://nokia.com/)
@@ -440,6 +459,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [NumPyro](https://github.com/pyro-ppl/numpyro)
 - [ONNX](https://github.com/onnx/onnx)
 - [OpenBB](https://github.com/OpenBB-finance/OpenBBTerminal)
+- [Open Wine Components](https://github.com/Open-Wine-Components/umu-launcher)
 - [PDM](https://github.com/pdm-project/pdm)
 - [PaddlePaddle](https://github.com/PaddlePaddle/Paddle)
 - [Pandas](https://github.com/pandas-dev/pandas)
@@ -467,6 +487,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [Sphinx](https://github.com/sphinx-doc/sphinx)
 - [Stable Baselines3](https://github.com/DLR-RM/stable-baselines3)
 - [Starlette](https://github.com/encode/starlette)
+- [Streamlit](https://github.com/streamlit/streamlit)
 - [The Algorithms](https://github.com/TheAlgorithms/Python)
 - [Vega-Altair](https://github.com/altair-viz/altair)
 - WordPress ([Openverse](https://github.com/WordPress/openverse))

_typos.toml

@@ -1,6 +1,6 @@
 [files]
 # https://github.com/crate-ci/typos/issues/868
-extend-exclude = ["crates/red_knot/vendor/**/*", "**/resources/**/*", "**/snapshots/**/*"]
+extend-exclude = ["crates/red_knot_module_resolver/vendor/**/*", "**/resources/**/*", "**/snapshots/**/*"]
 
 [default.extend-words]
 "arange" = "arange"  # e.g. `numpy.arange`
@@ -16,5 +16,6 @@ jod = "jod" # e.g., `jod-thread`
 [default]
 extend-ignore-re = [
   # Line ignore with trailing "spellchecker:disable-line"
-  "(?Rm)^.*#\\s*spellchecker:disable-line$"
+  "(?Rm)^.*#\\s*spellchecker:disable-line$",
+  "LICENSEs",
 ]

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
@@ -8,35 +8,29 @@ documentation.workspace = true
 repository.workspace = true
 authors.workspace = true
 license.workspace = true
+default-run = "red_knot"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-ruff_python_parser = { workspace = true }
+red_knot_module_resolver = { workspace = true }
+red_knot_python_semantic = { workspace = true }
+
+ruff_db = { workspace = true }
 ruff_python_ast = { workspace = true }
-ruff_text_size = { workspace = true }
-ruff_index = { workspace = true }
-ruff_notebook = { workspace = true }
 
 anyhow = { workspace = true }
-bitflags = { workspace = true }
+countme = { workspace = true, features = ["enable"] }
 crossbeam = { workspace = true }
 ctrlc = { version = "3.4.4" }
-dashmap = { workspace = true }
-hashbrown = { workspace = true }
-indexmap = { 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]
-textwrap = { version = "0.16.1" }
-tempfile = { workspace = true }
 
 [lints]
 workspace = true

crates/red_knot/README.md

@@ -1,9 +0,0 @@
-# Red Knot
-
-The Red Knot crate contains code working towards multifile analysis, type inference and, ultimately, type-checking. It's very much a work in progress for now.
-
-## Vendored types for the stdlib
-
-Red Knot vendors [typeshed](https://github.com/python/typeshed)'s stubs for the standard library. The vendored stubs can be found in `crates/red_knot/vendor/typeshed`. The file `crates/red_knot/vendor/typeshed/source_commit.txt` tells you the typeshed commit that our vendored stdlib stubs currently correspond to.
-
-The typeshed stubs are updated every two weeks via an automated PR using the `sync_typeshed.yaml` workflow in the `.github/workflows` directory. This workflow can also be triggered at any time via [workflow dispatch](https://docs.github.com/en/actions/using-workflows/manually-running-a-workflow#running-a-workflow).

crates/red_knot/src/ast_ids.rs

@@ -1,415 +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::preorder;
-use ruff_python_ast::visitor::preorder::{PreorderVisitor, 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_preorder(&mut visitor);
-                }
-                DeferredNode::ClassDefinition(def) => def.visit_preorder(&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> PreorderVisitor<'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(_) => {}
-        }
-
-        preorder::walk_stmt(self, stmt);
-    }
-
-    fn visit_expr(&mut self, _expr: &'a Expr) {}
-
-    fn visit_parameter(&mut self, parameter: &'a Parameter) {
-        self.create_id(parameter);
-        preorder::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);
-            }
-        }
-
-        preorder::walk_except_handler(self, except_handler);
-    }
-
-    fn visit_with_item(&mut self, with_item: &'a WithItem) {
-        self.create_id(with_item);
-        preorder::walk_with_item(self, with_item);
-    }
-
-    fn visit_match_case(&mut self, match_case: &'a MatchCase) {
-        self.create_id(match_case);
-        preorder::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 {
-            kind: node.as_any_node_ref().kind(),
-            range: node.range(),
-        };
-        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> PreorderVisitor<'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 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/db.rs

@@ -1,248 +1,10 @@
-use std::sync::Arc;
+use red_knot_python_semantic::Db as SemanticDb;
+use ruff_db::Upcast;
+use salsa::DbWithJar;
 
-pub use jars::{HasJar, HasJars};
-pub use query::{QueryError, QueryResult};
-pub use runtime::DbRuntime;
-pub use storage::JarsStorage;
+use crate::lint::{lint_semantic, lint_syntax, unwind_if_cancelled};
 
-use crate::files::FileId;
-use crate::lint::{LintSemanticStorage, LintSyntaxStorage};
-use crate::module::ModuleResolver;
-use crate::parse::ParsedStorage;
-use crate::source::SourceStorage;
-use crate::symbols::SymbolTablesStorage;
-use crate::types::TypeStore;
+pub trait Db: DbWithJar<Jar> + SemanticDb + Upcast<dyn SemanticDb> {}
 
-mod jars;
-mod query;
-mod runtime;
-mod storage;
-
-pub trait Database {
-    /// Returns a reference to the runtime of the current worker.
-    fn runtime(&self) -> &DbRuntime;
-
-    /// 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;
-
-    /// Returns `Ok` if the queries have not been cancelled and `Err(QueryError::Cancelled)` otherwise.
-    fn cancelled(&self) -> QueryResult<()> {
-        self.runtime().cancelled()
-    }
-
-    /// Returns `true` if the queries have been cancelled.
-    fn is_cancelled(&self) -> bool {
-        self.runtime().is_cancelled()
-    }
-}
-
-/// 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<DB> std::ops::Deref for Snapshot<DB>
-where
-    DB: ParallelDatabase,
-{
-    type Target = DB;
-
-    fn deref(&self) -> &DB {
-        &self.db
-    }
-}
-
-pub trait Upcast<T: ?Sized> {
-    fn upcast(&self) -> &T;
-}
-
-// Red knot specific databases code.
-
-pub trait SourceDb: DbWithJar<SourceJar> {
-    // queries
-    fn file_id(&self, path: &std::path::Path) -> FileId;
-
-    fn file_path(&self, file_id: FileId) -> Arc<std::path::Path>;
-}
-
-pub trait SemanticDb: SourceDb + DbWithJar<SemanticJar> + Upcast<dyn SourceDb> {}
-
-pub trait LintDb: SemanticDb + DbWithJar<LintJar> + Upcast<dyn SemanticDb> {}
-
-pub trait Db: LintDb + Upcast<dyn LintDb> {}
-
-#[derive(Debug, Default)]
-pub struct SourceJar {
-    pub sources: SourceStorage,
-    pub parsed: ParsedStorage,
-}
-
-#[derive(Debug, Default)]
-pub struct SemanticJar {
-    pub module_resolver: ModuleResolver,
-    pub symbol_tables: SymbolTablesStorage,
-    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()
-        }
-    }
-}
+#[salsa::jar(db=Db)]
+pub struct Jar(lint_syntax, lint_semantic, unwind_if_cancelled);

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,109 +1,52 @@
-use std::fmt::Formatter;
-use std::hash::BuildHasherDefault;
-use std::ops::Deref;
-use std::path::{Path, PathBuf};
+use rustc_hash::FxHashSet;
 
-use rustc_hash::{FxHashSet, FxHasher};
+use ruff_db::file_system::{FileSystemPath, FileSystemPathBuf};
+use ruff_db::vfs::VfsFile;
 
-use crate::files::FileId;
+use crate::db::Jar;
 
-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;
-pub mod source;
-mod symbols;
-mod types;
 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,
+    root: FileSystemPathBuf,
     /// 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>,
+    open_files: FxHashSet<VfsFile>,
 }
 
 impl Workspace {
-    pub fn new(root: PathBuf) -> Self {
+    pub fn new(root: FileSystemPathBuf) -> Self {
         Self {
             root,
             open_files: FxHashSet::default(),
         }
     }
 
-    pub fn root(&self) -> &Path {
+    pub fn root(&self) -> &FileSystemPath {
         self.root.as_path()
     }
 
     // TODO having the content in workspace feels wrong.
-    pub fn open_file(&mut self, file_id: FileId) {
+    pub fn open_file(&mut self, file_id: VfsFile) {
         self.open_files.insert(file_id);
     }
 
-    pub fn close_file(&mut self, file_id: FileId) {
+    pub fn close_file(&mut self, file_id: VfsFile) {
         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> + '_ {
+    pub fn open_files(&self) -> impl Iterator<Item = VfsFile> + '_ {
         self.open_files.iter().copied()
     }
 
-    pub fn is_file_open(&self, file_id: FileId) -> bool {
+    pub fn is_file_open(&self, file_id: VfsFile) -> bool {
         self.open_files.contains(&file_id)
     }
 }
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Name(smol_str::SmolStr);
-
-impl Name {
-    #[inline]
-    pub fn new(name: &str) -> Self {
-        Self(smol_str::SmolStr::new(name))
-    }
-
-    pub fn as_str(&self) -> &str {
-        self.0.as_str()
-    }
-}
-
-impl Deref for Name {
-    type Target = str;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        self.as_str()
-    }
-}
-
-impl<T> From<T> for Name
-where
-    T: Into<smol_str::SmolStr>,
-{
-    fn from(value: T) -> Self {
-        Self(value.into())
-    }
-}
-
-impl std::fmt::Display for Name {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.as_str())
-    }
-}

crates/red_knot/src/lint.rs

@@ -1,59 +1,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 tracing::trace_span;
 
-use crate::cache::KeyValueCache;
-use crate::db::{LintDb, LintJar, QueryResult};
-use crate::files::FileId;
-use crate::module::ModuleName;
-use crate::parse::{parse, Parsed};
-use crate::source::{source_text, Source};
-use crate::symbols::{
-    resolve_global_symbol, symbol_table, Definition, GlobalSymbolId, SymbolId, SymbolTable,
-};
-use crate::types::{infer_definition_type, infer_symbol_type, Type};
+use red_knot_module_resolver::ModuleName;
+use red_knot_python_semantic::types::Type;
+use red_knot_python_semantic::{HasTy, SemanticModel};
+use ruff_db::parsed::{parsed_module, ParsedModule};
+use ruff_db::source::{source_text, SourceText};
+use ruff_db::vfs::VfsFile;
+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: VfsFile) -> 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.ast();
+    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>) {
@@ -73,165 +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: VfsFile) -> 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 symbols = symbol_table(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,
-            symbols,
-            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.symbols().all_definitions() {
-        match definition {
-            Definition::Import(import) => {
-                let ty = context.infer_symbol_type(symbol)?;
-
-                if ty.is_unknown() {
-                    context.push_diagnostic(format!("Unresolved module {}", import.module));
-                }
-            }
-            Definition::ImportFrom(import) => {
-                let ty = context.infer_symbol_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) =
-        resolve_global_symbol(context.db.upcast(), ModuleName::new("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.symbols().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_unknown() {
+                    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_unknown() {
+                    context.push_diagnostic(format!("Unresolved import '{}'", &alias.name));
+                }
+            }
+        }
+    }
+}
+
+fn lint_bad_override(context: &SemanticLintContext, class: &ast::StmtClassDef) {
+    let semantic = &context.semantic;
+    let typing_context = semantic.typing_context();
+
+    // 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 Some(typing_override) = semantic.public_symbol(&typing, "override") else {
+        return;
+    };
+
+    let override_ty = semantic.public_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)?
+
+        if ty.has_decorator(&typing_context, override_ty) {
+            let method_name = ty.name(&typing_context);
+            if class_ty
+                .inherited_class_member(&typing_context, method_name)
                 .is_none()
             {
                 // TODO should have a qualname() method to support nested classes
                 context.push_diagnostic(
                     format!(
                         "Method {}.{} is decorated with `typing.override` but does not override any base class method",
-                        class.name(context.db.upcast())?,
+                        class_ty.name(&typing_context),
                         method_name,
                     ));
             }
         }
     }
-    Ok(())
 }
 
-pub struct SemanticLintContext<'a> {
-    file_id: FileId,
-    source: Source,
-    parsed: Parsed,
-    symbols: Arc<SymbolTable>,
-    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
+    #[allow(unused)]
+    pub(crate) fn ast(&self) -> &'db ast::ModModule {
+        self.parsed.syntax()
     }
 
-    pub fn ast(&self) -> &ModModule {
-        self.parsed.ast()
-    }
-
-    pub fn symbols(&self) -> &SymbolTable {
-        &self.symbols
-    }
-
-    pub fn infer_symbol_type(&self, symbol_id: SymbolId) -> QueryResult<Type> {
-        infer_symbol_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);
     }
 }
@@ -243,7 +203,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];
 
@@ -254,10 +214,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 {
@@ -281,41 +264,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,7 @@
-#![allow(clippy::dbg_macro)]
-
-use std::path::Path;
 use std::sync::Mutex;
 
 use crossbeam::channel as crossbeam_channel;
+use salsa::ParallelDatabase;
 use tracing::subscriber::Interest;
 use tracing::{Level, Metadata};
 use tracing_subscriber::filter::LevelFilter;
@@ -11,15 +9,21 @@ 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, ModuleSearchPath, ModuleSearchPathKind};
-use red_knot::program::check::ExecutionMode;
 use red_knot::program::{FileWatcherChange, Program};
 use red_knot::watch::FileWatcher;
 use red_knot::Workspace;
+use red_knot_module_resolver::{set_module_resolution_settings, ModuleResolutionSettings};
+use ruff_db::file_system::{FileSystem, FileSystemPath, OsFileSystem};
+use ruff_db::vfs::system_path_to_file;
 
-#[allow(clippy::print_stdout, clippy::unnecessary_wraps, clippy::print_stderr)]
-fn main() -> anyhow::Result<()> {
+#[allow(
+    clippy::print_stdout,
+    clippy::unnecessary_wraps,
+    clippy::print_stderr,
+    clippy::dbg_macro
+)]
+pub fn main() -> anyhow::Result<()> {
+    countme::enable(true);
     setup_tracing();
 
     let arguments: Vec<_> = std::env::args().collect();
@@ -29,29 +33,39 @@ fn main() -> anyhow::Result<()> {
         return Err(anyhow::anyhow!("Invalid arguments"));
     }
 
-    let entry_point = Path::new(&arguments[1]);
+    let fs = OsFileSystem;
+    let entry_point = FileSystemPath::new(&arguments[1]);
 
-    if !entry_point.exists() {
+    if !fs.exists(entry_point) {
         eprintln!("The entry point does not exist.");
         return Err(anyhow::anyhow!("Invalid arguments"));
     }
 
-    if !entry_point.is_file() {
+    if !fs.is_file(entry_point) {
         eprintln!("The entry point is not a file.");
         return Err(anyhow::anyhow!("Invalid arguments"));
     }
 
+    let entry_point = entry_point.to_path_buf();
+
     let workspace_folder = entry_point.parent().unwrap();
     let workspace = Workspace::new(workspace_folder.to_path_buf());
 
-    let workspace_search_path = ModuleSearchPath::new(
-        workspace.root().to_path_buf(),
-        ModuleSearchPathKind::FirstParty,
-    );
-    let mut program = Program::new(workspace);
-    set_module_search_paths(&mut program, vec![workspace_search_path]);
+    let workspace_search_path = workspace.root().to_path_buf();
 
-    let entry_id = program.file_id(entry_point);
+    let mut program = Program::new(workspace, fs);
+
+    set_module_resolution_settings(
+        &mut program,
+        ModuleResolutionSettings {
+            extra_paths: vec![],
+            workspace_root: workspace_search_path,
+            site_packages: None,
+            custom_typeshed: None,
+        },
+    );
+
+    let entry_id = system_path_to_file(&program, entry_point.clone()).unwrap();
     program.workspace_mut().open_file(entry_id);
 
     let (main_loop, main_loop_cancellation_token) = MainLoop::new();
@@ -73,14 +87,11 @@ fn main() -> anyhow::Result<()> {
         file_changes_notifier.notify(changes);
     })?;
 
-    file_watcher.watch_folder(workspace_folder)?;
+    file_watcher.watch_folder(workspace_folder.as_std_path())?;
 
     main_loop.run(&mut program);
 
-    let source_jar: &SourceJar = program.jar().unwrap();
-
-    dbg!(source_jar.parsed.statistics());
-    dbg!(source_jar.sources.statistics());
+    println!("{}", countme::get_all());
 
     Ok(())
 }
@@ -122,6 +133,7 @@ impl MainLoop {
         }
     }
 
+    #[allow(clippy::print_stderr)]
     fn run(self, program: &mut Program) {
         self.orchestrator_sender
             .send(OrchestratorMessage::Run)
@@ -137,8 +149,8 @@ impl MainLoop {
 
                     // Spawn a new task that checks the program. This needs to be done in a separate thread
                     // to prevent blocking the main loop here.
-                    rayon::spawn(move || match program.check(ExecutionMode::ThreadPool) {
-                        Ok(result) => {
+                    rayon::spawn(move || {
+                        if let Ok(result) = program.check() {
                             sender
                                 .send(OrchestratorMessage::CheckProgramCompleted {
                                     diagnostics: result,
@@ -146,7 +158,6 @@ impl MainLoop {
                                 })
                                 .unwrap();
                         }
-                        Err(QueryError::Cancelled) => {}
                     });
                 }
                 MainLoopMessage::ApplyChanges(changes) => {
@@ -154,9 +165,11 @@ impl MainLoop {
                     program.apply_changes(changes);
                 }
                 MainLoopMessage::CheckCompleted(diagnostics) => {
-                    dbg!(diagnostics);
+                    eprintln!("{}", diagnostics.join("\n"));
+                    eprintln!("{}", countme::get_all());
                 }
                 MainLoopMessage::Exit => {
+                    eprintln!("{}", countme::get_all());
                     return;
                 }
             }
@@ -205,6 +218,7 @@ struct Orchestrator {
 }
 
 impl Orchestrator {
+    #[allow(clippy::print_stderr)]
     fn run(&mut self) {
         while let Ok(message) = self.receiver.recv() {
             match message {

crates/red_knot/src/parse.rs

@@ -1,93 +0,0 @@
-use std::ops::{Deref, DerefMut};
-use std::sync::Arc;
-
-use ruff_python_ast as ast;
-use ruff_python_parser::{Mode, ParseError};
-use ruff_text_size::{Ranged, TextRange};
-
-use crate::cache::KeyValueCache;
-use crate::db::{QueryResult, SourceDb};
-use crate::files::FileId;
-use crate::source::source_text;
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Parsed {
-    inner: Arc<ParsedInner>,
-}
-
-#[derive(Debug, PartialEq)]
-struct ParsedInner {
-    ast: ast::ModModule,
-    errors: Vec<ParseError>,
-}
-
-impl Parsed {
-    fn new(ast: ast::ModModule, errors: Vec<ParseError>) -> Self {
-        Self {
-            inner: Arc::new(ParsedInner { ast, errors }),
-        }
-    }
-
-    pub(crate) fn from_text(text: &str) -> Self {
-        let result = ruff_python_parser::parse(text, Mode::Module);
-
-        let (module, errors) = match result {
-            Ok(ast::Mod::Module(module)) => (module, vec![]),
-            Ok(ast::Mod::Expression(expression)) => (
-                ast::ModModule {
-                    range: expression.range(),
-                    body: vec![ast::Stmt::Expr(ast::StmtExpr {
-                        range: expression.range(),
-                        value: expression.body,
-                    })],
-                },
-                vec![],
-            ),
-            Err(errors) => (
-                ast::ModModule {
-                    range: TextRange::default(),
-                    body: Vec::new(),
-                },
-                vec![errors],
-            ),
-        };
-
-        Parsed::new(module, errors)
-    }
-
-    pub fn ast(&self) -> &ast::ModModule {
-        &self.inner.ast
-    }
-
-    pub fn errors(&self) -> &[ParseError] {
-        &self.inner.errors
-    }
-}
-
-#[tracing::instrument(level = "debug", skip(db))]
-pub(crate) fn parse(db: &dyn SourceDb, file_id: FileId) -> QueryResult<Parsed> {
-    let jar = db.jar()?;
-
-    jar.parsed.get(&file_id, |file_id| {
-        let source = source_text(db, *file_id)?;
-
-        Ok(Parsed::from_text(source.text()))
-    })
-}
-
-#[derive(Debug, Default)]
-pub struct ParsedStorage(KeyValueCache<FileId, Parsed>);
-
-impl Deref for ParsedStorage {
-    type Target = KeyValueCache<FileId, Parsed>;
-
-    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 +1,32 @@
-use rayon::{current_num_threads, yield_local};
-use rustc_hash::FxHashSet;
+use ruff_db::vfs::VfsFile;
+use salsa::Cancelled;
 
-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::symbols::{symbol_table, 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()?;
+    pub fn check(&self) -> Result<Vec<String>, Cancelled> {
+        self.with_db(|db| {
+            let mut result = Vec::new();
+            for open_file in db.workspace.open_files() {
+                result.extend_from_slice(&db.check_file_impl(open_file));
+            }
 
-        let mut context = CheckContext::new(self);
-
-        match mode {
-            ExecutionMode::SingleThreaded => SingleThreadedExecutor.run(&mut context)?,
-            ExecutionMode::ThreadPool => ThreadPoolExecutor.run(&mut context)?,
-        };
-
-        Ok(context.finish())
+            result
+        })
     }
 
-    #[tracing::instrument(level = "debug", skip(self, context))]
-    fn check_file(&self, file: FileId, context: &CheckFileContext) -> QueryResult<Diagnostics> {
-        self.cancelled()?;
-
-        let symbol_table = symbol_table(self, file)?;
-        let dependencies = 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());
-                        }
-                    }
-                }
-            }
-        }
+    #[tracing::instrument(level = "debug", skip(self))]
+    pub fn check_file(&self, file: VfsFile) -> Result<Diagnostics, Cancelled> {
+        self.with_db(|db| db.check_file_impl(file))
+    }
 
+    fn check_file_impl(&self, file: VfsFile) -> Diagnostics {
         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))
+        diagnostics.extend_from_slice(lint_syntax(self, file));
+        diagnostics.extend_from_slice(lint_semantic(self, file));
+        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,30 +1,36 @@
-use std::collections::hash_map::Entry;
-use std::path::{Path, PathBuf};
+use std::panic::{RefUnwindSafe, UnwindSafe};
 use std::sync::Arc;
 
-use rustc_hash::FxHashMap;
+use salsa::{Cancelled, Database};
 
-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 red_knot_module_resolver::{Db as ResolverDb, Jar as ResolverJar};
+use red_knot_python_semantic::{Db as SemanticDb, Jar as SemanticJar};
+use ruff_db::file_system::{FileSystem, FileSystemPathBuf};
+use ruff_db::vfs::{Vfs, VfsFile, VfsPath};
+use ruff_db::{Db as SourceDb, Jar as SourceJar, Upcast};
+
+use crate::db::{Db, Jar};
 use crate::Workspace;
 
-pub mod check;
+mod check;
 
-#[derive(Debug)]
+#[salsa::db(SourceJar, ResolverJar, SemanticJar, Jar)]
 pub struct Program {
-    jars: JarsStorage<Program>,
-    files: Files,
+    storage: salsa::Storage<Program>,
+    vfs: Vfs,
+    fs: Arc<dyn FileSystem + Send + Sync + RefUnwindSafe>,
     workspace: Workspace,
 }
 
 impl Program {
-    pub fn new(workspace: Workspace) -> Self {
+    pub fn new<Fs>(workspace: Workspace, file_system: Fs) -> Self
+    where
+        Fs: FileSystem + 'static + Send + Sync + RefUnwindSafe,
+    {
         Self {
-            jars: JarsStorage::default(),
-            files: Files::default(),
+            storage: salsa::Storage::default(),
+            vfs: Vfs::default(),
+            fs: Arc::new(file_system),
             workspace,
         }
     }
@@ -33,30 +39,11 @@ impl Program {
     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(change.id);
-            semantic.symbol_tables.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);
+        for change in changes {
+            VfsFile::touch_path(self, &VfsPath::file_system(change.path));
         }
     }
 
-    pub fn files(&self) -> &Files {
-        &self.files
-    }
-
     pub fn workspace(&self) -> &Workspace {
         &self.workspace
     }
@@ -64,28 +51,18 @@ impl Program {
     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)
+    #[allow(clippy::unnecessary_wraps)]
+    fn with_db<F, T>(&self, f: F) -> Result<T, Cancelled>
+    where
+        F: FnOnce(&Program) -> T + UnwindSafe,
+    {
+        // TODO: Catch in `Caancelled::catch`
+        //  See https://salsa.zulipchat.com/#narrow/stream/145099-general/topic/How.20to.20use.20.60Cancelled.3A.3Acatch.60
+        Ok(f(self))
     }
 }
 
-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
@@ -98,178 +75,57 @@ impl Upcast<dyn SourceDb> for Program {
     }
 }
 
-impl Upcast<dyn LintDb> for Program {
-    fn upcast(&self) -> &(dyn LintDb + 'static) {
+impl Upcast<dyn ResolverDb> for Program {
+    fn upcast(&self) -> &(dyn ResolverDb + 'static) {
         self
     }
 }
 
-impl Db for Program {}
+impl ResolverDb for Program {}
 
-impl Database for Program {
-    fn runtime(&self) -> &DbRuntime {
-        self.jars.runtime()
+impl SemanticDb for Program {}
+
+impl SourceDb for Program {
+    fn file_system(&self) -> &dyn FileSystem {
+        &*self.fs
     }
 
-    fn runtime_mut(&mut self) -> &mut DbRuntime {
-        self.jars.runtime_mut()
+    fn vfs(&self) -> &Vfs {
+        &self.vfs
     }
 }
 
-impl ParallelDatabase for Program {
-    fn snapshot(&self) -> Snapshot<Self> {
-        Snapshot::new(Self {
-            jars: self.jars.snapshot(),
-            files: self.files.snapshot(),
+impl Database for Program {}
+
+impl Db for Program {}
+
+impl salsa::ParallelDatabase for Program {
+    fn snapshot(&self) -> salsa::Snapshot<Self> {
+        salsa::Snapshot::new(Self {
+            storage: self.storage.snapshot(),
+            vfs: self.vfs.snapshot(),
+            fs: self.fs.clone(),
             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,
+    path: FileSystemPathBuf,
+    #[allow(unused)]
     kind: FileChangeKind,
 }
 
 impl FileWatcherChange {
-    pub fn new(path: PathBuf, kind: FileChangeKind) -> Self {
+    pub fn new(path: FileSystemPathBuf, 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/source.rs

@@ -1,95 +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>),
-}
-
-#[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/types.rs

@@ -1,745 +0,0 @@
-#![allow(dead_code)]
-use crate::ast_ids::NodeKey;
-use crate::db::{QueryResult, SemanticDb, SemanticJar};
-use crate::files::FileId;
-use crate::symbols::{symbol_table, GlobalSymbolId, ScopeId, ScopeKind, SymbolId};
-use crate::{FxDashMap, FxIndexSet, Name};
-use ruff_index::{newtype_index, IndexVec};
-use rustc_hash::FxHashMap;
-
-pub(crate) mod infer;
-
-pub(crate) use infer::{infer_definition_type, infer_symbol_type};
-
-/// unique ID for a type
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum Type {
-    /// the dynamic or gradual type: a statically-unknown set of values
-    Any,
-    /// the empty set of values
-    Never,
-    /// unknown type (no annotation)
-    /// equivalent to Any, or to object in strict mode
-    Unknown,
-    /// name is not bound to any value
-    Unbound,
-    /// a specific function object
-    Function(FunctionTypeId),
-    /// a specific class object
-    Class(ClassTypeId),
-    /// the set of Python objects with the given class in their __class__'s method resolution order
-    Instance(ClassTypeId),
-    Union(UnionTypeId),
-    Intersection(IntersectionTypeId),
-    // TODO protocols, callable types, overloads, generics, type vars
-}
-
-impl Type {
-    fn display<'a>(&'a self, store: &'a TypeStore) -> DisplayType<'a> {
-        DisplayType { ty: self, store }
-    }
-
-    pub const fn is_unbound(&self) -> bool {
-        matches!(self, Type::Unbound)
-    }
-
-    pub const fn is_unknown(&self) -> bool {
-        matches!(self, Type::Unknown)
-    }
-}
-
-impl From<FunctionTypeId> for Type {
-    fn from(id: FunctionTypeId) -> Self {
-        Type::Function(id)
-    }
-}
-
-impl From<UnionTypeId> for Type {
-    fn from(id: UnionTypeId) -> Self {
-        Type::Union(id)
-    }
-}
-
-impl From<IntersectionTypeId> for Type {
-    fn from(id: IntersectionTypeId) -> Self {
-        Type::Intersection(id)
-    }
-}
-
-// TODO: currently calling `get_function` et al and holding on to the `FunctionTypeRef` will lock a
-// shard of this dashmap, for as long as you hold the reference. This may be a problem. We could
-// switch to having all the arenas hold Arc, or we could see if we can split up ModuleTypeStore,
-// and/or give it inner mutability and finer-grained internal locking.
-#[derive(Debug, Default)]
-pub struct TypeStore {
-    modules: FxDashMap<FileId, ModuleTypeStore>,
-}
-
-impl TypeStore {
-    pub fn remove_module(&mut self, file_id: FileId) {
-        self.modules.remove(&file_id);
-    }
-
-    pub fn cache_symbol_type(&self, symbol: GlobalSymbolId, ty: Type) {
-        self.add_or_get_module(symbol.file_id)
-            .symbol_types
-            .insert(symbol.symbol_id, ty);
-    }
-
-    pub fn cache_node_type(&self, file_id: FileId, node_key: NodeKey, ty: Type) {
-        self.add_or_get_module(file_id)
-            .node_types
-            .insert(node_key, ty);
-    }
-
-    pub fn get_cached_symbol_type(&self, symbol: GlobalSymbolId) -> Option<Type> {
-        self.try_get_module(symbol.file_id)?
-            .symbol_types
-            .get(&symbol.symbol_id)
-            .copied()
-    }
-
-    pub fn get_cached_node_type(&self, file_id: FileId, node_key: &NodeKey) -> Option<Type> {
-        self.try_get_module(file_id)?
-            .node_types
-            .get(node_key)
-            .copied()
-    }
-
-    fn add_or_get_module(&self, file_id: FileId) -> ModuleStoreRefMut {
-        self.modules
-            .entry(file_id)
-            .or_insert_with(|| ModuleTypeStore::new(file_id))
-    }
-
-    fn get_module(&self, file_id: FileId) -> ModuleStoreRef {
-        self.try_get_module(file_id).expect("module should exist")
-    }
-
-    fn try_get_module(&self, file_id: FileId) -> Option<ModuleStoreRef> {
-        self.modules.get(&file_id)
-    }
-
-    fn add_function(
-        &self,
-        file_id: FileId,
-        name: &str,
-        symbol_id: SymbolId,
-        scope_id: ScopeId,
-        decorators: Vec<Type>,
-    ) -> FunctionTypeId {
-        self.add_or_get_module(file_id)
-            .add_function(name, symbol_id, scope_id, decorators)
-    }
-
-    fn add_class(
-        &self,
-        file_id: FileId,
-        name: &str,
-        scope_id: ScopeId,
-        bases: Vec<Type>,
-    ) -> ClassTypeId {
-        self.add_or_get_module(file_id)
-            .add_class(name, scope_id, bases)
-    }
-
-    fn add_union(&mut self, file_id: FileId, elems: &[Type]) -> UnionTypeId {
-        self.add_or_get_module(file_id).add_union(elems)
-    }
-
-    fn add_intersection(
-        &mut self,
-        file_id: FileId,
-        positive: &[Type],
-        negative: &[Type],
-    ) -> IntersectionTypeId {
-        self.add_or_get_module(file_id)
-            .add_intersection(positive, negative)
-    }
-
-    fn get_function(&self, id: FunctionTypeId) -> FunctionTypeRef {
-        FunctionTypeRef {
-            module_store: self.get_module(id.file_id),
-            function_id: id.func_id,
-        }
-    }
-
-    fn get_class(&self, id: ClassTypeId) -> ClassTypeRef {
-        ClassTypeRef {
-            module_store: self.get_module(id.file_id),
-            class_id: id.class_id,
-        }
-    }
-
-    fn get_union(&self, id: UnionTypeId) -> UnionTypeRef {
-        UnionTypeRef {
-            module_store: self.get_module(id.file_id),
-            union_id: id.union_id,
-        }
-    }
-
-    fn get_intersection(&self, id: IntersectionTypeId) -> IntersectionTypeRef {
-        IntersectionTypeRef {
-            module_store: self.get_module(id.file_id),
-            intersection_id: id.intersection_id,
-        }
-    }
-}
-
-type ModuleStoreRef<'a> = dashmap::mapref::one::Ref<
-    'a,
-    FileId,
-    ModuleTypeStore,
-    std::hash::BuildHasherDefault<rustc_hash::FxHasher>,
->;
-
-type ModuleStoreRefMut<'a> = dashmap::mapref::one::RefMut<
-    'a,
-    FileId,
-    ModuleTypeStore,
-    std::hash::BuildHasherDefault<rustc_hash::FxHasher>,
->;
-
-#[derive(Debug)]
-pub(crate) struct FunctionTypeRef<'a> {
-    module_store: ModuleStoreRef<'a>,
-    function_id: ModuleFunctionTypeId,
-}
-
-impl<'a> std::ops::Deref for FunctionTypeRef<'a> {
-    type Target = FunctionType;
-
-    fn deref(&self) -> &Self::Target {
-        self.module_store.get_function(self.function_id)
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct ClassTypeRef<'a> {
-    module_store: ModuleStoreRef<'a>,
-    class_id: ModuleClassTypeId,
-}
-
-impl<'a> std::ops::Deref for ClassTypeRef<'a> {
-    type Target = ClassType;
-
-    fn deref(&self) -> &Self::Target {
-        self.module_store.get_class(self.class_id)
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct UnionTypeRef<'a> {
-    module_store: ModuleStoreRef<'a>,
-    union_id: ModuleUnionTypeId,
-}
-
-impl<'a> std::ops::Deref for UnionTypeRef<'a> {
-    type Target = UnionType;
-
-    fn deref(&self) -> &Self::Target {
-        self.module_store.get_union(self.union_id)
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct IntersectionTypeRef<'a> {
-    module_store: ModuleStoreRef<'a>,
-    intersection_id: ModuleIntersectionTypeId,
-}
-
-impl<'a> std::ops::Deref for IntersectionTypeRef<'a> {
-    type Target = IntersectionType;
-
-    fn deref(&self) -> &Self::Target {
-        self.module_store.get_intersection(self.intersection_id)
-    }
-}
-
-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-pub struct FunctionTypeId {
-    file_id: FileId,
-    func_id: ModuleFunctionTypeId,
-}
-
-impl FunctionTypeId {
-    fn function(self, db: &dyn SemanticDb) -> QueryResult<FunctionTypeRef> {
-        let jar: &SemanticJar = db.jar()?;
-        Ok(jar.type_store.get_function(self))
-    }
-
-    pub(crate) fn name(self, db: &dyn SemanticDb) -> QueryResult<Name> {
-        Ok(self.function(db)?.name().into())
-    }
-
-    pub(crate) fn global_symbol(self, db: &dyn SemanticDb) -> QueryResult<GlobalSymbolId> {
-        Ok(GlobalSymbolId {
-            file_id: self.file(),
-            symbol_id: self.symbol(db)?,
-        })
-    }
-
-    pub(crate) fn file(self) -> FileId {
-        self.file_id
-    }
-
-    pub(crate) fn symbol(self, db: &dyn SemanticDb) -> QueryResult<SymbolId> {
-        let FunctionType { symbol_id, .. } = *self.function(db)?;
-        Ok(symbol_id)
-    }
-
-    pub(crate) fn get_containing_class(
-        self,
-        db: &dyn SemanticDb,
-    ) -> QueryResult<Option<ClassTypeId>> {
-        let table = symbol_table(db, self.file_id)?;
-        let FunctionType { symbol_id, .. } = *self.function(db)?;
-        let scope_id = symbol_id.symbol(&table).scope_id();
-        let scope = scope_id.scope(&table);
-        if !matches!(scope.kind(), ScopeKind::Class) {
-            return Ok(None);
-        };
-        let Some(def) = scope.definition() else {
-            return Ok(None);
-        };
-        let Some(symbol_id) = scope.defining_symbol() else {
-            return Ok(None);
-        };
-        let Type::Class(class) = infer_definition_type(
-            db,
-            GlobalSymbolId {
-                file_id: self.file_id,
-                symbol_id,
-            },
-            def,
-        )?
-        else {
-            return Ok(None);
-        };
-        Ok(Some(class))
-    }
-
-    pub(crate) fn has_decorator(
-        self,
-        db: &dyn SemanticDb,
-        decorator_symbol: GlobalSymbolId,
-    ) -> QueryResult<bool> {
-        for deco_ty in self.function(db)?.decorators() {
-            let Type::Function(deco_func) = deco_ty else {
-                continue;
-            };
-            if deco_func.global_symbol(db)? == decorator_symbol {
-                return Ok(true);
-            }
-        }
-        Ok(false)
-    }
-}
-
-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-pub struct ClassTypeId {
-    file_id: FileId,
-    class_id: ModuleClassTypeId,
-}
-
-impl ClassTypeId {
-    fn class(self, db: &dyn SemanticDb) -> QueryResult<ClassTypeRef> {
-        let jar: &SemanticJar = db.jar()?;
-        Ok(jar.type_store.get_class(self))
-    }
-
-    pub(crate) fn name(self, db: &dyn SemanticDb) -> QueryResult<Name> {
-        Ok(self.class(db)?.name().into())
-    }
-
-    pub(crate) fn get_super_class_member(
-        self,
-        db: &dyn SemanticDb,
-        name: &Name,
-    ) -> QueryResult<Option<Type>> {
-        // TODO we should linearize the MRO instead of doing this recursively
-        let class = self.class(db)?;
-        for base in class.bases() {
-            if let Type::Class(base) = base {
-                if let Some(own_member) = base.get_own_class_member(db, name)? {
-                    return Ok(Some(own_member));
-                }
-                if let Some(base_member) = base.get_super_class_member(db, name)? {
-                    return Ok(Some(base_member));
-                }
-            }
-        }
-        Ok(None)
-    }
-
-    fn get_own_class_member(self, db: &dyn SemanticDb, name: &Name) -> QueryResult<Option<Type>> {
-        // TODO: this should distinguish instance-only members (e.g. `x: int`) and not return them
-        let ClassType { scope_id, .. } = *self.class(db)?;
-        let table = symbol_table(db, self.file_id)?;
-        if let Some(symbol_id) = table.symbol_id_by_name(scope_id, name) {
-            Ok(Some(infer_symbol_type(
-                db,
-                GlobalSymbolId {
-                    file_id: self.file_id,
-                    symbol_id,
-                },
-            )?))
-        } else {
-            Ok(None)
-        }
-    }
-
-    // TODO: get_own_instance_member, get_class_member, get_instance_member
-}
-
-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-pub struct UnionTypeId {
-    file_id: FileId,
-    union_id: ModuleUnionTypeId,
-}
-
-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-pub struct IntersectionTypeId {
-    file_id: FileId,
-    intersection_id: ModuleIntersectionTypeId,
-}
-
-#[newtype_index]
-struct ModuleFunctionTypeId;
-
-#[newtype_index]
-struct ModuleClassTypeId;
-
-#[newtype_index]
-struct ModuleUnionTypeId;
-
-#[newtype_index]
-struct ModuleIntersectionTypeId;
-
-#[derive(Debug)]
-struct ModuleTypeStore {
-    file_id: FileId,
-    /// arena of all function types defined in this module
-    functions: IndexVec<ModuleFunctionTypeId, FunctionType>,
-    /// arena of all class types defined in this module
-    classes: IndexVec<ModuleClassTypeId, ClassType>,
-    /// arenda of all union types created in this module
-    unions: IndexVec<ModuleUnionTypeId, UnionType>,
-    /// arena of all intersection types created in this module
-    intersections: IndexVec<ModuleIntersectionTypeId, IntersectionType>,
-    /// cached types of symbols in this module
-    symbol_types: FxHashMap<SymbolId, Type>,
-    /// cached types of AST nodes in this module
-    node_types: FxHashMap<NodeKey, Type>,
-}
-
-impl ModuleTypeStore {
-    fn new(file_id: FileId) -> Self {
-        Self {
-            file_id,
-            functions: IndexVec::default(),
-            classes: IndexVec::default(),
-            unions: IndexVec::default(),
-            intersections: IndexVec::default(),
-            symbol_types: FxHashMap::default(),
-            node_types: FxHashMap::default(),
-        }
-    }
-
-    fn add_function(
-        &mut self,
-        name: &str,
-        symbol_id: SymbolId,
-        scope_id: ScopeId,
-        decorators: Vec<Type>,
-    ) -> FunctionTypeId {
-        let func_id = self.functions.push(FunctionType {
-            name: Name::new(name),
-            symbol_id,
-            scope_id,
-            decorators,
-        });
-        FunctionTypeId {
-            file_id: self.file_id,
-            func_id,
-        }
-    }
-
-    fn add_class(&mut self, name: &str, scope_id: ScopeId, bases: Vec<Type>) -> ClassTypeId {
-        let class_id = self.classes.push(ClassType {
-            name: Name::new(name),
-            scope_id,
-            // TODO: if no bases are given, that should imply [object]
-            bases,
-        });
-        ClassTypeId {
-            file_id: self.file_id,
-            class_id,
-        }
-    }
-
-    fn add_union(&mut self, elems: &[Type]) -> UnionTypeId {
-        let union_id = self.unions.push(UnionType {
-            elements: elems.iter().copied().collect(),
-        });
-        UnionTypeId {
-            file_id: self.file_id,
-            union_id,
-        }
-    }
-
-    fn add_intersection(&mut self, positive: &[Type], negative: &[Type]) -> IntersectionTypeId {
-        let intersection_id = self.intersections.push(IntersectionType {
-            positive: positive.iter().copied().collect(),
-            negative: negative.iter().copied().collect(),
-        });
-        IntersectionTypeId {
-            file_id: self.file_id,
-            intersection_id,
-        }
-    }
-
-    fn get_function(&self, func_id: ModuleFunctionTypeId) -> &FunctionType {
-        &self.functions[func_id]
-    }
-
-    fn get_class(&self, class_id: ModuleClassTypeId) -> &ClassType {
-        &self.classes[class_id]
-    }
-
-    fn get_union(&self, union_id: ModuleUnionTypeId) -> &UnionType {
-        &self.unions[union_id]
-    }
-
-    fn get_intersection(&self, intersection_id: ModuleIntersectionTypeId) -> &IntersectionType {
-        &self.intersections[intersection_id]
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-struct DisplayType<'a> {
-    ty: &'a Type,
-    store: &'a TypeStore,
-}
-
-impl std::fmt::Display for DisplayType<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self.ty {
-            Type::Any => f.write_str("Any"),
-            Type::Never => f.write_str("Never"),
-            Type::Unknown => f.write_str("Unknown"),
-            Type::Unbound => f.write_str("Unbound"),
-            // TODO functions and classes should display using a fully qualified name
-            Type::Class(class_id) => {
-                f.write_str("Literal[")?;
-                f.write_str(self.store.get_class(*class_id).name())?;
-                f.write_str("]")
-            }
-            Type::Instance(class_id) => f.write_str(self.store.get_class(*class_id).name()),
-            Type::Function(func_id) => f.write_str(self.store.get_function(*func_id).name()),
-            Type::Union(union_id) => self
-                .store
-                .get_module(union_id.file_id)
-                .get_union(union_id.union_id)
-                .display(f, self.store),
-            Type::Intersection(int_id) => self
-                .store
-                .get_module(int_id.file_id)
-                .get_intersection(int_id.intersection_id)
-                .display(f, self.store),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct ClassType {
-    /// Name of the class at definition
-    name: Name,
-    /// `ScopeId` of the class body
-    scope_id: ScopeId,
-    /// Types of all class bases
-    bases: Vec<Type>,
-}
-
-impl ClassType {
-    fn name(&self) -> &str {
-        self.name.as_str()
-    }
-
-    fn bases(&self) -> &[Type] {
-        self.bases.as_slice()
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct FunctionType {
-    /// name of the function at definition
-    name: Name,
-    /// symbol which this function is a definition of
-    symbol_id: SymbolId,
-    /// scope of this function's body
-    scope_id: ScopeId,
-    /// types of all decorators on this function
-    decorators: Vec<Type>,
-}
-
-impl FunctionType {
-    fn name(&self) -> &str {
-        self.name.as_str()
-    }
-
-    fn scope_id(&self) -> ScopeId {
-        self.scope_id
-    }
-
-    pub(crate) fn decorators(&self) -> &[Type] {
-        self.decorators.as_slice()
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct UnionType {
-    // the union type includes values in any of these types
-    elements: FxIndexSet<Type>,
-}
-
-impl UnionType {
-    fn display(&self, f: &mut std::fmt::Formatter<'_>, store: &TypeStore) -> std::fmt::Result {
-        f.write_str("(")?;
-        let mut first = true;
-        for ty in &self.elements {
-            if !first {
-                f.write_str(" | ")?;
-            };
-            first = false;
-            write!(f, "{}", ty.display(store))?;
-        }
-        f.write_str(")")
-    }
-}
-
-// Negation types aren't expressible in annotations, and are most likely to arise from type
-// narrowing along with intersections (e.g. `if not isinstance(...)`), so we represent them
-// directly in intersections rather than as a separate type. This sacrifices some efficiency in the
-// case where a Not appears outside an intersection (unclear when that could even happen, but we'd
-// have to represent it as a single-element intersection if it did) in exchange for better
-// efficiency in the within-intersection case.
-#[derive(Debug)]
-pub(crate) struct IntersectionType {
-    // the intersection type includes only values in all of these types
-    positive: FxIndexSet<Type>,
-    // the intersection type does not include any value in any of these types
-    negative: FxIndexSet<Type>,
-}
-
-impl IntersectionType {
-    fn display(&self, f: &mut std::fmt::Formatter<'_>, store: &TypeStore) -> std::fmt::Result {
-        f.write_str("(")?;
-        let mut first = true;
-        for (neg, ty) in self
-            .positive
-            .iter()
-            .map(|ty| (false, ty))
-            .chain(self.negative.iter().map(|ty| (true, ty)))
-        {
-            if !first {
-                f.write_str(" & ")?;
-            };
-            first = false;
-            if neg {
-                f.write_str("~")?;
-            };
-            write!(f, "{}", ty.display(store))?;
-        }
-        f.write_str(")")
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::path::Path;
-
-    use crate::files::Files;
-    use crate::symbols::{SymbolFlags, SymbolTable};
-    use crate::types::{Type, TypeStore};
-    use crate::FxIndexSet;
-
-    #[test]
-    fn add_class() {
-        let store = TypeStore::default();
-        let files = Files::default();
-        let file_id = files.intern(Path::new("/foo"));
-        let id = store.add_class(file_id, "C", SymbolTable::root_scope_id(), Vec::new());
-        assert_eq!(store.get_class(id).name(), "C");
-        let inst = Type::Instance(id);
-        assert_eq!(format!("{}", inst.display(&store)), "C");
-    }
-
-    #[test]
-    fn add_function() {
-        let store = TypeStore::default();
-        let files = Files::default();
-        let file_id = files.intern(Path::new("/foo"));
-        let mut table = SymbolTable::new();
-        let func_symbol = table.add_or_update_symbol(
-            SymbolTable::root_scope_id(),
-            "func",
-            SymbolFlags::IS_DEFINED,
-        );
-
-        let id = store.add_function(
-            file_id,
-            "func",
-            func_symbol,
-            SymbolTable::root_scope_id(),
-            vec![Type::Unknown],
-        );
-        assert_eq!(store.get_function(id).name(), "func");
-        assert_eq!(store.get_function(id).decorators(), vec![Type::Unknown]);
-        let func = Type::Function(id);
-        assert_eq!(format!("{}", func.display(&store)), "func");
-    }
-
-    #[test]
-    fn add_union() {
-        let mut store = TypeStore::default();
-        let files = Files::default();
-        let file_id = files.intern(Path::new("/foo"));
-        let c1 = store.add_class(file_id, "C1", SymbolTable::root_scope_id(), Vec::new());
-        let c2 = store.add_class(file_id, "C2", SymbolTable::root_scope_id(), Vec::new());
-        let elems = vec![Type::Instance(c1), Type::Instance(c2)];
-        let id = store.add_union(file_id, &elems);
-        assert_eq!(
-            store.get_union(id).elements,
-            elems.into_iter().collect::<FxIndexSet<_>>()
-        );
-        let union = Type::Union(id);
-        assert_eq!(format!("{}", union.display(&store)), "(C1 | C2)");
-    }
-
-    #[test]
-    fn add_intersection() {
-        let mut store = TypeStore::default();
-        let files = Files::default();
-        let file_id = files.intern(Path::new("/foo"));
-        let c1 = store.add_class(file_id, "C1", SymbolTable::root_scope_id(), Vec::new());
-        let c2 = store.add_class(file_id, "C2", SymbolTable::root_scope_id(), Vec::new());
-        let c3 = store.add_class(file_id, "C3", SymbolTable::root_scope_id(), Vec::new());
-        let pos = vec![Type::Instance(c1), Type::Instance(c2)];
-        let neg = vec![Type::Instance(c3)];
-        let id = store.add_intersection(file_id, &pos, &neg);
-        assert_eq!(
-            store.get_intersection(id).positive,
-            pos.into_iter().collect::<FxIndexSet<_>>()
-        );
-        assert_eq!(
-            store.get_intersection(id).negative,
-            neg.into_iter().collect::<FxIndexSet<_>>()
-        );
-        let intersection = Type::Intersection(id);
-        assert_eq!(
-            format!("{}", intersection.display(&store)),
-            "(C1 & C2 & ~C3)"
-        );
-    }
-}

crates/red_knot/src/types/infer.rs

@@ -1,292 +0,0 @@
-#![allow(dead_code)]
-
-use ruff_python_ast as ast;
-use ruff_python_ast::AstNode;
-
-use crate::db::{QueryResult, SemanticDb, SemanticJar};
-
-use crate::module::ModuleName;
-use crate::parse::parse;
-use crate::symbols::{
-    resolve_global_symbol, symbol_table, Definition, GlobalSymbolId, ImportFromDefinition,
-};
-use crate::types::Type;
-use crate::FileId;
-
-// FIXME: Figure out proper dead-lock free synchronisation now that this takes `&db` instead of `&mut db`.
-#[tracing::instrument(level = "trace", skip(db))]
-pub fn infer_symbol_type(db: &dyn SemanticDb, symbol: GlobalSymbolId) -> QueryResult<Type> {
-    let symbols = symbol_table(db, symbol.file_id)?;
-    let defs = symbols.definitions(symbol.symbol_id);
-    let jar: &SemanticJar = db.jar()?;
-
-    if let Some(ty) = jar.type_store.get_cached_symbol_type(symbol) {
-        return Ok(ty);
-    }
-
-    // TODO handle multiple defs, conditional defs...
-    assert_eq!(defs.len(), 1);
-
-    let ty = infer_definition_type(db, symbol, defs[0].clone())?;
-
-    jar.type_store.cache_symbol_type(symbol, ty);
-
-    // TODO record dependencies
-    Ok(ty)
-}
-
-#[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::ImportFrom(ImportFromDefinition {
-            module,
-            name,
-            level,
-        }) => {
-            // TODO relative imports
-            assert!(matches!(level, 0));
-            let module_name = ModuleName::new(module.as_ref().expect("TODO relative imports"));
-            if let Some(remote_symbol) = resolve_global_symbol(db, module_name, &name)? {
-                infer_symbol_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.ast();
-                let table = symbol_table(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 = table.scope_id_for_node(node_key.erased());
-                let ty = Type::Class(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.ast();
-                let table = symbol_table(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 = 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,
-                    )
-                    .into();
-                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.ast();
-            let node = node_key.resolve_unwrap(ast.as_any_node_ref());
-            // TODO handle unpacking assignment correctly
-            infer_expr_type(db, file_id, &node.value)
-        }
-        _ => todo!("other kinds of definitions"),
-    }
-}
-
-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 symbols = symbol_table(db, file_id)?;
-    match expr {
-        ast::Expr::Name(name) => {
-            // TODO look up in the correct scope, don't assume global
-            if let Some(symbol_id) = symbols.root_symbol_id_by_name(&name.id) {
-                infer_symbol_type(db, GlobalSymbolId { file_id, symbol_id })
-            } else {
-                Ok(Type::Unknown)
-            }
-        }
-        _ => todo!("full expression type resolution"),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::db::tests::TestDb;
-    use crate::db::{HasJar, SemanticJar};
-    use crate::module::{
-        resolve_module, set_module_search_paths, ModuleName, ModuleSearchPath, ModuleSearchPathKind,
-    };
-    use crate::symbols::{symbol_table, GlobalSymbolId};
-    use crate::types::{infer_symbol_type, 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: ModuleSearchPath,
-    }
-
-    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 = ModuleSearchPath::new(src.canonicalize()?, ModuleSearchPathKind::FirstParty);
-
-        let roots = vec![src.clone()];
-
-        let mut db = TestDb::default();
-        set_module_search_paths(&mut db, roots);
-
-        Ok(TestCase { temp_dir, db, src })
-    }
-
-    #[test]
-    fn follow_import_to_class() -> anyhow::Result<()> {
-        let case = create_test()?;
-        let db = &case.db;
-
-        let a_path = case.src.path().join("a.py");
-        let b_path = case.src.path().join("b.py");
-        std::fs::write(a_path, "from b import C as D; E = D")?;
-        std::fs::write(b_path, "class C: pass")?;
-        let a_file = resolve_module(db, ModuleName::new("a"))?
-            .expect("module should be found")
-            .path(db)?
-            .file();
-        let a_syms = symbol_table(db, a_file)?;
-        let e_sym = a_syms
-            .root_symbol_id_by_name("E")
-            .expect("E symbol should be found");
-
-        let ty = infer_symbol_type(
-            db,
-            GlobalSymbolId {
-                file_id: a_file,
-                symbol_id: e_sym,
-            },
-        )?;
-
-        let jar = HasJar::<SemanticJar>::jar(db)?;
-        assert!(matches!(ty, Type::Class(_)));
-        assert_eq!(format!("{}", ty.display(&jar.type_store)), "Literal[C]");
-
-        Ok(())
-    }
-
-    #[test]
-    fn resolve_base_class_by_name() -> anyhow::Result<()> {
-        let case = create_test()?;
-        let db = &case.db;
-
-        let path = case.src.path().join("mod.py");
-        std::fs::write(path, "class Base: pass\nclass Sub(Base): pass")?;
-        let file = resolve_module(db, ModuleName::new("mod"))?
-            .expect("module should be found")
-            .path(db)?
-            .file();
-        let syms = symbol_table(db, file)?;
-        let sym = syms
-            .root_symbol_id_by_name("Sub")
-            .expect("Sub symbol should be found");
-
-        let ty = infer_symbol_type(
-            db,
-            GlobalSymbolId {
-                file_id: file,
-                symbol_id: sym,
-            },
-        )?;
-
-        let Type::Class(class_id) = ty else {
-            panic!("Sub is not a Class")
-        };
-        let jar = HasJar::<SemanticJar>::jar(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()?;
-        let db = &case.db;
-
-        let path = case.src.path().join("mod.py");
-        std::fs::write(path, "class C:\n  def f(self): pass")?;
-        let file = resolve_module(db, ModuleName::new("mod"))?
-            .expect("module should be found")
-            .path(db)?
-            .file();
-        let syms = symbol_table(db, file)?;
-        let sym = syms
-            .root_symbol_id_by_name("C")
-            .expect("C symbol should be found");
-
-        let ty = infer_symbol_type(
-            db,
-            GlobalSymbolId {
-                file_id: file,
-                symbol_id: sym,
-            },
-        )?;
-
-        let Type::Class(class_id) = ty else {
-            panic!("C is not a Class");
-        };
-
-        let member_ty = class_id
-            .get_own_class_member(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(db)?;
-        let function = jar.type_store.get_function(func_id);
-        assert_eq!(function.name(), "f");
-
-        Ok(())
-    }
-}

crates/red_knot/src/watch.rs

@@ -1,10 +1,10 @@
 use std::path::Path;
 
+use crate::program::{FileChangeKind, FileWatcherChange};
 use anyhow::Context;
 use notify::event::{CreateKind, RemoveKind};
 use notify::{recommended_watcher, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
-
-use crate::program::{FileChangeKind, FileWatcherChange};
+use ruff_db::file_system::FileSystemPath;
 
 pub struct FileWatcher {
     watcher: RecommendedWatcher,
@@ -50,7 +50,12 @@ impl FileWatcher {
 
                     for path in event.paths {
                         if path.is_file() {
-                            changes.push(FileWatcherChange::new(path, change_kind));
+                            if let Some(fs_path) = FileSystemPath::from_std_path(&path) {
+                                changes.push(FileWatcherChange::new(
+                                    fs_path.to_path_buf(),
+                                    change_kind,
+                                ));
+                            }
                         }
                     }
 

crates/red_knot/vendor/typeshed/source_commit.txt

@@ -1 +0,0 @@
-a9d7e861f7a46ae7acd56569326adef302e10f29

crates/red_knot/vendor/typeshed/stdlib/_ast.pyi

@@ -1,591 +0,0 @@
-import sys
-import typing_extensions
-from typing import Any, ClassVar, Literal
-
-PyCF_ONLY_AST: Literal[1024]
-PyCF_TYPE_COMMENTS: Literal[4096]
-PyCF_ALLOW_TOP_LEVEL_AWAIT: Literal[8192]
-
-# Alias used for fields that must always be valid identifiers
-# A string `x` counts as a valid identifier if both the following are True
-# (1) `x.isidentifier()` evaluates to `True`
-# (2) `keyword.iskeyword(x)` evaluates to `False`
-_Identifier: typing_extensions.TypeAlias = str
-
-class AST:
-    if sys.version_info >= (3, 10):
-        __match_args__ = ()
-    _attributes: ClassVar[tuple[str, ...]]
-    _fields: ClassVar[tuple[str, ...]]
-    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
-    # TODO: Not all nodes have all of the following attributes
-    lineno: int
-    col_offset: int
-    end_lineno: int | None
-    end_col_offset: int | None
-    type_comment: str | None
-
-class mod(AST): ...
-class type_ignore(AST): ...
-
-class TypeIgnore(type_ignore):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("lineno", "tag")
-    tag: str
-
-class FunctionType(mod):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("argtypes", "returns")
-    argtypes: list[expr]
-    returns: expr
-
-class Module(mod):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("body", "type_ignores")
-    body: list[stmt]
-    type_ignores: list[TypeIgnore]
-
-class Interactive(mod):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("body",)
-    body: list[stmt]
-
-class Expression(mod):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("body",)
-    body: expr
-
-class stmt(AST): ...
-
-class FunctionDef(stmt):
-    if sys.version_info >= (3, 12):
-        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment", "type_params")
-    elif sys.version_info >= (3, 10):
-        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment")
-    name: _Identifier
-    args: arguments
-    body: list[stmt]
-    decorator_list: list[expr]
-    returns: expr | None
-    if sys.version_info >= (3, 12):
-        type_params: list[type_param]
-
-class AsyncFunctionDef(stmt):
-    if sys.version_info >= (3, 12):
-        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment", "type_params")
-    elif sys.version_info >= (3, 10):
-        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment")
-    name: _Identifier
-    args: arguments
-    body: list[stmt]
-    decorator_list: list[expr]
-    returns: expr | None
-    if sys.version_info >= (3, 12):
-        type_params: list[type_param]
-
-class ClassDef(stmt):
-    if sys.version_info >= (3, 12):
-        __match_args__ = ("name", "bases", "keywords", "body", "decorator_list", "type_params")
-    elif sys.version_info >= (3, 10):
-        __match_args__ = ("name", "bases", "keywords", "body", "decorator_list")
-    name: _Identifier
-    bases: list[expr]
-    keywords: list[keyword]
-    body: list[stmt]
-    decorator_list: list[expr]
-    if sys.version_info >= (3, 12):
-        type_params: list[type_param]
-
-class Return(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value",)
-    value: expr | None
-
-class Delete(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("targets",)
-    targets: list[expr]
-
-class Assign(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("targets", "value", "type_comment")
-    targets: list[expr]
-    value: expr
-
-class AugAssign(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "op", "value")
-    target: Name | Attribute | Subscript
-    op: operator
-    value: expr
-
-class AnnAssign(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "annotation", "value", "simple")
-    target: Name | Attribute | Subscript
-    annotation: expr
-    value: expr | None
-    simple: int
-
-class For(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "iter", "body", "orelse", "type_comment")
-    target: expr
-    iter: expr
-    body: list[stmt]
-    orelse: list[stmt]
-
-class AsyncFor(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "iter", "body", "orelse", "type_comment")
-    target: expr
-    iter: expr
-    body: list[stmt]
-    orelse: list[stmt]
-
-class While(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("test", "body", "orelse")
-    test: expr
-    body: list[stmt]
-    orelse: list[stmt]
-
-class If(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("test", "body", "orelse")
-    test: expr
-    body: list[stmt]
-    orelse: list[stmt]
-
-class With(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("items", "body", "type_comment")
-    items: list[withitem]
-    body: list[stmt]
-
-class AsyncWith(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("items", "body", "type_comment")
-    items: list[withitem]
-    body: list[stmt]
-
-class Raise(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("exc", "cause")
-    exc: expr | None
-    cause: expr | None
-
-class Try(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("body", "handlers", "orelse", "finalbody")
-    body: list[stmt]
-    handlers: list[ExceptHandler]
-    orelse: list[stmt]
-    finalbody: list[stmt]
-
-if sys.version_info >= (3, 11):
-    class TryStar(stmt):
-        __match_args__ = ("body", "handlers", "orelse", "finalbody")
-        body: list[stmt]
-        handlers: list[ExceptHandler]
-        orelse: list[stmt]
-        finalbody: list[stmt]
-
-class Assert(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("test", "msg")
-    test: expr
-    msg: expr | None
-
-class Import(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("names",)
-    names: list[alias]
-
-class ImportFrom(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("module", "names", "level")
-    module: str | None
-    names: list[alias]
-    level: int
-
-class Global(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("names",)
-    names: list[_Identifier]
-
-class Nonlocal(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("names",)
-    names: list[_Identifier]
-
-class Expr(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value",)
-    value: expr
-
-class Pass(stmt): ...
-class Break(stmt): ...
-class Continue(stmt): ...
-class expr(AST): ...
-
-class BoolOp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("op", "values")
-    op: boolop
-    values: list[expr]
-
-class BinOp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("left", "op", "right")
-    left: expr
-    op: operator
-    right: expr
-
-class UnaryOp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("op", "operand")
-    op: unaryop
-    operand: expr
-
-class Lambda(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("args", "body")
-    args: arguments
-    body: expr
-
-class IfExp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("test", "body", "orelse")
-    test: expr
-    body: expr
-    orelse: expr
-
-class Dict(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("keys", "values")
-    keys: list[expr | None]
-    values: list[expr]
-
-class Set(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elts",)
-    elts: list[expr]
-
-class ListComp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elt", "generators")
-    elt: expr
-    generators: list[comprehension]
-
-class SetComp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elt", "generators")
-    elt: expr
-    generators: list[comprehension]
-
-class DictComp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("key", "value", "generators")
-    key: expr
-    value: expr
-    generators: list[comprehension]
-
-class GeneratorExp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elt", "generators")
-    elt: expr
-    generators: list[comprehension]
-
-class Await(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value",)
-    value: expr
-
-class Yield(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value",)
-    value: expr | None
-
-class YieldFrom(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value",)
-    value: expr
-
-class Compare(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("left", "ops", "comparators")
-    left: expr
-    ops: list[cmpop]
-    comparators: list[expr]
-
-class Call(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("func", "args", "keywords")
-    func: expr
-    args: list[expr]
-    keywords: list[keyword]
-
-class FormattedValue(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value", "conversion", "format_spec")
-    value: expr
-    conversion: int
-    format_spec: expr | None
-
-class JoinedStr(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("values",)
-    values: list[expr]
-
-class Constant(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value", "kind")
-    value: Any  # None, str, bytes, bool, int, float, complex, Ellipsis
-    kind: str | None
-    # Aliases for value, for backwards compatibility
-    s: Any
-    n: int | float | complex
-
-class NamedExpr(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "value")
-    target: Name
-    value: expr
-
-class Attribute(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value", "attr", "ctx")
-    value: expr
-    attr: _Identifier
-    ctx: expr_context
-
-if sys.version_info >= (3, 9):
-    _Slice: typing_extensions.TypeAlias = expr
-else:
-    class slice(AST): ...
-    _Slice: typing_extensions.TypeAlias = slice
-
-class Slice(_Slice):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("lower", "upper", "step")
-    lower: expr | None
-    upper: expr | None
-    step: expr | None
-
-if sys.version_info < (3, 9):
-    class ExtSlice(slice):
-        dims: list[slice]
-
-    class Index(slice):
-        value: expr
-
-class Subscript(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value", "slice", "ctx")
-    value: expr
-    slice: _Slice
-    ctx: expr_context
-
-class Starred(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value", "ctx")
-    value: expr
-    ctx: expr_context
-
-class Name(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("id", "ctx")
-    id: _Identifier
-    ctx: expr_context
-
-class List(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elts", "ctx")
-    elts: list[expr]
-    ctx: expr_context
-
-class Tuple(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elts", "ctx")
-    elts: list[expr]
-    ctx: expr_context
-    if sys.version_info >= (3, 9):
-        dims: list[expr]
-
-class expr_context(AST): ...
-
-if sys.version_info < (3, 9):
-    class AugLoad(expr_context): ...
-    class AugStore(expr_context): ...
-    class Param(expr_context): ...
-
-    class Suite(mod):
-        body: list[stmt]
-
-class Del(expr_context): ...
-class Load(expr_context): ...
-class Store(expr_context): ...
-class boolop(AST): ...
-class And(boolop): ...
-class Or(boolop): ...
-class operator(AST): ...
-class Add(operator): ...
-class BitAnd(operator): ...
-class BitOr(operator): ...
-class BitXor(operator): ...
-class Div(operator): ...
-class FloorDiv(operator): ...
-class LShift(operator): ...
-class Mod(operator): ...
-class Mult(operator): ...
-class MatMult(operator): ...
-class Pow(operator): ...
-class RShift(operator): ...
-class Sub(operator): ...
-class unaryop(AST): ...
-class Invert(unaryop): ...
-class Not(unaryop): ...
-class UAdd(unaryop): ...
-class USub(unaryop): ...
-class cmpop(AST): ...
-class Eq(cmpop): ...
-class Gt(cmpop): ...
-class GtE(cmpop): ...
-class In(cmpop): ...
-class Is(cmpop): ...
-class IsNot(cmpop): ...
-class Lt(cmpop): ...
-class LtE(cmpop): ...
-class NotEq(cmpop): ...
-class NotIn(cmpop): ...
-
-class comprehension(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "iter", "ifs", "is_async")
-    target: expr
-    iter: expr
-    ifs: list[expr]
-    is_async: int
-
-class excepthandler(AST): ...
-
-class ExceptHandler(excepthandler):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("type", "name", "body")
-    type: expr | None
-    name: _Identifier | None
-    body: list[stmt]
-
-class arguments(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("posonlyargs", "args", "vararg", "kwonlyargs", "kw_defaults", "kwarg", "defaults")
-    posonlyargs: list[arg]
-    args: list[arg]
-    vararg: arg | None
-    kwonlyargs: list[arg]
-    kw_defaults: list[expr | None]
-    kwarg: arg | None
-    defaults: list[expr]
-
-class arg(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("arg", "annotation", "type_comment")
-    arg: _Identifier
-    annotation: expr | None
-
-class keyword(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("arg", "value")
-    arg: _Identifier | None
-    value: expr
-
-class alias(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("name", "asname")
-    name: str
-    asname: _Identifier | None
-
-class withitem(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("context_expr", "optional_vars")
-    context_expr: expr
-    optional_vars: expr | None
-
-if sys.version_info >= (3, 10):
-    class Match(stmt):
-        __match_args__ = ("subject", "cases")
-        subject: expr
-        cases: list[match_case]
-
-    class pattern(AST): ...
-    # Without the alias, Pyright complains variables named pattern are recursively defined
-    _Pattern: typing_extensions.TypeAlias = pattern
-
-    class match_case(AST):
-        __match_args__ = ("pattern", "guard", "body")
-        pattern: _Pattern
-        guard: expr | None
-        body: list[stmt]
-
-    class MatchValue(pattern):
-        __match_args__ = ("value",)
-        value: expr
-
-    class MatchSingleton(pattern):
-        __match_args__ = ("value",)
-        value: Literal[True, False] | None
-
-    class MatchSequence(pattern):
-        __match_args__ = ("patterns",)
-        patterns: list[pattern]
-
-    class MatchStar(pattern):
-        __match_args__ = ("name",)
-        name: _Identifier | None
-
-    class MatchMapping(pattern):
-        __match_args__ = ("keys", "patterns", "rest")
-        keys: list[expr]
-        patterns: list[pattern]
-        rest: _Identifier | None
-
-    class MatchClass(pattern):
-        __match_args__ = ("cls", "patterns", "kwd_attrs", "kwd_patterns")
-        cls: expr
-        patterns: list[pattern]
-        kwd_attrs: list[_Identifier]
-        kwd_patterns: list[pattern]
-
-    class MatchAs(pattern):
-        __match_args__ = ("pattern", "name")
-        pattern: _Pattern | None
-        name: _Identifier | None
-
-    class MatchOr(pattern):
-        __match_args__ = ("patterns",)
-        patterns: list[pattern]
-
-if sys.version_info >= (3, 12):
-    class type_param(AST):
-        end_lineno: int
-        end_col_offset: int
-
-    class TypeVar(type_param):
-        __match_args__ = ("name", "bound")
-        name: _Identifier
-        bound: expr | None
-
-    class ParamSpec(type_param):
-        __match_args__ = ("name",)
-        name: _Identifier
-
-    class TypeVarTuple(type_param):
-        __match_args__ = ("name",)
-        name: _Identifier
-
-    class TypeAlias(stmt):
-        __match_args__ = ("name", "type_params", "value")
-        name: Name
-        type_params: list[type_param]
-        value: expr

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

@@ -1,196 +0,0 @@
-import sys
-import types
-from abc import ABCMeta, abstractmethod
-from collections.abc import Callable
-from typing import Literal
-from typing_extensions import Self, TypeVarTuple, Unpack, deprecated
-
-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):
-        __all__ = (
-            "SelectorEventLoop",
-            "AbstractChildWatcher",
-            "SafeChildWatcher",
-            "FastChildWatcher",
-            "PidfdChildWatcher",
-            "MultiLoopChildWatcher",
-            "ThreadedChildWatcher",
-            "DefaultEventLoopPolicy",
-        )
-    else:
-        __all__ = (
-            "SelectorEventLoop",
-            "AbstractChildWatcher",
-            "SafeChildWatcher",
-            "FastChildWatcher",
-            "MultiLoopChildWatcher",
-            "ThreadedChildWatcher",
-            "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: ...
-
-    if sys.version_info >= (3, 12):
-        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-        class SafeChildWatcher(BaseChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
-
-        @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:
-        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): ...
-
-    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: ...
-
-    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: ...
-            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: ...
-
-    class ThreadedChildWatcher(AbstractChildWatcher):
-        def is_active(self) -> Literal[True]: ...
-        def close(self) -> None: ...
-        def __enter__(self) -> Self: ...
-        def __exit__(
-            self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-        ) -> None: ...
-        def __del__(self) -> None: ...
-        def add_child_handler(
-            self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-        ) -> None: ...
-        def remove_child_handler(self, pid: int) -> bool: ...
-        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-
-    if sys.version_info >= (3, 9):
-        class PidfdChildWatcher(AbstractChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(
-                self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-            ) -> None: ...
-            def is_active(self) -> bool: ...
-            def close(self) -> None: ...
-            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...

crates/red_knot/vendor/typeshed/stdlib/distutils/archive_util.pyi

@@ -1,20 +0,0 @@
-def make_archive(
-    base_name: str,
-    format: str,
-    root_dir: str | None = None,
-    base_dir: str | None = None,
-    verbose: int = 0,
-    dry_run: int = 0,
-    owner: str | None = None,
-    group: str | None = None,
-) -> str: ...
-def make_tarball(
-    base_name: str,
-    base_dir: str,
-    compress: str | None = "gzip",
-    verbose: int = 0,
-    dry_run: int = 0,
-    owner: str | None = None,
-    group: str | None = None,
-) -> str: ...
-def make_zipfile(base_name: str, base_dir: str, verbose: int = 0, dry_run: int = 0) -> str: ...

crates/red_knot/vendor/typeshed/stdlib/distutils/cmd.pyi

@@ -1,66 +0,0 @@
-from _typeshed import Incomplete
-from abc import abstractmethod
-from collections.abc import Callable, Iterable
-from distutils.dist import Distribution
-from typing import Any
-
-class Command:
-    distribution: Distribution
-    sub_commands: list[tuple[str, Callable[[Command], bool] | None]]
-    def __init__(self, dist: Distribution) -> None: ...
-    @abstractmethod
-    def initialize_options(self) -> None: ...
-    @abstractmethod
-    def finalize_options(self) -> None: ...
-    @abstractmethod
-    def run(self) -> None: ...
-    def announce(self, msg: str, level: int = 1) -> None: ...
-    def debug_print(self, msg: str) -> None: ...
-    def ensure_string(self, option: str, default: str | None = None) -> None: ...
-    def ensure_string_list(self, option: str | list[str]) -> None: ...
-    def ensure_filename(self, option: str) -> None: ...
-    def ensure_dirname(self, option: str) -> None: ...
-    def get_command_name(self) -> str: ...
-    def set_undefined_options(self, src_cmd: str, *option_pairs: tuple[str, str]) -> None: ...
-    def get_finalized_command(self, command: str, create: int = 1) -> Command: ...
-    def reinitialize_command(self, command: Command | str, reinit_subcommands: int = 0) -> Command: ...
-    def run_command(self, command: str) -> None: ...
-    def get_sub_commands(self) -> list[str]: ...
-    def warn(self, msg: str) -> None: ...
-    def execute(self, func: Callable[..., object], args: Iterable[Any], msg: str | None = None, level: int = 1) -> None: ...
-    def mkpath(self, name: str, mode: int = 0o777) -> None: ...
-    def copy_file(
-        self, infile: str, outfile: str, preserve_mode: int = 1, preserve_times: int = 1, link: str | None = None, level: Any = 1
-    ) -> tuple[str, bool]: ...  # level is not used
-    def copy_tree(
-        self,
-        infile: str,
-        outfile: str,
-        preserve_mode: int = 1,
-        preserve_times: int = 1,
-        preserve_symlinks: int = 0,
-        level: Any = 1,
-    ) -> list[str]: ...  # level is not used
-    def move_file(self, src: str, dst: str, level: Any = 1) -> str: ...  # level is not used
-    def spawn(self, cmd: Iterable[str], search_path: int = 1, level: Any = 1) -> None: ...  # level is not used
-    def make_archive(
-        self,
-        base_name: str,
-        format: str,
-        root_dir: str | None = None,
-        base_dir: str | None = None,
-        owner: str | None = None,
-        group: str | None = None,
-    ) -> str: ...
-    def make_file(
-        self,
-        infiles: str | list[str] | tuple[str, ...],
-        outfile: str,
-        func: Callable[..., object],
-        args: list[Any],
-        exec_msg: str | None = None,
-        skip_msg: str | None = None,
-        level: Any = 1,
-    ) -> None: ...  # level is not used
-    def ensure_finalized(self) -> None: ...
-    def dump_options(self, header: Incomplete | None = None, indent: str = "") -> None: ...

crates/red_knot/vendor/typeshed/stdlib/distutils/dep_util.pyi

@@ -1,3 +0,0 @@
-def newer(source: str, target: str) -> bool: ...
-def newer_pairwise(sources: list[str], targets: list[str]) -> list[tuple[str, str]]: ...
-def newer_group(sources: list[str], target: str, missing: str = "error") -> bool: ...

crates/red_knot/vendor/typeshed/stdlib/distutils/dir_util.pyi

@@ -1,13 +0,0 @@
-def mkpath(name: str, mode: int = 0o777, verbose: int = 1, dry_run: int = 0) -> list[str]: ...
-def create_tree(base_dir: str, files: list[str], mode: int = 0o777, verbose: int = 1, dry_run: int = 0) -> None: ...
-def copy_tree(
-    src: str,
-    dst: str,
-    preserve_mode: int = 1,
-    preserve_times: int = 1,
-    preserve_symlinks: int = 0,
-    update: int = 0,
-    verbose: int = 1,
-    dry_run: int = 0,
-) -> list[str]: ...
-def remove_tree(directory: str, verbose: int = 1, dry_run: int = 0) -> None: ...

crates/red_knot/vendor/typeshed/stdlib/distutils/file_util.pyi

@@ -1,14 +0,0 @@
-from collections.abc import Sequence
-
-def copy_file(
-    src: str,
-    dst: str,
-    preserve_mode: bool = ...,
-    preserve_times: bool = ...,
-    update: bool = ...,
-    link: str | None = None,
-    verbose: bool = ...,
-    dry_run: bool = ...,
-) -> tuple[str, str]: ...
-def move_file(src: str, dst: str, verbose: bool = ..., dry_run: bool = ...) -> str: ...
-def write_file(filename: str, contents: Sequence[str]) -> None: ...

crates/red_knot/vendor/typeshed/stdlib/distutils/spawn.pyi

@@ -1,2 +0,0 @@
-def spawn(cmd: list[str], search_path: bool = ..., verbose: bool = ..., dry_run: bool = ...) -> None: ...
-def find_executable(executable: str, path: str | None = None) -> str | None: ...

crates/red_knot/vendor/typeshed/stdlib/marshal.pyi

@@ -1,33 +0,0 @@
-import builtins
-import types
-from _typeshed import ReadableBuffer, SupportsRead, SupportsWrite
-from typing import Any
-from typing_extensions import TypeAlias
-
-version: int
-
-_Marshallable: TypeAlias = (
-    # handled in w_object() in marshal.c
-    None
-    | type[StopIteration]
-    | builtins.ellipsis
-    | bool
-    # handled in w_complex_object() in marshal.c
-    | int
-    | float
-    | complex
-    | bytes
-    | str
-    | tuple[_Marshallable, ...]
-    | list[Any]
-    | dict[Any, Any]
-    | set[Any]
-    | frozenset[_Marshallable]
-    | types.CodeType
-    | ReadableBuffer
-)
-
-def dump(value: _Marshallable, file: SupportsWrite[bytes], version: int = 4, /) -> None: ...
-def load(file: SupportsRead[bytes], /) -> Any: ...
-def dumps(value: _Marshallable, version: int = 4, /) -> bytes: ...
-def loads(bytes: ReadableBuffer, /) -> Any: ...

crates/red_knot/vendor/typeshed/stdlib/stat.pyi

@@ -1 +0,0 @@
-from _stat import *

crates/red_knot_module_resolver/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "red_knot_module_resolver"
+version = "0.0.0"
+publish = false
+authors = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+homepage = { workspace = true }
+documentation = { workspace = true }
+repository = { workspace = true }
+license = { workspace = true }
+
+[dependencies]
+ruff_db = { workspace = true }
+ruff_python_stdlib = { workspace = true }
+
+compact_str = { workspace = true }
+rustc-hash = { workspace = true }
+salsa = { workspace = true }
+tracing = { workspace = true }
+zip = { workspace = true }
+
+[build-dependencies]
+path-slash = { workspace = true }
+walkdir = { workspace = true }
+zip = { workspace = true }
+
+[dev-dependencies]
+anyhow = { workspace = true }
+insta = { workspace = true }
+tempfile = { workspace = true }
+walkdir = { workspace = true }
+
+[lints]
+workspace = true

crates/red_knot_module_resolver/README.md

@@ -0,0 +1,9 @@
+# Red Knot
+
+A work-in-progress multifile module resolver for Ruff.
+
+## Vendored types for the stdlib
+
+This crate vendors [typeshed](https://github.com/python/typeshed)'s stubs for the standard library. The vendored stubs can be found in `crates/red_knot_module_resolver/vendor/typeshed`. The file `crates/red_knot_module_resolver/vendor/typeshed/source_commit.txt` tells you the typeshed commit that our vendored stdlib stubs currently correspond to.
+
+The typeshed stubs are updated every two weeks via an automated PR using the `sync_typeshed.yaml` workflow in the `.github/workflows` directory. This workflow can also be triggered at any time via [workflow dispatch](https://docs.github.com/en/actions/using-workflows/manually-running-a-workflow#running-a-workflow).

crates/red_knot_module_resolver/build.rs

@@ -0,0 +1,74 @@
+//! Build script to package our vendored typeshed files
+//! into a zip archive that can be included in the Ruff binary.
+//!
+//! This script should be automatically run at build time
+//! whenever the script itself changes, or whenever any files
+//! in `crates/red_knot_module_resolver/vendor/typeshed` change.
+
+use std::fs::File;
+use std::path::Path;
+
+use path_slash::PathExt;
+use zip::result::ZipResult;
+use zip::write::{FileOptions, ZipWriter};
+use zip::CompressionMethod;
+
+const TYPESHED_SOURCE_DIR: &str = "vendor/typeshed";
+const TYPESHED_ZIP_LOCATION: &str = "/zipped_typeshed.zip";
+
+/// Recursively zip the contents of an entire directory.
+///
+/// This routine is adapted from a recipe at
+/// <https://github.com/zip-rs/zip-old/blob/5d0f198124946b7be4e5969719a7f29f363118cd/examples/write_dir.rs>
+fn zip_dir(directory_path: &str, writer: File) -> ZipResult<File> {
+    let mut zip = ZipWriter::new(writer);
+
+    let options = FileOptions::default()
+        .compression_method(CompressionMethod::Zstd)
+        .unix_permissions(0o644);
+
+    for entry in walkdir::WalkDir::new(directory_path) {
+        let dir_entry = entry.unwrap();
+        let absolute_path = dir_entry.path();
+        let normalized_relative_path = absolute_path
+            .strip_prefix(Path::new(directory_path))
+            .unwrap()
+            .to_slash()
+            .expect("Unexpected non-utf8 typeshed path!");
+
+        // Write file or directory explicitly
+        // Some unzip tools unzip files with directory paths correctly, some do not!
+        if absolute_path.is_file() {
+            println!("adding file {absolute_path:?} as {normalized_relative_path:?} ...");
+            zip.start_file(normalized_relative_path, options)?;
+            let mut f = File::open(absolute_path)?;
+            std::io::copy(&mut f, &mut zip).unwrap();
+        } else if !normalized_relative_path.is_empty() {
+            // Only if not root! Avoids path spec / warning
+            // and mapname conversion failed error on unzip
+            println!("adding dir {absolute_path:?} as {normalized_relative_path:?} ...");
+            zip.add_directory(normalized_relative_path, options)?;
+        }
+    }
+    zip.finish()
+}
+
+fn main() {
+    println!("cargo:rerun-if-changed={TYPESHED_SOURCE_DIR}");
+    assert!(
+        Path::new(TYPESHED_SOURCE_DIR).is_dir(),
+        "Where is typeshed?"
+    );
+    let out_dir = std::env::var("OUT_DIR").unwrap();
+
+    // N.B. Deliberately using `format!()` instead of `Path::join()` here,
+    // so that we use `/` as a path separator on all platforms.
+    // That enables us to load the typeshed zip at compile time in `module.rs`
+    // (otherwise we'd have to dynamically determine the exact path to the typeshed zip
+    // based on the default path separator for the specific platform we're on,
+    // which can't be done at compile time.)
+    let zipped_typeshed_location = format!("{out_dir}{TYPESHED_ZIP_LOCATION}");
+
+    let zipped_typeshed = File::create(zipped_typeshed_location).unwrap();
+    zip_dir(TYPESHED_SOURCE_DIR, zipped_typeshed).unwrap();
+}

crates/red_knot_module_resolver/src/db.rs

@@ -0,0 +1,156 @@
+use ruff_db::Upcast;
+
+use crate::resolver::{
+    file_to_module,
+    internal::{ModuleNameIngredient, ModuleResolverSearchPaths},
+    resolve_module_query,
+};
+
+#[salsa::jar(db=Db)]
+pub struct Jar(
+    ModuleNameIngredient<'_>,
+    ModuleResolverSearchPaths,
+    resolve_module_query,
+    file_to_module,
+);
+
+pub trait Db: salsa::DbWithJar<Jar> + ruff_db::Db + Upcast<dyn ruff_db::Db> {}
+
+pub(crate) mod tests {
+    use std::sync;
+
+    use salsa::DebugWithDb;
+
+    use ruff_db::file_system::{FileSystem, MemoryFileSystem, OsFileSystem};
+    use ruff_db::vfs::Vfs;
+
+    use super::*;
+
+    #[salsa::db(Jar, ruff_db::Jar)]
+    pub(crate) struct TestDb {
+        storage: salsa::Storage<Self>,
+        file_system: TestFileSystem,
+        events: sync::Arc<sync::Mutex<Vec<salsa::Event>>>,
+        vfs: Vfs,
+    }
+
+    impl TestDb {
+        #[allow(unused)]
+        pub(crate) fn new() -> Self {
+            Self {
+                storage: salsa::Storage::default(),
+                file_system: TestFileSystem::Memory(MemoryFileSystem::default()),
+                events: sync::Arc::default(),
+                vfs: Vfs::with_stubbed_vendored(),
+            }
+        }
+
+        /// Returns the memory file system.
+        ///
+        /// ## Panics
+        /// If this test db isn't using a memory file system.
+        #[allow(unused)]
+        pub(crate) fn memory_file_system(&self) -> &MemoryFileSystem {
+            if let TestFileSystem::Memory(fs) = &self.file_system {
+                fs
+            } else {
+                panic!("The test db is not using a memory file system");
+            }
+        }
+
+        /// Uses the real file system instead of the memory file system.
+        ///
+        /// This useful for testing advanced file system features like permissions, symlinks, etc.
+        ///
+        /// Note that any files written to the memory file system won't be copied over.
+        #[allow(unused)]
+        pub(crate) fn with_os_file_system(&mut self) {
+            self.file_system = TestFileSystem::Os(OsFileSystem);
+        }
+
+        #[allow(unused)]
+        pub(crate) fn vfs_mut(&mut self) -> &mut Vfs {
+            &mut self.vfs
+        }
+
+        /// Takes the salsa events.
+        ///
+        /// ## Panics
+        /// If there are any pending salsa snapshots.
+        #[allow(unused)]
+        pub(crate) fn take_salsa_events(&mut self) -> Vec<salsa::Event> {
+            let inner = sync::Arc::get_mut(&mut self.events).expect("no pending salsa snapshots");
+
+            let events = inner.get_mut().unwrap();
+            std::mem::take(&mut *events)
+        }
+
+        /// Clears the salsa events.
+        ///
+        /// ## Panics
+        /// If there are any pending salsa snapshots.
+        #[allow(unused)]
+        pub(crate) fn clear_salsa_events(&mut self) {
+            self.take_salsa_events();
+        }
+    }
+
+    impl Upcast<dyn ruff_db::Db> for TestDb {
+        fn upcast(&self) -> &(dyn ruff_db::Db + 'static) {
+            self
+        }
+    }
+
+    impl ruff_db::Db for TestDb {
+        fn file_system(&self) -> &dyn ruff_db::file_system::FileSystem {
+            self.file_system.inner()
+        }
+
+        fn vfs(&self) -> &ruff_db::vfs::Vfs {
+            &self.vfs
+        }
+    }
+
+    impl Db for TestDb {}
+
+    impl salsa::Database for TestDb {
+        fn salsa_event(&self, event: salsa::Event) {
+            tracing::trace!("event: {:?}", event.debug(self));
+            let mut events = self.events.lock().unwrap();
+            events.push(event);
+        }
+    }
+
+    impl salsa::ParallelDatabase for TestDb {
+        fn snapshot(&self) -> salsa::Snapshot<Self> {
+            salsa::Snapshot::new(Self {
+                storage: self.storage.snapshot(),
+                file_system: self.file_system.snapshot(),
+                events: self.events.clone(),
+                vfs: self.vfs.snapshot(),
+            })
+        }
+    }
+
+    enum TestFileSystem {
+        Memory(MemoryFileSystem),
+        #[allow(unused)]
+        Os(OsFileSystem),
+    }
+
+    impl TestFileSystem {
+        fn inner(&self) -> &dyn FileSystem {
+            match self {
+                Self::Memory(inner) => inner,
+                Self::Os(inner) => inner,
+            }
+        }
+
+        fn snapshot(&self) -> Self {
+            match self {
+                Self::Memory(inner) => Self::Memory(inner.snapshot()),
+                Self::Os(inner) => Self::Os(inner.snapshot()),
+            }
+        }
+    }
+}

crates/red_knot_module_resolver/src/lib.rs

@@ -0,0 +1,9 @@
+mod db;
+mod module;
+mod resolver;
+mod typeshed;
+
+pub use db::{Db, Jar};
+pub use module::{Module, ModuleKind, ModuleName};
+pub use resolver::{resolve_module, set_module_resolution_settings, ModuleResolutionSettings};
+pub use typeshed::versions::TypeshedVersions;

crates/red_knot_module_resolver/src/module.rs

@@ -0,0 +1,343 @@
+use compact_str::ToCompactString;
+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 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(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]
+    pub fn new(name: &str) -> Option<Self> {
+        Self::is_valid_name(name).then(|| Self(compact_str::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]
+    pub fn new_static(name: &'static str) -> Option<Self> {
+        // TODO(Micha): Use CompactString::const_new once we upgrade to 0.8 https://github.com/ParkMyCar/compact_str/pull/336
+        Self::is_valid_name(name).then(|| Self(compact_str::CompactString::from(name)))
+    }
+
+    fn is_valid_name(name: &str) -> bool {
+        if name.is_empty() {
+            return false;
+        }
+
+        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"]);
+    /// ```
+    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(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()));
+    /// ```
+    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 = compact_str::CompactString::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());
+
+            name
+        } else {
+            path.file_stem()?.to_compact_string()
+        };
+
+        Some(Self(name))
+    }
+}
+
+impl Deref for ModuleName {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.as_str()
+    }
+}
+
+impl PartialEq<str> for ModuleName {
+    fn eq(&self, other: &str) -> bool {
+        self.as_str() == other
+    }
+}
+
+impl PartialEq<ModuleName> for str {
+    fn eq(&self, other: &ModuleName) -> bool {
+        self == other.as_str()
+    }
+}
+
+impl std::fmt::Display for ModuleName {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+
+/// Representation of a Python module.
+#[derive(Clone, PartialEq, Eq)]
+pub struct Module {
+    inner: Arc<ModuleInner>,
+}
+
+impl Module {
+    pub(crate) fn new(
+        name: ModuleName,
+        kind: ModuleKind,
+        search_path: ModuleSearchPath,
+        file: VfsFile,
+    ) -> Self {
+        Self {
+            inner: Arc::new(ModuleInner {
+                name,
+                kind,
+                search_path,
+                file,
+            }),
+        }
+    }
+
+    /// The absolute name of the module (e.g. `foo.bar`)
+    pub fn name(&self) -> &ModuleName {
+        &self.inner.name
+    }
+
+    /// The file to the source code that defines this module
+    pub fn file(&self) -> VfsFile {
+        self.inner.file
+    }
+
+    /// The search path from which the module was resolved.
+    pub fn search_path(&self) -> &ModuleSearchPath {
+        &self.inner.search_path
+    }
+
+    /// Determine whether this module is a single-file module or a package
+    pub fn kind(&self) -> ModuleKind {
+        self.inner.kind
+    }
+}
+
+impl std::fmt::Debug for Module {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Module")
+            .field("name", &self.name())
+            .field("kind", &self.kind())
+            .field("file", &self.file())
+            .field("search_path", &self.search_path())
+            .finish()
+    }
+}
+
+impl salsa::DebugWithDb<dyn Db> for Module {
+    fn fmt(&self, f: &mut Formatter<'_>, db: &dyn Db) -> std::fmt::Result {
+        f.debug_struct("Module")
+            .field("name", &self.name())
+            .field("kind", &self.kind())
+            .field("file", &self.file().debug(db.upcast()))
+            .field("search_path", &self.search_path())
+            .finish()
+    }
+}
+
+#[derive(PartialEq, Eq)]
+struct ModuleInner {
+    name: ModuleName,
+    kind: ModuleKind,
+    search_path: ModuleSearchPath,
+    file: VfsFile,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum ModuleKind {
+    /// A single-file module (e.g. `foo.py` or `foo.pyi`)
+    Module,
+
+    /// 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/resolver.rs

@@ -0,0 +1,935 @@
+use std::ops::Deref;
+
+use ruff_db::file_system::{FileSystem, FileSystemPath, FileSystemPathBuf};
+use ruff_db::vfs::{system_path_to_file, vfs_path_to_file, VfsFile, VfsPath};
+
+use crate::module::{Module, ModuleKind, ModuleName, ModuleSearchPath, ModuleSearchPathKind};
+use crate::resolver::internal::ModuleResolverSearchPaths;
+use crate::Db;
+
+const TYPESHED_STDLIB_DIRECTORY: &str = "stdlib";
+
+/// Configures the module search paths for the module resolver.
+///
+/// Must be called before calling any other module resolution functions.
+pub fn set_module_resolution_settings(db: &mut dyn Db, config: ModuleResolutionSettings) {
+    // There's no concurrency issue here because we hold a `&mut dyn Db` reference. No other
+    // thread can mutate the `Db` while we're in this call, so using `try_get` to test if
+    // the settings have already been set is safe.
+    if let Some(existing) = ModuleResolverSearchPaths::try_get(db) {
+        existing
+            .set_search_paths(db)
+            .to(config.into_ordered_search_paths());
+    } else {
+        ModuleResolverSearchPaths::new(db, config.into_ordered_search_paths());
+    }
+}
+
+/// Resolves a module name to a module.
+pub fn resolve_module(db: &dyn Db, module_name: ModuleName) -> Option<Module> {
+    let interned_name = internal::ModuleNameIngredient::new(db, module_name);
+
+    resolve_module_query(db, interned_name)
+}
+
+/// Salsa query that resolves an interned [`ModuleNameIngredient`] to a module.
+///
+/// This query should not be called directly. Instead, use [`resolve_module`]. It only exists
+/// because Salsa requires the module name to be an ingredient.
+#[salsa::tracked]
+pub(crate) fn resolve_module_query<'db>(
+    db: &'db dyn Db,
+    module_name: internal::ModuleNameIngredient<'db>,
+) -> Option<Module> {
+    let _span = tracing::trace_span!("resolve_module", ?module_name).entered();
+
+    let name = module_name.name(db);
+
+    let (search_path, module_file, kind) = resolve_name(db, name)?;
+
+    let module = Module::new(name.clone(), kind, search_path, module_file);
+
+    Some(module)
+}
+
+/// Resolves the module for the given path.
+///
+/// Returns `None` if the path is not a module locatable via `sys.path`.
+#[allow(unused)]
+pub(crate) fn path_to_module(db: &dyn Db, path: &VfsPath) -> Option<Module> {
+    // It's not entirely clear on first sight why this method calls `file_to_module` instead of
+    // it being the other way round, considering that the first thing that `file_to_module` does
+    // is to retrieve the file's path.
+    //
+    // The reason is that `file_to_module` is a tracked Salsa query and salsa queries require that
+    // all arguments are Salsa ingredients (something stored in Salsa). `Path`s aren't salsa ingredients but
+    // `VfsFile` is. So what we do here is to retrieve the `path`'s `VfsFile` so that we can make
+    // use of Salsa's caching and invalidation.
+    let file = vfs_path_to_file(db.upcast(), path)?;
+    file_to_module(db, file)
+}
+
+/// Resolves the module for the file with the given id.
+///
+/// Returns `None` if the file is not a module locatable via `sys.path`.
+#[salsa::tracked]
+pub(crate) fn file_to_module(db: &dyn Db, file: VfsFile) -> Option<Module> {
+    let _span = tracing::trace_span!("file_to_module", ?file).entered();
+
+    let path = file.path(db.upcast());
+
+    let search_paths = module_search_paths(db);
+
+    let relative_path = search_paths
+        .iter()
+        .find_map(|root| match (root.path(), path) {
+            (VfsPath::FileSystem(root_path), VfsPath::FileSystem(path)) => {
+                let relative_path = path.strip_prefix(root_path).ok()?;
+                Some(relative_path)
+            }
+            (VfsPath::Vendored(_), VfsPath::Vendored(_)) => {
+                todo!("Add support for vendored modules")
+            }
+            (VfsPath::Vendored(_), VfsPath::FileSystem(_))
+            | (VfsPath::FileSystem(_), VfsPath::Vendored(_)) => None,
+        })?;
+
+    let module_name = ModuleName::from_relative_path(relative_path)?;
+
+    // Resolve the module name to see if Python would resolve the name to the same path.
+    // If it doesn't, then that means that multiple modules have the same name in different
+    // root paths, but that the module corresponding to `path` is in a lower priority search path,
+    // in which case we ignore it.
+    let module = resolve_module(db, module_name)?;
+
+    if file == module.file() {
+        Some(module)
+    } else {
+        // This path is for a module with the same name but with a different precedence. For example:
+        // ```
+        // src/foo.py
+        // src/foo/__init__.py
+        // ```
+        // The module name of `src/foo.py` is `foo`, but the module loaded by Python is `src/foo/__init__.py`.
+        // That means we need to ignore `src/foo.py` even though it resolves to the same module name.
+        None
+    }
+}
+
+/// Configures the search paths that are used to resolve modules.
+#[derive(Eq, PartialEq, Debug)]
+pub struct ModuleResolutionSettings {
+    /// List of user-provided paths that should take first priority in the module resolution.
+    /// Examples in other type checkers are mypy's MYPYPATH environment variable,
+    /// or pyright's stubPath configuration setting.
+    pub extra_paths: Vec<FileSystemPathBuf>,
+
+    /// The root of the workspace, used for finding first-party modules.
+    pub workspace_root: FileSystemPathBuf,
+
+    /// The path to the user's `site-packages` directory, where third-party packages from ``PyPI`` are installed.
+    pub site_packages: Option<FileSystemPathBuf>,
+
+    /// Optional path to standard-library typeshed stubs.
+    /// Currently this has to be a directory that exists on disk.
+    ///
+    /// (TODO: fall back to vendored stubs if no custom directory is provided.)
+    pub custom_typeshed: Option<FileSystemPathBuf>,
+}
+
+impl ModuleResolutionSettings {
+    /// Implementation of PEP 561's module resolution order
+    /// (with some small, deliberate, differences)
+    fn into_ordered_search_paths(self) -> OrderedSearchPaths {
+        let ModuleResolutionSettings {
+            extra_paths,
+            workspace_root,
+            site_packages,
+            custom_typeshed,
+        } = self;
+
+        let mut paths: Vec<_> = extra_paths
+            .into_iter()
+            .map(|path| ModuleSearchPath::new(path, ModuleSearchPathKind::Extra))
+            .collect();
+
+        paths.push(ModuleSearchPath::new(
+            workspace_root,
+            ModuleSearchPathKind::FirstParty,
+        ));
+
+        // TODO fallback to vendored typeshed stubs if no custom typeshed directory is provided by the user
+        if let Some(custom_typeshed) = custom_typeshed {
+            paths.push(ModuleSearchPath::new(
+                custom_typeshed.join(TYPESHED_STDLIB_DIRECTORY),
+                ModuleSearchPathKind::StandardLibrary,
+            ));
+        }
+
+        // TODO vendor typeshed's third-party stubs as well as the stdlib and fallback to them as a final step
+        if let Some(site_packages) = site_packages {
+            paths.push(ModuleSearchPath::new(
+                site_packages,
+                ModuleSearchPathKind::SitePackagesThirdParty,
+            ));
+        }
+
+        OrderedSearchPaths(paths)
+    }
+}
+
+/// A resolved module resolution order, implementing PEP 561
+/// (with some small, deliberate differences)
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub(crate) struct OrderedSearchPaths(Vec<ModuleSearchPath>);
+
+impl Deref for OrderedSearchPaths {
+    type Target = [ModuleSearchPath];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+// The singleton methods generated by salsa are all `pub` instead of `pub(crate)` which triggers
+// `unreachable_pub`. Work around this by creating a module and allow `unreachable_pub` for it.
+// Salsa also generates uses to `_db` variables for `interned` which triggers `clippy::used_underscore_binding`. Suppress that too
+// TODO(micha): Contribute a fix for this upstream where the singleton methods have the same visibility as the struct.
+#[allow(unreachable_pub, clippy::used_underscore_binding)]
+pub(crate) mod internal {
+    use crate::module::ModuleName;
+    use crate::resolver::OrderedSearchPaths;
+
+    #[salsa::input(singleton)]
+    pub(crate) struct ModuleResolverSearchPaths {
+        #[return_ref]
+        pub(super) search_paths: OrderedSearchPaths,
+    }
+
+    /// A thin wrapper around `ModuleName` to make it a Salsa ingredient.
+    ///
+    /// This is needed because Salsa requires that all query arguments are salsa ingredients.
+    #[salsa::interned]
+    pub(crate) struct ModuleNameIngredient<'db> {
+        #[return_ref]
+        pub(super) name: ModuleName,
+    }
+}
+
+fn module_search_paths(db: &dyn Db) -> &[ModuleSearchPath] {
+    ModuleResolverSearchPaths::get(db).search_paths(db)
+}
+
+/// Given a module name and a list of search paths in which to lookup modules,
+/// attempt to resolve the module name
+fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(ModuleSearchPath, VfsFile, ModuleKind)> {
+    let search_paths = module_search_paths(db);
+
+    for search_path in search_paths {
+        let mut components = name.components();
+        let module_name = components.next_back()?;
+
+        let VfsPath::FileSystem(fs_search_path) = search_path.path() else {
+            todo!("Vendored search paths are not yet supported");
+        };
+
+        match resolve_package(db.file_system(), fs_search_path, components) {
+            Ok(resolved_package) => {
+                let mut package_path = resolved_package.path;
+
+                package_path.push(module_name);
+
+                // Must be a `__init__.pyi` or `__init__.py` or it isn't a package.
+                let kind = if db.file_system().is_directory(&package_path) {
+                    package_path.push("__init__");
+                    ModuleKind::Package
+                } else {
+                    ModuleKind::Module
+                };
+
+                // TODO Implement full https://peps.python.org/pep-0561/#type-checker-module-resolution-order resolution
+                let stub = package_path.with_extension("pyi");
+
+                if let Some(stub) = system_path_to_file(db.upcast(), &stub) {
+                    return Some((search_path.clone(), stub, kind));
+                }
+
+                let module = package_path.with_extension("py");
+
+                if let Some(module) = system_path_to_file(db.upcast(), &module) {
+                    return Some((search_path.clone(), module, kind));
+                }
+
+                // For regular packages, don't search the next search path. All files of that
+                // package must be in the same location
+                if resolved_package.kind.is_regular_package() {
+                    return None;
+                }
+            }
+            Err(parent_kind) => {
+                if parent_kind.is_regular_package() {
+                    // For regular packages, don't search the next search path.
+                    return None;
+                }
+            }
+        }
+    }
+
+    None
+}
+
+fn resolve_package<'a, I>(
+    fs: &dyn FileSystem,
+    module_search_path: &FileSystemPath,
+    components: I,
+) -> Result<ResolvedPackage, PackageKind>
+where
+    I: Iterator<Item = &'a str>,
+{
+    let mut package_path = module_search_path.to_path_buf();
+
+    // `true` if inside a folder that is a namespace package (has no `__init__.py`).
+    // Namespace packages are special because they can be spread across multiple search paths.
+    // https://peps.python.org/pep-0420/
+    let mut in_namespace_package = false;
+
+    // `true` if resolving a sub-package. For example, `true` when resolving `bar` of `foo.bar`.
+    let mut in_sub_package = false;
+
+    // For `foo.bar.baz`, test that `foo` and `baz` both contain a `__init__.py`.
+    for folder in components {
+        package_path.push(folder);
+
+        let has_init_py = fs.is_file(&package_path.join("__init__.py"))
+            || fs.is_file(&package_path.join("__init__.pyi"));
+
+        if has_init_py {
+            in_namespace_package = false;
+        } else if fs.is_directory(&package_path) {
+            // A directory without an `__init__.py` is a namespace package, continue with the next folder.
+            in_namespace_package = true;
+        } else if in_namespace_package {
+            // Package not found but it is part of a namespace package.
+            return Err(PackageKind::Namespace);
+        } else if in_sub_package {
+            // A regular sub package wasn't found.
+            return Err(PackageKind::Regular);
+        } else {
+            // We couldn't find `foo` for `foo.bar.baz`, search the next search path.
+            return Err(PackageKind::Root);
+        }
+
+        in_sub_package = true;
+    }
+
+    let kind = if in_namespace_package {
+        PackageKind::Namespace
+    } else if in_sub_package {
+        PackageKind::Regular
+    } else {
+        PackageKind::Root
+    };
+
+    Ok(ResolvedPackage {
+        kind,
+        path: package_path,
+    })
+}
+
+#[derive(Debug)]
+struct ResolvedPackage {
+    path: FileSystemPathBuf,
+    kind: PackageKind,
+}
+
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+enum PackageKind {
+    /// A root package or module. E.g. `foo` in `foo.bar.baz` or just `foo`.
+    Root,
+
+    /// A regular sub-package where the parent contains an `__init__.py`.
+    ///
+    /// For example, `bar` in `foo.bar` when the `foo` directory contains an `__init__.py`.
+    Regular,
+
+    /// A sub-package in a namespace package. A namespace package is a package without an `__init__.py`.
+    ///
+    /// For example, `bar` in `foo.bar` if the `foo` directory contains no `__init__.py`.
+    Namespace,
+}
+
+impl PackageKind {
+    const fn is_regular_package(self) -> bool {
+        matches!(self, PackageKind::Regular)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use ruff_db::file_system::{FileSystemPath, FileSystemPathBuf};
+    use ruff_db::vfs::{system_path_to_file, VfsFile, VfsPath};
+
+    use crate::db::tests::TestDb;
+    use crate::module::{ModuleKind, ModuleName};
+
+    use super::{
+        path_to_module, resolve_module, set_module_resolution_settings, ModuleResolutionSettings,
+        TYPESHED_STDLIB_DIRECTORY,
+    };
+
+    struct TestCase {
+        db: TestDb,
+
+        src: FileSystemPathBuf,
+        custom_typeshed: FileSystemPathBuf,
+        site_packages: FileSystemPathBuf,
+    }
+
+    fn create_resolver() -> std::io::Result<TestCase> {
+        let mut db = TestDb::new();
+
+        let src = FileSystemPath::new("src").to_path_buf();
+        let site_packages = FileSystemPath::new("site_packages").to_path_buf();
+        let custom_typeshed = FileSystemPath::new("typeshed").to_path_buf();
+
+        let fs = db.memory_file_system();
+
+        fs.create_directory_all(&src)?;
+        fs.create_directory_all(&site_packages)?;
+        fs.create_directory_all(&custom_typeshed)?;
+
+        let settings = ModuleResolutionSettings {
+            extra_paths: vec![],
+            workspace_root: src.clone(),
+            site_packages: Some(site_packages.clone()),
+            custom_typeshed: Some(custom_typeshed.clone()),
+        };
+
+        set_module_resolution_settings(&mut db, settings);
+
+        Ok(TestCase {
+            db,
+            src,
+            custom_typeshed,
+            site_packages,
+        })
+    }
+
+    #[test]
+    fn first_party_module() -> anyhow::Result<()> {
+        let TestCase { db, src, .. } = create_resolver()?;
+
+        let foo_module_name = ModuleName::new_static("foo").unwrap();
+        let foo_path = src.join("foo.py");
+        db.memory_file_system()
+            .write_file(&foo_path, "print('Hello, world!')")?;
+
+        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
+
+        assert_eq!(
+            Some(&foo_module),
+            resolve_module(&db, foo_module_name.clone()).as_ref()
+        );
+
+        assert_eq!("foo", foo_module.name());
+        assert_eq!(&src, foo_module.search_path().path());
+        assert_eq!(ModuleKind::Module, foo_module.kind());
+        assert_eq!(&foo_path, foo_module.file().path(&db));
+
+        assert_eq!(
+            Some(foo_module),
+            path_to_module(&db, &VfsPath::FileSystem(foo_path))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn stdlib() -> anyhow::Result<()> {
+        let TestCase {
+            db,
+            custom_typeshed,
+            ..
+        } = create_resolver()?;
+
+        let stdlib_dir = custom_typeshed.join(TYPESHED_STDLIB_DIRECTORY);
+        let functools_path = stdlib_dir.join("functools.py");
+        db.memory_file_system()
+            .write_file(&functools_path, "def update_wrapper(): ...")?;
+
+        let functools_module_name = ModuleName::new_static("functools").unwrap();
+        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
+
+        assert_eq!(
+            Some(&functools_module),
+            resolve_module(&db, functools_module_name).as_ref()
+        );
+
+        assert_eq!(&stdlib_dir, functools_module.search_path().path());
+        assert_eq!(ModuleKind::Module, functools_module.kind());
+        assert_eq!(&functools_path.clone(), functools_module.file().path(&db));
+
+        assert_eq!(
+            Some(functools_module),
+            path_to_module(&db, &VfsPath::FileSystem(functools_path))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn first_party_precedence_over_stdlib() -> anyhow::Result<()> {
+        let TestCase {
+            db,
+            src,
+            custom_typeshed,
+            ..
+        } = create_resolver()?;
+
+        let stdlib_dir = custom_typeshed.join(TYPESHED_STDLIB_DIRECTORY);
+        let stdlib_functools_path = stdlib_dir.join("functools.py");
+        let first_party_functools_path = src.join("functools.py");
+
+        db.memory_file_system().write_files([
+            (&stdlib_functools_path, "def update_wrapper(): ..."),
+            (&first_party_functools_path, "def update_wrapper(): ..."),
+        ])?;
+
+        let functools_module_name = ModuleName::new_static("functools").unwrap();
+        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
+
+        assert_eq!(
+            Some(&functools_module),
+            resolve_module(&db, functools_module_name).as_ref()
+        );
+        assert_eq!(&src, functools_module.search_path().path());
+        assert_eq!(ModuleKind::Module, functools_module.kind());
+        assert_eq!(
+            &first_party_functools_path.clone(),
+            functools_module.file().path(&db)
+        );
+
+        assert_eq!(
+            Some(functools_module),
+            path_to_module(&db, &VfsPath::FileSystem(first_party_functools_path))
+        );
+
+        Ok(())
+    }
+
+    // TODO: Port typeshed test case. Porting isn't possible at the moment because the vendored zip
+    //   is part of the red knot crate
+    // #[test]
+    // fn typeshed_zip_created_at_build_time() -> anyhow::Result<()> {
+    //     // 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"));
+    //     assert!(!TYPESHED_ZIP_BYTES.is_empty());
+    //     let mut typeshed_zip_archive = ZipArchive::new(Cursor::new(TYPESHED_ZIP_BYTES))?;
+    //
+    //     let path_to_functools = Path::new("stdlib").join("functools.pyi");
+    //     let mut functools_module_stub = typeshed_zip_archive
+    //         .by_name(path_to_functools.to_str().unwrap())
+    //         .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)?;
+    //
+    //     assert!(functools_module_stub_source.contains("def update_wrapper("));
+    //     Ok(())
+    // }
+
+    #[test]
+    fn resolve_package() -> anyhow::Result<()> {
+        let TestCase { src, db, .. } = create_resolver()?;
+
+        let foo_dir = src.join("foo");
+        let foo_path = foo_dir.join("__init__.py");
+
+        db.memory_file_system()
+            .write_file(&foo_path, "print('Hello, world!')")?;
+
+        let foo_module = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
+
+        assert_eq!("foo", foo_module.name());
+        assert_eq!(&src, foo_module.search_path().path());
+        assert_eq!(&foo_path, foo_module.file().path(&db));
+
+        assert_eq!(
+            Some(&foo_module),
+            path_to_module(&db, &VfsPath::FileSystem(foo_path)).as_ref()
+        );
+
+        // Resolving by directory doesn't resolve to the init file.
+        assert_eq!(None, path_to_module(&db, &VfsPath::FileSystem(foo_dir)));
+
+        Ok(())
+    }
+
+    #[test]
+    fn package_priority_over_module() -> anyhow::Result<()> {
+        let TestCase { db, src, .. } = create_resolver()?;
+
+        let foo_dir = src.join("foo");
+        let foo_init = foo_dir.join("__init__.py");
+
+        db.memory_file_system()
+            .write_file(&foo_init, "print('Hello, world!')")?;
+
+        let foo_py = src.join("foo.py");
+        db.memory_file_system()
+            .write_file(&foo_py, "print('Hello, world!')")?;
+
+        let foo_module = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
+
+        assert_eq!(&src, foo_module.search_path().path());
+        assert_eq!(&foo_init, foo_module.file().path(&db));
+        assert_eq!(ModuleKind::Package, foo_module.kind());
+
+        assert_eq!(
+            Some(foo_module),
+            path_to_module(&db, &VfsPath::FileSystem(foo_init))
+        );
+        assert_eq!(None, path_to_module(&db, &VfsPath::FileSystem(foo_py)));
+
+        Ok(())
+    }
+
+    #[test]
+    fn typing_stub_over_module() -> anyhow::Result<()> {
+        let TestCase { db, src, .. } = create_resolver()?;
+
+        let foo_stub = src.join("foo.pyi");
+        let foo_py = src.join("foo.py");
+        db.memory_file_system()
+            .write_files([(&foo_stub, "x: int"), (&foo_py, "print('Hello, world!')")])?;
+
+        let foo = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
+
+        assert_eq!(&src, foo.search_path().path());
+        assert_eq!(&foo_stub, foo.file().path(&db));
+
+        assert_eq!(
+            Some(foo),
+            path_to_module(&db, &VfsPath::FileSystem(foo_stub))
+        );
+        assert_eq!(None, path_to_module(&db, &VfsPath::FileSystem(foo_py)));
+
+        Ok(())
+    }
+
+    #[test]
+    fn sub_packages() -> anyhow::Result<()> {
+        let TestCase { db, src, .. } = create_resolver()?;
+
+        let foo = src.join("foo");
+        let bar = foo.join("bar");
+        let baz = bar.join("baz.py");
+
+        db.memory_file_system().write_files([
+            (&foo.join("__init__.py"), ""),
+            (&bar.join("__init__.py"), ""),
+            (&baz, "print('Hello, world!')"),
+        ])?;
+
+        let baz_module =
+            resolve_module(&db, ModuleName::new_static("foo.bar.baz").unwrap()).unwrap();
+
+        assert_eq!(&src, baz_module.search_path().path());
+        assert_eq!(&baz, baz_module.file().path(&db));
+
+        assert_eq!(
+            Some(baz_module),
+            path_to_module(&db, &VfsPath::FileSystem(baz))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn namespace_package() -> anyhow::Result<()> {
+        let TestCase {
+            db,
+            src,
+            site_packages,
+            ..
+        } = create_resolver()?;
+
+        // From [PEP420](https://peps.python.org/pep-0420/#nested-namespace-packages).
+        // But uses `src` for `project1` and `site_packages2` for `project2`.
+        // ```
+        // src
+        //   parent
+        //     child
+        //       one.py
+        // site_packages
+        //   parent
+        //     child
+        //       two.py
+        // ```
+
+        let parent1 = src.join("parent");
+        let child1 = parent1.join("child");
+        let one = child1.join("one.py");
+
+        let parent2 = site_packages.join("parent");
+        let child2 = parent2.join("child");
+        let two = child2.join("two.py");
+
+        db.memory_file_system().write_files([
+            (&one, "print('Hello, world!')"),
+            (&two, "print('Hello, world!')"),
+        ])?;
+
+        let one_module =
+            resolve_module(&db, ModuleName::new_static("parent.child.one").unwrap()).unwrap();
+
+        assert_eq!(
+            Some(one_module),
+            path_to_module(&db, &VfsPath::FileSystem(one))
+        );
+
+        let two_module =
+            resolve_module(&db, ModuleName::new_static("parent.child.two").unwrap()).unwrap();
+        assert_eq!(
+            Some(two_module),
+            path_to_module(&db, &VfsPath::FileSystem(two))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn regular_package_in_namespace_package() -> anyhow::Result<()> {
+        let TestCase {
+            db,
+            src,
+            site_packages,
+            ..
+        } = create_resolver()?;
+
+        // Adopted test case from the [PEP420 examples](https://peps.python.org/pep-0420/#nested-namespace-packages).
+        // The `src/parent/child` package is a regular package. Therefore, `site_packages/parent/child/two.py` should not be resolved.
+        // ```
+        // src
+        //   parent
+        //     child
+        //       one.py
+        // site_packages
+        //   parent
+        //     child
+        //       two.py
+        // ```
+
+        let parent1 = src.join("parent");
+        let child1 = parent1.join("child");
+        let one = child1.join("one.py");
+
+        let parent2 = site_packages.join("parent");
+        let child2 = parent2.join("child");
+        let two = child2.join("two.py");
+
+        db.memory_file_system().write_files([
+            (&child1.join("__init__.py"), "print('Hello, world!')"),
+            (&one, "print('Hello, world!')"),
+            (&two, "print('Hello, world!')"),
+        ])?;
+
+        let one_module =
+            resolve_module(&db, ModuleName::new_static("parent.child.one").unwrap()).unwrap();
+
+        assert_eq!(
+            Some(one_module),
+            path_to_module(&db, &VfsPath::FileSystem(one))
+        );
+
+        assert_eq!(
+            None,
+            resolve_module(&db, ModuleName::new_static("parent.child.two").unwrap())
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn module_search_path_priority() -> anyhow::Result<()> {
+        let TestCase {
+            db,
+            src,
+            site_packages,
+            ..
+        } = create_resolver()?;
+
+        let foo_src = src.join("foo.py");
+        let foo_site_packages = site_packages.join("foo.py");
+
+        db.memory_file_system()
+            .write_files([(&foo_src, ""), (&foo_site_packages, "")])?;
+
+        let foo_module = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
+
+        assert_eq!(&src, foo_module.search_path().path());
+        assert_eq!(&foo_src, foo_module.file().path(&db));
+
+        assert_eq!(
+            Some(foo_module),
+            path_to_module(&db, &VfsPath::FileSystem(foo_src))
+        );
+        assert_eq!(
+            None,
+            path_to_module(&db, &VfsPath::FileSystem(foo_site_packages))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(target_family = "unix")]
+    fn symlink() -> anyhow::Result<()> {
+        let TestCase {
+            mut db,
+            src,
+            site_packages,
+            custom_typeshed,
+        } = create_resolver()?;
+
+        db.with_os_file_system();
+
+        let temp_dir = tempfile::tempdir()?;
+        let root = FileSystemPath::from_std_path(temp_dir.path()).unwrap();
+
+        let src = root.join(src);
+        let site_packages = root.join(site_packages);
+        let custom_typeshed = root.join(custom_typeshed);
+
+        let foo = src.join("foo.py");
+        let bar = src.join("bar.py");
+
+        std::fs::create_dir_all(src.as_std_path())?;
+        std::fs::create_dir_all(site_packages.as_std_path())?;
+        std::fs::create_dir_all(custom_typeshed.as_std_path())?;
+
+        std::fs::write(foo.as_std_path(), "")?;
+        std::os::unix::fs::symlink(foo.as_std_path(), bar.as_std_path())?;
+
+        let settings = ModuleResolutionSettings {
+            extra_paths: vec![],
+            workspace_root: src.clone(),
+            site_packages: Some(site_packages),
+            custom_typeshed: Some(custom_typeshed),
+        };
+
+        set_module_resolution_settings(&mut db, settings);
+
+        let foo_module = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
+        let bar_module = resolve_module(&db, ModuleName::new_static("bar").unwrap()).unwrap();
+
+        assert_ne!(foo_module, bar_module);
+
+        assert_eq!(&src, foo_module.search_path().path());
+        assert_eq!(&foo, foo_module.file().path(&db));
+
+        // `foo` and `bar` shouldn't resolve to the same file
+
+        assert_eq!(&src, bar_module.search_path().path());
+        assert_eq!(&bar, bar_module.file().path(&db));
+        assert_eq!(&foo, foo_module.file().path(&db));
+
+        assert_ne!(&foo_module, &bar_module);
+
+        assert_eq!(
+            Some(foo_module),
+            path_to_module(&db, &VfsPath::FileSystem(foo))
+        );
+        assert_eq!(
+            Some(bar_module),
+            path_to_module(&db, &VfsPath::FileSystem(bar))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn deleting_an_unrealted_file_doesnt_change_module_resolution() -> anyhow::Result<()> {
+        let TestCase { mut db, src, .. } = create_resolver()?;
+
+        let foo_path = src.join("foo.py");
+        let bar_path = src.join("bar.py");
+
+        db.memory_file_system()
+            .write_files([(&foo_path, "x = 1"), (&bar_path, "y = 2")])?;
+
+        let foo_module_name = ModuleName::new_static("foo").unwrap();
+        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
+
+        let bar = system_path_to_file(&db, &bar_path).expect("bar.py to exist");
+
+        db.clear_salsa_events();
+
+        // Delete `bar.py`
+        db.memory_file_system().remove_file(&bar_path)?;
+        bar.touch(&mut db);
+
+        // Re-query the foo module. The foo module should still be cached because `bar.py` isn't relevant
+        // for resolving `foo`.
+
+        let foo_module2 = resolve_module(&db, foo_module_name);
+
+        assert!(!db
+            .take_salsa_events()
+            .iter()
+            .any(|event| { matches!(event.kind, salsa::EventKind::WillExecute { .. }) }));
+
+        assert_eq!(Some(foo_module), foo_module2);
+
+        Ok(())
+    }
+
+    #[test]
+    fn adding_a_file_on_which_the_module_resolution_depends_on_invalidates_the_query(
+    ) -> anyhow::Result<()> {
+        let TestCase { mut db, src, .. } = create_resolver()?;
+        let foo_path = src.join("foo.py");
+
+        let foo_module_name = ModuleName::new_static("foo").unwrap();
+        assert_eq!(resolve_module(&db, foo_module_name.clone()), None);
+
+        // Now write the foo file
+        db.memory_file_system().write_file(&foo_path, "x = 1")?;
+        VfsFile::touch_path(&mut db, &VfsPath::FileSystem(foo_path.clone()));
+        let foo_file = system_path_to_file(&db, &foo_path).expect("foo.py to exist");
+
+        let foo_module = resolve_module(&db, foo_module_name).expect("Foo module to resolve");
+        assert_eq!(foo_file, foo_module.file());
+
+        Ok(())
+    }
+
+    #[test]
+    fn removing_a_file_that_the_module_resolution_depends_on_invalidates_the_query(
+    ) -> anyhow::Result<()> {
+        let TestCase { mut db, src, .. } = create_resolver()?;
+        let foo_path = src.join("foo.py");
+        let foo_init_path = src.join("foo/__init__.py");
+
+        db.memory_file_system()
+            .write_files([(&foo_path, "x = 1"), (&foo_init_path, "x = 2")])?;
+
+        let foo_module_name = ModuleName::new_static("foo").unwrap();
+        let foo_module = resolve_module(&db, foo_module_name.clone()).expect("foo module to exist");
+
+        assert_eq!(&foo_init_path, foo_module.file().path(&db));
+
+        // Delete `foo/__init__.py` and the `foo` folder. `foo` should now resolve to `foo.py`
+        db.memory_file_system().remove_file(&foo_init_path)?;
+        db.memory_file_system()
+            .remove_directory(foo_init_path.parent().unwrap())?;
+        VfsFile::touch_path(&mut db, &VfsPath::FileSystem(foo_init_path.clone()));
+
+        let foo_module = resolve_module(&db, foo_module_name).expect("Foo module to resolve");
+        assert_eq!(&foo_path, foo_module.file().path(&db));
+
+        Ok(())
+    }
+}

crates/red_knot_module_resolver/src/typeshed.rs

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

crates/red_knot_module_resolver/src/typeshed/versions.rs

@@ -0,0 +1,590 @@
+use std::collections::BTreeMap;
+use std::fmt;
+use std::num::{NonZeroU16, NonZeroUsize};
+use std::ops::{RangeFrom, RangeInclusive};
+use std::str::FromStr;
+
+use rustc_hash::FxHashMap;
+
+use crate::module::ModuleName;
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct TypeshedVersionsParseError {
+    line_number: NonZeroU16,
+    reason: TypeshedVersionsParseErrorKind,
+}
+
+impl fmt::Display for TypeshedVersionsParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let TypeshedVersionsParseError {
+            line_number,
+            reason,
+        } = self;
+        write!(
+            f,
+            "Error while parsing line {line_number} of typeshed's VERSIONS file: {reason}"
+        )
+    }
+}
+
+impl std::error::Error for TypeshedVersionsParseError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        if let TypeshedVersionsParseErrorKind::IntegerParsingFailure { err, .. } = &self.reason {
+            Some(err)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum TypeshedVersionsParseErrorKind {
+    TooManyLines(NonZeroUsize),
+    UnexpectedNumberOfColons,
+    InvalidModuleName(String),
+    UnexpectedNumberOfHyphens,
+    UnexpectedNumberOfPeriods(String),
+    IntegerParsingFailure {
+        version: String,
+        err: std::num::ParseIntError,
+    },
+}
+
+impl fmt::Display for TypeshedVersionsParseErrorKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::TooManyLines(num_lines) => write!(
+                f,
+                "File has too many lines ({num_lines}); maximum allowed is {}",
+                NonZeroU16::MAX
+            ),
+            Self::UnexpectedNumberOfColons => {
+                f.write_str("Expected every non-comment line to have exactly one colon")
+            }
+            Self::InvalidModuleName(name) => write!(
+                f,
+                "Expected all components of '{name}' to be valid Python identifiers"
+            ),
+            Self::UnexpectedNumberOfHyphens => {
+                f.write_str("Expected every non-comment line to have exactly one '-' character")
+            }
+            Self::UnexpectedNumberOfPeriods(format) => write!(
+                f,
+                "Expected all versions to be in the form {{MAJOR}}.{{MINOR}}; got '{format}'"
+            ),
+            Self::IntegerParsingFailure { version, err } => write!(
+                f,
+                "Failed to convert '{version}' to a pair of integers due to {err}",
+            ),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct TypeshedVersions(FxHashMap<ModuleName, PyVersionRange>);
+
+impl TypeshedVersions {
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    pub fn contains_module(&self, module_name: &ModuleName) -> bool {
+        self.0.contains_key(module_name)
+    }
+
+    pub fn module_exists_on_version(
+        &self,
+        module: ModuleName,
+        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 = module_to_try.parent();
+        }
+        false
+    }
+}
+
+impl FromStr for TypeshedVersions {
+    type Err = TypeshedVersionsParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut map = FxHashMap::default();
+
+        for (line_index, line) in s.lines().enumerate() {
+            // humans expect line numbers to be 1-indexed
+            let line_number = NonZeroUsize::new(line_index.saturating_add(1)).unwrap();
+
+            let Ok(line_number) = NonZeroU16::try_from(line_number) else {
+                return Err(TypeshedVersionsParseError {
+                    line_number: NonZeroU16::MAX,
+                    reason: TypeshedVersionsParseErrorKind::TooManyLines(line_number),
+                });
+            };
+
+            let Some(content) = line.split('#').map(str::trim).next() else {
+                continue;
+            };
+            if content.is_empty() {
+                continue;
+            }
+
+            let mut parts = content.split(':').map(str::trim);
+            let (Some(module_name), Some(rest), None) = (parts.next(), parts.next(), parts.next())
+            else {
+                return Err(TypeshedVersionsParseError {
+                    line_number,
+                    reason: TypeshedVersionsParseErrorKind::UnexpectedNumberOfColons,
+                });
+            };
+
+            let Some(module_name) = ModuleName::new(module_name) else {
+                return Err(TypeshedVersionsParseError {
+                    line_number,
+                    reason: TypeshedVersionsParseErrorKind::InvalidModuleName(
+                        module_name.to_string(),
+                    ),
+                });
+            };
+
+            match PyVersionRange::from_str(rest) {
+                Ok(version) => map.insert(module_name, version),
+                Err(reason) => {
+                    return Err(TypeshedVersionsParseError {
+                        line_number,
+                        reason,
+                    })
+                }
+            };
+        }
+
+        Ok(Self(map))
+    }
+}
+
+impl fmt::Display for TypeshedVersions {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let sorted_items: BTreeMap<&ModuleName, &PyVersionRange> = self.0.iter().collect();
+        for (module_name, range) in sorted_items {
+            writeln!(f, "{module_name}: {range}")?;
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+enum PyVersionRange {
+    AvailableFrom(RangeFrom<PyVersion>),
+    AvailableWithin(RangeInclusive<PyVersion>),
+}
+
+impl PyVersionRange {
+    fn contains(&self, version: PyVersion) -> bool {
+        match self {
+            Self::AvailableFrom(inner) => inner.contains(&version),
+            Self::AvailableWithin(inner) => inner.contains(&version),
+        }
+    }
+}
+
+impl FromStr for PyVersionRange {
+    type Err = TypeshedVersionsParseErrorKind;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut parts = s.split('-').map(str::trim);
+        match (parts.next(), parts.next(), parts.next()) {
+            (Some(lower), Some(""), None) => Ok(Self::AvailableFrom((lower.parse()?)..)),
+            (Some(lower), Some(upper), None) => {
+                Ok(Self::AvailableWithin((lower.parse()?)..=(upper.parse()?)))
+            }
+            _ => Err(TypeshedVersionsParseErrorKind::UnexpectedNumberOfHyphens),
+        }
+    }
+}
+
+impl fmt::Display for PyVersionRange {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::AvailableFrom(range_from) => write!(f, "{}-", range_from.start),
+            Self::AvailableWithin(range_inclusive) => {
+                write!(f, "{}-{}", range_inclusive.start(), range_inclusive.end())
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct PyVersion {
+    major: u8,
+    minor: u8,
+}
+
+impl FromStr for PyVersion {
+    type Err = TypeshedVersionsParseErrorKind;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut parts = s.split('.').map(str::trim);
+        let (Some(major), Some(minor), None) = (parts.next(), parts.next(), parts.next()) else {
+            return Err(TypeshedVersionsParseErrorKind::UnexpectedNumberOfPeriods(
+                s.to_string(),
+            ));
+        };
+        let major = match u8::from_str(major) {
+            Ok(major) => major,
+            Err(err) => {
+                return Err(TypeshedVersionsParseErrorKind::IntegerParsingFailure {
+                    version: s.to_string(),
+                    err,
+                })
+            }
+        };
+        let minor = match u8::from_str(minor) {
+            Ok(minor) => minor,
+            Err(err) => {
+                return Err(TypeshedVersionsParseErrorKind::IntegerParsingFailure {
+                    version: s.to_string(),
+                    err,
+                })
+            }
+        };
+        Ok(Self { major, minor })
+    }
+}
+
+impl fmt::Display for PyVersion {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let PyVersion { major, minor } = self;
+        write!(f, "{major}.{minor}")
+    }
+}
+
+// TODO: unify with the PythonVersion enum in the linter/formatter crates?
+#[derive(Copy, Clone, Hash, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
+pub enum SupportedPyVersion {
+    Py37,
+    #[default]
+    Py38,
+    Py39,
+    Py310,
+    Py311,
+    Py312,
+    Py313,
+}
+
+impl From<SupportedPyVersion> for PyVersion {
+    fn from(value: SupportedPyVersion) -> Self {
+        match value {
+            SupportedPyVersion::Py37 => PyVersion { major: 3, minor: 7 },
+            SupportedPyVersion::Py38 => PyVersion { major: 3, minor: 8 },
+            SupportedPyVersion::Py39 => PyVersion { major: 3, minor: 9 },
+            SupportedPyVersion::Py310 => PyVersion {
+                major: 3,
+                minor: 10,
+            },
+            SupportedPyVersion::Py311 => PyVersion {
+                major: 3,
+                minor: 11,
+            },
+            SupportedPyVersion::Py312 => PyVersion {
+                major: 3,
+                minor: 12,
+            },
+            SupportedPyVersion::Py313 => PyVersion {
+                major: 3,
+                minor: 13,
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::num::{IntErrorKind, NonZeroU16};
+    use std::path::Path;
+
+    use super::*;
+
+    use insta::assert_snapshot;
+
+    const TYPESHED_STDLIB_DIR: &str = "stdlib";
+
+    #[allow(unsafe_code)]
+    const ONE: NonZeroU16 = unsafe { NonZeroU16::new_unchecked(1) };
+
+    #[test]
+    fn can_parse_vendored_versions_file() {
+        let versions_data = include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/vendor/typeshed/stdlib/VERSIONS"
+        ));
+
+        let versions = TypeshedVersions::from_str(versions_data).unwrap();
+        assert!(versions.len() > 100);
+        assert!(versions.len() < 1000);
+
+        let asyncio = ModuleName::new_static("asyncio").unwrap();
+        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.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));
+    }
+
+    #[test]
+    fn typeshed_versions_consistent_with_vendored_stubs() {
+        const VERSIONS_DATA: &str = include_str!("../../vendor/typeshed/stdlib/VERSIONS");
+        let vendored_typeshed_dir = Path::new("vendor/typeshed").canonicalize().unwrap();
+        let vendored_typeshed_versions = TypeshedVersions::from_str(VERSIONS_DATA).unwrap();
+
+        let mut empty_iterator = true;
+
+        let stdlib_stubs_path = vendored_typeshed_dir.join(TYPESHED_STDLIB_DIR);
+
+        for entry in std::fs::read_dir(&stdlib_stubs_path).unwrap() {
+            empty_iterator = false;
+            let entry = entry.unwrap();
+            let absolute_path = entry.path();
+
+            let relative_path = absolute_path
+                .strip_prefix(&stdlib_stubs_path)
+                .unwrap_or_else(|_| panic!("Expected path to be a child of {stdlib_stubs_path:?} but found {absolute_path:?}"));
+
+            let relative_path_str = relative_path.as_os_str().to_str().unwrap_or_else(|| {
+                panic!("Expected all typeshed paths to be valid UTF-8; got {relative_path:?}")
+            });
+            if relative_path_str == "VERSIONS" {
+                continue;
+            }
+
+            let top_level_module = if let Some(extension) = relative_path.extension() {
+                // It was a file; strip off the file extension to get the module name:
+                let extension = extension
+                    .to_str()
+                    .unwrap_or_else(||panic!("Expected all file extensions to be UTF-8; was not true for {relative_path:?}"));
+
+                relative_path_str
+                    .strip_suffix(extension)
+                    .and_then(|string| string.strip_suffix('.')).unwrap_or_else(|| {
+                        panic!("Expected path {relative_path_str:?} to end with computed extension {extension:?}")
+                })
+            } else {
+                // It was a directory; no need to do anything to get the module name
+                relative_path_str
+            };
+
+            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!(
+            !empty_iterator,
+            "Expected there to be at least one file or directory in the vendored typeshed stubs"
+        );
+    }
+
+    #[test]
+    fn can_parse_mock_versions_file() {
+        const VERSIONS: &str = "\
+# a comment
+    # some more comment
+# yet more comment
+
+
+# and some more comment
+
+bar: 2.7-3.10
+
+# more comment
+bar.baz: 3.1-3.9
+foo: 3.8-   # trailing comment
+";
+        let parsed_versions = TypeshedVersions::from_str(VERSIONS).unwrap();
+        assert_eq!(parsed_versions.len(), 3);
+        assert_snapshot!(parsed_versions.to_string(), @r###"
+        bar: 2.7-3.10
+        bar.baz: 3.1-3.9
+        foo: 3.8-
+        "###
+        );
+
+        let foo = ModuleName::new_static("foo").unwrap();
+        let bar = ModuleName::new_static("bar").unwrap();
+        let bar_baz = ModuleName::new_static("bar.baz").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));
+    }
+
+    #[test]
+    fn invalid_huge_versions_file() {
+        let offset = 100;
+        let too_many = u16::MAX as usize + offset;
+
+        let mut massive_versions_file = String::new();
+        for i in 0..too_many {
+            massive_versions_file.push_str(&format!("x{i}: 3.8-\n"));
+        }
+
+        assert_eq!(
+            TypeshedVersions::from_str(&massive_versions_file),
+            Err(TypeshedVersionsParseError {
+                line_number: NonZeroU16::MAX,
+                reason: TypeshedVersionsParseErrorKind::TooManyLines(
+                    NonZeroUsize::new(too_many + 1 - offset).unwrap()
+                )
+            })
+        );
+    }
+
+    #[test]
+    fn invalid_typeshed_versions_bad_colon_number() {
+        assert_eq!(
+            TypeshedVersions::from_str("foo 3.7"),
+            Err(TypeshedVersionsParseError {
+                line_number: ONE,
+                reason: TypeshedVersionsParseErrorKind::UnexpectedNumberOfColons
+            })
+        );
+        assert_eq!(
+            TypeshedVersions::from_str("foo:: 3.7"),
+            Err(TypeshedVersionsParseError {
+                line_number: ONE,
+                reason: TypeshedVersionsParseErrorKind::UnexpectedNumberOfColons
+            })
+        );
+    }
+
+    #[test]
+    fn invalid_typeshed_versions_non_identifier_modules() {
+        assert_eq!(
+            TypeshedVersions::from_str("not!an!identifier!: 3.7"),
+            Err(TypeshedVersionsParseError {
+                line_number: ONE,
+                reason: TypeshedVersionsParseErrorKind::InvalidModuleName(
+                    "not!an!identifier!".to_string()
+                )
+            })
+        );
+        assert_eq!(
+            TypeshedVersions::from_str("(also_not).(an_identifier): 3.7"),
+            Err(TypeshedVersionsParseError {
+                line_number: ONE,
+                reason: TypeshedVersionsParseErrorKind::InvalidModuleName(
+                    "(also_not).(an_identifier)".to_string()
+                )
+            })
+        );
+    }
+
+    #[test]
+    fn invalid_typeshed_versions_bad_hyphen_number() {
+        assert_eq!(
+            TypeshedVersions::from_str("foo: 3.8"),
+            Err(TypeshedVersionsParseError {
+                line_number: ONE,
+                reason: TypeshedVersionsParseErrorKind::UnexpectedNumberOfHyphens
+            })
+        );
+        assert_eq!(
+            TypeshedVersions::from_str("foo: 3.8--"),
+            Err(TypeshedVersionsParseError {
+                line_number: ONE,
+                reason: TypeshedVersionsParseErrorKind::UnexpectedNumberOfHyphens
+            })
+        );
+        assert_eq!(
+            TypeshedVersions::from_str("foo: 3.8--3.9"),
+            Err(TypeshedVersionsParseError {
+                line_number: ONE,
+                reason: TypeshedVersionsParseErrorKind::UnexpectedNumberOfHyphens
+            })
+        );
+    }
+
+    #[test]
+    fn invalid_typeshed_versions_bad_period_number() {
+        assert_eq!(
+            TypeshedVersions::from_str("foo: 38-"),
+            Err(TypeshedVersionsParseError {
+                line_number: ONE,
+                reason: TypeshedVersionsParseErrorKind::UnexpectedNumberOfPeriods("38".to_string())
+            })
+        );
+        assert_eq!(
+            TypeshedVersions::from_str("foo: 3..8-"),
+            Err(TypeshedVersionsParseError {
+                line_number: ONE,
+                reason: TypeshedVersionsParseErrorKind::UnexpectedNumberOfPeriods(
+                    "3..8".to_string()
+                )
+            })
+        );
+        assert_eq!(
+            TypeshedVersions::from_str("foo: 3.8-3..11"),
+            Err(TypeshedVersionsParseError {
+                line_number: ONE,
+                reason: TypeshedVersionsParseErrorKind::UnexpectedNumberOfPeriods(
+                    "3..11".to_string()
+                )
+            })
+        );
+    }
+
+    #[test]
+    fn invalid_typeshed_versions_non_digits() {
+        let err = TypeshedVersions::from_str("foo: 1.two-").unwrap_err();
+        assert_eq!(err.line_number, ONE);
+        let TypeshedVersionsParseErrorKind::IntegerParsingFailure { version, err } = err.reason
+        else {
+            panic!()
+        };
+        assert_eq!(version, "1.two".to_string());
+        assert_eq!(*err.kind(), IntErrorKind::InvalidDigit);
+
+        let err = TypeshedVersions::from_str("foo: 3.8-four.9").unwrap_err();
+        assert_eq!(err.line_number, ONE);
+        let TypeshedVersionsParseErrorKind::IntegerParsingFailure { version, err } = err.reason
+        else {
+            panic!()
+        };
+        assert_eq!(version, "four.9".to_string());
+        assert_eq!(*err.kind(), IntErrorKind::InvalidDigit);
+    }
+}

crates/red_knot_module_resolver/vendor/typeshed/source_commit.txt

@@ -0,0 +1 @@
+dcab6e88883c629ede9637fb011958f8b4918f52

crates/red_knot_module_resolver/vendor/typeshed/stdlib/VERSIONS

@@ -34,6 +34,7 @@ _dummy_thread: 3.0-3.8
 _dummy_threading: 3.0-3.8
 _heapq: 3.0-
 _imp: 3.0-
+_interpchannels: 3.13-
 _json: 3.0-
 _locale: 3.0-
 _lsprof: 3.0-
@@ -65,9 +66,9 @@ array: 3.0-
 ast: 3.0-
 asynchat: 3.0-3.11
 asyncio: 3.4-
-asyncio.mixins: 3.10-
 asyncio.exceptions: 3.8-
 asyncio.format_helpers: 3.7-
+asyncio.mixins: 3.10-
 asyncio.runners: 3.7-
 asyncio.staggered: 3.8-
 asyncio.taskgroups: 3.11-
@@ -166,7 +167,7 @@ ipaddress: 3.3-
 itertools: 3.0-
 json: 3.0-
 keyword: 3.0-
-lib2to3: 3.0-
+lib2to3: 3.0-3.12
 linecache: 3.0-
 locale: 3.0-
 logging: 3.0-
@@ -270,6 +271,7 @@ threading: 3.0-
 time: 3.0-
 timeit: 3.0-
 tkinter: 3.0-
+tkinter.tix: 3.0-3.12
 token: 3.0-
 tokenize: 3.0-
 tomllib: 3.11-

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

@@ -201,7 +201,7 @@ class Array(_CData, Generic[_CT]):
     # Sized and _CData prevents using _CDataMeta.
     def __len__(self) -> int: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def addressof(obj: _CData) -> int: ...
 def alignment(obj_or_type: _CData | type[_CData]) -> int: ...

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

@@ -63,8 +63,7 @@ A_COLOR: int
 A_DIM: int
 A_HORIZONTAL: int
 A_INVIS: int
-if sys.platform != "darwin":
-    A_ITALIC: int
+A_ITALIC: int
 A_LEFT: int
 A_LOW: int
 A_NORMAL: 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/_json.pyi

@@ -45,5 +45,5 @@ class make_scanner:
     def __init__(self, context: make_scanner) -> None: ...
     def __call__(self, string: str, index: int) -> tuple[Any, int]: ...
 
-def encode_basestring_ascii(s: str) -> str: ...
+def encode_basestring_ascii(s: str, /) -> str: ...
 def scanstring(string: str, end: int, strict: bool = ...) -> tuple[str, int]: ...