Move gate

Fixes CI errors seen in
https://github.com/astral-sh/ruff/pull/12224#issuecomment-2212594024

x-ref
17b3644f64

.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/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/publish-docs.yml

@@ -1,3 +1,7 @@
+# Publish the Ruff documentation.
+#
+# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a post-announce
+# job within `cargo-dist`.
 name: mkdocs
 
 on:
@@ -7,8 +11,11 @@ on:
         description: "The commit SHA, tag, or branch to publish. Uses the default branch if not specified."
         default: ""
         type: string
-  release:
-    types: [published]
+  workflow_call:
+    inputs:
+      plan:
+        required: true
+        type: string
 
 jobs:
   mkdocs:
@@ -47,7 +54,7 @@ jobs:
         run: mkdocs build --strict -f mkdocs.public.yml
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.6.1
+        uses: cloudflare/wrangler-action@v3.7.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/publish-playground.yml

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

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

.pre-commit-config.yaml

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

.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,178 @@
 # Changelog
 
+## 0.5.1
+
+### Preview features
+
+- \[`flake8-bugbear`\] Implement mutable-contextvar-default (B039) ([#12113](https://github.com/astral-sh/ruff/pull/12113))
+- \[`pycodestyle`\] Whitespace after decorator (`E204`) ([#12140](https://github.com/astral-sh/ruff/pull/12140))
+- \[`pytest`\] Reverse `PT001` and `PT0023` defaults ([#12106](https://github.com/astral-sh/ruff/pull/12106))
+
+### Rule changes
+
+- Enable token-based rules on source with syntax errors ([#11950](https://github.com/astral-sh/ruff/pull/11950))
+- \[`flake8-bandit`\] Detect `httpx` for `S113` ([#12174](https://github.com/astral-sh/ruff/pull/12174))
+- \[`numpy`\] Update `NPY201` to include exception deprecations ([#12065](https://github.com/astral-sh/ruff/pull/12065))
+- \[`pylint`\] Generate autofix for `duplicate-bases` (`PLE0241`) ([#12105](https://github.com/astral-sh/ruff/pull/12105))
+
+### Server
+
+- Avoid syntax error notification for source code actions ([#12148](https://github.com/astral-sh/ruff/pull/12148))
+- Consider the content of the new cells during notebook sync ([#12203](https://github.com/astral-sh/ruff/pull/12203))
+- Fix replacement edit range computation ([#12171](https://github.com/astral-sh/ruff/pull/12171))
+
+### Bug fixes
+
+- Disable auto-fix when source has syntax errors ([#12134](https://github.com/astral-sh/ruff/pull/12134))
+- Fix cache key collisions for paths with separators ([#12159](https://github.com/astral-sh/ruff/pull/12159))
+- Make `requires-python` inference robust to `==` ([#12091](https://github.com/astral-sh/ruff/pull/12091))
+- Use char-wise width instead of `str`-width ([#12135](https://github.com/astral-sh/ruff/pull/12135))
+- \[`pycodestyle`\] Avoid `E275` if keyword followed by comma ([#12136](https://github.com/astral-sh/ruff/pull/12136))
+- \[`pycodestyle`\] Avoid `E275` if keyword is followed by a semicolon ([#12095](https://github.com/astral-sh/ruff/pull/12095))
+- \[`pylint`\] Skip [dummy variables](https://docs.astral.sh/ruff/settings/#lint_dummy-variable-rgx) for `PLR1704` ([#12190](https://github.com/astral-sh/ruff/pull/12190))
+
+### Performance
+
+- Remove allocation in `parse_identifier` ([#12103](https://github.com/astral-sh/ruff/pull/12103))
+- Use `CompactString` for `Identifier` AST node ([#12101](https://github.com/astral-sh/ruff/pull/12101))
+
+## 0.5.0
+
+Check out the [blog post](https://astral.sh/blog/ruff-v0.5.0) for a migration guide and overview of the changes!
+
+### Breaking changes
+
+See also, the "Remapped rules" section which may result in disabled rules.
+
+- Follow the XDG specification to discover user-level configurations on macOS (same as on other Unix platforms)
+- Selecting `ALL` now excludes deprecated rules
+- The released archives now include an extra level of nesting, which can be removed with `--strip-components=1` when untarring.
+- The release artifact's file name no longer includes the version tag. This enables users to install via `/latest` URLs on GitHub.
+- The diagnostic ranges for some `flake8-bandit` rules were modified ([#10667](https://github.com/astral-sh/ruff/pull/10667)).
+
+### Deprecations
+
+The following rules are now deprecated:
+
+- [`syntax-error`](https://docs.astral.sh/ruff/rules/syntax-error/) (`E999`): Syntax errors are now always shown
+
+### Remapped rules
+
+The following rules have been remapped to new rule codes:
+
+- [`blocking-http-call-in-async-function`](https://docs.astral.sh/ruff/rules/blocking-http-call-in-async-function/): `ASYNC100` to `ASYNC210`
+- [`open-sleep-or-subprocess-in-async-function`](https://docs.astral.sh/ruff/rules/open-sleep-or-subprocess-in-async-function/): `ASYNC101` split into `ASYNC220`, `ASYNC221`, `ASYNC230`, and `ASYNC251`
+- [`blocking-os-call-in-async-function`](https://docs.astral.sh/ruff/rules/blocking-os-call-in-async-function/): `ASYNC102` has been merged into `ASYNC220` and `ASYNC221`
+- [`trio-timeout-without-await`](https://docs.astral.sh/ruff/rules/trio-timeout-without-await/): `TRIO100` to `ASYNC100`
+- [`trio-sync-call`](https://docs.astral.sh/ruff/rules/trio-sync-call/): `TRIO105` to `ASYNC105`
+- [`trio-async-function-with-timeout`](https://docs.astral.sh/ruff/rules/trio-async-function-with-timeout/): `TRIO109` to `ASYNC109`
+- [`trio-unneeded-sleep`](https://docs.astral.sh/ruff/rules/trio-unneeded-sleep/): `TRIO110` to `ASYNC110`
+- [`trio-zero-sleep-call`](https://docs.astral.sh/ruff/rules/trio-zero-sleep-call/): `TRIO115` to `ASYNC115`
+- [`repeated-isinstance-calls`](https://docs.astral.sh/ruff/rules/repeated-isinstance-calls/): `PLR1701` to `SIM101`
+
+### Stabilization
+
+The following rules have been stabilized and are no longer in preview:
+
+- [`mutable-fromkeys-value`](https://docs.astral.sh/ruff/rules/mutable-fromkeys-value/) (`RUF024`)
+- [`default-factory-kwarg`](https://docs.astral.sh/ruff/rules/default-factory-kwarg/) (`RUF026`)
+- [`django-extra`](https://docs.astral.sh/ruff/rules/django-extra/) (`S610`)
+- [`manual-dict-comprehension`](https://docs.astral.sh/ruff/rules/manual-dict-comprehension/) (`PERF403`)
+- [`print-empty-string`](https://docs.astral.sh/ruff/rules/print-empty-string/) (`FURB105`)
+- [`readlines-in-for`](https://docs.astral.sh/ruff/rules/readlines-in-for/) (`FURB129`)
+- [`if-expr-min-max`](https://docs.astral.sh/ruff/rules/if-expr-min-max/) (`FURB136`)
+- [`bit-count`](https://docs.astral.sh/ruff/rules/bit-count/) (`FURB161`)
+- [`redundant-log-base`](https://docs.astral.sh/ruff/rules/redundant-log-base/) (`FURB163`)
+- [`regex-flag-alias`](https://docs.astral.sh/ruff/rules/regex-flag-alias/) (`FURB167`)
+- [`isinstance-type-none`](https://docs.astral.sh/ruff/rules/isinstance-type-none/) (`FURB168`)
+- [`type-none-comparison`](https://docs.astral.sh/ruff/rules/type-none-comparison/) (`FURB169`)
+- [`implicit-cwd`](https://docs.astral.sh/ruff/rules/implicit-cwd/) (`FURB177`)
+- [`hashlib-digest-hex`](https://docs.astral.sh/ruff/rules/hashlib-digest-hex/) (`FURB181`)
+- [`list-reverse-copy`](https://docs.astral.sh/ruff/rules/list-reverse-copy/) (`FURB187`)
+- [`bad-open-mode`](https://docs.astral.sh/ruff/rules/bad-open-mode/) (`PLW1501`)
+- [`empty-comment`](https://docs.astral.sh/ruff/rules/empty-comment/) (`PLR2044`)
+- [`global-at-module-level`](https://docs.astral.sh/ruff/rules/global-at-module-level/) (`PLW0604`)
+- [`misplaced-bare-raise`](https://docs.astral.sh/ruff/rules/misplaced-bare-raise/) (`PLE0744`)
+- [`non-ascii-import-name`](https://docs.astral.sh/ruff/rules/non-ascii-import-name/) (`PLC2403`)
+- [`non-ascii-name`](https://docs.astral.sh/ruff/rules/non-ascii-name/) (`PLC2401`)
+- [`nonlocal-and-global`](https://docs.astral.sh/ruff/rules/nonlocal-and-global/) (`PLE0115`)
+- [`potential-index-error`](https://docs.astral.sh/ruff/rules/potential-index-error/) (`PLE0643`)
+- [`redeclared-assigned-name`](https://docs.astral.sh/ruff/rules/redeclared-assigned-name/) (`PLW0128`)
+- [`redefined-argument-from-local`](https://docs.astral.sh/ruff/rules/redefined-argument-from-local/) (`PLR1704`)
+- [`repeated-keyword-argument`](https://docs.astral.sh/ruff/rules/repeated-keyword-argument/) (`PLE1132`)
+- [`super-without-brackets`](https://docs.astral.sh/ruff/rules/super-without-brackets/) (`PLW0245`)
+- [`unnecessary-list-index-lookup`](https://docs.astral.sh/ruff/rules/unnecessary-list-index-lookup/) (`PLR1736`)
+- [`useless-exception-statement`](https://docs.astral.sh/ruff/rules/useless-exception-statement/) (`PLW0133`)
+- [`useless-with-lock`](https://docs.astral.sh/ruff/rules/useless-with-lock/) (`PLW2101`)
+
+The following behaviors have been stabilized:
+
+- [`is-literal`](https://docs.astral.sh/ruff/rules/is-literal/) (`F632`) now warns for identity checks against list, set or dictionary literals
+- [`needless-bool`](https://docs.astral.sh/ruff/rules/needless-bool/) (`SIM103`) now detects `if` expressions with implicit `else` branches
+- [`module-import-not-at-top-of-file`](https://docs.astral.sh/ruff/rules/module-import-not-at-top-of-file/) (`E402`) now allows `os.environ` modifications between import statements
+- [`type-comparison`](https://docs.astral.sh/ruff/rules/type-comparison/) (`E721`) now allows idioms such as `type(x) is int`
+- [`yoda-condition`](https://docs.astral.sh/ruff/rules/yoda-conditions/) (`SIM300`) now flags a wider range of expressions
+
+### Removals
+
+The following deprecated settings have been removed:
+
+- `output-format=text`; use `output-format=concise` or `output-format=full`
+- `tab-size`; use `indent-width`
+
+The following deprecated CLI options have been removed:
+
+- `--show-source`; use `--output-format=full`
+- `--no-show-source`; use `--output-format=concise`
+
+The following deprecated CLI commands have been removed:
+
+- `ruff <path>`; use `ruff check <path>`
+- `ruff --clean`; use `ruff clean`
+- `ruff --generate-shell-completion`; use `ruff generate-shell-completion`
+
+### Preview features
+
+- \[`ruff`\] Add `assert-with-print-message` rule ([#11981](https://github.com/astral-sh/ruff/pull/11981))
+
+### CLI
+
+- Use rule name rather than message in `--statistics` ([#11697](https://github.com/astral-sh/ruff/pull/11697))
+- Use the output format `full` by default ([#12010](https://github.com/astral-sh/ruff/pull/12010))
+- Don't log syntax errors to the console ([#11902](https://github.com/astral-sh/ruff/pull/11902))
+
+### Rule changes
+
+- \[`ruff`\] Fix false positives if `gettext` is imported using an alias (`RUF027`) ([#12025](https://github.com/astral-sh/ruff/pull/12025))
+- \[`numpy`\] Update `trapz` and `in1d` deprecation (`NPY201`) ([#11948](https://github.com/astral-sh/ruff/pull/11948))
+- \[`flake8-bandit`\] Modify diagnostic ranges for shell-related rules ([#10667](https://github.com/astral-sh/ruff/pull/10667))
+
+### Server
+
+- Closing an untitled, unsaved notebook document no longer throws an error ([#11942](https://github.com/astral-sh/ruff/pull/11942))
+- Support the usage of tildes and environment variables in `logFile` ([#11945](https://github.com/astral-sh/ruff/pull/11945))
+- Add option to configure whether to show syntax errors ([#12059](https://github.com/astral-sh/ruff/pull/12059))
+
+### Bug fixes
+
+- \[`pycodestyle`\] Avoid `E203` for f-string debug expression ([#12024](https://github.com/astral-sh/ruff/pull/12024))
+- \[`pep8-naming`\] Match import-name ignores against both name and alias (`N812`, `N817`) ([#12033](https://github.com/astral-sh/ruff/pull/12033))
+- \[`pyflakes`\] Detect assignments that shadow definitions (`F811`) ([#11961](https://github.com/astral-sh/ruff/pull/11961))
+
+### Parser
+
+- Emit a syntax error for an empty type parameter list ([#12030](https://github.com/astral-sh/ruff/pull/12030))
+- Avoid consuming the newline for unterminated strings ([#12067](https://github.com/astral-sh/ruff/pull/12067))
+- Do not include the newline in the unterminated string range ([#12017](https://github.com/astral-sh/ruff/pull/12017))
+- Use the correct range to highlight line continuation errors ([#12016](https://github.com/astral-sh/ruff/pull/12016))
+- Consider 2-character EOL before line continuations ([#12035](https://github.com/astral-sh/ruff/pull/12035))
+- Consider line continuation character for re-lexing ([#12008](https://github.com/astral-sh/ruff/pull/12008))
+
+### Other changes
+
+- Upgrade the Unicode table used for measuring the line-length ([#11194](https://github.com/astral-sh/ruff/pull/11194))
+- Remove the deprecation error message for the nursery selector ([#10172](https://github.com/astral-sh/ruff/pull/10172))
+
 ## 0.4.10
 
 ### Parser

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

Cargo.lock

@@ -184,9 +184,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "bstr"
@@ -232,6 +232,15 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
+[[package]]
+name = "castaway"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a17ed5635fc8536268e5d4de1e22e81ac34419e5f052d4d51f4e01dcc263fcc"
+dependencies = [
+ "rustversion",
+]
+
 [[package]]
 name = "cc"
 version = "1.0.95"
@@ -305,9 +314,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.7"
+version = "4.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5db83dced34638ad474f39f250d7fea9598bdd239eaced1bdf45d597da0f433f"
+checksum = "84b3edb18336f4df585bc9aa31dd99c036dfa5dc5e9a2939a722a188f3a8970d"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -315,9 +324,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.7"
+version = "4.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7e204572485eb3fbf28f871612191521df159bc3e15a9f5064c66dba3a8c05f"
+checksum = "c1c09dd5ada6c6c78075d6fd0da3f90d8080651e2d6cc8eb2f1aaa4034ced708"
 dependencies = [
  "anstream",
  "anstyle",
@@ -369,11 +378,11 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.5"
+version = "4.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c780290ccf4fb26629baa7a1081e68ced113f1d3ec302fa5948f1c381ebf06c6"
+checksum = "2bac35c6dafb060fd4d275d9a4ffae97917c13a6327903a8be2153cd964f7085"
 dependencies = [
- "heck 0.5.0",
+ "heck",
  "proc-macro2",
  "quote",
  "syn",
@@ -436,6 +445,20 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "compact_str"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f86b9c4c00838774a6d902ef931eff7470720c51d90c2e32cfe15dc304737b3f"
+dependencies = [
+ "castaway",
+ "cfg-if",
+ "itoa",
+ "ryu",
+ "serde",
+ "static_assertions",
+]
+
 [[package]]
 name = "console"
 version = "0.15.8"
@@ -480,6 +503,11 @@ name = "countme"
 version = "3.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7704b5fdd17b18ae31c4c1da5a2e0305a2bf17b5249300a9ee9ed7b72114c636"
+dependencies = [
+ "dashmap 5.5.3",
+ "once_cell",
+ "rustc-hash 1.1.0",
+]
 
 [[package]]
 name = "crc32fast"
@@ -638,7 +666,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
 dependencies = [
  "cfg-if",
- "hashbrown 0.14.5",
+ "hashbrown",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "dashmap"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "804c8821570c3f8b70230c2ba75ffa5c0f9a4189b9a432b6656c536712acae28"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "hashbrown",
  "lock_api",
  "once_cell",
  "parking_lot_core",
@@ -755,13 +797,14 @@ dependencies = [
 ]
 
 [[package]]
-name = "eyre"
-version = "0.6.12"
+name = "etcetera"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cd915d99f24784cdc19fd37ef22b97e3ff0ae756c7e492e9fbfe897d61e2aec"
+checksum = "136d1b5283a1ab77bd9257427ffd09d8667ced0570b6f938942bc7568ed5b943"
 dependencies = [
- "indenter",
- "once_cell",
+ "cfg-if",
+ "home",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -885,12 +928,6 @@ dependencies = [
  "crunchy",
 ]
 
-[[package]]
-name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-
 [[package]]
 name = "hashbrown"
 version = "0.14.5"
@@ -907,15 +944,9 @@ version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
 dependencies = [
- "hashbrown 0.14.5",
+ "hashbrown",
 ]
 
-[[package]]
-name = "heck"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
-
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -1000,12 +1031,12 @@ dependencies = [
 
 [[package]]
 name = "imara-diff"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e98c1d0ad70fc91b8b9654b1f33db55e59579d3b3de2bffdced0fdb810570cb8"
+checksum = "af13c8ceb376860ff0c6a66d83a8cdd4ecd9e464da24621bbffcd02b49619434"
 dependencies = [
  "ahash",
- "hashbrown 0.12.3",
+ "hashbrown",
 ]
 
 [[package]]
@@ -1018,12 +1049,6 @@ dependencies = [
  "rust-stemmers",
 ]
 
-[[package]]
-name = "indenter"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683"
-
 [[package]]
 name = "indexmap"
 version = "2.2.6"
@@ -1031,7 +1056,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.5",
+ "hashbrown",
  "serde",
 ]
 
@@ -1274,7 +1299,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "libc",
 ]
 
@@ -1302,9 +1327,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.21"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "lsp-server"
@@ -1347,9 +1372,9 @@ checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
 
 [[package]]
 name = "matchit"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "540f1c43aed89909c0cc0cc604e3bb2f7e7a341a3728a9e6cfe760e733cd11ed"
+checksum = "8d3c2fcf089c060eb333302d80c5f3ffa8297abecf220f788e4a09ef85f59420"
 
 [[package]]
 name = "memchr"
@@ -1414,7 +1439,7 @@ version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -1436,7 +1461,7 @@ version = "6.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "crossbeam-channel",
  "filetime",
  "fsevent-sys",
@@ -1501,6 +1526,15 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
+[[package]]
+name = "ordermap"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab5a8e22be64dfa1123429350872e7be33594dbf5ae5212c90c5890e71966d1d"
+dependencies = [
+ "indexmap",
+]
+
 [[package]]
 name = "os_str_bytes"
 version = "6.6.1"
@@ -1827,28 +1861,20 @@ dependencies = [
 
 [[package]]
 name = "red_knot"
-version = "0.1.0"
+version = "0.0.0"
 dependencies = [
  "anyhow",
- "bitflags 2.5.0",
+ "countme",
  "crossbeam",
  "ctrlc",
- "dashmap",
- "hashbrown 0.14.5",
- "indexmap",
- "is-macro",
  "notify",
- "parking_lot",
  "rayon",
  "red_knot_module_resolver",
- "ruff_index",
- "ruff_notebook",
+ "red_knot_python_semantic",
+ "ruff_db",
  "ruff_python_ast",
- "ruff_python_parser",
- "ruff_text_size",
  "rustc-hash 2.0.0",
- "smol_str",
- "tempfile",
+ "salsa",
  "tracing",
  "tracing-subscriber",
  "tracing-tree",
@@ -1859,13 +1885,14 @@ name = "red_knot_module_resolver"
 version = "0.0.0"
 dependencies = [
  "anyhow",
+ "camino",
+ "compact_str",
  "insta",
  "path-slash",
  "ruff_db",
  "ruff_python_stdlib",
  "rustc-hash 2.0.0",
  "salsa",
- "smol_str",
  "tempfile",
  "tracing",
  "walkdir",
@@ -1877,9 +1904,9 @@ name = "red_knot_python_semantic"
 version = "0.0.0"
 dependencies = [
  "anyhow",
- "bitflags 2.5.0",
- "hashbrown 0.14.5",
- "indexmap",
+ "bitflags 2.6.0",
+ "hashbrown",
+ "ordermap",
  "red_knot_module_resolver",
  "ruff_db",
  "ruff_index",
@@ -1888,8 +1915,6 @@ dependencies = [
  "ruff_text_size",
  "rustc-hash 2.0.0",
  "salsa",
- "smallvec",
- "smol_str",
  "tracing",
 ]
 
@@ -1974,12 +1999,12 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.4.10"
+version = "0.5.1"
 dependencies = [
  "anyhow",
  "argfile",
  "bincode",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "cachedir",
  "chrono",
  "clap",
@@ -2032,6 +2057,9 @@ dependencies = [
  "criterion",
  "mimalloc",
  "once_cell",
+ "red_knot",
+ "red_knot_module_resolver",
+ "ruff_db",
  "ruff_linter",
  "ruff_python_ast",
  "ruff_python_formatter",
@@ -2063,7 +2091,7 @@ version = "0.0.0"
 dependencies = [
  "camino",
  "countme",
- "dashmap",
+ "dashmap 6.0.1",
  "filetime",
  "insta",
  "once_cell",
@@ -2153,12 +2181,12 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.4.10"
+version = "0.5.1"
 dependencies = [
  "aho-corasick",
  "annotate-snippets 0.9.2",
  "anyhow",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "chrono",
  "clap",
  "colored",
@@ -2247,14 +2275,18 @@ name = "ruff_python_ast"
 version = "0.0.0"
 dependencies = [
  "aho-corasick",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
+ "compact_str",
  "is-macro",
  "itertools 0.13.0",
  "once_cell",
+ "ruff_cache",
+ "ruff_macros",
  "ruff_python_trivia",
  "ruff_source_file",
  "ruff_text_size",
  "rustc-hash 2.0.0",
+ "schemars",
  "serde",
 ]
 
@@ -2327,7 +2359,7 @@ dependencies = [
 name = "ruff_python_literal"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "itertools 0.13.0",
  "ruff_python_ast",
  "unic-ucd-category",
@@ -2339,8 +2371,9 @@ version = "0.0.0"
 dependencies = [
  "annotate-snippets 0.9.2",
  "anyhow",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "bstr",
+ "compact_str",
  "insta",
  "memchr",
  "ruff_python_ast",
@@ -2369,7 +2402,7 @@ dependencies = [
 name = "ruff_python_semantic"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "is-macro",
  "ruff_index",
  "ruff_python_ast",
@@ -2493,7 +2526,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "colored",
- "dirs 5.0.1",
+ "etcetera",
  "glob",
  "globset",
  "ignore",
@@ -2549,7 +2582,7 @@ version = "0.38.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -2558,11 +2591,12 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.22.4"
+version = "0.23.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf4ef73721ac7bcd79b2b315da7779d8fc09718c6b3d2d1b2d94850eb8c18432"
+checksum = "05cff451f60db80f490f3c182b77c35260baace73209e9cdbbe526bfe3a4d402"
 dependencies = [
  "log",
+ "once_cell",
  "ring",
  "rustls-pki-types",
  "rustls-webpki",
@@ -2572,15 +2606,15 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.5.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "beb461507cee2c2ff151784c52762cf4d9ff6a61f3e80968600ed24fa837fa54"
+checksum = "976295e77ce332211c0d24d92c0e83e50f5c5f046d11082cea19f3df13a3562d"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.102.3"
+version = "0.102.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3bce581c0dd41bce533ce695a1437fa16a7ab5ac3ccfa99fe1a620a7885eabf"
+checksum = "f9a6fccd794a42c2c105b513a2f62bc3fd8f3ba57a4593677ceb0bd035164d78"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -2602,12 +2636,11 @@ checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
 [[package]]
 name = "salsa"
 version = "0.18.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=f706aa2d32d473ee633a77c1af01d180c85da308#f706aa2d32d473ee633a77c1af01d180c85da308"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=a1bf3a613f451af7fc0a59411c56abc47fe8e8e1#a1bf3a613f451af7fc0a59411c56abc47fe8e8e1"
 dependencies = [
  "arc-swap",
  "crossbeam",
- "crossbeam-utils",
- "dashmap",
+ "dashmap 5.5.3",
  "hashlink",
  "indexmap",
  "log",
@@ -2620,10 +2653,8 @@ dependencies = [
 [[package]]
 name = "salsa-macros"
 version = "0.18.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=f706aa2d32d473ee633a77c1af01d180c85da308#f706aa2d32d473ee633a77c1af01d180c85da308"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=a1bf3a613f451af7fc0a59411c56abc47fe8e8e1#a1bf3a613f451af7fc0a59411c56abc47fe8e8e1"
 dependencies = [
- "eyre",
- "heck 0.4.1",
  "proc-macro2",
  "quote",
  "syn",
@@ -2683,9 +2714,9 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
 
 [[package]]
 name = "serde"
-version = "1.0.203"
+version = "1.0.204"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
+checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
 dependencies = [
  "serde_derive",
 ]
@@ -2703,9 +2734,9 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.203"
+version = "1.0.204"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
+checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2725,9 +2756,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.117"
+version = "1.0.120"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"
+checksum = "4e0d21c9a8cae1235ad58a00c11cb40d4b1e5c784f1ef2c537876ed6ffd8b7c5"
 dependencies = [
  "itoa",
  "ryu",
@@ -2765,9 +2796,9 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.8.1"
+version = "3.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ad483d2ab0149d5a5ebcd9972a3852711e0153d863bf5a5d0391d28883c4a20"
+checksum = "e73139bc5ec2d45e6c5fd85be5a46949c1c39a4c18e56915f5eb4c12f975e377"
 dependencies = [
  "serde",
  "serde_derive",
@@ -2776,9 +2807,9 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.8.1"
+version = "3.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65569b702f41443e8bc8bbb1c5779bd0450bbe723b56198980e80ec45780bce2"
+checksum = "b80d3d6b56b64335c0180e5ffde23b3c5e08c14c585b51a15bd0e95393f46703"
 dependencies = [
  "darling",
  "proc-macro2",
@@ -2822,15 +2853,6 @@ version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
-[[package]]
-name = "smol_str"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -2879,7 +2901,7 @@ version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
 dependencies = [
- "heck 0.5.0",
+ "heck",
  "proc-macro2",
  "quote",
  "rustversion",
@@ -2894,9 +2916,9 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
 
 [[package]]
 name = "syn"
-version = "2.0.68"
+version = "2.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9"
+checksum = "201fcda3845c23e8212cd466bfebf0bd20694490fc0356ae8e428e0824a915a6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3248,9 +3270,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-width"
-version = "0.1.11"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
+checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
 
 [[package]]
 name = "unicode_names2"
@@ -3288,9 +3310,9 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "ureq"
-version = "2.9.7"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d11a831e3c0b56e438a28308e7c810799e3c118417f342d30ecec080105395cd"
+checksum = "72139d247e5f97a3eff96229a7ae85ead5328a39efe76f8bf5a06313d505b6ea"
 dependencies = [
  "base64",
  "flate2",
@@ -3298,7 +3320,6 @@ dependencies = [
  "once_cell",
  "rustls",
  "rustls-pki-types",
- "rustls-webpki",
  "url",
  "webpki-roots",
 ]
@@ -3323,9 +3344,9 @@ checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
 
 [[package]]
 name = "uuid"
-version = "1.8.0"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
+checksum = "5de17fd2f7da591098415cff336e12965a28061ddace43b59cb3c430179c9439"
 dependencies = [
  "getrandom",
  "rand",
@@ -3335,9 +3356,9 @@ dependencies = [
 
 [[package]]
 name = "uuid-macro-internal"
-version = "1.8.0"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9881bea7cbe687e36c9ab3b778c36cd0487402e270304e8b1296d5085303c1a2"
+checksum = "a3ff64d5cde1e2cb5268bdb497235b6bd255ba8244f910dbc3574e59593de68c"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

@@ -35,7 +35,9 @@ ruff_source_file = { path = "crates/ruff_source_file" }
 ruff_text_size = { path = "crates/ruff_text_size" }
 ruff_workspace = { path = "crates/ruff_workspace" }
 
+red_knot = { path = "crates/red_knot" }
 red_knot_module_resolver = { path = "crates/red_knot_module_resolver" }
+red_knot_python_semantic = { path = "crates/red_knot_python_semantic" }
 
 aho-corasick = { version = "1.1.3" }
 annotate-snippets = { version = "0.9.2", features = ["color"] }
@@ -55,12 +57,13 @@ colored = { version = "2.1.0" }
 console_error_panic_hook = { version = "0.1.7" }
 console_log = { version = "1.0.0" }
 countme = { version = "3.0.1" }
+compact_str = "0.7.1"
 criterion = { version = "0.5.1", default-features = false }
 crossbeam = { version = "0.8.4" }
-dashmap = { version = "5.5.3" }
-dirs = { version = "5.0.0" }
+dashmap = { version = "6.0.1" }
 drop_bomb = { version = "0.1.5" }
 env_logger = { version = "0.11.0" }
+etcetera = { version = "0.8.0" }
 fern = { version = "0.6.1" }
 filetime = { version = "0.2.23" }
 glob = { version = "0.3.1" }
@@ -69,7 +72,6 @@ hashbrown = "0.14.3"
 ignore = { version = "0.4.22" }
 imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
-indexmap = { version = "2.2.6" }
 indicatif = { version = "0.17.8" }
 indoc = { version = "2.0.4" }
 insta = { version = "1.35.1" }
@@ -92,10 +94,10 @@ mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
 notify = { version = "6.1.1" }
 once_cell = { version = "1.19.0" }
+ordermap = { version = "0.5.0" }
 path-absolutize = { version = "3.1.1" }
 path-slash = { version = "0.2.1" }
 pathdiff = { version = "0.2.1" }
-parking_lot = "0.12.1"
 pep440_rs = { version = "0.6.0", features = ["serde"] }
 pretty_assertions = "1.3.0"
 proc-macro2 = { version = "1.0.79" }
@@ -106,7 +108,7 @@ rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "f706aa2d32d473ee633a77c1af01d180c85da308" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "a1bf3a613f451af7fc0a59411c56abc47fe8e8e1" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -119,7 +121,6 @@ serde_with = { version = "3.6.0", default-features = false, features = [
 shellexpand = { version = "3.0.0" }
 similar = { version = "2.4.0", features = ["inline"] }
 smallvec = { version = "1.13.2" }
-smol_str = { version = "0.2.2" }
 static_assertions = "1.1.0"
 strum = { version = "0.26.0", features = ["strum_macros"] }
 strum_macros = { version = "0.26.0" }
@@ -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"]
+# Announcement jobs to run in CI
+post-announce-jobs = ["./notify-dependents", "./publish-docs", "./publish-playground"]
+# Custom permissions for GitHub Jobs
+github-custom-job-permissions = { "build-docker" = { packages = "write", contents = "read" } }
+# Whether to install an updater program
+install-updater = false

README.md

@@ -119,7 +119,25 @@ For more, see the [documentation](https://docs.astral.sh/ruff/).
 Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 
 ```shell
+# With pip.
 pip install ruff
+
+# With pipx.
+pipx install ruff
+```
+
+Starting with version `0.5.0`, Ruff can be installed with our standalone installers:
+
+```shell
+# On macOS and Linux.
+curl -LsSf https://astral.sh/ruff/install.sh | sh
+
+# On Windows.
+powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
+
+# For a specific version.
+curl -LsSf https://astral.sh/ruff/0.5.1/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.5.1/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -152,7 +170,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.4.10
+  rev: v0.5.1
   hooks:
     # Run the linter.
     - id: ruff
@@ -334,7 +352,6 @@ quality tools, including:
 - [flake8-super](https://pypi.org/project/flake8-super/)
 - [flake8-tidy-imports](https://pypi.org/project/flake8-tidy-imports/)
 - [flake8-todos](https://pypi.org/project/flake8-todos/)
-- [flake8-trio](https://pypi.org/project/flake8-trio/)
 - [flake8-type-checking](https://pypi.org/project/flake8-type-checking/)
 - [flake8-use-pathlib](https://pypi.org/project/flake8-use-pathlib/)
 - [flynt](https://pypi.org/project/flynt/) ([#2102](https://github.com/astral-sh/ruff/issues/2102))

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

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,23 @@ license.workspace = true
 
 [dependencies]
 red_knot_module_resolver = { workspace = true }
+red_knot_python_semantic = { workspace = true }
 
-ruff_python_parser = { workspace = true }
+ruff_db = { workspace = true }
 ruff_python_ast = { workspace = true }
-ruff_text_size = { workspace = true }
-ruff_index = { workspace = true }
-ruff_notebook = { workspace = true }
 
 anyhow = { workspace = true }
-bitflags = { workspace = true }
+countme = { workspace = true, features = ["enable"] }
 crossbeam = { workspace = true }
 ctrlc = { version = "3.4.4" }
-dashmap = { workspace = true }
-hashbrown = { workspace = true }
-indexmap = { workspace = true }
-is-macro = { workspace = true }
 notify = { workspace = true }
-parking_lot = { workspace = true }
 rayon = { workspace = true }
 rustc-hash = { workspace = true }
-smol_str = { version = "0.2.1" }
+salsa = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 tracing-tree = { workspace = true }
 
-[dev-dependencies]
-tempfile = { workspace = true }
 
 [lints]
 workspace = true

crates/red_knot/src/ast_ids.rs

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

crates/red_knot/src/cache.rs

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

crates/red_knot/src/cancellation.rs

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

crates/red_knot/src/db.rs

@@ -1,248 +1,10 @@
-use std::sync::Arc;
+use red_knot_python_semantic::Db as SemanticDb;
+use ruff_db::Upcast;
+use salsa::DbWithJar;
 
-pub use jars::{HasJar, HasJars};
-pub use query::{QueryError, QueryResult};
-pub use runtime::DbRuntime;
-pub use storage::JarsStorage;
+use crate::lint::{lint_semantic, lint_syntax, unwind_if_cancelled};
 
-use crate::files::FileId;
-use crate::lint::{LintSemanticStorage, LintSyntaxStorage};
-use crate::module::ModuleResolver;
-use crate::parse::ParsedStorage;
-use crate::semantic::SemanticIndexStorage;
-use crate::semantic::TypeStore;
-use crate::source::SourceStorage;
+pub trait Db: DbWithJar<Jar> + SemanticDb + Upcast<dyn SemanticDb> {}
 
-mod jars;
-mod query;
-mod runtime;
-mod storage;
-
-pub trait Database {
-    /// Returns a reference to the runtime of the current worker.
-    fn runtime(&self) -> &DbRuntime;
-
-    /// Returns a mutable reference to the runtime. Only one worker can hold a mutable reference to the runtime.
-    fn runtime_mut(&mut self) -> &mut DbRuntime;
-
-    /// Returns `Ok` if the queries have not been cancelled and `Err(QueryError::Cancelled)` otherwise.
-    fn cancelled(&self) -> QueryResult<()> {
-        self.runtime().cancelled()
-    }
-
-    /// Returns `true` if the queries have been cancelled.
-    fn is_cancelled(&self) -> bool {
-        self.runtime().is_cancelled()
-    }
-}
-
-/// Database that supports running queries from multiple threads.
-pub trait ParallelDatabase: Database + Send {
-    /// Creates a snapshot of the database state that can be used to query the database in another thread.
-    ///
-    /// The snapshot is a read-only view of the database but query results are shared between threads.
-    /// All queries will be automatically cancelled when applying any mutations (calling [`HasJars::jars_mut`])
-    /// to the database (not the snapshot, because they're readonly).
-    ///
-    /// ## Creating a snapshot
-    ///
-    /// Creating a snapshot of the database's jars is cheap but creating a snapshot of
-    /// other state stored on the database might require deep-cloning data. That's why you should
-    /// avoid creating snapshots in a hot function (e.g. don't create a snapshot for each file, instead
-    /// create a snapshot when scheduling the check of an entire program).
-    ///
-    /// ## Salsa compatibility
-    /// Salsa prohibits creating a snapshot while running a local query (it's fine if other workers run a query) [[source](https://github.com/salsa-rs/salsa/issues/80)].
-    /// We should avoid creating snapshots while running a query because we might want to adopt Salsa in the future (if we can figure out persistent caching).
-    /// Unfortunately, the infrastructure doesn't provide an automated way of knowing when a query is run, that's
-    /// why we have to "enforce" this constraint manually.
-    #[must_use]
-    fn snapshot(&self) -> Snapshot<Self>;
-}
-
-pub trait DbWithJar<Jar>: Database + HasJar<Jar> {}
-
-/// Readonly snapshot of a database.
-///
-/// ## Dead locks
-/// A snapshot should always be dropped as soon as it is no longer necessary to run queries.
-/// Storing the snapshot without running a query or periodically checking if cancellation was requested
-/// can lead to deadlocks because mutating the [`Database`] requires cancels all pending queries
-/// and waiting for all [`Snapshot`]s to be dropped.
-#[derive(Debug)]
-pub struct Snapshot<DB: ?Sized>
-where
-    DB: ParallelDatabase,
-{
-    db: DB,
-}
-
-impl<DB> Snapshot<DB>
-where
-    DB: ParallelDatabase,
-{
-    pub fn new(db: DB) -> Self {
-        Snapshot { db }
-    }
-}
-
-impl<DB> std::ops::Deref for Snapshot<DB>
-where
-    DB: ParallelDatabase,
-{
-    type Target = DB;
-
-    fn deref(&self) -> &DB {
-        &self.db
-    }
-}
-
-pub trait Upcast<T: ?Sized> {
-    fn upcast(&self) -> &T;
-}
-
-// Red knot specific databases code.
-
-pub trait SourceDb: DbWithJar<SourceJar> {
-    // queries
-    fn file_id(&self, path: &std::path::Path) -> FileId;
-
-    fn file_path(&self, file_id: FileId) -> Arc<std::path::Path>;
-}
-
-pub trait SemanticDb: SourceDb + DbWithJar<SemanticJar> + Upcast<dyn SourceDb> {}
-
-pub trait LintDb: SemanticDb + DbWithJar<LintJar> + Upcast<dyn SemanticDb> {}
-
-pub trait Db: LintDb + Upcast<dyn LintDb> {}
-
-#[derive(Debug, Default)]
-pub struct SourceJar {
-    pub sources: SourceStorage,
-    pub parsed: ParsedStorage,
-}
-
-#[derive(Debug, Default)]
-pub struct SemanticJar {
-    pub module_resolver: ModuleResolver,
-    pub 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()
-        }
-    }
-}
+#[salsa::jar(db=Db)]
+pub struct Jar(lint_syntax, lint_semantic, unwind_if_cancelled);

crates/red_knot/src/db/jars.rs

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

crates/red_knot/src/db/query.rs

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

crates/red_knot/src/db/runtime.rs

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

crates/red_knot/src/db/storage.rs

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

crates/red_knot/src/files.rs

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

crates/red_knot/src/hir.rs

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

crates/red_knot/src/hir/definition.rs

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

crates/red_knot/src/lib.rs

@@ -1,108 +1,52 @@
-use std::fmt::Formatter;
-use std::hash::BuildHasherDefault;
-use std::ops::Deref;
-use std::path::{Path, PathBuf};
+use rustc_hash::FxHashSet;
 
-use rustc_hash::{FxHashSet, FxHasher};
+use ruff_db::file_system::{FileSystemPath, FileSystemPathBuf};
+use ruff_db::vfs::VfsFile;
 
-use crate::files::FileId;
+use crate::db::Jar;
 
-pub mod ast_ids;
-pub mod cache;
-pub mod cancellation;
 pub mod db;
-pub mod files;
-pub mod hir;
 pub mod lint;
-pub mod module;
-mod parse;
 pub mod program;
-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,
+    root: FileSystemPathBuf,
     /// The files that are open in the workspace.
     ///
     /// * Editor: The files that are actively being edited in the editor (the user has a tab open with the file).
     /// * CLI: The resolved files passed as arguments to the CLI.
-    open_files: FxHashSet<FileId>,
+    open_files: FxHashSet<VfsFile>,
 }
 
 impl Workspace {
-    pub fn new(root: PathBuf) -> Self {
+    pub fn new(root: FileSystemPathBuf) -> Self {
         Self {
             root,
             open_files: FxHashSet::default(),
         }
     }
 
-    pub fn root(&self) -> &Path {
+    pub fn root(&self) -> &FileSystemPath {
         self.root.as_path()
     }
 
     // TODO having the content in workspace feels wrong.
-    pub fn open_file(&mut self, file_id: FileId) {
+    pub fn open_file(&mut self, file_id: VfsFile) {
         self.open_files.insert(file_id);
     }
 
-    pub fn close_file(&mut self, file_id: FileId) {
+    pub fn close_file(&mut self, file_id: VfsFile) {
         self.open_files.remove(&file_id);
     }
 
     // TODO introduce an `OpenFile` type instead of using an anonymous tuple.
-    pub fn open_files(&self) -> impl Iterator<Item = FileId> + '_ {
+    pub fn open_files(&self) -> impl Iterator<Item = VfsFile> + '_ {
         self.open_files.iter().copied()
     }
 
-    pub fn is_file_open(&self, file_id: FileId) -> bool {
+    pub fn is_file_open(&self, file_id: VfsFile) -> bool {
         self.open_files.contains(&file_id)
     }
 }
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Name(smol_str::SmolStr);
-
-impl Name {
-    #[inline]
-    pub fn new(name: &str) -> Self {
-        Self(smol_str::SmolStr::new(name))
-    }
-
-    pub fn as_str(&self) -> &str {
-        self.0.as_str()
-    }
-}
-
-impl Deref for Name {
-    type Target = str;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        self.as_str()
-    }
-}
-
-impl<T> From<T> for Name
-where
-    T: Into<smol_str::SmolStr>,
-{
-    fn from(value: T) -> Self {
-        Self(value.into())
-    }
-}
-
-impl std::fmt::Display for Name {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.as_str())
-    }
-}

crates/red_knot/src/lint.rs

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

crates/red_knot/src/main.rs

@@ -1,9 +1,7 @@
-#![allow(clippy::dbg_macro)]
-
-use std::path::Path;
 use std::sync::Mutex;
 
 use crossbeam::channel as crossbeam_channel;
+use salsa::ParallelDatabase;
 use tracing::subscriber::Interest;
 use tracing::{Level, Metadata};
 use tracing_subscriber::filter::LevelFilter;
@@ -11,15 +9,23 @@ 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_module_resolver::{
+    set_module_resolution_settings, RawModuleResolutionSettings, TargetVersion,
+};
+use ruff_db::file_system::{FileSystem, FileSystemPath, OsFileSystem};
+use ruff_db::vfs::system_path_to_file;
 
-#[allow(clippy::print_stdout, clippy::unnecessary_wraps, clippy::print_stderr)]
-fn main() -> anyhow::Result<()> {
+#[allow(
+    clippy::print_stdout,
+    clippy::unnecessary_wraps,
+    clippy::print_stderr,
+    clippy::dbg_macro
+)]
+pub fn main() -> anyhow::Result<()> {
+    countme::enable(true);
     setup_tracing();
 
     let arguments: Vec<_> = std::env::args().collect();
@@ -29,34 +35,40 @@ fn main() -> anyhow::Result<()> {
         return Err(anyhow::anyhow!("Invalid arguments"));
     }
 
-    let entry_point = Path::new(&arguments[1]);
+    let fs = OsFileSystem;
+    let entry_point = FileSystemPath::new(&arguments[1]);
 
-    if !entry_point.exists() {
+    if !fs.exists(entry_point) {
         eprintln!("The entry point does not exist.");
         return Err(anyhow::anyhow!("Invalid arguments"));
     }
 
-    if !entry_point.is_file() {
+    if !fs.is_file(entry_point) {
         eprintln!("The entry point is not a file.");
         return Err(anyhow::anyhow!("Invalid arguments"));
     }
 
+    let entry_point = entry_point.to_path_buf();
+
     let workspace_folder = entry_point.parent().unwrap();
     let workspace = Workspace::new(workspace_folder.to_path_buf());
 
     let workspace_search_path = workspace.root().to_path_buf();
 
-    let search_paths = ModuleResolutionInputs {
-        extra_paths: vec![],
-        workspace_root: workspace_search_path,
-        site_packages: None,
-        custom_typeshed: None,
-    };
+    let mut program = Program::new(workspace, fs);
 
-    let mut program = Program::new(workspace);
-    set_module_search_paths(&mut program, search_paths);
+    set_module_resolution_settings(
+        &mut program,
+        RawModuleResolutionSettings {
+            extra_paths: vec![],
+            workspace_root: workspace_search_path,
+            site_packages: None,
+            custom_typeshed: None,
+            target_version: TargetVersion::Py38,
+        },
+    );
 
-    let entry_id = program.file_id(entry_point);
+    let entry_id = system_path_to_file(&program, entry_point.clone()).unwrap();
     program.workspace_mut().open_file(entry_id);
 
     let (main_loop, main_loop_cancellation_token) = MainLoop::new();
@@ -78,14 +90,11 @@ fn main() -> anyhow::Result<()> {
         file_changes_notifier.notify(changes);
     })?;
 
-    file_watcher.watch_folder(workspace_folder)?;
+    file_watcher.watch_folder(workspace_folder.as_std_path())?;
 
     main_loop.run(&mut program);
 
-    let source_jar: &SourceJar = program.jar().unwrap();
-
-    dbg!(source_jar.parsed.statistics());
-    dbg!(source_jar.sources.statistics());
+    println!("{}", countme::get_all());
 
     Ok(())
 }
@@ -127,6 +136,7 @@ impl MainLoop {
         }
     }
 
+    #[allow(clippy::print_stderr)]
     fn run(self, program: &mut Program) {
         self.orchestrator_sender
             .send(OrchestratorMessage::Run)
@@ -142,8 +152,8 @@ impl MainLoop {
 
                     // Spawn a new task that checks the program. This needs to be done in a separate thread
                     // to prevent blocking the main loop here.
-                    rayon::spawn(move || match program.check(ExecutionMode::ThreadPool) {
-                        Ok(result) => {
+                    rayon::spawn(move || {
+                        if let Ok(result) = program.check() {
                             sender
                                 .send(OrchestratorMessage::CheckProgramCompleted {
                                     diagnostics: result,
@@ -151,7 +161,6 @@ impl MainLoop {
                                 })
                                 .unwrap();
                         }
-                        Err(QueryError::Cancelled) => {}
                     });
                 }
                 MainLoopMessage::ApplyChanges(changes) => {
@@ -159,9 +168,11 @@ impl MainLoop {
                     program.apply_changes(changes);
                 }
                 MainLoopMessage::CheckCompleted(diagnostics) => {
-                    dbg!(diagnostics);
+                    eprintln!("{}", diagnostics.join("\n"));
+                    eprintln!("{}", countme::get_all());
                 }
                 MainLoopMessage::Exit => {
+                    eprintln!("{}", countme::get_all());
                     return;
                 }
             }
@@ -210,6 +221,7 @@ struct Orchestrator {
 }
 
 impl Orchestrator {
+    #[allow(clippy::print_stderr)]
     fn run(&mut self) {
         while let Ok(message) = self.receiver.recv() {
             match message {

crates/red_knot/src/parse.rs

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

crates/red_knot/src/program/mod.rs

@@ -1,30 +1,36 @@
-use std::collections::hash_map::Entry;
-use std::path::{Path, PathBuf};
+use std::panic::{RefUnwindSafe, UnwindSafe};
 use std::sync::Arc;
 
-use rustc_hash::FxHashMap;
+use salsa::{Cancelled, Database};
 
-use crate::db::{
-    Database, Db, DbRuntime, DbWithJar, HasJar, HasJars, JarsStorage, LintDb, LintJar,
-    ParallelDatabase, QueryResult, SemanticDb, SemanticJar, Snapshot, SourceDb, SourceJar, Upcast,
-};
-use crate::files::{FileId, Files};
+use red_knot_module_resolver::{Db as ResolverDb, Jar as ResolverJar};
+use red_knot_python_semantic::{Db as SemanticDb, Jar as SemanticJar};
+use ruff_db::file_system::{FileSystem, FileSystemPathBuf};
+use ruff_db::vfs::{Vfs, VfsFile, VfsPath};
+use ruff_db::{Db as SourceDb, Jar as SourceJar, Upcast};
+
+use crate::db::{Db, Jar};
 use crate::Workspace;
 
-pub mod check;
+mod check;
 
-#[derive(Debug)]
+#[salsa::db(SourceJar, ResolverJar, SemanticJar, Jar)]
 pub struct Program {
-    jars: JarsStorage<Program>,
-    files: Files,
+    storage: salsa::Storage<Program>,
+    vfs: Vfs,
+    fs: Arc<dyn FileSystem + Send + Sync + RefUnwindSafe>,
     workspace: Workspace,
 }
 
 impl Program {
-    pub fn new(workspace: Workspace) -> Self {
+    pub fn new<Fs>(workspace: Workspace, file_system: Fs) -> Self
+    where
+        Fs: FileSystem + 'static + Send + Sync + RefUnwindSafe,
+    {
         Self {
-            jars: JarsStorage::default(),
-            files: Files::default(),
+            storage: salsa::Storage::default(),
+            vfs: Vfs::default(),
+            fs: Arc::new(file_system),
             workspace,
         }
     }
@@ -33,30 +39,11 @@ impl Program {
     where
         I: IntoIterator<Item = FileWatcherChange>,
     {
-        let mut aggregated_changes = AggregatedChanges::default();
-
-        aggregated_changes.extend(changes.into_iter().map(|change| FileChange {
-            id: self.files.intern(&change.path),
-            kind: change.kind,
-        }));
-
-        let (source, semantic, lint) = self.jars_mut();
-        for change in aggregated_changes.iter() {
-            semantic.module_resolver.remove_module_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);
+        for change in changes {
+            VfsFile::touch_path(self, &VfsPath::file_system(change.path));
         }
     }
 
-    pub fn files(&self) -> &Files {
-        &self.files
-    }
-
     pub fn workspace(&self) -> &Workspace {
         &self.workspace
     }
@@ -64,28 +51,18 @@ impl Program {
     pub fn workspace_mut(&mut self) -> &mut Workspace {
         &mut self.workspace
     }
-}
 
-impl SourceDb for Program {
-    fn file_id(&self, path: &Path) -> FileId {
-        self.files.intern(path)
-    }
-
-    fn file_path(&self, file_id: FileId) -> Arc<Path> {
-        self.files.path(file_id)
+    #[allow(clippy::unnecessary_wraps)]
+    fn with_db<F, T>(&self, f: F) -> Result<T, Cancelled>
+    where
+        F: FnOnce(&Program) -> T + UnwindSafe,
+    {
+        // TODO: Catch in `Caancelled::catch`
+        //  See https://salsa.zulipchat.com/#narrow/stream/145099-general/topic/How.20to.20use.20.60Cancelled.3A.3Acatch.60
+        Ok(f(self))
     }
 }
 
-impl DbWithJar<SourceJar> for Program {}
-
-impl SemanticDb for Program {}
-
-impl DbWithJar<SemanticJar> for Program {}
-
-impl LintDb for Program {}
-
-impl DbWithJar<LintJar> for Program {}
-
 impl Upcast<dyn SemanticDb> for Program {
     fn upcast(&self) -> &(dyn SemanticDb + 'static) {
         self
@@ -98,178 +75,57 @@ impl Upcast<dyn SourceDb> for Program {
     }
 }
 
-impl Upcast<dyn LintDb> for Program {
-    fn upcast(&self) -> &(dyn LintDb + 'static) {
+impl Upcast<dyn ResolverDb> for Program {
+    fn upcast(&self) -> &(dyn ResolverDb + 'static) {
         self
     }
 }
 
-impl Db for Program {}
+impl ResolverDb for Program {}
 
-impl Database for Program {
-    fn runtime(&self) -> &DbRuntime {
-        self.jars.runtime()
+impl SemanticDb for Program {}
+
+impl SourceDb for Program {
+    fn file_system(&self) -> &dyn FileSystem {
+        &*self.fs
     }
 
-    fn runtime_mut(&mut self) -> &mut DbRuntime {
-        self.jars.runtime_mut()
+    fn vfs(&self) -> &Vfs {
+        &self.vfs
     }
 }
 
-impl ParallelDatabase for Program {
-    fn snapshot(&self) -> Snapshot<Self> {
-        Snapshot::new(Self {
-            jars: self.jars.snapshot(),
-            files: self.files.snapshot(),
+impl Database for Program {}
+
+impl Db for Program {}
+
+impl salsa::ParallelDatabase for Program {
+    fn snapshot(&self) -> salsa::Snapshot<Self> {
+        salsa::Snapshot::new(Self {
+            storage: self.storage.snapshot(),
+            vfs: self.vfs.snapshot(),
+            fs: self.fs.clone(),
             workspace: self.workspace.clone(),
         })
     }
 }
 
-impl HasJars for Program {
-    type Jars = (SourceJar, SemanticJar, LintJar);
-
-    fn jars(&self) -> QueryResult<&Self::Jars> {
-        self.jars.jars()
-    }
-
-    fn jars_mut(&mut self) -> &mut Self::Jars {
-        self.jars.jars_mut()
-    }
-}
-
-impl HasJar<SourceJar> for Program {
-    fn jar(&self) -> QueryResult<&SourceJar> {
-        Ok(&self.jars()?.0)
-    }
-
-    fn jar_mut(&mut self) -> &mut SourceJar {
-        &mut self.jars_mut().0
-    }
-}
-
-impl HasJar<SemanticJar> for Program {
-    fn jar(&self) -> QueryResult<&SemanticJar> {
-        Ok(&self.jars()?.1)
-    }
-
-    fn jar_mut(&mut self) -> &mut SemanticJar {
-        &mut self.jars_mut().1
-    }
-}
-
-impl HasJar<LintJar> for Program {
-    fn jar(&self) -> QueryResult<&LintJar> {
-        Ok(&self.jars()?.2)
-    }
-
-    fn jar_mut(&mut self) -> &mut LintJar {
-        &mut self.jars_mut().2
-    }
-}
-
 #[derive(Clone, Debug)]
 pub struct FileWatcherChange {
-    path: PathBuf,
+    path: FileSystemPathBuf,
+    #[allow(unused)]
     kind: FileChangeKind,
 }
 
 impl FileWatcherChange {
-    pub fn new(path: PathBuf, kind: FileChangeKind) -> Self {
+    pub fn new(path: FileSystemPathBuf, kind: FileChangeKind) -> Self {
         Self { path, kind }
     }
 }
 
-#[derive(Copy, Clone, Debug)]
-struct FileChange {
-    id: FileId,
-    kind: FileChangeKind,
-}
-
-impl FileChange {
-    fn file_id(self) -> FileId {
-        self.id
-    }
-
-    fn kind(self) -> FileChangeKind {
-        self.kind
-    }
-}
-
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum FileChangeKind {
     Created,
     Modified,
     Deleted,
 }
-
-#[derive(Default, Debug)]
-struct AggregatedChanges {
-    changes: FxHashMap<FileId, FileChangeKind>,
-}
-
-impl AggregatedChanges {
-    fn add(&mut self, change: FileChange) {
-        match self.changes.entry(change.file_id()) {
-            Entry::Occupied(mut entry) => {
-                let merged = entry.get_mut();
-
-                match (merged, change.kind()) {
-                    (FileChangeKind::Created, FileChangeKind::Deleted) => {
-                        // Deletion after creations means that ruff never saw the file.
-                        entry.remove();
-                    }
-                    (FileChangeKind::Created, FileChangeKind::Modified) => {
-                        // No-op, for ruff, modifying a file that it doesn't yet know that it exists is still considered a creation.
-                    }
-
-                    (FileChangeKind::Modified, FileChangeKind::Created) => {
-                        // Uhh, that should probably not happen. Continue considering it a modification.
-                    }
-
-                    (FileChangeKind::Modified, FileChangeKind::Deleted) => {
-                        *entry.get_mut() = FileChangeKind::Deleted;
-                    }
-
-                    (FileChangeKind::Deleted, FileChangeKind::Created) => {
-                        *entry.get_mut() = FileChangeKind::Modified;
-                    }
-
-                    (FileChangeKind::Deleted, FileChangeKind::Modified) => {
-                        // That's weird, but let's consider it a modification.
-                        *entry.get_mut() = FileChangeKind::Modified;
-                    }
-
-                    (FileChangeKind::Created, FileChangeKind::Created)
-                    | (FileChangeKind::Modified, FileChangeKind::Modified)
-                    | (FileChangeKind::Deleted, FileChangeKind::Deleted) => {
-                        // No-op transitions. Some of them should be impossible but we handle them anyway.
-                    }
-                }
-            }
-            Entry::Vacant(entry) => {
-                entry.insert(change.kind());
-            }
-        }
-    }
-
-    fn extend<I>(&mut self, changes: I)
-    where
-        I: IntoIterator<Item = FileChange>,
-    {
-        let iter = changes.into_iter();
-        let (lower, _) = iter.size_hint();
-        self.changes.reserve(lower);
-
-        for change in iter {
-            self.add(change);
-        }
-    }
-
-    fn iter(&self) -> impl Iterator<Item = FileChange> + '_ {
-        self.changes.iter().map(|(id, kind)| FileChange {
-            id: *id,
-            kind: *kind,
-        })
-    }
-}

crates/red_knot/src/semantic.rs

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

crates/red_knot/src/semantic/definitions.rs

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

crates/red_knot/src/semantic/flow_graph.rs

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

crates/red_knot/src/semantic/symbol_table.rs

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

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

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

crates/red_knot/src/source.rs

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

crates/red_knot/src/watch.rs

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

crates/red_knot_module_resolver/Cargo.toml

@@ -14,9 +14,10 @@ license = { workspace = true }
 ruff_db = { workspace = true }
 ruff_python_stdlib = { workspace = true }
 
+compact_str = { workspace = true }
+camino = { workspace = true }
 rustc-hash = { workspace = true }
 salsa = { workspace = true }
-smol_str = { workspace = true }
 tracing = { workspace = true }
 zip = { workspace = true }
 

crates/red_knot_module_resolver/src/db.rs

@@ -2,28 +2,34 @@ use ruff_db::Upcast;
 
 use crate::resolver::{
     file_to_module,
-    internal::{ModuleNameIngredient, ModuleResolverSearchPaths},
+    internal::{ModuleNameIngredient, ModuleResolverSettings},
     resolve_module_query,
 };
+use crate::typeshed::parse_typeshed_versions;
 
 #[salsa::jar(db=Db)]
 pub struct Jar(
     ModuleNameIngredient<'_>,
-    ModuleResolverSearchPaths,
+    ModuleResolverSettings,
     resolve_module_query,
     file_to_module,
+    parse_typeshed_versions,
 );
 
 pub trait Db: salsa::DbWithJar<Jar> + ruff_db::Db + Upcast<dyn ruff_db::Db> {}
 
+#[cfg(test)]
 pub(crate) mod tests {
     use std::sync;
 
     use salsa::DebugWithDb;
 
-    use ruff_db::file_system::{FileSystem, MemoryFileSystem, OsFileSystem};
+    use ruff_db::file_system::{FileSystem, FileSystemPathBuf, MemoryFileSystem, OsFileSystem};
     use ruff_db::vfs::Vfs;
 
+    use crate::resolver::{set_module_resolution_settings, RawModuleResolutionSettings};
+    use crate::supported_py_version::TargetVersion;
+
     use super::*;
 
     #[salsa::db(Jar, ruff_db::Jar)]
@@ -35,7 +41,6 @@ pub(crate) mod tests {
     }
 
     impl TestDb {
-        #[allow(unused)]
         pub(crate) fn new() -> Self {
             Self {
                 storage: salsa::Storage::default(),
@@ -49,7 +54,6 @@ pub(crate) mod tests {
         ///
         /// ## 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
@@ -63,7 +67,6 @@ pub(crate) mod tests {
         /// 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);
         }
@@ -77,7 +80,6 @@ pub(crate) mod tests {
         ///
         /// ## 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 +91,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();
         }
@@ -153,4 +154,111 @@ pub(crate) mod tests {
             }
         }
     }
+
+    pub(crate) struct TestCaseBuilder {
+        db: TestDb,
+        src: FileSystemPathBuf,
+        custom_typeshed: FileSystemPathBuf,
+        site_packages: FileSystemPathBuf,
+        target_version: Option<TargetVersion>,
+    }
+
+    impl TestCaseBuilder {
+        #[must_use]
+        pub(crate) fn with_target_version(mut self, target_version: TargetVersion) -> Self {
+            self.target_version = Some(target_version);
+            self
+        }
+
+        pub(crate) fn build(self) -> TestCase {
+            let TestCaseBuilder {
+                mut db,
+                src,
+                custom_typeshed,
+                site_packages,
+                target_version,
+            } = self;
+
+            let settings = RawModuleResolutionSettings {
+                target_version: target_version.unwrap_or_default(),
+                extra_paths: vec![],
+                workspace_root: src.clone(),
+                custom_typeshed: Some(custom_typeshed.clone()),
+                site_packages: Some(site_packages.clone()),
+            };
+
+            set_module_resolution_settings(&mut db, settings);
+
+            TestCase {
+                db,
+                src,
+                custom_typeshed,
+                site_packages,
+            }
+        }
+    }
+
+    pub(crate) struct TestCase {
+        pub(crate) db: TestDb,
+        pub(crate) src: FileSystemPathBuf,
+        pub(crate) custom_typeshed: FileSystemPathBuf,
+        pub(crate) site_packages: FileSystemPathBuf,
+    }
+
+    pub(crate) fn create_resolver_builder() -> std::io::Result<TestCaseBuilder> {
+        static VERSIONS_DATA: &str = "\
+        asyncio: 3.8-               # 'Regular' package on py38+
+        asyncio.tasks: 3.9-3.11
+        collections: 3.9-           # 'Regular' package on py39+
+        functools: 3.8-
+        importlib: 3.9-             # Namespace package on py39+
+        xml: 3.8-3.8                # Namespace package on py38 only
+        ";
+
+        let db = TestDb::new();
+
+        let src = FileSystemPathBuf::from("src");
+        let site_packages = FileSystemPathBuf::from("site_packages");
+        let custom_typeshed = FileSystemPathBuf::from("typeshed");
+
+        let fs = db.memory_file_system();
+
+        fs.create_directory_all(&src)?;
+        fs.create_directory_all(&site_packages)?;
+        fs.create_directory_all(&custom_typeshed)?;
+        fs.write_file(custom_typeshed.join("stdlib/VERSIONS"), VERSIONS_DATA)?;
+
+        // Regular package on py38+
+        fs.create_directory_all(custom_typeshed.join("stdlib/asyncio"))?;
+        fs.touch(custom_typeshed.join("stdlib/asyncio/__init__.pyi"))?;
+        fs.write_file(
+            custom_typeshed.join("stdlib/asyncio/tasks.pyi"),
+            "class Task: ...",
+        )?;
+
+        // Regular package on py39+
+        fs.create_directory_all(custom_typeshed.join("stdlib/collections"))?;
+        fs.touch(custom_typeshed.join("stdlib/collections/__init__.pyi"))?;
+
+        // Namespace package on py38 only
+        fs.create_directory_all(custom_typeshed.join("stdlib/xml"))?;
+        fs.touch(custom_typeshed.join("stdlib/xml/etree.pyi"))?;
+
+        // Namespace package on py39+
+        fs.create_directory_all(custom_typeshed.join("stdlib/importlib"))?;
+        fs.touch(custom_typeshed.join("stdlib/importlib/abc.pyi"))?;
+
+        fs.write_file(
+            custom_typeshed.join("stdlib/functools.pyi"),
+            "def update_wrapper(): ...",
+        )?;
+
+        Ok(TestCaseBuilder {
+            db,
+            src,
+            custom_typeshed,
+            site_packages,
+            target_version: None,
+        })
+    }
 }

crates/red_knot_module_resolver/src/lib.rs

@@ -1,9 +1,15 @@
 mod db;
 mod module;
+mod module_name;
+mod path;
 mod resolver;
+mod state;
+mod supported_py_version;
 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;
+pub use module::{Module, ModuleKind};
+pub use module_name::ModuleName;
+pub use resolver::{resolve_module, set_module_resolution_settings, RawModuleResolutionSettings};
+pub use supported_py_version::TargetVersion;
+pub use typeshed::{TypeshedVersionsParseError, TypeshedVersionsParseErrorKind};

crates/red_knot_module_resolver/src/module.rs

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

crates/red_knot_module_resolver/src/module_name.rs

@@ -0,0 +1,199 @@
+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> {
+        // TODO(Micha): Use CompactString::const_new once we upgrade to 0.8 https://github.com/ParkMyCar/compact_str/pull/336
+        Self::is_valid_name(name).then(|| Self(CompactString::from(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/path.rs

@@ -0,0 +1,997 @@
+/// Internal abstractions for differentiating between different kinds of search paths.
+///
+/// TODO(Alex): Should we use different types for absolute vs relative paths?
+/// <https://github.com/astral-sh/ruff/pull/12141#discussion_r1667010245>
+use std::fmt;
+
+use ruff_db::file_system::{FileSystemPath, FileSystemPathBuf};
+use ruff_db::vfs::{system_path_to_file, VfsFile};
+
+use crate::module_name::ModuleName;
+use crate::state::ResolverState;
+use crate::typeshed::TypeshedVersionsQueryResult;
+
+/// 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,
+/// as per [the order given in the typing spec]
+///
+/// [the order given in the typing spec]: https://typing.readthedocs.io/en/latest/spec/distributing.html#import-resolution-ordering
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+enum ModuleResolutionPathBufInner {
+    Extra(FileSystemPathBuf),
+    FirstParty(FileSystemPathBuf),
+    StandardLibrary(FileSystemPathBuf),
+    SitePackages(FileSystemPathBuf),
+}
+
+impl ModuleResolutionPathBufInner {
+    fn push(&mut self, component: &str) {
+        let extension = camino::Utf8Path::new(component).extension();
+        let inner = match self {
+            Self::Extra(ref mut path) => {
+                if let Some(extension) = extension {
+                    assert!(
+                        matches!(extension, "pyi" | "py"),
+                        "Extension must be `py` or `pyi`; got `{extension}`"
+                    );
+                }
+                path
+            }
+            Self::FirstParty(ref mut path) => {
+                if let Some(extension) = extension {
+                    assert!(
+                        matches!(extension, "pyi" | "py"),
+                        "Extension must be `py` or `pyi`; got `{extension}`"
+                    );
+                }
+                path
+            }
+            Self::StandardLibrary(ref mut path) => {
+                if let Some(extension) = extension {
+                    assert_eq!(
+                        extension, "pyi",
+                        "Extension must be `pyi`; got `{extension}`"
+                    );
+                }
+                path
+            }
+            Self::SitePackages(ref mut path) => {
+                if let Some(extension) = extension {
+                    assert!(
+                        matches!(extension, "pyi" | "py"),
+                        "Extension must be `py` or `pyi`; got `{extension}`"
+                    );
+                }
+                path
+            }
+        };
+        assert!(
+            inner.extension().is_none(),
+            "Cannot push part {component} to {inner}, which already has an extension"
+        );
+        inner.push(component);
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub(crate) struct ModuleResolutionPathBuf(ModuleResolutionPathBufInner);
+
+impl ModuleResolutionPathBuf {
+    /// Push a new part to the path,
+    /// while maintaining the invariant that the path can only have `.py` or `.pyi` extensions.
+    /// For the stdlib variant specifically, it may only have a `.pyi` extension.
+    ///
+    /// ## Panics:
+    /// If a component with an invalid extension is passed
+    pub(crate) fn push(&mut self, component: &str) {
+        self.0.push(component);
+    }
+
+    #[must_use]
+    pub(crate) fn extra(path: impl Into<FileSystemPathBuf>) -> Option<Self> {
+        let path = path.into();
+        path.extension()
+            .map_or(true, |ext| matches!(ext, "py" | "pyi"))
+            .then_some(Self(ModuleResolutionPathBufInner::Extra(path)))
+    }
+
+    #[must_use]
+    pub(crate) fn first_party(path: impl Into<FileSystemPathBuf>) -> Option<Self> {
+        let path = path.into();
+        path.extension()
+            .map_or(true, |ext| matches!(ext, "pyi" | "py"))
+            .then_some(Self(ModuleResolutionPathBufInner::FirstParty(path)))
+    }
+
+    #[must_use]
+    pub(crate) fn standard_library(path: impl Into<FileSystemPathBuf>) -> Option<Self> {
+        let path = path.into();
+        path.extension()
+            .map_or(true, |ext| ext == "pyi")
+            .then_some(Self(ModuleResolutionPathBufInner::StandardLibrary(path)))
+    }
+
+    #[must_use]
+    pub(crate) fn stdlib_from_typeshed_root(typeshed_root: &FileSystemPath) -> Option<Self> {
+        Self::standard_library(typeshed_root.join(FileSystemPath::new("stdlib")))
+    }
+
+    #[must_use]
+    pub(crate) fn site_packages(path: impl Into<FileSystemPathBuf>) -> Option<Self> {
+        let path = path.into();
+        path.extension()
+            .map_or(true, |ext| matches!(ext, "pyi" | "py"))
+            .then_some(Self(ModuleResolutionPathBufInner::SitePackages(path)))
+    }
+
+    #[must_use]
+    pub(crate) fn is_regular_package(&self, search_path: &Self, resolver: &ResolverState) -> bool {
+        ModuleResolutionPathRef::from(self).is_regular_package(search_path, resolver)
+    }
+
+    #[must_use]
+    pub(crate) fn is_directory(&self, search_path: &Self, resolver: &ResolverState) -> bool {
+        ModuleResolutionPathRef::from(self).is_directory(search_path, resolver)
+    }
+
+    #[must_use]
+    pub(crate) fn with_pyi_extension(&self) -> Self {
+        ModuleResolutionPathRef::from(self).with_pyi_extension()
+    }
+
+    #[must_use]
+    pub(crate) fn with_py_extension(&self) -> Option<Self> {
+        ModuleResolutionPathRef::from(self).with_py_extension()
+    }
+
+    #[must_use]
+    pub(crate) fn relativize_path<'a>(
+        &'a self,
+        absolute_path: &'a (impl AsRef<FileSystemPath> + ?Sized),
+    ) -> Option<ModuleResolutionPathRef<'a>> {
+        ModuleResolutionPathRef::from(self).relativize_path(absolute_path.as_ref())
+    }
+
+    /// Returns `None` if the path doesn't exist, isn't accessible, or if the path points to a directory.
+    pub(crate) fn to_vfs_file(
+        &self,
+        search_path: &Self,
+        resolver: &ResolverState,
+    ) -> Option<VfsFile> {
+        ModuleResolutionPathRef::from(self).to_vfs_file(search_path, resolver)
+    }
+}
+
+impl fmt::Debug for ModuleResolutionPathBuf {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (name, path) = match &self.0 {
+            ModuleResolutionPathBufInner::Extra(path) => ("Extra", path),
+            ModuleResolutionPathBufInner::FirstParty(path) => ("FirstParty", path),
+            ModuleResolutionPathBufInner::SitePackages(path) => ("SitePackages", path),
+            ModuleResolutionPathBufInner::StandardLibrary(path) => ("StandardLibrary", path),
+        };
+        f.debug_tuple(&format!("ModuleResolutionPathBuf::{name}"))
+            .field(path)
+            .finish()
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
+enum ModuleResolutionPathRefInner<'a> {
+    Extra(&'a FileSystemPath),
+    FirstParty(&'a FileSystemPath),
+    StandardLibrary(&'a FileSystemPath),
+    SitePackages(&'a FileSystemPath),
+}
+
+impl<'a> ModuleResolutionPathRefInner<'a> {
+    #[must_use]
+    fn query_stdlib_version<'db>(
+        module_path: &'a FileSystemPath,
+        stdlib_search_path: Self,
+        stdlib_root: &FileSystemPath,
+        resolver_state: &ResolverState<'db>,
+    ) -> TypeshedVersionsQueryResult {
+        let Some(module_name) = stdlib_search_path
+            .relativize_path(module_path)
+            .and_then(Self::to_module_name)
+        else {
+            return TypeshedVersionsQueryResult::DoesNotExist;
+        };
+        let ResolverState {
+            db,
+            typeshed_versions,
+            target_version,
+        } = resolver_state;
+        typeshed_versions.query_module(&module_name, *db, stdlib_root, *target_version)
+    }
+
+    #[must_use]
+    fn is_directory(&self, search_path: Self, resolver: &ResolverState) -> bool {
+        match (self, search_path) {
+            (Self::Extra(path), Self::Extra(_)) => resolver.file_system().is_directory(path),
+            (Self::FirstParty(path), Self::FirstParty(_)) => resolver.file_system().is_directory(path),
+            (Self::SitePackages(path), Self::SitePackages(_)) => resolver.file_system().is_directory(path),
+            (Self::StandardLibrary(path), Self::StandardLibrary(stdlib_root)) => {
+                match Self::query_stdlib_version( path, search_path, stdlib_root, resolver) {
+                    TypeshedVersionsQueryResult::DoesNotExist => false,
+                    TypeshedVersionsQueryResult::Exists => resolver.file_system().is_directory(path),
+                    TypeshedVersionsQueryResult::MaybeExists => resolver.file_system().is_directory(path),
+                }
+            }
+            (path, root) => unreachable!(
+                "The search path should always be the same variant as `self` (got: {path:?}, {root:?})"
+            )
+        }
+    }
+
+    #[must_use]
+    fn is_regular_package(&self, search_path: Self, resolver: &ResolverState) -> bool {
+        fn is_non_stdlib_pkg(state: &ResolverState, path: &FileSystemPath) -> bool {
+            let file_system = state.file_system();
+            file_system.exists(&path.join("__init__.py"))
+                || file_system.exists(&path.join("__init__.pyi"))
+        }
+
+        match (self, search_path) {
+            (Self::Extra(path), Self::Extra(_)) => is_non_stdlib_pkg(resolver, path),
+            (Self::FirstParty(path), Self::FirstParty(_)) => is_non_stdlib_pkg(resolver, path),
+            (Self::SitePackages(path), Self::SitePackages(_)) => is_non_stdlib_pkg(resolver, path),
+            // Unlike the other variants:
+            // (1) Account for VERSIONS
+            // (2) Only test for `__init__.pyi`, not `__init__.py`
+            (Self::StandardLibrary(path), Self::StandardLibrary(stdlib_root)) => {
+                match Self::query_stdlib_version( path, search_path, stdlib_root, resolver) {
+                    TypeshedVersionsQueryResult::DoesNotExist => false,
+                    TypeshedVersionsQueryResult::Exists => resolver.db.file_system().exists(&path.join("__init__.pyi")),
+                    TypeshedVersionsQueryResult::MaybeExists => resolver.db.file_system().exists(&path.join("__init__.pyi")),
+                }
+            }
+            (path, root) => unreachable!(
+                "The search path should always be the same variant as `self` (got: {path:?}, {root:?})"
+            )
+        }
+    }
+
+    fn to_vfs_file(self, search_path: Self, resolver: &ResolverState) -> Option<VfsFile> {
+        match (self, search_path) {
+            (Self::Extra(path), Self::Extra(_)) => system_path_to_file(resolver.db.upcast(), path),
+            (Self::FirstParty(path), Self::FirstParty(_)) => system_path_to_file(resolver.db.upcast(), path),
+            (Self::SitePackages(path), Self::SitePackages(_)) => {
+                system_path_to_file(resolver.db.upcast(), path)
+            }
+            (Self::StandardLibrary(path), Self::StandardLibrary(stdlib_root)) => {
+                match Self::query_stdlib_version(path, search_path, stdlib_root, resolver) {
+                    TypeshedVersionsQueryResult::DoesNotExist => None,
+                    TypeshedVersionsQueryResult::Exists => system_path_to_file(resolver.db.upcast(), path),
+                    TypeshedVersionsQueryResult::MaybeExists => system_path_to_file(resolver.db.upcast(), path)
+                }
+            }
+            (path, root) => unreachable!(
+                "The search path should always be the same variant as `self` (got: {path:?}, {root:?})"
+            )
+        }
+    }
+
+    #[must_use]
+    fn to_module_name(self) -> Option<ModuleName> {
+        let (fs_path, skip_final_part) = match self {
+            Self::Extra(path) | Self::FirstParty(path) | Self::SitePackages(path) => (
+                path,
+                path.ends_with("__init__.py") || path.ends_with("__init__.pyi"),
+            ),
+            Self::StandardLibrary(path) => (path, path.ends_with("__init__.pyi")),
+        };
+
+        let parent_components = fs_path
+            .parent()?
+            .components()
+            .map(|component| component.as_str());
+
+        if skip_final_part {
+            ModuleName::from_components(parent_components)
+        } else {
+            ModuleName::from_components(parent_components.chain(fs_path.file_stem()))
+        }
+    }
+
+    #[must_use]
+    fn with_pyi_extension(&self) -> ModuleResolutionPathBufInner {
+        match self {
+            Self::Extra(path) => ModuleResolutionPathBufInner::Extra(path.with_extension("pyi")),
+            Self::FirstParty(path) => {
+                ModuleResolutionPathBufInner::FirstParty(path.with_extension("pyi"))
+            }
+            Self::StandardLibrary(path) => {
+                ModuleResolutionPathBufInner::StandardLibrary(path.with_extension("pyi"))
+            }
+            Self::SitePackages(path) => {
+                ModuleResolutionPathBufInner::SitePackages(path.with_extension("pyi"))
+            }
+        }
+    }
+
+    #[must_use]
+    fn with_py_extension(&self) -> Option<ModuleResolutionPathBufInner> {
+        match self {
+            Self::Extra(path) => Some(ModuleResolutionPathBufInner::Extra(
+                path.with_extension("py"),
+            )),
+            Self::FirstParty(path) => Some(ModuleResolutionPathBufInner::FirstParty(
+                path.with_extension("py"),
+            )),
+            Self::StandardLibrary(_) => None,
+            Self::SitePackages(path) => Some(ModuleResolutionPathBufInner::SitePackages(
+                path.with_extension("py"),
+            )),
+        }
+    }
+
+    #[must_use]
+    fn relativize_path(&self, absolute_path: &'a FileSystemPath) -> Option<Self> {
+        match self {
+            Self::Extra(root) => absolute_path.strip_prefix(root).ok().and_then(|path| {
+                path.extension()
+                    .map_or(true, |ext| matches!(ext, "py" | "pyi"))
+                    .then_some(Self::Extra(path))
+            }),
+            Self::FirstParty(root) => absolute_path.strip_prefix(root).ok().and_then(|path| {
+                path.extension()
+                    .map_or(true, |ext| matches!(ext, "pyi" | "py"))
+                    .then_some(Self::FirstParty(path))
+            }),
+            Self::StandardLibrary(root) => absolute_path.strip_prefix(root).ok().and_then(|path| {
+                path.extension()
+                    .map_or(true, |ext| ext == "pyi")
+                    .then_some(Self::StandardLibrary(path))
+            }),
+            Self::SitePackages(root) => absolute_path.strip_prefix(root).ok().and_then(|path| {
+                path.extension()
+                    .map_or(true, |ext| matches!(ext, "pyi" | "py"))
+                    .then_some(Self::SitePackages(path))
+            }),
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) struct ModuleResolutionPathRef<'a>(ModuleResolutionPathRefInner<'a>);
+
+impl<'a> ModuleResolutionPathRef<'a> {
+    #[must_use]
+    pub(crate) fn is_directory(
+        &self,
+        search_path: impl Into<Self>,
+        resolver: &ResolverState,
+    ) -> bool {
+        self.0.is_directory(search_path.into().0, resolver)
+    }
+
+    #[must_use]
+    pub(crate) fn is_regular_package(
+        &self,
+        search_path: impl Into<Self>,
+        resolver: &ResolverState,
+    ) -> bool {
+        self.0.is_regular_package(search_path.into().0, resolver)
+    }
+
+    #[must_use]
+    pub(crate) fn to_vfs_file(
+        self,
+        search_path: impl Into<Self>,
+        resolver: &ResolverState,
+    ) -> Option<VfsFile> {
+        self.0.to_vfs_file(search_path.into().0, resolver)
+    }
+
+    #[must_use]
+    pub(crate) fn to_module_name(self) -> Option<ModuleName> {
+        self.0.to_module_name()
+    }
+
+    #[must_use]
+    pub(crate) fn with_pyi_extension(&self) -> ModuleResolutionPathBuf {
+        ModuleResolutionPathBuf(self.0.with_pyi_extension())
+    }
+
+    #[must_use]
+    pub(crate) fn with_py_extension(self) -> Option<ModuleResolutionPathBuf> {
+        self.0.with_py_extension().map(ModuleResolutionPathBuf)
+    }
+
+    #[must_use]
+    pub(crate) fn relativize_path(&self, absolute_path: &'a FileSystemPath) -> Option<Self> {
+        self.0.relativize_path(absolute_path).map(Self)
+    }
+}
+
+impl fmt::Debug for ModuleResolutionPathRef<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (name, path) = match &self.0 {
+            ModuleResolutionPathRefInner::Extra(path) => ("Extra", path),
+            ModuleResolutionPathRefInner::FirstParty(path) => ("FirstParty", path),
+            ModuleResolutionPathRefInner::SitePackages(path) => ("SitePackages", path),
+            ModuleResolutionPathRefInner::StandardLibrary(path) => ("StandardLibrary", path),
+        };
+        f.debug_tuple(&format!("ModuleResolutionPathRef::{name}"))
+            .field(path)
+            .finish()
+    }
+}
+
+impl<'a> From<&'a ModuleResolutionPathBuf> for ModuleResolutionPathRef<'a> {
+    fn from(value: &'a ModuleResolutionPathBuf) -> Self {
+        let inner = match &value.0 {
+            ModuleResolutionPathBufInner::Extra(path) => ModuleResolutionPathRefInner::Extra(path),
+            ModuleResolutionPathBufInner::FirstParty(path) => {
+                ModuleResolutionPathRefInner::FirstParty(path)
+            }
+            ModuleResolutionPathBufInner::StandardLibrary(path) => {
+                ModuleResolutionPathRefInner::StandardLibrary(path)
+            }
+            ModuleResolutionPathBufInner::SitePackages(path) => {
+                ModuleResolutionPathRefInner::SitePackages(path)
+            }
+        };
+        ModuleResolutionPathRef(inner)
+    }
+}
+
+impl PartialEq<FileSystemPath> for ModuleResolutionPathRef<'_> {
+    fn eq(&self, other: &FileSystemPath) -> bool {
+        let fs_path = match self.0 {
+            ModuleResolutionPathRefInner::Extra(path) => path,
+            ModuleResolutionPathRefInner::FirstParty(path) => path,
+            ModuleResolutionPathRefInner::SitePackages(path) => path,
+            ModuleResolutionPathRefInner::StandardLibrary(path) => path,
+        };
+        fs_path == other
+    }
+}
+
+impl PartialEq<ModuleResolutionPathRef<'_>> for FileSystemPath {
+    fn eq(&self, other: &ModuleResolutionPathRef) -> bool {
+        other == self
+    }
+}
+
+impl PartialEq<FileSystemPathBuf> for ModuleResolutionPathRef<'_> {
+    fn eq(&self, other: &FileSystemPathBuf) -> bool {
+        self == &**other
+    }
+}
+
+impl PartialEq<ModuleResolutionPathRef<'_>> for FileSystemPathBuf {
+    fn eq(&self, other: &ModuleResolutionPathRef<'_>) -> bool {
+        &**self == other
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use insta::assert_debug_snapshot;
+
+    use crate::db::tests::{create_resolver_builder, TestCase, TestDb};
+    use crate::supported_py_version::TargetVersion;
+    use crate::typeshed::LazyTypeshedVersions;
+
+    use super::*;
+
+    impl ModuleResolutionPathBuf {
+        #[must_use]
+        pub(crate) fn join(&self, component: &str) -> Self {
+            ModuleResolutionPathRef::from(self).join(component)
+        }
+    }
+
+    impl<'a> ModuleResolutionPathRef<'a> {
+        #[must_use]
+        fn join(
+            &self,
+            component: &'a (impl AsRef<FileSystemPath> + ?Sized),
+        ) -> ModuleResolutionPathBuf {
+            let mut result = self.to_path_buf();
+            result.push(component.as_ref().as_str());
+            result
+        }
+
+        #[must_use]
+        pub(crate) fn to_path_buf(self) -> ModuleResolutionPathBuf {
+            let inner = match self.0 {
+                ModuleResolutionPathRefInner::Extra(path) => {
+                    ModuleResolutionPathBufInner::Extra(path.to_path_buf())
+                }
+                ModuleResolutionPathRefInner::FirstParty(path) => {
+                    ModuleResolutionPathBufInner::FirstParty(path.to_path_buf())
+                }
+                ModuleResolutionPathRefInner::StandardLibrary(path) => {
+                    ModuleResolutionPathBufInner::StandardLibrary(path.to_path_buf())
+                }
+                ModuleResolutionPathRefInner::SitePackages(path) => {
+                    ModuleResolutionPathBufInner::SitePackages(path.to_path_buf())
+                }
+            };
+            ModuleResolutionPathBuf(inner)
+        }
+
+        #[must_use]
+        pub(crate) const fn is_stdlib_search_path(&self) -> bool {
+            matches!(&self.0, ModuleResolutionPathRefInner::StandardLibrary(_))
+        }
+    }
+
+    #[test]
+    fn constructor_rejects_non_pyi_stdlib_paths() {
+        assert_eq!(ModuleResolutionPathBuf::standard_library("foo.py"), None);
+        assert_eq!(
+            ModuleResolutionPathBuf::standard_library("foo/__init__.py"),
+            None
+        );
+    }
+
+    #[test]
+    fn path_buf_debug_impl() {
+        assert_debug_snapshot!(
+            ModuleResolutionPathBuf::standard_library("foo/bar.pyi").unwrap(),
+            @r###"
+        ModuleResolutionPathBuf::StandardLibrary(
+            "foo/bar.pyi",
+        )
+        "###
+        );
+    }
+
+    #[test]
+    fn path_ref_debug_impl() {
+        assert_debug_snapshot!(
+            ModuleResolutionPathRef(ModuleResolutionPathRefInner::Extra(FileSystemPath::new("foo/bar.py"))),
+            @r###"
+        ModuleResolutionPathRef::Extra(
+            "foo/bar.py",
+        )
+        "###
+        );
+    }
+
+    #[test]
+    fn with_extension_methods() {
+        assert_eq!(
+            ModuleResolutionPathBuf::standard_library("foo")
+                .unwrap()
+                .with_py_extension(),
+            None
+        );
+
+        assert_eq!(
+            ModuleResolutionPathBuf::standard_library("foo")
+                .unwrap()
+                .with_pyi_extension(),
+            ModuleResolutionPathBuf(ModuleResolutionPathBufInner::StandardLibrary(
+                FileSystemPathBuf::from("foo.pyi")
+            ))
+        );
+
+        assert_eq!(
+            ModuleResolutionPathBuf::first_party("foo/bar")
+                .unwrap()
+                .with_py_extension()
+                .unwrap(),
+            ModuleResolutionPathBuf(ModuleResolutionPathBufInner::FirstParty(
+                FileSystemPathBuf::from("foo/bar.py")
+            ))
+        );
+    }
+
+    #[test]
+    fn module_name_1_part() {
+        assert_eq!(
+            ModuleResolutionPathRef(ModuleResolutionPathRefInner::Extra(FileSystemPath::new(
+                "foo"
+            )))
+            .to_module_name(),
+            ModuleName::new_static("foo")
+        );
+
+        assert_eq!(
+            ModuleResolutionPathRef(ModuleResolutionPathRefInner::StandardLibrary(
+                FileSystemPath::new("foo.pyi")
+            ))
+            .to_module_name(),
+            ModuleName::new_static("foo")
+        );
+
+        assert_eq!(
+            ModuleResolutionPathRef(ModuleResolutionPathRefInner::FirstParty(
+                FileSystemPath::new("foo/__init__.py")
+            ))
+            .to_module_name(),
+            ModuleName::new_static("foo")
+        );
+    }
+
+    #[test]
+    fn module_name_2_parts() {
+        assert_eq!(
+            ModuleResolutionPathRef(ModuleResolutionPathRefInner::StandardLibrary(
+                FileSystemPath::new("foo/bar")
+            ))
+            .to_module_name(),
+            ModuleName::new_static("foo.bar")
+        );
+
+        assert_eq!(
+            ModuleResolutionPathRef(ModuleResolutionPathRefInner::Extra(FileSystemPath::new(
+                "foo/bar.pyi"
+            )))
+            .to_module_name(),
+            ModuleName::new_static("foo.bar")
+        );
+
+        assert_eq!(
+            ModuleResolutionPathRef(ModuleResolutionPathRefInner::SitePackages(
+                FileSystemPath::new("foo/bar/__init__.pyi")
+            ))
+            .to_module_name(),
+            ModuleName::new_static("foo.bar")
+        );
+    }
+
+    #[test]
+    fn module_name_3_parts() {
+        assert_eq!(
+            ModuleResolutionPathRef(ModuleResolutionPathRefInner::SitePackages(
+                FileSystemPath::new("foo/bar/__init__.pyi")
+            ))
+            .to_module_name(),
+            ModuleName::new_static("foo.bar")
+        );
+
+        assert_eq!(
+            ModuleResolutionPathRef(ModuleResolutionPathRefInner::SitePackages(
+                FileSystemPath::new("foo/bar/baz")
+            ))
+            .to_module_name(),
+            ModuleName::new_static("foo.bar.baz")
+        );
+    }
+
+    #[test]
+    fn join() {
+        assert_eq!(
+            ModuleResolutionPathBuf::standard_library("foo")
+                .unwrap()
+                .join("bar"),
+            ModuleResolutionPathBuf(ModuleResolutionPathBufInner::StandardLibrary(
+                FileSystemPathBuf::from("foo/bar")
+            ))
+        );
+        assert_eq!(
+            ModuleResolutionPathBuf::standard_library("foo")
+                .unwrap()
+                .join("bar.pyi"),
+            ModuleResolutionPathBuf(ModuleResolutionPathBufInner::StandardLibrary(
+                FileSystemPathBuf::from("foo/bar.pyi")
+            ))
+        );
+        assert_eq!(
+            ModuleResolutionPathBuf::extra("foo")
+                .unwrap()
+                .join("bar.py"),
+            ModuleResolutionPathBuf(ModuleResolutionPathBufInner::Extra(
+                FileSystemPathBuf::from("foo/bar.py")
+            ))
+        );
+    }
+
+    #[test]
+    #[should_panic(expected = "Extension must be `pyi`; got `py`")]
+    fn stdlib_path_invalid_join_py() {
+        ModuleResolutionPathBuf::standard_library("foo")
+            .unwrap()
+            .push("bar.py");
+    }
+
+    #[test]
+    #[should_panic(expected = "Extension must be `pyi`; got `rs`")]
+    fn stdlib_path_invalid_join_rs() {
+        ModuleResolutionPathBuf::standard_library("foo")
+            .unwrap()
+            .push("bar.rs");
+    }
+
+    #[test]
+    #[should_panic(expected = "Extension must be `py` or `pyi`; got `rs`")]
+    fn non_stdlib_path_invalid_join_rs() {
+        ModuleResolutionPathBuf::site_packages("foo")
+            .unwrap()
+            .push("bar.rs");
+    }
+
+    #[test]
+    #[should_panic(expected = "already has an extension")]
+    fn invalid_stdlib_join_too_many_extensions() {
+        ModuleResolutionPathBuf::standard_library("foo.pyi")
+            .unwrap()
+            .push("bar.pyi");
+    }
+
+    #[test]
+    fn relativize_stdlib_path_errors() {
+        let root = ModuleResolutionPathBuf::standard_library("foo/stdlib").unwrap();
+
+        // Must have a `.pyi` extension or no extension:
+        let bad_absolute_path = FileSystemPath::new("foo/stdlib/x.py");
+        assert_eq!(root.relativize_path(bad_absolute_path), None);
+        let second_bad_absolute_path = FileSystemPath::new("foo/stdlib/x.rs");
+        assert_eq!(root.relativize_path(second_bad_absolute_path), None);
+
+        // Must be a path that is a child of `root`:
+        let third_bad_absolute_path = FileSystemPath::new("bar/stdlib/x.pyi");
+        assert_eq!(root.relativize_path(third_bad_absolute_path), None);
+    }
+
+    #[test]
+    fn relativize_non_stdlib_path_errors() {
+        let root = ModuleResolutionPathBuf::extra("foo/stdlib").unwrap();
+        // Must have a `.py` extension, a `.pyi` extension, or no extension:
+        let bad_absolute_path = FileSystemPath::new("foo/stdlib/x.rs");
+        assert_eq!(root.relativize_path(bad_absolute_path), None);
+        // Must be a path that is a child of `root`:
+        let second_bad_absolute_path = FileSystemPath::new("bar/stdlib/x.pyi");
+        assert_eq!(root.relativize_path(second_bad_absolute_path), None);
+    }
+
+    #[test]
+    fn relativize_path() {
+        assert_eq!(
+            ModuleResolutionPathBuf::standard_library("foo/baz")
+                .unwrap()
+                .relativize_path("foo/baz/eggs/__init__.pyi")
+                .unwrap(),
+            ModuleResolutionPathRef(ModuleResolutionPathRefInner::StandardLibrary(
+                FileSystemPath::new("eggs/__init__.pyi")
+            ))
+        );
+    }
+
+    fn py38_stdlib_test_case() -> (TestDb, ModuleResolutionPathBuf) {
+        let TestCase {
+            db,
+            custom_typeshed,
+            ..
+        } = create_resolver_builder().unwrap().build();
+        let stdlib_module_path =
+            ModuleResolutionPathBuf::stdlib_from_typeshed_root(&custom_typeshed).unwrap();
+        (db, stdlib_module_path)
+    }
+
+    #[test]
+    fn mocked_typeshed_existing_regular_stdlib_pkg_py38() {
+        let (db, stdlib_path) = py38_stdlib_test_case();
+        let resolver = ResolverState {
+            db: &db,
+            typeshed_versions: LazyTypeshedVersions::new(),
+            target_version: TargetVersion::Py38,
+        };
+
+        let asyncio_regular_package = stdlib_path.join("asyncio");
+        assert!(asyncio_regular_package.is_directory(&stdlib_path, &resolver));
+        assert!(asyncio_regular_package.is_regular_package(&stdlib_path, &resolver));
+        // Paths to directories don't resolve to VfsFiles
+        assert_eq!(
+            asyncio_regular_package.to_vfs_file(&stdlib_path, &resolver),
+            None
+        );
+        assert!(asyncio_regular_package
+            .join("__init__.pyi")
+            .to_vfs_file(&stdlib_path, &resolver)
+            .is_some());
+
+        // The `asyncio` package exists on Python 3.8, but the `asyncio.tasks` submodule does not,
+        // according to the `VERSIONS` file in our typeshed mock:
+        let asyncio_tasks_module = stdlib_path.join("asyncio/tasks.pyi");
+        assert_eq!(
+            asyncio_tasks_module.to_vfs_file(&stdlib_path, &resolver),
+            None
+        );
+        assert!(!asyncio_tasks_module.is_directory(&stdlib_path, &resolver));
+        assert!(!asyncio_tasks_module.is_regular_package(&stdlib_path, &resolver));
+    }
+
+    #[test]
+    fn mocked_typeshed_existing_namespace_stdlib_pkg_py38() {
+        let (db, stdlib_path) = py38_stdlib_test_case();
+        let resolver = ResolverState {
+            db: &db,
+            typeshed_versions: LazyTypeshedVersions::new(),
+            target_version: TargetVersion::Py38,
+        };
+
+        let xml_namespace_package = stdlib_path.join("xml");
+        assert!(xml_namespace_package.is_directory(&stdlib_path, &resolver));
+        // Paths to directories don't resolve to VfsFiles
+        assert_eq!(
+            xml_namespace_package.to_vfs_file(&stdlib_path, &resolver),
+            None
+        );
+        assert!(!xml_namespace_package.is_regular_package(&stdlib_path, &resolver));
+
+        let xml_etree = stdlib_path.join("xml/etree.pyi");
+        assert!(!xml_etree.is_directory(&stdlib_path, &resolver));
+        assert!(xml_etree.to_vfs_file(&stdlib_path, &resolver).is_some());
+        assert!(!xml_etree.is_regular_package(&stdlib_path, &resolver));
+    }
+
+    #[test]
+    fn mocked_typeshed_single_file_stdlib_module_py38() {
+        let (db, stdlib_path) = py38_stdlib_test_case();
+        let resolver = ResolverState {
+            db: &db,
+            typeshed_versions: LazyTypeshedVersions::new(),
+            target_version: TargetVersion::Py38,
+        };
+
+        let functools_module = stdlib_path.join("functools.pyi");
+        assert!(functools_module
+            .to_vfs_file(&stdlib_path, &resolver)
+            .is_some());
+        assert!(!functools_module.is_directory(&stdlib_path, &resolver));
+        assert!(!functools_module.is_regular_package(&stdlib_path, &resolver));
+    }
+
+    #[test]
+    fn mocked_typeshed_nonexistent_regular_stdlib_pkg_py38() {
+        let (db, stdlib_path) = py38_stdlib_test_case();
+        let resolver = ResolverState {
+            db: &db,
+            typeshed_versions: LazyTypeshedVersions::new(),
+            target_version: TargetVersion::Py38,
+        };
+
+        let collections_regular_package = stdlib_path.join("collections");
+        assert_eq!(
+            collections_regular_package.to_vfs_file(&stdlib_path, &resolver),
+            None
+        );
+        assert!(!collections_regular_package.is_directory(&stdlib_path, &resolver));
+        assert!(!collections_regular_package.is_regular_package(&stdlib_path, &resolver));
+    }
+
+    #[test]
+    fn mocked_typeshed_nonexistent_namespace_stdlib_pkg_py38() {
+        let (db, stdlib_path) = py38_stdlib_test_case();
+        let resolver = ResolverState {
+            db: &db,
+            typeshed_versions: LazyTypeshedVersions::new(),
+            target_version: TargetVersion::Py38,
+        };
+
+        let importlib_namespace_package = stdlib_path.join("importlib");
+        assert_eq!(
+            importlib_namespace_package.to_vfs_file(&stdlib_path, &resolver),
+            None
+        );
+        assert!(!importlib_namespace_package.is_directory(&stdlib_path, &resolver));
+        assert!(!importlib_namespace_package.is_regular_package(&stdlib_path, &resolver));
+
+        let importlib_abc = stdlib_path.join("importlib/abc.pyi");
+        assert_eq!(importlib_abc.to_vfs_file(&stdlib_path, &resolver), None);
+        assert!(!importlib_abc.is_directory(&stdlib_path, &resolver));
+        assert!(!importlib_abc.is_regular_package(&stdlib_path, &resolver));
+    }
+
+    #[test]
+    fn mocked_typeshed_nonexistent_single_file_module_py38() {
+        let (db, stdlib_path) = py38_stdlib_test_case();
+        let resolver = ResolverState {
+            db: &db,
+            typeshed_versions: LazyTypeshedVersions::new(),
+            target_version: TargetVersion::Py38,
+        };
+
+        let non_existent = stdlib_path.join("doesnt_even_exist");
+        assert_eq!(non_existent.to_vfs_file(&stdlib_path, &resolver), None);
+        assert!(!non_existent.is_directory(&stdlib_path, &resolver));
+        assert!(!non_existent.is_regular_package(&stdlib_path, &resolver));
+    }
+
+    fn py39_stdlib_test_case() -> (TestDb, ModuleResolutionPathBuf) {
+        let TestCase {
+            db,
+            custom_typeshed,
+            ..
+        } = create_resolver_builder()
+            .unwrap()
+            .with_target_version(TargetVersion::Py39)
+            .build();
+        let stdlib_module_path =
+            ModuleResolutionPathBuf::stdlib_from_typeshed_root(&custom_typeshed).unwrap();
+        (db, stdlib_module_path)
+    }
+
+    #[test]
+    fn mocked_typeshed_existing_regular_stdlib_pkgs_py39() {
+        let (db, stdlib_path) = py39_stdlib_test_case();
+        let resolver = ResolverState {
+            db: &db,
+            typeshed_versions: LazyTypeshedVersions::new(),
+            target_version: TargetVersion::Py39,
+        };
+
+        // Since we've set the target version to Py39,
+        // `collections` should now exist as a directory, according to VERSIONS...
+        let collections_regular_package = stdlib_path.join("collections");
+        assert!(collections_regular_package.is_directory(&stdlib_path, &resolver));
+        assert!(collections_regular_package.is_regular_package(&stdlib_path, &resolver));
+        // (This is still `None`, as directories don't resolve to `Vfs` files)
+        assert_eq!(
+            collections_regular_package.to_vfs_file(&stdlib_path, &resolver),
+            None
+        );
+        assert!(collections_regular_package
+            .join("__init__.pyi")
+            .to_vfs_file(&stdlib_path, &resolver)
+            .is_some());
+
+        // ...and so should the `asyncio.tasks` submodule (though it's still not a directory):
+        let asyncio_tasks_module = stdlib_path.join("asyncio/tasks.pyi");
+        assert!(asyncio_tasks_module
+            .to_vfs_file(&stdlib_path, &resolver)
+            .is_some());
+        assert!(!asyncio_tasks_module.is_directory(&stdlib_path, &resolver));
+        assert!(!asyncio_tasks_module.is_regular_package(&stdlib_path, &resolver));
+    }
+
+    #[test]
+    fn mocked_typeshed_existing_namespace_stdlib_pkg_py39() {
+        let (db, stdlib_path) = py39_stdlib_test_case();
+        let resolver = ResolverState {
+            db: &db,
+            typeshed_versions: LazyTypeshedVersions::new(),
+            target_version: TargetVersion::Py39,
+        };
+
+        // The `importlib` directory now also exists...
+        let importlib_namespace_package = stdlib_path.join("importlib");
+        assert!(importlib_namespace_package.is_directory(&stdlib_path, &resolver));
+        assert!(!importlib_namespace_package.is_regular_package(&stdlib_path, &resolver));
+        // (This is still `None`, as directories don't resolve to `Vfs` files)
+        assert_eq!(
+            importlib_namespace_package.to_vfs_file(&stdlib_path, &resolver),
+            None
+        );
+
+        // ...As do submodules in the `importlib` namespace package:
+        let importlib_abc = importlib_namespace_package.join("abc.pyi");
+        assert!(!importlib_abc.is_directory(&stdlib_path, &resolver));
+        assert!(!importlib_abc.is_regular_package(&stdlib_path, &resolver));
+        assert!(importlib_abc.to_vfs_file(&stdlib_path, &resolver).is_some());
+    }
+
+    #[test]
+    fn mocked_typeshed_nonexistent_namespace_stdlib_pkg_py39() {
+        let (db, stdlib_path) = py39_stdlib_test_case();
+        let resolver = ResolverState {
+            db: &db,
+            typeshed_versions: LazyTypeshedVersions::new(),
+            target_version: TargetVersion::Py39,
+        };
+
+        // The `xml` package no longer exists on py39:
+        let xml_namespace_package = stdlib_path.join("xml");
+        assert_eq!(
+            xml_namespace_package.to_vfs_file(&stdlib_path, &resolver),
+            None
+        );
+        assert!(!xml_namespace_package.is_directory(&stdlib_path, &resolver));
+        assert!(!xml_namespace_package.is_regular_package(&stdlib_path, &resolver));
+
+        let xml_etree = xml_namespace_package.join("etree.pyi");
+        assert_eq!(xml_etree.to_vfs_file(&stdlib_path, &resolver), None);
+        assert!(!xml_etree.is_directory(&stdlib_path, &resolver));
+        assert!(!xml_etree.is_regular_package(&stdlib_path, &resolver));
+    }
+}

crates/red_knot_module_resolver/src/resolver.rs

@@ -1,28 +1,29 @@
-use salsa::DebugWithDb;
 use std::ops::Deref;
+use std::sync::Arc;
 
-use ruff_db::file_system::{FileSystem, FileSystemPath, FileSystemPathBuf};
-use ruff_db::vfs::{system_path_to_file, vfs_path_to_file, VfsFile, VfsPath};
+use ruff_db::file_system::FileSystemPathBuf;
+use ruff_db::vfs::{vfs_path_to_file, VfsFile, VfsPath};
 
-use crate::module::{Module, ModuleKind, ModuleName, ModuleSearchPath, ModuleSearchPathKind};
-use crate::resolver::internal::ModuleResolverSearchPaths;
-use crate::Db;
+use crate::db::Db;
+use crate::module::{Module, ModuleKind};
+use crate::module_name::ModuleName;
+use crate::path::ModuleResolutionPathBuf;
+use crate::resolver::internal::ModuleResolverSettings;
+use crate::state::ResolverState;
+use crate::supported_py_version::TargetVersion;
 
-const TYPESHED_STDLIB_DIRECTORY: &str = "stdlib";
-
-/// Configures the module search paths for the module resolver.
+/// Configures the module resolver settings.
 ///
 /// Must be called before calling any other module resolution functions.
-pub fn set_module_resolution_settings(db: &mut dyn Db, config: ModuleResolutionSettings) {
+pub fn set_module_resolution_settings(db: &mut dyn Db, config: RawModuleResolutionSettings) {
     // There's no concurrency issue here because we hold a `&mut dyn Db` reference. No other
     // thread can mutate the `Db` while we're in this call, so using `try_get` to test if
     // the settings have already been set is safe.
-    if let Some(existing) = ModuleResolverSearchPaths::try_get(db) {
-        existing
-            .set_search_paths(db)
-            .to(config.into_ordered_search_paths());
+    let resolved_settings = config.into_configuration_settings();
+    if let Some(existing) = ModuleResolverSettings::try_get(db) {
+        existing.set_settings(db).to(resolved_settings);
     } else {
-        ModuleResolverSearchPaths::new(db, config.into_ordered_search_paths());
+        ModuleResolverSettings::new(db, resolved_settings);
     }
 }
 
@@ -42,7 +43,7 @@ pub(crate) fn resolve_module_query<'db>(
     db: &'db dyn Db,
     module_name: internal::ModuleNameIngredient<'db>,
 ) -> Option<Module> {
-    let _ = tracing::trace_span!("resolve_module", module_name = ?module_name.debug(db)).enter();
+    let _span = tracing::trace_span!("resolve_module", ?module_name).entered();
 
     let name = module_name.name(db);
 
@@ -55,9 +56,9 @@ pub(crate) fn resolve_module_query<'db>(
 
 /// Resolves the module for the given path.
 ///
-/// Returns `None` if the path is not a module locatable via `sys.path`.
-#[tracing::instrument(level = "debug", skip(db))]
-pub fn path_to_module(db: &dyn Db, path: &VfsPath) -> Option<Module> {
+/// Returns `None` if the path is not a module locatable via any of the known search paths.
+#[allow(unused)]
+pub(crate) fn path_to_module(db: &dyn Db, path: &VfsPath) -> Option<Module> {
     // It's not entirely clear on first sight why this method calls `file_to_module` instead of
     // it being the other way round, considering that the first thing that `file_to_module` does
     // is to retrieve the file's path.
@@ -72,31 +73,23 @@ pub fn path_to_module(db: &dyn Db, path: &VfsPath) -> Option<Module> {
 
 /// Resolves the module for the file with the given id.
 ///
-/// Returns `None` if the file is not a module locatable via `sys.path`.
+/// Returns `None` if the file is not a module locatable via any of the known search paths.
 #[salsa::tracked]
-#[allow(unused)]
 pub(crate) fn file_to_module(db: &dyn Db, file: VfsFile) -> Option<Module> {
-    let _ = tracing::trace_span!("file_to_module", file = ?file.debug(db.upcast())).enter();
+    let _span = tracing::trace_span!("file_to_module", ?file).entered();
 
-    let path = file.path(db.upcast());
+    let VfsPath::FileSystem(path) = file.path(db.upcast()) else {
+        todo!("VendoredPaths are not yet supported")
+    };
 
-    let search_paths = module_search_paths(db);
+    let resolver_settings = module_resolver_settings(db);
 
-    let relative_path = search_paths
+    let relative_path = resolver_settings
+        .search_paths()
         .iter()
-        .find_map(|root| match (root.path(), path) {
-            (VfsPath::FileSystem(root_path), VfsPath::FileSystem(path)) => {
-                let relative_path = path.strip_prefix(root_path).ok()?;
-                Some(relative_path)
-            }
-            (VfsPath::Vendored(_), VfsPath::Vendored(_)) => {
-                todo!("Add support for vendored modules")
-            }
-            (VfsPath::Vendored(_), VfsPath::FileSystem(_))
-            | (VfsPath::FileSystem(_), VfsPath::Vendored(_)) => None,
-        })?;
+        .find_map(|root| root.relativize_path(path))?;
 
-    let module_name = ModuleName::from_relative_path(relative_path)?;
+    let module_name = relative_path.to_module_name()?;
 
     // Resolve the module name to see if Python would resolve the name to the same path.
     // If it doesn't, then that means that multiple modules have the same name in different
@@ -118,9 +111,12 @@ pub(crate) fn file_to_module(db: &dyn Db, file: VfsFile) -> Option<Module> {
     }
 }
 
-/// Configures the search paths that are used to resolve modules.
+/// "Raw" configuration settings for module resolution: unvalidated, unnormalized
 #[derive(Eq, PartialEq, Debug)]
-pub struct ModuleResolutionSettings {
+pub struct RawModuleResolutionSettings {
+    /// The target Python version the user has specified
+    pub target_version: TargetVersion,
+
     /// List of user-provided paths that should take first priority in the module resolution.
     /// Examples in other type checkers are mypy's MYPYPATH environment variable,
     /// or pyright's stubPath configuration setting.
@@ -129,83 +125,103 @@ pub struct ModuleResolutionSettings {
     /// The root of the workspace, used for finding first-party modules.
     pub workspace_root: FileSystemPathBuf,
 
+    /// Optional (already validated) path to standard-library typeshed stubs.
+    /// If this is not provided, we will fallback to our vendored typeshed stubs
+    /// bundled as a zip file in the binary
+    pub custom_typeshed: Option<FileSystemPathBuf>,
+
     /// The path to the user's `site-packages` directory, where third-party packages from ``PyPI`` are installed.
     pub site_packages: Option<FileSystemPathBuf>,
-
-    /// Optional path to standard-library typeshed stubs.
-    /// Currently this has to be a directory that exists on disk.
-    ///
-    /// (TODO: fall back to vendored stubs if no custom directory is provided.)
-    pub custom_typeshed: Option<FileSystemPathBuf>,
 }
 
-impl ModuleResolutionSettings {
-    /// Implementation of PEP 561's module resolution order
-    /// (with some small, deliberate, differences)
-    fn into_ordered_search_paths(self) -> OrderedSearchPaths {
-        let ModuleResolutionSettings {
+impl RawModuleResolutionSettings {
+    /// Implementation of the typing spec's [module resolution order]
+    ///
+    /// TODO(Alex): this method does multiple `.unwrap()` calls when it should really return an error.
+    /// Each `.unwrap()` call is a point where we're validating a setting that the user would pass
+    /// and transforming it into an internal representation for a validated path.
+    /// Rather than panicking if a path fails to validate, we should display an error message to the user
+    /// and exit the process with a nonzero exit code.
+    /// This validation should probably be done outside of Salsa?
+    ///
+    /// [module resolution order]: https://typing.readthedocs.io/en/latest/spec/distributing.html#import-resolution-ordering
+    fn into_configuration_settings(self) -> ModuleResolutionSettings {
+        let RawModuleResolutionSettings {
+            target_version,
             extra_paths,
             workspace_root,
             site_packages,
             custom_typeshed,
         } = self;
 
-        let mut paths: Vec<_> = extra_paths
+        let mut paths: Vec<ModuleResolutionPathBuf> = extra_paths
             .into_iter()
-            .map(|path| ModuleSearchPath::new(path, ModuleSearchPathKind::Extra))
+            .map(|fs_path| ModuleResolutionPathBuf::extra(fs_path).unwrap())
             .collect();
 
-        paths.push(ModuleSearchPath::new(
-            workspace_root,
-            ModuleSearchPathKind::FirstParty,
-        ));
+        paths.push(ModuleResolutionPathBuf::first_party(workspace_root).unwrap());
 
-        // TODO fallback to vendored typeshed stubs if no custom typeshed directory is provided by the user
         if let Some(custom_typeshed) = custom_typeshed {
-            paths.push(ModuleSearchPath::new(
-                custom_typeshed.join(TYPESHED_STDLIB_DIRECTORY),
-                ModuleSearchPathKind::StandardLibrary,
-            ));
+            paths.push(
+                ModuleResolutionPathBuf::stdlib_from_typeshed_root(&custom_typeshed).unwrap(),
+            );
         }
 
         // TODO vendor typeshed's third-party stubs as well as the stdlib and fallback to them as a final step
         if let Some(site_packages) = site_packages {
-            paths.push(ModuleSearchPath::new(
-                site_packages,
-                ModuleSearchPathKind::SitePackagesThirdParty,
-            ));
+            paths.push(ModuleResolutionPathBuf::site_packages(site_packages).unwrap());
         }
 
-        OrderedSearchPaths(paths)
+        ModuleResolutionSettings {
+            target_version,
+            search_paths: OrderedSearchPaths(paths.into_iter().map(Arc::new).collect()),
+        }
     }
 }
 
-/// A resolved module resolution order, implementing PEP 561
-/// (with some small, deliberate differences)
+/// A resolved module resolution order as per the [typing spec]
+///
+/// [typing spec]: https://typing.readthedocs.io/en/latest/spec/distributing.html#import-resolution-ordering
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
-pub(crate) struct OrderedSearchPaths(Vec<ModuleSearchPath>);
+pub(crate) struct OrderedSearchPaths(Vec<Arc<ModuleResolutionPathBuf>>);
 
 impl Deref for OrderedSearchPaths {
-    type Target = [ModuleSearchPath];
+    type Target = [Arc<ModuleResolutionPathBuf>];
 
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct ModuleResolutionSettings {
+    search_paths: OrderedSearchPaths,
+    target_version: TargetVersion,
+}
+
+impl ModuleResolutionSettings {
+    pub(crate) fn search_paths(&self) -> &[Arc<ModuleResolutionPathBuf>] {
+        &self.search_paths
+    }
+
+    pub(crate) fn target_version(&self) -> TargetVersion {
+        self.target_version
+    }
+}
+
 // The singleton methods generated by salsa are all `pub` instead of `pub(crate)` which triggers
 // `unreachable_pub`. Work around this by creating a module and allow `unreachable_pub` for it.
 // Salsa also generates uses to `_db` variables for `interned` which triggers `clippy::used_underscore_binding`. Suppress that too
 // TODO(micha): Contribute a fix for this upstream where the singleton methods have the same visibility as the struct.
 #[allow(unreachable_pub, clippy::used_underscore_binding)]
 pub(crate) mod internal {
-    use crate::module::ModuleName;
-    use crate::resolver::OrderedSearchPaths;
+    use crate::module_name::ModuleName;
+    use crate::resolver::ModuleResolutionSettings;
 
     #[salsa::input(singleton)]
-    pub(crate) struct ModuleResolverSearchPaths {
+    pub(crate) struct ModuleResolverSettings {
         #[return_ref]
-        pub(super) search_paths: OrderedSearchPaths,
+        pub(super) settings: ModuleResolutionSettings,
     }
 
     /// A thin wrapper around `ModuleName` to make it a Salsa ingredient.
@@ -218,31 +234,31 @@ pub(crate) mod internal {
     }
 }
 
-fn module_search_paths(db: &dyn Db) -> &[ModuleSearchPath] {
-    ModuleResolverSearchPaths::get(db).search_paths(db)
+fn module_resolver_settings(db: &dyn Db) -> &ModuleResolutionSettings {
+    ModuleResolverSettings::get(db).settings(db)
 }
 
 /// Given a module name and a list of search paths in which to lookup modules,
 /// attempt to resolve the module name
-fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(ModuleSearchPath, VfsFile, ModuleKind)> {
-    let search_paths = module_search_paths(db);
+fn resolve_name(
+    db: &dyn Db,
+    name: &ModuleName,
+) -> Option<(Arc<ModuleResolutionPathBuf>, VfsFile, ModuleKind)> {
+    let resolver_settings = module_resolver_settings(db);
+    let resolver_state = ResolverState::new(db, resolver_settings.target_version());
 
-    for search_path in search_paths {
+    for search_path in resolver_settings.search_paths() {
         let mut components = name.components();
         let module_name = components.next_back()?;
 
-        let VfsPath::FileSystem(fs_search_path) = search_path.path() else {
-            todo!("Vendored search paths are not yet supported");
-        };
-
-        match resolve_package(db.file_system(), fs_search_path, components) {
+        match resolve_package(search_path, components, &resolver_state) {
             Ok(resolved_package) => {
                 let mut package_path = resolved_package.path;
 
                 package_path.push(module_name);
 
                 // Must be a `__init__.pyi` or `__init__.py` or it isn't a package.
-                let kind = if db.file_system().is_directory(&package_path) {
+                let kind = if package_path.is_directory(search_path, &resolver_state) {
                     package_path.push("__init__");
                     ModuleKind::Package
                 } else {
@@ -250,15 +266,17 @@ fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(ModuleSearchPath, Vfs
                 };
 
                 // TODO Implement full https://peps.python.org/pep-0561/#type-checker-module-resolution-order resolution
-                let stub = package_path.with_extension("pyi");
-
-                if let Some(stub) = system_path_to_file(db.upcast(), &stub) {
+                if let Some(stub) = package_path
+                    .with_pyi_extension()
+                    .to_vfs_file(search_path, &resolver_state)
+                {
                     return Some((search_path.clone(), stub, kind));
                 }
 
-                let module = package_path.with_extension("py");
-
-                if let Some(module) = system_path_to_file(db.upcast(), &module) {
+                if let Some(module) = package_path
+                    .with_py_extension()
+                    .and_then(|path| path.to_vfs_file(search_path, &resolver_state))
+                {
                     return Some((search_path.clone(), module, kind));
                 }
 
@@ -280,15 +298,15 @@ fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(ModuleSearchPath, Vfs
     None
 }
 
-fn resolve_package<'a, I>(
-    fs: &dyn FileSystem,
-    module_search_path: &FileSystemPath,
+fn resolve_package<'a, 'db, I>(
+    module_search_path: &ModuleResolutionPathBuf,
     components: I,
+    resolver_state: &ResolverState<'db>,
 ) -> Result<ResolvedPackage, PackageKind>
 where
     I: Iterator<Item = &'a str>,
 {
-    let mut package_path = module_search_path.to_path_buf();
+    let mut package_path = module_search_path.clone();
 
     // `true` if inside a folder that is a namespace package (has no `__init__.py`).
     // Namespace packages are special because they can be spread across multiple search paths.
@@ -302,12 +320,12 @@ where
     for folder in components {
         package_path.push(folder);
 
-        let has_init_py = fs.is_file(&package_path.join("__init__.py"))
-            || fs.is_file(&package_path.join("__init__.pyi"));
+        let is_regular_package =
+            package_path.is_regular_package(module_search_path, resolver_state);
 
-        if has_init_py {
+        if is_regular_package {
             in_namespace_package = false;
-        } else if fs.is_directory(&package_path) {
+        } else if package_path.is_directory(module_search_path, resolver_state) {
             // A directory without an `__init__.py` is a namespace package, continue with the next folder.
             in_namespace_package = true;
         } else if in_namespace_package {
@@ -340,7 +358,7 @@ where
 
 #[derive(Debug)]
 struct ResolvedPackage {
-    path: FileSystemPathBuf,
+    path: ModuleResolutionPathBuf,
     kind: PackageKind,
 }
 
@@ -368,59 +386,22 @@ impl PackageKind {
 
 #[cfg(test)]
 mod tests {
-
-    use ruff_db::file_system::{FileSystemPath, FileSystemPathBuf};
+    use ruff_db::file_system::FileSystemPath;
     use ruff_db::vfs::{system_path_to_file, VfsFile, VfsPath};
 
-    use crate::db::tests::TestDb;
-    use crate::module::{ModuleKind, ModuleName};
+    use crate::db::tests::{create_resolver_builder, TestCase};
+    use crate::module::ModuleKind;
+    use crate::module_name::ModuleName;
 
-    use super::{
-        path_to_module, resolve_module, set_module_resolution_settings, ModuleResolutionSettings,
-        TYPESHED_STDLIB_DIRECTORY,
-    };
+    use super::*;
 
-    struct TestCase {
-        db: TestDb,
-
-        src: FileSystemPathBuf,
-        custom_typeshed: FileSystemPathBuf,
-        site_packages: FileSystemPathBuf,
-    }
-
-    fn create_resolver() -> std::io::Result<TestCase> {
-        let mut db = TestDb::new();
-
-        let src = FileSystemPath::new("src").to_path_buf();
-        let site_packages = FileSystemPath::new("site_packages").to_path_buf();
-        let custom_typeshed = FileSystemPath::new("typeshed").to_path_buf();
-
-        let fs = db.memory_file_system();
-
-        fs.create_directory_all(&src)?;
-        fs.create_directory_all(&site_packages)?;
-        fs.create_directory_all(&custom_typeshed)?;
-
-        let settings = ModuleResolutionSettings {
-            extra_paths: vec![],
-            workspace_root: src.clone(),
-            site_packages: Some(site_packages.clone()),
-            custom_typeshed: Some(custom_typeshed.clone()),
-        };
-
-        set_module_resolution_settings(&mut db, settings);
-
-        Ok(TestCase {
-            db,
-            src,
-            custom_typeshed,
-            site_packages,
-        })
+    fn setup_resolver_test() -> TestCase {
+        create_resolver_builder().unwrap().build()
     }
 
     #[test]
     fn first_party_module() -> anyhow::Result<()> {
-        let TestCase { db, src, .. } = create_resolver()?;
+        let TestCase { db, src, .. } = setup_resolver_test();
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
         let foo_path = src.join("foo.py");
@@ -435,10 +416,10 @@ mod tests {
         );
 
         assert_eq!("foo", foo_module.name());
-        assert_eq!(&src, foo_module.search_path().path());
+        assert_eq!(&src, &foo_module.search_path());
         assert_eq!(ModuleKind::Module, foo_module.kind());
-        assert_eq!(&foo_path, foo_module.file().path(&db));
 
+        assert_eq!(&foo_path, foo_module.file().path(&db));
         assert_eq!(
             Some(foo_module),
             path_to_module(&db, &VfsPath::FileSystem(foo_path))
@@ -448,18 +429,15 @@ mod tests {
     }
 
     #[test]
-    fn stdlib() -> anyhow::Result<()> {
+    fn stdlib() {
         let TestCase {
             db,
             custom_typeshed,
             ..
-        } = create_resolver()?;
-
-        let stdlib_dir = custom_typeshed.join(TYPESHED_STDLIB_DIRECTORY);
-        let functools_path = stdlib_dir.join("functools.py");
-        db.memory_file_system()
-            .write_file(&functools_path, "def update_wrapper(): ...")?;
+        } = setup_resolver_test();
 
+        let stdlib_dir =
+            ModuleResolutionPathBuf::stdlib_from_typeshed_root(&custom_typeshed).unwrap();
         let functools_module_name = ModuleName::new_static("functools").unwrap();
         let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
 
@@ -468,35 +446,127 @@ mod tests {
             resolve_module(&db, functools_module_name).as_ref()
         );
 
-        assert_eq!(&stdlib_dir, functools_module.search_path().path());
+        assert_eq!(stdlib_dir, functools_module.search_path().to_path_buf());
         assert_eq!(ModuleKind::Module, functools_module.kind());
-        assert_eq!(&functools_path.clone(), functools_module.file().path(&db));
+
+        let expected_functools_path =
+            VfsPath::FileSystem(custom_typeshed.join("stdlib/functools.pyi"));
+        assert_eq!(&expected_functools_path, functools_module.file().path(&db));
 
         assert_eq!(
             Some(functools_module),
-            path_to_module(&db, &VfsPath::FileSystem(functools_path))
+            path_to_module(&db, &expected_functools_path)
         );
+    }
 
-        Ok(())
+    fn create_module_names(raw_names: &[&str]) -> Vec<ModuleName> {
+        raw_names
+            .iter()
+            .map(|raw| ModuleName::new(raw).unwrap())
+            .collect()
+    }
+
+    #[test]
+    fn stdlib_resolution_respects_versions_file_py38_existing_modules() {
+        let TestCase {
+            db,
+            custom_typeshed,
+            ..
+        } = setup_resolver_test();
+
+        let existing_modules = create_module_names(&["asyncio", "functools", "xml.etree"]);
+        for module_name in existing_modules {
+            let resolved_module = resolve_module(&db, module_name.clone()).unwrap_or_else(|| {
+                panic!("Expected module {module_name} to exist in the mock stdlib")
+            });
+            let search_path = resolved_module.search_path();
+            assert_eq!(
+                &custom_typeshed.join("stdlib"),
+                &search_path,
+                "Search path for {module_name} was unexpectedly {search_path:?}"
+            );
+            assert!(
+                search_path.is_stdlib_search_path(),
+                "Expected a stdlib search path, but got {search_path:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn stdlib_resolution_respects_versions_file_py38_nonexisting_modules() {
+        let TestCase { db, .. } = setup_resolver_test();
+        let nonexisting_modules = create_module_names(&[
+            "collections",
+            "importlib",
+            "importlib.abc",
+            "xml",
+            "asyncio.tasks",
+        ]);
+        for module_name in nonexisting_modules {
+            assert!(
+                resolve_module(&db, module_name.clone()).is_none(),
+                "Unexpectedly resolved a module for {module_name}"
+            );
+        }
+    }
+
+    #[test]
+    fn stdlib_resolution_respects_versions_file_py39_existing_modules() {
+        let TestCase {
+            db,
+            custom_typeshed,
+            ..
+        } = create_resolver_builder()
+            .unwrap()
+            .with_target_version(TargetVersion::Py39)
+            .build();
+
+        let existing_modules = create_module_names(&[
+            "asyncio",
+            "functools",
+            "importlib.abc",
+            "collections",
+            "asyncio.tasks",
+        ]);
+        for module_name in existing_modules {
+            let resolved_module = resolve_module(&db, module_name.clone()).unwrap_or_else(|| {
+                panic!("Expected module {module_name} to exist in the mock stdlib")
+            });
+            let search_path = resolved_module.search_path();
+            assert_eq!(
+                &custom_typeshed.join("stdlib"),
+                &search_path,
+                "Search path for {module_name} was unexpectedly {search_path:?}"
+            );
+            assert!(
+                search_path.is_stdlib_search_path(),
+                "Expected a stdlib search path, but got {search_path:?}"
+            );
+        }
+    }
+    #[test]
+    fn stdlib_resolution_respects_versions_file_py39_nonexisting_modules() {
+        let TestCase { db, .. } = create_resolver_builder()
+            .unwrap()
+            .with_target_version(TargetVersion::Py39)
+            .build();
+
+        let nonexisting_modules = create_module_names(&["importlib", "xml", "xml.etree"]);
+        for module_name in nonexisting_modules {
+            assert!(
+                resolve_module(&db, module_name.clone()).is_none(),
+                "Unexpectedly resolved a module for {module_name}"
+            );
+        }
     }
 
     #[test]
     fn first_party_precedence_over_stdlib() -> anyhow::Result<()> {
-        let TestCase {
-            db,
-            src,
-            custom_typeshed,
-            ..
-        } = create_resolver()?;
+        let TestCase { db, src, .. } = setup_resolver_test();
 
-        let stdlib_dir = custom_typeshed.join(TYPESHED_STDLIB_DIRECTORY);
-        let stdlib_functools_path = stdlib_dir.join("functools.py");
         let first_party_functools_path = src.join("functools.py");
-
-        db.memory_file_system().write_files([
-            (&stdlib_functools_path, "def update_wrapper(): ..."),
-            (&first_party_functools_path, "def update_wrapper(): ..."),
-        ])?;
+        db.memory_file_system()
+            .write_file(&first_party_functools_path, "def update_wrapper(): ...")?;
 
         let functools_module_name = ModuleName::new_static("functools").unwrap();
         let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
@@ -505,10 +575,10 @@ mod tests {
             Some(&functools_module),
             resolve_module(&db, functools_module_name).as_ref()
         );
-        assert_eq!(&src, functools_module.search_path().path());
+        assert_eq!(&src, &functools_module.search_path());
         assert_eq!(ModuleKind::Module, functools_module.kind());
         assert_eq!(
-            &first_party_functools_path.clone(),
+            &first_party_functools_path,
             functools_module.file().path(&db)
         );
 
@@ -520,33 +590,9 @@ mod tests {
         Ok(())
     }
 
-    // TODO: Port typeshed test case. Porting isn't possible at the moment because the vendored zip
-    //   is part of the red knot crate
-    // #[test]
-    // fn typeshed_zip_created_at_build_time() -> anyhow::Result<()> {
-    //     // The file path here is hardcoded in this crate's `build.rs` script.
-    //     // Luckily this crate will fail to build if this file isn't available at build time.
-    //     const TYPESHED_ZIP_BYTES: &[u8] =
-    //         include_bytes!(concat!(env!("OUT_DIR"), "/zipped_typeshed.zip"));
-    //     assert!(!TYPESHED_ZIP_BYTES.is_empty());
-    //     let mut typeshed_zip_archive = ZipArchive::new(Cursor::new(TYPESHED_ZIP_BYTES))?;
-    //
-    //     let path_to_functools = Path::new("stdlib").join("functools.pyi");
-    //     let mut functools_module_stub = typeshed_zip_archive
-    //         .by_name(path_to_functools.to_str().unwrap())
-    //         .unwrap();
-    //     assert!(functools_module_stub.is_file());
-    //
-    //     let mut functools_module_stub_source = String::new();
-    //     functools_module_stub.read_to_string(&mut functools_module_stub_source)?;
-    //
-    //     assert!(functools_module_stub_source.contains("def update_wrapper("));
-    //     Ok(())
-    // }
-
     #[test]
     fn resolve_package() -> anyhow::Result<()> {
-        let TestCase { src, db, .. } = create_resolver()?;
+        let TestCase { src, db, .. } = setup_resolver_test();
 
         let foo_dir = src.join("foo");
         let foo_path = foo_dir.join("__init__.py");
@@ -557,7 +603,7 @@ mod tests {
         let foo_module = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
 
         assert_eq!("foo", foo_module.name());
-        assert_eq!(&src, foo_module.search_path().path());
+        assert_eq!(&src, &foo_module.search_path());
         assert_eq!(&foo_path, foo_module.file().path(&db));
 
         assert_eq!(
@@ -573,7 +619,7 @@ mod tests {
 
     #[test]
     fn package_priority_over_module() -> anyhow::Result<()> {
-        let TestCase { db, src, .. } = create_resolver()?;
+        let TestCase { db, src, .. } = setup_resolver_test();
 
         let foo_dir = src.join("foo");
         let foo_init = foo_dir.join("__init__.py");
@@ -587,7 +633,7 @@ mod tests {
 
         let foo_module = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
 
-        assert_eq!(&src, foo_module.search_path().path());
+        assert_eq!(&src, &foo_module.search_path());
         assert_eq!(&foo_init, foo_module.file().path(&db));
         assert_eq!(ModuleKind::Package, foo_module.kind());
 
@@ -602,7 +648,7 @@ mod tests {
 
     #[test]
     fn typing_stub_over_module() -> anyhow::Result<()> {
-        let TestCase { db, src, .. } = create_resolver()?;
+        let TestCase { db, src, .. } = setup_resolver_test();
 
         let foo_stub = src.join("foo.pyi");
         let foo_py = src.join("foo.py");
@@ -611,7 +657,7 @@ mod tests {
 
         let foo = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
 
-        assert_eq!(&src, foo.search_path().path());
+        assert_eq!(&src, &foo.search_path());
         assert_eq!(&foo_stub, foo.file().path(&db));
 
         assert_eq!(
@@ -625,7 +671,7 @@ mod tests {
 
     #[test]
     fn sub_packages() -> anyhow::Result<()> {
-        let TestCase { db, src, .. } = create_resolver()?;
+        let TestCase { db, src, .. } = setup_resolver_test();
 
         let foo = src.join("foo");
         let bar = foo.join("bar");
@@ -640,7 +686,7 @@ mod tests {
         let baz_module =
             resolve_module(&db, ModuleName::new_static("foo.bar.baz").unwrap()).unwrap();
 
-        assert_eq!(&src, baz_module.search_path().path());
+        assert_eq!(&src, &baz_module.search_path());
         assert_eq!(&baz, baz_module.file().path(&db));
 
         assert_eq!(
@@ -658,7 +704,7 @@ mod tests {
             src,
             site_packages,
             ..
-        } = create_resolver()?;
+        } = setup_resolver_test();
 
         // From [PEP420](https://peps.python.org/pep-0420/#nested-namespace-packages).
         // But uses `src` for `project1` and `site_packages2` for `project2`.
@@ -711,7 +757,7 @@ mod tests {
             src,
             site_packages,
             ..
-        } = create_resolver()?;
+        } = setup_resolver_test();
 
         // Adopted test case from the [PEP420 examples](https://peps.python.org/pep-0420/#nested-namespace-packages).
         // The `src/parent/child` package is a regular package. Therefore, `site_packages/parent/child/two.py` should not be resolved.
@@ -762,7 +808,7 @@ mod tests {
             src,
             site_packages,
             ..
-        } = create_resolver()?;
+        } = setup_resolver_test();
 
         let foo_src = src.join("foo.py");
         let foo_site_packages = site_packages.join("foo.py");
@@ -772,7 +818,7 @@ mod tests {
 
         let foo_module = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
 
-        assert_eq!(&src, foo_module.search_path().path());
+        assert_eq!(&src, &foo_module.search_path());
         assert_eq!(&foo_src, foo_module.file().path(&db));
 
         assert_eq!(
@@ -795,7 +841,7 @@ mod tests {
             src,
             site_packages,
             custom_typeshed,
-        } = create_resolver()?;
+        } = setup_resolver_test();
 
         db.with_os_file_system();
 
@@ -816,11 +862,12 @@ mod tests {
         std::fs::write(foo.as_std_path(), "")?;
         std::os::unix::fs::symlink(foo.as_std_path(), bar.as_std_path())?;
 
-        let settings = ModuleResolutionSettings {
+        let settings = RawModuleResolutionSettings {
+            target_version: TargetVersion::Py38,
             extra_paths: vec![],
             workspace_root: src.clone(),
-            site_packages: Some(site_packages),
-            custom_typeshed: Some(custom_typeshed),
+            site_packages: Some(site_packages.clone()),
+            custom_typeshed: Some(custom_typeshed.clone()),
         };
 
         set_module_resolution_settings(&mut db, settings);
@@ -830,12 +877,12 @@ mod tests {
 
         assert_ne!(foo_module, bar_module);
 
-        assert_eq!(&src, foo_module.search_path().path());
+        assert_eq!(&src, &foo_module.search_path());
         assert_eq!(&foo, foo_module.file().path(&db));
 
         // `foo` and `bar` shouldn't resolve to the same file
 
-        assert_eq!(&src, bar_module.search_path().path());
+        assert_eq!(&src, &bar_module.search_path());
         assert_eq!(&bar, bar_module.file().path(&db));
         assert_eq!(&foo, foo_module.file().path(&db));
 
@@ -854,8 +901,8 @@ mod tests {
     }
 
     #[test]
-    fn deleting_an_unrealted_file_doesnt_change_module_resolution() -> anyhow::Result<()> {
-        let TestCase { mut db, src, .. } = create_resolver()?;
+    fn deleting_an_unrelated_file_doesnt_change_module_resolution() -> anyhow::Result<()> {
+        let TestCase { mut db, src, .. } = setup_resolver_test();
 
         let foo_path = src.join("foo.py");
         let bar_path = src.join("bar.py");
@@ -892,7 +939,7 @@ mod tests {
     #[test]
     fn adding_a_file_on_which_the_module_resolution_depends_on_invalidates_the_query(
     ) -> anyhow::Result<()> {
-        let TestCase { mut db, src, .. } = create_resolver()?;
+        let TestCase { mut db, src, .. } = setup_resolver_test();
         let foo_path = src.join("foo.py");
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
@@ -912,7 +959,7 @@ mod tests {
     #[test]
     fn removing_a_file_that_the_module_resolution_depends_on_invalidates_the_query(
     ) -> anyhow::Result<()> {
-        let TestCase { mut db, src, .. } = create_resolver()?;
+        let TestCase { mut db, src, .. } = setup_resolver_test();
         let foo_path = src.join("foo.py");
         let foo_init_path = src.join("foo/__init__.py");
 
@@ -928,7 +975,7 @@ mod tests {
         db.memory_file_system().remove_file(&foo_init_path)?;
         db.memory_file_system()
             .remove_directory(foo_init_path.parent().unwrap())?;
-        VfsFile::touch_path(&mut db, &VfsPath::FileSystem(foo_init_path.clone()));
+        VfsFile::touch_path(&mut db, &VfsPath::FileSystem(foo_init_path));
 
         let foo_module = resolve_module(&db, foo_module_name).expect("Foo module to resolve");
         assert_eq!(&foo_path, foo_module.file().path(&db));

crates/red_knot_module_resolver/src/state.rs

@@ -0,0 +1,25 @@
+use ruff_db::file_system::FileSystem;
+
+use crate::db::Db;
+use crate::supported_py_version::TargetVersion;
+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 file_system(&self) -> &dyn FileSystem {
+        self.db.file_system()
+    }
+}

crates/red_knot_module_resolver/src/supported_py_version.rs

@@ -0,0 +1,14 @@
+/// 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)]
+pub enum TargetVersion {
+    Py37,
+    #[default]
+    Py38,
+    Py39,
+    Py310,
+    Py311,
+    Py312,
+    Py313,
+}

crates/red_knot_module_resolver/src/typeshed.rs

@@ -1,4 +1,9 @@
-pub(crate) mod versions;
+mod versions;
+
+pub(crate) use versions::{
+    parse_typeshed_versions, LazyTypeshedVersions, TypeshedVersionsQueryResult,
+};
+pub use versions::{TypeshedVersionsParseError, TypeshedVersionsParseErrorKind};
 
 #[cfg(test)]
 mod tests {

crates/red_knot_module_resolver/src/typeshed/versions.rs

@@ -1,16 +1,78 @@
+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 ruff_db::file_system::FileSystemPath;
+use ruff_db::source::source_text;
+use ruff_db::vfs::{system_path_to_file, VfsFile};
 use rustc_hash::FxHashMap;
 
-use crate::module::ModuleName;
+use crate::db::Db;
+use crate::module_name::ModuleName;
+use crate::supported_py_version::TargetVersion;
 
-#[derive(Debug, PartialEq, Eq)]
+#[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,
+        module: &ModuleName,
+        db: &'db dyn Db,
+        stdlib_root: &FileSystemPath,
+        target_version: TargetVersion,
+    ) -> TypeshedVersionsQueryResult {
+        let versions = self.0.get_or_init(|| {
+            let versions_path = stdlib_root.join("VERSIONS");
+            let Some(versions_file) = system_path_to_file(db.upcast(), &versions_path) else {
+                todo!(
+                    "Still need to figure out how to handle VERSIONS files being deleted \
+                    from custom typeshed directories! Expected a file to exist at {versions_path}"
+                )
+            };
+            // TODO(Alex/Micha): If VERSIONS is invalid,
+            // this should invalidate not just the specific module resolution we're currently attempting,
+            // but all type inference that depends on any standard-library types.
+            // Unwrapping here is not correct...
+            parse_typeshed_versions(db, versions_file).as_ref().unwrap()
+        });
+        versions.query_module(module, PyVersion::from(target_version))
+    }
+}
+
+#[salsa::tracked(return_ref)]
+pub(crate) fn parse_typeshed_versions(
+    db: &dyn Db,
+    versions_file: VfsFile,
+) -> Result<TypeshedVersions, TypeshedVersionsParseError> {
+    let file_content = source_text(db.upcast(), versions_file);
+    file_content.parse()
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub struct TypeshedVersionsParseError {
-    line_number: NonZeroU16,
+    line_number: Option<NonZeroU16>,
     reason: TypeshedVersionsParseErrorKind,
 }
 
@@ -20,10 +82,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 +103,7 @@ impl std::error::Error for TypeshedVersionsParseError {
     }
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum TypeshedVersionsParseErrorKind {
     TooManyLines(NonZeroUsize),
     UnexpectedNumberOfColons,
@@ -48,6 +114,7 @@ pub enum TypeshedVersionsParseErrorKind {
         version: String,
         err: std::num::ParseIntError,
     },
+    EmptyVersionsFile,
 }
 
 impl fmt::Display for TypeshedVersionsParseErrorKind {
@@ -76,43 +143,100 @@ impl fmt::Display for TypeshedVersionsParseErrorKind {
                 f,
                 "Failed to convert '{version}' to a pair of integers due to {err}",
             ),
+            Self::EmptyVersionsFile => f.write_str("Versions file was empty!"),
         }
     }
 }
 
 #[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 +249,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 +265,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,14 +283,21 @@ impl FromStr for TypeshedVersions {
                 Ok(version) => map.insert(module_name, version),
                 Err(reason) => {
                     return Err(TypeshedVersionsParseError {
-                        line_number,
+                        line_number: Some(line_number),
                         reason,
                     })
                 }
             };
         }
 
-        Ok(Self(map))
+        if map.is_empty() {
+            Err(TypeshedVersionsParseError {
+                line_number: None,
+                reason: TypeshedVersionsParseErrorKind::EmptyVersionsFile,
+            })
+        } else {
+            Ok(Self(map))
+        }
     }
 }
 
@@ -180,13 +311,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 +354,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 +398,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,
             },
@@ -317,7 +436,19 @@ mod tests {
     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 +465,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 +537,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 +570,127 @@ 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_exact(&spam));
+        assert_eq!(
+            parsed_versions.query_module(&spam, TargetVersion::Py37.into()),
+            TypeshedVersionsQueryResult::DoesNotExist
+        );
+        assert_eq!(
+            parsed_versions.query_module(&spam, TargetVersion::Py313.into()),
+            TypeshedVersionsQueryResult::DoesNotExist
+        );
+    }
 
-        assert!(parsed_versions.contains_module(&bar));
-        assert!(parsed_versions.module_exists_on_version(bar.clone(), SupportedPyVersion::Py37));
-        assert!(parsed_versions.module_exists_on_version(bar.clone(), SupportedPyVersion::Py310));
-        assert!(!parsed_versions.module_exists_on_version(bar, SupportedPyVersion::Py311));
-
-        assert!(parsed_versions.contains_module(&bar_baz));
-        assert!(parsed_versions.module_exists_on_version(bar_baz.clone(), SupportedPyVersion::Py37));
-        assert!(parsed_versions.module_exists_on_version(bar_baz.clone(), SupportedPyVersion::Py39));
-        assert!(!parsed_versions.module_exists_on_version(bar_baz, SupportedPyVersion::Py310));
-
-        assert!(!parsed_versions.contains_module(&spam));
-        assert!(!parsed_versions.module_exists_on_version(spam.clone(), SupportedPyVersion::Py37));
-        assert!(!parsed_versions.module_exists_on_version(spam, SupportedPyVersion::Py313));
+    #[test]
+    fn invalid_empty_versions_file() {
+        assert_eq!(
+            TypeshedVersions::from_str(""),
+            Err(TypeshedVersionsParseError {
+                line_number: None,
+                reason: TypeshedVersionsParseErrorKind::EmptyVersionsFile
+            })
+        );
+        assert_eq!(
+            TypeshedVersions::from_str("       "),
+            Err(TypeshedVersionsParseError {
+                line_number: None,
+                reason: TypeshedVersionsParseErrorKind::EmptyVersionsFile
+            })
+        );
+        assert_eq!(
+            TypeshedVersions::from_str(" \n  \n  \n "),
+            Err(TypeshedVersionsParseError {
+                line_number: None,
+                reason: TypeshedVersionsParseErrorKind::EmptyVersionsFile
+            })
+        );
     }
 
     #[test]
@@ -465,7 +706,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
+dcab6e88883c629ede9637fb011958f8b4918f52

crates/red_knot_module_resolver/vendor/typeshed/stdlib/VERSIONS

@@ -34,6 +34,7 @@ _dummy_thread: 3.0-3.8
 _dummy_threading: 3.0-3.8
 _heapq: 3.0-
 _imp: 3.0-
+_interpchannels: 3.13-
 _json: 3.0-
 _locale: 3.0-
 _lsprof: 3.0-

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

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

crates/red_knot_module_resolver/vendor/typeshed/stdlib/_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/argparse.pyi

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

crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/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")
@@ -541,18 +558,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 +583,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/tasks.pyi

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

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

@@ -13,51 +13,54 @@ _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: ...
+if sys.version_info < (3, 14):
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class AbstractChildWatcher:
+            @abstractmethod
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            @abstractmethod
+            def remove_child_handler(self, pid: int) -> bool: ...
+            @abstractmethod
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            @abstractmethod
+            def close(self) -> None: ...
+            @abstractmethod
+            def __enter__(self) -> Self: ...
+            @abstractmethod
+            def __exit__(
+                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+            ) -> None: ...
+            @abstractmethod
+            def is_active(self) -> bool: ...
 
-else:
-    class AbstractChildWatcher:
-        @abstractmethod
-        def add_child_handler(
-            self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-        ) -> None: ...
-        @abstractmethod
-        def remove_child_handler(self, pid: int) -> bool: ...
-        @abstractmethod
-        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-        @abstractmethod
-        def close(self) -> None: ...
-        @abstractmethod
-        def __enter__(self) -> Self: ...
-        @abstractmethod
-        def __exit__(
-            self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
-        ) -> None: ...
-        @abstractmethod
-        def is_active(self) -> bool: ...
+    else:
+        class AbstractChildWatcher:
+            @abstractmethod
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            @abstractmethod
+            def remove_child_handler(self, pid: int) -> bool: ...
+            @abstractmethod
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            @abstractmethod
+            def close(self) -> None: ...
+            @abstractmethod
+            def __enter__(self) -> Self: ...
+            @abstractmethod
+            def __exit__(
+                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+            ) -> None: ...
+            @abstractmethod
+            def is_active(self) -> bool: ...
 
 if sys.platform != "win32":
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 14):
+        __all__ = ("SelectorEventLoop", "DefaultEventLoopPolicy")
+    elif sys.version_info >= (3, 9):
         __all__ = (
             "SelectorEventLoop",
             "AbstractChildWatcher",
@@ -79,118 +82,137 @@ 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: ...
+    if sys.version_info < (3, 14):
+        if sys.version_info >= (3, 12):
+            # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
+            # See discussion in #7412
+            class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
+                def close(self) -> None: ...
+                def is_active(self) -> bool: ...
+                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
 
-    if sys.version_info >= (3, 12):
-        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-        class SafeChildWatcher(BaseChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            class 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: ...
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            class FastChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
 
-    else:
-        class SafeChildWatcher(BaseChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
+        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 FastChildWatcher(BaseChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
+            class SafeChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+
+            class FastChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
 
     class _UnixSelectorEventLoop(BaseSelectorEventLoop): ...
 
     class _UnixDefaultEventLoopPolicy(BaseDefaultEventLoopPolicy):
-        if sys.version_info >= (3, 12):
-            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-            def get_child_watcher(self) -> AbstractChildWatcher: ...
-            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-            def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
-        else:
-            def get_child_watcher(self) -> AbstractChildWatcher: ...
-            def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+        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, 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

@@ -74,8 +74,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]]

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

@@ -1673,9 +1673,9 @@ def pow(base: float, exp: complex | _SupportsSomeKindOfPow, mod: None = None) ->
 @overload
 def pow(base: complex, exp: complex | _SupportsSomeKindOfPow, mod: None = None) -> complex: ...
 @overload
-def pow(base: _SupportsPow2[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...
+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

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

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

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

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

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

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

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

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

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

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

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

@@ -77,11 +77,7 @@ pathsep: LiteralString
 defpath: LiteralString
 devnull: LiteralString
 
-# Overloads are necessary to work around python/mypy#3644.
-@overload
-def abspath(path: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def abspath(path: AnyStr) -> AnyStr: ...
+def abspath(path: PathLike[AnyStr] | AnyStr) -> AnyStr: ...
 @overload
 def basename(p: PathLike[AnyStr]) -> AnyStr: ...
 @overload
@@ -90,14 +86,8 @@ def basename(p: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
 def dirname(p: PathLike[AnyStr]) -> AnyStr: ...
 @overload
 def dirname(p: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
-@overload
-def expanduser(path: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def expanduser(path: AnyStr) -> AnyStr: ...
-@overload
-def expandvars(path: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def expandvars(path: AnyStr) -> AnyStr: ...
+def expanduser(path: PathLike[AnyStr] | AnyStr) -> AnyStr: ...
+def expandvars(path: PathLike[AnyStr] | AnyStr) -> AnyStr: ...
 @overload
 def normcase(s: PathLike[AnyStr]) -> AnyStr: ...
 @overload

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

@@ -36,6 +36,11 @@ if sys.platform != "win32":
         def sp_expire(self) -> int: ...
         @property
         def sp_flag(self) -> int: ...
+        # Deprecated aliases below.
+        @property
+        def sp_nam(self) -> str: ...
+        @property
+        def sp_pwd(self) -> str: ...
 
     def getspall() -> list[struct_spwd]: ...
     def getspnam(arg: str, /) -> struct_spwd: ...

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

@@ -889,6 +889,7 @@ if sys.version_info >= (3, 11):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -920,6 +921,7 @@ elif sys.version_info >= (3, 10):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -950,6 +952,7 @@ elif sys.version_info >= (3, 9):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -978,6 +981,7 @@ else:
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
     ) -> int: ...
@@ -1005,6 +1009,7 @@ if sys.version_info >= (3, 11):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1036,6 +1041,7 @@ elif sys.version_info >= (3, 10):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1066,6 +1072,7 @@ elif sys.version_info >= (3, 9):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1094,6 +1101,7 @@ else:
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
     ) -> int: ...
 

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

@@ -103,10 +103,13 @@ PAX_NAME_FIELDS: set[str]
 
 ENCODING: str
 
+_FileCreationModes: TypeAlias = Literal["a", "w", "x"]
+
+@overload
 def open(
     name: StrOrBytesPath | None = None,
     mode: str = "r",
-    fileobj: IO[bytes] | None = None,  # depends on mode
+    fileobj: IO[bytes] | None = None,
     bufsize: int = 10240,
     *,
     format: int | None = ...,
@@ -121,6 +124,25 @@ def open(
     compresslevel: int | None = ...,
     preset: Literal[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] | None = ...,
 ) -> TarFile: ...
+@overload
+def open(
+    name: StrOrBytesPath | None = None,
+    mode: _FileCreationModes = ...,
+    fileobj: _Fileobj | None = None,
+    bufsize: int = 10240,
+    *,
+    format: int | None = ...,
+    tarinfo: type[TarInfo] | None = ...,
+    dereference: bool | None = ...,
+    ignore_zeros: bool | None = ...,
+    encoding: str | None = ...,
+    errors: str = ...,
+    pax_headers: Mapping[str, str] | None = ...,
+    debug: int | None = ...,
+    errorlevel: int | None = ...,
+    compresslevel: int | None = ...,
+    preset: int | None = ...,
+) -> TarFile: ...
 
 class ExFileObject(io.BufferedReader):
     def __init__(self, tarfile: TarFile, tarinfo: TarInfo) -> None: ...

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

@@ -41,7 +41,10 @@ _P = ParamSpec("_P")
 ProxyTypes: tuple[type[Any], ...]
 
 class WeakMethod(ref[_CallableT]):
-    def __new__(cls, meth: _CallableT, callback: Callable[[Self], object] | None = None) -> Self: ...
+    # `ref` is implemented in `C` so positional-only arguments are enforced, but not in `WeakMethod`.
+    def __new__(  # pyright: ignore[reportInconsistentConstructor]
+        cls, meth: _CallableT, callback: Callable[[Self], Any] | None = None
+    ) -> Self: ...
     def __call__(self) -> _CallableT | None: ...
     def __eq__(self, other: object) -> bool: ...
     def __ne__(self, other: object) -> bool: ...

crates/red_knot_module_resolver/vendor/typeshed/stdlib/xml/sax/handler.pyi

@@ -14,7 +14,7 @@ class ContentHandler:
     def startDocument(self) -> None: ...
     def endDocument(self) -> None: ...
     def startPrefixMapping(self, prefix: str | None, uri: str) -> None: ...
-    def endPrefixMapping(self, prefix) -> None: ...
+    def endPrefixMapping(self, prefix: str | None) -> None: ...
     def startElement(self, name: str, attrs: xmlreader.AttributesImpl) -> None: ...
     def endElement(self, name: str) -> None: ...
     def startElementNS(self, name: tuple[str, str], qname: str, attrs: xmlreader.AttributesNSImpl) -> None: ...

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

@@ -28,5 +28,7 @@ class zipimporter:
     def is_package(self, fullname: str) -> bool: ...
     def load_module(self, fullname: str) -> ModuleType: ...
     if sys.version_info >= (3, 10):
+        def exec_module(self, module: ModuleType) -> None: ...
+        def create_module(self, spec: ModuleSpec) -> None: ...
         def find_spec(self, fullname: str, target: ModuleType | None = None) -> ModuleSpec | None: ...
         def invalidate_caches(self) -> None: ...

crates/red_knot_python_semantic/Cargo.toml

@@ -18,10 +18,8 @@ ruff_python_ast = { workspace = true }
 ruff_text_size = { workspace = true }
 
 bitflags = { workspace = true }
-indexmap = { workspace = true }
+ordermap = { workspace = true }
 salsa = { workspace = true }
-smallvec = { workspace = true }
-smol_str = { workspace = true }
 tracing = { workspace = true }
 rustc-hash = { workspace = true }
 hashbrown = { workspace = true }

crates/red_knot_python_semantic/src/db.rs

@@ -4,16 +4,23 @@ use ruff_db::{Db as SourceDb, Upcast};
 
 use red_knot_module_resolver::Db as ResolverDb;
 
-use crate::semantic_index::symbol::{public_symbols_map, scopes_map, PublicSymbolId, ScopeId};
+use crate::semantic_index::definition::Definition;
+use crate::semantic_index::symbol::{public_symbols_map, PublicSymbolId, ScopeId};
 use crate::semantic_index::{root_scope, semantic_index, symbol_table};
-use crate::types::{infer_types, public_symbol_ty};
+use crate::types::{
+    infer_types, public_symbol_ty, ClassType, FunctionType, IntersectionType, UnionType,
+};
 
 #[salsa::jar(db=Db)]
 pub struct Jar(
     ScopeId<'_>,
     PublicSymbolId<'_>,
+    Definition<'_>,
+    FunctionType<'_>,
+    ClassType<'_>,
+    UnionType<'_>,
+    IntersectionType<'_>,
     symbol_table,
-    scopes_map,
     root_scope,
     semantic_index,
     infer_types,

crates/red_knot_python_semantic/src/lib.rs

@@ -1,12 +1,15 @@
-pub mod ast_node_ref;
-mod db;
-pub mod name;
-mod node_key;
-pub mod semantic_index;
-pub mod types;
+use std::hash::BuildHasherDefault;
 
-type FxIndexSet<V> = indexmap::set::IndexSet<V, BuildHasherDefault<FxHasher>>;
+use rustc_hash::FxHasher;
 
 pub use db::{Db, Jar};
-use rustc_hash::FxHasher;
-use std::hash::BuildHasherDefault;
+pub use semantic_model::{HasTy, SemanticModel};
+
+pub mod ast_node_ref;
+mod db;
+mod node_key;
+pub mod semantic_index;
+mod semantic_model;
+pub mod types;
+
+type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;

crates/red_knot_python_semantic/src/mod.rs

@@ -1,10 +0,0 @@
-use std::hash::BuildHasherDefault;
-
-use rustc_hash::FxHasher;
-
-pub mod ast_node_ref;
-mod node_key;
-pub mod semantic_index;
-pub mod types;
-
-pub(crate) type FxIndexSet<V> = indexmap::set::IndexSet<V, BuildHasherDefault<FxHasher>>;

crates/red_knot_python_semantic/src/name.rs

@@ -1,56 +0,0 @@
-use std::ops::Deref;
-
-#[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))
-    }
-
-    #[inline]
-    pub fn new_static(name: &'static str) -> Self {
-        Self(smol_str::SmolStr::new_static(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 std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.as_str())
-    }
-}
-
-impl PartialEq<str> for Name {
-    fn eq(&self, other: &str) -> bool {
-        self.as_str() == other
-    }
-}
-
-impl PartialEq<Name> for str {
-    fn eq(&self, other: &Name) -> bool {
-        other == self
-    }
-}

crates/red_knot_python_semantic/src/semantic_index.rs

@@ -2,18 +2,18 @@ use std::iter::FusedIterator;
 use std::sync::Arc;
 
 use rustc_hash::FxHashMap;
-use salsa::DebugWithDb;
 
 use ruff_db::parsed::parsed_module;
 use ruff_db::vfs::VfsFile;
 use ruff_index::{IndexSlice, IndexVec};
-use ruff_python_ast as ast;
 
-use crate::node_key::NodeKey;
-use crate::semantic_index::ast_ids::{AstId, AstIds, ScopeClassId, ScopeFunctionId};
+use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey;
+use crate::semantic_index::ast_ids::AstIds;
 use crate::semantic_index::builder::SemanticIndexBuilder;
+use crate::semantic_index::definition::{Definition, DefinitionNodeKey, DefinitionNodeRef};
 use crate::semantic_index::symbol::{
-    FileScopeId, PublicSymbolId, Scope, ScopeId, ScopeKind, ScopedSymbolId, SymbolTable,
+    FileScopeId, NodeWithScopeKey, NodeWithScopeRef, PublicSymbolId, Scope, ScopeId,
+    ScopedSymbolId, SymbolTable,
 };
 use crate::Db;
 
@@ -28,12 +28,12 @@ type SymbolMap = hashbrown::HashMap<ScopedSymbolId, (), ()>;
 ///
 /// Prefer using [`symbol_table`] when working with symbols from a single scope.
 #[salsa::tracked(return_ref, no_eq)]
-pub(crate) fn semantic_index(db: &dyn Db, file: VfsFile) -> SemanticIndex {
-    let _ = tracing::trace_span!("semantic_index", file = ?file.debug(db.upcast())).enter();
+pub(crate) fn semantic_index(db: &dyn Db, file: VfsFile) -> SemanticIndex<'_> {
+    let _span = tracing::trace_span!("semantic_index", ?file).entered();
 
     let parsed = parsed_module(db.upcast(), file);
 
-    SemanticIndexBuilder::new(parsed).build()
+    SemanticIndexBuilder::new(db, file, parsed).build()
 }
 
 /// Returns the symbol table for a specific `scope`.
@@ -42,8 +42,8 @@ pub(crate) fn semantic_index(db: &dyn Db, file: VfsFile) -> SemanticIndex {
 /// Salsa can avoid invalidating dependent queries if this scope's symbol table
 /// is unchanged.
 #[salsa::tracked]
-pub(crate) fn symbol_table<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> Arc<SymbolTable> {
-    let _ = tracing::trace_span!("symbol_table", scope = ?scope.debug(db)).enter();
+pub(crate) fn symbol_table<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> Arc<SymbolTable<'db>> {
+    let _span = tracing::trace_span!("symbol_table", ?scope).entered();
     let index = semantic_index(db, scope.file(db));
 
     index.symbol_table(scope.file_scope_id(db))
@@ -52,14 +52,14 @@ pub(crate) fn symbol_table<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> Arc<Sym
 /// Returns the root scope of `file`.
 #[salsa::tracked]
 pub(crate) fn root_scope(db: &dyn Db, file: VfsFile) -> ScopeId<'_> {
-    let _ = tracing::trace_span!("root_scope", file = ?file.debug(db.upcast())).enter();
+    let _span = tracing::trace_span!("root_scope", ?file).entered();
 
     FileScopeId::root().to_scope_id(db, file)
 }
 
 /// Returns the symbol with the given name in `file`'s public scope or `None` if
 /// no symbol with the given name exists.
-pub fn public_symbol<'db>(
+pub(crate) fn public_symbol<'db>(
     db: &'db dyn Db,
     file: VfsFile,
     name: &str,
@@ -72,9 +72,9 @@ pub fn public_symbol<'db>(
 
 /// The symbol tables for an entire file.
 #[derive(Debug)]
-pub struct SemanticIndex {
+pub(crate) struct SemanticIndex<'db> {
     /// List of all symbol tables in this file, indexed by scope.
-    symbol_tables: IndexVec<FileScopeId, Arc<SymbolTable>>,
+    symbol_tables: IndexVec<FileScopeId, Arc<SymbolTable<'db>>>,
 
     /// List of all scopes in this file.
     scopes: IndexVec<FileScopeId, Scope>,
@@ -82,24 +82,30 @@ pub struct SemanticIndex {
     /// Maps expressions to their corresponding scope.
     /// We can't use [`ExpressionId`] here, because the challenge is how to get from
     /// an [`ast::Expr`] to an [`ExpressionId`] (which requires knowing the scope).
-    expression_scopes: FxHashMap<NodeKey, FileScopeId>,
+    scopes_by_expression: FxHashMap<ExpressionNodeKey, FileScopeId>,
+
+    /// Maps from a node creating a definition node to its definition.
+    definitions_by_node: FxHashMap<DefinitionNodeKey, Definition<'db>>,
+
+    /// Map from nodes that create a scope to the scope they create.
+    scopes_by_node: FxHashMap<NodeWithScopeKey, FileScopeId>,
+
+    /// Map from the file-local [`FileScopeId`] to the salsa-ingredient [`ScopeId`].
+    scope_ids_by_scope: IndexVec<FileScopeId, ScopeId<'db>>,
 
     /// Lookup table to map between node ids and ast nodes.
     ///
     /// Note: We should not depend on this map when analysing other files or
     /// changing a file invalidates all dependents.
     ast_ids: IndexVec<FileScopeId, AstIds>,
-
-    /// Map from scope to the node that introduces the scope.
-    scope_nodes: IndexVec<FileScopeId, NodeWithScopeId>,
 }
 
-impl SemanticIndex {
+impl<'db> SemanticIndex<'db> {
     /// Returns the symbol table for a specific scope.
     ///
     /// Use the Salsa cached [`symbol_table`] query if you only need the
     /// symbol table for a single scope.
-    pub(super) fn symbol_table(&self, scope_id: FileScopeId) -> Arc<SymbolTable> {
+    pub(super) fn symbol_table(&self, scope_id: FileScopeId) -> Arc<SymbolTable<'db>> {
         self.symbol_tables[scope_id].clone()
     }
 
@@ -108,13 +114,16 @@ impl SemanticIndex {
     }
 
     /// Returns the ID of the `expression`'s enclosing scope.
-    pub(crate) fn expression_scope_id(&self, expression: &ast::Expr) -> FileScopeId {
-        self.expression_scopes[&NodeKey::from_node(expression)]
+    pub(crate) fn expression_scope_id(
+        &self,
+        expression: impl Into<ExpressionNodeKey>,
+    ) -> FileScopeId {
+        self.scopes_by_expression[&expression.into()]
     }
 
     /// Returns the [`Scope`] of the `expression`'s enclosing scope.
     #[allow(unused)]
-    pub(crate) fn expression_scope(&self, expression: &ast::Expr) -> &Scope {
+    pub(crate) fn expression_scope(&self, expression: impl Into<ExpressionNodeKey>) -> &Scope {
         &self.scopes[self.expression_scope_id(expression)]
     }
 
@@ -142,6 +151,7 @@ impl SemanticIndex {
     }
 
     /// Returns an iterator over the direct child scopes of `scope`.
+    #[allow(unused)]
     pub(crate) fn child_scopes(&self, scope: FileScopeId) -> ChildrenIter {
         ChildrenIter::new(self, scope)
     }
@@ -151,8 +161,18 @@ impl SemanticIndex {
         AncestorsIter::new(self, scope)
     }
 
-    pub(crate) fn scope_node(&self, scope_id: FileScopeId) -> NodeWithScopeId {
-        self.scope_nodes[scope_id]
+    /// Returns the [`Definition`] salsa ingredient for `definition_node`.
+    pub(crate) fn definition<'def>(
+        &self,
+        definition_node: impl Into<DefinitionNodeRef<'def>>,
+    ) -> Definition<'db> {
+        self.definitions_by_node[&definition_node.into().key()]
+    }
+
+    /// Returns the id of the scope that `node` creates. This is different from [`Definition::scope`] which
+    /// returns the scope in which that definition is defined in.
+    pub(crate) fn node_scope(&self, node: NodeWithScopeRef) -> FileScopeId {
+        self.scopes_by_node[&node.node_key()]
     }
 }
 
@@ -248,28 +268,6 @@ impl<'a> Iterator for ChildrenIter<'a> {
     }
 }
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub(crate) enum NodeWithScopeId {
-    Module,
-    Class(AstId<ScopeClassId>),
-    ClassTypeParams(AstId<ScopeClassId>),
-    Function(AstId<ScopeFunctionId>),
-    FunctionTypeParams(AstId<ScopeFunctionId>),
-}
-
-impl NodeWithScopeId {
-    fn scope_kind(self) -> ScopeKind {
-        match self {
-            NodeWithScopeId::Module => ScopeKind::Module,
-            NodeWithScopeId::Class(_) => ScopeKind::Class,
-            NodeWithScopeId::Function(_) => ScopeKind::Function,
-            NodeWithScopeId::ClassTypeParams(_) | NodeWithScopeId::FunctionTypeParams(_) => {
-                ScopeKind::Annotation
-            }
-        }
-    }
-}
-
 impl FusedIterator for ChildrenIter<'_> {}
 
 #[cfg(test)]
@@ -278,8 +276,9 @@ mod tests {
     use ruff_db::vfs::{system_path_to_file, VfsFile};
 
     use crate::db::tests::TestDb;
-    use crate::semantic_index::symbol::{FileScopeId, ScopeKind, SymbolTable};
+    use crate::semantic_index::symbol::{FileScopeId, Scope, ScopeKind, SymbolTable};
     use crate::semantic_index::{root_scope, semantic_index, symbol_table};
+    use crate::Db;
 
     struct TestCase {
         db: TestDb,
@@ -297,10 +296,10 @@ mod tests {
         TestCase { db, file }
     }
 
-    fn names(table: &SymbolTable) -> Vec<&str> {
+    fn names(table: &SymbolTable) -> Vec<String> {
         table
             .symbols()
-            .map(|symbol| symbol.name().as_str())
+            .map(|symbol| symbol.name().to_string())
             .collect()
     }
 
@@ -309,7 +308,9 @@ mod tests {
         let TestCase { db, file } = test_case("");
         let root_table = symbol_table(&db, root_scope(&db, file));
 
-        assert_eq!(names(&root_table), Vec::<&str>::new());
+        let root_names = names(&root_table);
+
+        assert_eq!(root_names, Vec::<&str>::new());
     }
 
     #[test]
@@ -416,7 +417,8 @@ y = 2
 
         let (class_scope_id, class_scope) = scopes[0];
         assert_eq!(class_scope.kind(), ScopeKind::Class);
-        assert_eq!(class_scope.name(), "C");
+
+        assert_eq!(class_scope_id.to_scope_id(&db, file).name(&db), "C");
 
         let class_table = index.symbol_table(class_scope_id);
         assert_eq!(names(&class_table), vec!["x"]);
@@ -445,7 +447,7 @@ y = 2
 
         let (function_scope_id, function_scope) = scopes[0];
         assert_eq!(function_scope.kind(), ScopeKind::Function);
-        assert_eq!(function_scope.name(), "func");
+        assert_eq!(function_scope_id.to_scope_id(&db, file).name(&db), "func");
 
         let function_table = index.symbol_table(function_scope_id);
         assert_eq!(names(&function_table), vec!["x"]);
@@ -480,9 +482,10 @@ def func():
         let (func_scope2_id, func_scope_2) = scopes[1];
 
         assert_eq!(func_scope_1.kind(), ScopeKind::Function);
-        assert_eq!(func_scope_1.name(), "func");
+
+        assert_eq!(func_scope1_id.to_scope_id(&db, file).name(&db), "func");
         assert_eq!(func_scope_2.kind(), ScopeKind::Function);
-        assert_eq!(func_scope_2.name(), "func");
+        assert_eq!(func_scope2_id.to_scope_id(&db, file).name(&db), "func");
 
         let func1_table = index.symbol_table(func_scope1_id);
         let func2_table = index.symbol_table(func_scope2_id);
@@ -517,7 +520,7 @@ def func[T]():
         let (ann_scope_id, ann_scope) = scopes[0];
 
         assert_eq!(ann_scope.kind(), ScopeKind::Annotation);
-        assert_eq!(ann_scope.name(), "func");
+        assert_eq!(ann_scope_id.to_scope_id(&db, file).name(&db), "func");
         let ann_table = index.symbol_table(ann_scope_id);
         assert_eq!(names(&ann_table), vec!["T"]);
 
@@ -525,7 +528,7 @@ def func[T]():
         assert_eq!(scopes.len(), 1);
         let (func_scope_id, func_scope) = scopes[0];
         assert_eq!(func_scope.kind(), ScopeKind::Function);
-        assert_eq!(func_scope.name(), "func");
+        assert_eq!(func_scope_id.to_scope_id(&db, file).name(&db), "func");
         let func_table = index.symbol_table(func_scope_id);
         assert_eq!(names(&func_table), vec!["x"]);
     }
@@ -549,7 +552,7 @@ class C[T]:
         assert_eq!(scopes.len(), 1);
         let (ann_scope_id, ann_scope) = scopes[0];
         assert_eq!(ann_scope.kind(), ScopeKind::Annotation);
-        assert_eq!(ann_scope.name(), "C");
+        assert_eq!(ann_scope_id.to_scope_id(&db, file).name(&db), "C");
         let ann_table = index.symbol_table(ann_scope_id);
         assert_eq!(names(&ann_table), vec!["T"]);
         assert!(
@@ -561,11 +564,11 @@ class C[T]:
 
         let scopes: Vec<_> = index.child_scopes(ann_scope_id).collect();
         assert_eq!(scopes.len(), 1);
-        let (func_scope_id, func_scope) = scopes[0];
+        let (class_scope_id, class_scope) = scopes[0];
 
-        assert_eq!(func_scope.kind(), ScopeKind::Class);
-        assert_eq!(func_scope.name(), "C");
-        assert_eq!(names(&index.symbol_table(func_scope_id)), vec!["x"]);
+        assert_eq!(class_scope.kind(), ScopeKind::Class);
+        assert_eq!(class_scope_id.to_scope_id(&db, file).name(&db), "C");
+        assert_eq!(names(&index.symbol_table(class_scope_id)), vec!["x"]);
     }
 
     // TODO: After porting the control flow graph.
@@ -625,6 +628,17 @@ class C[T]:
 
     #[test]
     fn scope_iterators() {
+        fn scope_names<'a>(
+            scopes: impl Iterator<Item = (FileScopeId, &'a Scope)>,
+            db: &'a dyn Db,
+            file: VfsFile,
+        ) -> Vec<&'a str> {
+            scopes
+                .into_iter()
+                .map(|(scope_id, _)| scope_id.to_scope_id(db, file).name(db))
+                .collect()
+        }
+
         let TestCase { db, file } = test_case(
             r#"
 class Test:
@@ -640,35 +654,32 @@ def x():
 
         let index = semantic_index(&db, file);
 
-        let descendents: Vec<_> = index
-            .descendent_scopes(FileScopeId::root())
-            .map(|(_, scope)| scope.name().as_str())
-            .collect();
-        assert_eq!(descendents, vec!["Test", "foo", "bar", "baz", "x"]);
+        let descendents = index.descendent_scopes(FileScopeId::root());
+        assert_eq!(
+            scope_names(descendents, &db, file),
+            vec!["Test", "foo", "bar", "baz", "x"]
+        );
 
-        let children: Vec<_> = index
-            .child_scopes(FileScopeId::root())
-            .map(|(_, scope)| scope.name.as_str())
-            .collect();
-        assert_eq!(children, vec!["Test", "x"]);
+        let children = index.child_scopes(FileScopeId::root());
+        assert_eq!(scope_names(children, &db, file), vec!["Test", "x"]);
 
         let test_class = index.child_scopes(FileScopeId::root()).next().unwrap().0;
-        let test_child_scopes: Vec<_> = index
-            .child_scopes(test_class)
-            .map(|(_, scope)| scope.name.as_str())
-            .collect();
-        assert_eq!(test_child_scopes, vec!["foo", "baz"]);
+        let test_child_scopes = index.child_scopes(test_class);
+        assert_eq!(
+            scope_names(test_child_scopes, &db, file),
+            vec!["foo", "baz"]
+        );
 
         let bar_scope = index
             .descendent_scopes(FileScopeId::root())
             .nth(2)
             .unwrap()
             .0;
-        let ancestors: Vec<_> = index
-            .ancestor_scopes(bar_scope)
-            .map(|(_, scope)| scope.name())
-            .collect();
+        let ancestors = index.ancestor_scopes(bar_scope);
 
-        assert_eq!(ancestors, vec!["bar", "foo", "Test", "<module>"]);
+        assert_eq!(
+            scope_names(ancestors, &db, file),
+            vec!["bar", "foo", "Test", "<module>"]
+        );
     }
 }

crates/red_knot_python_semantic/src/semantic_index/ast_ids.rs

@@ -1,15 +1,12 @@
 use rustc_hash::FxHashMap;
 
-use ruff_db::parsed::ParsedModule;
-use ruff_db::vfs::VfsFile;
-use ruff_index::{newtype_index, IndexVec};
+use ruff_index::{newtype_index, Idx};
 use ruff_python_ast as ast;
-use ruff_python_ast::AnyNodeRef;
+use ruff_python_ast::ExpressionRef;
 
-use crate::ast_node_ref::AstNodeRef;
-use crate::node_key::NodeKey;
+use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey;
 use crate::semantic_index::semantic_index;
-use crate::semantic_index::symbol::{FileScopeId, ScopeId};
+use crate::semantic_index::symbol::ScopeId;
 use crate::Db;
 
 /// AST ids for a single scope.
@@ -27,41 +24,15 @@ use crate::Db;
 ///
 /// x = foo()
 /// ```
+#[derive(Debug)]
 pub(crate) struct AstIds {
-    /// Maps expression ids to their expressions.
-    expressions: IndexVec<ScopeExpressionId, AstNodeRef<ast::Expr>>,
-
     /// Maps expressions to their expression id. Uses `NodeKey` because it avoids cloning [`Parsed`].
-    expressions_map: FxHashMap<NodeKey, ScopeExpressionId>,
-
-    statements: IndexVec<ScopeStatementId, AstNodeRef<ast::Stmt>>,
-
-    statements_map: FxHashMap<NodeKey, ScopeStatementId>,
+    expressions_map: FxHashMap<ExpressionNodeKey, ScopedExpressionId>,
 }
 
 impl AstIds {
-    fn statement_id<'a, N>(&self, node: N) -> ScopeStatementId
-    where
-        N: Into<AnyNodeRef<'a>>,
-    {
-        self.statements_map[&NodeKey::from_node(node.into())]
-    }
-
-    fn expression_id<'a, N>(&self, node: N) -> ScopeExpressionId
-    where
-        N: Into<AnyNodeRef<'a>>,
-    {
-        self.expressions_map[&NodeKey::from_node(node.into())]
-    }
-}
-
-#[allow(clippy::missing_fields_in_debug)]
-impl std::fmt::Debug for AstIds {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("AstIds")
-            .field("expressions", &self.expressions)
-            .field("statements", &self.statements)
-            .finish()
+    fn expression_id(&self, key: impl Into<ExpressionNodeKey>) -> ScopedExpressionId {
+        self.expressions_map[&key.into()]
     }
 }
 
@@ -69,325 +40,130 @@ fn ast_ids<'db>(db: &'db dyn Db, scope: ScopeId) -> &'db AstIds {
     semantic_index(db, scope.file(db)).ast_ids(scope.file_scope_id(db))
 }
 
-/// Node that can be uniquely identified by an id in a [`FileScopeId`].
-pub trait ScopeAstIdNode {
+pub trait HasScopedAstId {
     /// The type of the ID uniquely identifying the node.
     type Id: Copy;
 
     /// Returns the ID that uniquely identifies the node in `scope`.
-    ///
-    /// ## Panics
-    /// Panics if the node doesn't belong to `file` or is outside `scope`.
-    fn scope_ast_id(&self, db: &dyn Db, file: VfsFile, scope: FileScopeId) -> Self::Id;
-
-    /// Looks up the AST node by its ID.
-    ///
-    /// ## Panics
-    /// May panic if the `id` does not belong to the AST of `file`, or is outside `scope`.
-    fn lookup_in_scope(db: &dyn Db, file: VfsFile, scope: FileScopeId, id: Self::Id) -> &Self
-    where
-        Self: Sized;
+    fn scoped_ast_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id;
 }
 
-/// Extension trait for AST nodes that can be resolved by an `AstId`.
-pub trait AstIdNode {
-    type ScopeId: Copy;
-
-    /// Resolves the AST id of the node.
-    ///
-    /// ## Panics
-    /// May panic if the node does not belongs to `file`'s AST or is outside of `scope`. It may also
-    /// return an incorrect node if that's the case.
-    fn ast_id(&self, db: &dyn Db, file: VfsFile, scope: FileScopeId) -> AstId<Self::ScopeId>;
-
-    /// Resolves the AST node for `id`.
-    ///
-    /// ## Panics
-    /// May panic if the `id` does not belong to the AST of `file` or it returns an incorrect node.
-
-    fn lookup(db: &dyn Db, file: VfsFile, id: AstId<Self::ScopeId>) -> &Self
-    where
-        Self: Sized;
-}
-
-impl<T> AstIdNode for T
-where
-    T: ScopeAstIdNode,
-{
-    type ScopeId = T::Id;
-
-    fn ast_id(&self, db: &dyn Db, file: VfsFile, scope: FileScopeId) -> AstId<Self::ScopeId> {
-        let in_scope_id = self.scope_ast_id(db, file, scope);
-        AstId { scope, in_scope_id }
-    }
-
-    fn lookup(db: &dyn Db, file: VfsFile, id: AstId<Self::ScopeId>) -> &Self
-    where
-        Self: Sized,
-    {
-        let scope = id.scope;
-        Self::lookup_in_scope(db, file, scope, id.in_scope_id)
-    }
-}
-
-/// Uniquely identifies an AST node in a file.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct AstId<L: Copy> {
-    /// The node's scope.
-    scope: FileScopeId,
-
-    /// The ID of the node inside [`Self::scope`].
-    in_scope_id: L,
-}
-
-impl<L: Copy> AstId<L> {
-    pub(super) fn new(scope: FileScopeId, in_scope_id: L) -> Self {
-        Self { scope, in_scope_id }
-    }
-
-    pub(super) fn in_scope_id(self) -> L {
-        self.in_scope_id
-    }
-}
-
-/// Uniquely identifies an [`ast::Expr`] in a [`FileScopeId`].
+/// Uniquely identifies an [`ast::Expr`] in a [`crate::semantic_index::symbol::FileScopeId`].
 #[newtype_index]
-pub struct ScopeExpressionId;
+pub struct ScopedExpressionId;
 
-impl ScopeAstIdNode for ast::Expr {
-    type Id = ScopeExpressionId;
+macro_rules! impl_has_scoped_expression_id {
+    ($ty: ty) => {
+        impl HasScopedAstId for $ty {
+            type Id = ScopedExpressionId;
 
-    fn scope_ast_id(&self, db: &dyn Db, file: VfsFile, file_scope: FileScopeId) -> Self::Id {
-        let scope = file_scope.to_scope_id(db, file);
-        let ast_ids = ast_ids(db, scope);
-        ast_ids.expressions_map[&NodeKey::from_node(self)]
-    }
-
-    fn lookup_in_scope(db: &dyn Db, file: VfsFile, file_scope: FileScopeId, id: Self::Id) -> &Self {
-        let scope = file_scope.to_scope_id(db, file);
-        let ast_ids = ast_ids(db, scope);
-        ast_ids.expressions[id].node()
-    }
+            fn scoped_ast_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id {
+                let expression_ref = ExpressionRef::from(self);
+                expression_ref.scoped_ast_id(db, scope)
+            }
+        }
+    };
 }
 
-/// Uniquely identifies an [`ast::Stmt`] in a [`FileScopeId`].
-#[newtype_index]
-pub struct ScopeStatementId;
+impl_has_scoped_expression_id!(ast::ExprBoolOp);
+impl_has_scoped_expression_id!(ast::ExprName);
+impl_has_scoped_expression_id!(ast::ExprBinOp);
+impl_has_scoped_expression_id!(ast::ExprUnaryOp);
+impl_has_scoped_expression_id!(ast::ExprLambda);
+impl_has_scoped_expression_id!(ast::ExprIf);
+impl_has_scoped_expression_id!(ast::ExprDict);
+impl_has_scoped_expression_id!(ast::ExprSet);
+impl_has_scoped_expression_id!(ast::ExprListComp);
+impl_has_scoped_expression_id!(ast::ExprSetComp);
+impl_has_scoped_expression_id!(ast::ExprDictComp);
+impl_has_scoped_expression_id!(ast::ExprGenerator);
+impl_has_scoped_expression_id!(ast::ExprAwait);
+impl_has_scoped_expression_id!(ast::ExprYield);
+impl_has_scoped_expression_id!(ast::ExprYieldFrom);
+impl_has_scoped_expression_id!(ast::ExprCompare);
+impl_has_scoped_expression_id!(ast::ExprCall);
+impl_has_scoped_expression_id!(ast::ExprFString);
+impl_has_scoped_expression_id!(ast::ExprStringLiteral);
+impl_has_scoped_expression_id!(ast::ExprBytesLiteral);
+impl_has_scoped_expression_id!(ast::ExprNumberLiteral);
+impl_has_scoped_expression_id!(ast::ExprBooleanLiteral);
+impl_has_scoped_expression_id!(ast::ExprNoneLiteral);
+impl_has_scoped_expression_id!(ast::ExprEllipsisLiteral);
+impl_has_scoped_expression_id!(ast::ExprAttribute);
+impl_has_scoped_expression_id!(ast::ExprSubscript);
+impl_has_scoped_expression_id!(ast::ExprStarred);
+impl_has_scoped_expression_id!(ast::ExprNamed);
+impl_has_scoped_expression_id!(ast::ExprList);
+impl_has_scoped_expression_id!(ast::ExprTuple);
+impl_has_scoped_expression_id!(ast::ExprSlice);
+impl_has_scoped_expression_id!(ast::ExprIpyEscapeCommand);
+impl_has_scoped_expression_id!(ast::Expr);
 
-impl ScopeAstIdNode for ast::Stmt {
-    type Id = ScopeStatementId;
+impl HasScopedAstId for ast::ExpressionRef<'_> {
+    type Id = ScopedExpressionId;
 
-    fn scope_ast_id(&self, db: &dyn Db, file: VfsFile, file_scope: FileScopeId) -> Self::Id {
-        let scope = file_scope.to_scope_id(db, file);
+    fn scoped_ast_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id {
         let ast_ids = ast_ids(db, scope);
-        ast_ids.statement_id(self)
-    }
-
-    fn lookup_in_scope(db: &dyn Db, file: VfsFile, file_scope: FileScopeId, id: Self::Id) -> &Self {
-        let scope = file_scope.to_scope_id(db, file);
-        let ast_ids = ast_ids(db, scope);
-
-        ast_ids.statements[id].node()
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
-pub struct ScopeFunctionId(pub(super) ScopeStatementId);
-
-impl ScopeAstIdNode for ast::StmtFunctionDef {
-    type Id = ScopeFunctionId;
-
-    fn scope_ast_id(&self, db: &dyn Db, file: VfsFile, file_scope: FileScopeId) -> Self::Id {
-        let scope = file_scope.to_scope_id(db, file);
-        let ast_ids = ast_ids(db, scope);
-        ScopeFunctionId(ast_ids.statement_id(self))
-    }
-
-    fn lookup_in_scope(db: &dyn Db, file: VfsFile, scope: FileScopeId, id: Self::Id) -> &Self {
-        ast::Stmt::lookup_in_scope(db, file, scope, id.0)
-            .as_function_def_stmt()
-            .unwrap()
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
-pub struct ScopeClassId(pub(super) ScopeStatementId);
-
-impl ScopeAstIdNode for ast::StmtClassDef {
-    type Id = ScopeClassId;
-
-    fn scope_ast_id(&self, db: &dyn Db, file: VfsFile, file_scope: FileScopeId) -> Self::Id {
-        let scope = file_scope.to_scope_id(db, file);
-        let ast_ids = ast_ids(db, scope);
-        ScopeClassId(ast_ids.statement_id(self))
-    }
-
-    fn lookup_in_scope(db: &dyn Db, file: VfsFile, scope: FileScopeId, id: Self::Id) -> &Self {
-        let statement = ast::Stmt::lookup_in_scope(db, file, scope, id.0);
-        statement.as_class_def_stmt().unwrap()
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
-pub struct ScopeAssignmentId(pub(super) ScopeStatementId);
-
-impl ScopeAstIdNode for ast::StmtAssign {
-    type Id = ScopeAssignmentId;
-
-    fn scope_ast_id(&self, db: &dyn Db, file: VfsFile, file_scope: FileScopeId) -> Self::Id {
-        let scope = file_scope.to_scope_id(db, file);
-        let ast_ids = ast_ids(db, scope);
-        ScopeAssignmentId(ast_ids.statement_id(self))
-    }
-
-    fn lookup_in_scope(db: &dyn Db, file: VfsFile, scope: FileScopeId, id: Self::Id) -> &Self {
-        let statement = ast::Stmt::lookup_in_scope(db, file, scope, id.0);
-        statement.as_assign_stmt().unwrap()
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
-pub struct ScopeAnnotatedAssignmentId(ScopeStatementId);
-
-impl ScopeAstIdNode for ast::StmtAnnAssign {
-    type Id = ScopeAnnotatedAssignmentId;
-
-    fn scope_ast_id(&self, db: &dyn Db, file: VfsFile, file_scope: FileScopeId) -> Self::Id {
-        let scope = file_scope.to_scope_id(db, file);
-        let ast_ids = ast_ids(db, scope);
-        ScopeAnnotatedAssignmentId(ast_ids.statement_id(self))
-    }
-
-    fn lookup_in_scope(db: &dyn Db, file: VfsFile, scope: FileScopeId, id: Self::Id) -> &Self {
-        let statement = ast::Stmt::lookup_in_scope(db, file, scope, id.0);
-        statement.as_ann_assign_stmt().unwrap()
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
-pub struct ScopeImportId(pub(super) ScopeStatementId);
-
-impl ScopeAstIdNode for ast::StmtImport {
-    type Id = ScopeImportId;
-
-    fn scope_ast_id(&self, db: &dyn Db, file: VfsFile, file_scope: FileScopeId) -> Self::Id {
-        let scope = file_scope.to_scope_id(db, file);
-        let ast_ids = ast_ids(db, scope);
-        ScopeImportId(ast_ids.statement_id(self))
-    }
-
-    fn lookup_in_scope(db: &dyn Db, file: VfsFile, scope: FileScopeId, id: Self::Id) -> &Self {
-        let statement = ast::Stmt::lookup_in_scope(db, file, scope, id.0);
-        statement.as_import_stmt().unwrap()
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
-pub struct ScopeImportFromId(pub(super) ScopeStatementId);
-
-impl ScopeAstIdNode for ast::StmtImportFrom {
-    type Id = ScopeImportFromId;
-
-    fn scope_ast_id(&self, db: &dyn Db, file: VfsFile, file_scope: FileScopeId) -> Self::Id {
-        let scope = file_scope.to_scope_id(db, file);
-        let ast_ids = ast_ids(db, scope);
-        ScopeImportFromId(ast_ids.statement_id(self))
-    }
-
-    fn lookup_in_scope(db: &dyn Db, file: VfsFile, scope: FileScopeId, id: Self::Id) -> &Self {
-        let statement = ast::Stmt::lookup_in_scope(db, file, scope, id.0);
-        statement.as_import_from_stmt().unwrap()
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
-pub struct ScopeNamedExprId(pub(super) ScopeExpressionId);
-
-impl ScopeAstIdNode for ast::ExprNamed {
-    type Id = ScopeNamedExprId;
-
-    fn scope_ast_id(&self, db: &dyn Db, file: VfsFile, file_scope: FileScopeId) -> Self::Id {
-        let scope = file_scope.to_scope_id(db, file);
-        let ast_ids = ast_ids(db, scope);
-        ScopeNamedExprId(ast_ids.expression_id(self))
-    }
-
-    fn lookup_in_scope(db: &dyn Db, file: VfsFile, scope: FileScopeId, id: Self::Id) -> &Self
-    where
-        Self: Sized,
-    {
-        let expression = ast::Expr::lookup_in_scope(db, file, scope, id.0);
-        expression.as_named_expr().unwrap()
+        ast_ids.expression_id(*self)
     }
 }
 
 #[derive(Debug)]
 pub(super) struct AstIdsBuilder {
-    expressions: IndexVec<ScopeExpressionId, AstNodeRef<ast::Expr>>,
-    expressions_map: FxHashMap<NodeKey, ScopeExpressionId>,
-    statements: IndexVec<ScopeStatementId, AstNodeRef<ast::Stmt>>,
-    statements_map: FxHashMap<NodeKey, ScopeStatementId>,
+    next_id: ScopedExpressionId,
+    expressions_map: FxHashMap<ExpressionNodeKey, ScopedExpressionId>,
 }
 
 impl AstIdsBuilder {
     pub(super) fn new() -> Self {
         Self {
-            expressions: IndexVec::default(),
+            next_id: ScopedExpressionId::new(0),
             expressions_map: FxHashMap::default(),
-            statements: IndexVec::default(),
-            statements_map: FxHashMap::default(),
         }
     }
 
-    /// Adds `stmt` to the AST ids map and returns its id.
-    ///
-    /// ## Safety
-    /// The function is marked as unsafe because it calls [`AstNodeRef::new`] which requires
-    /// that `stmt` is a child of `parsed`.
-    #[allow(unsafe_code)]
-    pub(super) unsafe fn record_statement(
-        &mut self,
-        stmt: &ast::Stmt,
-        parsed: &ParsedModule,
-    ) -> ScopeStatementId {
-        let statement_id = self.statements.push(AstNodeRef::new(parsed.clone(), stmt));
-
-        self.statements_map
-            .insert(NodeKey::from_node(stmt), statement_id);
-
-        statement_id
-    }
-
     /// Adds `expr` to the AST ids map and returns its id.
     ///
     /// ## Safety
     /// The function is marked as unsafe because it calls [`AstNodeRef::new`] which requires
     /// that `expr` is a child of `parsed`.
     #[allow(unsafe_code)]
-    pub(super) unsafe fn record_expression(
-        &mut self,
-        expr: &ast::Expr,
-        parsed: &ParsedModule,
-    ) -> ScopeExpressionId {
-        let expression_id = self.expressions.push(AstNodeRef::new(parsed.clone(), expr));
+    pub(super) fn record_expression(&mut self, expr: &ast::Expr) -> ScopedExpressionId {
+        let expression_id = self.next_id;
+        self.next_id = expression_id + 1;
 
-        self.expressions_map
-            .insert(NodeKey::from_node(expr), expression_id);
+        self.expressions_map.insert(expr.into(), expression_id);
 
         expression_id
     }
 
     pub(super) fn finish(mut self) -> AstIds {
-        self.expressions.shrink_to_fit();
         self.expressions_map.shrink_to_fit();
-        self.statements.shrink_to_fit();
-        self.statements_map.shrink_to_fit();
 
         AstIds {
-            expressions: self.expressions,
             expressions_map: self.expressions_map,
-            statements: self.statements,
-            statements_map: self.statements_map,
+        }
+    }
+}
+
+/// Node key that can only be constructed for expressions.
+pub(crate) mod node_key {
+    use ruff_python_ast as ast;
+
+    use crate::node_key::NodeKey;
+
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub(crate) struct ExpressionNodeKey(NodeKey);
+
+    impl From<ast::ExpressionRef<'_>> for ExpressionNodeKey {
+        fn from(value: ast::ExpressionRef<'_>) -> Self {
+            Self(NodeKey::from_node(value))
+        }
+    }
+
+    impl From<&ast::Expr> for ExpressionNodeKey {
+        fn from(value: &ast::Expr) -> Self {
+            Self(NodeKey::from_node(value))
         }
     }
 }

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -3,58 +3,64 @@ use std::sync::Arc;
 use rustc_hash::FxHashMap;
 
 use ruff_db::parsed::ParsedModule;
+use ruff_db::vfs::VfsFile;
 use ruff_index::IndexVec;
 use ruff_python_ast as ast;
+use ruff_python_ast::name::Name;
 use ruff_python_ast::visitor::{walk_expr, walk_stmt, Visitor};
 
-use crate::name::Name;
-use crate::node_key::NodeKey;
-use crate::semantic_index::ast_ids::{
-    AstId, AstIdsBuilder, ScopeAssignmentId, ScopeClassId, ScopeFunctionId, ScopeImportFromId,
-    ScopeImportId, ScopeNamedExprId,
-};
-use crate::semantic_index::definition::{Definition, ImportDefinition, ImportFromDefinition};
+use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey;
+use crate::semantic_index::ast_ids::AstIdsBuilder;
+use crate::semantic_index::definition::{Definition, DefinitionNodeKey, DefinitionNodeRef};
 use crate::semantic_index::symbol::{
-    FileScopeId, FileSymbolId, Scope, ScopedSymbolId, SymbolFlags, SymbolTableBuilder,
+    FileScopeId, NodeWithScopeKey, NodeWithScopeRef, Scope, ScopeId, ScopedSymbolId, SymbolFlags,
+    SymbolTableBuilder,
 };
-use crate::semantic_index::{NodeWithScopeId, SemanticIndex};
+use crate::semantic_index::SemanticIndex;
+use crate::Db;
 
-pub(super) struct SemanticIndexBuilder<'a> {
+pub(super) struct SemanticIndexBuilder<'db, 'ast> {
     // Builder state
-    module: &'a ParsedModule,
+    db: &'db dyn Db,
+    file: VfsFile,
+    module: &'db ParsedModule,
     scope_stack: Vec<FileScopeId>,
-    /// the definition whose target(s) we are currently walking
-    current_definition: Option<Definition>,
+    /// the target we're currently inferring
+    current_target: Option<CurrentTarget<'ast>>,
 
     // Semantic Index fields
     scopes: IndexVec<FileScopeId, Scope>,
-    symbol_tables: IndexVec<FileScopeId, SymbolTableBuilder>,
+    scope_ids_by_scope: IndexVec<FileScopeId, ScopeId<'db>>,
+    symbol_tables: IndexVec<FileScopeId, SymbolTableBuilder<'db>>,
     ast_ids: IndexVec<FileScopeId, AstIdsBuilder>,
-    expression_scopes: FxHashMap<NodeKey, FileScopeId>,
-    scope_nodes: IndexVec<FileScopeId, NodeWithScopeId>,
+    scopes_by_node: FxHashMap<NodeWithScopeKey, FileScopeId>,
+    scopes_by_expression: FxHashMap<ExpressionNodeKey, FileScopeId>,
+    definitions_by_node: FxHashMap<DefinitionNodeKey, Definition<'db>>,
 }
 
-impl<'a> SemanticIndexBuilder<'a> {
-    pub(super) fn new(parsed: &'a ParsedModule) -> Self {
+impl<'db, 'ast> SemanticIndexBuilder<'db, 'ast>
+where
+    'db: 'ast,
+{
+    pub(super) fn new(db: &'db dyn Db, file: VfsFile, parsed: &'db ParsedModule) -> Self {
         let mut builder = Self {
+            db,
+            file,
             module: parsed,
             scope_stack: Vec::new(),
-            current_definition: None,
+            current_target: None,
 
             scopes: IndexVec::new(),
             symbol_tables: IndexVec::new(),
             ast_ids: IndexVec::new(),
-            expression_scopes: FxHashMap::default(),
-            scope_nodes: IndexVec::new(),
+            scope_ids_by_scope: IndexVec::new(),
+
+            scopes_by_expression: FxHashMap::default(),
+            scopes_by_node: FxHashMap::default(),
+            definitions_by_node: FxHashMap::default(),
         };
 
-        builder.push_scope_with_parent(
-            NodeWithScopeId::Module,
-            &Name::new_static("<module>"),
-            None,
-            None,
-            None,
-        );
+        builder.push_scope_with_parent(NodeWithScopeRef::Module, None);
 
         builder
     }
@@ -66,44 +72,40 @@ impl<'a> SemanticIndexBuilder<'a> {
             .expect("Always to have a root scope")
     }
 
-    fn push_scope(
-        &mut self,
-        node: NodeWithScopeId,
-        name: &Name,
-        defining_symbol: Option<FileSymbolId>,
-        definition: Option<Definition>,
-    ) {
+    fn push_scope(&mut self, node: NodeWithScopeRef<'ast>) {
         let parent = self.current_scope();
-        self.push_scope_with_parent(node, name, defining_symbol, definition, Some(parent));
+        self.push_scope_with_parent(node, Some(parent));
     }
 
     fn push_scope_with_parent(
         &mut self,
-        node: NodeWithScopeId,
-        name: &Name,
-        defining_symbol: Option<FileSymbolId>,
-        definition: Option<Definition>,
+        node: NodeWithScopeRef<'ast>,
         parent: Option<FileScopeId>,
     ) {
         let children_start = self.scopes.next_index() + 1;
 
         let scope = Scope {
-            name: name.clone(),
             parent,
-            defining_symbol,
-            definition,
             kind: node.scope_kind(),
             descendents: children_start..children_start,
         };
 
-        let scope_id = self.scopes.push(scope);
+        let file_scope_id = self.scopes.push(scope);
         self.symbol_tables.push(SymbolTableBuilder::new());
         let ast_id_scope = self.ast_ids.push(AstIdsBuilder::new());
-        let scope_node_id = self.scope_nodes.push(node);
 
-        debug_assert_eq!(ast_id_scope, scope_id);
-        debug_assert_eq!(scope_id, scope_node_id);
-        self.scope_stack.push(scope_id);
+        #[allow(unsafe_code)]
+        // SAFETY: `node` is guaranteed to be a child of `self.module`
+        let scope_id = ScopeId::new(self.db, self.file, file_scope_id, unsafe {
+            node.to_kind(self.module.clone())
+        });
+
+        self.scope_ids_by_scope.push(scope_id);
+        self.scopes_by_node.insert(node.node_key(), file_scope_id);
+
+        debug_assert_eq!(ast_id_scope, file_scope_id);
+
+        self.scope_stack.push(file_scope_id);
     }
 
     fn pop_scope(&mut self) -> FileScopeId {
@@ -114,7 +116,7 @@ impl<'a> SemanticIndexBuilder<'a> {
         id
     }
 
-    fn current_symbol_table(&mut self) -> &mut SymbolTableBuilder {
+    fn current_symbol_table(&mut self) -> &mut SymbolTableBuilder<'db> {
         let scope_id = self.current_scope();
         &mut self.symbol_tables[scope_id]
     }
@@ -126,49 +128,71 @@ impl<'a> SemanticIndexBuilder<'a> {
 
     fn add_or_update_symbol(&mut self, name: Name, flags: SymbolFlags) -> ScopedSymbolId {
         let symbol_table = self.current_symbol_table();
+        symbol_table.add_or_update_symbol(name, flags)
+    }
 
-        symbol_table.add_or_update_symbol(name, flags, None)
+    fn add_definition(
+        &mut self,
+        definition_node: impl Into<DefinitionNodeRef<'ast>>,
+        symbol_id: ScopedSymbolId,
+    ) -> Definition<'db> {
+        let definition_node = definition_node.into();
+        let definition = Definition::new(
+            self.db,
+            self.file,
+            self.current_scope(),
+            symbol_id,
+            #[allow(unsafe_code)]
+            unsafe {
+                definition_node.into_owned(self.module.clone())
+            },
+        );
+
+        self.definitions_by_node
+            .insert(definition_node.key(), definition);
+
+        definition
     }
 
     fn add_or_update_symbol_with_definition(
         &mut self,
         name: Name,
-
-        definition: Definition,
-    ) -> ScopedSymbolId {
+        definition: impl Into<DefinitionNodeRef<'ast>>,
+    ) -> (ScopedSymbolId, Definition<'db>) {
         let symbol_table = self.current_symbol_table();
 
-        symbol_table.add_or_update_symbol(name, SymbolFlags::IS_DEFINED, Some(definition))
+        let id = symbol_table.add_or_update_symbol(name, SymbolFlags::IS_DEFINED);
+        let definition = self.add_definition(definition, id);
+        self.current_symbol_table().add_definition(id, definition);
+        (id, definition)
     }
 
     fn with_type_params(
         &mut self,
-        name: &Name,
-        with_params: &WithTypeParams,
-        defining_symbol: FileSymbolId,
+        with_params: &WithTypeParams<'ast>,
         nested: impl FnOnce(&mut Self) -> FileScopeId,
     ) -> FileScopeId {
         let type_params = with_params.type_parameters();
 
         if let Some(type_params) = type_params {
-            let type_node = match with_params {
-                WithTypeParams::ClassDef { id, .. } => NodeWithScopeId::ClassTypeParams(*id),
-                WithTypeParams::FunctionDef { id, .. } => NodeWithScopeId::FunctionTypeParams(*id),
+            let with_scope = match with_params {
+                WithTypeParams::ClassDef { node, .. } => {
+                    NodeWithScopeRef::ClassTypeParameters(node)
+                }
+                WithTypeParams::FunctionDef { node, .. } => {
+                    NodeWithScopeRef::FunctionTypeParameters(node)
+                }
             };
 
-            self.push_scope(
-                type_node,
-                name,
-                Some(defining_symbol),
-                Some(with_params.definition()),
-            );
+            self.push_scope(with_scope);
+
             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::new(name), SymbolFlags::IS_DEFINED);
+                self.add_or_update_symbol(name.id.clone(), SymbolFlags::IS_DEFINED);
             }
         }
 
@@ -181,7 +205,7 @@ impl<'a> SemanticIndexBuilder<'a> {
         nested_scope
     }
 
-    pub(super) fn build(mut self) -> SemanticIndex {
+    pub(super) fn build(mut self) -> SemanticIndex<'db> {
         let module = self.module;
         self.visit_body(module.suite());
 
@@ -189,7 +213,7 @@ impl<'a> SemanticIndexBuilder<'a> {
         self.pop_scope();
         assert!(self.scope_stack.is_empty());
 
-        assert!(self.current_definition.is_none());
+        assert!(self.current_target.is_none());
 
         let mut symbol_tables: IndexVec<_, _> = self
             .symbol_tables
@@ -206,61 +230,49 @@ impl<'a> SemanticIndexBuilder<'a> {
         self.scopes.shrink_to_fit();
         ast_ids.shrink_to_fit();
         symbol_tables.shrink_to_fit();
-        self.expression_scopes.shrink_to_fit();
-        self.scope_nodes.shrink_to_fit();
+        self.scopes_by_expression.shrink_to_fit();
+        self.definitions_by_node.shrink_to_fit();
+
+        self.scope_ids_by_scope.shrink_to_fit();
+        self.scopes_by_node.shrink_to_fit();
 
         SemanticIndex {
             symbol_tables,
             scopes: self.scopes,
-            scope_nodes: self.scope_nodes,
+            definitions_by_node: self.definitions_by_node,
+            scope_ids_by_scope: self.scope_ids_by_scope,
             ast_ids,
-            expression_scopes: self.expression_scopes,
+            scopes_by_expression: self.scopes_by_expression,
+            scopes_by_node: self.scopes_by_node,
         }
     }
 }
 
-impl Visitor<'_> for SemanticIndexBuilder<'_> {
-    fn visit_stmt(&mut self, stmt: &ast::Stmt) {
-        let module = self.module;
-        #[allow(unsafe_code)]
-        let statement_id = unsafe {
-            // SAFETY: The builder only visits nodes that are part of `module`. This guarantees that
-            // the current statement must be a child of `module`.
-            self.current_ast_ids().record_statement(stmt, module)
-        };
+impl<'db, 'ast> Visitor<'ast> for SemanticIndexBuilder<'db, 'ast>
+where
+    'db: 'ast,
+{
+    fn visit_stmt(&mut self, stmt: &'ast ast::Stmt) {
         match stmt {
             ast::Stmt::FunctionDef(function_def) => {
                 for decorator in &function_def.decorator_list {
                     self.visit_decorator(decorator);
                 }
-                let name = Name::new(&function_def.name.id);
-                let function_id = ScopeFunctionId(statement_id);
-                let definition = Definition::FunctionDef(function_id);
-                let scope = self.current_scope();
-                let symbol = FileSymbolId::new(
-                    scope,
-                    self.add_or_update_symbol_with_definition(name.clone(), definition),
+
+                self.add_or_update_symbol_with_definition(
+                    function_def.name.id.clone(),
+                    function_def,
                 );
 
                 self.with_type_params(
-                    &name,
-                    &WithTypeParams::FunctionDef {
-                        node: function_def,
-                        id: AstId::new(scope, function_id),
-                    },
-                    symbol,
+                    &WithTypeParams::FunctionDef { node: function_def },
                     |builder| {
                         builder.visit_parameters(&function_def.parameters);
                         for expr in &function_def.returns {
                             builder.visit_annotation(expr);
                         }
 
-                        builder.push_scope(
-                            NodeWithScopeId::Function(AstId::new(scope, function_id)),
-                            &name,
-                            Some(symbol),
-                            Some(definition),
-                        );
+                        builder.push_scope(NodeWithScopeRef::Function(function_def));
                         builder.visit_body(&function_def.body);
                         builder.pop_scope()
                     },
@@ -271,51 +283,28 @@ impl Visitor<'_> for SemanticIndexBuilder<'_> {
                     self.visit_decorator(decorator);
                 }
 
-                let name = Name::new(&class.name.id);
-                let class_id = ScopeClassId(statement_id);
-                let definition = Definition::from(class_id);
-                let scope = self.current_scope();
-                let id = FileSymbolId::new(
-                    self.current_scope(),
-                    self.add_or_update_symbol_with_definition(name.clone(), definition),
-                );
-                self.with_type_params(
-                    &name,
-                    &WithTypeParams::ClassDef {
-                        node: class,
-                        id: AstId::new(scope, class_id),
-                    },
-                    id,
-                    |builder| {
-                        if let Some(arguments) = &class.arguments {
-                            builder.visit_arguments(arguments);
-                        }
+                self.add_or_update_symbol_with_definition(class.name.id.clone(), class);
 
-                        builder.push_scope(
-                            NodeWithScopeId::Class(AstId::new(scope, class_id)),
-                            &name,
-                            Some(id),
-                            Some(definition),
-                        );
-                        builder.visit_body(&class.body);
+                self.with_type_params(&WithTypeParams::ClassDef { node: class }, |builder| {
+                    if let Some(arguments) = &class.arguments {
+                        builder.visit_arguments(arguments);
+                    }
 
-                        builder.pop_scope()
-                    },
-                );
+                    builder.push_scope(NodeWithScopeRef::Class(class));
+                    builder.visit_body(&class.body);
+
+                    builder.pop_scope()
+                });
             }
             ast::Stmt::Import(ast::StmtImport { names, .. }) => {
-                for (i, alias) in names.iter().enumerate() {
+                for alias in names {
                     let symbol_name = if let Some(asname) = &alias.asname {
-                        asname.id.as_str()
+                        asname.id.clone()
                     } else {
-                        alias.name.id.split('.').next().unwrap()
+                        Name::new(alias.name.id.split('.').next().unwrap())
                     };
 
-                    let def = Definition::Import(ImportDefinition {
-                        import_id: ScopeImportId(statement_id),
-                        alias: u32::try_from(i).unwrap(),
-                    });
-                    self.add_or_update_symbol_with_definition(Name::new(symbol_name), def);
+                    self.add_or_update_symbol_with_definition(symbol_name, alias);
                 }
             }
             ast::Stmt::ImportFrom(ast::StmtImportFrom {
@@ -324,28 +313,24 @@ impl Visitor<'_> for SemanticIndexBuilder<'_> {
                 level: _,
                 ..
             }) => {
-                for (i, alias) in names.iter().enumerate() {
+                for alias in names {
                     let symbol_name = if let Some(asname) = &alias.asname {
-                        asname.id.as_str()
+                        &asname.id
                     } else {
-                        alias.name.id.as_str()
+                        &alias.name.id
                     };
-                    let def = Definition::ImportFrom(ImportFromDefinition {
-                        import_id: ScopeImportFromId(statement_id),
-                        name: u32::try_from(i).unwrap(),
-                    });
-                    self.add_or_update_symbol_with_definition(Name::new(symbol_name), def);
+
+                    self.add_or_update_symbol_with_definition(symbol_name.clone(), alias);
                 }
             }
             ast::Stmt::Assign(node) => {
-                debug_assert!(self.current_definition.is_none());
+                debug_assert!(self.current_target.is_none());
                 self.visit_expr(&node.value);
-                self.current_definition =
-                    Some(Definition::Assignment(ScopeAssignmentId(statement_id)));
                 for target in &node.targets {
+                    self.current_target = Some(CurrentTarget::Expr(target));
                     self.visit_expr(target);
                 }
-                self.current_definition = None;
+                self.current_target = None;
             }
             _ => {
                 walk_stmt(self, stmt);
@@ -353,17 +338,10 @@ impl Visitor<'_> for SemanticIndexBuilder<'_> {
         }
     }
 
-    fn visit_expr(&mut self, expr: &'_ ast::Expr) {
-        let module = self.module;
-        #[allow(unsafe_code)]
-        let expression_id = unsafe {
-            // SAFETY: The builder only visits nodes that are part of `module`. This guarantees that
-            // the current expression must be a child of `module`.
-            self.current_ast_ids().record_expression(expr, module)
-        };
-
-        self.expression_scopes
-            .insert(NodeKey::from_node(expr), self.current_scope());
+    fn visit_expr(&mut self, expr: &'ast ast::Expr) {
+        self.scopes_by_expression
+            .insert(expr.into(), self.current_scope());
+        self.current_ast_ids().record_expression(expr);
 
         match expr {
             ast::Expr::Name(ast::ExprName { id, ctx, .. }) => {
@@ -373,24 +351,23 @@ impl Visitor<'_> for SemanticIndexBuilder<'_> {
                     ast::ExprContext::Del => SymbolFlags::IS_DEFINED,
                     ast::ExprContext::Invalid => SymbolFlags::empty(),
                 };
-                match self.current_definition {
-                    Some(definition) if flags.contains(SymbolFlags::IS_DEFINED) => {
-                        self.add_or_update_symbol_with_definition(Name::new(id), definition);
+                match self.current_target {
+                    Some(target) if flags.contains(SymbolFlags::IS_DEFINED) => {
+                        self.add_or_update_symbol_with_definition(id.clone(), target);
                     }
                     _ => {
-                        self.add_or_update_symbol(Name::new(id), flags);
+                        self.add_or_update_symbol(id.clone(), flags);
                     }
                 }
 
                 walk_expr(self, expr);
             }
             ast::Expr::Named(node) => {
-                debug_assert!(self.current_definition.is_none());
-                self.current_definition =
-                    Some(Definition::NamedExpr(ScopeNamedExprId(expression_id)));
+                debug_assert!(self.current_target.is_none());
+                self.current_target = Some(CurrentTarget::ExprNamed(node));
                 // TODO walrus in comprehensions is implicitly nonlocal
                 self.visit_expr(&node.target);
-                self.current_definition = None;
+                self.current_target = None;
                 self.visit_expr(&node.value);
             }
             ast::Expr::If(ast::ExprIf {
@@ -426,29 +403,31 @@ impl Visitor<'_> for SemanticIndexBuilder<'_> {
     }
 }
 
-enum WithTypeParams<'a> {
-    ClassDef {
-        node: &'a ast::StmtClassDef,
-        id: AstId<ScopeClassId>,
-    },
-    FunctionDef {
-        node: &'a ast::StmtFunctionDef,
-        id: AstId<ScopeFunctionId>,
-    },
+enum WithTypeParams<'node> {
+    ClassDef { node: &'node ast::StmtClassDef },
+    FunctionDef { node: &'node ast::StmtFunctionDef },
 }
 
-impl<'a> WithTypeParams<'a> {
-    fn type_parameters(&self) -> Option<&'a ast::TypeParams> {
+impl<'node> WithTypeParams<'node> {
+    fn type_parameters(&self) -> Option<&'node ast::TypeParams> {
         match self {
             WithTypeParams::ClassDef { node, .. } => node.type_params.as_deref(),
             WithTypeParams::FunctionDef { node, .. } => node.type_params.as_deref(),
         }
     }
+}
 
-    fn definition(&self) -> Definition {
-        match self {
-            WithTypeParams::ClassDef { id, .. } => Definition::ClassDef(id.in_scope_id()),
-            WithTypeParams::FunctionDef { id, .. } => Definition::FunctionDef(id.in_scope_id()),
+#[derive(Copy, Clone, Debug)]
+enum CurrentTarget<'a> {
+    Expr(&'a ast::Expr),
+    ExprNamed(&'a ast::ExprNamed),
+}
+
+impl<'a> From<CurrentTarget<'a>> for DefinitionNodeRef<'a> {
+    fn from(val: CurrentTarget<'a>) -> Self {
+        match val {
+            CurrentTarget::Expr(expression) => DefinitionNodeRef::Target(expression),
+            CurrentTarget::ExprNamed(named) => DefinitionNodeRef::NamedExpression(named),
         }
     }
 }

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -1,76 +1,103 @@
-use crate::semantic_index::ast_ids::{
-    ScopeAnnotatedAssignmentId, ScopeAssignmentId, ScopeClassId, ScopeFunctionId,
-    ScopeImportFromId, ScopeImportId, ScopeNamedExprId,
-};
+use ruff_db::parsed::ParsedModule;
+use ruff_db::vfs::VfsFile;
+use ruff_python_ast as ast;
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum Definition {
-    Import(ImportDefinition),
-    ImportFrom(ImportFromDefinition),
-    ClassDef(ScopeClassId),
-    FunctionDef(ScopeFunctionId),
-    Assignment(ScopeAssignmentId),
-    AnnotatedAssignment(ScopeAnnotatedAssignmentId),
-    NamedExpr(ScopeNamedExprId),
-    /// represents the implicit initial definition of every name as "unbound"
-    Unbound,
-    // TODO with statements, except handlers, function args...
+use crate::ast_node_ref::AstNodeRef;
+use crate::node_key::NodeKey;
+use crate::semantic_index::symbol::{FileScopeId, ScopedSymbolId};
+
+#[salsa::tracked]
+pub struct Definition<'db> {
+    /// The file in which the definition is defined.
+    #[id]
+    pub(super) file: VfsFile,
+
+    /// The scope in which the definition is defined.
+    #[id]
+    pub(crate) scope: FileScopeId,
+
+    /// The id of the corresponding symbol. Mainly used as ID.
+    #[id]
+    symbol_id: ScopedSymbolId,
+
+    #[no_eq]
+    #[return_ref]
+    pub(crate) node: DefinitionKind,
 }
 
-impl From<ImportDefinition> for Definition {
-    fn from(value: ImportDefinition) -> Self {
-        Self::Import(value)
+#[derive(Copy, Clone, Debug)]
+pub(crate) enum DefinitionNodeRef<'a> {
+    Alias(&'a ast::Alias),
+    Function(&'a ast::StmtFunctionDef),
+    Class(&'a ast::StmtClassDef),
+    NamedExpression(&'a ast::ExprNamed),
+    Target(&'a ast::Expr),
+}
+
+impl<'a> From<&'a ast::Alias> for DefinitionNodeRef<'a> {
+    fn from(node: &'a ast::Alias) -> Self {
+        Self::Alias(node)
+    }
+}
+impl<'a> From<&'a ast::StmtFunctionDef> for DefinitionNodeRef<'a> {
+    fn from(node: &'a ast::StmtFunctionDef) -> Self {
+        Self::Function(node)
+    }
+}
+impl<'a> From<&'a ast::StmtClassDef> for DefinitionNodeRef<'a> {
+    fn from(node: &'a ast::StmtClassDef) -> Self {
+        Self::Class(node)
+    }
+}
+impl<'a> From<&'a ast::ExprNamed> for DefinitionNodeRef<'a> {
+    fn from(node: &'a ast::ExprNamed) -> Self {
+        Self::NamedExpression(node)
     }
 }
 
-impl From<ImportFromDefinition> for Definition {
-    fn from(value: ImportFromDefinition) -> Self {
-        Self::ImportFrom(value)
+impl DefinitionNodeRef<'_> {
+    #[allow(unsafe_code)]
+    pub(super) unsafe fn into_owned(self, parsed: ParsedModule) -> DefinitionKind {
+        match self {
+            DefinitionNodeRef::Alias(alias) => {
+                DefinitionKind::Alias(AstNodeRef::new(parsed, alias))
+            }
+            DefinitionNodeRef::Function(function) => {
+                DefinitionKind::Function(AstNodeRef::new(parsed, function))
+            }
+            DefinitionNodeRef::Class(class) => {
+                DefinitionKind::Class(AstNodeRef::new(parsed, class))
+            }
+            DefinitionNodeRef::NamedExpression(named) => {
+                DefinitionKind::NamedExpression(AstNodeRef::new(parsed, named))
+            }
+            DefinitionNodeRef::Target(target) => {
+                DefinitionKind::Target(AstNodeRef::new(parsed, target))
+            }
+        }
     }
 }
 
-impl From<ScopeClassId> for Definition {
-    fn from(value: ScopeClassId) -> Self {
-        Self::ClassDef(value)
+impl DefinitionNodeRef<'_> {
+    pub(super) fn key(self) -> DefinitionNodeKey {
+        match self {
+            Self::Alias(node) => DefinitionNodeKey(NodeKey::from_node(node)),
+            Self::Function(node) => DefinitionNodeKey(NodeKey::from_node(node)),
+            Self::Class(node) => DefinitionNodeKey(NodeKey::from_node(node)),
+            Self::NamedExpression(node) => DefinitionNodeKey(NodeKey::from_node(node)),
+            Self::Target(node) => DefinitionNodeKey(NodeKey::from_node(node)),
+        }
     }
 }
 
-impl From<ScopeFunctionId> for Definition {
-    fn from(value: ScopeFunctionId) -> Self {
-        Self::FunctionDef(value)
-    }
+#[derive(Clone, Debug)]
+pub enum DefinitionKind {
+    Alias(AstNodeRef<ast::Alias>),
+    Function(AstNodeRef<ast::StmtFunctionDef>),
+    Class(AstNodeRef<ast::StmtClassDef>),
+    NamedExpression(AstNodeRef<ast::ExprNamed>),
+    Target(AstNodeRef<ast::Expr>),
 }
 
-impl From<ScopeAssignmentId> for Definition {
-    fn from(value: ScopeAssignmentId) -> Self {
-        Self::Assignment(value)
-    }
-}
-
-impl From<ScopeAnnotatedAssignmentId> for Definition {
-    fn from(value: ScopeAnnotatedAssignmentId) -> Self {
-        Self::AnnotatedAssignment(value)
-    }
-}
-
-impl From<ScopeNamedExprId> for Definition {
-    fn from(value: ScopeNamedExprId) -> Self {
-        Self::NamedExpr(value)
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct ImportDefinition {
-    pub(crate) import_id: ScopeImportId,
-
-    /// Index into [`ruff_python_ast::StmtImport::names`].
-    pub(crate) alias: u32,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct ImportFromDefinition {
-    pub(crate) import_id: ScopeImportFromId,
-
-    /// Index into [`ruff_python_ast::StmtImportFrom::names`].
-    pub(crate) name: u32,
-}
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+pub(super) struct DefinitionNodeKey(NodeKey);

crates/red_knot_python_semantic/src/semantic_index/symbol.rs

@@ -3,36 +3,39 @@ use std::ops::Range;
 
 use bitflags::bitflags;
 use hashbrown::hash_map::RawEntryMut;
-use rustc_hash::FxHasher;
-use salsa::DebugWithDb;
-use smallvec::SmallVec;
-
+use ruff_db::parsed::ParsedModule;
 use ruff_db::vfs::VfsFile;
 use ruff_index::{newtype_index, IndexVec};
+use ruff_python_ast::name::Name;
+use ruff_python_ast::{self as ast};
+use rustc_hash::FxHasher;
 
-use crate::name::Name;
+use crate::ast_node_ref::AstNodeRef;
+use crate::node_key::NodeKey;
 use crate::semantic_index::definition::Definition;
 use crate::semantic_index::{root_scope, semantic_index, symbol_table, SymbolMap};
 use crate::Db;
 
 #[derive(Eq, PartialEq, Debug)]
-pub struct Symbol {
+pub struct Symbol<'db> {
     name: Name,
     flags: SymbolFlags,
     /// The nodes that define this symbol, in source order.
-    definitions: SmallVec<[Definition; 4]>,
+    ///
+    /// TODO: Use smallvec here, but it creates the same lifetime issues as in [QualifiedName](https://github.com/astral-sh/ruff/blob/5109b50bb3847738eeb209352cf26bda392adf62/crates/ruff_python_ast/src/name.rs#L562-L569)
+    definitions: Vec<Definition<'db>>,
 }
 
-impl Symbol {
-    fn new(name: Name, definition: Option<Definition>) -> Self {
+impl<'db> Symbol<'db> {
+    fn new(name: Name) -> Self {
         Self {
             name,
             flags: SymbolFlags::empty(),
-            definitions: definition.into_iter().collect(),
+            definitions: Vec::new(),
         }
     }
 
-    fn push_definition(&mut self, definition: Definition) {
+    fn push_definition(&mut self, definition: Definition<'db>) {
         self.definitions.push(definition);
     }
 
@@ -89,13 +92,6 @@ pub struct FileSymbolId {
 }
 
 impl FileSymbolId {
-    pub(super) fn new(scope: FileScopeId, symbol: ScopedSymbolId) -> Self {
-        Self {
-            scope,
-            scoped_symbol_id: symbol,
-        }
-    }
-
     pub fn scope(self) -> FileScopeId {
         self.scope
     }
@@ -126,42 +122,9 @@ impl ScopedSymbolId {
     }
 }
 
-/// Returns a mapping from [`FileScopeId`] to globally unique [`ScopeId`].
-#[salsa::tracked(return_ref)]
-pub(crate) fn scopes_map(db: &dyn Db, file: VfsFile) -> ScopesMap<'_> {
-    let _ = tracing::trace_span!("scopes_map", file = ?file.debug(db.upcast())).enter();
-
-    let index = semantic_index(db, file);
-
-    let scopes: IndexVec<_, _> = index
-        .scopes
-        .indices()
-        .map(|id| ScopeId::new(db, file, id))
-        .collect();
-
-    ScopesMap { scopes }
-}
-
-/// Maps from the file specific [`FileScopeId`] to the global [`ScopeId`] that can be used as a Salsa query parameter.
-///
-/// The [`SemanticIndex`] uses [`FileScopeId`] on a per-file level to identify scopes
-/// because they allow for more efficient storage of associated data
-/// (use of an [`IndexVec`] keyed by [`FileScopeId`] over an [`FxHashMap`] keyed by [`ScopeId`]).
-#[derive(Eq, PartialEq, Debug)]
-pub(crate) struct ScopesMap<'db> {
-    scopes: IndexVec<FileScopeId, ScopeId<'db>>,
-}
-
-impl<'db> ScopesMap<'db> {
-    /// Gets the program-wide unique scope id for the given file specific `scope_id`.
-    fn get(&self, scope: FileScopeId) -> ScopeId<'db> {
-        self.scopes[scope]
-    }
-}
-
 #[salsa::tracked(return_ref)]
 pub(crate) fn public_symbols_map(db: &dyn Db, file: VfsFile) -> PublicSymbolsMap<'_> {
-    let _ = tracing::trace_span!("public_symbols_map", file = ?file.debug(db.upcast())).enter();
+    let _span = tracing::trace_span!("public_symbols_map", ?file).entered();
 
     let module_scope = root_scope(db, file);
     let symbols = symbol_table(db, module_scope);
@@ -192,11 +155,29 @@ impl<'db> PublicSymbolsMap<'db> {
 /// A cross-module identifier of a scope that can be used as a salsa query parameter.
 #[salsa::tracked]
 pub struct ScopeId<'db> {
-    #[allow(clippy::used_underscore_binding)]
     #[id]
     pub file: VfsFile,
     #[id]
     pub file_scope_id: FileScopeId,
+
+    /// The node that introduces this scope.
+    #[no_eq]
+    #[return_ref]
+    pub node: NodeWithScopeKind,
+}
+
+impl<'db> ScopeId<'db> {
+    #[cfg(test)]
+    pub(crate) fn name(self, db: &'db dyn Db) -> &'db str {
+        match self.node(db) {
+            NodeWithScopeKind::Module => "<module>",
+            NodeWithScopeKind::Class(class) | NodeWithScopeKind::ClassTypeParameters(class) => {
+                class.name.as_str()
+            }
+            NodeWithScopeKind::Function(function)
+            | NodeWithScopeKind::FunctionTypeParameters(function) => function.name.as_str(),
+        }
+    }
 }
 
 /// ID that uniquely identifies a scope inside of a module.
@@ -210,33 +191,19 @@ impl FileScopeId {
     }
 
     pub fn to_scope_id(self, db: &dyn Db, file: VfsFile) -> ScopeId<'_> {
-        scopes_map(db, file).get(self)
+        let index = semantic_index(db, file);
+        index.scope_ids_by_scope[self]
     }
 }
 
 #[derive(Debug, Eq, PartialEq)]
 pub struct Scope {
-    pub(super) name: Name,
     pub(super) parent: Option<FileScopeId>,
-    pub(super) definition: Option<Definition>,
-    pub(super) defining_symbol: Option<FileSymbolId>,
     pub(super) kind: ScopeKind,
     pub(super) descendents: Range<FileScopeId>,
 }
 
 impl Scope {
-    pub fn name(&self) -> &Name {
-        &self.name
-    }
-
-    pub fn definition(&self) -> Option<Definition> {
-        self.definition
-    }
-
-    pub fn defining_symbol(&self) -> Option<FileSymbolId> {
-        self.defining_symbol
-    }
-
     pub fn parent(self) -> Option<FileScopeId> {
         self.parent
     }
@@ -256,15 +223,15 @@ pub enum ScopeKind {
 
 /// Symbol table for a specific [`Scope`].
 #[derive(Debug)]
-pub struct SymbolTable {
+pub struct SymbolTable<'db> {
     /// The symbols in this scope.
-    symbols: IndexVec<ScopedSymbolId, Symbol>,
+    symbols: IndexVec<ScopedSymbolId, Symbol<'db>>,
 
     /// The symbols indexed by name.
     symbols_by_name: SymbolMap,
 }
 
-impl SymbolTable {
+impl<'db> SymbolTable<'db> {
     fn new() -> Self {
         Self {
             symbols: IndexVec::new(),
@@ -276,21 +243,21 @@ impl SymbolTable {
         self.symbols.shrink_to_fit();
     }
 
-    pub(crate) fn symbol(&self, symbol_id: impl Into<ScopedSymbolId>) -> &Symbol {
+    pub(crate) fn symbol(&self, symbol_id: impl Into<ScopedSymbolId>) -> &Symbol<'db> {
         &self.symbols[symbol_id.into()]
     }
 
-    pub(crate) fn symbol_ids(&self) -> impl Iterator<Item = ScopedSymbolId> {
+    pub(crate) fn symbol_ids(&self) -> impl Iterator<Item = ScopedSymbolId> + 'db {
         self.symbols.indices()
     }
 
-    pub fn symbols(&self) -> impl Iterator<Item = &Symbol> {
+    pub fn symbols(&self) -> impl Iterator<Item = &Symbol<'db>> {
         self.symbols.iter()
     }
 
     /// Returns the symbol named `name`.
     #[allow(unused)]
-    pub(crate) fn symbol_by_name(&self, name: &str) -> Option<&Symbol> {
+    pub(crate) fn symbol_by_name(&self, name: &str) -> Option<&Symbol<'db>> {
         let id = self.symbol_id_by_name(name)?;
         Some(self.symbol(id))
     }
@@ -314,21 +281,21 @@ impl SymbolTable {
     }
 }
 
-impl PartialEq for SymbolTable {
+impl PartialEq for SymbolTable<'_> {
     fn eq(&self, other: &Self) -> bool {
         // We don't need to compare the symbols_by_name because the name is already captured in `Symbol`.
         self.symbols == other.symbols
     }
 }
 
-impl Eq for SymbolTable {}
+impl Eq for SymbolTable<'_> {}
 
 #[derive(Debug)]
-pub(super) struct SymbolTableBuilder {
-    table: SymbolTable,
+pub(super) struct SymbolTableBuilder<'db> {
+    table: SymbolTable<'db>,
 }
 
-impl SymbolTableBuilder {
+impl<'db> SymbolTableBuilder<'db> {
     pub(super) fn new() -> Self {
         Self {
             table: SymbolTable::new(),
@@ -339,7 +306,6 @@ impl SymbolTableBuilder {
         &mut self,
         name: Name,
         flags: SymbolFlags,
-        definition: Option<Definition>,
     ) -> ScopedSymbolId {
         let hash = SymbolTable::hash_name(&name);
         let entry = self
@@ -353,14 +319,10 @@ impl SymbolTableBuilder {
                 let symbol = &mut self.table.symbols[*entry.key()];
                 symbol.insert_flags(flags);
 
-                if let Some(definition) = definition {
-                    symbol.push_definition(definition);
-                }
-
                 *entry.key()
             }
             RawEntryMut::Vacant(entry) => {
-                let mut symbol = Symbol::new(name, definition);
+                let mut symbol = Symbol::new(name);
                 symbol.insert_flags(flags);
 
                 let id = self.table.symbols.push(symbol);
@@ -372,8 +334,92 @@ impl SymbolTableBuilder {
         }
     }
 
-    pub(super) fn finish(mut self) -> SymbolTable {
+    pub(super) fn add_definition(&mut self, symbol: ScopedSymbolId, definition: Definition<'db>) {
+        self.table.symbols[symbol].push_definition(definition);
+    }
+
+    pub(super) fn finish(mut self) -> SymbolTable<'db> {
         self.table.shrink_to_fit();
         self.table
     }
 }
+
+/// Reference to a node that introduces a new scope.
+#[derive(Copy, Clone, Debug)]
+pub(crate) enum NodeWithScopeRef<'a> {
+    Module,
+    Class(&'a ast::StmtClassDef),
+    Function(&'a ast::StmtFunctionDef),
+    FunctionTypeParameters(&'a ast::StmtFunctionDef),
+    ClassTypeParameters(&'a ast::StmtClassDef),
+}
+
+impl NodeWithScopeRef<'_> {
+    /// Converts the unowned reference to an owned [`NodeWithScopeKind`].
+    ///
+    /// # Safety
+    /// The node wrapped by `self` must be a child of `module`.
+    #[allow(unsafe_code)]
+    pub(super) unsafe fn to_kind(self, module: ParsedModule) -> NodeWithScopeKind {
+        match self {
+            NodeWithScopeRef::Module => NodeWithScopeKind::Module,
+            NodeWithScopeRef::Class(class) => {
+                NodeWithScopeKind::Class(AstNodeRef::new(module, class))
+            }
+            NodeWithScopeRef::Function(function) => {
+                NodeWithScopeKind::Function(AstNodeRef::new(module, function))
+            }
+            NodeWithScopeRef::FunctionTypeParameters(function) => {
+                NodeWithScopeKind::FunctionTypeParameters(AstNodeRef::new(module, function))
+            }
+            NodeWithScopeRef::ClassTypeParameters(class) => {
+                NodeWithScopeKind::Class(AstNodeRef::new(module, class))
+            }
+        }
+    }
+
+    pub(super) fn scope_kind(self) -> ScopeKind {
+        match self {
+            NodeWithScopeRef::Module => ScopeKind::Module,
+            NodeWithScopeRef::Class(_) => ScopeKind::Class,
+            NodeWithScopeRef::Function(_) => ScopeKind::Function,
+            NodeWithScopeRef::FunctionTypeParameters(_)
+            | NodeWithScopeRef::ClassTypeParameters(_) => ScopeKind::Annotation,
+        }
+    }
+
+    pub(crate) fn node_key(self) -> NodeWithScopeKey {
+        match self {
+            NodeWithScopeRef::Module => NodeWithScopeKey::Module,
+            NodeWithScopeRef::Class(class) => NodeWithScopeKey::Class(NodeKey::from_node(class)),
+            NodeWithScopeRef::Function(function) => {
+                NodeWithScopeKey::Function(NodeKey::from_node(function))
+            }
+            NodeWithScopeRef::FunctionTypeParameters(function) => {
+                NodeWithScopeKey::FunctionTypeParameters(NodeKey::from_node(function))
+            }
+            NodeWithScopeRef::ClassTypeParameters(class) => {
+                NodeWithScopeKey::ClassTypeParameters(NodeKey::from_node(class))
+            }
+        }
+    }
+}
+
+/// Node that introduces a new scope.
+#[derive(Clone, Debug)]
+pub enum NodeWithScopeKind {
+    Module,
+    Class(AstNodeRef<ast::StmtClassDef>),
+    ClassTypeParameters(AstNodeRef<ast::StmtClassDef>),
+    Function(AstNodeRef<ast::StmtFunctionDef>),
+    FunctionTypeParameters(AstNodeRef<ast::StmtFunctionDef>),
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub(crate) enum NodeWithScopeKey {
+    Module,
+    Class(NodeKey),
+    ClassTypeParameters(NodeKey),
+    Function(NodeKey),
+    FunctionTypeParameters(NodeKey),
+}

crates/red_knot_python_semantic/src/semantic_model.rs

@@ -0,0 +1,268 @@
+use red_knot_module_resolver::{resolve_module, Module, ModuleName};
+use ruff_db::vfs::VfsFile;
+use ruff_python_ast as ast;
+use ruff_python_ast::{Expr, ExpressionRef, StmtClassDef};
+
+use crate::semantic_index::ast_ids::HasScopedAstId;
+use crate::semantic_index::symbol::PublicSymbolId;
+use crate::semantic_index::{public_symbol, semantic_index};
+use crate::types::{infer_types, public_symbol_ty, Type};
+use crate::Db;
+
+pub struct SemanticModel<'db> {
+    db: &'db dyn Db,
+    file: VfsFile,
+}
+
+impl<'db> SemanticModel<'db> {
+    pub fn new(db: &'db dyn Db, file: VfsFile) -> Self {
+        Self { db, file }
+    }
+
+    // TODO we don't actually want to expose the Db directly to lint rules, but we need to find a
+    // solution for exposing information from types
+    pub fn db(&self) -> &dyn Db {
+        self.db
+    }
+
+    pub fn resolve_module(&self, module_name: ModuleName) -> Option<Module> {
+        resolve_module(self.db.upcast(), module_name)
+    }
+
+    pub fn public_symbol(&self, module: &Module, symbol_name: &str) -> Option<PublicSymbolId<'db>> {
+        public_symbol(self.db, module.file(), symbol_name)
+    }
+
+    pub fn public_symbol_ty(&self, symbol: PublicSymbolId<'db>) -> Type {
+        public_symbol_ty(self.db, symbol)
+    }
+}
+
+pub trait HasTy {
+    /// Returns the inferred type of `self`.
+    ///
+    /// ## Panics
+    /// May panic if `self` is from another file than `model`.
+    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db>;
+}
+
+impl HasTy for ast::ExpressionRef<'_> {
+    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
+        let index = semantic_index(model.db, model.file);
+        let file_scope = index.expression_scope_id(*self);
+        let scope = file_scope.to_scope_id(model.db, model.file);
+
+        let expression_id = self.scoped_ast_id(model.db, scope);
+        infer_types(model.db, scope).expression_ty(expression_id)
+    }
+}
+
+macro_rules! impl_expression_has_ty {
+    ($ty: ty) => {
+        impl HasTy for $ty {
+            #[inline]
+            fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
+                let expression_ref = ExpressionRef::from(self);
+                expression_ref.ty(model)
+            }
+        }
+    };
+}
+
+impl_expression_has_ty!(ast::ExprBoolOp);
+impl_expression_has_ty!(ast::ExprNamed);
+impl_expression_has_ty!(ast::ExprBinOp);
+impl_expression_has_ty!(ast::ExprUnaryOp);
+impl_expression_has_ty!(ast::ExprLambda);
+impl_expression_has_ty!(ast::ExprIf);
+impl_expression_has_ty!(ast::ExprDict);
+impl_expression_has_ty!(ast::ExprSet);
+impl_expression_has_ty!(ast::ExprListComp);
+impl_expression_has_ty!(ast::ExprSetComp);
+impl_expression_has_ty!(ast::ExprDictComp);
+impl_expression_has_ty!(ast::ExprGenerator);
+impl_expression_has_ty!(ast::ExprAwait);
+impl_expression_has_ty!(ast::ExprYield);
+impl_expression_has_ty!(ast::ExprYieldFrom);
+impl_expression_has_ty!(ast::ExprCompare);
+impl_expression_has_ty!(ast::ExprCall);
+impl_expression_has_ty!(ast::ExprFString);
+impl_expression_has_ty!(ast::ExprStringLiteral);
+impl_expression_has_ty!(ast::ExprBytesLiteral);
+impl_expression_has_ty!(ast::ExprNumberLiteral);
+impl_expression_has_ty!(ast::ExprBooleanLiteral);
+impl_expression_has_ty!(ast::ExprNoneLiteral);
+impl_expression_has_ty!(ast::ExprEllipsisLiteral);
+impl_expression_has_ty!(ast::ExprAttribute);
+impl_expression_has_ty!(ast::ExprSubscript);
+impl_expression_has_ty!(ast::ExprStarred);
+impl_expression_has_ty!(ast::ExprName);
+impl_expression_has_ty!(ast::ExprList);
+impl_expression_has_ty!(ast::ExprTuple);
+impl_expression_has_ty!(ast::ExprSlice);
+impl_expression_has_ty!(ast::ExprIpyEscapeCommand);
+
+impl HasTy for ast::Expr {
+    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
+        match self {
+            Expr::BoolOp(inner) => inner.ty(model),
+            Expr::Named(inner) => inner.ty(model),
+            Expr::BinOp(inner) => inner.ty(model),
+            Expr::UnaryOp(inner) => inner.ty(model),
+            Expr::Lambda(inner) => inner.ty(model),
+            Expr::If(inner) => inner.ty(model),
+            Expr::Dict(inner) => inner.ty(model),
+            Expr::Set(inner) => inner.ty(model),
+            Expr::ListComp(inner) => inner.ty(model),
+            Expr::SetComp(inner) => inner.ty(model),
+            Expr::DictComp(inner) => inner.ty(model),
+            Expr::Generator(inner) => inner.ty(model),
+            Expr::Await(inner) => inner.ty(model),
+            Expr::Yield(inner) => inner.ty(model),
+            Expr::YieldFrom(inner) => inner.ty(model),
+            Expr::Compare(inner) => inner.ty(model),
+            Expr::Call(inner) => inner.ty(model),
+            Expr::FString(inner) => inner.ty(model),
+            Expr::StringLiteral(inner) => inner.ty(model),
+            Expr::BytesLiteral(inner) => inner.ty(model),
+            Expr::NumberLiteral(inner) => inner.ty(model),
+            Expr::BooleanLiteral(inner) => inner.ty(model),
+            Expr::NoneLiteral(inner) => inner.ty(model),
+            Expr::EllipsisLiteral(inner) => inner.ty(model),
+            Expr::Attribute(inner) => inner.ty(model),
+            Expr::Subscript(inner) => inner.ty(model),
+            Expr::Starred(inner) => inner.ty(model),
+            Expr::Name(inner) => inner.ty(model),
+            Expr::List(inner) => inner.ty(model),
+            Expr::Tuple(inner) => inner.ty(model),
+            Expr::Slice(inner) => inner.ty(model),
+            Expr::IpyEscapeCommand(inner) => inner.ty(model),
+        }
+    }
+}
+
+impl HasTy for ast::StmtFunctionDef {
+    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
+        let index = semantic_index(model.db, model.file);
+        let definition = index.definition(self);
+
+        let scope = definition.scope(model.db).to_scope_id(model.db, model.file);
+        let types = infer_types(model.db, scope);
+
+        types.definition_ty(definition)
+    }
+}
+
+impl HasTy for StmtClassDef {
+    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
+        let index = semantic_index(model.db, model.file);
+        let definition = index.definition(self);
+
+        let scope = definition.scope(model.db).to_scope_id(model.db, model.file);
+        let types = infer_types(model.db, scope);
+
+        types.definition_ty(definition)
+    }
+}
+
+impl HasTy for ast::Alias {
+    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
+        let index = semantic_index(model.db, model.file);
+        let definition = index.definition(self);
+
+        let scope = definition.scope(model.db).to_scope_id(model.db, model.file);
+        let types = infer_types(model.db, scope);
+
+        types.definition_ty(definition)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use red_knot_module_resolver::{
+        set_module_resolution_settings, RawModuleResolutionSettings, TargetVersion,
+    };
+    use ruff_db::file_system::FileSystemPathBuf;
+    use ruff_db::parsed::parsed_module;
+    use ruff_db::vfs::system_path_to_file;
+
+    use crate::db::tests::TestDb;
+    use crate::types::Type;
+    use crate::{HasTy, SemanticModel};
+
+    fn setup_db() -> TestDb {
+        let mut db = TestDb::new();
+        set_module_resolution_settings(
+            &mut db,
+            RawModuleResolutionSettings {
+                extra_paths: vec![],
+                workspace_root: FileSystemPathBuf::from("/src"),
+                site_packages: None,
+                custom_typeshed: None,
+                target_version: TargetVersion::Py38,
+            },
+        );
+
+        db
+    }
+
+    #[test]
+    fn function_ty() -> anyhow::Result<()> {
+        let db = setup_db();
+
+        db.memory_file_system()
+            .write_file("/src/foo.py", "def test(): pass")?;
+        let foo = system_path_to_file(&db, "/src/foo.py").unwrap();
+
+        let ast = parsed_module(&db, foo);
+
+        let function = ast.suite()[0].as_function_def_stmt().unwrap();
+        let model = SemanticModel::new(&db, foo);
+        let ty = function.ty(&model);
+
+        assert!(matches!(ty, Type::Function(_)));
+
+        Ok(())
+    }
+
+    #[test]
+    fn class_ty() -> anyhow::Result<()> {
+        let db = setup_db();
+
+        db.memory_file_system()
+            .write_file("/src/foo.py", "class Test: pass")?;
+        let foo = system_path_to_file(&db, "/src/foo.py").unwrap();
+
+        let ast = parsed_module(&db, foo);
+
+        let class = ast.suite()[0].as_class_def_stmt().unwrap();
+        let model = SemanticModel::new(&db, foo);
+        let ty = class.ty(&model);
+
+        assert!(matches!(ty, Type::Class(_)));
+
+        Ok(())
+    }
+
+    #[test]
+    fn alias_ty() -> anyhow::Result<()> {
+        let db = setup_db();
+
+        db.memory_file_system().write_files([
+            ("/src/foo.py", "class Test: pass"),
+            ("/src/bar.py", "from foo import Test"),
+        ])?;
+        let bar = system_path_to_file(&db, "/src/bar.py").unwrap();
+
+        let ast = parsed_module(&db, bar);
+
+        let import = ast.suite()[0].as_import_from_stmt().unwrap();
+        let alias = &import.names[0];
+        let model = SemanticModel::new(&db, bar);
+        let ty = alias.ty(&model);
+
+        assert!(matches!(ty, Type::Class(_)));
+
+        Ok(())
+    }
+}

crates/red_knot_python_semantic/src/types.rs

@@ -1,45 +1,15 @@
-use salsa::DebugWithDb;
-
 use ruff_db::parsed::parsed_module;
 use ruff_db::vfs::VfsFile;
-use ruff_index::newtype_index;
-use ruff_python_ast as ast;
+use ruff_python_ast::name::Name;
 
-use crate::name::Name;
-use crate::semantic_index::ast_ids::{AstIdNode, ScopeAstIdNode};
-use crate::semantic_index::symbol::{FileScopeId, PublicSymbolId, ScopeId};
-use crate::semantic_index::{
-    public_symbol, root_scope, semantic_index, symbol_table, NodeWithScopeId,
-};
+use crate::semantic_index::symbol::{NodeWithScopeKind, PublicSymbolId, ScopeId};
+use crate::semantic_index::{public_symbol, root_scope, semantic_index, symbol_table};
 use crate::types::infer::{TypeInference, TypeInferenceBuilder};
-use crate::Db;
-use crate::FxIndexSet;
+use crate::{Db, FxOrderSet};
 
 mod display;
 mod infer;
 
-/// Infers the type of `expr`.
-///
-/// Calling this function from a salsa query adds a dependency on [`semantic_index`]
-/// which changes with every AST change. That's why you should only call
-/// this function for the current file that's being analyzed and not for
-/// a dependency (or the query reruns whenever a dependency change).
-///
-/// Prefer [`public_symbol_ty`] when resolving the type of symbol from another file.
-#[tracing::instrument(level = "debug", skip(db))]
-pub(crate) fn expression_ty<'db>(
-    db: &'db dyn Db,
-    file: VfsFile,
-    expression: &ast::Expr,
-) -> Type<'db> {
-    let index = semantic_index(db, file);
-    let file_scope = index.expression_scope_id(expression);
-    let expression_id = expression.scope_ast_id(db, file, file_scope);
-    let scope = file_scope.to_scope_id(db, file);
-
-    infer_types(db, scope).expression_ty(expression_id)
-}
-
 /// Infers the type of a public symbol.
 ///
 /// This is a Salsa query to get symbol-level invalidation instead of file-level dependency invalidation.
@@ -66,17 +36,18 @@ pub(crate) fn expression_ty<'db>(
 /// This being a query ensures that the invalidation short-circuits if the type of this symbol didn't change.
 #[salsa::tracked]
 pub(crate) fn public_symbol_ty<'db>(db: &'db dyn Db, symbol: PublicSymbolId<'db>) -> Type<'db> {
-    let _ = tracing::trace_span!("public_symbol_ty", symbol = ?symbol.debug(db)).enter();
+    let _span = tracing::trace_span!("public_symbol_ty", ?symbol).entered();
 
     let file = symbol.file(db);
     let scope = root_scope(db, file);
 
+    // TODO switch to inferring just the definition(s), not the whole scope
     let inference = infer_types(db, scope);
     inference.symbol_ty(symbol.scoped_symbol_id(db))
 }
 
 /// Shorthand for `public_symbol_ty` that takes a symbol name instead of a [`PublicSymbolId`].
-pub fn public_symbol_ty_by_name<'db>(
+pub(crate) fn public_symbol_ty_by_name<'db>(
     db: &'db dyn Db,
     file: VfsFile,
     name: &str,
@@ -88,38 +59,29 @@ pub fn public_symbol_ty_by_name<'db>(
 /// Infers all types for `scope`.
 #[salsa::tracked(return_ref)]
 pub(crate) fn infer_types<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> TypeInference<'db> {
-    let _ = tracing::trace_span!("infer_types", scope = ?scope.debug(db)).enter();
+    let _span = tracing::trace_span!("infer_types", ?scope).entered();
 
     let file = scope.file(db);
     // Using the index here is fine because the code below depends on the AST anyway.
     // The isolation of the query is by the return inferred types.
     let index = semantic_index(db, file);
 
-    let scope_id = scope.file_scope_id(db);
-    let node = index.scope_node(scope_id);
+    let node = scope.node(db);
 
     let mut context = TypeInferenceBuilder::new(db, scope, index);
 
     match node {
-        NodeWithScopeId::Module => {
+        NodeWithScopeKind::Module => {
             let parsed = parsed_module(db.upcast(), file);
             context.infer_module(parsed.syntax());
         }
-        NodeWithScopeId::Class(class_id) => {
-            let class = ast::StmtClassDef::lookup(db, file, class_id);
-            context.infer_class_body(class);
+        NodeWithScopeKind::Function(function) => context.infer_function_body(function.node()),
+        NodeWithScopeKind::Class(class) => context.infer_class_body(class.node()),
+        NodeWithScopeKind::ClassTypeParameters(class) => {
+            context.infer_class_type_params(class.node());
         }
-        NodeWithScopeId::ClassTypeParams(class_id) => {
-            let class = ast::StmtClassDef::lookup(db, file, class_id);
-            context.infer_class_type_params(class);
-        }
-        NodeWithScopeId::Function(function_id) => {
-            let function = ast::StmtFunctionDef::lookup(db, file, function_id);
-            context.infer_function_body(function);
-        }
-        NodeWithScopeId::FunctionTypeParams(function_id) => {
-            let function = ast::StmtFunctionDef::lookup(db, file, function_id);
-            context.infer_function_type_params(function);
+        NodeWithScopeKind::FunctionTypeParameters(function) => {
+            context.infer_function_type_params(function.node());
         }
     }
 
@@ -127,7 +89,7 @@ pub(crate) fn infer_types<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> TypeInfe
 }
 
 /// unique ID for a type
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub enum Type<'db> {
     /// the dynamic type: a statically-unknown set of values
     Any,
@@ -141,15 +103,15 @@ pub enum Type<'db> {
     /// the None object (TODO remove this in favor of Instance(types.NoneType)
     None,
     /// a specific function object
-    Function(TypeId<'db, ScopedFunctionTypeId>),
+    Function(FunctionType<'db>),
     /// a specific module object
-    Module(TypeId<'db, ScopedModuleTypeId>),
+    Module(VfsFile),
     /// a specific class object
-    Class(TypeId<'db, ScopedClassTypeId>),
+    Class(ClassType<'db>),
     /// the set of Python objects with the given class in their __class__'s method resolution order
-    Instance(TypeId<'db, ScopedClassTypeId>),
-    Union(TypeId<'db, ScopedUnionTypeId>),
-    Intersection(TypeId<'db, ScopedIntersectionTypeId>),
+    Instance(ClassType<'db>),
+    Union(UnionType<'db>),
+    Intersection(IntersectionType<'db>),
     IntLiteral(i64),
     // TODO protocols, callable types, overloads, generics, type vars
 }
@@ -163,7 +125,7 @@ impl<'db> Type<'db> {
         matches!(self, Type::Unknown)
     }
 
-    pub fn member(&self, context: &TypingContext<'db, '_>, name: &Name) -> Option<Type<'db>> {
+    pub fn member(&self, db: &'db dyn Db, name: &Name) -> Option<Type<'db>> {
         match self {
             Type::Any => Some(Type::Any),
             Type::Never => todo!("attribute lookup on Never type"),
@@ -171,14 +133,13 @@ impl<'db> Type<'db> {
             Type::Unbound => todo!("attribute lookup on Unbound type"),
             Type::None => todo!("attribute lookup on None type"),
             Type::Function(_) => todo!("attribute lookup on Function type"),
-            Type::Module(module) => module.member(context, name),
-            Type::Class(class) => class.class_member(context, name),
+            Type::Module(file) => public_symbol_ty_by_name(db, *file, name),
+            Type::Class(class) => class.class_member(db, name),
             Type::Instance(_) => {
                 // TODO MRO? get_own_instance_member, get_instance_member
                 todo!("attribute lookup on Instance type")
             }
-            Type::Union(union_id) => {
-                let _union = union_id.lookup(context);
+            Type::Union(_) => {
                 // TODO perform the get_member on each type in the union
                 // TODO return the union of those results
                 // TODO if any of those results is `None` then include Unknown in the result union
@@ -197,126 +158,25 @@ impl<'db> Type<'db> {
     }
 }
 
-/// ID that uniquely identifies a type in a program.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct TypeId<'db, L> {
-    /// The scope in which this type is defined or was created.
-    scope: ScopeId<'db>,
-    /// The type's local ID in its scope.
-    scoped: L,
-}
-
-impl<'db, Id> TypeId<'db, Id>
-where
-    Id: Copy,
-{
-    pub fn scope(&self) -> ScopeId<'db> {
-        self.scope
-    }
-
-    pub fn scoped_id(&self) -> Id {
-        self.scoped
-    }
-
-    /// Resolves the type ID to the actual type.
-    pub(crate) fn lookup<'a>(self, context: &'a TypingContext<'db, 'a>) -> &'a Id::Ty<'db>
-    where
-        Id: ScopedTypeId,
-    {
-        let types = context.types(self.scope);
-        self.scoped.lookup_scoped(types)
-    }
-}
-
-/// ID that uniquely identifies a type in a scope.
-pub(crate) trait ScopedTypeId {
-    /// The type that this ID points to.
-    type Ty<'db>;
-
-    /// Looks up the type in `index`.
-    ///
-    /// ## Panics
-    /// May panic if this type is from another scope than `index`, or might just return an invalid type.
-    fn lookup_scoped<'a, 'db>(self, index: &'a TypeInference<'db>) -> &'a Self::Ty<'db>;
-}
-
-/// ID uniquely identifying a function type in a `scope`.
-#[newtype_index]
-pub struct ScopedFunctionTypeId;
-
-impl ScopedTypeId for ScopedFunctionTypeId {
-    type Ty<'db> = FunctionType<'db>;
-
-    fn lookup_scoped<'a, 'db>(self, types: &'a TypeInference<'db>) -> &'a Self::Ty<'db> {
-        types.function_ty(self)
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub struct FunctionType<'a> {
+#[salsa::interned]
+pub struct FunctionType<'db> {
     /// name of the function at definition
-    name: Name,
+    pub name: Name,
+
     /// types of all decorators on this function
-    decorators: Vec<Type<'a>>,
+    decorators: Vec<Type<'db>>,
 }
 
-impl<'a> FunctionType<'a> {
-    fn name(&self) -> &str {
-        self.name.as_str()
-    }
-
-    #[allow(unused)]
-    pub(crate) fn decorators(&self) -> &[Type<'a>] {
-        self.decorators.as_slice()
+impl<'db> FunctionType<'db> {
+    pub fn has_decorator(self, db: &dyn Db, decorator: Type<'_>) -> bool {
+        self.decorators(db).contains(&decorator)
     }
 }
 
-#[newtype_index]
-pub struct ScopedClassTypeId;
-
-impl ScopedTypeId for ScopedClassTypeId {
-    type Ty<'db> = ClassType<'db>;
-
-    fn lookup_scoped<'a, 'db>(self, types: &'a TypeInference<'db>) -> &'a Self::Ty<'db> {
-        types.class_ty(self)
-    }
-}
-
-impl<'db> TypeId<'db, ScopedClassTypeId> {
-    /// Returns the class member of this class named `name`.
-    ///
-    /// The member resolves to a member of the class itself or any of its bases.
-    fn class_member(self, context: &TypingContext<'db, '_>, name: &Name) -> Option<Type<'db>> {
-        if let Some(member) = self.own_class_member(context, name) {
-            return Some(member);
-        }
-
-        let class = self.lookup(context);
-        for base in &class.bases {
-            if let Some(member) = base.member(context, name) {
-                return Some(member);
-            }
-        }
-
-        None
-    }
-
-    /// Returns the inferred type of the class member named `name`.
-    fn own_class_member(self, context: &TypingContext<'db, '_>, name: &Name) -> Option<Type<'db>> {
-        let class = self.lookup(context);
-
-        let symbols = symbol_table(context.db, class.body_scope);
-        let symbol = symbols.symbol_id_by_name(name)?;
-        let types = context.types(class.body_scope);
-
-        Some(types.symbol_ty(symbol))
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Clone)]
+#[salsa::interned]
 pub struct ClassType<'db> {
     /// Name of the class at definition
-    name: Name,
+    pub name: Name,
 
     /// Types of all class bases
     bases: Vec<Type<'db>>,
@@ -325,52 +185,62 @@ pub struct ClassType<'db> {
 }
 
 impl<'db> ClassType<'db> {
-    fn name(&self) -> &str {
-        self.name.as_str()
+    /// Returns the class member of this class named `name`.
+    ///
+    /// The member resolves to a member of the class itself or any of its bases.
+    pub fn class_member(self, db: &'db dyn Db, name: &Name) -> Option<Type<'db>> {
+        if let Some(member) = self.own_class_member(db, name) {
+            return Some(member);
+        }
+
+        self.inherited_class_member(db, name)
     }
 
-    #[allow(unused)]
-    pub(super) fn bases(&self) -> &'db [Type] {
-        self.bases.as_slice()
+    /// Returns the inferred type of the class member named `name`.
+    pub fn own_class_member(self, db: &'db dyn Db, name: &Name) -> Option<Type<'db>> {
+        let scope = self.body_scope(db);
+        let symbols = symbol_table(db, scope);
+        let symbol = symbols.symbol_id_by_name(name)?;
+        let types = infer_types(db, scope);
+
+        Some(types.symbol_ty(symbol))
+    }
+
+    pub fn inherited_class_member(self, db: &'db dyn Db, name: &Name) -> Option<Type<'db>> {
+        for base in self.bases(db) {
+            if let Some(member) = base.member(db, name) {
+                return Some(member);
+            }
+        }
+
+        None
     }
 }
 
-#[newtype_index]
-pub struct ScopedUnionTypeId;
-
-impl ScopedTypeId for ScopedUnionTypeId {
-    type Ty<'db> = UnionType<'db>;
-
-    fn lookup_scoped<'a, 'db>(self, types: &'a TypeInference<'db>) -> &'a Self::Ty<'db> {
-        types.union_ty(self)
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Clone)]
+#[salsa::interned]
 pub struct UnionType<'db> {
-    // the union type includes values in any of these types
-    elements: FxIndexSet<Type<'db>>,
+    /// the union type includes values in any of these types
+    elements: FxOrderSet<Type<'db>>,
 }
 
-struct UnionTypeBuilder<'db, 'a> {
-    elements: FxIndexSet<Type<'db>>,
-    context: &'a TypingContext<'db, 'a>,
+struct UnionTypeBuilder<'db> {
+    elements: FxOrderSet<Type<'db>>,
+    db: &'db dyn Db,
 }
 
-impl<'db, 'a> UnionTypeBuilder<'db, 'a> {
-    fn new(context: &'a TypingContext<'db, 'a>) -> Self {
+impl<'db> UnionTypeBuilder<'db> {
+    fn new(db: &'db dyn Db) -> Self {
         Self {
-            context,
-            elements: FxIndexSet::default(),
+            db,
+            elements: FxOrderSet::default(),
         }
     }
 
     /// Adds a type to this union.
     fn add(mut self, ty: Type<'db>) -> Self {
         match ty {
-            Type::Union(union_id) => {
-                let union = union_id.lookup(self.context);
-                self.elements.extend(&union.elements);
+            Type::Union(union) => {
+                self.elements.extend(&union.elements(self.db));
             }
             _ => {
                 self.elements.insert(ty);
@@ -381,20 +251,7 @@ impl<'db, 'a> UnionTypeBuilder<'db, 'a> {
     }
 
     fn build(self) -> UnionType<'db> {
-        UnionType {
-            elements: self.elements,
-        }
-    }
-}
-
-#[newtype_index]
-pub struct ScopedIntersectionTypeId;
-
-impl ScopedTypeId for ScopedIntersectionTypeId {
-    type Ty<'db> = IntersectionType<'db>;
-
-    fn lookup_scoped<'a, 'db>(self, types: &'a TypeInference<'db>) -> &'a Self::Ty<'db> {
-        types.intersection_ty(self)
+        UnionType::new(self.db, self.elements)
     }
 }
 
@@ -404,108 +261,19 @@ impl ScopedTypeId for ScopedIntersectionTypeId {
 // case where a Not appears outside an intersection (unclear when that could even happen, but we'd
 // have to represent it as a single-element intersection if it did) in exchange for better
 // efficiency in the within-intersection case.
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[salsa::interned]
 pub struct IntersectionType<'db> {
     // the intersection type includes only values in all of these types
-    positive: FxIndexSet<Type<'db>>,
+    positive: FxOrderSet<Type<'db>>,
     // the intersection type does not include any value in any of these types
-    negative: FxIndexSet<Type<'db>>,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct ScopedModuleTypeId;
-
-impl ScopedTypeId for ScopedModuleTypeId {
-    type Ty<'db> = ModuleType;
-
-    fn lookup_scoped<'a, 'db>(self, types: &'a TypeInference<'db>) -> &'a Self::Ty<'db> {
-        types.module_ty()
-    }
-}
-
-impl<'db> TypeId<'db, ScopedModuleTypeId> {
-    fn member(self, context: &TypingContext<'db, '_>, name: &Name) -> Option<Type<'db>> {
-        context.public_symbol_ty(self.scope.file(context.db), name)
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub struct ModuleType {
-    file: VfsFile,
-}
-
-/// Context in which to resolve types.
-///
-/// This abstraction is necessary to support a uniform API that can be used
-/// while in the process of building the type inference structure for a scope
-/// but also when all types should be resolved by querying the db.
-pub struct TypingContext<'db, 'inference> {
-    db: &'db dyn Db,
-
-    /// The Local type inference scope that is in the process of being built.
-    ///
-    /// Bypass the `db` when resolving the types for this scope.
-    local: Option<(ScopeId<'db>, &'inference TypeInference<'db>)>,
-}
-
-impl<'db, 'inference> TypingContext<'db, 'inference> {
-    /// Creates a context that resolves all types by querying the db.
-    #[allow(unused)]
-    pub(super) fn global(db: &'db dyn Db) -> Self {
-        Self { db, local: None }
-    }
-
-    /// Creates a context that by-passes the `db` when resolving types from `scope_id` and instead uses `types`.
-    fn scoped(
-        db: &'db dyn Db,
-        scope_id: ScopeId<'db>,
-        types: &'inference TypeInference<'db>,
-    ) -> Self {
-        Self {
-            db,
-            local: Some((scope_id, types)),
-        }
-    }
-
-    /// Returns the [`TypeInference`] results (not guaranteed to be complete) for `scope_id`.
-    fn types(&self, scope_id: ScopeId<'db>) -> &'inference TypeInference<'db> {
-        if let Some((scope, local_types)) = self.local {
-            if scope == scope_id {
-                return local_types;
-            }
-        }
-
-        infer_types(self.db, scope_id)
-    }
-
-    fn module_ty(&self, file: VfsFile) -> Type<'db> {
-        let scope = root_scope(self.db, file);
-
-        Type::Module(TypeId {
-            scope,
-            scoped: ScopedModuleTypeId,
-        })
-    }
-
-    /// Resolves the public type of a symbol named `name` defined in `file`.
-    ///
-    /// This function calls [`public_symbol_ty`] if the local scope isn't the module scope of `file`.
-    /// It otherwise tries to resolve the symbol type locally.
-    fn public_symbol_ty(&self, file: VfsFile, name: &Name) -> Option<Type<'db>> {
-        let symbol = public_symbol(self.db, file, name)?;
-
-        if let Some((scope, local_types)) = self.local {
-            if scope.file_scope_id(self.db) == FileScopeId::root() && scope.file(self.db) == file {
-                return Some(local_types.symbol_ty(symbol.scoped_symbol_id(self.db)));
-            }
-        }
-
-        Some(public_symbol_ty(self.db, symbol))
-    }
+    negative: FxOrderSet<Type<'db>>,
 }
 
 #[cfg(test)]
 mod tests {
+    use red_knot_module_resolver::{
+        set_module_resolution_settings, RawModuleResolutionSettings, TargetVersion,
+    };
     use ruff_db::file_system::FileSystemPathBuf;
     use ruff_db::parsed::parsed_module;
     use ruff_db::vfs::system_path_to_file;
@@ -514,14 +282,15 @@ mod tests {
         assert_will_not_run_function_query, assert_will_run_function_query, TestDb,
     };
     use crate::semantic_index::root_scope;
-    use crate::types::{expression_ty, infer_types, public_symbol_ty_by_name, TypingContext};
-    use red_knot_module_resolver::{set_module_resolution_settings, ModuleResolutionSettings};
+    use crate::types::{infer_types, public_symbol_ty_by_name};
+    use crate::{HasTy, SemanticModel};
 
     fn setup_db() -> TestDb {
         let mut db = TestDb::new();
         set_module_resolution_settings(
             &mut db,
-            ModuleResolutionSettings {
+            RawModuleResolutionSettings {
+                target_version: TargetVersion::Py38,
                 extra_paths: vec![],
                 workspace_root: FileSystemPathBuf::from("/src"),
                 site_packages: None,
@@ -542,13 +311,11 @@ mod tests {
         let parsed = parsed_module(&db, a);
 
         let statement = parsed.suite().first().unwrap().as_assign_stmt().unwrap();
+        let model = SemanticModel::new(&db, a);
 
-        let literal_ty = expression_ty(&db, a, &statement.value);
+        let literal_ty = statement.value.ty(&model);
 
-        assert_eq!(
-            format!("{}", literal_ty.display(&TypingContext::global(&db))),
-            "Literal[10]"
-        );
+        assert_eq!(format!("{}", literal_ty.display(&db)), "Literal[10]");
 
         Ok(())
     }
@@ -565,10 +332,7 @@ mod tests {
         let a = system_path_to_file(&db, "/src/a.py").unwrap();
         let x_ty = public_symbol_ty_by_name(&db, a, "x").unwrap();
 
-        assert_eq!(
-            x_ty.display(&TypingContext::global(&db)).to_string(),
-            "Literal[10]"
-        );
+        assert_eq!(x_ty.display(&db).to_string(), "Literal[10]");
 
         // Change `x` to a different value
         db.memory_file_system()
@@ -582,10 +346,7 @@ mod tests {
         db.clear_salsa_events();
         let x_ty_2 = public_symbol_ty_by_name(&db, a, "x").unwrap();
 
-        assert_eq!(
-            x_ty_2.display(&TypingContext::global(&db)).to_string(),
-            "Literal[20]"
-        );
+        assert_eq!(x_ty_2.display(&db).to_string(), "Literal[20]");
 
         let events = db.take_salsa_events();
 
@@ -612,10 +373,7 @@ mod tests {
         let a = system_path_to_file(&db, "/src/a.py").unwrap();
         let x_ty = public_symbol_ty_by_name(&db, a, "x").unwrap();
 
-        assert_eq!(
-            x_ty.display(&TypingContext::global(&db)).to_string(),
-            "Literal[10]"
-        );
+        assert_eq!(x_ty.display(&db).to_string(), "Literal[10]");
 
         db.memory_file_system()
             .write_file("/src/foo.py", "x = 10\ndef foo(): pass")?;
@@ -629,10 +387,7 @@ mod tests {
 
         let x_ty_2 = public_symbol_ty_by_name(&db, a, "x").unwrap();
 
-        assert_eq!(
-            x_ty_2.display(&TypingContext::global(&db)).to_string(),
-            "Literal[10]"
-        );
+        assert_eq!(x_ty_2.display(&db).to_string(), "Literal[10]");
 
         let events = db.take_salsa_events();
 
@@ -660,10 +415,7 @@ mod tests {
         let a = system_path_to_file(&db, "/src/a.py").unwrap();
         let x_ty = public_symbol_ty_by_name(&db, a, "x").unwrap();
 
-        assert_eq!(
-            x_ty.display(&TypingContext::global(&db)).to_string(),
-            "Literal[10]"
-        );
+        assert_eq!(x_ty.display(&db).to_string(), "Literal[10]");
 
         db.memory_file_system()
             .write_file("/src/foo.py", "x = 10\ny = 30")?;
@@ -677,10 +429,7 @@ mod tests {
 
         let x_ty_2 = public_symbol_ty_by_name(&db, a, "x").unwrap();
 
-        assert_eq!(
-            x_ty_2.display(&TypingContext::global(&db)).to_string(),
-            "Literal[10]"
-        );
+        assert_eq!(x_ty_2.display(&db).to_string(), "Literal[10]");
 
         let events = db.take_salsa_events();
 

crates/red_knot_python_semantic/src/types/display.rs

@@ -2,18 +2,19 @@
 
 use std::fmt::{Display, Formatter};
 
-use crate::types::{IntersectionType, Type, TypingContext, UnionType};
+use crate::types::{IntersectionType, Type, UnionType};
+use crate::Db;
 
-impl Type<'_> {
-    pub fn display<'a>(&'a self, context: &'a TypingContext) -> DisplayType<'a> {
-        DisplayType { ty: self, context }
+impl<'db> Type<'db> {
+    pub fn display(&'db self, db: &'db dyn Db) -> DisplayType<'db> {
+        DisplayType { ty: self, db }
     }
 }
 
 #[derive(Copy, Clone)]
-pub struct DisplayType<'a> {
-    ty: &'a Type<'a>,
-    context: &'a TypingContext<'a, 'a>,
+pub struct DisplayType<'db> {
+    ty: &'db Type<'db>,
+    db: &'db dyn Db,
 }
 
 impl Display for DisplayType<'_> {
@@ -24,42 +25,19 @@ impl Display for DisplayType<'_> {
             Type::Unknown => f.write_str("Unknown"),
             Type::Unbound => f.write_str("Unbound"),
             Type::None => f.write_str("None"),
-            Type::Module(module_id) => {
-                write!(
-                    f,
-                    "<module '{:?}'>",
-                    module_id
-                        .scope
-                        .file(self.context.db)
-                        .path(self.context.db.upcast())
-                )
+            Type::Module(file) => {
+                write!(f, "<module '{:?}'>", file.path(self.db.upcast()))
             }
             // TODO functions and classes should display using a fully qualified name
-            Type::Class(class_id) => {
-                let class = class_id.lookup(self.context);
-
+            Type::Class(class) => {
                 f.write_str("Literal[")?;
-                f.write_str(class.name())?;
+                f.write_str(&class.name(self.db))?;
                 f.write_str("]")
             }
-            Type::Instance(class_id) => {
-                let class = class_id.lookup(self.context);
-                f.write_str(class.name())
-            }
-            Type::Function(function_id) => {
-                let function = function_id.lookup(self.context);
-                f.write_str(function.name())
-            }
-            Type::Union(union_id) => {
-                let union = union_id.lookup(self.context);
-
-                union.display(self.context).fmt(f)
-            }
-            Type::Intersection(intersection_id) => {
-                let intersection = intersection_id.lookup(self.context);
-
-                intersection.display(self.context).fmt(f)
-            }
+            Type::Instance(class) => f.write_str(&class.name(self.db)),
+            Type::Function(function) => f.write_str(&function.name(self.db)),
+            Type::Union(union) => union.display(self.db).fmt(f),
+            Type::Intersection(intersection) => intersection.display(self.db).fmt(f),
             Type::IntLiteral(n) => write!(f, "Literal[{n}]"),
         }
     }
@@ -71,15 +49,15 @@ impl std::fmt::Debug for DisplayType<'_> {
     }
 }
 
-impl UnionType<'_> {
-    fn display<'a>(&'a self, context: &'a TypingContext<'a, 'a>) -> DisplayUnionType<'a> {
-        DisplayUnionType { context, ty: self }
+impl<'db> UnionType<'db> {
+    fn display(&'db self, db: &'db dyn Db) -> DisplayUnionType<'db> {
+        DisplayUnionType { db, ty: self }
     }
 }
 
-struct DisplayUnionType<'a> {
-    ty: &'a UnionType<'a>,
-    context: &'a TypingContext<'a, 'a>,
+struct DisplayUnionType<'db> {
+    ty: &'db UnionType<'db>,
+    db: &'db dyn Db,
 }
 
 impl Display for DisplayUnionType<'_> {
@@ -87,7 +65,7 @@ impl Display for DisplayUnionType<'_> {
         let union = self.ty;
 
         let (int_literals, other_types): (Vec<Type>, Vec<Type>) = union
-            .elements
+            .elements(self.db)
             .iter()
             .copied()
             .partition(|ty| matches!(ty, Type::IntLiteral(_)));
@@ -121,7 +99,7 @@ impl Display for DisplayUnionType<'_> {
                 f.write_str(" | ")?;
             };
             first = false;
-            write!(f, "{}", ty.display(self.context))?;
+            write!(f, "{}", ty.display(self.db))?;
         }
 
         Ok(())
@@ -134,15 +112,15 @@ impl std::fmt::Debug for DisplayUnionType<'_> {
     }
 }
 
-impl IntersectionType<'_> {
-    fn display<'a>(&'a self, context: &'a TypingContext<'a, 'a>) -> DisplayIntersectionType<'a> {
-        DisplayIntersectionType { ty: self, context }
+impl<'db> IntersectionType<'db> {
+    fn display(&'db self, db: &'db dyn Db) -> DisplayIntersectionType<'db> {
+        DisplayIntersectionType { db, ty: self }
     }
 }
 
-struct DisplayIntersectionType<'a> {
-    ty: &'a IntersectionType<'a>,
-    context: &'a TypingContext<'a, 'a>,
+struct DisplayIntersectionType<'db> {
+    ty: &'db IntersectionType<'db>,
+    db: &'db dyn Db,
 }
 
 impl Display for DisplayIntersectionType<'_> {
@@ -150,10 +128,10 @@ impl Display for DisplayIntersectionType<'_> {
         let mut first = true;
         for (neg, ty) in self
             .ty
-            .positive
+            .positive(self.db)
             .iter()
             .map(|ty| (false, ty))
-            .chain(self.ty.negative.iter().map(|ty| (true, ty)))
+            .chain(self.ty.negative(self.db).iter().map(|ty| (true, ty)))
         {
             if !first {
                 f.write_str(" & ")?;
@@ -162,7 +140,7 @@ impl Display for DisplayIntersectionType<'_> {
             if neg {
                 f.write_str("~")?;
             };
-            write!(f, "{}", ty.display(self.context))?;
+            write!(f, "{}", ty.display(self.db))?;
         }
         Ok(())
     }

crates/red_knot_python_semantic/src/types/infer.rs

@@ -1,125 +1,89 @@
+use rustc_hash::FxHashMap;
+use std::borrow::Cow;
 use std::sync::Arc;
 
-use rustc_hash::FxHashMap;
-
-use red_knot_module_resolver::resolve_module;
-use red_knot_module_resolver::ModuleName;
+use red_knot_module_resolver::{resolve_module, ModuleName};
 use ruff_db::vfs::VfsFile;
 use ruff_index::IndexVec;
 use ruff_python_ast as ast;
 use ruff_python_ast::{ExprContext, TypeParams};
 
-use crate::name::Name;
-use crate::semantic_index::ast_ids::{ScopeAstIdNode, ScopeExpressionId};
-use crate::semantic_index::definition::{Definition, ImportDefinition, ImportFromDefinition};
-use crate::semantic_index::symbol::{FileScopeId, ScopeId, ScopeKind, ScopedSymbolId, SymbolTable};
-use crate::semantic_index::{symbol_table, ChildrenIter, SemanticIndex};
-use crate::types::{
-    ClassType, FunctionType, IntersectionType, ModuleType, ScopedClassTypeId, ScopedFunctionTypeId,
-    ScopedIntersectionTypeId, ScopedUnionTypeId, Type, TypeId, TypingContext, UnionType,
-    UnionTypeBuilder,
+use crate::semantic_index::ast_ids::ScopedExpressionId;
+use crate::semantic_index::definition::{Definition, DefinitionNodeRef};
+use crate::semantic_index::symbol::{
+    FileScopeId, NodeWithScopeRef, ScopeId, ScopedSymbolId, SymbolTable,
 };
+use crate::semantic_index::{symbol_table, SemanticIndex};
+use crate::types::{infer_types, ClassType, FunctionType, Name, Type, UnionTypeBuilder};
 use crate::Db;
 
 /// The inferred types for a single scope.
 #[derive(Debug, Eq, PartialEq, Default, Clone)]
 pub(crate) struct TypeInference<'db> {
-    /// The type of the module if the scope is a module scope.
-    module_type: Option<ModuleType>,
-
-    /// The types of the defined classes in this scope.
-    class_types: IndexVec<ScopedClassTypeId, ClassType<'db>>,
-
-    /// The types of the defined functions in this scope.
-    function_types: IndexVec<ScopedFunctionTypeId, FunctionType<'db>>,
-
-    union_types: IndexVec<ScopedUnionTypeId, UnionType<'db>>,
-    intersection_types: IndexVec<ScopedIntersectionTypeId, IntersectionType<'db>>,
-
     /// The types of every expression in this scope.
-    expression_tys: IndexVec<ScopeExpressionId, Type<'db>>,
+    expressions: IndexVec<ScopedExpressionId, Type<'db>>,
 
     /// The public types of every symbol in this scope.
-    symbol_tys: IndexVec<ScopedSymbolId, Type<'db>>,
+    symbols: IndexVec<ScopedSymbolId, Type<'db>>,
+
+    /// The type of a definition.
+    definitions: FxHashMap<Definition<'db>, Type<'db>>,
 }
 
 impl<'db> TypeInference<'db> {
     #[allow(unused)]
-    pub(super) fn expression_ty(&self, expression: ScopeExpressionId) -> Type<'db> {
-        self.expression_tys[expression]
+    pub(crate) fn expression_ty(&self, expression: ScopedExpressionId) -> Type<'db> {
+        self.expressions[expression]
     }
 
     pub(super) fn symbol_ty(&self, symbol: ScopedSymbolId) -> Type<'db> {
-        self.symbol_tys[symbol]
+        self.symbols[symbol]
     }
 
-    pub(super) fn module_ty(&self) -> &ModuleType {
-        self.module_type.as_ref().unwrap()
-    }
-
-    pub(super) fn class_ty(&self, id: ScopedClassTypeId) -> &ClassType<'db> {
-        &self.class_types[id]
-    }
-
-    pub(super) fn function_ty(&self, id: ScopedFunctionTypeId) -> &FunctionType<'db> {
-        &self.function_types[id]
-    }
-
-    pub(super) fn union_ty(&self, id: ScopedUnionTypeId) -> &UnionType<'db> {
-        &self.union_types[id]
-    }
-
-    pub(super) fn intersection_ty(&self, id: ScopedIntersectionTypeId) -> &IntersectionType<'db> {
-        &self.intersection_types[id]
+    pub(crate) fn definition_ty(&self, definition: Definition<'db>) -> Type<'db> {
+        self.definitions[&definition]
     }
 
     fn shrink_to_fit(&mut self) {
-        self.class_types.shrink_to_fit();
-        self.function_types.shrink_to_fit();
-        self.union_types.shrink_to_fit();
-        self.intersection_types.shrink_to_fit();
-
-        self.expression_tys.shrink_to_fit();
-        self.symbol_tys.shrink_to_fit();
+        self.expressions.shrink_to_fit();
+        self.symbols.shrink_to_fit();
+        self.definitions.shrink_to_fit();
     }
 }
 
 /// Builder to infer all types in a [`ScopeId`].
-pub(super) struct TypeInferenceBuilder<'a> {
-    db: &'a dyn Db,
+pub(super) struct TypeInferenceBuilder<'db> {
+    db: &'db dyn Db,
 
     // Cached lookups
-    index: &'a SemanticIndex,
-    scope: ScopeId<'a>,
+    index: &'db SemanticIndex<'db>,
     file_scope_id: FileScopeId,
     file_id: VfsFile,
-    symbol_table: Arc<SymbolTable>,
+    symbol_table: Arc<SymbolTable<'db>>,
 
     /// The type inference results
-    types: TypeInference<'a>,
-    definition_tys: FxHashMap<Definition, Type<'a>>,
-    children_scopes: ChildrenIter<'a>,
+    types: TypeInference<'db>,
 }
 
 impl<'db> TypeInferenceBuilder<'db> {
     /// Creates a new builder for inferring the types of `scope`.
-    pub(super) fn new(db: &'db dyn Db, scope: ScopeId<'db>, index: &'db SemanticIndex) -> Self {
+    pub(super) fn new(
+        db: &'db dyn Db,
+        scope: ScopeId<'db>,
+        index: &'db SemanticIndex<'db>,
+    ) -> Self {
         let file_scope_id = scope.file_scope_id(db);
         let file = scope.file(db);
-        let children_scopes = index.child_scopes(file_scope_id);
         let symbol_table = index.symbol_table(file_scope_id);
 
         Self {
             index,
             file_scope_id,
             file_id: file,
-            scope,
             symbol_table,
 
             db,
             types: TypeInference::default(),
-            definition_tys: FxHashMap::default(),
-            children_scopes,
         }
     }
 
@@ -186,7 +150,6 @@ impl<'db> TypeInferenceBuilder<'db> {
             decorator_list,
         } = function;
 
-        let function_id = function.scope_ast_id(self.db, self.file_id, self.file_scope_id);
         let decorator_tys = decorator_list
             .iter()
             .map(|decorator| self.infer_decorator(decorator))
@@ -198,35 +161,23 @@ impl<'db> TypeInferenceBuilder<'db> {
             self.infer_expression(return_ty);
         }
 
-        let function_ty = self.function_ty(FunctionType {
-            name: Name::new(&name.id),
-            decorators: decorator_tys,
-        });
+        let function_ty =
+            Type::Function(FunctionType::new(self.db, name.id.clone(), decorator_tys));
 
-        // Skip over the function or type params child scope.
-        let (_, scope) = self.children_scopes.next().unwrap();
-
-        assert!(matches!(
-            scope.kind(),
-            ScopeKind::Function | ScopeKind::Annotation
-        ));
-
-        self.definition_tys
-            .insert(Definition::FunctionDef(function_id), function_ty);
+        let definition = self.index.definition(function);
+        self.types.definitions.insert(definition, function_ty);
     }
 
     fn infer_class_definition_statement(&mut self, class: &ast::StmtClassDef) {
         let ast::StmtClassDef {
             range: _,
             name,
-            type_params,
+            type_params: _,
             decorator_list,
             arguments,
             body: _,
         } = class;
 
-        let class_id = class.scope_ast_id(self.db, self.file_id, self.file_scope_id);
-
         for decorator in decorator_list {
             self.infer_decorator(decorator);
         }
@@ -236,25 +187,15 @@ impl<'db> TypeInferenceBuilder<'db> {
             .map(|arguments| self.infer_arguments(arguments))
             .unwrap_or(Vec::new());
 
-        // If the class has type parameters, then the class body scope is the first child scope of the type parameter's scope
-        // Otherwise the next scope must be the class definition scope.
-        let (class_body_scope_id, class_body_scope) = if type_params.is_some() {
-            let (type_params_scope, _) = self.children_scopes.next().unwrap();
-            self.index.child_scopes(type_params_scope).next().unwrap()
-        } else {
-            self.children_scopes.next().unwrap()
-        };
+        let body_scope = self
+            .index
+            .node_scope(NodeWithScopeRef::Class(class))
+            .to_scope_id(self.db, self.file_id);
 
-        assert_eq!(class_body_scope.kind(), ScopeKind::Class);
+        let class_ty = Type::Class(ClassType::new(self.db, name.id.clone(), bases, body_scope));
 
-        let class_ty = self.class_ty(ClassType {
-            name: Name::new(name),
-            bases,
-            body_scope: class_body_scope_id.to_scope_id(self.db, self.file_id),
-        });
-
-        self.definition_tys
-            .insert(Definition::ClassDef(class_id), class_ty);
+        let definition = self.index.definition(class);
+        self.types.definitions.insert(definition, class_ty);
     }
 
     fn infer_if_statement(&mut self, if_statement: &ast::StmtIf) {
@@ -294,13 +235,12 @@ impl<'db> TypeInferenceBuilder<'db> {
 
         for target in targets {
             self.infer_expression(target);
+
+            self.types.definitions.insert(
+                self.index.definition(DefinitionNodeRef::Target(target)),
+                value_ty,
+            );
         }
-
-        let assign_id = assignment.scope_ast_id(self.db, self.file_id, self.file_scope_id);
-
-        // TODO: Handle multiple targets.
-        self.definition_tys
-            .insert(Definition::Assignment(assign_id), value_ty);
     }
 
     fn infer_annotated_assignment_statement(&mut self, assignment: &ast::StmtAnnAssign) {
@@ -319,12 +259,8 @@ impl<'db> TypeInferenceBuilder<'db> {
         let annotation_ty = self.infer_expression(annotation);
         self.infer_expression(target);
 
-        self.definition_tys.insert(
-            Definition::AnnotatedAssignment(assignment.scope_ast_id(
-                self.db,
-                self.file_id,
-                self.file_scope_id,
-            )),
+        self.types.definitions.insert(
+            self.index.definition(DefinitionNodeRef::Target(target)),
             annotation_ty,
         );
     }
@@ -348,9 +284,7 @@ impl<'db> TypeInferenceBuilder<'db> {
     fn infer_import_statement(&mut self, import: &ast::StmtImport) {
         let ast::StmtImport { range: _, names } = import;
 
-        let import_id = import.scope_ast_id(self.db, self.file_id, self.file_scope_id);
-
-        for (i, alias) in names.iter().enumerate() {
+        for alias in names {
             let ast::Alias {
                 range: _,
                 name,
@@ -360,16 +294,12 @@ impl<'db> TypeInferenceBuilder<'db> {
             let module_name = ModuleName::new(&name.id);
             let module = module_name.and_then(|name| resolve_module(self.db.upcast(), name));
             let module_ty = module
-                .map(|module| self.typing_context().module_ty(module.file()))
+                .map(|module| Type::Module(module.file()))
                 .unwrap_or(Type::Unknown);
 
-            self.definition_tys.insert(
-                Definition::Import(ImportDefinition {
-                    import_id,
-                    alias: u32::try_from(i).unwrap(),
-                }),
-                module_ty,
-            );
+            let definition = self.index.definition(alias);
+
+            self.types.definitions.insert(definition, module_ty);
         }
     }
 
@@ -381,16 +311,15 @@ impl<'db> TypeInferenceBuilder<'db> {
             level: _,
         } = import;
 
-        let import_id = import.scope_ast_id(self.db, self.file_id, self.file_scope_id);
         let module_name = ModuleName::new(module.as_deref().expect("Support relative imports"));
 
         let module =
             module_name.and_then(|module_name| resolve_module(self.db.upcast(), module_name));
         let module_ty = module
-            .map(|module| self.typing_context().module_ty(module.file()))
+            .map(|module| Type::Module(module.file()))
             .unwrap_or(Type::Unknown);
 
-        for (i, alias) in names.iter().enumerate() {
+        for alias in names {
             let ast::Alias {
                 range: _,
                 name,
@@ -398,16 +327,11 @@ impl<'db> TypeInferenceBuilder<'db> {
             } = alias;
 
             let ty = module_ty
-                .member(&self.typing_context(), &Name::new(&name.id))
+                .member(self.db, &Name::new(&name.id))
                 .unwrap_or(Type::Unknown);
 
-            self.definition_tys.insert(
-                Definition::ImportFrom(ImportFromDefinition {
-                    import_id,
-                    name: u32::try_from(i).unwrap(),
-                }),
-                ty,
-            );
+            let definition = self.index.definition(alias);
+            self.types.definitions.insert(definition, ty);
         }
     }
 
@@ -454,7 +378,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             _ => todo!("expression type resolution for {:?}", expression),
         };
 
-        self.types.expression_tys.push(ty);
+        self.types.expressions.push(ty);
 
         ty
     }
@@ -483,10 +407,9 @@ impl<'db> TypeInferenceBuilder<'db> {
         let value_ty = self.infer_expression(value);
         self.infer_expression(target);
 
-        self.definition_tys.insert(
-            Definition::NamedExpr(named.scope_ast_id(self.db, self.file_id, self.file_scope_id)),
-            value_ty,
-        );
+        self.types
+            .definitions
+            .insert(self.index.definition(named), value_ty);
 
         value_ty
     }
@@ -505,12 +428,12 @@ impl<'db> TypeInferenceBuilder<'db> {
         let body_ty = self.infer_expression(body);
         let orelse_ty = self.infer_expression(orelse);
 
-        let union = UnionTypeBuilder::new(&self.typing_context())
+        let union = UnionTypeBuilder::new(self.db)
             .add(body_ty)
             .add(orelse_ty)
             .build();
 
-        self.union_ty(union)
+        Type::Union(union)
     }
 
     fn infer_name_expression(&mut self, name: &ast::ExprName) -> Type<'db> {
@@ -518,28 +441,38 @@ impl<'db> TypeInferenceBuilder<'db> {
 
         match ctx {
             ExprContext::Load => {
-                if let Some(symbol_id) = self
-                    .index
-                    .symbol_table(self.file_scope_id)
-                    .symbol_id_by_name(id)
-                {
-                    self.local_definition_ty(symbol_id)
-                } else {
-                    let ancestors = self.index.ancestor_scopes(self.file_scope_id).skip(1);
+                let ancestors = self.index.ancestor_scopes(self.file_scope_id);
 
-                    for (ancestor_id, _) in ancestors {
-                        // TODO: Skip over class scopes unless the they are a immediately-nested type param scope.
-                        // TODO: Support built-ins
+                for (ancestor_id, _) in ancestors {
+                    // TODO: Skip over class scopes unless the they are a immediately-nested type param scope.
+                    // TODO: Support built-ins
 
-                        let symbol_table =
-                            symbol_table(self.db, ancestor_id.to_scope_id(self.db, self.file_id));
+                    let (symbol_table, ancestor_scope) = if ancestor_id == self.file_scope_id {
+                        (Cow::Borrowed(&self.symbol_table), None)
+                    } else {
+                        let ancestor_scope = ancestor_id.to_scope_id(self.db, self.file_id);
+                        (
+                            Cow::Owned(symbol_table(self.db, ancestor_scope)),
+                            Some(ancestor_scope),
+                        )
+                    };
 
-                        if let Some(_symbol_id) = symbol_table.symbol_id_by_name(id) {
-                            todo!("Return type for symbol from outer scope");
+                    if let Some(symbol_id) = symbol_table.symbol_id_by_name(id) {
+                        let symbol = symbol_table.symbol(symbol_id);
+
+                        if !symbol.is_defined() {
+                            continue;
                         }
+
+                        return if let Some(ancestor_scope) = ancestor_scope {
+                            let types = infer_types(self.db, ancestor_scope);
+                            types.symbol_ty(symbol_id)
+                        } else {
+                            self.local_definition_ty(symbol_id)
+                        };
                     }
-                    Type::Unknown
                 }
+                Type::Unknown
             }
             ExprContext::Del => Type::None,
             ExprContext::Invalid => Type::Unknown,
@@ -557,7 +490,7 @@ impl<'db> TypeInferenceBuilder<'db> {
 
         let value_ty = self.infer_expression(value);
         let member_ty = value_ty
-            .member(&self.typing_context(), &Name::new(&attr.id))
+            .member(self.db, &Name::new(&attr.id))
             .unwrap_or(Type::Unknown);
 
         match ctx {
@@ -632,57 +565,31 @@ impl<'db> TypeInferenceBuilder<'db> {
             .map(|symbol| self.local_definition_ty(symbol))
             .collect();
 
-        self.types.symbol_tys = symbol_tys;
+        self.types.symbols = symbol_tys;
         self.types.shrink_to_fit();
         self.types
     }
 
-    fn union_ty(&mut self, ty: UnionType<'db>) -> Type<'db> {
-        Type::Union(TypeId {
-            scope: self.scope,
-            scoped: self.types.union_types.push(ty),
-        })
-    }
-
-    fn function_ty(&mut self, ty: FunctionType<'db>) -> Type<'db> {
-        Type::Function(TypeId {
-            scope: self.scope,
-            scoped: self.types.function_types.push(ty),
-        })
-    }
-
-    fn class_ty(&mut self, ty: ClassType<'db>) -> Type<'db> {
-        Type::Class(TypeId {
-            scope: self.scope,
-            scoped: self.types.class_types.push(ty),
-        })
-    }
-
-    fn typing_context(&self) -> TypingContext<'db, '_> {
-        TypingContext::scoped(self.db, self.scope, &self.types)
-    }
-
     fn local_definition_ty(&mut self, symbol: ScopedSymbolId) -> Type<'db> {
         let symbol = self.symbol_table.symbol(symbol);
         let mut definitions = symbol
             .definitions()
             .iter()
-            .filter_map(|definition| self.definition_tys.get(definition).copied());
+            .filter_map(|definition| self.types.definitions.get(definition).copied());
 
         let Some(first) = definitions.next() else {
             return Type::Unbound;
         };
 
         if let Some(second) = definitions.next() {
-            let context = self.typing_context();
-            let mut builder = UnionTypeBuilder::new(&context);
+            let mut builder = UnionTypeBuilder::new(self.db);
             builder = builder.add(first).add(second);
 
             for variant in definitions {
                 builder = builder.add(variant);
             }
 
-            self.union_ty(builder.build())
+            Type::Union(builder.build())
         } else {
             first
         }
@@ -691,20 +598,23 @@ impl<'db> TypeInferenceBuilder<'db> {
 
 #[cfg(test)]
 mod tests {
+    use red_knot_module_resolver::{
+        set_module_resolution_settings, RawModuleResolutionSettings, TargetVersion,
+    };
     use ruff_db::file_system::FileSystemPathBuf;
     use ruff_db::vfs::system_path_to_file;
+    use ruff_python_ast::name::Name;
 
     use crate::db::tests::TestDb;
-    use crate::name::Name;
-    use crate::types::{public_symbol_ty_by_name, Type, TypingContext};
-    use red_knot_module_resolver::{set_module_resolution_settings, ModuleResolutionSettings};
+    use crate::types::{public_symbol_ty_by_name, Type};
 
     fn setup_db() -> TestDb {
         let mut db = TestDb::new();
 
         set_module_resolution_settings(
             &mut db,
-            ModuleResolutionSettings {
+            RawModuleResolutionSettings {
+                target_version: TargetVersion::Py38,
                 extra_paths: Vec::new(),
                 workspace_root: FileSystemPathBuf::from("/src"),
                 site_packages: None,
@@ -719,7 +629,7 @@ mod tests {
         let file = system_path_to_file(db, file_name).expect("Expected file to exist.");
 
         let ty = public_symbol_ty_by_name(db, file, symbol_name).unwrap_or(Type::Unknown);
-        assert_eq!(ty.display(&TypingContext::global(db)).to_string(), expected);
+        assert_eq!(ty.display(db).to_string(), expected);
     }
 
     #[test]
@@ -753,17 +663,14 @@ class Sub(Base):
         let mod_file = system_path_to_file(&db, "src/mod.py").expect("Expected file to exist.");
         let ty = public_symbol_ty_by_name(&db, mod_file, "Sub").expect("Symbol type to exist");
 
-        let Type::Class(class_id) = ty else {
+        let Type::Class(class) = ty else {
             panic!("Sub is not a Class")
         };
 
-        let context = TypingContext::global(&db);
-
-        let base_names: Vec<_> = class_id
-            .lookup(&context)
-            .bases()
+        let base_names: Vec<_> = class
+            .bases(&db)
             .iter()
-            .map(|base_ty| format!("{}", base_ty.display(&context)))
+            .map(|base_ty| format!("{}", base_ty.display(&db)))
             .collect();
 
         assert_eq!(base_names, vec!["Literal[Base]"]);
@@ -790,15 +697,13 @@ class C:
             panic!("C is not a Class");
         };
 
-        let context = TypingContext::global(&db);
-        let member_ty = class_id.class_member(&context, &Name::new("f"));
+        let member_ty = class_id.class_member(&db, &Name::new_static("f"));
 
-        let Some(Type::Function(func_id)) = member_ty else {
+        let Some(Type::Function(func)) = member_ty else {
             panic!("C.f is not a Function");
         };
 
-        let function_ty = func_id.lookup(&context);
-        assert_eq!(function_ty.name(), "f");
+        assert_eq!(func.name(&db), "f");
 
         Ok(())
     }

crates/ruff/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "ruff"
-version = "0.4.10"
-publish = false
+version = "0.5.1"
+publish = true
 authors = { workspace = true }
 edition = { workspace = true }
 rust-version = { workspace = true }

crates/ruff/src/args.rs

@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::Arc;
 
-use anyhow::bail;
+use anyhow::{anyhow, bail};
 use clap::builder::{TypedValueParser, ValueParserFactory};
 use clap::{command, Parser};
 use colored::Colorize;
@@ -18,10 +18,10 @@ use ruff_linter::line_width::LineLength;
 use ruff_linter::logging::LogLevel;
 use ruff_linter::registry::Rule;
 use ruff_linter::settings::types::{
-    ExtensionPair, FilePattern, PatternPrefixPair, PerFileIgnore, PreviewMode, PythonVersion,
-    SerializationFormat, UnsafeFixes,
+    ExtensionPair, FilePattern, OutputFormat, PatternPrefixPair, PerFileIgnore, PreviewMode,
+    PythonVersion, UnsafeFixes,
 };
-use ruff_linter::{warn_user, RuleParser, RuleSelector, RuleSelectorParser};
+use ruff_linter::{RuleParser, RuleSelector, RuleSelectorParser};
 use ruff_source_file::{LineIndex, OneIndexed};
 use ruff_text_size::TextRange;
 use ruff_workspace::configuration::{Configuration, RuleSelection};
@@ -95,7 +95,6 @@ pub enum Command {
     /// Run Ruff on the given files or directories (default).
     Check(CheckCommand),
     /// Explain a rule (or all rules).
-    #[clap(alias = "--explain")]
     #[command(group = clap::ArgGroup::new("selector").multiple(false).required(true))]
     Rule {
         /// Rule to explain
@@ -125,10 +124,9 @@ pub enum Command {
         output_format: HelpFormat,
     },
     /// Clear any caches in the current directory and any subdirectories.
-    #[clap(alias = "--clean")]
     Clean,
     /// Generate shell completion.
-    #[clap(alias = "--generate-shell-completion", hide = true)]
+    #[clap(hide = true)]
     GenerateShellCompletion { shell: clap_complete_command::Shell },
     /// Run the Ruff formatter on the given files or directories.
     Format(FormatCommand),
@@ -160,13 +158,6 @@ pub struct CheckCommand {
     unsafe_fixes: bool,
     #[arg(long, overrides_with("unsafe_fixes"), hide = true)]
     no_unsafe_fixes: bool,
-    /// Show violations with source code.
-    /// Use `--no-show-source` to disable.
-    /// (Deprecated: use `--output-format=full` or `--output-format=concise` instead of `--show-source` and `--no-show-source`, respectively)
-    #[arg(long, overrides_with("no_show_source"))]
-    show_source: bool,
-    #[clap(long, overrides_with("show_source"), hide = true)]
-    no_show_source: bool,
     /// Show an enumeration of all fixed lint violations.
     /// Use `--no-show-fixes` to disable.
     #[arg(long, overrides_with("no_show_fixes"))]
@@ -194,7 +185,7 @@ pub struct CheckCommand {
     /// The default serialization format is "concise".
     /// In preview mode, the default serialization format is "full".
     #[arg(long, value_enum, env = "RUFF_OUTPUT_FORMAT")]
-    pub output_format: Option<SerializationFormat>,
+    pub output_format: Option<OutputFormat>,
 
     /// Specify file to write the linter output to (default: stdout).
     #[arg(short, long, env = "RUFF_OUTPUT_FILE")]
@@ -365,7 +356,6 @@ pub struct CheckCommand {
         long,
         // Unsupported default-command arguments.
         conflicts_with = "diff",
-        conflicts_with = "show_source",
         conflicts_with = "watch",
     )]
     pub statistics: bool,
@@ -701,11 +691,7 @@ impl CheckCommand {
             unsafe_fixes: resolve_bool_arg(self.unsafe_fixes, self.no_unsafe_fixes)
                 .map(UnsafeFixes::from),
             force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
-            output_format: resolve_output_format(
-                self.output_format,
-                resolve_bool_arg(self.show_source, self.no_show_source),
-                resolve_bool_arg(self.preview, self.no_preview).unwrap_or_default(),
-            ),
+            output_format: resolve_output_format(self.output_format)?,
             show_fixes: resolve_bool_arg(self.show_fixes, self.no_show_fixes),
             extension: self.extension,
         };
@@ -933,41 +919,15 @@ The path `{value}` does not point to a configuration file"
     }
 }
 
+#[allow(deprecated)]
 fn resolve_output_format(
-    output_format: Option<SerializationFormat>,
-    show_sources: Option<bool>,
-    preview: bool,
-) -> Option<SerializationFormat> {
-    Some(match (output_format, show_sources) {
-        (Some(o), None) => o,
-        (Some(SerializationFormat::Grouped), Some(true)) => {
-            warn_user!("`--show-source` with `--output-format=grouped` is deprecated, and will not show source files. Use `--output-format=full` to show source information.");
-            SerializationFormat::Grouped
-        }
-        (Some(fmt), Some(true)) => {
-            warn_user!("The `--show-source` argument is deprecated and has been ignored in favor of `--output-format={fmt}`.");
-            fmt
-        }
-        (Some(fmt), Some(false)) => {
-            warn_user!("The `--no-show-source` argument is deprecated and has been ignored in favor of `--output-format={fmt}`.");
-            fmt
-        }
-        (None, Some(true)) => {
-            warn_user!("The `--show-source` argument is deprecated. Use `--output-format=full` instead.");
-            SerializationFormat::Full
-        }
-        (None, Some(false)) => {
-            warn_user!("The `--no-show-source` argument is deprecated. Use `--output-format=concise` instead.");
-            SerializationFormat::Concise
-        }
-        (None, None) => return None
-    }).map(|format| match format {
-        SerializationFormat::Text => {
-            warn_user!("`--output-format=text` is deprecated. Use `--output-format=full` or `--output-format=concise` instead. `text` will be treated as `{}`.", SerializationFormat::default(preview));
-            SerializationFormat::default(preview)
-        },
-        other => other
-    })
+    output_format: Option<OutputFormat>,
+) -> anyhow::Result<Option<OutputFormat>> {
+    if let Some(OutputFormat::Text) = output_format {
+        Err(anyhow!("`--output-format=text` is no longer supported. Use `--output-format=full` or `--output-format=concise` instead."))
+    } else {
+        Ok(output_format)
+    }
 }
 
 /// CLI settings that are distinct from configuration (commands, lists of files,
@@ -1219,7 +1179,7 @@ struct ExplicitConfigOverrides {
     fix_only: Option<bool>,
     unsafe_fixes: Option<UnsafeFixes>,
     force_exclude: Option<bool>,
-    output_format: Option<SerializationFormat>,
+    output_format: Option<OutputFormat>,
     show_fixes: Option<bool>,
     extension: Option<Vec<ExtensionPair>>,
 }

crates/ruff/src/cache.rs

@@ -19,7 +19,7 @@ use tempfile::NamedTempFile;
 
 use ruff_cache::{CacheKey, CacheKeyHasher};
 use ruff_diagnostics::{DiagnosticKind, Fix};
-use ruff_linter::message::Message;
+use ruff_linter::message::{DiagnosticMessage, Message};
 use ruff_linter::{warn_user, VERSION};
 use ruff_macros::CacheKey;
 use ruff_notebook::NotebookIndex;
@@ -333,12 +333,14 @@ impl FileCache {
                 let file = SourceFileBuilder::new(path.to_string_lossy(), &*lint.source).finish();
                 lint.messages
                     .iter()
-                    .map(|msg| Message {
-                        kind: msg.kind.clone(),
-                        range: msg.range,
-                        fix: msg.fix.clone(),
-                        file: file.clone(),
-                        noqa_offset: msg.noqa_offset,
+                    .map(|msg| {
+                        Message::Diagnostic(DiagnosticMessage {
+                            kind: msg.kind.clone(),
+                            range: msg.range,
+                            fix: msg.fix.clone(),
+                            file: file.clone(),
+                            noqa_offset: msg.noqa_offset,
+                        })
                     })
                     .collect()
             };
@@ -412,18 +414,19 @@ impl LintCacheData {
         notebook_index: Option<NotebookIndex>,
     ) -> Self {
         let source = if let Some(msg) = messages.first() {
-            msg.file.source_text().to_owned()
+            msg.source_file().source_text().to_owned()
         } else {
             String::new() // No messages, no need to keep the source!
         };
 
         let messages = messages
             .iter()
+            .filter_map(|message| message.as_diagnostic_message())
             .map(|msg| {
                 // Make sure that all message use the same source file.
                 assert_eq!(
-                    msg.file,
-                    messages.first().unwrap().file,
+                    &msg.file,
+                    messages.first().unwrap().source_file(),
                     "message uses a different source file"
                 );
                 CacheMessage {
@@ -571,6 +574,7 @@ mod tests {
     use test_case::test_case;
 
     use ruff_cache::CACHE_DIR_NAME;
+    use ruff_linter::message::Message;
     use ruff_linter::settings::flags;
     use ruff_linter::settings::types::UnsafeFixes;
     use ruff_python_ast::PySourceType;
@@ -633,11 +637,7 @@ mod tests {
                     UnsafeFixes::Enabled,
                 )
                 .unwrap();
-                if diagnostics
-                    .messages
-                    .iter()
-                    .any(|m| m.kind.name == "SyntaxError")
-                {
+                if diagnostics.messages.iter().any(Message::is_syntax_error) {
                     parse_errors.push(path.clone());
                 }
                 paths.push(path);

crates/ruff/src/commands/format.rs

@@ -794,6 +794,8 @@ pub(super) fn warn_incompatible_formatter_settings(resolver: &Resolver) {
             //     pass
             // ```
             Rule::MissingTrailingComma,
+            // The formatter always removes blank lines before the docstring.
+            Rule::OneBlankLineBeforeClass,
         ] {
             if setting.linter.rules.enabled(rule) {
                 incompatible_rules.insert(rule);

crates/ruff/src/commands/rule.rs

@@ -36,7 +36,7 @@ impl<'a> Explanation<'a> {
             message_formats: rule.message_formats(),
             fix,
             explanation: rule.explanation(),
-            preview: rule.is_preview() || rule.is_nursery(),
+            preview: rule.is_preview(),
         }
     }
 }
@@ -62,7 +62,7 @@ fn format_rule_text(rule: Rule) -> String {
         output.push('\n');
     }
 
-    if rule.is_preview() || rule.is_nursery() {
+    if rule.is_preview() {
         output.push_str(
             r"This rule is in preview and is not stable. The `--preview` flag is required for use.",
         );

crates/ruff/src/diagnostics.rs

@@ -9,19 +9,18 @@ use std::path::Path;
 
 use anyhow::{Context, Result};
 use colored::Colorize;
-use log::{debug, error, warn};
+use log::{debug, warn};
 use rustc_hash::FxHashMap;
 
 use ruff_diagnostics::Diagnostic;
+use ruff_linter::codes::Rule;
 use ruff_linter::linter::{lint_fix, lint_only, FixTable, FixerResult, LinterResult, ParseSource};
-use ruff_linter::logging::DisplayParseError;
-use ruff_linter::message::Message;
+use ruff_linter::message::{Message, SyntaxErrorMessage};
 use ruff_linter::pyproject_toml::lint_pyproject_toml;
-use ruff_linter::registry::AsRule;
 use ruff_linter::settings::types::UnsafeFixes;
 use ruff_linter::settings::{flags, LinterSettings};
 use ruff_linter::source_kind::{SourceError, SourceKind};
-use ruff_linter::{fs, IOError, SyntaxError};
+use ruff_linter::{fs, IOError};
 use ruff_notebook::{Notebook, NotebookError, NotebookIndex};
 use ruff_python_ast::{PySourceType, SourceType, TomlSourceType};
 use ruff_source_file::SourceFileBuilder;
@@ -55,57 +54,61 @@ impl Diagnostics {
         path: Option<&Path>,
         settings: &LinterSettings,
     ) -> Self {
-        let diagnostic = match err {
+        match err {
             // IO errors.
             SourceError::Io(_)
             | SourceError::Notebook(NotebookError::Io(_) | NotebookError::Json(_)) => {
-                Diagnostic::new(
-                    IOError {
-                        message: err.to_string(),
-                    },
-                    TextRange::default(),
-                )
+                if settings.rules.enabled(Rule::IOError) {
+                    let name = path.map_or_else(|| "-".into(), Path::to_string_lossy);
+                    let source_file = SourceFileBuilder::new(name, "").finish();
+                    Self::new(
+                        vec![Message::from_diagnostic(
+                            Diagnostic::new(
+                                IOError {
+                                    message: err.to_string(),
+                                },
+                                TextRange::default(),
+                            ),
+                            source_file,
+                            TextSize::default(),
+                        )],
+                        FxHashMap::default(),
+                    )
+                } else {
+                    match path {
+                        Some(path) => {
+                            warn!(
+                                "{}{}{} {err}",
+                                "Failed to lint ".bold(),
+                                fs::relativize_path(path).bold(),
+                                ":".bold()
+                            );
+                        }
+                        None => {
+                            warn!("{}{} {err}", "Failed to lint".bold(), ":".bold());
+                        }
+                    }
+
+                    Self::default()
+                }
             }
             // Syntax errors.
             SourceError::Notebook(
                 NotebookError::InvalidJson(_)
                 | NotebookError::InvalidSchema(_)
                 | NotebookError::InvalidFormat(_),
-            ) => Diagnostic::new(
-                SyntaxError {
-                    message: err.to_string(),
-                },
-                TextRange::default(),
-            ),
-        };
-
-        if settings.rules.enabled(diagnostic.kind.rule()) {
-            let name = path.map_or_else(|| "-".into(), Path::to_string_lossy);
-            let dummy = SourceFileBuilder::new(name, "").finish();
-            Self::new(
-                vec![Message::from_diagnostic(
-                    diagnostic,
-                    dummy,
-                    TextSize::default(),
-                )],
-                FxHashMap::default(),
-            )
-        } else {
-            match path {
-                Some(path) => {
-                    warn!(
-                        "{}{}{} {err}",
-                        "Failed to lint ".bold(),
-                        fs::relativize_path(path).bold(),
-                        ":".bold()
-                    );
-                }
-                None => {
-                    warn!("{}{} {err}", "Failed to lint".bold(), ":".bold());
-                }
+            ) => {
+                let name = path.map_or_else(|| "-".into(), Path::to_string_lossy);
+                let dummy = SourceFileBuilder::new(name, "").finish();
+                Self::new(
+                    vec![Message::SyntaxError(SyntaxErrorMessage {
+                        message: err.to_string(),
+                        range: TextRange::default(),
+                        file: dummy,
+                    })],
+                    FxHashMap::default(),
+                )
             }
-
-            Self::default()
         }
     }
 }
@@ -261,8 +264,8 @@ pub(crate) fn lint_path(
     // Lint the file.
     let (
         LinterResult {
-            data: messages,
-            error: parse_error,
+            messages,
+            has_syntax_error: has_error,
         },
         transformed,
         fixed,
@@ -331,7 +334,7 @@ pub(crate) fn lint_path(
 
     if let Some((cache, relative_path, key)) = caching {
         // We don't cache parsing errors.
-        if parse_error.is_none() {
+        if !has_error {
             // `FixMode::Apply` and `FixMode::Diff` rely on side-effects (writing to disk,
             // and writing the diff to stdout, respectively). If a file has diagnostics, we
             // need to avoid reading from and writing to the cache in these modes.
@@ -353,13 +356,6 @@ pub(crate) fn lint_path(
         }
     }
 
-    if let Some(error) = parse_error {
-        error!(
-            "{}",
-            DisplayParseError::from_source_kind(error, Some(path.to_path_buf()), &transformed)
-        );
-    }
-
     let notebook_indexes = if let SourceKind::IpyNotebook(notebook) = transformed {
         FxHashMap::from_iter([(path.to_string_lossy().to_string(), notebook.into_index())])
     } else {
@@ -404,52 +400,66 @@ pub(crate) fn lint_stdin(
     };
 
     // Lint the inputs.
-    let (
-        LinterResult {
-            data: messages,
-            error: parse_error,
-        },
-        transformed,
-        fixed,
-    ) = if matches!(fix_mode, flags::FixMode::Apply | flags::FixMode::Diff) {
-        if let Ok(FixerResult {
-            result,
-            transformed,
-            fixed,
-        }) = lint_fix(
-            path.unwrap_or_else(|| Path::new("-")),
-            package,
-            noqa,
-            settings.unsafe_fixes,
-            &settings.linter,
-            &source_kind,
-            source_type,
-        ) {
-            match fix_mode {
-                flags::FixMode::Apply => {
-                    // Write the contents to stdout, regardless of whether any errors were fixed.
-                    transformed.write(&mut io::stdout().lock())?;
-                }
-                flags::FixMode::Diff => {
-                    // But only write a diff if it's non-empty.
-                    if !fixed.is_empty() {
-                        write!(
-                            &mut io::stdout().lock(),
-                            "{}",
-                            source_kind.diff(&transformed, path).unwrap()
-                        )?;
+    let (LinterResult { messages, .. }, transformed, fixed) =
+        if matches!(fix_mode, flags::FixMode::Apply | flags::FixMode::Diff) {
+            if let Ok(FixerResult {
+                result,
+                transformed,
+                fixed,
+            }) = lint_fix(
+                path.unwrap_or_else(|| Path::new("-")),
+                package,
+                noqa,
+                settings.unsafe_fixes,
+                &settings.linter,
+                &source_kind,
+                source_type,
+            ) {
+                match fix_mode {
+                    flags::FixMode::Apply => {
+                        // Write the contents to stdout, regardless of whether any errors were fixed.
+                        transformed.write(&mut io::stdout().lock())?;
                     }
+                    flags::FixMode::Diff => {
+                        // But only write a diff if it's non-empty.
+                        if !fixed.is_empty() {
+                            write!(
+                                &mut io::stdout().lock(),
+                                "{}",
+                                source_kind.diff(&transformed, path).unwrap()
+                            )?;
+                        }
+                    }
+                    flags::FixMode::Generate => {}
                 }
-                flags::FixMode::Generate => {}
-            }
-            let transformed = if let Cow::Owned(transformed) = transformed {
-                transformed
+                let transformed = if let Cow::Owned(transformed) = transformed {
+                    transformed
+                } else {
+                    source_kind
+                };
+                (result, transformed, fixed)
             } else {
-                source_kind
-            };
-            (result, transformed, fixed)
+                // If we fail to fix, lint the original source code.
+                let result = lint_only(
+                    path.unwrap_or_else(|| Path::new("-")),
+                    package,
+                    &settings.linter,
+                    noqa,
+                    &source_kind,
+                    source_type,
+                    ParseSource::None,
+                );
+
+                // Write the contents to stdout anyway.
+                if fix_mode.is_apply() {
+                    source_kind.write(&mut io::stdout().lock())?;
+                }
+
+                let transformed = source_kind;
+                let fixed = FxHashMap::default();
+                (result, transformed, fixed)
+            }
         } else {
-            // If we fail to fix, lint the original source code.
             let result = lint_only(
                 path.unwrap_or_else(|| Path::new("-")),
                 package,
@@ -459,37 +469,10 @@ pub(crate) fn lint_stdin(
                 source_type,
                 ParseSource::None,
             );
-
-            // Write the contents to stdout anyway.
-            if fix_mode.is_apply() {
-                source_kind.write(&mut io::stdout().lock())?;
-            }
-
             let transformed = source_kind;
             let fixed = FxHashMap::default();
             (result, transformed, fixed)
-        }
-    } else {
-        let result = lint_only(
-            path.unwrap_or_else(|| Path::new("-")),
-            package,
-            &settings.linter,
-            noqa,
-            &source_kind,
-            source_type,
-            ParseSource::None,
-        );
-        let transformed = source_kind;
-        let fixed = FxHashMap::default();
-        (result, transformed, fixed)
-    };
-
-    if let Some(error) = parse_error {
-        error!(
-            "{}",
-            DisplayParseError::from_source_kind(error, path.map(Path::to_path_buf), &transformed)
-        );
-    }
+        };
 
     let notebook_indexes = if let SourceKind::IpyNotebook(notebook) = transformed {
         FxHashMap::from_iter([(

crates/ruff/src/lib.rs

@@ -8,15 +8,15 @@ use std::process::ExitCode;
 use std::sync::mpsc::channel;
 
 use anyhow::Result;
-use args::{GlobalConfigArgs, ServerCommand};
 use clap::CommandFactory;
 use colored::Colorize;
 use log::warn;
 use notify::{recommended_watcher, RecursiveMode, Watcher};
 
+use args::{GlobalConfigArgs, ServerCommand};
 use ruff_linter::logging::{set_up_logging, LogLevel};
 use ruff_linter::settings::flags::FixMode;
-use ruff_linter::settings::types::SerializationFormat;
+use ruff_linter::settings::types::OutputFormat;
 use ruff_linter::{fs, warn_user, warn_user_once};
 use ruff_workspace::Settings;
 
@@ -121,7 +121,6 @@ pub fn run(
         command,
         global_options,
     }: Args,
-    deprecated_alias_warning: Option<&'static str>,
 ) -> Result<ExitStatus> {
     {
         let default_panic_hook = std::panic::take_hook();
@@ -145,23 +144,8 @@ pub fn run(
         }));
     }
 
-    // Enabled ANSI colors on Windows 10.
-    #[cfg(windows)]
-    assert!(colored::control::set_virtual_terminal(true).is_ok());
-
-    // support FORCE_COLOR env var
-    if let Some(force_color) = std::env::var_os("FORCE_COLOR") {
-        if force_color.len() > 0 {
-            colored::control::set_override(true);
-        }
-    }
-
     set_up_logging(global_options.log_level())?;
 
-    if let Some(deprecated_alias_warning) = deprecated_alias_warning {
-        warn_user!("{}", deprecated_alias_warning);
-    }
-
     match command {
         Command::Version { output_format } => {
             commands::version::version(output_format)?;
@@ -351,10 +335,10 @@ pub fn check(args: CheckCommand, global_options: GlobalConfigArgs) -> Result<Exi
     let preview = pyproject_config.settings.linter.preview.is_enabled();
 
     if cli.watch {
-        if output_format != SerializationFormat::default(preview) {
+        if output_format != OutputFormat::default() {
             warn_user!(
                 "`--output-format {}` is always used in watch mode.",
-                SerializationFormat::default(preview)
+                OutputFormat::default()
             );
         }
 

crates/ruff/src/main.rs

@@ -2,9 +2,11 @@ use std::process::ExitCode;
 
 use clap::{Parser, Subcommand};
 use colored::Colorize;
+use log::error;
 
 use ruff::args::{Args, Command};
 use ruff::{run, ExitStatus};
+use ruff_linter::logging::{set_up_logging, LogLevel};
 
 #[cfg(target_os = "windows")]
 #[global_allocator]
@@ -23,23 +25,33 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
 pub fn main() -> ExitCode {
+    // Enabled ANSI colors on Windows 10.
+    #[cfg(windows)]
+    assert!(colored::control::set_virtual_terminal(true).is_ok());
+
+    // support FORCE_COLOR env var
+    if let Some(force_color) = std::env::var_os("FORCE_COLOR") {
+        if force_color.len() > 0 {
+            colored::control::set_override(true);
+        }
+    }
+
     let args = wild::args_os();
-    let mut args =
-        argfile::expand_args_from(args, argfile::parse_fromfile, argfile::PREFIX).unwrap();
+    let args = argfile::expand_args_from(args, argfile::parse_fromfile, argfile::PREFIX).unwrap();
 
     // We can't use `warn_user` here because logging isn't set up at this point
     // and we also don't know if the user runs ruff with quiet.
     // Keep the message and pass it to `run` that is responsible for emitting the warning.
-    let deprecated_alias_warning = match args.get(1).and_then(|arg| arg.to_str()) {
+    let deprecated_alias_error = match args.get(1).and_then(|arg| arg.to_str()) {
         // Deprecated aliases that are handled by clap
         Some("--explain") => {
-            Some("`ruff --explain <RULE>` is deprecated. Use `ruff rule <RULE>` instead.")
+            Some("`ruff --explain <RULE>` has been removed. Use `ruff rule <RULE>` instead.")
         }
         Some("--clean") => {
-            Some("`ruff --clean` is deprecated. Use `ruff clean` instead.")
+            Some("`ruff --clean` has been removed. Use `ruff clean` instead.")
         }
         Some("--generate-shell-completion") => {
-            Some("`ruff --generate-shell-completion <SHELL>` is deprecated. Use `ruff generate-shell-completion <SHELL>` instead.")
+            Some("`ruff --generate-shell-completion <SHELL>` has been removed. Use `ruff generate-shell-completion <SHELL>` instead.")
         }
         // Deprecated `ruff` alias to `ruff check`
         // Clap doesn't support default subcommands but we want to run `check` by
@@ -51,18 +63,26 @@ pub fn main() -> ExitCode {
             && arg != "-V"
             && arg != "--version"
             && arg != "help" => {
-
             {
-                args.insert(1, "check".into());
-                Some("`ruff <path>` is deprecated. Use `ruff check <path>` instead.")
+                Some("`ruff <path>` has been removed. Use `ruff check <path>` instead.")
             }
         },
         _ => None
     };
 
+    if let Some(error) = deprecated_alias_error {
+        #[allow(clippy::print_stderr)]
+        if set_up_logging(LogLevel::Default).is_ok() {
+            error!("{}", error);
+        } else {
+            eprintln!("{}", error.red().bold());
+        }
+        return ExitCode::FAILURE;
+    }
+
     let args = Args::parse_from(args);
 
-    match run(args, deprecated_alias_warning) {
+    match run(args) {
         Ok(code) => code.into(),
         Err(err) => {
             #[allow(clippy::print_stderr)]

crates/ruff/src/printer.rs

@@ -13,13 +13,13 @@ use ruff_linter::fs::relativize_path;
 use ruff_linter::logging::LogLevel;
 use ruff_linter::message::{
     AzureEmitter, Emitter, EmitterContext, GithubEmitter, GitlabEmitter, GroupedEmitter,
-    JsonEmitter, JsonLinesEmitter, JunitEmitter, PylintEmitter, RdjsonEmitter, SarifEmitter,
-    TextEmitter,
+    JsonEmitter, JsonLinesEmitter, JunitEmitter, Message, MessageKind, PylintEmitter,
+    RdjsonEmitter, SarifEmitter, TextEmitter,
 };
 use ruff_linter::notify_user;
-use ruff_linter::registry::{AsRule, Rule};
+use ruff_linter::registry::Rule;
 use ruff_linter::settings::flags::{self};
-use ruff_linter::settings::types::{SerializationFormat, UnsafeFixes};
+use ruff_linter::settings::types::{OutputFormat, UnsafeFixes};
 
 use crate::diagnostics::{Diagnostics, FixMap};
 
@@ -36,13 +36,14 @@ bitflags! {
 }
 
 #[derive(Serialize)]
-struct ExpandedStatistics<'a> {
-    code: SerializeRuleAsCode,
-    message: &'a str,
+struct ExpandedStatistics {
+    code: Option<SerializeRuleAsCode>,
+    name: SerializeMessageKindAsTitle,
     count: usize,
     fixable: bool,
 }
 
+#[derive(Copy, Clone)]
 struct SerializeRuleAsCode(Rule);
 
 impl Serialize for SerializeRuleAsCode {
@@ -66,8 +67,31 @@ impl From<Rule> for SerializeRuleAsCode {
     }
 }
 
+struct SerializeMessageKindAsTitle(MessageKind);
+
+impl Serialize for SerializeMessageKindAsTitle {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(self.0.as_str())
+    }
+}
+
+impl Display for SerializeMessageKindAsTitle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.0.as_str())
+    }
+}
+
+impl From<MessageKind> for SerializeMessageKindAsTitle {
+    fn from(kind: MessageKind) -> Self {
+        Self(kind)
+    }
+}
+
 pub(crate) struct Printer {
-    format: SerializationFormat,
+    format: OutputFormat,
     log_level: LogLevel,
     fix_mode: flags::FixMode,
     unsafe_fixes: UnsafeFixes,
@@ -76,7 +100,7 @@ pub(crate) struct Printer {
 
 impl Printer {
     pub(crate) const fn new(
-        format: SerializationFormat,
+        format: OutputFormat,
         log_level: LogLevel,
         fix_mode: flags::FixMode,
         unsafe_fixes: UnsafeFixes,
@@ -217,12 +241,13 @@ impl Printer {
         }
 
         if !self.flags.intersects(Flags::SHOW_VIOLATIONS) {
+            #[allow(deprecated)]
             if matches!(
                 self.format,
-                SerializationFormat::Text
-                    | SerializationFormat::Full
-                    | SerializationFormat::Concise
-                    | SerializationFormat::Grouped
+                OutputFormat::Text
+                    | OutputFormat::Full
+                    | OutputFormat::Concise
+                    | OutputFormat::Grouped
             ) {
                 if self.flags.intersects(Flags::SHOW_FIX_SUMMARY) {
                     if !diagnostics.fixed.is_empty() {
@@ -240,24 +265,23 @@ impl Printer {
         let fixables = FixableStatistics::try_from(diagnostics, self.unsafe_fixes);
 
         match self.format {
-            SerializationFormat::Json => {
+            OutputFormat::Json => {
                 JsonEmitter.emit(writer, &diagnostics.messages, &context)?;
             }
-            SerializationFormat::Rdjson => {
+            OutputFormat::Rdjson => {
                 RdjsonEmitter.emit(writer, &diagnostics.messages, &context)?;
             }
-            SerializationFormat::JsonLines => {
+            OutputFormat::JsonLines => {
                 JsonLinesEmitter.emit(writer, &diagnostics.messages, &context)?;
             }
-            SerializationFormat::Junit => {
+            OutputFormat::Junit => {
                 JunitEmitter.emit(writer, &diagnostics.messages, &context)?;
             }
-            SerializationFormat::Concise
-            | SerializationFormat::Full => {
+            OutputFormat::Concise | OutputFormat::Full => {
                 TextEmitter::default()
                     .with_show_fix_status(show_fix_status(self.fix_mode, fixables.as_ref()))
                     .with_show_fix_diff(self.flags.intersects(Flags::SHOW_FIX_DIFF))
-                    .with_show_source(self.format == SerializationFormat::Full)
+                    .with_show_source(self.format == OutputFormat::Full)
                     .with_unsafe_fixes(self.unsafe_fixes)
                     .emit(writer, &diagnostics.messages, &context)?;
 
@@ -271,7 +295,7 @@ impl Printer {
 
                 self.write_summary_text(writer, diagnostics)?;
             }
-            SerializationFormat::Grouped => {
+            OutputFormat::Grouped => {
                 GroupedEmitter::default()
                     .with_show_fix_status(show_fix_status(self.fix_mode, fixables.as_ref()))
                     .with_unsafe_fixes(self.unsafe_fixes)
@@ -286,22 +310,23 @@ impl Printer {
                 }
                 self.write_summary_text(writer, diagnostics)?;
             }
-            SerializationFormat::Github => {
+            OutputFormat::Github => {
                 GithubEmitter.emit(writer, &diagnostics.messages, &context)?;
             }
-            SerializationFormat::Gitlab => {
+            OutputFormat::Gitlab => {
                 GitlabEmitter::default().emit(writer, &diagnostics.messages, &context)?;
             }
-            SerializationFormat::Pylint => {
+            OutputFormat::Pylint => {
                 PylintEmitter.emit(writer, &diagnostics.messages, &context)?;
             }
-            SerializationFormat::Azure => {
+            OutputFormat::Azure => {
                 AzureEmitter.emit(writer, &diagnostics.messages, &context)?;
             }
-            SerializationFormat::Sarif => {
+            OutputFormat::Sarif => {
                 SarifEmitter.emit(writer, &diagnostics.messages, &context)?;
             }
-            SerializationFormat::Text => unreachable!("Text is deprecated and should have been automatically converted to the default serialization format")
+            #[allow(deprecated)]
+            OutputFormat::Text => unreachable!("Text is deprecated and should have been automatically converted to the default serialization format")
         }
 
         writer.flush()?;
@@ -317,30 +342,23 @@ impl Printer {
         let statistics: Vec<ExpandedStatistics> = diagnostics
             .messages
             .iter()
-            .map(|message| {
-                (
-                    message.kind.rule(),
-                    &message.kind.body,
-                    message.fix.is_some(),
-                )
-            })
-            .sorted()
-            .fold(vec![], |mut acc, (rule, body, fixable)| {
-                if let Some((prev_rule, _, _, count)) = acc.last_mut() {
-                    if *prev_rule == rule {
+            .sorted_by_key(|message| (message.rule(), message.fixable()))
+            .fold(vec![], |mut acc: Vec<(&Message, usize)>, message| {
+                if let Some((prev_message, count)) = acc.last_mut() {
+                    if prev_message.rule() == message.rule() {
                         *count += 1;
                         return acc;
                     }
                 }
-                acc.push((rule, body, fixable, 1));
+                acc.push((message, 1));
                 acc
             })
             .iter()
-            .map(|(rule, message, fixable, count)| ExpandedStatistics {
-                code: (*rule).into(),
-                count: *count,
-                message,
-                fixable: *fixable,
+            .map(|&(message, count)| ExpandedStatistics {
+                code: message.rule().map(std::convert::Into::into),
+                name: message.kind().into(),
+                count,
+                fixable: message.fixable(),
             })
             .sorted_by_key(|statistic| Reverse(statistic.count))
             .collect();
@@ -350,9 +368,8 @@ impl Printer {
         }
 
         match self.format {
-            SerializationFormat::Text
-            | SerializationFormat::Full
-            | SerializationFormat::Concise => {
+            #[allow(deprecated)]
+            OutputFormat::Text | OutputFormat::Full | OutputFormat::Concise => {
                 // Compute the maximum number of digits in the count and code, for all messages,
                 // to enable pretty-printing.
                 let count_width = num_digits(
@@ -364,7 +381,12 @@ impl Printer {
                 );
                 let code_width = statistics
                     .iter()
-                    .map(|statistic| statistic.code.to_string().len())
+                    .map(|statistic| {
+                        statistic
+                            .code
+                            .map_or_else(String::new, |rule| rule.to_string())
+                            .len()
+                    })
                     .max()
                     .unwrap();
                 let any_fixable = statistics.iter().any(|statistic| statistic.fixable);
@@ -378,7 +400,11 @@ impl Printer {
                         writer,
                         "{:>count_width$}\t{:<code_width$}\t{}{}",
                         statistic.count.to_string().bold(),
-                        statistic.code.to_string().red().bold(),
+                        statistic
+                            .code
+                            .map_or_else(String::new, |rule| rule.to_string())
+                            .red()
+                            .bold(),
                         if any_fixable {
                             if statistic.fixable {
                                 &fixable
@@ -388,12 +414,12 @@ impl Printer {
                         } else {
                             ""
                         },
-                        statistic.message,
+                        statistic.name,
                     )?;
                 }
                 return Ok(());
             }
-            SerializationFormat::Json => {
+            OutputFormat::Json => {
                 writeln!(writer, "{}", serde_json::to_string_pretty(&statistics)?)?;
             }
             _ => {
@@ -528,7 +554,7 @@ impl FixableStatistics {
         let mut unapplicable_unsafe = 0;
 
         for message in &diagnostics.messages {
-            if let Some(fix) = &message.fix {
+            if let Some(fix) = message.fix() {
                 if fix.applies(unsafe_fixes.required_applicability()) {
                     applicable += 1;
                 } else {