Expose unfixable as an LSP setting

## Summary

Make it a violation of `C409` to call `tuple` with a list or set
comprehension, and
implement the (unsafe) fix of calling the `tuple` with the underlying
generator instead.

Closes #12648.

## Test Plan

Test fixture updated, cargo test, docs checked for updated description.

.github/CODEOWNERS

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

.github/workflows/build-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 }}
@@ -171,8 +183,8 @@ jobs:
         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:
@@ -181,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:
@@ -202,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 }}
@@ -219,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:
@@ -261,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 }}
@@ -282,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
@@ -298,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:
@@ -320,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 }}
@@ -343,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:
@@ -376,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 }}
@@ -400,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@v6
-        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

@@ -616,10 +616,10 @@ jobs:
       - uses: Swatinem/rust-cache@v2
 
       - name: "Build benchmarks"
-        run: cargo codspeed build --features codspeed -p ruff_benchmark
+        run: cargo codspeed build -p ruff_benchmark
 
       - name: "Run benchmarks"
-        uses: CodSpeedHQ/action@v2
+        uses: CodSpeedHQ/action@v3
         with:
           run: cargo codspeed run
           token: ${{ secrets.CODSPEED_TOKEN }}

.github/workflows/docs.yaml

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

.github/workflows/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

@@ -23,6 +23,7 @@ jobs:
           name: pr-number
           run_id: ${{ github.event.workflow_run.id ||  github.event.inputs.workflow_run_id }}
           if_no_artifact_found: ignore
+          allow_forks: true
 
       - name: Parse pull request number
         id: pr-number
@@ -43,6 +44,7 @@ jobs:
           path: pr/ecosystem
           workflow_conclusion: completed
           if_no_artifact_found: ignore
+          allow_forks: true
 
       - name: Generate comment content
         id: generate-comment

.github/workflows/publish-docs.yml

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

.github/workflows/publish-playground.yml

@@ -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.6.1
+        uses: cloudflare/wrangler-action@v3.7.0
         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/publish-wasm.yml

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

.github/workflows/release.yml

@@ -0,0 +1,298 @@
+# 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"
+
+  custom-publish-wasm:
+    needs:
+      - plan
+      - host
+    if: ${{ !fromJson(needs.plan.outputs.val).announcement_is_prerelease || fromJson(needs.plan.outputs.val).publish_prereleases }}
+    uses: ./.github/workflows/publish-wasm.yml
+    with:
+      plan: ${{ needs.plan.outputs.val }}
+    secrets: inherit
+    # publish jobs get escalated permissions
+    permissions:
+      "contents": "read"
+      "id-token": "write"
+      "packages": "write"
+
+  # Create a GitHub Release while uploading all files to it
+  announce:
+    needs:
+      - plan
+      - host
+      - custom-publish-pypi
+      - custom-publish-wasm
+    # use "always() && ..." to allow us to wait for all publish jobs while
+    # still allowing individual publish jobs to skip themselves (for prereleases).
+    # "host" however must run to completion, no skipping allowed!
+    if: ${{ always() && needs.host.result == 'success' && (needs.custom-publish-pypi.result == 'skipped' || needs.custom-publish-pypi.result == 'success') && (needs.custom-publish-wasm.result == 'skipped' || needs.custom-publish-wasm.result == 'success') }}
+    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

.pre-commit-config.yaml

@@ -9,7 +9,8 @@ exclude: |
     crates/ruff_python_formatter/resources/.*|
     crates/ruff_python_formatter/tests/snapshots/.*|
     crates/ruff_python_resolver/resources/.*|
-    crates/ruff_python_resolver/tests/snapshots/.*
+    crates/ruff_python_resolver/tests/snapshots/.*|
+    crates/red_knot_workspace/resources/.*
   )$
 
 repos:
@@ -42,7 +43,7 @@ repos:
           )$
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.22.9
+    rev: v1.23.6
     hooks:
       - id: typos
 
@@ -56,18 +57,13 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.10
+    rev: v0.5.6
     hooks:
       - id: ruff-format
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
         types_or: [python, pyi]
         require_serial: true
-        exclude: |
-          (?x)^(
-            crates/ruff_linter/resources/.*|
-            crates/ruff_python_formatter/resources/.*
-          )$
 
   # Prettier
   - repo: https://github.com/pre-commit/mirrors-prettier

.prettierignore

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

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,368 @@
 # Changelog
 
+## 0.5.6
+
+Ruff 0.5.6 automatically enables linting and formatting of notebooks in *preview mode*.
+You can opt-out of this behavior by adding `*.ipynb` to the `extend-exclude` setting.
+
+```toml
+[tool.ruff]
+extend-exclude = ["*.ipynb"]
+```
+
+### Preview features
+
+- Enable notebooks by default in preview mode ([#12621](https://github.com/astral-sh/ruff/pull/12621))
+- \[`flake8-builtins`\] Implement import, lambda, and module shadowing ([#12546](https://github.com/astral-sh/ruff/pull/12546))
+- \[`pydoclint`\] Add `docstring-missing-returns` (`DOC201`) and `docstring-extraneous-returns` (`DOC202`) ([#12485](https://github.com/astral-sh/ruff/pull/12485))
+
+### Rule changes
+
+- \[`flake8-return`\] Exempt cached properties and other property-like decorators from explicit return rule (`RET501`) ([#12563](https://github.com/astral-sh/ruff/pull/12563))
+
+### Server
+
+- Make server panic hook more error resilient ([#12610](https://github.com/astral-sh/ruff/pull/12610))
+- Use `$/logTrace` for server trace logs in Zed and VS Code ([#12564](https://github.com/astral-sh/ruff/pull/12564))
+- Keep track of deleted cells for reorder change request ([#12575](https://github.com/astral-sh/ruff/pull/12575))
+
+### Configuration
+
+- \[`flake8-implicit-str-concat`\] Always allow explicit multi-line concatenations when implicit concatenations are banned ([#12532](https://github.com/astral-sh/ruff/pull/12532))
+
+### Bug fixes
+
+- \[`flake8-async`\] Avoid flagging `asyncio.timeout`s as unused when the context manager includes `asyncio.TaskGroup` ([#12605](https://github.com/astral-sh/ruff/pull/12605))
+- \[`flake8-slots`\] Avoid recommending `__slots__` for classes that inherit from more than `namedtuple` ([#12531](https://github.com/astral-sh/ruff/pull/12531))
+- \[`isort`\] Avoid marking required imports as unused ([#12537](https://github.com/astral-sh/ruff/pull/12537))
+- \[`isort`\] Preserve trailing inline comments on import-from statements ([#12498](https://github.com/astral-sh/ruff/pull/12498))
+- \[`pycodestyle`\] Add newlines before comments (`E305`) ([#12606](https://github.com/astral-sh/ruff/pull/12606))
+- \[`pycodestyle`\] Don't attach comments with mismatched indents ([#12604](https://github.com/astral-sh/ruff/pull/12604))
+- \[`pyflakes`\] Fix preview-mode bugs in `F401` when attempting to autofix unused first-party submodule imports in an `__init__.py` file ([#12569](https://github.com/astral-sh/ruff/pull/12569))
+- \[`pylint`\] Respect start index in `unnecessary-list-index-lookup` ([#12603](https://github.com/astral-sh/ruff/pull/12603))
+- \[`pyupgrade`\] Avoid recommending no-argument super in `slots=True` dataclasses ([#12530](https://github.com/astral-sh/ruff/pull/12530))
+- \[`pyupgrade`\] Use colon rather than dot formatting for integer-only types ([#12534](https://github.com/astral-sh/ruff/pull/12534))
+- Fix NFKC normalization bug when removing unused imports ([#12571](https://github.com/astral-sh/ruff/pull/12571))
+
+### Other changes
+
+- Consider more stdlib decorators to be property-like ([#12583](https://github.com/astral-sh/ruff/pull/12583))
+- Improve handling of metaclasses in various linter rules ([#12579](https://github.com/astral-sh/ruff/pull/12579))
+- Improve consistency between linter rules in determining whether a function is property ([#12581](https://github.com/astral-sh/ruff/pull/12581))
+
+## 0.5.5
+
+### Preview features
+
+- \[`fastapi`\] Implement `fastapi-redundant-response-model` (`FAST001`) and `fastapi-non-annotated-dependency`(`FAST002`) ([#11579](https://github.com/astral-sh/ruff/pull/11579))
+- \[`pydoclint`\] Implement `docstring-missing-exception` (`DOC501`) and `docstring-extraneous-exception` (`DOC502`) ([#11471](https://github.com/astral-sh/ruff/pull/11471))
+
+### Rule changes
+
+- \[`numpy`\] Fix NumPy 2.0 rule for `np.alltrue` and `np.sometrue` ([#12473](https://github.com/astral-sh/ruff/pull/12473))
+- \[`numpy`\] Ignore `NPY201` inside `except` blocks for compatibility with older numpy versions ([#12490](https://github.com/astral-sh/ruff/pull/12490))
+- \[`pep8-naming`\] Avoid applying `ignore-names` to `self` and `cls` function names (`N804`, `N805`) ([#12497](https://github.com/astral-sh/ruff/pull/12497))
+
+### Formatter
+
+- Fix incorrect placement of leading function comment with type params ([#12447](https://github.com/astral-sh/ruff/pull/12447))
+
+### Server
+
+- Do not bail code action resolution when a quick fix is requested ([#12462](https://github.com/astral-sh/ruff/pull/12462))
+
+### Bug fixes
+
+- Fix `Ord` implementation of `cmp_fix` ([#12471](https://github.com/astral-sh/ruff/pull/12471))
+- Raise syntax error for unparenthesized generator expression in multi-argument call ([#12445](https://github.com/astral-sh/ruff/pull/12445))
+- \[`pydoclint`\] Fix panic in `DOC501` reported in [#12428](https://github.com/astral-sh/ruff/pull/12428) ([#12435](https://github.com/astral-sh/ruff/pull/12435))
+- \[`flake8-bugbear`\] Allow singleton tuples with starred expressions in `B013` ([#12484](https://github.com/astral-sh/ruff/pull/12484))
+
+### Documentation
+
+- Add Eglot setup guide for Emacs editor ([#12426](https://github.com/astral-sh/ruff/pull/12426))
+- Add note about the breaking change in `nvim-lspconfig` ([#12507](https://github.com/astral-sh/ruff/pull/12507))
+- Add note to include notebook files for native server ([#12449](https://github.com/astral-sh/ruff/pull/12449))
+- Add setup docs for Zed editor ([#12501](https://github.com/astral-sh/ruff/pull/12501))
+
+## 0.5.4
+
+### Rule changes
+
+- \[`ruff`\] Rename `RUF007` to `zip-instead-of-pairwise` ([#12399](https://github.com/astral-sh/ruff/pull/12399))
+
+### Bug fixes
+
+- \[`flake8-builtins`\] Avoid shadowing diagnostics for `@override` methods ([#12415](https://github.com/astral-sh/ruff/pull/12415))
+- \[`flake8-comprehensions`\] Insert parentheses for multi-argument generators ([#12422](https://github.com/astral-sh/ruff/pull/12422))
+- \[`pydocstyle`\] Handle escaped docstrings within docstring (`D301`) ([#12192](https://github.com/astral-sh/ruff/pull/12192))
+
+### Documentation
+
+- Fix GitHub link to Neovim setup ([#12410](https://github.com/astral-sh/ruff/pull/12410))
+- Fix `output-format` default in settings reference ([#12409](https://github.com/astral-sh/ruff/pull/12409))
+
+## 0.5.3
+
+**Ruff 0.5.3 marks the stable release of the Ruff language server and introduces revamped
+[documentation](https://docs.astral.sh/ruff/editors), including [setup guides for your editor of
+choice](https://docs.astral.sh/ruff/editors/setup) and [the language server
+itself](https://docs.astral.sh/ruff/editors/settings)**.
+
+### Preview features
+
+- Formatter: Insert empty line between suite and alternative branch after function/class definition ([#12294](https://github.com/astral-sh/ruff/pull/12294))
+- \[`pyupgrade`\] Implement `unnecessary-default-type-args` (`UP043`) ([#12371](https://github.com/astral-sh/ruff/pull/12371))
+
+### Rule changes
+
+- \[`flake8-bugbear`\] Detect enumerate iterations in `loop-iterator-mutation` (`B909`) ([#12366](https://github.com/astral-sh/ruff/pull/12366))
+- \[`flake8-bugbear`\] Remove `discard`, `remove`, and `pop` allowance for `loop-iterator-mutation` (`B909`) ([#12365](https://github.com/astral-sh/ruff/pull/12365))
+- \[`pylint`\] Allow `repeated-equality-comparison` for mixed operations (`PLR1714`) ([#12369](https://github.com/astral-sh/ruff/pull/12369))
+- \[`pylint`\] Ignore `self` and `cls` when counting arguments (`PLR0913`) ([#12367](https://github.com/astral-sh/ruff/pull/12367))
+- \[`pylint`\] Use UTF-8 as default encoding in `unspecified-encoding` fix (`PLW1514`) ([#12370](https://github.com/astral-sh/ruff/pull/12370))
+
+### Server
+
+- Build settings index in parallel for the native server ([#12299](https://github.com/astral-sh/ruff/pull/12299))
+- Use fallback settings when indexing the project ([#12362](https://github.com/astral-sh/ruff/pull/12362))
+- Consider `--preview` flag for `server` subcommand for the linter and formatter ([#12208](https://github.com/astral-sh/ruff/pull/12208))
+
+### Bug fixes
+
+- \[`flake8-comprehensions`\] Allow additional arguments for `sum` and `max` comprehensions (`C419`) ([#12364](https://github.com/astral-sh/ruff/pull/12364))
+- \[`pylint`\] Avoid dropping extra boolean operations in `repeated-equality-comparison` (`PLR1714`) ([#12368](https://github.com/astral-sh/ruff/pull/12368))
+- \[`pylint`\] Consider expression before statement when determining binding kind (`PLR1704`) ([#12346](https://github.com/astral-sh/ruff/pull/12346))
+
+### Documentation
+
+- Add docs for Ruff language server ([#12344](https://github.com/astral-sh/ruff/pull/12344))
+- Migrate to standalone docs repo ([#12341](https://github.com/astral-sh/ruff/pull/12341))
+- Update versioning policy for editor integration ([#12375](https://github.com/astral-sh/ruff/pull/12375))
+
+### Other changes
+
+- Publish Wasm API to npm ([#12317](https://github.com/astral-sh/ruff/pull/12317))
+
+## 0.5.2
+
+### Preview features
+
+- Use `space` separator before parenthesized expressions in comprehensions with leading comments ([#12282](https://github.com/astral-sh/ruff/pull/12282))
+- \[`flake8-async`\] Update `ASYNC100` to include `anyio` and `asyncio` ([#12221](https://github.com/astral-sh/ruff/pull/12221))
+- \[`flake8-async`\] Update `ASYNC109` to include `anyio` and `asyncio` ([#12236](https://github.com/astral-sh/ruff/pull/12236))
+- \[`flake8-async`\] Update `ASYNC110` to include `anyio` and `asyncio` ([#12261](https://github.com/astral-sh/ruff/pull/12261))
+- \[`flake8-async`\] Update `ASYNC115` to include `anyio` and `asyncio` ([#12262](https://github.com/astral-sh/ruff/pull/12262))
+- \[`flake8-async`\] Update `ASYNC116` to include `anyio` and `asyncio` ([#12266](https://github.com/astral-sh/ruff/pull/12266))
+
+### Rule changes
+
+- \[`flake8-return`\] Exempt properties from explicit return rule (`RET501`) ([#12243](https://github.com/astral-sh/ruff/pull/12243))
+- \[`numpy`\] Add `np.NAN`-to-`np.nan` diagnostic ([#12292](https://github.com/astral-sh/ruff/pull/12292))
+- \[`refurb`\] Make `list-reverse-copy` an unsafe fix ([#12303](https://github.com/astral-sh/ruff/pull/12303))
+
+### Server
+
+- Consider `include` and `extend-include` settings in native server ([#12252](https://github.com/astral-sh/ruff/pull/12252))
+- Include nested configurations in settings reloading ([#12253](https://github.com/astral-sh/ruff/pull/12253))
+
+### CLI
+
+- Omit code frames for fixes with empty ranges ([#12304](https://github.com/astral-sh/ruff/pull/12304))
+- Warn about formatter incompatibility for `D203` ([#12238](https://github.com/astral-sh/ruff/pull/12238))
+
+### Bug fixes
+
+- Make cache-write failures non-fatal on Windows ([#12302](https://github.com/astral-sh/ruff/pull/12302))
+- Treat `not` operations as boolean tests ([#12301](https://github.com/astral-sh/ruff/pull/12301))
+- \[`flake8-bandit`\] Avoid `S310` violations for HTTP-safe f-strings ([#12305](https://github.com/astral-sh/ruff/pull/12305))
+- \[`flake8-bandit`\] Support explicit string concatenations in S310 HTTP detection ([#12315](https://github.com/astral-sh/ruff/pull/12315))
+- \[`flake8-bandit`\] fix S113 false positive for httpx without `timeout` argument ([#12213](https://github.com/astral-sh/ruff/pull/12213))
+- \[`pycodestyle`\] Remove "non-obvious" allowance for E721 ([#12300](https://github.com/astral-sh/ruff/pull/12300))
+- \[`pyflakes`\] Consider `with` blocks as single-item branches for redefinition analysis ([#12311](https://github.com/astral-sh/ruff/pull/12311))
+- \[`refurb`\] Restrict forwarding for `newline` argument in `open()` calls to Python versions >= 3.10 ([#12244](https://github.com/astral-sh/ruff/pull/12244))
+
+### Documentation
+
+- Update help and documentation to reflect `--output-format full` default ([#12248](https://github.com/astral-sh/ruff/pull/12248))
+
+### Performance
+
+- Use more threads when discovering Python files ([#12258](https://github.com/astral-sh/ruff/pull/12258))
+
+## 0.5.1
+
+### Preview features
+
+- \[`flake8-bugbear`\] Implement mutable-contextvar-default (B039) ([#12113](https://github.com/astral-sh/ruff/pull/12113))
+- \[`pycodestyle`\] Whitespace after decorator (`E204`) ([#12140](https://github.com/astral-sh/ruff/pull/12140))
+- \[`pytest`\] Reverse `PT001` and `PT0023` defaults ([#12106](https://github.com/astral-sh/ruff/pull/12106))
+
+### Rule changes
+
+- Enable token-based rules on source with syntax errors ([#11950](https://github.com/astral-sh/ruff/pull/11950))
+- \[`flake8-bandit`\] Detect `httpx` for `S113` ([#12174](https://github.com/astral-sh/ruff/pull/12174))
+- \[`numpy`\] Update `NPY201` to include exception deprecations ([#12065](https://github.com/astral-sh/ruff/pull/12065))
+- \[`pylint`\] Generate autofix for `duplicate-bases` (`PLE0241`) ([#12105](https://github.com/astral-sh/ruff/pull/12105))
+
+### Server
+
+- Avoid syntax error notification for source code actions ([#12148](https://github.com/astral-sh/ruff/pull/12148))
+- Consider the content of the new cells during notebook sync ([#12203](https://github.com/astral-sh/ruff/pull/12203))
+- Fix replacement edit range computation ([#12171](https://github.com/astral-sh/ruff/pull/12171))
+
+### Bug fixes
+
+- Disable auto-fix when source has syntax errors ([#12134](https://github.com/astral-sh/ruff/pull/12134))
+- Fix cache key collisions for paths with separators ([#12159](https://github.com/astral-sh/ruff/pull/12159))
+- Make `requires-python` inference robust to `==` ([#12091](https://github.com/astral-sh/ruff/pull/12091))
+- Use char-wise width instead of `str`-width ([#12135](https://github.com/astral-sh/ruff/pull/12135))
+- \[`pycodestyle`\] Avoid `E275` if keyword followed by comma ([#12136](https://github.com/astral-sh/ruff/pull/12136))
+- \[`pycodestyle`\] Avoid `E275` if keyword is followed by a semicolon ([#12095](https://github.com/astral-sh/ruff/pull/12095))
+- \[`pylint`\] Skip [dummy variables](https://docs.astral.sh/ruff/settings/#lint_dummy-variable-rgx) for `PLR1704` ([#12190](https://github.com/astral-sh/ruff/pull/12190))
+
+### Performance
+
+- Remove allocation in `parse_identifier` ([#12103](https://github.com/astral-sh/ruff/pull/12103))
+- Use `CompactString` for `Identifier` AST node ([#12101](https://github.com/astral-sh/ruff/pull/12101))
+
+## 0.5.0
+
+Check out the [blog post](https://astral.sh/blog/ruff-v0.5.0) for a migration guide and overview of the changes!
+
+### 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

CONTRIBUTING.md

@@ -280,7 +280,7 @@ These represent, respectively: the schema used to parse the `pyproject.toml` fil
 intermediate representation; and the final, internal representation used to power Ruff.
 
 To add a new configuration option, you'll likely want to modify these latter few files (along with
-`arg.rs`, if appropriate). If you want to pattern-match against an existing example, grep for
+`args.rs`, if appropriate). If you want to pattern-match against an existing example, grep for
 `dummy_variable_rgx`, which defines a regular expression to match against acceptable unused
 variables (e.g., `_`).
 
@@ -333,7 +333,7 @@ even patch releases may contain [non-backwards-compatible changes](https://semve
 ### Creating a new release
 
 1. Install `uv`: `curl -LsSf https://astral.sh/uv/install.sh | sh`
-1. Run `./scripts/release/bump.sh`; this command will:
+1. Run `./scripts/release.sh`; this command will:
     - Generate a temporary virtual environment with `rooster`
     - Generate a changelog entry in `CHANGELOG.md`
     - Update versions in `pyproject.toml` and `Cargo.toml`
@@ -346,9 +346,8 @@ 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. If you just need to rerun the build,
@@ -360,10 +359,8 @@ even patch releases may contain [non-backwards-compatible changes](https://semve
     1. Attach artifacts to draft GitHub release
     1. Trigger downstream repositories. This can fail non-catastrophically, as we can run any
         downstream jobs manually if needed.
-1. 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
@@ -908,7 +905,7 @@ There are three ways in which an import can be categorized as "first-party":
     package (e.g., `from foo import bar` or `import foo.bar`), they'll be classified as first-party
     automatically. This check is as simple as comparing the first segment of the current file's
     module path to the first segment of the import.
-1. **Source roots**: Ruff supports a `[src](https://docs.astral.sh/ruff/settings/#src)` setting, which
+1. **Source roots**: Ruff supports a [`src`](https://docs.astral.sh/ruff/settings/#src) setting, which
     sets the directories to scan when identifying first-party imports. The algorithm is
     straightforward: given an import, like `import foo`, iterate over the directories enumerated in
     the `src` setting and, for each directory, check for the existence of a subdirectory `foo` or a

Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-rust-version = "1.75"
+rust-version = "1.76"
 homepage = "https://docs.astral.sh/ruff"
 documentation = "https://docs.astral.sh/ruff"
 repository = "https://github.com/astral-sh/ruff"
@@ -36,6 +36,8 @@ ruff_text_size = { path = "crates/ruff_text_size" }
 ruff_workspace = { path = "crates/ruff_workspace" }
 
 red_knot_module_resolver = { path = "crates/red_knot_module_resolver" }
+red_knot_python_semantic = { path = "crates/red_knot_python_semantic" }
+red_knot_workspace = { path = "crates/red_knot_workspace" }
 
 aho-corasick = { version = "1.1.3" }
 annotate-snippets = { version = "0.9.2", features = ["color"] }
@@ -48,19 +50,19 @@ cachedir = { version = "0.3.1" }
 camino = { version = "1.1.7" }
 chrono = { version = "0.4.35", default-features = false, features = ["clock"] }
 clap = { version = "4.5.3", features = ["derive"] }
-clap_complete_command = { version = "0.5.1" }
+clap_complete_command = { version = "0.6.0" }
 clearscreen = { version = "3.0.0" }
 codspeed-criterion-compat = { version = "2.6.0", default-features = false }
 colored = { version = "2.1.0" }
 console_error_panic_hook = { version = "0.1.7" }
 console_log = { version = "1.0.0" }
 countme = { version = "3.0.1" }
-criterion = { version = "0.5.1", default-features = false }
+compact_str = "0.8.0"
 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" }
@@ -69,7 +71,6 @@ hashbrown = "0.14.3"
 ignore = { version = "0.4.22" }
 imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
-indexmap = { version = "2.2.6" }
 indicatif = { version = "0.17.8" }
 indoc = { version = "2.0.4" }
 insta = { version = "1.35.1" }
@@ -92,10 +93,10 @@ mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
 notify = { version = "6.1.1" }
 once_cell = { version = "1.19.0" }
+ordermap = { version = "0.5.0" }
 path-absolutize = { version = "3.1.1" }
 path-slash = { version = "0.2.1" }
 pathdiff = { version = "0.2.1" }
-parking_lot = "0.12.1"
 pep440_rs = { version = "0.6.0", features = ["serde"] }
 pretty_assertions = "1.3.0"
 proc-macro2 = { version = "1.0.79" }
@@ -106,7 +107,7 @@ rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "f706aa2d32d473ee633a77c1af01d180c85da308" }
+salsa = { git = "https://github.com/MichaReiser/salsa.git", rev = "635e23943c095077c4a423488ac829b4ae0bfa77" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -119,7 +120,6 @@ serde_with = { version = "3.6.0", default-features = false, features = [
 shellexpand = { version = "3.0.0" }
 similar = { version = "2.4.0", features = ["inline"] }
 smallvec = { version = "1.13.2" }
-smol_str = { version = "0.2.2" }
 static_assertions = "1.1.0"
 strum = { version = "0.26.0", features = ["strum_macros"] }
 strum_macros = { version = "0.26.0" }
@@ -127,12 +127,12 @@ syn = { version = "2.0.55" }
 tempfile = { version = "3.9.0" }
 test-case = { version = "3.3.1" }
 thiserror = { version = "1.0.58" }
-tikv-jemallocator = { version = "0.5.0" }
+tikv-jemallocator = { version = "0.6.0" }
 toml = { version = "0.8.11" }
 tracing = { version = "0.1.40" }
 tracing-indicatif = { version = "0.3.6" }
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
-tracing-tree = { version = "0.3.0" }
+tracing-tree = { version = "0.4.0" }
 typed-arena = { version = "2.0.2" }
 unic-ucd-category = { version = "0.9" }
 unicode-ident = { version = "1.0.12" }
@@ -156,6 +156,7 @@ zip = { version = "0.6.6", default-features = false, features = ["zstd"] }
 [workspace.lints.rust]
 unsafe_code = "warn"
 unreachable_pub = "warn"
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(fuzzing)'] }
 
 [workspace.lints.clippy]
 pedantic = { level = "warn", priority = -2 }
@@ -219,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", "./publish-wasm"]
+# Announcement jobs to run in CI
+post-announce-jobs = ["./notify-dependents", "./publish-docs", "./publish-playground"]
+# Custom permissions for GitHub Jobs
+github-custom-job-permissions = { "build-docker" = { packages = "write", contents = "read" }, "publish-wasm" = { contents = "read", id-token = "write", packages = "write" } }
+# Whether to install an updater program
+install-updater = false

LICENSE

@@ -1371,3 +1371,28 @@ are:
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
     SOFTWARE.
   """
+
+- pydoclint, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2023 jsh9
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  """

README.md

@@ -35,7 +35,7 @@ An extremely fast Python linter and code formatter, written in Rust.
 - 📏 Over [800 built-in rules](https://docs.astral.sh/ruff/rules/), with native re-implementations
     of popular Flake8 plugins, like flake8-bugbear
 - ⌨️ First-party [editor integrations](https://docs.astral.sh/ruff/integrations/) for
-    [VS Code](https://github.com/astral-sh/ruff-vscode) and [more](https://github.com/astral-sh/ruff-lsp)
+    [VS Code](https://github.com/astral-sh/ruff-vscode) and [more](https://docs.astral.sh/ruff/editors/setup)
 - 🌎 Monorepo-friendly, with [hierarchical and cascading configuration](https://docs.astral.sh/ruff/configuration/#pyprojecttoml-discovery)
 
 Ruff aims to be orders of magnitude faster than alternative tools while integrating more
@@ -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.6/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.5.6/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.10
+  rev: v0.5.6
   hooks:
     # Run the linter.
     - id: ruff
@@ -161,8 +179,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
     - id: ruff-format
 ```
 
-Ruff can also be used as a [VS Code extension](https://github.com/astral-sh/ruff-vscode) or
-alongside any other editor through the [Ruff LSP](https://github.com/astral-sh/ruff-lsp).
+Ruff can also be used as a [VS Code extension](https://github.com/astral-sh/ruff-vscode) or with [various other editors](https://docs.astral.sh/ruff/editors/setup).
 
 Ruff can also be used as a [GitHub Action](https://github.com/features/actions) via
 [`ruff-action`](https://github.com/chartboost/ruff-action):
@@ -334,7 +351,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))
@@ -407,6 +423,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [Dagger](https://github.com/dagger/dagger)
 - [Dagster](https://github.com/dagster-io/dagster)
 - Databricks ([MLflow](https://github.com/mlflow/mlflow))
+- [Dify](https://github.com/langgenius/dify)
 - [FastAPI](https://github.com/tiangolo/fastapi)
 - [Godot](https://github.com/godotengine/godot)
 - [Gradio](https://github.com/gradio-app/gradio)
@@ -417,6 +434,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - Hugging Face ([Transformers](https://github.com/huggingface/transformers),
     [Datasets](https://github.com/huggingface/datasets),
     [Diffusers](https://github.com/huggingface/diffusers))
+- IBM ([Qiskit](https://github.com/Qiskit/qiskit))
 - ING Bank ([popmon](https://github.com/ing-bank/popmon), [probatus](https://github.com/ing-bank/probatus))
 - [Ibis](https://github.com/ibis-project/ibis)
 - [ivy](https://github.com/unifyai/ivy)

_typos.toml

@@ -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",
 ]

clippy.toml

@@ -10,4 +10,12 @@ doc-valid-idents = [
   "SCREAMING_SNAKE_CASE",
   "SQLAlchemy",
   "StackOverflow",
+  "PyCharm",
+]
+
+ignore-interior-mutability = [
+  # Interned is read-only. The wrapped `Rc` never gets updated.
+  "ruff_formatter::format_element::Interned",
+  # The expression is read-only.
+  "ruff_python_ast::hashable::HashableExpr",
 ]

crates/red_knot/Cargo.toml

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

crates/red_knot/src/ast_ids.rs

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

crates/red_knot/src/cache.rs

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

crates/red_knot/src/cancellation.rs

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

crates/red_knot/src/cli/mod.rs

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

crates/red_knot/src/cli/target_version.rs

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

crates/red_knot/src/cli/verbosity.rs

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

crates/red_knot/src/db.rs

@@ -1,248 +0,0 @@
-use std::sync::Arc;
-
-pub use jars::{HasJar, HasJars};
-pub use query::{QueryError, QueryResult};
-pub use runtime::DbRuntime;
-pub use storage::JarsStorage;
-
-use crate::files::FileId;
-use crate::lint::{LintSemanticStorage, LintSyntaxStorage};
-use crate::module::ModuleResolver;
-use crate::parse::ParsedStorage;
-use crate::semantic::SemanticIndexStorage;
-use crate::semantic::TypeStore;
-use crate::source::SourceStorage;
-
-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 semantic_indices: SemanticIndexStorage,
-    pub type_store: TypeStore,
-}
-
-#[derive(Debug, Default)]
-pub struct LintJar {
-    pub lint_syntax: LintSyntaxStorage,
-    pub lint_semantic: LintSemanticStorage,
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use std::path::Path;
-    use std::sync::Arc;
-
-    use crate::db::{
-        Database, DbRuntime, DbWithJar, HasJar, HasJars, JarsStorage, LintDb, LintJar, QueryResult,
-        SourceDb, SourceJar, Upcast,
-    };
-    use crate::files::{FileId, Files};
-
-    use super::{SemanticDb, SemanticJar};
-
-    // This can be a partial database used in a single crate for testing.
-    // It would hold fewer data than the full database.
-    #[derive(Debug, Default)]
-    pub(crate) struct TestDb {
-        files: Files,
-        jars: JarsStorage<Self>,
-    }
-
-    impl HasJar<SourceJar> for TestDb {
-        fn jar(&self) -> QueryResult<&SourceJar> {
-            Ok(&self.jars()?.0)
-        }
-
-        fn jar_mut(&mut self) -> &mut SourceJar {
-            &mut self.jars_mut().0
-        }
-    }
-
-    impl HasJar<SemanticJar> for TestDb {
-        fn jar(&self) -> QueryResult<&SemanticJar> {
-            Ok(&self.jars()?.1)
-        }
-
-        fn jar_mut(&mut self) -> &mut SemanticJar {
-            &mut self.jars_mut().1
-        }
-    }
-
-    impl HasJar<LintJar> for TestDb {
-        fn jar(&self) -> QueryResult<&LintJar> {
-            Ok(&self.jars()?.2)
-        }
-
-        fn jar_mut(&mut self) -> &mut LintJar {
-            &mut self.jars_mut().2
-        }
-    }
-
-    impl SourceDb for TestDb {
-        fn file_id(&self, path: &Path) -> FileId {
-            self.files.intern(path)
-        }
-
-        fn file_path(&self, file_id: FileId) -> Arc<Path> {
-            self.files.path(file_id)
-        }
-    }
-
-    impl DbWithJar<SourceJar> for TestDb {}
-
-    impl Upcast<dyn SourceDb> for TestDb {
-        fn upcast(&self) -> &(dyn SourceDb + 'static) {
-            self
-        }
-    }
-
-    impl SemanticDb for TestDb {}
-
-    impl DbWithJar<SemanticJar> for TestDb {}
-
-    impl Upcast<dyn SemanticDb> for TestDb {
-        fn upcast(&self) -> &(dyn SemanticDb + 'static) {
-            self
-        }
-    }
-
-    impl LintDb for TestDb {}
-
-    impl Upcast<dyn LintDb> for TestDb {
-        fn upcast(&self) -> &(dyn LintDb + 'static) {
-            self
-        }
-    }
-
-    impl DbWithJar<LintJar> for TestDb {}
-
-    impl HasJars for TestDb {
-        type Jars = (SourceJar, SemanticJar, LintJar);
-
-        fn jars(&self) -> QueryResult<&Self::Jars> {
-            self.jars.jars()
-        }
-
-        fn jars_mut(&mut self) -> &mut Self::Jars {
-            self.jars.jars_mut()
-        }
-    }
-
-    impl Database for TestDb {
-        fn runtime(&self) -> &DbRuntime {
-            self.jars.runtime()
-        }
-
-        fn runtime_mut(&mut self) -> &mut DbRuntime {
-            self.jars.runtime_mut()
-        }
-    }
-}

crates/red_knot/src/db/jars.rs

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

crates/red_knot/src/db/query.rs

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

crates/red_knot/src/db/runtime.rs

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

crates/red_knot/src/db/storage.rs

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

crates/red_knot/src/files.rs

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

crates/red_knot/src/hir.rs

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

crates/red_knot/src/hir/definition.rs

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

crates/red_knot/src/lib.rs

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

crates/red_knot/src/lint.rs

@@ -1,332 +0,0 @@
-use std::cell::RefCell;
-use std::ops::{Deref, DerefMut};
-use std::sync::Arc;
-use std::time::Duration;
-
-use ruff_python_ast::visitor::Visitor;
-use ruff_python_ast::{ModModule, StringLiteral};
-use ruff_python_parser::Parsed;
-
-use crate::cache::KeyValueCache;
-use crate::db::{LintDb, LintJar, QueryResult};
-use crate::files::FileId;
-use crate::module::{resolve_module, ModuleName};
-use crate::parse::parse;
-use crate::semantic::{infer_definition_type, infer_symbol_public_type, Type};
-use crate::semantic::{
-    resolve_global_symbol, semantic_index, Definition, GlobalSymbolId, SemanticIndex, SymbolId,
-};
-use crate::source::{source_text, Source};
-
-#[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;
-
-    #[allow(clippy::print_stdout)]
-    if std::env::var("RED_KNOT_SLOW_LINT").is_ok() {
-        for i in 0..10 {
-            db.cancelled()?;
-            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 source = source_text(db.upcast(), *file_id)?;
-        lint_lines(source.text(), &mut diagnostics);
-
-        let parsed = parse(db.upcast(), *file_id)?;
-
-        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));
-        }
-
-        Ok(Diagnostics::from(diagnostics))
-    })
-}
-
-fn lint_lines(source: &str, diagnostics: &mut Vec<String>) {
-    for (line_number, line) in source.lines().enumerate() {
-        if line.len() < 88 {
-            continue;
-        }
-
-        let char_count = line.chars().count();
-        if char_count > 88 {
-            diagnostics.push(format!(
-                "Line {} is too long ({} characters)",
-                line_number + 1,
-                char_count
-            ));
-        }
-    }
-}
-
-#[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;
-
-    storage.get(&file_id, |file_id| {
-        let source = source_text(db.upcast(), *file_id)?;
-        let parsed = parse(db.upcast(), *file_id)?;
-        let semantic_index = semantic_index(db.upcast(), *file_id)?;
-
-        let context = SemanticLintContext {
-            file_id: *file_id,
-            source,
-            parsed: &parsed,
-            semantic_index,
-            db,
-            diagnostics: RefCell::new(Vec::new()),
-        };
-
-        lint_unresolved_imports(&context)?;
-        lint_bad_overrides(&context)?;
-
-        Ok(Diagnostics::from(context.diagnostics.take()))
-    })
-}
-
-fn lint_unresolved_imports(context: &SemanticLintContext) -> QueryResult<()> {
-    // TODO: Consider iterating over the dependencies (imports) only instead of all definitions.
-    for (symbol, definition) in context.semantic_index().symbol_table().all_definitions() {
-        match definition {
-            Definition::Import(import) => {
-                let ty = context.infer_symbol_public_type(symbol)?;
-
-                if ty.is_unknown() {
-                    context.push_diagnostic(format!("Unresolved module {}", import.module));
-                }
-            }
-            Definition::ImportFrom(import) => {
-                let ty = context.infer_symbol_public_type(symbol)?;
-
-                if ty.is_unknown() {
-                    let module_name = import.module().map(Deref::deref).unwrap_or_default();
-                    let message = if import.level() > 0 {
-                        format!(
-                            "Unresolved relative import '{}' from {}{}",
-                            import.name(),
-                            ".".repeat(import.level() as usize),
-                            module_name
-                        )
-                    } else {
-                        format!(
-                            "Unresolved import '{}' from '{}'",
-                            import.name(),
-                            module_name
-                        )
-                    };
-
-                    context.push_diagnostic(message);
-                }
-            }
-            _ => {}
-        }
-    }
-
-    Ok(())
-}
-
-fn lint_bad_overrides(context: &SemanticLintContext) -> QueryResult<()> {
-    // TODO we should have a special marker on the real typing module (from typeshed) so if you
-    // have your own "typing" module in your project, we don't consider it THE typing module (and
-    // same for other stdlib modules that our lint rules care about)
-    let Some(typing_override) = context.resolve_global_symbol("typing", "override")? else {
-        // TODO once we bundle typeshed, this should be unreachable!()
-        return Ok(());
-    };
-
-    // TODO we should maybe index definitions by type instead of iterating all, or else iterate all
-    // just once, match, and branch to all lint rules that care about a type of definition
-    for (symbol, definition) in context.semantic_index().symbol_table().all_definitions() {
-        if !matches!(definition, Definition::FunctionDef(_)) {
-            continue;
-        }
-        let ty = infer_definition_type(
-            context.db.upcast(),
-            GlobalSymbolId {
-                file_id: context.file_id,
-                symbol_id: symbol,
-            },
-            definition.clone(),
-        )?;
-        let Type::Function(func) = ty else {
-            unreachable!("type of a FunctionDef should always be a Function");
-        };
-        let Some(class) = func.get_containing_class(context.db.upcast())? else {
-            // not a method of a class
-            continue;
-        };
-        if func.has_decorator(context.db.upcast(), typing_override)? {
-            let method_name = func.name(context.db.upcast())?;
-            if class
-                .get_super_class_member(context.db.upcast(), &method_name)?
-                .is_none()
-            {
-                // TODO should have a qualname() method to support nested classes
-                context.push_diagnostic(
-                    format!(
-                        "Method {}.{} is decorated with `typing.override` but does not override any base class method",
-                        class.name(context.db.upcast())?,
-                        method_name,
-                    ));
-            }
-        }
-    }
-    Ok(())
-}
-
-pub struct SemanticLintContext<'a> {
-    file_id: FileId,
-    source: Source,
-    parsed: &'a Parsed<ModModule>,
-    semantic_index: Arc<SemanticIndex>,
-    db: &'a dyn LintDb,
-    diagnostics: RefCell<Vec<String>>,
-}
-
-impl<'a> SemanticLintContext<'a> {
-    pub fn source_text(&self) -> &str {
-        self.source.text()
-    }
-
-    pub fn file_id(&self) -> FileId {
-        self.file_id
-    }
-
-    pub fn ast(&self) -> &'a ModModule {
-        self.parsed.syntax()
-    }
-
-    pub fn semantic_index(&self) -> &SemanticIndex {
-        &self.semantic_index
-    }
-
-    pub fn infer_symbol_public_type(&self, symbol_id: SymbolId) -> QueryResult<Type> {
-        infer_symbol_public_type(
-            self.db.upcast(),
-            GlobalSymbolId {
-                file_id: self.file_id,
-                symbol_id,
-            },
-        )
-    }
-
-    pub fn push_diagnostic(&self, diagnostic: String) {
-        self.diagnostics.borrow_mut().push(diagnostic);
-    }
-
-    pub fn extend_diagnostics(&mut self, diagnostics: impl IntoIterator<Item = String>) {
-        self.diagnostics.get_mut().extend(diagnostics);
-    }
-
-    pub fn resolve_global_symbol(
-        &self,
-        module: &str,
-        symbol_name: &str,
-    ) -> QueryResult<Option<GlobalSymbolId>> {
-        let Some(module) = resolve_module(self.db.upcast(), ModuleName::new(module))? else {
-            return Ok(None);
-        };
-
-        resolve_global_symbol(self.db.upcast(), module, symbol_name)
-    }
-}
-
-#[derive(Debug)]
-struct SyntaxLintVisitor<'a> {
-    diagnostics: Vec<String>,
-    source: &'a str,
-}
-
-impl Visitor<'_> for SyntaxLintVisitor<'_> {
-    fn visit_string_literal(&mut self, string_literal: &'_ StringLiteral) {
-        // A very naive implementation of use double quotes
-        let text = &self.source[string_literal.range];
-
-        if text.starts_with('\'') {
-            self.diagnostics
-                .push("Use double quotes for strings".to_string());
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum Diagnostics {
-    Empty,
-    List(Arc<Vec<String>>),
-}
-
-impl Diagnostics {
-    pub fn as_slice(&self) -> &[String] {
-        match self {
-            Diagnostics::Empty => &[],
-            Diagnostics::List(list) => list.as_slice(),
-        }
-    }
-}
-
-impl Deref for Diagnostics {
-    type Target = [String];
-    fn deref(&self) -> &Self::Target {
-        self.as_slice()
-    }
-}
-
-impl From<Vec<String>> for Diagnostics {
-    fn from(value: Vec<String>) -> Self {
-        if value.is_empty() {
-            Diagnostics::Empty
-        } else {
-            Diagnostics::List(Arc::new(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
-    }
-}

crates/red_knot/src/main.rs

@@ -1,8 +1,6 @@
-#![allow(clippy::dbg_macro)]
-
-use std::path::Path;
 use std::sync::Mutex;
 
+use clap::Parser;
 use crossbeam::channel as crossbeam_channel;
 use tracing::subscriber::Interest;
 use tracing::{Level, Metadata};
@@ -11,55 +9,110 @@ use tracing_subscriber::layer::{Context, Filter, SubscriberExt};
 use tracing_subscriber::{Layer, Registry};
 use tracing_tree::time::Uptime;
 
-use red_knot::db::{HasJar, ParallelDatabase, QueryError, SourceDb, SourceJar};
-use red_knot::module::{set_module_search_paths, ModuleResolutionInputs};
-use red_knot::program::check::ExecutionMode;
-use red_knot::program::{FileWatcherChange, Program};
-use red_knot::watch::FileWatcher;
-use red_knot::Workspace;
+use red_knot_workspace::db::RootDatabase;
+use red_knot_workspace::watch;
+use red_knot_workspace::watch::WorkspaceWatcher;
+use red_knot_workspace::workspace::WorkspaceMetadata;
+use ruff_db::program::{ProgramSettings, SearchPathSettings};
+use ruff_db::system::{OsSystem, System, SystemPathBuf};
 
-#[allow(clippy::print_stdout, clippy::unnecessary_wraps, clippy::print_stderr)]
-fn main() -> anyhow::Result<()> {
-    setup_tracing();
+use cli::target_version::TargetVersion;
+use cli::verbosity::{Verbosity, VerbosityLevel};
 
-    let arguments: Vec<_> = std::env::args().collect();
+mod cli;
 
-    if arguments.len() < 2 {
-        eprintln!("Usage: red_knot <path>");
-        return Err(anyhow::anyhow!("Invalid arguments"));
-    }
+#[derive(Debug, Parser)]
+#[command(
+    author,
+    name = "red-knot",
+    about = "An experimental multifile analysis backend for Ruff"
+)]
+#[command(version)]
+struct Args {
+    #[arg(
+        long,
+        help = "Changes the current working directory.",
+        long_help = "Changes the current working directory before any specified operations. This affects the workspace and configuration discovery.",
+        value_name = "PATH"
+    )]
+    current_directory: Option<SystemPathBuf>,
 
-    let entry_point = Path::new(&arguments[1]);
+    #[arg(
+        long,
+        value_name = "DIRECTORY",
+        help = "Custom directory to use for stdlib typeshed stubs"
+    )]
+    custom_typeshed_dir: Option<SystemPathBuf>,
 
-    if !entry_point.exists() {
-        eprintln!("The entry point does not exist.");
-        return Err(anyhow::anyhow!("Invalid arguments"));
-    }
+    #[arg(
+        long,
+        value_name = "PATH",
+        help = "Additional path to use as a module-resolution source (can be passed multiple times)"
+    )]
+    extra_search_path: Vec<SystemPathBuf>,
 
-    if !entry_point.is_file() {
-        eprintln!("The entry point is not a file.");
-        return Err(anyhow::anyhow!("Invalid arguments"));
-    }
+    #[arg(long, help = "Python version to assume when resolving types", default_value_t = TargetVersion::default(), value_name="VERSION")]
+    target_version: TargetVersion,
 
-    let workspace_folder = entry_point.parent().unwrap();
-    let workspace = Workspace::new(workspace_folder.to_path_buf());
+    #[clap(flatten)]
+    verbosity: Verbosity,
 
-    let workspace_search_path = workspace.root().to_path_buf();
+    #[arg(
+        long,
+        help = "Run in watch mode by re-running whenever files change",
+        short = 'W'
+    )]
+    watch: bool,
+}
 
-    let search_paths = ModuleResolutionInputs {
-        extra_paths: vec![],
-        workspace_root: workspace_search_path,
-        site_packages: None,
-        custom_typeshed: None,
+#[allow(
+    clippy::print_stdout,
+    clippy::unnecessary_wraps,
+    clippy::print_stderr,
+    clippy::dbg_macro
+)]
+pub fn main() -> anyhow::Result<()> {
+    let Args {
+        current_directory,
+        custom_typeshed_dir,
+        extra_search_path: extra_paths,
+        target_version,
+        verbosity,
+        watch,
+    } = Args::parse_from(std::env::args().collect::<Vec<_>>());
+
+    let verbosity = verbosity.level();
+    countme::enable(verbosity == Some(VerbosityLevel::Trace));
+    setup_tracing(verbosity);
+
+    let cwd = if let Some(cwd) = current_directory {
+        let canonicalized = cwd.as_utf8_path().canonicalize_utf8().unwrap();
+        SystemPathBuf::from_utf8_path_buf(canonicalized)
+    } else {
+        let cwd = std::env::current_dir().unwrap();
+        SystemPathBuf::from_path_buf(cwd).unwrap()
     };
 
-    let mut program = Program::new(workspace);
-    set_module_search_paths(&mut program, search_paths);
+    let system = OsSystem::new(cwd.clone());
+    let workspace_metadata =
+        WorkspaceMetadata::from_path(system.current_directory(), &system).unwrap();
 
-    let entry_id = program.file_id(entry_point);
-    program.workspace_mut().open_file(entry_id);
+    // TODO: Respect the settings from the workspace metadata. when resolving the program settings.
+    let program_settings = ProgramSettings {
+        target_version: target_version.into(),
+        search_paths: SearchPathSettings {
+            extra_paths,
+            workspace_root: workspace_metadata.root().to_path_buf(),
+            custom_typeshed: custom_typeshed_dir,
+            site_packages: vec![],
+        },
+    };
 
-    let (main_loop, main_loop_cancellation_token) = MainLoop::new();
+    // TODO: Use the `program_settings` to compute the key for the database's persistent
+    //   cache and load the cache if it exists.
+    let db = RootDatabase::new(workspace_metadata, program_settings, system);
+
+    let (main_loop, main_loop_cancellation_token) = MainLoop::new(verbosity);
 
     // Listen to Ctrl+C and abort the watch mode.
     let main_loop_cancellation_token = Mutex::new(Some(main_loop_cancellation_token));
@@ -71,122 +124,124 @@ fn main() -> anyhow::Result<()> {
         }
     })?;
 
-    let file_changes_notifier = main_loop.file_changes_notifier();
+    let mut db = salsa::Handle::new(db);
+    if watch {
+        main_loop.watch(&mut db)?;
+    } else {
+        main_loop.run(&mut db);
+    };
 
-    // Watch for file changes and re-trigger the analysis.
-    let mut file_watcher = FileWatcher::new(move |changes| {
-        file_changes_notifier.notify(changes);
-    })?;
-
-    file_watcher.watch_folder(workspace_folder)?;
-
-    main_loop.run(&mut program);
-
-    let source_jar: &SourceJar = program.jar().unwrap();
-
-    dbg!(source_jar.parsed.statistics());
-    dbg!(source_jar.sources.statistics());
+    std::mem::forget(db);
 
     Ok(())
 }
 
 struct MainLoop {
-    orchestrator_sender: crossbeam_channel::Sender<OrchestratorMessage>,
-    main_loop_receiver: crossbeam_channel::Receiver<MainLoopMessage>,
+    /// Sender that can be used to send messages to the main loop.
+    sender: crossbeam_channel::Sender<MainLoopMessage>,
+
+    /// Receiver for the messages sent **to** the main loop.
+    receiver: crossbeam_channel::Receiver<MainLoopMessage>,
+
+    /// The file system watcher, if running in watch mode.
+    watcher: Option<WorkspaceWatcher>,
+
+    verbosity: Option<VerbosityLevel>,
 }
 
 impl MainLoop {
-    fn new() -> (Self, MainLoopCancellationToken) {
-        let (orchestrator_sender, orchestrator_receiver) = crossbeam_channel::bounded(1);
-        let (main_loop_sender, main_loop_receiver) = crossbeam_channel::bounded(1);
-
-        let mut orchestrator = Orchestrator {
-            receiver: orchestrator_receiver,
-            sender: main_loop_sender.clone(),
-            revision: 0,
-        };
-
-        std::thread::spawn(move || {
-            orchestrator.run();
-        });
+    fn new(verbosity: Option<VerbosityLevel>) -> (Self, MainLoopCancellationToken) {
+        let (sender, receiver) = crossbeam_channel::bounded(10);
 
         (
             Self {
-                orchestrator_sender,
-                main_loop_receiver,
-            },
-            MainLoopCancellationToken {
-                sender: main_loop_sender,
+                sender: sender.clone(),
+                receiver,
+                watcher: None,
+                verbosity,
             },
+            MainLoopCancellationToken { sender },
         )
     }
 
-    fn file_changes_notifier(&self) -> FileChangesNotifier {
-        FileChangesNotifier {
-            sender: self.orchestrator_sender.clone(),
-        }
+    fn watch(mut self, db: &mut salsa::Handle<RootDatabase>) -> anyhow::Result<()> {
+        let sender = self.sender.clone();
+        let watcher = watch::directory_watcher(move |event| {
+            sender.send(MainLoopMessage::ApplyChanges(event)).unwrap();
+        })?;
+
+        self.watcher = Some(WorkspaceWatcher::new(watcher, db));
+        self.run(db);
+        Ok(())
     }
 
-    fn run(self, program: &mut Program) {
-        self.orchestrator_sender
-            .send(OrchestratorMessage::Run)
-            .unwrap();
+    #[allow(clippy::print_stderr)]
+    fn run(mut self, db: &mut salsa::Handle<RootDatabase>) {
+        // Schedule the first check.
+        self.sender.send(MainLoopMessage::CheckWorkspace).unwrap();
+        let mut revision = 0usize;
 
-        for message in &self.main_loop_receiver {
+        while let Ok(message) = self.receiver.recv() {
             tracing::trace!("Main Loop: Tick");
 
             match message {
-                MainLoopMessage::CheckProgram { revision } => {
-                    let program = program.snapshot();
-                    let sender = self.orchestrator_sender.clone();
+                MainLoopMessage::CheckWorkspace => {
+                    let db = db.clone();
+                    let sender = self.sender.clone();
 
-                    // Spawn a new task that checks the program. This needs to be done in a separate thread
+                    // Spawn a new task that checks the workspace. This needs to be done in a separate thread
                     // to prevent blocking the main loop here.
-                    rayon::spawn(move || match program.check(ExecutionMode::ThreadPool) {
-                        Ok(result) => {
+                    rayon::spawn(move || {
+                        if let Ok(result) = db.check() {
+                            // Send the result back to the main loop for printing.
                             sender
-                                .send(OrchestratorMessage::CheckProgramCompleted {
-                                    diagnostics: result,
-                                    revision,
-                                })
-                                .unwrap();
+                                .send(MainLoopMessage::CheckCompleted { result, revision })
+                                .ok();
                         }
-                        Err(QueryError::Cancelled) => {}
                     });
                 }
-                MainLoopMessage::ApplyChanges(changes) => {
-                    // Automatically cancels any pending queries and waits for them to complete.
-                    program.apply_changes(changes);
+
+                MainLoopMessage::CheckCompleted {
+                    result,
+                    revision: check_revision,
+                } => {
+                    if check_revision == revision {
+                        eprintln!("{}", result.join("\n"));
+
+                        if self.verbosity == Some(VerbosityLevel::Trace) {
+                            eprintln!("{}", countme::get_all());
+                        }
+                    }
+
+                    if self.watcher.is_none() {
+                        return self.exit();
+                    }
                 }
-                MainLoopMessage::CheckCompleted(diagnostics) => {
-                    dbg!(diagnostics);
+
+                MainLoopMessage::ApplyChanges(changes) => {
+                    revision += 1;
+                    // Automatically cancels any pending queries and waits for them to complete.
+                    db.get_mut().apply_changes(changes);
+                    if let Some(watcher) = self.watcher.as_mut() {
+                        watcher.update(db);
+                    }
+                    self.sender.send(MainLoopMessage::CheckWorkspace).unwrap();
                 }
                 MainLoopMessage::Exit => {
-                    return;
+                    return self.exit();
                 }
             }
         }
+
+        self.exit();
     }
-}
 
-impl Drop for MainLoop {
-    fn drop(&mut self) {
-        self.orchestrator_sender
-            .send(OrchestratorMessage::Shutdown)
-            .unwrap();
-    }
-}
-
-#[derive(Debug, Clone)]
-struct FileChangesNotifier {
-    sender: crossbeam_channel::Sender<OrchestratorMessage>,
-}
-
-impl FileChangesNotifier {
-    fn notify(&self, changes: Vec<FileWatcherChange>) {
-        self.sender
-            .send(OrchestratorMessage::FileChanges(changes))
-            .unwrap();
+    #[allow(clippy::print_stderr, clippy::unused_self)]
+    fn exit(self) {
+        if self.verbosity == Some(VerbosityLevel::Trace) {
+            eprintln!("Exit");
+            eprintln!("{}", countme::get_all());
+        }
     }
 }
 
@@ -201,117 +256,26 @@ impl MainLoopCancellationToken {
     }
 }
 
-struct Orchestrator {
-    /// Sends messages to the main loop.
-    sender: crossbeam_channel::Sender<MainLoopMessage>,
-    /// Receives messages from the main loop.
-    receiver: crossbeam_channel::Receiver<OrchestratorMessage>,
-    revision: usize,
-}
-
-impl Orchestrator {
-    fn run(&mut self) {
-        while let Ok(message) = self.receiver.recv() {
-            match message {
-                OrchestratorMessage::Run => {
-                    self.sender
-                        .send(MainLoopMessage::CheckProgram {
-                            revision: self.revision,
-                        })
-                        .unwrap();
-                }
-
-                OrchestratorMessage::CheckProgramCompleted {
-                    diagnostics,
-                    revision,
-                } => {
-                    // Only take the diagnostics if they are for the latest revision.
-                    if self.revision == revision {
-                        self.sender
-                            .send(MainLoopMessage::CheckCompleted(diagnostics))
-                            .unwrap();
-                    } else {
-                        tracing::debug!("Discarding diagnostics for outdated revision {revision} (current: {}).", self.revision);
-                    }
-                }
-
-                OrchestratorMessage::FileChanges(changes) => {
-                    // Request cancellation, but wait until all analysis tasks have completed to
-                    // avoid stale messages in the next main loop.
-
-                    self.revision += 1;
-                    self.debounce_changes(changes);
-                }
-                OrchestratorMessage::Shutdown => {
-                    return self.shutdown();
-                }
-            }
-        }
-    }
-
-    fn debounce_changes(&self, mut changes: Vec<FileWatcherChange>) {
-        loop {
-            // Consume possibly incoming file change messages before running a new analysis, but don't wait for more than 100ms.
-            crossbeam_channel::select! {
-                recv(self.receiver) -> message => {
-                    match message {
-                        Ok(OrchestratorMessage::Shutdown) => {
-                            return self.shutdown();
-                        }
-                        Ok(OrchestratorMessage::FileChanges(file_changes)) => {
-                            changes.extend(file_changes);
-                        }
-
-                        Ok(OrchestratorMessage::CheckProgramCompleted { .. })=> {
-                            // disregard any outdated completion message.
-                        }
-                        Ok(OrchestratorMessage::Run) => unreachable!("The orchestrator is already running."),
-
-                        Err(_) => {
-                            // There are no more senders, no point in waiting for more messages
-                            return;
-                        }
-                    }
-                },
-                default(std::time::Duration::from_millis(10)) => {
-                    // No more file changes after 10 ms, send the changes and schedule a new analysis
-                    self.sender.send(MainLoopMessage::ApplyChanges(changes)).unwrap();
-                    self.sender.send(MainLoopMessage::CheckProgram { revision: self.revision}).unwrap();
-                    return;
-                }
-            }
-        }
-    }
-
-    #[allow(clippy::unused_self)]
-    fn shutdown(&self) {
-        tracing::trace!("Shutting down orchestrator.");
-    }
-}
-
 /// Message sent from the orchestrator to the main loop.
 #[derive(Debug)]
 enum MainLoopMessage {
-    CheckProgram { revision: usize },
-    CheckCompleted(Vec<String>),
-    ApplyChanges(Vec<FileWatcherChange>),
+    CheckWorkspace,
+    CheckCompleted {
+        result: Vec<String>,
+        revision: usize,
+    },
+    ApplyChanges(Vec<watch::ChangeEvent>),
     Exit,
 }
 
-#[derive(Debug)]
-enum OrchestratorMessage {
-    Run,
-    Shutdown,
+fn setup_tracing(verbosity: Option<VerbosityLevel>) {
+    let trace_level = match verbosity {
+        None => Level::WARN,
+        Some(VerbosityLevel::Info) => Level::INFO,
+        Some(VerbosityLevel::Debug) => Level::DEBUG,
+        Some(VerbosityLevel::Trace) => Level::TRACE,
+    };
 
-    CheckProgramCompleted {
-        diagnostics: Vec<String>,
-        revision: usize,
-    },
-
-    FileChanges(Vec<FileWatcherChange>),
-}
-
-fn setup_tracing() {
     let subscriber = Registry::default().with(
         tracing_tree::HierarchicalLayer::default()
             .with_indent_lines(true)
@@ -321,9 +285,7 @@ fn setup_tracing() {
             .with_targets(true)
             .with_writer(|| Box::new(std::io::stderr()))
             .with_timer(Uptime::default())
-            .with_filter(LoggingFilter {
-                trace_level: Level::TRACE,
-            }),
+            .with_filter(LoggingFilter { trace_level }),
     );
 
     tracing::subscriber::set_global_default(subscriber).unwrap();
@@ -337,6 +299,9 @@ impl LoggingFilter {
     fn is_enabled(&self, meta: &Metadata<'_>) -> bool {
         let filter = if meta.target().starts_with("red_knot") || meta.target().starts_with("ruff") {
             self.trace_level
+        } else if meta.target().starts_with("salsa") && self.trace_level <= Level::INFO {
+            // Salsa emits very verbose query traces with level info. Let's not show these to the user.
+            Level::WARN
         } else {
             Level::INFO
         };

crates/red_knot/src/parse.rs

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

crates/red_knot/src/program/check.rs

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

crates/red_knot/src/program/mod.rs

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

crates/red_knot/src/semantic.rs

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

crates/red_knot/src/semantic/definitions.rs

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

crates/red_knot/src/semantic/flow_graph.rs

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

crates/red_knot/src/semantic/symbol_table.rs

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

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

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

crates/red_knot/src/source.rs

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

crates/red_knot/src/watch.rs

@@ -1,77 +0,0 @@
-use std::path::Path;
-
-use anyhow::Context;
-use notify::event::{CreateKind, RemoveKind};
-use notify::{recommended_watcher, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
-
-use crate::program::{FileChangeKind, FileWatcherChange};
-
-pub struct FileWatcher {
-    watcher: RecommendedWatcher,
-}
-
-pub trait EventHandler: Send + 'static {
-    fn handle(&self, changes: Vec<FileWatcherChange>);
-}
-
-impl<F> EventHandler for F
-where
-    F: Fn(Vec<FileWatcherChange>) + Send + 'static,
-{
-    fn handle(&self, changes: Vec<FileWatcherChange>) {
-        let f = self;
-        f(changes);
-    }
-}
-
-impl FileWatcher {
-    pub fn new<E>(handler: E) -> anyhow::Result<Self>
-    where
-        E: EventHandler,
-    {
-        Self::from_handler(Box::new(handler))
-    }
-
-    fn from_handler(handler: Box<dyn EventHandler>) -> anyhow::Result<Self> {
-        let watcher = recommended_watcher(move |changes: notify::Result<Event>| {
-            match changes {
-                Ok(event) => {
-                    // TODO verify that this handles all events correctly
-                    let change_kind = match event.kind {
-                        EventKind::Create(CreateKind::File) => FileChangeKind::Created,
-                        EventKind::Modify(_) => FileChangeKind::Modified,
-                        EventKind::Remove(RemoveKind::File) => FileChangeKind::Deleted,
-                        _ => {
-                            return;
-                        }
-                    };
-
-                    let mut changes = Vec::new();
-
-                    for path in event.paths {
-                        if path.is_file() {
-                            changes.push(FileWatcherChange::new(path, change_kind));
-                        }
-                    }
-
-                    if !changes.is_empty() {
-                        handler.handle(changes);
-                    }
-                }
-                // TODO proper error handling
-                Err(err) => {
-                    panic!("Error: {err}");
-                }
-            }
-        })
-        .context("Failed to create file watcher.")?;
-
-        Ok(Self { watcher })
-    }
-
-    pub fn watch_folder(&mut self, path: &Path) -> anyhow::Result<()> {
-        self.watcher.watch(path, RecursiveMode::Recursive)?;
-
-        Ok(())
-    }
-}

crates/red_knot_module_resolver/Cargo.toml

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

crates/red_knot_module_resolver/src/db.rs

@@ -1,83 +1,44 @@
 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> {}
+#[salsa::db]
+pub trait Db: ruff_db::Db + Upcast<dyn ruff_db::Db> {}
 
+#[cfg(test)]
 pub(crate) mod tests {
     use std::sync;
 
-    use salsa::DebugWithDb;
+    use ruff_db::files::Files;
+    use ruff_db::system::{DbWithTestSystem, TestSystem};
+    use ruff_db::vendored::VendoredFileSystem;
 
-    use ruff_db::file_system::{FileSystem, MemoryFileSystem, OsFileSystem};
-    use ruff_db::vfs::Vfs;
+    use crate::vendored_typeshed_stubs;
 
     use super::*;
 
-    #[salsa::db(Jar, ruff_db::Jar)]
+    #[salsa::db]
     pub(crate) struct TestDb {
         storage: salsa::Storage<Self>,
-        file_system: TestFileSystem,
+        system: TestSystem,
+        vendored: VendoredFileSystem,
+        files: Files,
         events: sync::Arc<sync::Mutex<Vec<salsa::Event>>>,
-        vfs: Vfs,
     }
 
     impl TestDb {
-        #[allow(unused)]
         pub(crate) fn new() -> Self {
             Self {
                 storage: salsa::Storage::default(),
-                file_system: TestFileSystem::Memory(MemoryFileSystem::default()),
+                system: TestSystem::default(),
+                vendored: vendored_typeshed_stubs().clone(),
                 events: sync::Arc::default(),
-                vfs: Vfs::with_stubbed_vendored(),
+                files: Files::default(),
             }
         }
 
-        /// Returns the memory file system.
-        ///
-        /// ## Panics
-        /// If this test db isn't using a memory file system.
-        #[allow(unused)]
-        pub(crate) fn memory_file_system(&self) -> &MemoryFileSystem {
-            if let TestFileSystem::Memory(fs) = &self.file_system {
-                fs
-            } else {
-                panic!("The test db is not using a memory file system");
-            }
-        }
-
-        /// Uses the real file system instead of the memory file system.
-        ///
-        /// This useful for testing advanced file system features like permissions, symlinks, etc.
-        ///
-        /// Note that any files written to the memory file system won't be copied over.
-        #[allow(unused)]
-        pub(crate) fn with_os_file_system(&mut self) {
-            self.file_system = TestFileSystem::Os(OsFileSystem);
-        }
-
-        #[allow(unused)]
-        pub(crate) fn vfs_mut(&mut self) -> &mut Vfs {
-            &mut self.vfs
-        }
-
         /// Takes the salsa events.
         ///
         /// ## Panics
         /// If there are any pending salsa snapshots.
-        #[allow(unused)]
         pub(crate) fn take_salsa_events(&mut self) -> Vec<salsa::Event> {
             let inner = sync::Arc::get_mut(&mut self.events).expect("no pending salsa snapshots");
 
@@ -89,7 +50,6 @@ pub(crate) mod tests {
         ///
         /// ## Panics
         /// If there are any pending salsa snapshots.
-        #[allow(unused)]
         pub(crate) fn clear_salsa_events(&mut self) {
             self.take_salsa_events();
         }
@@ -99,58 +59,47 @@ pub(crate) mod tests {
         fn upcast(&self) -> &(dyn ruff_db::Db + 'static) {
             self
         }
+        fn upcast_mut(&mut self) -> &mut (dyn ruff_db::Db + 'static) {
+            self
+        }
     }
 
+    #[salsa::db]
     impl ruff_db::Db for TestDb {
-        fn file_system(&self) -> &dyn ruff_db::file_system::FileSystem {
-            self.file_system.inner()
+        fn vendored(&self) -> &VendoredFileSystem {
+            &self.vendored
         }
 
-        fn vfs(&self) -> &ruff_db::vfs::Vfs {
-            &self.vfs
+        fn system(&self) -> &dyn ruff_db::system::System {
+            &self.system
+        }
+
+        fn files(&self) -> &Files {
+            &self.files
         }
     }
 
+    #[salsa::db]
     impl Db for TestDb {}
 
+    impl DbWithTestSystem for TestDb {
+        fn test_system(&self) -> &TestSystem {
+            &self.system
+        }
+
+        fn test_system_mut(&mut self) -> &mut TestSystem {
+            &mut self.system
+        }
+    }
+
+    #[salsa::db]
     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()),
-            }
+            self.attach(|_| {
+                tracing::trace!("event: {event:?}");
+                let mut events = self.events.lock().unwrap();
+                events.push(event);
+            });
         }
     }
 }

crates/red_knot_module_resolver/src/lib.rs

@@ -1,9 +1,50 @@
+use std::iter::FusedIterator;
+
+pub use db::Db;
+pub use module::{Module, ModuleKind};
+pub use module_name::ModuleName;
+pub use resolver::resolve_module;
+use ruff_db::system::SystemPath;
+pub use typeshed::{
+    vendored_typeshed_stubs, TypeshedVersionsParseError, TypeshedVersionsParseErrorKind,
+};
+
+use crate::resolver::{module_resolution_settings, SearchPathIterator};
+
 mod db;
 mod module;
+mod module_name;
+mod path;
 mod resolver;
+mod state;
 mod typeshed;
 
-pub use db::{Db, Jar};
-pub use module::{ModuleKind, ModuleName};
-pub use resolver::{resolve_module, set_module_resolution_settings, ModuleResolutionSettings};
-pub use typeshed::versions::TypeshedVersions;
+#[cfg(test)]
+mod testing;
+
+/// Returns an iterator over all search paths pointing to a system path
+pub fn system_module_search_paths(db: &dyn Db) -> SystemModuleSearchPathsIter {
+    SystemModuleSearchPathsIter {
+        inner: module_resolution_settings(db).search_paths(db),
+    }
+}
+
+pub struct SystemModuleSearchPathsIter<'db> {
+    inner: SearchPathIterator<'db>,
+}
+
+impl<'db> Iterator for SystemModuleSearchPathsIter<'db> {
+    type Item = &'db SystemPath;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let next = self.inner.next()?;
+
+            if let Some(system_path) = next.as_system_path() {
+                return Some(system_path);
+            }
+        }
+    }
+}
+
+impl FusedIterator for SystemModuleSearchPathsIter<'_> {}

crates/red_knot_module_resolver/src/module.rs

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

crates/red_knot_module_resolver/src/module_name.rs

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

crates/red_knot_module_resolver/src/state.rs

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

crates/red_knot_module_resolver/src/testing.rs

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

crates/red_knot_module_resolver/src/typeshed.rs

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

crates/red_knot_module_resolver/src/typeshed/vendored.rs

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

crates/red_knot_module_resolver/src/typeshed/versions.rs

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

crates/red_knot_module_resolver/vendor/typeshed/source_commit.txt

@@ -1 +1 @@
-114409d49b43ba62a179ebb856fa70a5161f751e
+4ef2d66663fc080fefa379e6ae5fc45d4f8b54eb

crates/red_knot_module_resolver/vendor/typeshed/stdlib/VERSIONS

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

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

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

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

@@ -1,18 +1,18 @@
 import sys
 from _typeshed import SupportsWrite
 from collections.abc import Iterable, Iterator
-from typing import Any, Final, Literal
+from typing import Any, Final
 from typing_extensions import TypeAlias
 
 __version__: Final[str]
 
-QUOTE_ALL: Literal[1]
-QUOTE_MINIMAL: Literal[0]
-QUOTE_NONE: Literal[3]
-QUOTE_NONNUMERIC: Literal[2]
+QUOTE_ALL: Final = 1
+QUOTE_MINIMAL: Final = 0
+QUOTE_NONE: Final = 3
+QUOTE_NONNUMERIC: Final = 2
 if sys.version_info >= (3, 12):
-    QUOTE_STRINGS: Literal[4]
-    QUOTE_NOTNULL: Literal[5]
+    QUOTE_STRINGS: Final = 4
+    QUOTE_NOTNULL: Final = 5
 
 # Ideally this would be `QUOTE_ALL | QUOTE_MINIMAL | QUOTE_NONE | QUOTE_NONNUMERIC`
 # However, using literals in situations like these can cause false-positives (see #7258)

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

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

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

@@ -368,11 +368,7 @@ def tparm(
 ) -> bytes: ...
 def typeahead(fd: int, /) -> None: ...
 def unctrl(ch: _ChType, /) -> bytes: ...
-
-if sys.version_info < (3, 12) or sys.platform != "darwin":
-    # The support for macos was dropped in 3.12
-    def unget_wch(ch: int | str, /) -> None: ...
-
+def unget_wch(ch: int | str, /) -> None: ...
 def ungetch(ch: _ChType, /) -> None: ...
 def ungetmouse(id: int, x: int, y: int, z: int, bstate: int, /) -> None: ...
 def update_lines_cols() -> None: ...
@@ -447,13 +443,10 @@ class _CursesWindow:
     def getch(self) -> int: ...
     @overload
     def getch(self, y: int, x: int) -> int: ...
-    if sys.version_info < (3, 12) or sys.platform != "darwin":
-        # The support for macos was dropped in 3.12
-        @overload
-        def get_wch(self) -> int | str: ...
-        @overload
-        def get_wch(self, y: int, x: int) -> int | str: ...
-
+    @overload
+    def get_wch(self) -> int | str: ...
+    @overload
+    def get_wch(self, y: int, x: int) -> int | str: ...
     @overload
     def getkey(self) -> str: ...
     @overload

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

@@ -17,20 +17,20 @@ class DecimalTuple(NamedTuple):
     digits: tuple[int, ...]
     exponent: int | Literal["n", "N", "F"]
 
-ROUND_DOWN: str
-ROUND_HALF_UP: str
-ROUND_HALF_EVEN: str
-ROUND_CEILING: str
-ROUND_FLOOR: str
-ROUND_UP: str
-ROUND_HALF_DOWN: str
-ROUND_05UP: str
-HAVE_CONTEXTVAR: bool
-HAVE_THREADS: bool
-MAX_EMAX: int
-MAX_PREC: int
-MIN_EMIN: int
-MIN_ETINY: int
+ROUND_DOWN: Final[str]
+ROUND_HALF_UP: Final[str]
+ROUND_HALF_EVEN: Final[str]
+ROUND_CEILING: Final[str]
+ROUND_FLOOR: Final[str]
+ROUND_UP: Final[str]
+ROUND_HALF_DOWN: Final[str]
+ROUND_05UP: Final[str]
+HAVE_CONTEXTVAR: Final[bool]
+HAVE_THREADS: Final[bool]
+MAX_EMAX: Final[int]
+MAX_PREC: Final[int]
+MIN_EMIN: Final[int]
+MIN_ETINY: Final[int]
 
 class DecimalException(ArithmeticError): ...
 class Clamped(DecimalException): ...

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

@@ -0,0 +1,86 @@
+from _typeshed import structseq
+from typing import Any, 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(unboundop: Literal[1, 2, 3]) -> 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 = ...) -> tuple[Any, Literal[1, 2, 3]]: ...
+def close(cid: SupportsIndex, *, send: bool = False, recv: bool = False) -> None: ...
+def get_count(cid: SupportsIndex) -> int: ...
+def get_info(cid: SupportsIndex) -> ChannelInfo: ...
+def get_channel_defaults(cid: SupportsIndex) -> Literal[1, 2, 3]: ...
+def release(cid: SupportsIndex, *, send: bool = False, recv: bool = False, force: bool = False) -> None: ...

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

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

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

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

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

@@ -1,5 +1,5 @@
 from collections.abc import Iterable, Sequence
-from typing import TypeVar
+from typing import Final, TypeVar
 
 _T = TypeVar("_T")
 _K = TypeVar("_K")
@@ -7,15 +7,15 @@ _V = TypeVar("_V")
 
 __all__ = ["compiler_fixup", "customize_config_vars", "customize_compiler", "get_platform_osx"]
 
-_UNIVERSAL_CONFIG_VARS: tuple[str, ...]  # undocumented
-_COMPILER_CONFIG_VARS: tuple[str, ...]  # undocumented
-_INITPRE: str  # undocumented
+_UNIVERSAL_CONFIG_VARS: Final[tuple[str, ...]]  # undocumented
+_COMPILER_CONFIG_VARS: Final[tuple[str, ...]]  # undocumented
+_INITPRE: Final[str]  # undocumented
 
 def _find_executable(executable: str, path: str | None = None) -> str | None: ...  # undocumented
 def _read_output(commandstring: str, capture_stderr: bool = False) -> str | None: ...  # undocumented
 def _find_build_tool(toolname: str) -> str: ...  # undocumented
 
-_SYSTEM_VERSION: str | None  # undocumented
+_SYSTEM_VERSION: Final[str | None]  # undocumented
 
 def _get_system_version() -> str: ...  # undocumented
 def _remove_original_values(_config_vars: dict[str, str]) -> None: ...  # undocumented

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

@@ -1,30 +1,30 @@
 import sys
-from typing import Literal
+from typing import Final
 
-SF_APPEND: Literal[0x00040000]
-SF_ARCHIVED: Literal[0x00010000]
-SF_IMMUTABLE: Literal[0x00020000]
-SF_NOUNLINK: Literal[0x00100000]
-SF_SNAPSHOT: Literal[0x00200000]
+SF_APPEND: Final = 0x00040000
+SF_ARCHIVED: Final = 0x00010000
+SF_IMMUTABLE: Final = 0x00020000
+SF_NOUNLINK: Final = 0x00100000
+SF_SNAPSHOT: Final = 0x00200000
 
-ST_MODE: Literal[0]
-ST_INO: Literal[1]
-ST_DEV: Literal[2]
-ST_NLINK: Literal[3]
-ST_UID: Literal[4]
-ST_GID: Literal[5]
-ST_SIZE: Literal[6]
-ST_ATIME: Literal[7]
-ST_MTIME: Literal[8]
-ST_CTIME: Literal[9]
+ST_MODE: Final = 0
+ST_INO: Final = 1
+ST_DEV: Final = 2
+ST_NLINK: Final = 3
+ST_UID: Final = 4
+ST_GID: Final = 5
+ST_SIZE: Final = 6
+ST_ATIME: Final = 7
+ST_MTIME: Final = 8
+ST_CTIME: Final = 9
 
-S_IFIFO: Literal[0o010000]
-S_IFLNK: Literal[0o120000]
-S_IFREG: Literal[0o100000]
-S_IFSOCK: Literal[0o140000]
-S_IFBLK: Literal[0o060000]
-S_IFCHR: Literal[0o020000]
-S_IFDIR: Literal[0o040000]
+S_IFIFO: Final = 0o010000
+S_IFLNK: Final = 0o120000
+S_IFREG: Final = 0o100000
+S_IFSOCK: Final = 0o140000
+S_IFBLK: Final = 0o060000
+S_IFCHR: Final = 0o020000
+S_IFDIR: Final = 0o040000
 
 # These are 0 on systems that don't support the specific kind of file.
 # Example: Linux doesn't support door files, so S_IFDOOR is 0 on linux.
@@ -32,37 +32,37 @@ S_IFDOOR: int
 S_IFPORT: int
 S_IFWHT: int
 
-S_ISUID: Literal[0o4000]
-S_ISGID: Literal[0o2000]
-S_ISVTX: Literal[0o1000]
+S_ISUID: Final = 0o4000
+S_ISGID: Final = 0o2000
+S_ISVTX: Final = 0o1000
 
-S_IRWXU: Literal[0o0700]
-S_IRUSR: Literal[0o0400]
-S_IWUSR: Literal[0o0200]
-S_IXUSR: Literal[0o0100]
+S_IRWXU: Final = 0o0700
+S_IRUSR: Final = 0o0400
+S_IWUSR: Final = 0o0200
+S_IXUSR: Final = 0o0100
 
-S_IRWXG: Literal[0o0070]
-S_IRGRP: Literal[0o0040]
-S_IWGRP: Literal[0o0020]
-S_IXGRP: Literal[0o0010]
+S_IRWXG: Final = 0o0070
+S_IRGRP: Final = 0o0040
+S_IWGRP: Final = 0o0020
+S_IXGRP: Final = 0o0010
 
-S_IRWXO: Literal[0o0007]
-S_IROTH: Literal[0o0004]
-S_IWOTH: Literal[0o0002]
-S_IXOTH: Literal[0o0001]
+S_IRWXO: Final = 0o0007
+S_IROTH: Final = 0o0004
+S_IWOTH: Final = 0o0002
+S_IXOTH: Final = 0o0001
 
-S_ENFMT: Literal[0o2000]
-S_IREAD: Literal[0o0400]
-S_IWRITE: Literal[0o0200]
-S_IEXEC: Literal[0o0100]
+S_ENFMT: Final = 0o2000
+S_IREAD: Final = 0o0400
+S_IWRITE: Final = 0o0200
+S_IEXEC: Final = 0o0100
 
-UF_APPEND: Literal[0x00000004]
-UF_COMPRESSED: Literal[0x00000020]  # OS X 10.6+ only
-UF_HIDDEN: Literal[0x00008000]  # OX X 10.5+ only
-UF_IMMUTABLE: Literal[0x00000002]
-UF_NODUMP: Literal[0x00000001]
-UF_NOUNLINK: Literal[0x00000010]
-UF_OPAQUE: Literal[0x00000008]
+UF_APPEND: Final = 0x00000004
+UF_COMPRESSED: Final = 0x00000020  # OS X 10.6+ only
+UF_HIDDEN: Final = 0x00008000  # OX X 10.5+ only
+UF_IMMUTABLE: Final = 0x00000002
+UF_NODUMP: Final = 0x00000001
+UF_NOUNLINK: Final = 0x00000010
+UF_OPAQUE: Final = 0x00000008
 
 def S_IMODE(mode: int, /) -> int: ...
 def S_IFMT(mode: int, /) -> int: ...
@@ -84,34 +84,36 @@ if sys.platform == "win32":
     IO_REPARSE_TAG_APPEXECLINK: int
 
 if sys.platform == "win32":
-    FILE_ATTRIBUTE_ARCHIVE: Literal[32]
-    FILE_ATTRIBUTE_COMPRESSED: Literal[2048]
-    FILE_ATTRIBUTE_DEVICE: Literal[64]
-    FILE_ATTRIBUTE_DIRECTORY: Literal[16]
-    FILE_ATTRIBUTE_ENCRYPTED: Literal[16384]
-    FILE_ATTRIBUTE_HIDDEN: Literal[2]
-    FILE_ATTRIBUTE_INTEGRITY_STREAM: Literal[32768]
-    FILE_ATTRIBUTE_NORMAL: Literal[128]
-    FILE_ATTRIBUTE_NOT_CONTENT_INDEXED: Literal[8192]
-    FILE_ATTRIBUTE_NO_SCRUB_DATA: Literal[131072]
-    FILE_ATTRIBUTE_OFFLINE: Literal[4096]
-    FILE_ATTRIBUTE_READONLY: Literal[1]
-    FILE_ATTRIBUTE_REPARSE_POINT: Literal[1024]
-    FILE_ATTRIBUTE_SPARSE_FILE: Literal[512]
-    FILE_ATTRIBUTE_SYSTEM: Literal[4]
-    FILE_ATTRIBUTE_TEMPORARY: Literal[256]
-    FILE_ATTRIBUTE_VIRTUAL: Literal[65536]
+    FILE_ATTRIBUTE_ARCHIVE: Final = 32
+    FILE_ATTRIBUTE_COMPRESSED: Final = 2048
+    FILE_ATTRIBUTE_DEVICE: Final = 64
+    FILE_ATTRIBUTE_DIRECTORY: Final = 16
+    FILE_ATTRIBUTE_ENCRYPTED: Final = 16384
+    FILE_ATTRIBUTE_HIDDEN: Final = 2
+    FILE_ATTRIBUTE_INTEGRITY_STREAM: Final = 32768
+    FILE_ATTRIBUTE_NORMAL: Final = 128
+    FILE_ATTRIBUTE_NOT_CONTENT_INDEXED: Final = 8192
+    FILE_ATTRIBUTE_NO_SCRUB_DATA: Final = 131072
+    FILE_ATTRIBUTE_OFFLINE: Final = 4096
+    FILE_ATTRIBUTE_READONLY: Final = 1
+    FILE_ATTRIBUTE_REPARSE_POINT: Final = 1024
+    FILE_ATTRIBUTE_SPARSE_FILE: Final = 512
+    FILE_ATTRIBUTE_SYSTEM: Final = 4
+    FILE_ATTRIBUTE_TEMPORARY: Final = 256
+    FILE_ATTRIBUTE_VIRTUAL: Final = 65536
 
 if sys.version_info >= (3, 13):
-    SF_SETTABLE: Literal[0x3FFF0000]
+    # Varies by platform.
+    SF_SETTABLE: Final[int]
     # https://github.com/python/cpython/issues/114081#issuecomment-2119017790
     # SF_RESTRICTED: Literal[0x00080000]
-    SF_FIRMLINK: Literal[0x00800000]
-    SF_DATALESS: Literal[0x40000000]
+    SF_FIRMLINK: Final = 0x00800000
+    SF_DATALESS: Final = 0x40000000
 
-    SF_SUPPORTED: Literal[0x9F0000]
-    SF_SYNTHETIC: Literal[0xC0000000]
+    if sys.platform == "darwin":
+        SF_SUPPORTED: Final = 0x9F0000
+        SF_SYNTHETIC: Final = 0xC0000000
 
-    UF_TRACKED: Literal[0x00000040]
-    UF_DATAVAULT: Literal[0x00000080]
-    UF_SETTABLE: Literal[0x0000FFFF]
+    UF_TRACKED: Final = 0x00000040
+    UF_DATAVAULT: Final = 0x00000080
+    UF_SETTABLE: Final = 0x0000FFFF

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

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

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

@@ -1,6 +1,6 @@
 import sys
 from collections.abc import Callable
-from typing import Any, ClassVar, Literal, final
+from typing import Any, ClassVar, Final, final
 from typing_extensions import TypeAlias
 
 # _tkinter is meant to be only used internally by tkinter, but some tkinter
@@ -95,16 +95,16 @@ class TkappType:
         def settrace(self, func: _TkinterTraceFunc | None, /) -> None: ...
 
 # These should be kept in sync with tkinter.tix constants, except ALL_EVENTS which doesn't match TCL_ALL_EVENTS
-ALL_EVENTS: Literal[-3]
-FILE_EVENTS: Literal[8]
-IDLE_EVENTS: Literal[32]
-TIMER_EVENTS: Literal[16]
-WINDOW_EVENTS: Literal[4]
+ALL_EVENTS: Final = -3
+FILE_EVENTS: Final = 8
+IDLE_EVENTS: Final = 32
+TIMER_EVENTS: Final = 16
+WINDOW_EVENTS: Final = 4
 
-DONT_WAIT: Literal[2]
-EXCEPTION: Literal[8]
-READABLE: Literal[2]
-WRITABLE: Literal[4]
+DONT_WAIT: Final = 2
+EXCEPTION: Final = 8
+READABLE: Final = 2
+WRITABLE: Final = 4
 
 TCL_VERSION: str
 TK_VERSION: str

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

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

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

@@ -1,117 +1,117 @@
 import sys
 from _typeshed import ReadableBuffer
 from collections.abc import Sequence
-from typing import Any, Literal, NoReturn, final, overload
+from typing import Any, Final, Literal, NoReturn, final, overload
 
 if sys.platform == "win32":
-    ABOVE_NORMAL_PRIORITY_CLASS: Literal[0x8000]
-    BELOW_NORMAL_PRIORITY_CLASS: Literal[0x4000]
+    ABOVE_NORMAL_PRIORITY_CLASS: Final = 0x8000
+    BELOW_NORMAL_PRIORITY_CLASS: Final = 0x4000
 
-    CREATE_BREAKAWAY_FROM_JOB: Literal[0x1000000]
-    CREATE_DEFAULT_ERROR_MODE: Literal[0x4000000]
-    CREATE_NO_WINDOW: Literal[0x8000000]
-    CREATE_NEW_CONSOLE: Literal[0x10]
-    CREATE_NEW_PROCESS_GROUP: Literal[0x200]
+    CREATE_BREAKAWAY_FROM_JOB: Final = 0x1000000
+    CREATE_DEFAULT_ERROR_MODE: Final = 0x4000000
+    CREATE_NO_WINDOW: Final = 0x8000000
+    CREATE_NEW_CONSOLE: Final = 0x10
+    CREATE_NEW_PROCESS_GROUP: Final = 0x200
 
-    DETACHED_PROCESS: Literal[8]
-    DUPLICATE_CLOSE_SOURCE: Literal[1]
-    DUPLICATE_SAME_ACCESS: Literal[2]
+    DETACHED_PROCESS: Final = 8
+    DUPLICATE_CLOSE_SOURCE: Final = 1
+    DUPLICATE_SAME_ACCESS: Final = 2
 
-    ERROR_ALREADY_EXISTS: Literal[183]
-    ERROR_BROKEN_PIPE: Literal[109]
-    ERROR_IO_PENDING: Literal[997]
-    ERROR_MORE_DATA: Literal[234]
-    ERROR_NETNAME_DELETED: Literal[64]
-    ERROR_NO_DATA: Literal[232]
-    ERROR_NO_SYSTEM_RESOURCES: Literal[1450]
-    ERROR_OPERATION_ABORTED: Literal[995]
-    ERROR_PIPE_BUSY: Literal[231]
-    ERROR_PIPE_CONNECTED: Literal[535]
-    ERROR_SEM_TIMEOUT: Literal[121]
+    ERROR_ALREADY_EXISTS: Final = 183
+    ERROR_BROKEN_PIPE: Final = 109
+    ERROR_IO_PENDING: Final = 997
+    ERROR_MORE_DATA: Final = 234
+    ERROR_NETNAME_DELETED: Final = 64
+    ERROR_NO_DATA: Final = 232
+    ERROR_NO_SYSTEM_RESOURCES: Final = 1450
+    ERROR_OPERATION_ABORTED: Final = 995
+    ERROR_PIPE_BUSY: Final = 231
+    ERROR_PIPE_CONNECTED: Final = 535
+    ERROR_SEM_TIMEOUT: Final = 121
 
-    FILE_FLAG_FIRST_PIPE_INSTANCE: Literal[0x80000]
-    FILE_FLAG_OVERLAPPED: Literal[0x40000000]
+    FILE_FLAG_FIRST_PIPE_INSTANCE: Final = 0x80000
+    FILE_FLAG_OVERLAPPED: Final = 0x40000000
 
-    FILE_GENERIC_READ: Literal[1179785]
-    FILE_GENERIC_WRITE: Literal[1179926]
+    FILE_GENERIC_READ: Final = 1179785
+    FILE_GENERIC_WRITE: Final = 1179926
 
-    FILE_MAP_ALL_ACCESS: Literal[983071]
-    FILE_MAP_COPY: Literal[1]
-    FILE_MAP_EXECUTE: Literal[32]
-    FILE_MAP_READ: Literal[4]
-    FILE_MAP_WRITE: Literal[2]
+    FILE_MAP_ALL_ACCESS: Final = 983071
+    FILE_MAP_COPY: Final = 1
+    FILE_MAP_EXECUTE: Final = 32
+    FILE_MAP_READ: Final = 4
+    FILE_MAP_WRITE: Final = 2
 
-    FILE_TYPE_CHAR: Literal[2]
-    FILE_TYPE_DISK: Literal[1]
-    FILE_TYPE_PIPE: Literal[3]
-    FILE_TYPE_REMOTE: Literal[32768]
-    FILE_TYPE_UNKNOWN: Literal[0]
+    FILE_TYPE_CHAR: Final = 2
+    FILE_TYPE_DISK: Final = 1
+    FILE_TYPE_PIPE: Final = 3
+    FILE_TYPE_REMOTE: Final = 32768
+    FILE_TYPE_UNKNOWN: Final = 0
 
-    GENERIC_READ: Literal[0x80000000]
-    GENERIC_WRITE: Literal[0x40000000]
-    HIGH_PRIORITY_CLASS: Literal[0x80]
-    INFINITE: Literal[0xFFFFFFFF]
+    GENERIC_READ: Final = 0x80000000
+    GENERIC_WRITE: Final = 0x40000000
+    HIGH_PRIORITY_CLASS: Final = 0x80
+    INFINITE: Final = 0xFFFFFFFF
     # Ignore the Flake8 error -- flake8-pyi assumes
     # most numbers this long will be implementation details,
     # but here we can see that it's a power of 2
-    INVALID_HANDLE_VALUE: Literal[0xFFFFFFFFFFFFFFFF]  # noqa: Y054
-    IDLE_PRIORITY_CLASS: Literal[0x40]
-    NORMAL_PRIORITY_CLASS: Literal[0x20]
-    REALTIME_PRIORITY_CLASS: Literal[0x100]
-    NMPWAIT_WAIT_FOREVER: Literal[0xFFFFFFFF]
+    INVALID_HANDLE_VALUE: Final = 0xFFFFFFFFFFFFFFFF  # noqa: Y054
+    IDLE_PRIORITY_CLASS: Final = 0x40
+    NORMAL_PRIORITY_CLASS: Final = 0x20
+    REALTIME_PRIORITY_CLASS: Final = 0x100
+    NMPWAIT_WAIT_FOREVER: Final = 0xFFFFFFFF
 
-    MEM_COMMIT: Literal[0x1000]
-    MEM_FREE: Literal[0x10000]
-    MEM_IMAGE: Literal[0x1000000]
-    MEM_MAPPED: Literal[0x40000]
-    MEM_PRIVATE: Literal[0x20000]
-    MEM_RESERVE: Literal[0x2000]
+    MEM_COMMIT: Final = 0x1000
+    MEM_FREE: Final = 0x10000
+    MEM_IMAGE: Final = 0x1000000
+    MEM_MAPPED: Final = 0x40000
+    MEM_PRIVATE: Final = 0x20000
+    MEM_RESERVE: Final = 0x2000
 
-    NULL: Literal[0]
-    OPEN_EXISTING: Literal[3]
+    NULL: Final = 0
+    OPEN_EXISTING: Final = 3
 
-    PIPE_ACCESS_DUPLEX: Literal[3]
-    PIPE_ACCESS_INBOUND: Literal[1]
-    PIPE_READMODE_MESSAGE: Literal[2]
-    PIPE_TYPE_MESSAGE: Literal[4]
-    PIPE_UNLIMITED_INSTANCES: Literal[255]
-    PIPE_WAIT: Literal[0]
+    PIPE_ACCESS_DUPLEX: Final = 3
+    PIPE_ACCESS_INBOUND: Final = 1
+    PIPE_READMODE_MESSAGE: Final = 2
+    PIPE_TYPE_MESSAGE: Final = 4
+    PIPE_UNLIMITED_INSTANCES: Final = 255
+    PIPE_WAIT: Final = 0
 
-    PAGE_EXECUTE: Literal[0x10]
-    PAGE_EXECUTE_READ: Literal[0x20]
-    PAGE_EXECUTE_READWRITE: Literal[0x40]
-    PAGE_EXECUTE_WRITECOPY: Literal[0x80]
-    PAGE_GUARD: Literal[0x100]
-    PAGE_NOACCESS: Literal[0x1]
-    PAGE_NOCACHE: Literal[0x200]
-    PAGE_READONLY: Literal[0x2]
-    PAGE_READWRITE: Literal[0x4]
-    PAGE_WRITECOMBINE: Literal[0x400]
-    PAGE_WRITECOPY: Literal[0x8]
+    PAGE_EXECUTE: Final = 0x10
+    PAGE_EXECUTE_READ: Final = 0x20
+    PAGE_EXECUTE_READWRITE: Final = 0x40
+    PAGE_EXECUTE_WRITECOPY: Final = 0x80
+    PAGE_GUARD: Final = 0x100
+    PAGE_NOACCESS: Final = 0x1
+    PAGE_NOCACHE: Final = 0x200
+    PAGE_READONLY: Final = 0x2
+    PAGE_READWRITE: Final = 0x4
+    PAGE_WRITECOMBINE: Final = 0x400
+    PAGE_WRITECOPY: Final = 0x8
 
-    PROCESS_ALL_ACCESS: Literal[0x1FFFFF]
-    PROCESS_DUP_HANDLE: Literal[0x40]
+    PROCESS_ALL_ACCESS: Final = 0x1FFFFF
+    PROCESS_DUP_HANDLE: Final = 0x40
 
-    SEC_COMMIT: Literal[0x8000000]
-    SEC_IMAGE: Literal[0x1000000]
-    SEC_LARGE_PAGES: Literal[0x80000000]
-    SEC_NOCACHE: Literal[0x10000000]
-    SEC_RESERVE: Literal[0x4000000]
-    SEC_WRITECOMBINE: Literal[0x40000000]
+    SEC_COMMIT: Final = 0x8000000
+    SEC_IMAGE: Final = 0x1000000
+    SEC_LARGE_PAGES: Final = 0x80000000
+    SEC_NOCACHE: Final = 0x10000000
+    SEC_RESERVE: Final = 0x4000000
+    SEC_WRITECOMBINE: Final = 0x40000000
 
-    STARTF_USESHOWWINDOW: Literal[0x1]
-    STARTF_USESTDHANDLES: Literal[0x100]
+    STARTF_USESHOWWINDOW: Final = 0x1
+    STARTF_USESTDHANDLES: Final = 0x100
 
-    STD_ERROR_HANDLE: Literal[0xFFFFFFF4]
-    STD_OUTPUT_HANDLE: Literal[0xFFFFFFF5]
-    STD_INPUT_HANDLE: Literal[0xFFFFFFF6]
+    STD_ERROR_HANDLE: Final = 0xFFFFFFF4
+    STD_OUTPUT_HANDLE: Final = 0xFFFFFFF5
+    STD_INPUT_HANDLE: Final = 0xFFFFFFF6
 
-    STILL_ACTIVE: Literal[259]
-    SW_HIDE: Literal[0]
-    SYNCHRONIZE: Literal[0x100000]
-    WAIT_ABANDONED_0: Literal[128]
-    WAIT_OBJECT_0: Literal[0]
-    WAIT_TIMEOUT: Literal[258]
+    STILL_ACTIVE: Final = 259
+    SW_HIDE: Final = 0
+    SYNCHRONIZE: Final = 0x100000
+    WAIT_ABANDONED_0: Final = 128
+    WAIT_OBJECT_0: Final = 0
+    WAIT_TIMEOUT: Final = 258
 
     if sys.version_info >= (3, 10):
         LOCALE_NAME_INVARIANT: str
@@ -131,32 +131,32 @@ if sys.platform == "win32":
         LCMAP_UPPERCASE: int
 
     if sys.version_info >= (3, 12):
-        COPYFILE2_CALLBACK_CHUNK_STARTED: Literal[1]
-        COPYFILE2_CALLBACK_CHUNK_FINISHED: Literal[2]
-        COPYFILE2_CALLBACK_STREAM_STARTED: Literal[3]
-        COPYFILE2_CALLBACK_STREAM_FINISHED: Literal[4]
-        COPYFILE2_CALLBACK_POLL_CONTINUE: Literal[5]
-        COPYFILE2_CALLBACK_ERROR: Literal[6]
+        COPYFILE2_CALLBACK_CHUNK_STARTED: Final = 1
+        COPYFILE2_CALLBACK_CHUNK_FINISHED: Final = 2
+        COPYFILE2_CALLBACK_STREAM_STARTED: Final = 3
+        COPYFILE2_CALLBACK_STREAM_FINISHED: Final = 4
+        COPYFILE2_CALLBACK_POLL_CONTINUE: Final = 5
+        COPYFILE2_CALLBACK_ERROR: Final = 6
 
-        COPYFILE2_PROGRESS_CONTINUE: Literal[0]
-        COPYFILE2_PROGRESS_CANCEL: Literal[1]
-        COPYFILE2_PROGRESS_STOP: Literal[2]
-        COPYFILE2_PROGRESS_QUIET: Literal[3]
-        COPYFILE2_PROGRESS_PAUSE: Literal[4]
+        COPYFILE2_PROGRESS_CONTINUE: Final = 0
+        COPYFILE2_PROGRESS_CANCEL: Final = 1
+        COPYFILE2_PROGRESS_STOP: Final = 2
+        COPYFILE2_PROGRESS_QUIET: Final = 3
+        COPYFILE2_PROGRESS_PAUSE: Final = 4
 
-        COPY_FILE_FAIL_IF_EXISTS: Literal[0x1]
-        COPY_FILE_RESTARTABLE: Literal[0x2]
-        COPY_FILE_OPEN_SOURCE_FOR_WRITE: Literal[0x4]
-        COPY_FILE_ALLOW_DECRYPTED_DESTINATION: Literal[0x8]
-        COPY_FILE_COPY_SYMLINK: Literal[0x800]
-        COPY_FILE_NO_BUFFERING: Literal[0x1000]
-        COPY_FILE_REQUEST_SECURITY_PRIVILEGES: Literal[0x2000]
-        COPY_FILE_RESUME_FROM_PAUSE: Literal[0x4000]
-        COPY_FILE_NO_OFFLOAD: Literal[0x40000]
-        COPY_FILE_REQUEST_COMPRESSED_TRAFFIC: Literal[0x10000000]
+        COPY_FILE_FAIL_IF_EXISTS: Final = 0x1
+        COPY_FILE_RESTARTABLE: Final = 0x2
+        COPY_FILE_OPEN_SOURCE_FOR_WRITE: Final = 0x4
+        COPY_FILE_ALLOW_DECRYPTED_DESTINATION: Final = 0x8
+        COPY_FILE_COPY_SYMLINK: Final = 0x800
+        COPY_FILE_NO_BUFFERING: Final = 0x1000
+        COPY_FILE_REQUEST_SECURITY_PRIVILEGES: Final = 0x2000
+        COPY_FILE_RESUME_FROM_PAUSE: Final = 0x4000
+        COPY_FILE_NO_OFFLOAD: Final = 0x40000
+        COPY_FILE_REQUEST_COMPRESSED_TRAFFIC: Final = 0x10000000
 
-        ERROR_ACCESS_DENIED: Literal[5]
-        ERROR_PRIVILEGE_NOT_HELD: Literal[1314]
+        ERROR_ACCESS_DENIED: Final = 5
+        ERROR_PRIVILEGE_NOT_HELD: Final = 1314
 
     def CloseHandle(handle: int, /) -> None: ...
     @overload

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

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

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

@@ -2,7 +2,7 @@ import sys
 from _typeshed import sentinel
 from collections.abc import Callable, Generator, Iterable, Sequence
 from re import Pattern
-from typing import IO, Any, Generic, Literal, NewType, NoReturn, Protocol, TypeVar, overload
+from typing import IO, Any, Final, Generic, NewType, NoReturn, Protocol, TypeVar, overload
 from typing_extensions import Self, TypeAlias, deprecated
 
 __all__ = [
@@ -32,6 +32,7 @@ _T = TypeVar("_T")
 _ActionT = TypeVar("_ActionT", bound=Action)
 _ArgumentParserT = TypeVar("_ArgumentParserT", bound=ArgumentParser)
 _N = TypeVar("_N")
+_ActionType: TypeAlias = Callable[[str], Any] | FileType | str
 # more precisely, Literal["store", "store_const", "store_true",
 # "store_false", "append", "append_const", "count", "help", "version",
 # "extend"], but using this would make it hard to annotate callers
@@ -42,15 +43,15 @@ _ActionStr: TypeAlias = str
 # callers that don't use a literal argument
 _NArgsStr: TypeAlias = str
 
-ONE_OR_MORE: Literal["+"]
-OPTIONAL: Literal["?"]
-PARSER: Literal["A..."]
-REMAINDER: Literal["..."]
+ONE_OR_MORE: Final = "+"
+OPTIONAL: Final = "?"
+PARSER: Final = "A..."
+REMAINDER: Final = "..."
 _SUPPRESS_T = NewType("_SUPPRESS_T", str)
 SUPPRESS: _SUPPRESS_T | str  # not using Literal because argparse sometimes compares SUPPRESS with is
 # the | str is there so that foo = argparse.SUPPRESS; foo = "test" checks out in mypy
-ZERO_OR_MORE: Literal["*"]
-_UNRECOGNIZED_ARGS_ATTR: str  # undocumented
+ZERO_OR_MORE: Final = "*"
+_UNRECOGNIZED_ARGS_ATTR: Final[str]  # undocumented
 
 class ArgumentError(Exception):
     argument_name: str | None
@@ -89,7 +90,7 @@ class _ActionsContainer:
         nargs: int | _NArgsStr | _SUPPRESS_T | None = None,
         const: Any = ...,
         default: Any = ...,
-        type: Callable[[str], _T] | FileType = ...,
+        type: _ActionType = ...,
         choices: Iterable[_T] | None = ...,
         required: bool = ...,
         help: str | None = ...,
@@ -313,7 +314,7 @@ class Action(_AttributeHolder):
     nargs: int | str | None
     const: Any
     default: Any
-    type: Callable[[str], Any] | FileType | None
+    type: _ActionType | None
     choices: Iterable[Any] | None
     required: bool
     help: str | None
@@ -699,6 +700,7 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             add_help: bool = ...,
             allow_abbrev: bool = ...,
             exit_on_error: bool = ...,
+            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
     elif sys.version_info >= (3, 9):
         def add_parser(
@@ -721,6 +723,7 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             add_help: bool = ...,
             allow_abbrev: bool = ...,
             exit_on_error: bool = ...,
+            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
     else:
         def add_parser(
@@ -742,6 +745,7 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             conflict_handler: str = ...,
             add_help: bool = ...,
             allow_abbrev: bool = ...,
+            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
 
     def _get_subactions(self) -> list[Action]: ...

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

@@ -49,6 +49,10 @@ class Server(AbstractServer):
             ssl_handshake_timeout: float | None,
         ) -> None: ...
 
+    if sys.version_info >= (3, 13):
+        def close_clients(self) -> None: ...
+        def abort_clients(self) -> None: ...
+
     def get_loop(self) -> AbstractEventLoop: ...
     def is_serving(self) -> bool: ...
     async def start_serving(self) -> None: ...
@@ -222,7 +226,48 @@ class BaseEventLoop(AbstractEventLoop):
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
-    if sys.version_info >= (3, 11):
+
+    if sys.version_info >= (3, 13):
+        # 3.13 added `keep_alive`.
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str | Sequence[str] | None = None,
+            port: int = ...,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: None = None,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            keep_alive: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = None,
+            port: None = None,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: socket = ...,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            keep_alive: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+    elif sys.version_info >= (3, 11):
         @overload
         async def create_server(
             self,
@@ -259,26 +304,6 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_shutdown_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
-        async def start_tls(
-            self,
-            transport: BaseTransport,
-            protocol: BaseProtocol,
-            sslcontext: ssl.SSLContext,
-            *,
-            server_side: bool = False,
-            server_hostname: str | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-        ) -> Transport | None: ...
-        async def connect_accepted_socket(
-            self,
-            protocol_factory: Callable[[], _ProtocolT],
-            sock: socket,
-            *,
-            ssl: _SSLContext = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-        ) -> tuple[Transport, _ProtocolT]: ...
     else:
         @overload
         async def create_server(
@@ -314,6 +339,29 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_handshake_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
+
+    if sys.version_info >= (3, 11):
+        async def start_tls(
+            self,
+            transport: BaseTransport,
+            protocol: BaseProtocol,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_side: bool = False,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> Transport | None: ...
+        async def connect_accepted_socket(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            sock: socket,
+            *,
+            ssl: _SSLContext = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> tuple[Transport, _ProtocolT]: ...
+    else:
         async def start_tls(
             self,
             transport: BaseTransport,

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

@@ -1,6 +1,6 @@
 from collections.abc import Callable, Sequence
 from contextvars import Context
-from typing import Any, Literal
+from typing import Any, Final
 
 from . import futures
 
@@ -11,9 +11,9 @@ __all__ = ()
 # That's why the import order is reversed.
 from .futures import isfuture as isfuture
 
-_PENDING: Literal["PENDING"]  # undocumented
-_CANCELLED: Literal["CANCELLED"]  # undocumented
-_FINISHED: Literal["FINISHED"]  # undocumented
+_PENDING: Final = "PENDING"  # undocumented
+_CANCELLED: Final = "CANCELLED"  # undocumented
+_FINISHED: Final = "FINISHED"  # undocumented
 
 def _format_callbacks(cb: Sequence[tuple[Callable[[futures.Future[Any]], None], Context]]) -> str: ...  # undocumented
 def _future_repr_info(future: futures.Future[Any]) -> list[str]: ...  # undocumented

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

@@ -1,18 +1,18 @@
 import enum
 import sys
-from typing import Literal
+from typing import Final
 
-LOG_THRESHOLD_FOR_CONNLOST_WRITES: Literal[5]
-ACCEPT_RETRY_DELAY: Literal[1]
-DEBUG_STACK_DEPTH: Literal[10]
+LOG_THRESHOLD_FOR_CONNLOST_WRITES: Final = 5
+ACCEPT_RETRY_DELAY: Final = 1
+DEBUG_STACK_DEPTH: Final = 10
 SSL_HANDSHAKE_TIMEOUT: float
-SENDFILE_FALLBACK_READBUFFER_SIZE: Literal[262144]
+SENDFILE_FALLBACK_READBUFFER_SIZE: Final = 262144
 if sys.version_info >= (3, 11):
     SSL_SHUTDOWN_TIMEOUT: float
-    FLOW_CONTROL_HIGH_WATER_SSL_READ: Literal[256]
-    FLOW_CONTROL_HIGH_WATER_SSL_WRITE: Literal[512]
+    FLOW_CONTROL_HIGH_WATER_SSL_READ: Final = 256
+    FLOW_CONTROL_HIGH_WATER_SSL_WRITE: Final = 512
 if sys.version_info >= (3, 12):
-    THREAD_JOIN_TIMEOUT: Literal[300]
+    THREAD_JOIN_TIMEOUT: Final = 300
 
 class _SendfileMode(enum.Enum):
     UNSUPPORTED = 1

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

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

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

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

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

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

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

@@ -3,7 +3,7 @@ import sys
 from collections import deque
 from collections.abc import Callable
 from enum import Enum
-from typing import Any, ClassVar, Literal
+from typing import Any, ClassVar, Final, Literal
 from typing_extensions import TypeAlias
 
 from . import constants, events, futures, protocols, transports
@@ -29,10 +29,10 @@ if sys.version_info >= (3, 11):
     def add_flowcontrol_defaults(high: int | None, low: int | None, kb: int) -> tuple[int, int]: ...
 
 else:
-    _UNWRAPPED: Literal["UNWRAPPED"]
-    _DO_HANDSHAKE: Literal["DO_HANDSHAKE"]
-    _WRAPPED: Literal["WRAPPED"]
-    _SHUTDOWN: Literal["SHUTDOWN"]
+    _UNWRAPPED: Final = "UNWRAPPED"
+    _DO_HANDSHAKE: Final = "DO_HANDSHAKE"
+    _WRAPPED: Final = "WRAPPED"
+    _SHUTDOWN: Final = "SHUTDOWN"
 
 if sys.version_info < (3, 11):
     class _SSLPipe:

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

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

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

@@ -70,7 +70,10 @@ _T4 = TypeVar("_T4")
 _T5 = TypeVar("_T5")
 _T6 = TypeVar("_T6")
 _FT = TypeVar("_FT", bound=Future[Any])
-_FutureLike: TypeAlias = Future[_T] | Generator[Any, None, _T] | Awaitable[_T]
+if sys.version_info >= (3, 12):
+    _FutureLike: TypeAlias = Future[_T] | Awaitable[_T]
+else:
+    _FutureLike: TypeAlias = Future[_T] | Generator[Any, None, _T] | Awaitable[_T]
 _TaskYieldType: TypeAlias = Future[object] | None
 
 FIRST_COMPLETED = concurrent.futures.FIRST_COMPLETED
@@ -426,7 +429,11 @@ class Task(Future[_T_co]):  # type: ignore[type-var]  # pyright: ignore[reportIn
             self, coro: _TaskCompatibleCoro[_T_co], *, loop: AbstractEventLoop = ..., name: str | None = ...
         ) -> None: ...
 
-    def get_coro(self) -> _TaskCompatibleCoro[_T_co]: ...
+    if sys.version_info >= (3, 12):
+        def get_coro(self) -> _TaskCompatibleCoro[_T_co] | None: ...
+    else:
+        def get_coro(self) -> _TaskCompatibleCoro[_T_co]: ...
+
     def get_name(self) -> str: ...
     def set_name(self, value: object, /) -> None: ...
     if sys.version_info >= (3, 12):

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

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

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

@@ -2,24 +2,36 @@ import socket
 import sys
 from _typeshed import Incomplete, ReadableBuffer, WriteableBuffer
 from collections.abc import Callable
-from typing import IO, Any, ClassVar, Literal, NoReturn
+from typing import IO, Any, ClassVar, Final, NoReturn
 
 from . import events, futures, proactor_events, selector_events, streams, windows_utils
 
 if sys.platform == "win32":
-    __all__ = (
-        "SelectorEventLoop",
-        "ProactorEventLoop",
-        "IocpProactor",
-        "DefaultEventLoopPolicy",
-        "WindowsSelectorEventLoopPolicy",
-        "WindowsProactorEventLoopPolicy",
-    )
+    if sys.version_info >= (3, 13):
+        # 3.13 added `EventLoop`.
+        __all__ = (
+            "SelectorEventLoop",
+            "ProactorEventLoop",
+            "IocpProactor",
+            "DefaultEventLoopPolicy",
+            "WindowsSelectorEventLoopPolicy",
+            "WindowsProactorEventLoopPolicy",
+            "EventLoop",
+        )
+    else:
+        __all__ = (
+            "SelectorEventLoop",
+            "ProactorEventLoop",
+            "IocpProactor",
+            "DefaultEventLoopPolicy",
+            "WindowsSelectorEventLoopPolicy",
+            "WindowsProactorEventLoopPolicy",
+        )
 
-    NULL: Literal[0]
-    INFINITE: Literal[0xFFFFFFFF]
-    ERROR_CONNECTION_REFUSED: Literal[1225]
-    ERROR_CONNECTION_ABORTED: Literal[1236]
+    NULL: Final = 0
+    INFINITE: Final = 0xFFFFFFFF
+    ERROR_CONNECTION_REFUSED: Final = 1225
+    ERROR_CONNECTION_ABORTED: Final = 1236
     CONNECT_PIPE_INIT_DELAY: float
     CONNECT_PIPE_MAX_DELAY: float
 
@@ -74,8 +86,9 @@ if sys.platform == "win32":
 
     class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
         _loop_factory: ClassVar[type[SelectorEventLoop]]
-        def get_child_watcher(self) -> NoReturn: ...
-        def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+        if sys.version_info < (3, 14):
+            def get_child_watcher(self) -> NoReturn: ...
+            def set_child_watcher(self, watcher: Any) -> NoReturn: ...
 
     class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
         _loop_factory: ClassVar[type[ProactorEventLoop]]
@@ -83,3 +96,5 @@ if sys.platform == "win32":
         def set_child_watcher(self, watcher: Any) -> NoReturn: ...
 
     DefaultEventLoopPolicy = WindowsSelectorEventLoopPolicy
+    if sys.version_info >= (3, 13):
+        EventLoop = ProactorEventLoop

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

@@ -2,13 +2,13 @@ import subprocess
 import sys
 from collections.abc import Callable
 from types import TracebackType
-from typing import Any, AnyStr, Literal
+from typing import Any, AnyStr, Final
 from typing_extensions import Self
 
 if sys.platform == "win32":
     __all__ = ("pipe", "Popen", "PIPE", "PipeHandle")
 
-    BUFSIZE: Literal[8192]
+    BUFSIZE: Final = 8192
     PIPE = subprocess.PIPE
     STDOUT = subprocess.STDOUT
     def pipe(*, duplex: bool = False, overlapped: tuple[bool, bool] = (True, True), bufsize: int = 8192) -> tuple[int, int]: ...

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

@@ -1,8 +1,8 @@
 import sys
-from _typeshed import ExcInfo, TraceFunction
+from _typeshed import ExcInfo, TraceFunction, Unused
 from collections.abc import Callable, Iterable, Mapping
 from types import CodeType, FrameType, TracebackType
-from typing import IO, Any, Literal, SupportsInt, TypeVar
+from typing import IO, Any, Final, SupportsInt, TypeVar
 from typing_extensions import ParamSpec
 
 __all__ = ["BdbQuit", "Bdb", "Breakpoint"]
@@ -10,7 +10,10 @@ __all__ = ["BdbQuit", "Bdb", "Breakpoint"]
 _T = TypeVar("_T")
 _P = ParamSpec("_P")
 
-GENERATOR_AND_COROUTINE_FLAGS: Literal[672]
+# A union of code-object flags at runtime.
+# The exact values of code-object flags are implementation details,
+# so we don't include the value of this constant in the stubs.
+GENERATOR_AND_COROUTINE_FLAGS: Final[int]
 
 class BdbQuit(Exception): ...
 
@@ -32,6 +35,9 @@ class Bdb:
     def dispatch_call(self, frame: FrameType, arg: None) -> TraceFunction: ...
     def dispatch_return(self, frame: FrameType, arg: Any) -> TraceFunction: ...
     def dispatch_exception(self, frame: FrameType, arg: ExcInfo) -> TraceFunction: ...
+    if sys.version_info >= (3, 13):
+        def dispatch_opcode(self, frame: FrameType, arg: Unused) -> Callable[[FrameType, str, Any], TraceFunction]: ...
+
     def is_skipped_module(self, module_name: str) -> bool: ...
     def stop_here(self, frame: FrameType) -> bool: ...
     def break_here(self, frame: FrameType) -> bool: ...
@@ -42,7 +48,13 @@ class Bdb:
     def user_return(self, frame: FrameType, return_value: Any) -> None: ...
     def user_exception(self, frame: FrameType, exc_info: ExcInfo) -> None: ...
     def set_until(self, frame: FrameType, lineno: int | None = None) -> None: ...
+    if sys.version_info >= (3, 13):
+        def user_opcode(self, frame: FrameType) -> None: ...  # undocumented
+
     def set_step(self) -> None: ...
+    if sys.version_info >= (3, 13):
+        def set_stepinstr(self) -> None: ...  # undocumented
+
     def set_next(self, frame: FrameType) -> None: ...
     def set_return(self, frame: FrameType) -> None: ...
     def set_trace(self, frame: FrameType | None = None) -> None: ...

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

@@ -1,14 +1,14 @@
 from _typeshed import SizedBuffer
-from typing import IO, Any, Literal
+from typing import IO, Any, Final
 from typing_extensions import TypeAlias
 
 __all__ = ["binhex", "hexbin", "Error"]
 
 class Error(Exception): ...
 
-REASONABLY_LARGE: Literal[32768]
-LINELEN: Literal[64]
-RUNCHAR: Literal[b"\x90"]
+REASONABLY_LARGE: Final = 32768
+LINELEN: Final = 64
+RUNCHAR: Final = b"\x90"
 
 class FInfo:
     Type: str

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

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

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

@@ -1,9 +1,9 @@
 from collections.abc import Callable
-from typing import IO, Any, Literal
+from typing import IO, Any, Final
 
 __all__ = ["Cmd"]
 
-PROMPT: Literal["(Cmd) "]
+PROMPT: Final = "(Cmd) "
 IDENTCHARS: str  # Too big to be `Literal`
 
 class Cmd: