wip: subscript always via __getitem__

.github/workflows/build-binaries.yml

@@ -28,7 +28,7 @@ permissions: {}
 env:
   PACKAGE_NAME: ruff
   MODULE_NAME: ruff
-  PYTHON_VERSION: "3.13"
+  PYTHON_VERSION: "3.11"
   CARGO_INCREMENTAL: 0
   CARGO_NET_RETRY: 10
   CARGO_TERM_COLOR: always
@@ -39,17 +39,17 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build sdist"
-        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
         with:
           command: sdist
           args: --out dist
@@ -59,7 +59,7 @@ jobs:
           "${MODULE_NAME}" --help
           python -m "${MODULE_NAME}" --help
       - name: "Upload sdist"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-sdist
           path: dist
@@ -68,23 +68,23 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
     runs-on: macos-14
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels - x86_64"
-        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
         with:
           target: x86_64
           args: --release --locked --out dist
       - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-macos-x86_64
           path: dist
@@ -99,7 +99,7 @@ jobs:
           tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: artifacts-macos-x86_64
           path: |
@@ -110,18 +110,18 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
     runs-on: macos-14
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: arm64
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels - aarch64"
-        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
         with:
           target: aarch64
           args: --release --locked --out dist
@@ -131,7 +131,7 @@ jobs:
           ruff --help
           python -m ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-aarch64-apple-darwin
           path: dist
@@ -146,7 +146,7 @@ jobs:
           tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: artifacts-aarch64-apple-darwin
           path: |
@@ -166,18 +166,18 @@ jobs:
           - target: aarch64-pc-windows-msvc
             arch: x64
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: ${{ matrix.platform.arch }}
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
         with:
           target: ${{ matrix.platform.target }}
           args: --release --locked --out dist
@@ -192,7 +192,7 @@ jobs:
           "${MODULE_NAME}" --help
           python -m "${MODULE_NAME}" --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-${{ matrix.platform.target }}
           path: dist
@@ -203,7 +203,7 @@ jobs:
           7z a $ARCHIVE_FILE ./target/${{ matrix.platform.target }}/release/ruff.exe
           sha256sum $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: artifacts-${{ matrix.platform.target }}
           path: |
@@ -219,18 +219,18 @@ jobs:
           - x86_64-unknown-linux-gnu
           - i686-unknown-linux-gnu
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
         with:
           target: ${{ matrix.target }}
           manylinux: auto
@@ -242,7 +242,7 @@ jobs:
           "${MODULE_NAME}" --help
           python -m "${MODULE_NAME}" --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-${{ matrix.target }}
           path: dist
@@ -260,7 +260,7 @@ jobs:
           tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: artifacts-${{ matrix.target }}
           path: |
@@ -294,17 +294,17 @@ jobs:
             arch: arm
 
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
         with:
           target: ${{ matrix.platform.target }}
           manylinux: auto
@@ -325,7 +325,7 @@ jobs:
             pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
             ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-${{ matrix.platform.target }}
           path: dist
@@ -343,7 +343,7 @@ jobs:
           tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: artifacts-${{ matrix.platform.target }}
           path: |
@@ -359,18 +359,18 @@ jobs:
           - x86_64-unknown-linux-musl
           - i686-unknown-linux-musl
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
         with:
           target: ${{ matrix.target }}
           manylinux: musllinux_1_2
@@ -387,7 +387,7 @@ jobs:
             .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
             .venv/bin/${{ env.MODULE_NAME }} --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-${{ matrix.target }}
           path: dist
@@ -405,7 +405,7 @@ jobs:
           tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: artifacts-${{ matrix.target }}
           path: |
@@ -425,17 +425,17 @@ jobs:
             arch: armv7
 
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
         with:
           target: ${{ matrix.platform.target }}
           manylinux: musllinux_1_2
@@ -454,7 +454,7 @@ jobs:
             .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
             .venv/bin/${{ env.MODULE_NAME }} --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-${{ matrix.platform.target }}
           path: dist
@@ -472,7 +472,7 @@ jobs:
           tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: artifacts-${{ matrix.platform.target }}
           path: |

.github/workflows/build-docker.yml

@@ -33,7 +33,7 @@ jobs:
           - linux/amd64
           - linux/arm64
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           submodules: recursive
           persist-credentials: false
@@ -96,7 +96,7 @@ jobs:
           touch "/tmp/digests/${digest#sha256:}"
 
       - name: Upload digests
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: digests-${{ env.PLATFORM_TUPLE }}
           path: /tmp/digests/*
@@ -113,7 +113,7 @@ jobs:
     if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
     steps:
       - name: Download digests
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
         with:
           path: /tmp/digests
           pattern: digests-*
@@ -256,7 +256,7 @@ jobs:
     if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
     steps:
       - name: Download digests
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
         with:
           path: /tmp/digests
           pattern: digests-*

.github/workflows/ci.yaml

@@ -18,7 +18,7 @@ env:
   CARGO_TERM_COLOR: always
   RUSTUP_MAX_RETRIES: 10
   PACKAGE_NAME: ruff
-  PYTHON_VERSION: "3.13"
+  PYTHON_VERSION: "3.12"
 
 jobs:
   determine_changes:
@@ -36,13 +36,11 @@ jobs:
       code: ${{ steps.check_code.outputs.changed }}
       # Flag that is raised when any code that affects the fuzzer is changed
       fuzz: ${{ steps.check_fuzzer.outputs.changed }}
-      # Flag that is set to "true" when code related to red-knot changes.
-      red_knot: ${{ steps.check_red_knot.outputs.changed }}
 
       # Flag that is set to "true" when code related to the playground changes.
       playground: ${{ steps.check_playground.outputs.changed }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           fetch-depth: 0
           persist-credentials: false
@@ -143,7 +141,7 @@ jobs:
         env:
           MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
         run: |
-          if git diff --quiet "${MERGE_BASE}...HEAD" -- ':**' \
+          if git diff --quiet "${MERGE_BASE}...HEAD" -- ':**/*' \
             ':!**/*.md' \
             ':crates/red_knot_python_semantic/resources/mdtest/**/*.md' \
             ':!docs/**' \
@@ -168,35 +166,12 @@ jobs:
               echo "changed=true" >> "$GITHUB_OUTPUT"
           fi
 
-      - name: Check if the red-knot code changed
-        id: check_red_knot
-        env:
-          MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
-        run: |
-          if git diff --quiet "${MERGE_BASE}...HEAD" -- \
-            ':Cargo.toml' \
-            ':Cargo.lock' \
-            ':crates/red_knot*/**' \
-            ':crates/ruff_db/**' \
-            ':crates/ruff_annotate_snippets/**' \
-            ':crates/ruff_python_ast/**' \
-            ':crates/ruff_python_parser/**' \
-            ':crates/ruff_python_trivia/**' \
-            ':crates/ruff_source_file/**' \
-            ':crates/ruff_text_size/**' \
-            ':.github/workflows/ci.yaml' \
-          ; then
-              echo "changed=false" >> "$GITHUB_OUTPUT"
-          else
-              echo "changed=true" >> "$GITHUB_OUTPUT"
-          fi
-
   cargo-fmt:
     name: "cargo fmt"
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
       - name: "Install Rust toolchain"
@@ -210,10 +185,10 @@ jobs:
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: "Install Rust toolchain"
         run: |
           rustup component add clippy
@@ -230,30 +205,22 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
         uses: rui314/setup-mold@v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
         with:
           tool: cargo-insta
-      - name: Red-knot mdtests (GitHub annotations)
-        if: ${{ needs.determine_changes.outputs.red_knot == 'true' }}
-        env:
-          NO_COLOR: 1
-          MDTEST_GITHUB_ANNOTATIONS_FORMAT: 1
-        # Ignore errors if this step fails; we want to continue to later steps in the workflow anyway.
-        # This step is just to get nice GitHub annotations on the PR diff in the files-changed tab.
-        run: cargo test -p red_knot_python_semantic --test mdtest || true
       - name: "Run tests"
         shell: bash
         env:
@@ -272,7 +239,7 @@ jobs:
         env:
           # Setting RUSTDOCFLAGS because `cargo doc --check` isn't yet implemented (https://github.com/rust-lang/cargo/issues/10025).
           RUSTDOCFLAGS: "-D warnings"
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: ruff
           path: target/debug/ruff
@@ -284,20 +251,20 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
         uses: rui314/setup-mold@v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
         with:
           tool: cargo-insta
       - name: "Run tests"
@@ -313,14 +280,14 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
         with:
           tool: cargo-nextest
       - name: "Run tests"
@@ -340,13 +307,13 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
+      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
           node-version: 20
           cache: "npm"
@@ -369,10 +336,10 @@ jobs:
     if: ${{ github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
@@ -387,7 +354,7 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
       - uses: SebRollen/toml-action@b1b3628f55fc3a28208d4203ada8b737e9687876 # v1.2.0
@@ -395,7 +362,7 @@ jobs:
         with:
           file: "Cargo.toml"
           field: "workspace.package.rust-version"
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: "Install Rust toolchain"
         env:
           MSRV: ${{ steps.msrv.outputs.value }}
@@ -403,11 +370,11 @@ jobs:
       - name: "Install mold"
         uses: rui314/setup-mold@v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
         with:
           tool: cargo-insta
       - name: "Run tests"
@@ -424,10 +391,10 @@ jobs:
     if: ${{ github.ref == 'refs/heads/main' || needs.determine_changes.outputs.fuzz == 'true' || needs.determine_changes.outputs.code == 'true' }}
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
         with:
           workspaces: "fuzz -> target"
       - name: "Install Rust toolchain"
@@ -452,11 +419,11 @@ jobs:
     env:
       FORCE_COLOR: 1
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
-      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
+      - uses: astral-sh/setup-uv@22695119d769bdb6f7032ad67b9bca0ef8c4a174 # v5
+      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
         name: Download Ruff binary to test
         id: download-cached-binary
         with:
@@ -486,10 +453,10 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 5
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: "Install Rust toolchain"
         run: rustup component add rustfmt
       # Run all code generation scripts, and verify that the current output is
@@ -518,14 +485,14 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && github.event_name == 'pull_request' && needs.determine_changes.outputs.code == 'true' }}
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
+      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
         name: Download comparison Ruff binary
         id: ruff-target
         with:
@@ -620,13 +587,13 @@ jobs:
         run: |
           echo ${{ github.event.number }} > pr-number
 
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         name: Upload PR Number
         with:
           name: pr-number
           path: pr-number
 
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         name: Upload Results
         with:
           name: ecosystem-result
@@ -638,7 +605,7 @@ jobs:
     needs: determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
       - uses: cargo-bins/cargo-binstall@main
@@ -651,18 +618,18 @@ jobs:
     timeout-minutes: 20
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
         with:
           args: --out dist
       - name: "Test wheel"
@@ -675,15 +642,22 @@ jobs:
 
   pre-commit:
     name: "pre-commit"
-    runs-on: depot-ubuntu-22.04-16
+    runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - name: "Install pre-commit"
+        run: pip install pre-commit
       - name: "Cache pre-commit"
-        uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3
+        uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4
         with:
           path: ~/.cache/pre-commit
           key: pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
@@ -692,7 +666,7 @@ jobs:
           echo '```console' > "$GITHUB_STEP_SUMMARY"
           # Enable color output for pre-commit and remove it for the summary
           # Use --hook-stage=manual to enable slower pre-commit hooks that are skipped by default
-          SKIP=cargo-fmt,clippy,dev-generate-all uvx --python="${PYTHON_VERSION}" pre-commit run --all-files --show-diff-on-failure --color=always --hook-stage=manual | \
+          SKIP=cargo-fmt,clippy,dev-generate-all pre-commit run --all-files --show-diff-on-failure --color=always --hook-stage=manual | \
             tee >(sed -E 's/\x1B\[([0-9]{1,2}(;[0-9]{1,2})*)?[mGK]//g' >> "$GITHUB_STEP_SUMMARY") >&1
           exit_code="${PIPESTATUS[0]}"
           echo '```' >> "$GITHUB_STEP_SUMMARY"
@@ -705,22 +679,22 @@ jobs:
     env:
       MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: "3.13"
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: "Add SSH key"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        uses: webfactory/ssh-agent@a6f90b1f127823b31d4d4a8d96047790581349bd # v0.9.1
+        uses: webfactory/ssh-agent@dc588b651fe13675774614f8e6a936a468676387 # v0.9.0
         with:
           ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
       - name: "Install Rust toolchain"
         run: rustup show
       - name: Install uv
-        uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
+        uses: astral-sh/setup-uv@22695119d769bdb6f7032ad67b9bca0ef8c4a174 # v5
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
         run: uv pip install -r docs/requirements-insiders.txt --system
@@ -747,10 +721,10 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && (needs.determine_changes.outputs.formatter == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Run checks"
@@ -773,18 +747,17 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         name: "Download ruff-lsp source"
         with:
           persist-credentials: false
           repository: "astral-sh/ruff-lsp"
 
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
-          # installation fails on 3.13 and newer
-          python-version: "3.12"
+          python-version: ${{ env.PYTHON_VERSION }}
 
-      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
+      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
         name: Download development ruff binary
         id: ruff-target
         with:
@@ -815,13 +788,13 @@ jobs:
       - determine_changes
     if: ${{ (needs.determine_changes.outputs.playground == 'true') }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
           node-version: 22
           cache: "npm"
@@ -847,17 +820,17 @@ jobs:
     timeout-minutes: 20
     steps:
       - name: "Checkout Branch"
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
 
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
 
       - name: "Install Rust toolchain"
         run: rustup show
 
       - name: "Install codspeed"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
         with:
           tool: cargo-codspeed
 
@@ -865,7 +838,7 @@ jobs:
         run: cargo codspeed build --features codspeed -p ruff_benchmark
 
       - name: "Run benchmarks"
-        uses: CodSpeedHQ/action@0010eb0ca6e89b80c88e8edaaa07cfe5f3e6664d # v3.5.0
+        uses: CodSpeedHQ/action@0010eb0ca6e89b80c88e8edaaa07cfe5f3e6664d # v3
         with:
           run: cargo codspeed run
           token: ${{ secrets.CODSPEED_TOKEN }}

.github/workflows/daily_fuzz.yaml

@@ -31,15 +31,15 @@ jobs:
     # Don't run the cron job on forks:
     if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
+      - uses: astral-sh/setup-uv@22695119d769bdb6f7032ad67b9bca0ef8c4a174 # v5
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
         uses: rui314/setup-mold@v1
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: Build ruff
         # A debug build means the script runs slower once it gets started,
         # but this is outweighed by the fact that a release build takes *much* longer to compile in CI
@@ -65,7 +65,7 @@ jobs:
     permissions:
       issues: write
     steps:
-      - uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+      - uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |

.github/workflows/daily_property_tests.yaml

@@ -30,14 +30,14 @@ jobs:
     # Don't run the cron job on forks:
     if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
         uses: rui314/setup-mold@v1
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
       - name: Build Red Knot
         # A release build takes longer (2 min vs 1 min), but the property tests run much faster in release
         # mode (1.5 min vs 14 min), so the overall time is shorter with a release build.
@@ -59,7 +59,7 @@ jobs:
     permissions:
       issues: write
     steps:
-      - uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+      - uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |

.github/workflows/mypy_primer.yaml

@@ -25,19 +25,19 @@ env:
 jobs:
   mypy_primer:
     name: Run mypy_primer
-    runs-on: depot-ubuntu-22.04-16
+    runs-on: ubuntu-24.04
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           path: ruff
           fetch-depth: 0
           persist-credentials: false
 
       - name: Install the latest version of uv
-        uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
+        uses: astral-sh/setup-uv@22695119d769bdb6f7032ad67b9bca0ef8c4a174 # v5
 
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
         with:
           workspaces: "ruff"
       - name: Install Rust toolchain
@@ -45,7 +45,7 @@ jobs:
 
       - name: Install mypy_primer
         run: |
-          uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support-v4"
+          uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support"
 
       - name: Run mypy_primer
         shell: bash
@@ -68,7 +68,7 @@ jobs:
             --type-checker knot \
             --old base_commit \
             --new "$GITHUB_SHA" \
-            --project-selector '/(mypy_primer|black|pyp|git-revise|zipp|arrow|isort|itsdangerous|rich|packaging|pybind11|pyinstrument|typeshed-stats|scrapy|werkzeug|bidict|async-utils)$' \
+            --project-selector '/(mypy_primer|black|pyp|git-revise|zipp|arrow|isort|itsdangerous|rich|packaging|pybind11|pyinstrument)$' \
             --output concise \
             --debug > mypy_primer.diff || [ $? -eq 1 ]
 
@@ -81,13 +81,13 @@ jobs:
           echo ${{ github.event.number }} > pr-number
 
       - name: Upload diff
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: mypy_primer_diff
           path: mypy_primer.diff
 
       - name: Upload pr-number
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: pr-number
           path: pr-number

.github/workflows/notify-dependents.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: "Update pre-commit mirror"
-        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7
         with:
           github-token: ${{ secrets.RUFF_PRE_COMMIT_PAT }}
           script: |

.github/workflows/publish-docs.yml

@@ -23,12 +23,12 @@ jobs:
     env:
       MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           ref: ${{ inputs.ref }}
           persist-credentials: true
 
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
         with:
           python-version: 3.12
 
@@ -61,14 +61,14 @@ jobs:
 
       - name: "Add SSH key"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        uses: webfactory/ssh-agent@a6f90b1f127823b31d4d4a8d96047790581349bd # v0.9.1
+        uses: webfactory/ssh-agent@dc588b651fe13675774614f8e6a936a468676387 # v0.9.0
         with:
           ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
 
       - name: "Install Rust toolchain"
         run: rustup show
 
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
 
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}

.github/workflows/publish-knot-playground.yml

@@ -30,12 +30,12 @@ jobs:
     env:
       CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
+      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
           node-version: 22
       - uses: jetli/wasm-bindgen-action@20b33e20595891ab1a0ed73145d8a21fc96e7c29 # v0.2.0

.github/workflows/publish-playground.yml

@@ -24,12 +24,12 @@ jobs:
     env:
       CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
+      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
           node-version: 22
           cache: "npm"

.github/workflows/publish-pypi.yml

@@ -22,8 +22,8 @@ jobs:
       id-token: write
     steps:
       - name: "Install uv"
-        uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
-      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
+        uses: astral-sh/setup-uv@22695119d769bdb6f7032ad67b9bca0ef8c4a174 # v5
+      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
         with:
           pattern: wheels-*
           path: wheels

.github/workflows/publish-wasm.yml

@@ -29,7 +29,7 @@ jobs:
         target: [web, bundler, nodejs]
       fail-fast: false
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           persist-credentials: false
       - name: "Install Rust toolchain"
@@ -45,7 +45,7 @@ jobs:
           jq '.name="@astral-sh/ruff-wasm-${{ matrix.target }}"' crates/ruff_wasm/pkg/package.json > /tmp/package.json
           mv /tmp/package.json crates/ruff_wasm/pkg
       - run: cp LICENSE crates/ruff_wasm/pkg # wasm-pack does not put the LICENSE file in the pkg
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
+      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
           node-version: 20
           registry-url: "https://registry.npmjs.org"

.github/workflows/release.yml

@@ -1,7 +1,6 @@
-# This file was autogenerated by dist: https://github.com/astral-sh/cargo-dist
+# This file was autogenerated by dist: https://opensource.axo.dev/cargo-dist/
 #
 # Copyright 2022-2024, axodotdev
-# Copyright 2025 Astral Software Inc.
 # SPDX-License-Identifier: MIT or Apache-2.0
 #
 # CI that:
@@ -60,17 +59,16 @@ jobs:
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
-          persist-credentials: false
           submodules: recursive
       - name: Install 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/astral-sh/cargo-dist/releases/download/v0.28.4-prerelease.1/cargo-dist-installer.sh | sh"
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.25.2-prerelease.3/cargo-dist-installer.sh | sh"
       - name: Cache dist
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/dist
@@ -86,7 +84,7 @@ jobs:
           cat plan-dist-manifest.json
           echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
       - name: "Upload dist-manifest.json"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: artifacts-plan-dist-manifest
           path: plan-dist-manifest.json
@@ -123,19 +121,18 @@ jobs:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
-          persist-credentials: false
           submodules: recursive
       - name: Install cached dist
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/
       - run: chmod +x ~/.cargo/bin/dist
       # Get all the local artifacts for the global tasks to use (for e.g. checksums)
       - name: Fetch local artifacts
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
         with:
           pattern: artifacts-*
           path: target/distrib/
@@ -153,7 +150,7 @@ jobs:
 
           cp dist-manifest.json "$BUILD_MANIFEST_NAME"
       - name: "Upload artifacts"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: artifacts-build-global
           path: |
@@ -174,19 +171,18 @@ jobs:
     outputs:
       val: ${{ steps.host.outputs.manifest }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
-          persist-credentials: false
           submodules: recursive
       - name: Install cached dist
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/
       - run: chmod +x ~/.cargo/bin/dist
       # Fetch artifacts from scratch-storage
       - name: Fetch artifacts
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
         with:
           pattern: artifacts-*
           path: target/distrib/
@@ -200,7 +196,7 @@ jobs:
           cat dist-manifest.json
           echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
       - name: "Upload dist-manifest.json"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           # Overwrite the previous copy
           name: artifacts-dist-manifest
@@ -250,13 +246,12 @@ jobs:
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
-          persist-credentials: false
           submodules: recursive
       # Create a GitHub Release while uploading all files to it
       - name: "Download GitHub Artifacts"
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
         with:
           pattern: artifacts-*
           path: artifacts

.github/workflows/sync_typeshed.yaml

@@ -21,12 +21,12 @@ jobs:
       contents: write
       pull-requests: write
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         name: Checkout Ruff
         with:
           path: ruff
           persist-credentials: true
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         name: Checkout typeshed
         with:
           repository: python/typeshed
@@ -70,7 +70,7 @@ jobs:
     permissions:
       issues: write
     steps:
-      - uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+      - uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |

.pre-commit-config.yaml

@@ -18,13 +18,8 @@ exclude: |
   )$
 
 repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
-    hooks:
-      - id: check-merge-conflict
-
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.24.1
+    rev: v0.24
     hooks:
       - id: validate-pyproject
 
@@ -65,7 +60,7 @@ repos:
           - black==25.1.0
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.31.1
+    rev: v1.30.2
     hooks:
       - id: typos
 
@@ -79,7 +74,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.4
+    rev: v0.11.0
     hooks:
       - id: ruff-format
       - id: ruff
@@ -97,12 +92,12 @@ repos:
   # zizmor detects security vulnerabilities in GitHub Actions workflows.
   # Additional configuration for the tool is found in `.github/zizmor.yml`
   - repo: https://github.com/woodruffw/zizmor-pre-commit
-    rev: v1.5.2
+    rev: v1.5.1
     hooks:
       - id: zizmor
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.32.1
+    rev: 0.31.3
     hooks:
       - id: check-github-workflows
 

CHANGELOG.md

@@ -1,78 +1,5 @@
 # Changelog
 
-## 0.11.5
-
-### Preview features
-
-- \[`airflow`\] Add missing `AIR302` attribute check ([#17115](https://github.com/astral-sh/ruff/pull/17115))
-- \[`airflow`\] Expand module path check to individual symbols (`AIR302`) ([#17278](https://github.com/astral-sh/ruff/pull/17278))
-- \[`airflow`\] Extract `AIR312` from `AIR302` rules (`AIR302`, `AIR312`) ([#17152](https://github.com/astral-sh/ruff/pull/17152))
-- \[`airflow`\] Update oudated `AIR301`, `AIR302` rules ([#17123](https://github.com/astral-sh/ruff/pull/17123))
-- [syntax-errors] Async comprehension in sync comprehension ([#17177](https://github.com/astral-sh/ruff/pull/17177))
-- [syntax-errors] Check annotations in annotated assignments ([#17283](https://github.com/astral-sh/ruff/pull/17283))
-- [syntax-errors] Extend annotation checks to `await` ([#17282](https://github.com/astral-sh/ruff/pull/17282))
-
-### Bug fixes
-
-- \[`flake8-pie`\] Avoid false positive for multiple assignment with `auto()` (`PIE796`) ([#17274](https://github.com/astral-sh/ruff/pull/17274))
-
-### Rule changes
-
-- \[`ruff`\] Fix `RUF100` to detect unused file-level `noqa` directives with specific codes (#17042) ([#17061](https://github.com/astral-sh/ruff/pull/17061))
-- \[`flake8-pytest-style`\] Avoid false positive for legacy form of `pytest.raises` (`PT011`) ([#17231](https://github.com/astral-sh/ruff/pull/17231))
-
-### Documentation
-
-- Fix formatting of "See Style Guide" link ([#17272](https://github.com/astral-sh/ruff/pull/17272))
-
-## 0.11.4
-
-### Preview features
-
-- \[`ruff`\] Implement `invalid-rule-code` as `RUF102` ([#17138](https://github.com/astral-sh/ruff/pull/17138))
-- [syntax-errors] Detect duplicate keys in `match` mapping patterns ([#17129](https://github.com/astral-sh/ruff/pull/17129))
-- [syntax-errors] Detect duplicate attributes in `match` class patterns ([#17186](https://github.com/astral-sh/ruff/pull/17186))
-- [syntax-errors] Detect invalid syntax in annotations ([#17101](https://github.com/astral-sh/ruff/pull/17101))
-
-### Bug fixes
-
-- [syntax-errors] Fix multiple assignment error for class fields in `match` patterns ([#17184](https://github.com/astral-sh/ruff/pull/17184))
-- Don't skip visiting non-tuple slice in `typing.Annotated` subscripts ([#17201](https://github.com/astral-sh/ruff/pull/17201))
-
-## 0.11.3
-
-### Preview features
-
-- \[`airflow`\] Add more autofixes for `AIR302` ([#16876](https://github.com/astral-sh/ruff/pull/16876), [#16977](https://github.com/astral-sh/ruff/pull/16977), [#16976](https://github.com/astral-sh/ruff/pull/16976), [#16965](https://github.com/astral-sh/ruff/pull/16965))
-- \[`airflow`\] Move `AIR301` to `AIR002` ([#16978](https://github.com/astral-sh/ruff/pull/16978))
-- \[`airflow`\] Move `AIR302` to `AIR301` and `AIR303` to `AIR302` ([#17151](https://github.com/astral-sh/ruff/pull/17151))
-- \[`flake8-bandit`\] Mark `str` and `list[str]` literals as trusted input (`S603`) ([#17136](https://github.com/astral-sh/ruff/pull/17136))
-- \[`ruff`\] Support slices in `RUF005` ([#17078](https://github.com/astral-sh/ruff/pull/17078))
-- [syntax-errors] Start detecting compile-time syntax errors ([#16106](https://github.com/astral-sh/ruff/pull/16106))
-- [syntax-errors] Duplicate type parameter names ([#16858](https://github.com/astral-sh/ruff/pull/16858))
-- [syntax-errors] Irrefutable `case` pattern before final case ([#16905](https://github.com/astral-sh/ruff/pull/16905))
-- [syntax-errors] Multiple assignments in `case` pattern ([#16957](https://github.com/astral-sh/ruff/pull/16957))
-- [syntax-errors] Single starred assignment target ([#17024](https://github.com/astral-sh/ruff/pull/17024))
-- [syntax-errors] Starred expressions in `return`, `yield`, and `for` ([#17134](https://github.com/astral-sh/ruff/pull/17134))
-- [syntax-errors] Store to or delete `__debug__` ([#16984](https://github.com/astral-sh/ruff/pull/16984))
-
-### Bug fixes
-
-- Error instead of `panic!` when running Ruff from a deleted directory (#16903) ([#17054](https://github.com/astral-sh/ruff/pull/17054))
-- [syntax-errors] Fix false positive for parenthesized tuple index ([#16948](https://github.com/astral-sh/ruff/pull/16948))
-
-### CLI
-
-- Check `pyproject.toml` correctly when it is passed via stdin ([#16971](https://github.com/astral-sh/ruff/pull/16971))
-
-### Configuration
-
-- \[`flake8-import-conventions`\] Add import `numpy.typing as npt` to default `flake8-import-conventions.aliases` ([#17133](https://github.com/astral-sh/ruff/pull/17133))
-
-### Documentation
-
-- \[`refurb`\] Document why `UserDict`, `UserList`, and `UserString` are preferred over `dict`, `list`, and `str` (`FURB189`) ([#16927](https://github.com/astral-sh/ruff/pull/16927))
-
 ## 0.11.2
 
 ### Preview features

Cargo.lock

@@ -207,9 +207,9 @@ dependencies = [
 
 [[package]]
 name = "boxcar"
-version = "0.2.11"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6740c6e2fc6360fa57c35214c7493826aee95993926092606f27c983b40837be"
+checksum = "225450ee9328e1e828319b48a89726cffc1b0ad26fd9211ad435de9fa376acae"
 dependencies = [
  "loom",
 ]
@@ -334,9 +334,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.35"
+version = "4.5.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8aa86934b44c19c50f87cc2790e19f54f7a67aedb64101c2e1a2e5ecfb73944"
+checksum = "6088f3ae8c3608d19260cd7445411865a485688711b78b5be70d78cd96136f83"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -344,9 +344,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.35"
+version = "4.5.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2414dbb2dd0695280da6ea9261e327479e9d37b0630f6b53ba2a11c60c679fd9"
+checksum = "22a7ef7f676155edfb82daa97f99441f3ebf4a58d5e32f295a56259f1b6facc8"
 dependencies = [
  "anstream",
  "anstyle",
@@ -695,9 +695,9 @@ dependencies = [
 
 [[package]]
 name = "ctrlc"
-version = "3.4.6"
+version = "3.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "697b5419f348fd5ae2478e8018cb016c00a5881c7f46c717de98ffd135a5651c"
+checksum = "90eeab0aa92f3f9b4e87f258c72b139c207d251f9cbc1080a0086b86a8870dd3"
 dependencies = [
  "nix",
  "windows-sys 0.59.0",
@@ -894,9 +894,9 @@ checksum = "c7f84e12ccf0a7ddc17a6c41c93326024c42920d7ee630d04950e6926645c0fe"
 
 [[package]]
 name = "env_logger"
-version = "0.11.8"
+version = "0.11.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f"
+checksum = "c3716d7a920fb4fac5d84e9d4bce8ceb321e9414b4409da61b07b75c1e3d0697"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1390,9 +1390,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.9.0"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
+checksum = "3954d50fe15b02142bf25d3b8bdadb634ec3948f103d04ffe3031bc8fe9d7058"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.2",
@@ -1659,9 +1659,9 @@ dependencies = [
 
 [[package]]
 name = "libmimalloc-sys"
-version = "0.1.41"
+version = "0.1.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b20daca3a4ac14dbdc753c5e90fc7b490a48a9131daed3c9a9ced7b2defd37b"
+checksum = "07d0e07885d6a754b9c7993f2625187ad694ee985d60f23355ff0e7077261502"
 dependencies = [
  "cc",
  "libc",
@@ -1726,9 +1726,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.27"
+version = "0.4.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+checksum = "30bde2b3dc3671ae49d8e2e9f044c7c005836e7a023ee57cffa25ab82764bb9e"
 
 [[package]]
 name = "loom"
@@ -1797,9 +1797,9 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "mimalloc"
-version = "0.1.45"
+version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03cb1f88093fe50061ca1195d336ffec131347c7b833db31f9ab62a2d1b7925f"
+checksum = "99585191385958383e13f6b822e6b6d8d9cf928e7d286ceb092da92b43c87bc1"
 dependencies = [
  "libmimalloc-sys",
 ]
@@ -1973,9 +1973,9 @@ checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
 [[package]]
 name = "ordermap"
-version = "0.5.7"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d31b8b7a99f71bdff4235faf9ce9eada0ad3562c8fbeb7d607d9f41a6ec569d"
+checksum = "6e98f974336ceffd5b1b1f4fcbb89a23c8dcd334adc4b8612f11b7fa99944535"
 dependencies = [
  "indexmap",
 ]
@@ -2503,23 +2503,6 @@ dependencies = [
  "wild",
 ]
 
-[[package]]
-name = "red_knot_ide"
-version = "0.0.0"
-dependencies = [
- "insta",
- "red_knot_python_semantic",
- "red_knot_vendored",
- "ruff_db",
- "ruff_python_ast",
- "ruff_python_parser",
- "ruff_text_size",
- "rustc-hash 2.1.1",
- "salsa",
- "smallvec",
- "tracing",
-]
-
 [[package]]
 name = "red_knot_project"
 version = "0.0.0"
@@ -2531,14 +2514,12 @@ dependencies = [
  "notify",
  "pep440_rs",
  "rayon",
- "red_knot_ide",
  "red_knot_python_semantic",
  "red_knot_vendored",
  "ruff_cache",
  "ruff_db",
  "ruff_macros",
  "ruff_python_ast",
- "ruff_python_formatter",
  "ruff_text_size",
  "rustc-hash 2.1.1",
  "salsa",
@@ -2604,11 +2585,10 @@ dependencies = [
  "libc",
  "lsp-server",
  "lsp-types",
- "red_knot_ide",
  "red_knot_project",
- "red_knot_python_semantic",
  "ruff_db",
  "ruff_notebook",
+ "ruff_python_ast",
  "ruff_source_file",
  "ruff_text_size",
  "rustc-hash 2.1.1",
@@ -2666,12 +2646,10 @@ dependencies = [
  "getrandom 0.3.2",
  "js-sys",
  "log",
- "red_knot_ide",
  "red_knot_project",
  "red_knot_python_semantic",
  "ruff_db",
  "ruff_notebook",
- "ruff_python_formatter",
  "ruff_source_file",
  "ruff_text_size",
  "serde-wasm-bindgen",
@@ -2756,7 +2734,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.11.5"
+version = "0.11.2"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2991,7 +2969,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.11.5"
+version = "0.11.2"
 dependencies = [
  "aho-corasick",
  "anyhow",
@@ -3020,6 +2998,7 @@ dependencies = [
  "ruff_annotate_snippets",
  "ruff_cache",
  "ruff_diagnostics",
+ "ruff_index",
  "ruff_macros",
  "ruff_notebook",
  "ruff_python_ast",
@@ -3135,7 +3114,6 @@ dependencies = [
  "memchr",
  "regex",
  "ruff_cache",
- "ruff_db",
  "ruff_formatter",
  "ruff_macros",
  "ruff_python_ast",
@@ -3144,7 +3122,6 @@ dependencies = [
  "ruff_source_file",
  "ruff_text_size",
  "rustc-hash 2.1.1",
- "salsa",
  "schemars",
  "serde",
  "serde_json",
@@ -3216,7 +3193,6 @@ name = "ruff_python_semantic"
 version = "0.0.0"
 dependencies = [
  "bitflags 2.9.0",
- "insta",
  "is-macro",
  "ruff_cache",
  "ruff_index",
@@ -3229,7 +3205,6 @@ dependencies = [
  "schemars",
  "serde",
  "smallvec",
- "test-case",
 ]
 
 [[package]]
@@ -3317,7 +3292,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.11.5"
+version = "0.11.2"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -3442,7 +3417,7 @@ checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 [[package]]
 name = "salsa"
 version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=d758691ba17ee1a60c5356ea90888d529e1782ad#d758691ba17ee1a60c5356ea90888d529e1782ad"
 dependencies = [
  "boxcar",
  "compact_str 0.8.1",
@@ -3458,19 +3433,18 @@ dependencies = [
  "salsa-macro-rules",
  "salsa-macros",
  "smallvec",
- "thin-vec",
  "tracing",
 ]
 
 [[package]]
 name = "salsa-macro-rules"
 version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=d758691ba17ee1a60c5356ea90888d529e1782ad#d758691ba17ee1a60c5356ea90888d529e1782ad"
 
 [[package]]
 name = "salsa-macros"
 version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=d758691ba17ee1a60c5356ea90888d529e1782ad#d758691ba17ee1a60c5356ea90888d529e1782ad"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -3685,9 +3659,9 @@ checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
 name = "smallvec"
-version = "1.15.0"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
+checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
 
 [[package]]
 name = "snapbox"
@@ -3883,12 +3857,6 @@ dependencies = [
  "test-case-core",
 ]
 
-[[package]]
-name = "thin-vec"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "144f754d318415ac792f9d69fc87abbbfc043ce2ef041c60f16ad828f638717d"
-
 [[package]]
 name = "thiserror"
 version = "1.0.69"

Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-rust-version = "1.84"
+rust-version = "1.83"
 homepage = "https://docs.astral.sh/ruff"
 documentation = "https://docs.astral.sh/ruff"
 repository = "https://github.com/astral-sh/ruff"
@@ -38,11 +38,10 @@ ruff_text_size = { path = "crates/ruff_text_size" }
 red_knot_vendored = { path = "crates/red_knot_vendored" }
 ruff_workspace = { path = "crates/ruff_workspace" }
 
-red_knot_ide = { path = "crates/red_knot_ide" }
-red_knot_project = { path = "crates/red_knot_project", default-features = false }
 red_knot_python_semantic = { path = "crates/red_knot_python_semantic" }
 red_knot_server = { path = "crates/red_knot_server" }
 red_knot_test = { path = "crates/red_knot_test" }
+red_knot_project = { path = "crates/red_knot_project", default-features = false }
 
 aho-corasick = { version = "1.1.3" }
 anstream = { version = "0.6.18" }
@@ -124,7 +123,7 @@ rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
 # When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "87bf6b6c2d5f6479741271da73bd9d30c2580c26" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "d758691ba17ee1a60c5356ea90888d529e1782ad" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -209,7 +208,6 @@ must_use_candidate = "allow"
 similar_names = "allow"
 single_match_else = "allow"
 too_many_lines = "allow"
-needless_continue = "allow"       # An explicit continue can be more readable, especially if the alternative is an empty block.
 # Without the hashes we run into a `rustfmt` bug in some snapshot tests, see #13250
 needless_raw_string_hashes = "allow"
 # Disallowed restriction lints
@@ -272,7 +270,7 @@ inherits = "release"
 # Config for 'dist'
 [workspace.metadata.dist]
 # The preferred dist version to use in CI (Cargo.toml SemVer syntax)
-cargo-dist-version = "0.28.4-prerelease.1"
+cargo-dist-version = "0.25.2-prerelease.3"
 # CI backends to support
 ci = "github"
 # The installers to generate for each app
@@ -329,12 +327,9 @@ github-custom-job-permissions = { "build-docker" = { packages = "write", content
 install-updater = false
 # Path that installers should place binaries in
 install-path = ["$XDG_BIN_HOME/", "$XDG_DATA_HOME/../bin", "~/.local/bin"]
+# Temporarily allow changes to the `release` workflow, in which we pin actions
+# to a SHA instead of a tag (https://github.com/astral-sh/uv/issues/12253)
+allow-dirty = ["ci"]
 
 [workspace.metadata.dist.github-custom-runners]
 global = "depot-ubuntu-latest-4"
-
-[workspace.metadata.dist.github-action-commits]
-"actions/checkout" = "11bd71901bbe5b1630ceea73d27597364c9af683" # v4
-"actions/upload-artifact" = "ea165f8d65b6e75b540449e92b4886f43607fa02" # v4.6.2
-"actions/download-artifact" = "95815c38cf2ff2164869cbab79da8d1f422bc89e" # v4.2.1
-"actions/attest-build-provenance" = "c074443f1aee8d4aeeae555aebba3282517141b2" #v2.2.3

README.md

@@ -149,8 +149,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.11.5/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.11.5/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.11.2/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.11.2/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -183,7 +183,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.11.5
+  rev: v0.11.2
   hooks:
     # Run the linter.
     - id: ruff

crates/red_knot/src/args.rs

@@ -71,15 +71,6 @@ pub(crate) struct CheckCommand {
     #[arg(long, value_name = "VERSION", alias = "target-version")]
     pub(crate) python_version: Option<PythonVersion>,
 
-    /// Target platform to assume when resolving types.
-    ///
-    /// This is used to specialize the type of `sys.platform` and will affect the visibility
-    /// of platform-specific functions and attributes. If the value is set to `all`, no
-    /// assumptions are made about the target platform. If unspecified, the current system's
-    /// platform will be used.
-    #[arg(long, value_name = "PLATFORM", alias = "platform")]
-    pub(crate) python_platform: Option<String>,
-
     #[clap(flatten)]
     pub(crate) verbosity: Verbosity,
 
@@ -125,9 +116,6 @@ impl CheckCommand {
                 python_version: self
                     .python_version
                     .map(|version| RangedValue::cli(version.into())),
-                python_platform: self
-                    .python_platform
-                    .map(|platform| RangedValue::cli(platform.into())),
                 python: self.python.map(RelativePathBuf::cli),
                 typeshed: self.typeshed.map(RelativePathBuf::cli),
                 extra_paths: self.extra_search_path.map(|extra_search_paths| {
@@ -136,6 +124,7 @@ impl CheckCommand {
                         .map(RelativePathBuf::cli)
                         .collect()
                 }),
+                ..EnvironmentOptions::default()
             }),
             terminal: Some(TerminalOptions {
                 output_format: self

crates/red_knot/src/main.rs

@@ -15,7 +15,7 @@ use red_knot_project::watch::ProjectWatcher;
 use red_knot_project::{watch, Db};
 use red_knot_project::{ProjectDatabase, ProjectMetadata};
 use red_knot_server::run_server;
-use ruff_db::diagnostic::{Diagnostic, DisplayDiagnosticConfig, Severity};
+use ruff_db::diagnostic::{DisplayDiagnosticConfig, OldDiagnosticTrait, Severity};
 use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
 use salsa::plumbing::ZalsaDatabase;
 
@@ -288,7 +288,7 @@ impl MainLoop {
                             let diagnostics_count = result.len();
 
                             for diagnostic in result {
-                                write!(stdout, "{}", diagnostic.display(db, &display_config))?;
+                                writeln!(stdout, "{}", diagnostic.display(db, &display_config))?;
 
                                 failed |= diagnostic.severity() >= min_error_severity;
                             }
@@ -359,7 +359,7 @@ enum MainLoopMessage {
     CheckWorkspace,
     CheckCompleted {
         /// The diagnostics that were found during the check.
-        result: Vec<Diagnostic>,
+        result: Vec<Box<dyn OldDiagnosticTrait>>,
         revision: u64,
     },
     ApplyChanges(Vec<watch::ChangeEvent>),

crates/red_knot/tests/cli.rs

@@ -6,9 +6,9 @@ use std::process::Command;
 use tempfile::TempDir;
 
 /// Specifying an option on the CLI should take precedence over the same setting in the
-/// project's configuration. Here, this is tested for the Python version.
+/// project's configuration.
 #[test]
-fn config_override_python_version() -> anyhow::Result<()> {
+fn config_override() -> anyhow::Result<()> {
     let case = TestCase::with_files([
         (
             "pyproject.toml",
@@ -57,67 +57,6 @@ fn config_override_python_version() -> anyhow::Result<()> {
     Ok(())
 }
 
-/// Same as above, but for the Python platform.
-#[test]
-fn config_override_python_platform() -> anyhow::Result<()> {
-    let case = TestCase::with_files([
-        (
-            "pyproject.toml",
-            r#"
-            [tool.knot.environment]
-            python-platform = "linux"
-            "#,
-        ),
-        (
-            "test.py",
-            r#"
-            import sys
-            from typing_extensions import reveal_type
-
-            reveal_type(sys.platform)
-            "#,
-        ),
-    ])?;
-
-    assert_cmd_snapshot!(case.command(), @r#"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    info: revealed-type
-     --> <temp_dir>/test.py:5:1
-      |
-    3 | from typing_extensions import reveal_type
-    4 |
-    5 | reveal_type(sys.platform)
-      | ^^^^^^^^^^^^^^^^^^^^^^^^^ Revealed type is `Literal["linux"]`
-      |
-
-    Found 1 diagnostic
-
-    ----- stderr -----
-    "#);
-
-    assert_cmd_snapshot!(case.command().arg("--python-platform").arg("all"), @r"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    info: revealed-type
-     --> <temp_dir>/test.py:5:1
-      |
-    3 | from typing_extensions import reveal_type
-    4 |
-    5 | reveal_type(sys.platform)
-      | ^^^^^^^^^^^^^^^^^^^^^^^^^ Revealed type is `LiteralString`
-      |
-
-    Found 1 diagnostic
-
-    ----- stderr -----
-    ");
-
-    Ok(())
-}
-
 /// Paths specified on the CLI are relative to the current working directory and not the project root.
 ///
 /// We test this by adding an extra search path from the CLI to the libs directory when

crates/red_knot/tests/file_watching.rs

@@ -1125,11 +1125,11 @@ print(sys.last_exc, os.getegid())
 
     assert_eq!(diagnostics.len(), 2);
     assert_eq!(
-        diagnostics[0].primary_message(),
+        diagnostics[0].message(),
         "Type `<module 'sys'>` has no attribute `last_exc`"
     );
     assert_eq!(
-        diagnostics[1].primary_message(),
+        diagnostics[1].message(),
         "Type `<module 'os'>` has no attribute `getegid`"
     );
 

crates/red_knot_ide/Cargo.toml

@@ -1,31 +0,0 @@
-[package]
-name = "red_knot_ide"
-version = "0.0.0"
-publish = false
-authors = { workspace = true }
-edition = { workspace = true }
-rust-version = { workspace = true }
-homepage = { workspace = true }
-documentation = { workspace = true }
-repository = { workspace = true }
-license = { workspace = true }
-
-[dependencies]
-ruff_db = { workspace = true }
-ruff_python_ast = { workspace = true }
-ruff_python_parser = { workspace = true }
-ruff_text_size = { workspace = true }
-red_knot_python_semantic = { workspace = true }
-
-rustc-hash = { workspace = true }
-salsa = { workspace = true }
-smallvec = { workspace = true }
-tracing = { workspace = true }
-
-[dev-dependencies]
-red_knot_vendored = { workspace = true }
-
-insta = { workspace = true, features = ["filters"] }
-
-[lints]
-workspace = true

crates/red_knot_ide/src/db.rs

@@ -1,134 +0,0 @@
-use red_knot_python_semantic::Db as SemanticDb;
-use ruff_db::{Db as SourceDb, Upcast};
-
-#[salsa::db]
-pub trait Db: SemanticDb + Upcast<dyn SemanticDb> + Upcast<dyn SourceDb> {}
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use std::sync::Arc;
-
-    use super::Db;
-    use red_knot_python_semantic::lint::{LintRegistry, RuleSelection};
-    use red_knot_python_semantic::{default_lint_registry, Db as SemanticDb};
-    use ruff_db::files::{File, Files};
-    use ruff_db::system::{DbWithTestSystem, System, TestSystem};
-    use ruff_db::vendored::VendoredFileSystem;
-    use ruff_db::{Db as SourceDb, Upcast};
-
-    #[salsa::db]
-    #[derive(Clone)]
-    pub(crate) struct TestDb {
-        storage: salsa::Storage<Self>,
-        files: Files,
-        system: TestSystem,
-        vendored: VendoredFileSystem,
-        events: Arc<std::sync::Mutex<Vec<salsa::Event>>>,
-        rule_selection: Arc<RuleSelection>,
-    }
-
-    #[allow(dead_code)]
-    impl TestDb {
-        pub(crate) fn new() -> Self {
-            Self {
-                storage: salsa::Storage::default(),
-                system: TestSystem::default(),
-                vendored: red_knot_vendored::file_system().clone(),
-                events: Arc::default(),
-                files: Files::default(),
-                rule_selection: Arc::new(RuleSelection::from_registry(default_lint_registry())),
-            }
-        }
-
-        /// Takes the salsa events.
-        ///
-        /// ## Panics
-        /// If there are any pending salsa snapshots.
-        pub(crate) fn take_salsa_events(&mut self) -> Vec<salsa::Event> {
-            let inner = Arc::get_mut(&mut self.events).expect("no pending salsa snapshots");
-
-            let events = inner.get_mut().unwrap();
-            std::mem::take(&mut *events)
-        }
-
-        /// Clears the salsa events.
-        ///
-        /// ## Panics
-        /// If there are any pending salsa snapshots.
-        pub(crate) fn clear_salsa_events(&mut self) {
-            self.take_salsa_events();
-        }
-    }
-
-    impl DbWithTestSystem for TestDb {
-        fn test_system(&self) -> &TestSystem {
-            &self.system
-        }
-
-        fn test_system_mut(&mut self) -> &mut TestSystem {
-            &mut self.system
-        }
-    }
-
-    #[salsa::db]
-    impl SourceDb for TestDb {
-        fn vendored(&self) -> &VendoredFileSystem {
-            &self.vendored
-        }
-
-        fn system(&self) -> &dyn System {
-            &self.system
-        }
-
-        fn files(&self) -> &Files {
-            &self.files
-        }
-    }
-
-    impl Upcast<dyn SourceDb> for TestDb {
-        fn upcast(&self) -> &(dyn SourceDb + 'static) {
-            self
-        }
-        fn upcast_mut(&mut self) -> &mut (dyn SourceDb + 'static) {
-            self
-        }
-    }
-
-    impl Upcast<dyn SemanticDb> for TestDb {
-        fn upcast(&self) -> &(dyn SemanticDb + 'static) {
-            self
-        }
-
-        fn upcast_mut(&mut self) -> &mut dyn SemanticDb {
-            self
-        }
-    }
-
-    #[salsa::db]
-    impl SemanticDb for TestDb {
-        fn is_file_open(&self, file: File) -> bool {
-            !file.path(self).is_vendored_path()
-        }
-
-        fn rule_selection(&self) -> Arc<RuleSelection> {
-            self.rule_selection.clone()
-        }
-
-        fn lint_registry(&self) -> &LintRegistry {
-            default_lint_registry()
-        }
-    }
-
-    #[salsa::db]
-    impl Db for TestDb {}
-
-    #[salsa::db]
-    impl salsa::Database for TestDb {
-        fn salsa_event(&self, event: &dyn Fn() -> salsa::Event) {
-            let event = event();
-            tracing::trace!("event: {event:?}");
-            let mut events = self.events.lock().unwrap();
-            events.push(event);
-        }
-    }
-}

crates/red_knot_ide/src/find_node.rs

@@ -1,106 +0,0 @@
-use ruff_python_ast::visitor::source_order::{SourceOrderVisitor, TraversalSignal};
-use ruff_python_ast::AnyNodeRef;
-use ruff_text_size::{Ranged, TextRange};
-use std::fmt;
-use std::fmt::Formatter;
-
-/// Returns the node with a minimal range that fully contains `range`.
-///
-/// If `range` is empty and falls within a parser *synthesized* node generated during error recovery,
-/// then the first node with the given range is returned.
-///
-/// ## Panics
-/// Panics if `range` is not contained within `root`.
-pub(crate) fn covering_node(root: AnyNodeRef, range: TextRange) -> CoveringNode {
-    struct Visitor<'a> {
-        range: TextRange,
-        found: bool,
-        ancestors: Vec<AnyNodeRef<'a>>,
-    }
-
-    impl<'a> SourceOrderVisitor<'a> for Visitor<'a> {
-        fn enter_node(&mut self, node: AnyNodeRef<'a>) -> TraversalSignal {
-            // If the node fully contains the range, than it is a possible match but traverse into its children
-            // to see if there's a node with a narrower range.
-            if !self.found && node.range().contains_range(self.range) {
-                self.ancestors.push(node);
-                TraversalSignal::Traverse
-            } else {
-                TraversalSignal::Skip
-            }
-        }
-
-        fn leave_node(&mut self, node: AnyNodeRef<'a>) {
-            if !self.found && self.ancestors.last() == Some(&node) {
-                self.found = true;
-            }
-        }
-    }
-
-    assert!(
-        root.range().contains_range(range),
-        "Range is not contained within root"
-    );
-
-    let mut visitor = Visitor {
-        range,
-        found: false,
-        ancestors: Vec::new(),
-    };
-
-    root.visit_source_order(&mut visitor);
-
-    let minimal = visitor.ancestors.pop().unwrap_or(root);
-    CoveringNode {
-        node: minimal,
-        ancestors: visitor.ancestors,
-    }
-}
-
-/// The node with a minimal range that fully contains the search range.
-pub(crate) struct CoveringNode<'a> {
-    /// The node with a minimal range that fully contains the search range.
-    node: AnyNodeRef<'a>,
-
-    /// The node's ancestor (the spine up to the root).
-    ancestors: Vec<AnyNodeRef<'a>>,
-}
-
-impl<'a> CoveringNode<'a> {
-    pub(crate) fn node(&self) -> AnyNodeRef<'a> {
-        self.node
-    }
-
-    /// Returns the node's parent.
-    pub(crate) fn parent(&self) -> Option<AnyNodeRef<'a>> {
-        self.ancestors.last().copied()
-    }
-
-    /// Finds the minimal node that fully covers the range and fulfills the given predicate.
-    pub(crate) fn find(mut self, f: impl Fn(AnyNodeRef<'a>) -> bool) -> Result<Self, Self> {
-        if f(self.node) {
-            return Ok(self);
-        }
-
-        match self.ancestors.iter().rposition(|node| f(*node)) {
-            Some(index) => {
-                let node = self.ancestors[index];
-                self.ancestors.truncate(index);
-
-                Ok(Self {
-                    node,
-                    ancestors: self.ancestors,
-                })
-            }
-            None => Err(self),
-        }
-    }
-}
-
-impl fmt::Debug for CoveringNode<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("NodeWithAncestors")
-            .field(&self.node)
-            .finish()
-    }
-}

crates/red_knot_ide/src/goto.rs

@@ -1,851 +0,0 @@
-use crate::find_node::covering_node;
-use crate::{Db, HasNavigationTargets, NavigationTargets, RangedValue};
-use red_knot_python_semantic::types::Type;
-use red_knot_python_semantic::{HasType, SemanticModel};
-use ruff_db::files::{File, FileRange};
-use ruff_db::parsed::{parsed_module, ParsedModule};
-use ruff_python_ast::{self as ast, AnyNodeRef};
-use ruff_python_parser::TokenKind;
-use ruff_text_size::{Ranged, TextRange, TextSize};
-
-pub fn goto_type_definition(
-    db: &dyn Db,
-    file: File,
-    offset: TextSize,
-) -> Option<RangedValue<NavigationTargets>> {
-    let parsed = parsed_module(db.upcast(), file);
-    let goto_target = find_goto_target(parsed, offset)?;
-
-    let model = SemanticModel::new(db.upcast(), file);
-    let ty = goto_target.inferred_type(&model)?;
-
-    tracing::debug!(
-        "Inferred type of covering node is {}",
-        ty.display(db.upcast())
-    );
-
-    let navigation_targets = ty.navigation_targets(db);
-
-    Some(RangedValue {
-        range: FileRange::new(file, goto_target.range()),
-        value: navigation_targets,
-    })
-}
-
-#[derive(Clone, Copy, Debug)]
-pub(crate) enum GotoTarget<'a> {
-    Expression(ast::ExprRef<'a>),
-    FunctionDef(&'a ast::StmtFunctionDef),
-    ClassDef(&'a ast::StmtClassDef),
-    Parameter(&'a ast::Parameter),
-    Alias(&'a ast::Alias),
-
-    /// Go to on the module name of an import from
-    /// ```py
-    /// from foo import bar
-    ///      ^^^
-    /// ```
-    ImportedModule(&'a ast::StmtImportFrom),
-
-    /// Go to on the exception handler variable
-    /// ```py
-    /// try: ...
-    /// except Exception as e: ...
-    ///                     ^
-    /// ```
-    ExceptVariable(&'a ast::ExceptHandlerExceptHandler),
-
-    /// Go to on a keyword argument
-    /// ```py
-    /// test(a = 1)
-    ///      ^
-    /// ```
-    KeywordArgument(&'a ast::Keyword),
-
-    /// Go to on the rest parameter of a pattern match
-    ///
-    /// ```py
-    /// match x:
-    ///     case {"a": a, "b": b, **rest}: ...
-    ///                             ^^^^
-    /// ```
-    PatternMatchRest(&'a ast::PatternMatchMapping),
-
-    /// Go to on a keyword argument of a class pattern
-    ///
-    /// ```py
-    /// match Point3D(0, 0, 0):
-    ///     case Point3D(x=0, y=0, z=0): ...
-    ///                  ^    ^    ^
-    /// ```
-    PatternKeywordArgument(&'a ast::PatternKeyword),
-
-    /// Go to on a pattern star argument
-    ///
-    /// ```py
-    /// match array:
-    ///     case [*args]: ...
-    ///            ^^^^
-    PatternMatchStarName(&'a ast::PatternMatchStar),
-
-    /// Go to on the name of a pattern match as pattern
-    ///
-    /// ```py
-    /// match x:
-    ///     case [x] as y: ...
-    ///                 ^
-    PatternMatchAsName(&'a ast::PatternMatchAs),
-
-    /// Go to on the name of a type variable
-    ///
-    /// ```py
-    /// type Alias[T: int = bool] = list[T]
-    ///            ^
-    /// ```
-    TypeParamTypeVarName(&'a ast::TypeParamTypeVar),
-
-    /// Go to on the name of a type param spec
-    ///
-    /// ```py
-    /// type Alias[**P = [int, str]] = Callable[P, int]
-    ///              ^
-    /// ```
-    TypeParamParamSpecName(&'a ast::TypeParamParamSpec),
-
-    /// Go to on the name of a type var tuple
-    ///
-    /// ```py
-    /// type Alias[*Ts = ()] = tuple[*Ts]
-    ///             ^^
-    /// ```
-    TypeParamTypeVarTupleName(&'a ast::TypeParamTypeVarTuple),
-
-    NonLocal {
-        identifier: &'a ast::Identifier,
-    },
-    Globals {
-        identifier: &'a ast::Identifier,
-    },
-}
-
-impl<'db> GotoTarget<'db> {
-    pub(crate) fn inferred_type(self, model: &SemanticModel<'db>) -> Option<Type<'db>> {
-        let ty = match self {
-            GotoTarget::Expression(expression) => expression.inferred_type(model),
-            GotoTarget::FunctionDef(function) => function.inferred_type(model),
-            GotoTarget::ClassDef(class) => class.inferred_type(model),
-            GotoTarget::Parameter(parameter) => parameter.inferred_type(model),
-            GotoTarget::Alias(alias) => alias.inferred_type(model),
-            GotoTarget::ExceptVariable(except) => except.inferred_type(model),
-            GotoTarget::KeywordArgument(argument) => {
-                // TODO: Pyright resolves the declared type of the matching parameter. This seems more accurate
-                // than using the inferred value.
-                argument.value.inferred_type(model)
-            }
-            // TODO: Support identifier targets
-            GotoTarget::PatternMatchRest(_)
-            | GotoTarget::PatternKeywordArgument(_)
-            | GotoTarget::PatternMatchStarName(_)
-            | GotoTarget::PatternMatchAsName(_)
-            | GotoTarget::ImportedModule(_)
-            | GotoTarget::TypeParamTypeVarName(_)
-            | GotoTarget::TypeParamParamSpecName(_)
-            | GotoTarget::TypeParamTypeVarTupleName(_)
-            | GotoTarget::NonLocal { .. }
-            | GotoTarget::Globals { .. } => return None,
-        };
-
-        Some(ty)
-    }
-}
-
-impl Ranged for GotoTarget<'_> {
-    fn range(&self) -> TextRange {
-        match self {
-            GotoTarget::Expression(expression) => expression.range(),
-            GotoTarget::FunctionDef(function) => function.name.range,
-            GotoTarget::ClassDef(class) => class.name.range,
-            GotoTarget::Parameter(parameter) => parameter.name.range,
-            GotoTarget::Alias(alias) => alias.name.range,
-            GotoTarget::ImportedModule(module) => module.module.as_ref().unwrap().range,
-            GotoTarget::ExceptVariable(except) => except.name.as_ref().unwrap().range,
-            GotoTarget::KeywordArgument(keyword) => keyword.arg.as_ref().unwrap().range,
-            GotoTarget::PatternMatchRest(rest) => rest.rest.as_ref().unwrap().range,
-            GotoTarget::PatternKeywordArgument(keyword) => keyword.attr.range,
-            GotoTarget::PatternMatchStarName(star) => star.name.as_ref().unwrap().range,
-            GotoTarget::PatternMatchAsName(as_name) => as_name.name.as_ref().unwrap().range,
-            GotoTarget::TypeParamTypeVarName(type_var) => type_var.name.range,
-            GotoTarget::TypeParamParamSpecName(spec) => spec.name.range,
-            GotoTarget::TypeParamTypeVarTupleName(tuple) => tuple.name.range,
-            GotoTarget::NonLocal { identifier, .. } => identifier.range,
-            GotoTarget::Globals { identifier, .. } => identifier.range,
-        }
-    }
-}
-
-pub(crate) fn find_goto_target(parsed: &ParsedModule, offset: TextSize) -> Option<GotoTarget> {
-    let token = parsed
-        .tokens()
-        .at_offset(offset)
-        .max_by_key(|token| match token.kind() {
-            TokenKind::Name
-            | TokenKind::String
-            | TokenKind::Complex
-            | TokenKind::Float
-            | TokenKind::Int => 1,
-            _ => 0,
-        })?;
-
-    let covering_node = covering_node(parsed.syntax().into(), token.range())
-        .find(|node| node.is_identifier() || node.is_expression())
-        .ok()?;
-
-    tracing::trace!("Covering node is of kind {:?}", covering_node.node().kind());
-
-    match covering_node.node() {
-        AnyNodeRef::Identifier(identifier) => match covering_node.parent() {
-            Some(AnyNodeRef::StmtFunctionDef(function)) => Some(GotoTarget::FunctionDef(function)),
-            Some(AnyNodeRef::StmtClassDef(class)) => Some(GotoTarget::ClassDef(class)),
-            Some(AnyNodeRef::Parameter(parameter)) => Some(GotoTarget::Parameter(parameter)),
-            Some(AnyNodeRef::Alias(alias)) => Some(GotoTarget::Alias(alias)),
-            Some(AnyNodeRef::StmtImportFrom(from)) => Some(GotoTarget::ImportedModule(from)),
-            Some(AnyNodeRef::ExceptHandlerExceptHandler(handler)) => {
-                Some(GotoTarget::ExceptVariable(handler))
-            }
-            Some(AnyNodeRef::Keyword(keyword)) => Some(GotoTarget::KeywordArgument(keyword)),
-            Some(AnyNodeRef::PatternMatchMapping(mapping)) => {
-                Some(GotoTarget::PatternMatchRest(mapping))
-            }
-            Some(AnyNodeRef::PatternKeyword(keyword)) => {
-                Some(GotoTarget::PatternKeywordArgument(keyword))
-            }
-            Some(AnyNodeRef::PatternMatchStar(star)) => {
-                Some(GotoTarget::PatternMatchStarName(star))
-            }
-            Some(AnyNodeRef::PatternMatchAs(as_pattern)) => {
-                Some(GotoTarget::PatternMatchAsName(as_pattern))
-            }
-            Some(AnyNodeRef::TypeParamTypeVar(var)) => Some(GotoTarget::TypeParamTypeVarName(var)),
-            Some(AnyNodeRef::TypeParamParamSpec(bound)) => {
-                Some(GotoTarget::TypeParamParamSpecName(bound))
-            }
-            Some(AnyNodeRef::TypeParamTypeVarTuple(var_tuple)) => {
-                Some(GotoTarget::TypeParamTypeVarTupleName(var_tuple))
-            }
-            Some(AnyNodeRef::ExprAttribute(attribute)) => {
-                Some(GotoTarget::Expression(attribute.into()))
-            }
-            Some(AnyNodeRef::StmtNonlocal(_)) => Some(GotoTarget::NonLocal { identifier }),
-            Some(AnyNodeRef::StmtGlobal(_)) => Some(GotoTarget::Globals { identifier }),
-            None => None,
-            Some(parent) => {
-                tracing::debug!(
-                    "Missing `GoToTarget` for identifier with parent {:?}",
-                    parent.kind()
-                );
-                None
-            }
-        },
-
-        node => node.as_expr_ref().map(GotoTarget::Expression),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::tests::{cursor_test, CursorTest, IntoDiagnostic};
-    use crate::{goto_type_definition, NavigationTarget};
-    use insta::assert_snapshot;
-    use ruff_db::diagnostic::{
-        Annotation, Diagnostic, DiagnosticId, LintName, Severity, Span, SubDiagnostic,
-    };
-    use ruff_db::files::FileRange;
-    use ruff_text_size::Ranged;
-
-    #[test]
-    fn goto_type_of_expression_with_class_type() {
-        let test = cursor_test(
-            r#"
-            class Test: ...
-
-            a<CURSOR>b = Test()
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-         --> /main.py:2:19
-          |
-        2 |             class Test: ...
-          |                   ^^^^
-        3 |
-        4 |             ab = Test()
-          |
-        info: Source
-         --> /main.py:4:13
-          |
-        2 |             class Test: ...
-        3 |
-        4 |             ab = Test()
-          |             ^^
-          |
-        "###);
-    }
-
-    #[test]
-    fn goto_type_of_expression_with_function_type() {
-        let test = cursor_test(
-            r#"
-            def foo(a, b): ...
-
-            ab = foo
-
-            a<CURSOR>b
-        "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-         --> /main.py:2:17
-          |
-        2 |             def foo(a, b): ...
-          |                 ^^^
-        3 |
-        4 |             ab = foo
-          |
-        info: Source
-         --> /main.py:6:13
-          |
-        4 |             ab = foo
-        5 |
-        6 |             ab
-          |             ^^
-          |
-        "###);
-    }
-
-    #[test]
-    fn goto_type_of_expression_with_union_type() {
-        let test = cursor_test(
-            r#"
-
-            def foo(a, b): ...
-
-            def bar(a, b): ...
-
-            if random.choice():
-                a = foo
-            else:
-                a = bar
-
-            a<CURSOR>
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r"
-        info: lint:goto-type-definition: Type definition
-         --> /main.py:3:17
-          |
-        3 |             def foo(a, b): ...
-          |                 ^^^
-        4 |
-        5 |             def bar(a, b): ...
-          |
-        info: Source
-          --> /main.py:12:13
-           |
-        10 |                 a = bar
-        11 |
-        12 |             a
-           |             ^
-           |
-
-        info: lint:goto-type-definition: Type definition
-         --> /main.py:5:17
-          |
-        3 |             def foo(a, b): ...
-        4 |
-        5 |             def bar(a, b): ...
-          |                 ^^^
-        6 |
-        7 |             if random.choice():
-          |
-        info: Source
-          --> /main.py:12:13
-           |
-        10 |                 a = bar
-        11 |
-        12 |             a
-           |             ^
-           |
-        ");
-    }
-
-    #[test]
-    fn goto_type_of_expression_with_module() {
-        let mut test = cursor_test(
-            r#"
-            import lib
-
-            lib<CURSOR>
-            "#,
-        );
-
-        test.write_file("lib.py", "a = 10").unwrap();
-
-        assert_snapshot!(test.goto_type_definition(), @r"
-        info: lint:goto-type-definition: Type definition
-         --> /lib.py:1:1
-          |
-        1 | a = 10
-          | ^^^^^^
-          |
-        info: Source
-         --> /main.py:4:13
-          |
-        2 |             import lib
-        3 |
-        4 |             lib
-          |             ^^^
-          |
-        ");
-    }
-
-    #[test]
-    fn goto_type_of_expression_with_literal_type() {
-        let test = cursor_test(
-            r#"
-            a: str = "test"
-
-            a<CURSOR>
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:443:7
-            |
-        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        442 |
-        443 | class str(Sequence[str]):
-            |       ^^^
-        444 |     @overload
-        445 |     def __new__(cls, object: object = ...) -> Self: ...
-            |
-        info: Source
-         --> /main.py:4:13
-          |
-        2 |             a: str = "test"
-        3 |
-        4 |             a
-          |             ^
-          |
-        "###);
-    }
-    #[test]
-    fn goto_type_of_expression_with_literal_node() {
-        let test = cursor_test(
-            r#"
-            a: str = "te<CURSOR>st"
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:443:7
-            |
-        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        442 |
-        443 | class str(Sequence[str]):
-            |       ^^^
-        444 |     @overload
-        445 |     def __new__(cls, object: object = ...) -> Self: ...
-            |
-        info: Source
-         --> /main.py:2:22
-          |
-        2 |             a: str = "test"
-          |                      ^^^^^^
-          |
-        "###);
-    }
-
-    #[test]
-    fn goto_type_of_expression_with_type_var_type() {
-        let test = cursor_test(
-            r#"
-            type Alias[T: int = bool] = list[T<CURSOR>]
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-         --> /main.py:2:24
-          |
-        2 |             type Alias[T: int = bool] = list[T]
-          |                        ^
-          |
-        info: Source
-         --> /main.py:2:46
-          |
-        2 |             type Alias[T: int = bool] = list[T]
-          |                                              ^
-          |
-        "###);
-    }
-
-    #[test]
-    fn goto_type_of_expression_with_type_param_spec() {
-        let test = cursor_test(
-            r#"
-            type Alias[**P = [int, str]] = Callable[P<CURSOR>, int]
-            "#,
-        );
-
-        // TODO: Goto type definition currently doesn't work for type param specs
-        // because the inference doesn't support them yet.
-        // This snapshot should show a single target pointing to `T`
-        assert_snapshot!(test.goto_type_definition(), @"No type definitions found");
-    }
-
-    #[test]
-    fn goto_type_of_expression_with_type_var_tuple() {
-        let test = cursor_test(
-            r#"
-            type Alias[*Ts = ()] = tuple[*Ts<CURSOR>]
-            "#,
-        );
-
-        // TODO: Goto type definition currently doesn't work for type var tuples
-        // because the inference doesn't support them yet.
-        // This snapshot should show a single target pointing to `T`
-        assert_snapshot!(test.goto_type_definition(), @"No type definitions found");
-    }
-
-    #[test]
-    fn goto_type_on_keyword_argument() {
-        let test = cursor_test(
-            r#"
-            def test(a: str): ...
-
-            test(a<CURSOR>= "123")
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:443:7
-            |
-        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        442 |
-        443 | class str(Sequence[str]):
-            |       ^^^
-        444 |     @overload
-        445 |     def __new__(cls, object: object = ...) -> Self: ...
-            |
-        info: Source
-         --> /main.py:4:18
-          |
-        2 |             def test(a: str): ...
-        3 |
-        4 |             test(a= "123")
-          |                  ^
-          |
-        "###);
-    }
-
-    #[test]
-    fn goto_type_on_incorrectly_typed_keyword_argument() {
-        let test = cursor_test(
-            r#"
-            def test(a: str): ...
-
-            test(a<CURSOR>= 123)
-            "#,
-        );
-
-        // TODO: This should jump to `str` and not `int` because
-        //   the keyword is typed as a string. It's only the passed argument that
-        //   is an int. Navigating to `str` would match pyright's behavior.
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:234:7
-            |
-        232 | _LiteralInteger = _PositiveInteger | _NegativeInteger | Literal[0]  # noqa: Y026  # TODO: Use TypeAlias once mypy bugs are fixed
-        233 |
-        234 | class int:
-            |       ^^^
-        235 |     @overload
-        236 |     def __new__(cls, x: ConvertibleToInt = ..., /) -> Self: ...
-            |
-        info: Source
-         --> /main.py:4:18
-          |
-        2 |             def test(a: str): ...
-        3 |
-        4 |             test(a= 123)
-          |                  ^
-          |
-        "###);
-    }
-
-    #[test]
-    fn goto_type_on_kwargs() {
-        let test = cursor_test(
-            r#"
-            def f(name: str): ...
-
-kwargs = { "name": "test"}
-
-f(**kwargs<CURSOR>)
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-            --> stdlib/builtins.pyi:1098:7
-             |
-        1096 |         def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
-        1097 |
-        1098 | class dict(MutableMapping[_KT, _VT]):
-             |       ^^^^
-        1099 |     # __init__ should be kept roughly in line with `collections.UserDict.__init__`, which has similar semantics
-        1100 |     # Also multiprocessing.managers.SyncManager.dict()
-             |
-        info: Source
-         --> /main.py:6:5
-          |
-        4 | kwargs = { "name": "test"}
-        5 |
-        6 | f(**kwargs)
-          |     ^^^^^^
-          |
-        "###);
-    }
-
-    #[test]
-    fn goto_type_of_expression_with_builtin() {
-        let test = cursor_test(
-            r#"
-            def foo(a: str):
-                a<CURSOR>
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:443:7
-            |
-        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        442 |
-        443 | class str(Sequence[str]):
-            |       ^^^
-        444 |     @overload
-        445 |     def __new__(cls, object: object = ...) -> Self: ...
-            |
-        info: Source
-         --> /main.py:3:17
-          |
-        2 |             def foo(a: str):
-        3 |                 a
-          |                 ^
-          |
-        "###);
-    }
-
-    #[test]
-    fn goto_type_definition_cursor_between_object_and_attribute() {
-        let test = cursor_test(
-            r#"
-            class X:
-                def foo(a, b): ...
-
-            x = X()
-
-            x<CURSOR>.foo()
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-         --> /main.py:2:19
-          |
-        2 |             class X:
-          |                   ^
-        3 |                 def foo(a, b): ...
-          |
-        info: Source
-         --> /main.py:7:13
-          |
-        5 |             x = X()
-        6 |
-        7 |             x.foo()
-          |             ^
-          |
-        "###);
-    }
-
-    #[test]
-    fn goto_between_call_arguments() {
-        let test = cursor_test(
-            r#"
-            def foo(a, b): ...
-
-            foo<CURSOR>()
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-         --> /main.py:2:17
-          |
-        2 |             def foo(a, b): ...
-          |                 ^^^
-        3 |
-        4 |             foo()
-          |
-        info: Source
-         --> /main.py:4:13
-          |
-        2 |             def foo(a, b): ...
-        3 |
-        4 |             foo()
-          |             ^^^
-          |
-        "###);
-    }
-
-    #[test]
-    fn goto_type_narrowing() {
-        let test = cursor_test(
-            r#"
-            def foo(a: str | None, b):
-                if a is not None:
-                    print(a<CURSOR>)
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r###"
-        info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:443:7
-            |
-        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        442 |
-        443 | class str(Sequence[str]):
-            |       ^^^
-        444 |     @overload
-        445 |     def __new__(cls, object: object = ...) -> Self: ...
-            |
-        info: Source
-         --> /main.py:4:27
-          |
-        2 |             def foo(a: str | None, b):
-        3 |                 if a is not None:
-        4 |                     print(a)
-          |                           ^
-          |
-        "###);
-    }
-
-    #[test]
-    fn goto_type_none() {
-        let test = cursor_test(
-            r#"
-            def foo(a: str | None, b):
-                a<CURSOR>
-            "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r"
-        info: lint:goto-type-definition: Type definition
-           --> stdlib/types.pyi:677:11
-            |
-        675 | if sys.version_info >= (3, 10):
-        676 |     @final
-        677 |     class NoneType:
-            |           ^^^^^^^^
-        678 |         def __bool__(self) -> Literal[False]: ...
-            |
-        info: Source
-         --> /main.py:3:17
-          |
-        2 |             def foo(a: str | None, b):
-        3 |                 a
-          |                 ^
-          |
-
-        info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:443:7
-            |
-        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        442 |
-        443 | class str(Sequence[str]):
-            |       ^^^
-        444 |     @overload
-        445 |     def __new__(cls, object: object = ...) -> Self: ...
-            |
-        info: Source
-         --> /main.py:3:17
-          |
-        2 |             def foo(a: str | None, b):
-        3 |                 a
-          |                 ^
-          |
-        ");
-    }
-
-    impl CursorTest {
-        fn goto_type_definition(&self) -> String {
-            let Some(targets) = goto_type_definition(&self.db, self.file, self.cursor_offset)
-            else {
-                return "No goto target found".to_string();
-            };
-
-            if targets.is_empty() {
-                return "No type definitions found".to_string();
-            }
-
-            let source = targets.range;
-            self.render_diagnostics(
-                targets
-                    .into_iter()
-                    .map(|target| GotoTypeDefinitionDiagnostic::new(source, &target)),
-            )
-        }
-    }
-
-    struct GotoTypeDefinitionDiagnostic {
-        source: FileRange,
-        target: FileRange,
-    }
-
-    impl GotoTypeDefinitionDiagnostic {
-        fn new(source: FileRange, target: &NavigationTarget) -> Self {
-            Self {
-                source,
-                target: FileRange::new(target.file(), target.focus_range()),
-            }
-        }
-    }
-
-    impl IntoDiagnostic for GotoTypeDefinitionDiagnostic {
-        fn into_diagnostic(self) -> Diagnostic {
-            let mut source = SubDiagnostic::new(Severity::Info, "Source");
-            source.annotate(Annotation::primary(
-                Span::from(self.source.file()).with_range(self.source.range()),
-            ));
-
-            let mut main = Diagnostic::new(
-                DiagnosticId::Lint(LintName::of("goto-type-definition")),
-                Severity::Info,
-                "Type definition".to_string(),
-            );
-            main.annotate(Annotation::primary(
-                Span::from(self.target.file()).with_range(self.target.range()),
-            ));
-            main.sub(source);
-
-            main
-        }
-    }
-}

crates/red_knot_ide/src/hover.rs

@@ -1,602 +0,0 @@
-use crate::goto::{find_goto_target, GotoTarget};
-use crate::{Db, MarkupKind, RangedValue};
-use red_knot_python_semantic::types::Type;
-use red_knot_python_semantic::SemanticModel;
-use ruff_db::files::{File, FileRange};
-use ruff_db::parsed::parsed_module;
-use ruff_text_size::{Ranged, TextSize};
-use std::fmt;
-use std::fmt::Formatter;
-
-pub fn hover(db: &dyn Db, file: File, offset: TextSize) -> Option<RangedValue<Hover>> {
-    let parsed = parsed_module(db.upcast(), file);
-    let goto_target = find_goto_target(parsed, offset)?;
-
-    if let GotoTarget::Expression(expr) = goto_target {
-        if expr.is_literal_expr() {
-            return None;
-        }
-    }
-
-    let model = SemanticModel::new(db.upcast(), file);
-    let ty = goto_target.inferred_type(&model)?;
-
-    tracing::debug!(
-        "Inferred type of covering node is {}",
-        ty.display(db.upcast())
-    );
-
-    // TODO: Add documentation of the symbol (not the type's definition).
-    // TODO: Render the symbol's signature instead of just its type.
-    let contents = vec![HoverContent::Type(ty)];
-
-    Some(RangedValue {
-        range: FileRange::new(file, goto_target.range()),
-        value: Hover { contents },
-    })
-}
-
-pub struct Hover<'db> {
-    contents: Vec<HoverContent<'db>>,
-}
-
-impl<'db> Hover<'db> {
-    /// Renders the hover to a string using the specified markup kind.
-    pub const fn display<'a>(&'a self, db: &'a dyn Db, kind: MarkupKind) -> DisplayHover<'a> {
-        DisplayHover {
-            db,
-            hover: self,
-            kind,
-        }
-    }
-
-    fn iter(&self) -> std::slice::Iter<'_, HoverContent<'db>> {
-        self.contents.iter()
-    }
-}
-
-impl<'db> IntoIterator for Hover<'db> {
-    type Item = HoverContent<'db>;
-    type IntoIter = std::vec::IntoIter<Self::Item>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.contents.into_iter()
-    }
-}
-
-impl<'a, 'db> IntoIterator for &'a Hover<'db> {
-    type Item = &'a HoverContent<'db>;
-    type IntoIter = std::slice::Iter<'a, HoverContent<'db>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
-pub struct DisplayHover<'a> {
-    db: &'a dyn Db,
-    hover: &'a Hover<'a>,
-    kind: MarkupKind,
-}
-
-impl fmt::Display for DisplayHover<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let mut first = true;
-        for content in &self.hover.contents {
-            if !first {
-                self.kind.horizontal_line().fmt(f)?;
-            }
-
-            content.display(self.db, self.kind).fmt(f)?;
-            first = false;
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum HoverContent<'db> {
-    Type(Type<'db>),
-}
-
-impl<'db> HoverContent<'db> {
-    fn display(&self, db: &'db dyn Db, kind: MarkupKind) -> DisplayHoverContent<'_, 'db> {
-        DisplayHoverContent {
-            db,
-            content: self,
-            kind,
-        }
-    }
-}
-
-pub(crate) struct DisplayHoverContent<'a, 'db> {
-    db: &'db dyn Db,
-    content: &'a HoverContent<'db>,
-    kind: MarkupKind,
-}
-
-impl fmt::Display for DisplayHoverContent<'_, '_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.content {
-            HoverContent::Type(ty) => self
-                .kind
-                .fenced_code_block(ty.display(self.db.upcast()), "text")
-                .fmt(f),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::tests::{cursor_test, CursorTest};
-    use crate::{hover, MarkupKind};
-    use insta::assert_snapshot;
-    use ruff_db::diagnostic::{
-        Annotation, Diagnostic, DiagnosticFormat, DiagnosticId, DisplayDiagnosticConfig, LintName,
-        Severity, Span,
-    };
-    use ruff_text_size::{Ranged, TextRange};
-
-    #[test]
-    fn hover_basic() {
-        let test = cursor_test(
-            r#"
-        a = 10
-
-        a<CURSOR>
-        "#,
-        );
-
-        assert_snapshot!(test.hover(), @r"
-        Literal[10]
-        ---------------------------------------------
-        ```text
-        Literal[10]
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-         --> /main.py:4:9
-          |
-        2 |         a = 10
-        3 |
-        4 |         a
-          |         ^- Cursor offset
-          |         |
-          |         source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_member() {
-        let test = cursor_test(
-            r#"
-        class Foo:
-            a: int = 10
-
-            def __init__(a: int, b: str):
-                self.a = a
-                self.b: str = b
-
-        foo = Foo()
-        foo.<CURSOR>a
-        "#,
-        );
-
-        assert_snapshot!(test.hover(), @r"
-        int
-        ---------------------------------------------
-        ```text
-        int
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-          --> /main.py:10:9
-           |
-         9 |         foo = Foo()
-        10 |         foo.a
-           |         ^^^^-
-           |         |   |
-           |         |   Cursor offset
-           |         source
-           |
-        ");
-    }
-
-    #[test]
-    fn hover_function_typed_variable() {
-        let test = cursor_test(
-            r#"
-            def foo(a, b): ...
-
-            foo<CURSOR>
-        "#,
-        );
-
-        assert_snapshot!(test.hover(), @r"
-        Literal[foo]
-        ---------------------------------------------
-        ```text
-        Literal[foo]
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-         --> /main.py:4:13
-          |
-        2 |             def foo(a, b): ...
-        3 |
-        4 |             foo
-          |             ^^^- Cursor offset
-          |             |
-          |             source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_binary_expression() {
-        let test = cursor_test(
-            r#"
-            def foo(a: int, b: int, c: int):
-                a + b ==<CURSOR> c
-        "#,
-        );
-
-        assert_snapshot!(test.hover(), @r"
-        bool
-        ---------------------------------------------
-        ```text
-        bool
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-         --> /main.py:3:17
-          |
-        2 |             def foo(a: int, b: int, c: int):
-        3 |                 a + b == c
-          |                 ^^^^^^^^-^
-          |                 |       |
-          |                 |       Cursor offset
-          |                 source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_keyword_parameter() {
-        let test = cursor_test(
-            r#"
-            def test(a: int): ...
-
-            test(a<CURSOR>= 123)
-            "#,
-        );
-
-        // TODO: This should reveal `int` because the user hovers over the parameter and not the value.
-        assert_snapshot!(test.hover(), @r"
-        Literal[123]
-        ---------------------------------------------
-        ```text
-        Literal[123]
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-         --> /main.py:4:18
-          |
-        2 |             def test(a: int): ...
-        3 |
-        4 |             test(a= 123)
-          |                  ^- Cursor offset
-          |                  |
-          |                  source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_union() {
-        let test = cursor_test(
-            r#"
-
-            def foo(a, b): ...
-
-            def bar(a, b): ...
-
-            if random.choice([True, False]):
-                a = foo
-            else:
-                a = bar
-
-            a<CURSOR>
-            "#,
-        );
-
-        assert_snapshot!(test.hover(), @r"
-        Literal[foo, bar]
-        ---------------------------------------------
-        ```text
-        Literal[foo, bar]
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-          --> /main.py:12:13
-           |
-        10 |                 a = bar
-        11 |
-        12 |             a
-           |             ^- Cursor offset
-           |             |
-           |             source
-           |
-        ");
-    }
-
-    #[test]
-    fn hover_module() {
-        let mut test = cursor_test(
-            r#"
-            import lib
-
-            li<CURSOR>b
-            "#,
-        );
-
-        test.write_file("lib.py", "a = 10").unwrap();
-
-        assert_snapshot!(test.hover(), @r"
-        <module 'lib'>
-        ---------------------------------------------
-        ```text
-        <module 'lib'>
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-         --> /main.py:4:13
-          |
-        2 |             import lib
-        3 |
-        4 |             lib
-          |             ^^-
-          |             | |
-          |             | Cursor offset
-          |             source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_type_of_expression_with_type_var_type() {
-        let test = cursor_test(
-            r#"
-            type Alias[T: int = bool] = list[T<CURSOR>]
-            "#,
-        );
-
-        assert_snapshot!(test.hover(), @r"
-        T
-        ---------------------------------------------
-        ```text
-        T
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-         --> /main.py:2:46
-          |
-        2 |             type Alias[T: int = bool] = list[T]
-          |                                              ^- Cursor offset
-          |                                              |
-          |                                              source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_type_of_expression_with_type_param_spec() {
-        let test = cursor_test(
-            r#"
-            type Alias[**P = [int, str]] = Callable[P<CURSOR>, int]
-            "#,
-        );
-
-        assert_snapshot!(test.hover(), @r"
-        @Todo
-        ---------------------------------------------
-        ```text
-        @Todo
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-         --> /main.py:2:53
-          |
-        2 |             type Alias[**P = [int, str]] = Callable[P, int]
-          |                                                     ^- Cursor offset
-          |                                                     |
-          |                                                     source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_type_of_expression_with_type_var_tuple() {
-        let test = cursor_test(
-            r#"
-            type Alias[*Ts = ()] = tuple[*Ts<CURSOR>]
-            "#,
-        );
-
-        assert_snapshot!(test.hover(), @r"
-        @Todo
-        ---------------------------------------------
-        ```text
-        @Todo
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-         --> /main.py:2:43
-          |
-        2 |             type Alias[*Ts = ()] = tuple[*Ts]
-          |                                           ^^- Cursor offset
-          |                                           |
-          |                                           source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_class_member_declaration() {
-        let test = cursor_test(
-            r#"
-        class Foo:
-            a<CURSOR>: int
-        "#,
-        );
-
-        // TODO: This should be int and not `Never`, https://github.com/astral-sh/ruff/issues/17122
-        assert_snapshot!(test.hover(), @r"
-        Never
-        ---------------------------------------------
-        ```text
-        Never
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-         --> /main.py:3:13
-          |
-        2 |         class Foo:
-        3 |             a: int
-          |             ^- Cursor offset
-          |             |
-          |             source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_type_narrowing() {
-        let test = cursor_test(
-            r#"
-            def foo(a: str | None, b):
-                if a is not None:
-                    print(a<CURSOR>)
-            "#,
-        );
-
-        assert_snapshot!(test.hover(), @r"
-        str
-        ---------------------------------------------
-        ```text
-        str
-        ```
-        ---------------------------------------------
-        info: lint:hover: Hovered content is
-         --> /main.py:4:27
-          |
-        2 |             def foo(a: str | None, b):
-        3 |                 if a is not None:
-        4 |                     print(a)
-          |                           ^- Cursor offset
-          |                           |
-          |                           source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_whitespace() {
-        let test = cursor_test(
-            r#"
-        class C:
-            <CURSOR>
-            foo: str = 'bar'
-        "#,
-        );
-
-        assert_snapshot!(test.hover(), @"Hover provided no content");
-    }
-
-    #[test]
-    fn hover_literal_int() {
-        let test = cursor_test(
-            r#"
-        print(
-            0 + 1<CURSOR>
-        )
-        "#,
-        );
-
-        assert_snapshot!(test.hover(), @"Hover provided no content");
-    }
-
-    #[test]
-    fn hover_literal_ellipsis() {
-        let test = cursor_test(
-            r#"
-        print(
-            .<CURSOR>..
-        )
-        "#,
-        );
-
-        assert_snapshot!(test.hover(), @"Hover provided no content");
-    }
-
-    #[test]
-    fn hover_docstring() {
-        let test = cursor_test(
-            r#"
-        def f():
-            """Lorem ipsum dolor sit amet.<CURSOR>"""
-        "#,
-        );
-
-        assert_snapshot!(test.hover(), @"Hover provided no content");
-    }
-
-    impl CursorTest {
-        fn hover(&self) -> String {
-            use std::fmt::Write;
-
-            let Some(hover) = hover(&self.db, self.file, self.cursor_offset) else {
-                return "Hover provided no content".to_string();
-            };
-
-            let source = hover.range;
-
-            let mut buf = String::new();
-
-            write!(
-                &mut buf,
-                "{plaintext}{line}{markdown}{line}",
-                plaintext = hover.display(&self.db, MarkupKind::PlainText),
-                line = MarkupKind::PlainText.horizontal_line(),
-                markdown = hover.display(&self.db, MarkupKind::Markdown),
-            )
-            .unwrap();
-
-            let config = DisplayDiagnosticConfig::default()
-                .color(false)
-                .format(DiagnosticFormat::Full);
-
-            let mut diagnostic = Diagnostic::new(
-                DiagnosticId::Lint(LintName::of("hover")),
-                Severity::Info,
-                "Hovered content is",
-            );
-            diagnostic.annotate(
-                Annotation::primary(Span::from(source.file()).with_range(source.range()))
-                    .message("source"),
-            );
-            diagnostic.annotate(
-                Annotation::secondary(
-                    Span::from(source.file()).with_range(TextRange::empty(self.cursor_offset)),
-                )
-                .message("Cursor offset"),
-            );
-
-            write!(buf, "{}", diagnostic.display(&self.db, &config)).unwrap();
-
-            buf
-        }
-    }
-}

crates/red_knot_ide/src/inlay_hints.rs

@@ -1,279 +0,0 @@
-use crate::Db;
-use red_knot_python_semantic::types::Type;
-use red_knot_python_semantic::{HasType, SemanticModel};
-use ruff_db::files::File;
-use ruff_db::parsed::parsed_module;
-use ruff_python_ast::visitor::source_order::{self, SourceOrderVisitor, TraversalSignal};
-use ruff_python_ast::{AnyNodeRef, Expr, Stmt};
-use ruff_text_size::{Ranged, TextRange, TextSize};
-use std::fmt;
-use std::fmt::Formatter;
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct InlayHint<'db> {
-    pub position: TextSize,
-    pub content: InlayHintContent<'db>,
-}
-
-impl<'db> InlayHint<'db> {
-    pub const fn display(&self, db: &'db dyn Db) -> DisplayInlayHint<'_, 'db> {
-        self.content.display(db)
-    }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum InlayHintContent<'db> {
-    Type(Type<'db>),
-    ReturnType(Type<'db>),
-}
-
-impl<'db> InlayHintContent<'db> {
-    pub const fn display(&self, db: &'db dyn Db) -> DisplayInlayHint<'_, 'db> {
-        DisplayInlayHint { db, hint: self }
-    }
-}
-
-pub struct DisplayInlayHint<'a, 'db> {
-    db: &'db dyn Db,
-    hint: &'a InlayHintContent<'db>,
-}
-
-impl fmt::Display for DisplayInlayHint<'_, '_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self.hint {
-            InlayHintContent::Type(ty) => {
-                write!(f, ": {}", ty.display(self.db.upcast()))
-            }
-            InlayHintContent::ReturnType(ty) => {
-                write!(f, " -> {}", ty.display(self.db.upcast()))
-            }
-        }
-    }
-}
-
-pub fn inlay_hints(db: &dyn Db, file: File, range: TextRange) -> Vec<InlayHint<'_>> {
-    let mut visitor = InlayHintVisitor::new(db, file, range);
-
-    let ast = parsed_module(db.upcast(), file);
-
-    visitor.visit_body(ast.suite());
-
-    visitor.hints
-}
-
-struct InlayHintVisitor<'db> {
-    model: SemanticModel<'db>,
-    hints: Vec<InlayHint<'db>>,
-    in_assignment: bool,
-    range: TextRange,
-}
-
-impl<'db> InlayHintVisitor<'db> {
-    fn new(db: &'db dyn Db, file: File, range: TextRange) -> Self {
-        Self {
-            model: SemanticModel::new(db.upcast(), file),
-            hints: Vec::new(),
-            in_assignment: false,
-            range,
-        }
-    }
-
-    fn add_type_hint(&mut self, position: TextSize, ty: Type<'db>) {
-        self.hints.push(InlayHint {
-            position,
-            content: InlayHintContent::Type(ty),
-        });
-    }
-}
-
-impl SourceOrderVisitor<'_> for InlayHintVisitor<'_> {
-    fn enter_node(&mut self, node: AnyNodeRef<'_>) -> TraversalSignal {
-        if self.range.intersect(node.range()).is_some() {
-            TraversalSignal::Traverse
-        } else {
-            TraversalSignal::Skip
-        }
-    }
-
-    fn visit_stmt(&mut self, stmt: &Stmt) {
-        let node = AnyNodeRef::from(stmt);
-
-        if !self.enter_node(node).is_traverse() {
-            return;
-        }
-
-        match stmt {
-            Stmt::Assign(assign) => {
-                self.in_assignment = true;
-                for target in &assign.targets {
-                    self.visit_expr(target);
-                }
-                self.in_assignment = false;
-
-                return;
-            }
-            // TODO
-            Stmt::FunctionDef(_) => {}
-            Stmt::For(_) => {}
-            Stmt::Expr(_) => {
-                // Don't traverse into expression statements because we don't show any hints.
-                return;
-            }
-            _ => {}
-        }
-
-        source_order::walk_stmt(self, stmt);
-    }
-
-    fn visit_expr(&mut self, expr: &'_ Expr) {
-        if !self.in_assignment {
-            return;
-        }
-
-        match expr {
-            Expr::Name(name) => {
-                if name.ctx.is_store() {
-                    let ty = expr.inferred_type(&self.model);
-                    self.add_type_hint(expr.range().end(), ty);
-                }
-            }
-            _ => {
-                source_order::walk_expr(self, expr);
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use insta::assert_snapshot;
-    use ruff_db::{
-        files::{system_path_to_file, File},
-        source::source_text,
-    };
-    use ruff_text_size::TextSize;
-
-    use crate::db::tests::TestDb;
-
-    use red_knot_python_semantic::{
-        Program, ProgramSettings, PythonPath, PythonPlatform, SearchPathSettings,
-    };
-    use ruff_db::system::{DbWithWritableSystem, SystemPathBuf};
-    use ruff_python_ast::PythonVersion;
-
-    pub(super) fn inlay_hint_test(source: &str) -> InlayHintTest {
-        const START: &str = "<START>";
-        const END: &str = "<END>";
-
-        let mut db = TestDb::new();
-
-        let start = source.find(START);
-        let end = source
-            .find(END)
-            .map(|x| if start.is_some() { x - START.len() } else { x })
-            .unwrap_or(source.len());
-
-        let range = TextRange::new(
-            TextSize::try_from(start.unwrap_or_default()).unwrap(),
-            TextSize::try_from(end).unwrap(),
-        );
-
-        let source = source.replace(START, "");
-        let source = source.replace(END, "");
-
-        db.write_file("main.py", source)
-            .expect("write to memory file system to be successful");
-
-        let file = system_path_to_file(&db, "main.py").expect("newly written file to existing");
-
-        Program::from_settings(
-            &db,
-            ProgramSettings {
-                python_version: PythonVersion::latest(),
-                python_platform: PythonPlatform::default(),
-                search_paths: SearchPathSettings {
-                    extra_paths: vec![],
-                    src_roots: vec![SystemPathBuf::from("/")],
-                    custom_typeshed: None,
-                    python_path: PythonPath::KnownSitePackages(vec![]),
-                },
-            },
-        )
-        .expect("Default settings to be valid");
-
-        InlayHintTest { db, file, range }
-    }
-
-    pub(super) struct InlayHintTest {
-        pub(super) db: TestDb,
-        pub(super) file: File,
-        pub(super) range: TextRange,
-    }
-
-    impl InlayHintTest {
-        fn inlay_hints(&self) -> String {
-            let hints = inlay_hints(&self.db, self.file, self.range);
-
-            let mut buf = source_text(&self.db, self.file).as_str().to_string();
-
-            let mut offset = 0;
-
-            for hint in hints {
-                let end_position = (hint.position.to_u32() as usize) + offset;
-                let hint_str = format!("[{}]", hint.display(&self.db));
-                buf.insert_str(end_position, &hint_str);
-                offset += hint_str.len();
-            }
-
-            buf
-        }
-    }
-
-    #[test]
-    fn test_assign_statement() {
-        let test = inlay_hint_test("x = 1");
-
-        assert_snapshot!(test.inlay_hints(), @r"
-        x[: Literal[1]] = 1
-        ");
-    }
-
-    #[test]
-    fn test_tuple_assignment() {
-        let test = inlay_hint_test("x, y = (1, 'abc')");
-
-        assert_snapshot!(test.inlay_hints(), @r#"
-        x[: Literal[1]], y[: Literal["abc"]] = (1, 'abc')
-        "#);
-    }
-
-    #[test]
-    fn test_nested_tuple_assignment() {
-        let test = inlay_hint_test("x, (y, z) = (1, ('abc', 2))");
-
-        assert_snapshot!(test.inlay_hints(), @r#"
-        x[: Literal[1]], (y[: Literal["abc"]], z[: Literal[2]]) = (1, ('abc', 2))
-        "#);
-    }
-
-    #[test]
-    fn test_assign_statement_with_type_annotation() {
-        let test = inlay_hint_test("x: int = 1");
-
-        assert_snapshot!(test.inlay_hints(), @r"
-        x: int = 1
-        ");
-    }
-
-    #[test]
-    fn test_assign_statement_out_of_range() {
-        let test = inlay_hint_test("<START>x = 1<END>\ny = 2");
-
-        assert_snapshot!(test.inlay_hints(), @r"
-        x[: Literal[1]] = 1
-        y = 2
-        ");
-    }
-}

crates/red_knot_ide/src/lib.rs

@@ -1,296 +0,0 @@
-mod db;
-mod find_node;
-mod goto;
-mod hover;
-mod inlay_hints;
-mod markup;
-
-pub use db::Db;
-pub use goto::goto_type_definition;
-pub use hover::hover;
-pub use inlay_hints::inlay_hints;
-pub use markup::MarkupKind;
-
-use rustc_hash::FxHashSet;
-use std::ops::{Deref, DerefMut};
-
-use red_knot_python_semantic::types::{Type, TypeDefinition};
-use ruff_db::files::{File, FileRange};
-use ruff_text_size::{Ranged, TextRange};
-
-/// Information associated with a text range.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct RangedValue<T> {
-    pub range: FileRange,
-    pub value: T,
-}
-
-impl<T> RangedValue<T> {
-    pub fn file_range(&self) -> FileRange {
-        self.range
-    }
-}
-
-impl<T> Deref for RangedValue<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-impl<T> DerefMut for RangedValue<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.value
-    }
-}
-
-impl<T> IntoIterator for RangedValue<T>
-where
-    T: IntoIterator,
-{
-    type Item = T::Item;
-    type IntoIter = T::IntoIter;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.value.into_iter()
-    }
-}
-
-/// Target to which the editor can navigate to.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NavigationTarget {
-    file: File,
-
-    /// The range that should be focused when navigating to the target.
-    ///
-    /// This is typically not the full range of the node. For example, it's the range of the class's name in a class definition.
-    ///
-    /// The `focus_range` must be fully covered by `full_range`.
-    focus_range: TextRange,
-
-    /// The range covering the entire target.
-    full_range: TextRange,
-}
-
-impl NavigationTarget {
-    pub fn file(&self) -> File {
-        self.file
-    }
-
-    pub fn focus_range(&self) -> TextRange {
-        self.focus_range
-    }
-
-    pub fn full_range(&self) -> TextRange {
-        self.full_range
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct NavigationTargets(smallvec::SmallVec<[NavigationTarget; 1]>);
-
-impl NavigationTargets {
-    fn single(target: NavigationTarget) -> Self {
-        Self(smallvec::smallvec![target])
-    }
-
-    fn empty() -> Self {
-        Self(smallvec::SmallVec::new())
-    }
-
-    fn unique(targets: impl IntoIterator<Item = NavigationTarget>) -> Self {
-        let unique: FxHashSet<_> = targets.into_iter().collect();
-        if unique.is_empty() {
-            Self::empty()
-        } else {
-            let mut targets = unique.into_iter().collect::<Vec<_>>();
-            targets.sort_by_key(|target| (target.file, target.focus_range.start()));
-            Self(targets.into())
-        }
-    }
-
-    fn iter(&self) -> std::slice::Iter<'_, NavigationTarget> {
-        self.0.iter()
-    }
-
-    #[cfg(test)]
-    fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-}
-
-impl IntoIterator for NavigationTargets {
-    type Item = NavigationTarget;
-    type IntoIter = smallvec::IntoIter<[NavigationTarget; 1]>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.into_iter()
-    }
-}
-
-impl<'a> IntoIterator for &'a NavigationTargets {
-    type Item = &'a NavigationTarget;
-    type IntoIter = std::slice::Iter<'a, NavigationTarget>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
-impl FromIterator<NavigationTarget> for NavigationTargets {
-    fn from_iter<T: IntoIterator<Item = NavigationTarget>>(iter: T) -> Self {
-        Self::unique(iter)
-    }
-}
-
-pub trait HasNavigationTargets {
-    fn navigation_targets(&self, db: &dyn Db) -> NavigationTargets;
-}
-
-impl HasNavigationTargets for Type<'_> {
-    fn navigation_targets(&self, db: &dyn Db) -> NavigationTargets {
-        match self {
-            Type::Union(union) => union
-                .iter(db.upcast())
-                .flat_map(|target| target.navigation_targets(db))
-                .collect(),
-
-            Type::Intersection(intersection) => {
-                // Only consider the positive elements because the negative elements are mainly from narrowing constraints.
-                let mut targets = intersection
-                    .iter_positive(db.upcast())
-                    .filter(|ty| !ty.is_unknown());
-
-                let Some(first) = targets.next() else {
-                    return NavigationTargets::empty();
-                };
-
-                match targets.next() {
-                    Some(_) => {
-                        // If there are multiple types in the intersection, we can't navigate to a single one
-                        // because the type is the intersection of all those types.
-                        NavigationTargets::empty()
-                    }
-                    None => first.navigation_targets(db),
-                }
-            }
-
-            ty => ty
-                .definition(db.upcast())
-                .map(|definition| definition.navigation_targets(db))
-                .unwrap_or_else(NavigationTargets::empty),
-        }
-    }
-}
-
-impl HasNavigationTargets for TypeDefinition<'_> {
-    fn navigation_targets(&self, db: &dyn Db) -> NavigationTargets {
-        let full_range = self.full_range(db.upcast());
-        NavigationTargets::single(NavigationTarget {
-            file: full_range.file(),
-            focus_range: self.focus_range(db.upcast()).unwrap_or(full_range).range(),
-            full_range: full_range.range(),
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::db::tests::TestDb;
-    use insta::internals::SettingsBindDropGuard;
-    use red_knot_python_semantic::{
-        Program, ProgramSettings, PythonPath, PythonPlatform, SearchPathSettings,
-    };
-    use ruff_db::diagnostic::{Diagnostic, DiagnosticFormat, DisplayDiagnosticConfig};
-    use ruff_db::files::{system_path_to_file, File};
-    use ruff_db::system::{DbWithWritableSystem, SystemPath, SystemPathBuf};
-    use ruff_python_ast::PythonVersion;
-    use ruff_text_size::TextSize;
-
-    pub(super) fn cursor_test(source: &str) -> CursorTest {
-        let mut db = TestDb::new();
-        let cursor_offset = source.find("<CURSOR>").expect(
-            "`source`` should contain a `<CURSOR>` marker, indicating the position of the cursor.",
-        );
-
-        let mut content = source[..cursor_offset].to_string();
-        content.push_str(&source[cursor_offset + "<CURSOR>".len()..]);
-
-        db.write_file("main.py", &content)
-            .expect("write to memory file system to be successful");
-
-        let file = system_path_to_file(&db, "main.py").expect("newly written file to existing");
-
-        Program::from_settings(
-            &db,
-            ProgramSettings {
-                python_version: PythonVersion::latest(),
-                python_platform: PythonPlatform::default(),
-                search_paths: SearchPathSettings {
-                    extra_paths: vec![],
-                    src_roots: vec![SystemPathBuf::from("/")],
-                    custom_typeshed: None,
-                    python_path: PythonPath::KnownSitePackages(vec![]),
-                },
-            },
-        )
-        .expect("Default settings to be valid");
-
-        let mut insta_settings = insta::Settings::clone_current();
-        insta_settings.add_filter(r#"\\(\w\w|\s|\.|")"#, "/$1");
-        // Filter out TODO types because they are different between debug and release builds.
-        insta_settings.add_filter(r"@Todo\(.+\)", "@Todo");
-
-        let insta_settings_guard = insta_settings.bind_to_scope();
-
-        CursorTest {
-            db,
-            cursor_offset: TextSize::try_from(cursor_offset)
-                .expect("source to be smaller than 4GB"),
-            file,
-            _insta_settings_guard: insta_settings_guard,
-        }
-    }
-
-    pub(super) struct CursorTest {
-        pub(super) db: TestDb,
-        pub(super) cursor_offset: TextSize,
-        pub(super) file: File,
-        _insta_settings_guard: SettingsBindDropGuard,
-    }
-
-    impl CursorTest {
-        pub(super) fn write_file(
-            &mut self,
-            path: impl AsRef<SystemPath>,
-            content: &str,
-        ) -> std::io::Result<()> {
-            self.db.write_file(path, content)
-        }
-
-        pub(super) fn render_diagnostics<I, D>(&self, diagnostics: I) -> String
-        where
-            I: IntoIterator<Item = D>,
-            D: IntoDiagnostic,
-        {
-            use std::fmt::Write;
-
-            let mut buf = String::new();
-
-            let config = DisplayDiagnosticConfig::default()
-                .color(false)
-                .format(DiagnosticFormat::Full);
-            for diagnostic in diagnostics {
-                let diag = diagnostic.into_diagnostic();
-                write!(buf, "{}", diag.display(&self.db, &config)).unwrap();
-            }
-
-            buf
-        }
-    }
-
-    pub(super) trait IntoDiagnostic {
-        fn into_diagnostic(self) -> Diagnostic;
-    }
-}

crates/red_knot_ide/src/markup.rs

@@ -1,66 +0,0 @@
-use std::fmt;
-use std::fmt::Formatter;
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum MarkupKind {
-    PlainText,
-    Markdown,
-}
-
-impl MarkupKind {
-    pub(crate) const fn fenced_code_block<T>(self, code: T, language: &str) -> FencedCodeBlock<T>
-    where
-        T: fmt::Display,
-    {
-        FencedCodeBlock {
-            language,
-            code,
-            kind: self,
-        }
-    }
-
-    pub(crate) const fn horizontal_line(self) -> HorizontalLine {
-        HorizontalLine { kind: self }
-    }
-}
-
-pub(crate) struct FencedCodeBlock<'a, T> {
-    language: &'a str,
-    code: T,
-    kind: MarkupKind,
-}
-
-impl<T> fmt::Display for FencedCodeBlock<'_, T>
-where
-    T: fmt::Display,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.kind {
-            MarkupKind::PlainText => self.code.fmt(f),
-            MarkupKind::Markdown => write!(
-                f,
-                "```{language}\n{code}\n```",
-                language = self.language,
-                code = self.code
-            ),
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub(crate) struct HorizontalLine {
-    kind: MarkupKind,
-}
-
-impl fmt::Display for HorizontalLine {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self.kind {
-            MarkupKind::PlainText => {
-                f.write_str("\n---------------------------------------------\n")
-            }
-            MarkupKind::Markdown => {
-                write!(f, "\n---\n")
-            }
-        }
-    }
-}

crates/red_knot_project/Cargo.toml

@@ -16,9 +16,7 @@ ruff_cache = { workspace = true }
 ruff_db = { workspace = true, features = ["cache", "serde"] }
 ruff_macros = { workspace = true }
 ruff_python_ast = { workspace = true, features = ["serde"] }
-ruff_python_formatter = { workspace = true, optional = true }
 ruff_text_size = { workspace = true }
-red_knot_ide = { workspace = true }
 red_knot_python_semantic = { workspace = true, features = ["serde"] }
 red_knot_vendored = { workspace = true }
 
@@ -44,13 +42,8 @@ insta = { workspace = true, features = ["redactions", "ron"] }
 [features]
 default = ["zstd"]
 deflate = ["red_knot_vendored/deflate"]
-schemars = [
-    "dep:schemars",
-    "ruff_db/schemars",
-    "red_knot_python_semantic/schemars",
-]
+schemars = ["dep:schemars", "ruff_db/schemars", "red_knot_python_semantic/schemars"]
 zstd = ["red_knot_vendored/zstd"]
-format = ["ruff_python_formatter"]
 
 [lints]
 workspace = true

crates/red_knot_project/src/combine.rs

@@ -43,7 +43,7 @@ use ruff_python_ast::PythonVersion;
 /// resolved extra search path of `["b", "c", "a"]`, which means `a` will be tried last.
 ///
 /// There's an argument here that the user should be able to specify the order of the paths,
-/// because only then is the user in full control of where to insert the path when specifying `extra-paths`
+/// because only then is the user in full control of where to insert the path when specyifing `extra-paths`
 /// in multiple sources.
 ///
 /// ## Macro

crates/red_knot_project/src/db.rs

@@ -3,10 +3,9 @@ use std::sync::Arc;
 
 use crate::DEFAULT_LINT_REGISTRY;
 use crate::{Project, ProjectMetadata};
-use red_knot_ide::Db as IdeDb;
 use red_knot_python_semantic::lint::{LintRegistry, RuleSelection};
 use red_knot_python_semantic::{Db as SemanticDb, Program};
-use ruff_db::diagnostic::Diagnostic;
+use ruff_db::diagnostic::OldDiagnosticTrait;
 use ruff_db::files::{File, Files};
 use ruff_db::system::System;
 use ruff_db::vendored::VendoredFileSystem;
@@ -56,12 +55,12 @@ impl ProjectDatabase {
     }
 
     /// Checks all open files in the project and its dependencies.
-    pub fn check(&self) -> Result<Vec<Diagnostic>, Cancelled> {
+    pub fn check(&self) -> Result<Vec<Box<dyn OldDiagnosticTrait>>, Cancelled> {
         self.with_db(|db| db.project().check(db))
     }
 
     #[tracing::instrument(level = "debug", skip(self))]
-    pub fn check_file(&self, file: File) -> Result<Vec<Diagnostic>, Cancelled> {
+    pub fn check_file(&self, file: File) -> Result<Vec<Box<dyn OldDiagnosticTrait>>, Cancelled> {
         self.with_db(|db| self.project().check_file(db, file))
     }
 
@@ -104,19 +103,6 @@ impl Upcast<dyn SourceDb> for ProjectDatabase {
     }
 }
 
-impl Upcast<dyn IdeDb> for ProjectDatabase {
-    fn upcast(&self) -> &(dyn IdeDb + 'static) {
-        self
-    }
-
-    fn upcast_mut(&mut self) -> &mut (dyn IdeDb + 'static) {
-        self
-    }
-}
-
-#[salsa::db]
-impl IdeDb for ProjectDatabase {}
-
 #[salsa::db]
 impl SemanticDb for ProjectDatabase {
     fn is_file_open(&self, file: File) -> bool {
@@ -159,7 +145,7 @@ impl salsa::Database for ProjectDatabase {
         }
 
         let event = event();
-        if matches!(event.kind, salsa::EventKind::WillCheckCancellation) {
+        if matches!(event.kind, salsa::EventKind::WillCheckCancellation { .. }) {
             return;
         }
 
@@ -174,32 +160,6 @@ impl Db for ProjectDatabase {
     }
 }
 
-#[cfg(feature = "format")]
-mod format {
-    use crate::ProjectDatabase;
-    use ruff_db::files::File;
-    use ruff_db::Upcast;
-    use ruff_python_formatter::{Db as FormatDb, PyFormatOptions};
-
-    #[salsa::db]
-    impl FormatDb for ProjectDatabase {
-        fn format_options(&self, file: File) -> PyFormatOptions {
-            let source_ty = file.source_type(self);
-            PyFormatOptions::from_source_type(source_ty)
-        }
-    }
-
-    impl Upcast<dyn FormatDb> for ProjectDatabase {
-        fn upcast(&self) -> &(dyn FormatDb + 'static) {
-            self
-        }
-
-        fn upcast_mut(&mut self) -> &mut (dyn FormatDb + 'static) {
-            self
-        }
-    }
-}
-
 #[cfg(test)]
 pub(crate) mod tests {
     use std::sync::Arc;

crates/red_knot_project/src/db/changes.rs

@@ -187,7 +187,7 @@ impl ProjectDatabase {
                     let program = Program::get(self);
                     if let Err(error) = program.update_from_settings(self, program_settings) {
                         tracing::error!("Failed to update the program settings, keeping the old program settings: {error}");
-                    }
+                    };
 
                     if metadata.root() == project.root(self) {
                         tracing::debug!("Reloading project after structural change");

crates/red_knot_project/src/lib.rs

@@ -9,9 +9,7 @@ pub use metadata::{ProjectDiscoveryError, ProjectMetadata};
 use red_knot_python_semantic::lint::{LintRegistry, LintRegistryBuilder, RuleSelection};
 use red_knot_python_semantic::register_lints;
 use red_knot_python_semantic::types::check_types;
-use ruff_db::diagnostic::{
-    create_parse_diagnostic, Annotation, Diagnostic, DiagnosticId, Severity, Span,
-};
+use ruff_db::diagnostic::{DiagnosticId, OldDiagnosticTrait, OldParseDiagnostic, Severity, Span};
 use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
 use ruff_db::source::{source_text, SourceTextError};
@@ -19,6 +17,7 @@ use ruff_db::system::{SystemPath, SystemPathBuf};
 use rustc_hash::FxHashSet;
 use salsa::Durability;
 use salsa::Setter;
+use std::borrow::Cow;
 use std::sync::Arc;
 use thiserror::Error;
 
@@ -164,27 +163,24 @@ impl Project {
     }
 
     /// Checks all open files in the project and its dependencies.
-    pub(crate) fn check(self, db: &ProjectDatabase) -> Vec<Diagnostic> {
+    pub(crate) fn check(self, db: &ProjectDatabase) -> Vec<Box<dyn OldDiagnosticTrait>> {
         let project_span = tracing::debug_span!("Project::check");
         let _span = project_span.enter();
 
         tracing::debug!("Checking project '{name}'", name = self.name(db));
 
-        let mut diagnostics: Vec<Diagnostic> = Vec::new();
-        diagnostics.extend(
-            self.settings_diagnostics(db)
-                .iter()
-                .map(OptionDiagnostic::to_diagnostic),
-        );
+        let mut diagnostics: Vec<Box<dyn OldDiagnosticTrait>> = Vec::new();
+        diagnostics.extend(self.settings_diagnostics(db).iter().map(|diagnostic| {
+            let diagnostic: Box<dyn OldDiagnosticTrait> = Box::new(diagnostic.clone());
+            diagnostic
+        }));
 
         let files = ProjectFiles::new(db, self);
 
-        diagnostics.extend(
-            files
-                .diagnostics()
-                .iter()
-                .map(IOErrorDiagnostic::to_diagnostic),
-        );
+        diagnostics.extend(files.diagnostics().iter().cloned().map(|diagnostic| {
+            let diagnostic: Box<dyn OldDiagnosticTrait> = Box::new(diagnostic);
+            diagnostic
+        }));
 
         let result = Arc::new(std::sync::Mutex::new(diagnostics));
         let inner_result = Arc::clone(&result);
@@ -212,11 +208,14 @@ impl Project {
         Arc::into_inner(result).unwrap().into_inner().unwrap()
     }
 
-    pub(crate) fn check_file(self, db: &dyn Db, file: File) -> Vec<Diagnostic> {
+    pub(crate) fn check_file(self, db: &dyn Db, file: File) -> Vec<Box<dyn OldDiagnosticTrait>> {
         let mut file_diagnostics: Vec<_> = self
             .settings_diagnostics(db)
             .iter()
-            .map(OptionDiagnostic::to_diagnostic)
+            .map(|diagnostic| {
+                let diagnostic: Box<dyn OldDiagnosticTrait> = Box::new(diagnostic.clone());
+                diagnostic
+            })
             .collect();
 
         let check_diagnostics = check_file_impl(db, file);
@@ -399,36 +398,35 @@ impl Project {
     }
 }
 
-fn check_file_impl(db: &dyn Db, file: File) -> Vec<Diagnostic> {
-    let mut diagnostics: Vec<Diagnostic> = Vec::new();
+fn check_file_impl(db: &dyn Db, file: File) -> Vec<Box<dyn OldDiagnosticTrait>> {
+    let mut diagnostics: Vec<Box<dyn OldDiagnosticTrait>> = Vec::new();
 
     // Abort checking if there are IO errors.
     let source = source_text(db.upcast(), file);
 
     if let Some(read_error) = source.read_error() {
-        diagnostics.push(
-            IOErrorDiagnostic {
-                file: Some(file),
-                error: read_error.clone().into(),
-            }
-            .to_diagnostic(),
-        );
+        diagnostics.push(Box::new(IOErrorDiagnostic {
+            file: Some(file),
+            error: read_error.clone().into(),
+        }));
         return diagnostics;
     }
 
     let parsed = parsed_module(db.upcast(), file);
-    diagnostics.extend(
-        parsed
-            .errors()
-            .iter()
-            .map(|error| create_parse_diagnostic(file, error)),
-    );
+    diagnostics.extend(parsed.errors().iter().map(|error| {
+        let diagnostic: Box<dyn OldDiagnosticTrait> =
+            Box::new(OldParseDiagnostic::new(file, error.clone()));
+        diagnostic
+    }));
 
-    diagnostics.extend(check_types(db.upcast(), file).into_iter().cloned());
+    diagnostics.extend(check_types(db.upcast(), file).iter().map(|diagnostic| {
+        let boxed: Box<dyn OldDiagnosticTrait> = Box::new(diagnostic.clone());
+        boxed
+    }));
 
     diagnostics.sort_unstable_by_key(|diagnostic| {
         diagnostic
-            .primary_span()
+            .span()
             .and_then(|span| span.range())
             .unwrap_or_default()
             .start()
@@ -496,13 +494,21 @@ pub struct IOErrorDiagnostic {
     error: IOErrorKind,
 }
 
-impl IOErrorDiagnostic {
-    fn to_diagnostic(&self) -> Diagnostic {
-        let mut diag = Diagnostic::new(DiagnosticId::Io, Severity::Error, &self.error);
-        if let Some(file) = self.file {
-            diag.annotate(Annotation::primary(Span::from(file)));
-        }
-        diag
+impl OldDiagnosticTrait for IOErrorDiagnostic {
+    fn id(&self) -> DiagnosticId {
+        DiagnosticId::Io
+    }
+
+    fn message(&self) -> Cow<str> {
+        self.error.to_string().into()
+    }
+
+    fn span(&self) -> Option<Span> {
+        self.file.map(Span::from)
+    }
+
+    fn severity(&self) -> Severity {
+        Severity::Error
     }
 }
 
@@ -520,6 +526,7 @@ mod tests {
     use crate::db::tests::TestDb;
     use crate::{check_file_impl, ProjectMetadata};
     use red_knot_python_semantic::types::check_types;
+    use ruff_db::diagnostic::OldDiagnosticTrait;
     use ruff_db::files::system_path_to_file;
     use ruff_db::source::source_text;
     use ruff_db::system::{DbWithTestSystem, DbWithWritableSystem as _, SystemPath, SystemPathBuf};
@@ -543,7 +550,7 @@ mod tests {
         assert_eq!(
             check_file_impl(&db, file)
                 .into_iter()
-                .map(|diagnostic| diagnostic.primary_message().to_string())
+                .map(|diagnostic| diagnostic.message().into_owned())
                 .collect::<Vec<_>>(),
             vec!["Failed to read file: No such file or directory".to_string()]
         );
@@ -559,7 +566,7 @@ mod tests {
         assert_eq!(
             check_file_impl(&db, file)
                 .into_iter()
-                .map(|diagnostic| diagnostic.primary_message().to_string())
+                .map(|diagnostic| diagnostic.message().into_owned())
                 .collect::<Vec<_>>(),
             vec![] as Vec<String>
         );

crates/red_knot_project/src/metadata/options.rs

@@ -2,13 +2,14 @@ use crate::metadata::value::{RangedValue, RelativePathBuf, ValueSource, ValueSou
 use crate::Db;
 use red_knot_python_semantic::lint::{GetLintError, Level, LintSource, RuleSelection};
 use red_knot_python_semantic::{ProgramSettings, PythonPath, PythonPlatform, SearchPathSettings};
-use ruff_db::diagnostic::{Annotation, Diagnostic, DiagnosticFormat, DiagnosticId, Severity, Span};
+use ruff_db::diagnostic::{DiagnosticFormat, DiagnosticId, OldDiagnosticTrait, Severity, Span};
 use ruff_db::files::system_path_to_file;
 use ruff_db::system::{System, SystemPath};
 use ruff_macros::Combine;
 use ruff_python_ast::PythonVersion;
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
+use std::borrow::Cow;
 use std::fmt::Debug;
 use thiserror::Error;
 
@@ -54,25 +55,20 @@ impl Options {
         project_root: &SystemPath,
         system: &dyn System,
     ) -> ProgramSettings {
-        let python_version = self
+        let (python_version, python_platform) = self
             .environment
             .as_ref()
-            .and_then(|env| env.python_version.as_deref().copied())
+            .map(|env| {
+                (
+                    env.python_version.as_deref().copied(),
+                    env.python_platform.as_deref(),
+                )
+            })
             .unwrap_or_default();
-        let python_platform = self
-            .environment
-            .as_ref()
-            .and_then(|env| env.python_platform.as_deref().cloned())
-            .unwrap_or_else(|| {
-                let default = PythonPlatform::default();
-                tracing::info!(
-                    "Defaulting to default python version for this platform: '{default}'",
-                );
-                default
-            });
+
         ProgramSettings {
-            python_version,
-            python_platform,
+            python_version: python_version.unwrap_or_default(),
+            python_platform: python_platform.cloned().unwrap_or_default(),
             search_paths: self.to_search_path_settings(project_root, system),
         }
     }
@@ -125,7 +121,7 @@ impl Options {
                         .ok()
                         .map(PythonPath::from_virtual_env_var)
                 })
-                .unwrap_or_else(|| PythonPath::Discover(project_root.to_path_buf())),
+                .unwrap_or_else(|| PythonPath::KnownSitePackages(vec![])),
         }
     }
 
@@ -229,7 +225,7 @@ impl Options {
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct EnvironmentOptions {
-    /// Specifies the version of Python that will be used to analyze the source code.
+    /// Specifies the version of Python that will be used to execute the source code.
     /// The version should be specified as a string in the format `M.m` where `M` is the major version
     /// and `m` is the minor (e.g. "3.0" or "3.6").
     /// If a version is provided, knot will generate errors if the source code makes use of language features
@@ -238,16 +234,11 @@ pub struct EnvironmentOptions {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub python_version: Option<RangedValue<PythonVersion>>,
 
-    /// Specifies the target platform that will be used to analyze the source code.
+    /// Specifies the target platform that will be used to execute the source code.
     /// If specified, Red Knot will tailor its use of type stub files,
     /// which conditionalize type definitions based on the platform.
     ///
-    /// If no platform is specified, knot will use the current platform:
-    /// - `win32` for Windows
-    /// - `darwin` for macOS
-    /// - `android` for Android
-    /// - `ios` for iOS
-    /// - `linux` for everything else
+    /// If no platform is specified, knot will use `all` or the current platform in the LSP use case.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub python_platform: Option<RangedValue<PythonPlatform>>,
 
@@ -406,14 +397,22 @@ impl OptionDiagnostic {
     fn with_span(self, span: Option<Span>) -> Self {
         OptionDiagnostic { span, ..self }
     }
+}
 
-    pub(crate) fn to_diagnostic(&self) -> Diagnostic {
-        if let Some(ref span) = self.span {
-            let mut diag = Diagnostic::new(self.id, self.severity, "");
-            diag.annotate(Annotation::primary(span.clone()).message(&self.message));
-            diag
-        } else {
-            Diagnostic::new(self.id, self.severity, &self.message)
-        }
+impl OldDiagnosticTrait for OptionDiagnostic {
+    fn id(&self) -> DiagnosticId {
+        self.id
+    }
+
+    fn message(&self) -> Cow<str> {
+        Cow::Borrowed(&self.message)
+    }
+
+    fn span(&self) -> Option<Span> {
+        self.span.clone()
+    }
+
+    fn severity(&self) -> Severity {
+        self.severity
     }
 }

crates/red_knot_python_semantic/mdtest.py

@@ -155,7 +155,6 @@ class MDTestRunner:
 
     def watch(self) -> Never:
         self._recompile_tests("Compiling tests...", message_on_success=False)
-        self._run_mdtest()
         self.console.print("[dim]Ready to watch for changes...[/dim]")
 
         for changes in watch(CRATE_ROOT):

crates/red_knot_python_semantic/resources/mdtest/annotations/callable.md

@@ -2,7 +2,7 @@
 
 References:
 
-- <https://typing.python.org/en/latest/spec/callables.html#callable>
+- <https://typing.readthedocs.io/en/latest/spec/callables.html#callable>
 
 Note that `typing.Callable` is deprecated at runtime, in favour of `collections.abc.Callable` (see:
 <https://docs.python.org/3/library/typing.html#deprecated-aliases>). However, removal of
@@ -299,4 +299,4 @@ def _(c: Callable[[int], int]):
     reveal_type(c.__call__)  # revealed: Unknown
 ```
 
-[gradual form]: https://typing.python.org/en/latest/spec/glossary.html#term-gradual-form
+[gradual form]: https://typing.readthedocs.io/en/latest/spec/glossary.html#term-gradual-form

crates/red_knot_python_semantic/resources/mdtest/annotations/deferred.md

@@ -45,104 +45,3 @@ class Foo: ...
 
 reveal_type(get_foo())  # revealed: Foo
 ```
-
-## Deferred self-reference annotations in a class definition
-
-```py
-from __future__ import annotations
-
-class Foo:
-    this: Foo
-    # error: [unresolved-reference]
-    _ = Foo()
-    # error: [unresolved-reference]
-    [Foo for _ in range(1)]
-    a = int
-
-    def f(self, x: Foo):
-        reveal_type(x)  # revealed: Foo
-
-    def g(self) -> Foo:
-        _: Foo = self
-        return self
-
-    class Bar:
-        foo: Foo
-        b = int
-
-        def f(self, x: Foo):
-            return self
-        # error: [unresolved-reference]
-        def g(self) -> Bar:
-            return self
-        # error: [unresolved-reference]
-        def h[T: Bar](self):
-            pass
-
-        class Baz[T: Foo]:
-            pass
-
-        # error: [unresolved-reference]
-        type S = a
-        type T = b
-
-    def h[T: Bar]():
-        # error: [unresolved-reference]
-        return Bar()
-    type Baz = Foo
-```
-
-## Non-deferred self-reference annotations in a class definition
-
-```py
-class Foo:
-    # error: [unresolved-reference]
-    this: Foo
-    ok: "Foo"
-    # error: [unresolved-reference]
-    _ = Foo()
-    # error: [unresolved-reference]
-    [Foo for _ in range(1)]
-    a = int
-
-    # error: [unresolved-reference]
-    def f(self, x: Foo):
-        reveal_type(x)  # revealed: Unknown
-    # error: [unresolved-reference]
-    def g(self) -> Foo:
-        _: Foo = self
-        return self
-
-    class Bar:
-        # error: [unresolved-reference]
-        foo: Foo
-        b = int
-
-        # error: [unresolved-reference]
-        def f(self, x: Foo):
-            return self
-        # error: [unresolved-reference]
-        def g(self) -> Bar:
-            return self
-        # error: [unresolved-reference]
-        def h[T: Bar](self):
-            pass
-
-        class Baz[T: Foo]:
-            pass
-
-        # error: [unresolved-reference]
-        type S = a
-        type T = b
-
-    def h[T: Bar]():
-        # error: [unresolved-reference]
-        return Bar()
-    type Qux = Foo
-
-def _():
-    class C:
-        # error: [unresolved-reference]
-        def f(self) -> C:
-            return self
-```

crates/red_knot_python_semantic/resources/mdtest/annotations/int_float_complex.md

@@ -2,7 +2,7 @@
 
 In order to support common use cases, an annotation of `float` actually means `int | float`, and an
 annotation of `complex` actually means `int | float | complex`. See
-[the specification](https://typing.python.org/en/latest/spec/special-types.html#special-cases-for-float-and-complex)
+[the specification](https://typing.readthedocs.io/en/latest/spec/special-types.html#special-cases-for-float-and-complex)
 
 ## float
 

crates/red_knot_python_semantic/resources/mdtest/annotations/literal.md

@@ -1,6 +1,6 @@
 # Literal
 
-<https://typing.python.org/en/latest/spec/literal.html#literals>
+<https://typing.readthedocs.io/en/latest/spec/literal.html#literals>
 
 ## Parameterization
 
@@ -36,7 +36,7 @@ def f():
     reveal_type(a7)  # revealed: None
     reveal_type(a8)  # revealed: Literal[1]
     # TODO: This should be Color.RED
-    reveal_type(b1)  # revealed: @Todo(Attribute access on enum classes)
+    reveal_type(b1)  # revealed: Unknown | Literal[0]
 
 # error: [invalid-type-form]
 invalid1: Literal[3 + 4]

crates/red_knot_python_semantic/resources/mdtest/annotations/literal_string.md

@@ -73,12 +73,12 @@ qux = (foo, bar)
 reveal_type(qux)  # revealed: tuple[Literal["foo"], Literal["bar"]]
 
 # TODO: Infer "LiteralString"
-reveal_type(foo.join(qux))  # revealed: @Todo(return type of overloaded function)
+reveal_type(foo.join(qux))  # revealed: @Todo(return type of decorated function)
 
 template: LiteralString = "{}, {}"
 reveal_type(template)  # revealed: Literal["{}, {}"]
 # TODO: Infer `LiteralString`
-reveal_type(template.format(foo, bar))  # revealed: @Todo(return type of overloaded function)
+reveal_type(template.format(foo, bar))  # revealed: @Todo(return type of decorated function)
 ```
 
 ### Assignability
@@ -147,4 +147,4 @@ def f():
     reveal_type(x)  # revealed: LiteralString
 ```
 
-[1]: https://typing.python.org/en/latest/spec/literal.html#literalstring
+[1]: https://typing.readthedocs.io/en/latest/spec/literal.html#literalstring

crates/red_knot_python_semantic/resources/mdtest/annotations/new_types.md

@@ -8,11 +8,7 @@ Currently, red-knot doesn't support `typing.NewType` in type annotations.
 from typing_extensions import NewType
 from types import GenericAlias
 
-X = GenericAlias(type, ())
 A = NewType("A", int)
-# TODO: typeshed for `typing.GenericAlias` uses `type` for the first argument. `NewType` should be special-cased
-# to be compatible with `type`
-# error: [invalid-argument-type] "Object of type `NewType` cannot be assigned to parameter 2 (`origin`) of function `__new__`; expected type `type`"
 B = GenericAlias(A, ())
 
 def _(

crates/red_knot_python_semantic/resources/mdtest/annotations/union.md

@@ -2,7 +2,7 @@
 
 ## Annotation
 
-`typing.Union` can be used to construct union types in the same way as the `|` operator.
+`typing.Union` can be used to construct union types same as `|` operator.
 
 ```py
 from typing import Union
@@ -69,20 +69,3 @@ from typing import Union
 def f(x: Union) -> None:
     reveal_type(x)  # revealed: Unknown
 ```
-
-## Implicit type aliases using new-style unions
-
-We don't recognise these as type aliases yet, but we also don't emit false-positive diagnostics if
-you use them in type expressions:
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-X = int | str
-
-def f(y: X):
-    reveal_type(y)  # revealed: @Todo(Support for `types.UnionType` instances in type expressions)
-```

crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md

@@ -56,7 +56,7 @@ def _(
     reveal_type(d)  # revealed: Unknown
 
     def foo(a_: e) -> None:
-        reveal_type(a_)  # revealed: @Todo(Support for `typing.ParamSpec`)
+        reveal_type(a_)  # revealed: @Todo(Support for `typing.ParamSpec` instances in type expressions)
 ```
 
 ## Inheritance

crates/red_knot_python_semantic/resources/mdtest/assignment/annotations.md

@@ -52,11 +52,13 @@ reveal_type(b)  # revealed: tuple[int]
 reveal_type(c)  # revealed: tuple[str, int]
 reveal_type(d)  # revealed: tuple[tuple[str, str], tuple[int, int]]
 
-# TODO: homogeneous tuples, PEP-646 tuples, generics
+# TODO: homogeneous tuples, PEP-646 tuples
 reveal_type(e)  # revealed: @Todo(full tuple[...] support)
 reveal_type(f)  # revealed: @Todo(full tuple[...] support)
 reveal_type(g)  # revealed: @Todo(full tuple[...] support)
-reveal_type(h)  # revealed: tuple[@Todo(generics), @Todo(generics)]
+
+# TODO: support more kinds of type expressions in annotations
+reveal_type(h)  # revealed: @Todo(full tuple[...] support)
 
 reveal_type(i)  # revealed: tuple[str | int, str | int]
 reveal_type(j)  # revealed: tuple[str | int]

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -1395,59 +1395,6 @@ def _(ns: argparse.Namespace):
     reveal_type(ns.whatever)  # revealed: Any
 ```
 
-## Classes with custom `__setattr__` methods
-
-### Basic
-
-If a type provides a custom `__setattr__` method, we use the parameter type of that method as the
-type to validate attribute assignments. Consider the following `CustomSetAttr` class:
-
-```py
-class CustomSetAttr:
-    def __setattr__(self, name: str, value: int) -> None:
-        pass
-```
-
-We can set arbitrary attributes on instances of this class:
-
-```py
-c = CustomSetAttr()
-
-c.whatever = 42
-```
-
-### Type of the `name` parameter
-
-If the `name` parameter of the `__setattr__` method is annotated with a (union of) literal type(s),
-we only consider the attribute assignment to be valid if the assigned attribute is one of them:
-
-```py
-from typing import Literal
-
-class Date:
-    def __setattr__(self, name: Literal["day", "month", "year"], value: int) -> None:
-        pass
-
-date = Date()
-date.day = 8
-date.month = 4
-date.year = 2025
-
-# error: [unresolved-attribute] "Can not assign object of `Literal["UTC"]` to attribute `tz` on type `Date` with custom `__setattr__` method."
-date.tz = "UTC"
-```
-
-### `argparse.Namespace`
-
-A standard library example of a class with a custom `__setattr__` method is `argparse.Namespace`:
-
-```py
-import argparse
-
-def _(ns: argparse.Namespace):
-    ns.whatever = 42
-```
-
 ## Objects of all types have a `__class__` method
 
 The type of `x.__class__` is the same as `x`'s meta-type. `x.__class__` is always the same value as
@@ -1594,7 +1541,7 @@ integers are instances of that class:
 
 ```py
 reveal_type((2).bit_length)  # revealed: <bound method `bit_length` of `Literal[2]`>
-reveal_type((2).denominator)  # revealed: Literal[1]
+reveal_type((2).denominator)  # revealed: @Todo(@property)
 ```
 
 Some attributes are special-cased, however:
@@ -1762,37 +1709,6 @@ reveal_type(C.a_type)  # revealed: type
 reveal_type(C.a_none)  # revealed: None
 ```
 
-## Enum classes
-
-Enums are not supported yet; attribute access on an enum class is inferred as `Todo`.
-
-```py
-import enum
-
-reveal_type(enum.Enum.__members__)  # revealed: @Todo(Attribute access on enum classes)
-
-class Foo(enum.Enum):
-    BAR = 1
-
-reveal_type(Foo.BAR)  # revealed: @Todo(Attribute access on enum classes)
-reveal_type(Foo.BAR.value)  # revealed: @Todo(Attribute access on enum classes)
-reveal_type(Foo.__members__)  # revealed: @Todo(Attribute access on enum classes)
-```
-
-## `super()`
-
-`super()` is not supported yet, but we do not emit false positives on `super()` calls.
-
-```py
-class Foo:
-    def bar(self) -> int:
-        return 42
-
-class Bar(Foo):
-    def bar(self) -> int:
-        return super().bar()
-```
-
 ## References
 
 Some of the tests in the *Class and instance variables* section draw inspiration from
@@ -1800,5 +1716,5 @@ Some of the tests in the *Class and instance variables* section draw inspiration
 
 [descriptor protocol tests]: descriptor_protocol.md
 [pyright's documentation]: https://microsoft.github.io/pyright/#/type-concepts-advanced?id=class-and-instance-variables
-[typing spec on `classvar`]: https://typing.python.org/en/latest/spec/class-compat.html#classvar
+[typing spec on `classvar`]: https://typing.readthedocs.io/en/latest/spec/class-compat.html#classvar
 [`typing.classvar`]: https://docs.python.org/3/library/typing.html#typing.ClassVar

crates/red_knot_python_semantic/resources/mdtest/binary/instances.md

@@ -14,43 +14,43 @@ We support inference for all Python's binary operators: `+`, `-`, `*`, `@`, `/`,
 
 ```py
 class A:
-    def __add__(self, other) -> "A":
+    def __add__(self, other) -> A:
         return self
 
-    def __sub__(self, other) -> "A":
+    def __sub__(self, other) -> A:
         return self
 
-    def __mul__(self, other) -> "A":
+    def __mul__(self, other) -> A:
         return self
 
-    def __matmul__(self, other) -> "A":
+    def __matmul__(self, other) -> A:
         return self
 
-    def __truediv__(self, other) -> "A":
+    def __truediv__(self, other) -> A:
         return self
 
-    def __floordiv__(self, other) -> "A":
+    def __floordiv__(self, other) -> A:
         return self
 
-    def __mod__(self, other) -> "A":
+    def __mod__(self, other) -> A:
         return self
 
-    def __pow__(self, other) -> "A":
+    def __pow__(self, other) -> A:
         return self
 
-    def __lshift__(self, other) -> "A":
+    def __lshift__(self, other) -> A:
         return self
 
-    def __rshift__(self, other) -> "A":
+    def __rshift__(self, other) -> A:
         return self
 
-    def __and__(self, other) -> "A":
+    def __and__(self, other) -> A:
         return self
 
-    def __xor__(self, other) -> "A":
+    def __xor__(self, other) -> A:
         return self
 
-    def __or__(self, other) -> "A":
+    def __or__(self, other) -> A:
         return self
 
 class B: ...
@@ -76,43 +76,43 @@ We also support inference for reflected operations:
 
 ```py
 class A:
-    def __radd__(self, other) -> "A":
+    def __radd__(self, other) -> A:
         return self
 
-    def __rsub__(self, other) -> "A":
+    def __rsub__(self, other) -> A:
         return self
 
-    def __rmul__(self, other) -> "A":
+    def __rmul__(self, other) -> A:
         return self
 
-    def __rmatmul__(self, other) -> "A":
+    def __rmatmul__(self, other) -> A:
         return self
 
-    def __rtruediv__(self, other) -> "A":
+    def __rtruediv__(self, other) -> A:
         return self
 
-    def __rfloordiv__(self, other) -> "A":
+    def __rfloordiv__(self, other) -> A:
         return self
 
-    def __rmod__(self, other) -> "A":
+    def __rmod__(self, other) -> A:
         return self
 
-    def __rpow__(self, other) -> "A":
+    def __rpow__(self, other) -> A:
         return self
 
-    def __rlshift__(self, other) -> "A":
+    def __rlshift__(self, other) -> A:
         return self
 
-    def __rrshift__(self, other) -> "A":
+    def __rrshift__(self, other) -> A:
         return self
 
-    def __rand__(self, other) -> "A":
+    def __rand__(self, other) -> A:
         return self
 
-    def __rxor__(self, other) -> "A":
+    def __rxor__(self, other) -> A:
         return self
 
-    def __ror__(self, other) -> "A":
+    def __ror__(self, other) -> A:
         return self
 
 class B: ...
@@ -157,11 +157,11 @@ the right-hand side is not a subtype of the left-hand side, `lhs.__add__` will t
 
 ```py
 class A:
-    def __add__(self, other: "B") -> int:
+    def __add__(self, other: B) -> int:
         return 42
 
 class B:
-    def __radd__(self, other: "A") -> str:
+    def __radd__(self, other: A) -> str:
         return "foo"
 
 reveal_type(A() + B())  # revealed:  int
@@ -169,10 +169,10 @@ reveal_type(A() + B())  # revealed:  int
 # Edge case: C is a subtype of C, *but* if the two sides are of *equal* types,
 # the lhs *still* takes precedence
 class C:
-    def __add__(self, other: "C") -> int:
+    def __add__(self, other: C) -> int:
         return 42
 
-    def __radd__(self, other: "C") -> str:
+    def __radd__(self, other: C) -> str:
         return "foo"
 
 reveal_type(C() + C())  # revealed: int
@@ -237,11 +237,11 @@ well.
 
 ```py
 class A:
-    def __sub__(self, other: "A") -> "A":
+    def __sub__(self, other: A) -> A:
         return A()
 
 class B:
-    def __rsub__(self, other: A) -> "B":
+    def __rsub__(self, other: A) -> B:
         return B()
 
 reveal_type(A() - B())  # revealed: B
@@ -300,10 +300,10 @@ its instance super-type.
 
 ```py
 class A:
-    def __add__(self, other) -> "A":
+    def __add__(self, other) -> A:
         return self
 
-    def __radd__(self, other) -> "A":
+    def __radd__(self, other) -> A:
         return self
 
 reveal_type(A() + 1)  # revealed: A
@@ -312,7 +312,7 @@ reveal_type(1 + A())  # revealed: A
 reveal_type(A() + "foo")  # revealed: A
 # TODO should be `A` since `str.__add__` doesn't support `A` instances
 # TODO overloads
-reveal_type("foo" + A())  # revealed: @Todo(return type of overloaded function)
+reveal_type("foo" + A())  # revealed: @Todo(return type of decorated function)
 
 reveal_type(A() + b"foo")  # revealed: A
 # TODO should be `A` since `bytes.__add__` doesn't support `A` instances
@@ -320,7 +320,7 @@ reveal_type(b"foo" + A())  # revealed: bytes
 
 reveal_type(A() + ())  # revealed: A
 # TODO this should be `A`, since `tuple.__add__` doesn't support `A` instances
-reveal_type(() + A())  # revealed: @Todo(return type of overloaded function)
+reveal_type(() + A())  # revealed: @Todo(return type of decorated function)
 
 literal_string_instance = "foo" * 1_000_000_000
 # the test is not testing what it's meant to be testing if this isn't a `LiteralString`:
@@ -329,7 +329,7 @@ reveal_type(literal_string_instance)  # revealed: LiteralString
 reveal_type(A() + literal_string_instance)  # revealed: A
 # TODO should be `A` since `str.__add__` doesn't support `A` instances
 # TODO overloads
-reveal_type(literal_string_instance + A())  # revealed: @Todo(return type of overloaded function)
+reveal_type(literal_string_instance + A())  # revealed: @Todo(return type of decorated function)
 ```
 
 ## Operations involving instances of classes inheriting from `Any`
@@ -371,39 +371,6 @@ a = NotBoolable()
 10 and a and True
 ```
 
-## Operations on class objects
-
-When operating on class objects, the corresponding dunder methods are looked up on the metaclass.
-
-```py
-from __future__ import annotations
-
-class Meta(type):
-    def __add__(self, other: Meta) -> int:
-        return 1
-
-    def __lt__(self, other: Meta) -> bool:
-        return True
-
-    def __getitem__(self, key: int) -> str:
-        return "a"
-
-class A(metaclass=Meta): ...
-class B(metaclass=Meta): ...
-
-reveal_type(A + B)  # revealed: int
-# error: [unsupported-operator] "Operator `-` is unsupported between objects of type `Literal[A]` and `Literal[B]`"
-reveal_type(A - B)  # revealed: Unknown
-
-reveal_type(A < B)  # revealed: bool
-reveal_type(A > B)  # revealed: bool
-
-# error: [unsupported-operator] "Operator `<=` is not supported for types `Literal[A]` and `Literal[B]`"
-reveal_type(A <= B)  # revealed: Unknown
-
-reveal_type(A[0])  # revealed: str
-```
-
 ## Unsupported
 
 ### Dunder as instance attribute
@@ -466,7 +433,7 @@ the unreflected dunder of the left-hand operand. For context, see
 
 ```py
 class Foo:
-    def __radd__(self, other: "Foo") -> "Foo":
+    def __radd__(self, other: Foo) -> Foo:
         return self
 
 # error: [unsupported-operator]

crates/red_knot_python_semantic/resources/mdtest/binary/integers.md

@@ -50,21 +50,9 @@ reveal_type(1 ** (largest_u32 + 1))  # revealed: int
 reveal_type(2**largest_u32)  # revealed: int
 
 def variable(x: int):
-    reveal_type(x**2)  # revealed: @Todo(return type of overloaded function)
-    reveal_type(2**x)  # revealed: @Todo(return type of overloaded function)
-    reveal_type(x**x)  # revealed: @Todo(return type of overloaded function)
-```
-
-If the second argument is \<0, a `float` is returned at runtime. If the first argument is \<0 but
-the second argument is >=0, an `int` is still returned:
-
-```py
-reveal_type(1**0)  # revealed: Literal[1]
-reveal_type(0**1)  # revealed: Literal[0]
-reveal_type(0**0)  # revealed: Literal[1]
-reveal_type((-1) ** 2)  # revealed: Literal[1]
-reveal_type(2 ** (-1))  # revealed: float
-reveal_type((-1) ** (-1))  # revealed: float
+    reveal_type(x**2)  # revealed: @Todo(return type of decorated function)
+    reveal_type(2**x)  # revealed: @Todo(return type of decorated function)
+    reveal_type(x**x)  # revealed: @Todo(return type of decorated function)
 ```
 
 ## Division by Zero

crates/red_knot_python_semantic/resources/mdtest/binary/unions.md

@@ -49,11 +49,3 @@ def f4(x: float, y: float):
     reveal_type(x // y)  # revealed: int | float
     reveal_type(x % y)  # revealed: int | float
 ```
-
-If any of the union elements leads to a division by zero, we will report an error:
-
-```py
-def f5(m: int, n: Literal[-1, 0, 1]):
-    # error: [division-by-zero] "Cannot divide object of type `int` by zero"
-    return m / n
-```

crates/red_knot_python_semantic/resources/mdtest/call/builtins.md

@@ -26,11 +26,7 @@ reveal_type(type(1))  # revealed: Literal[int]
 But a three-argument call to type creates a dynamic instance of the `type` class:
 
 ```py
-class Base: ...
-
 reveal_type(type("Foo", (), {}))  # revealed: type
-
-reveal_type(type("Foo", (Base,), {"attr": 1}))  # revealed: type
 ```
 
 Other numbers of arguments are invalid
@@ -42,60 +38,3 @@ type("Foo", ())
 # error: [no-matching-overload] "No overload of class `type` matches arguments"
 type("Foo", (), {}, weird_other_arg=42)
 ```
-
-The following calls are also invalid, due to incorrect argument types:
-
-```py
-class Base: ...
-
-# error: [no-matching-overload] "No overload of class `type` matches arguments"
-type(b"Foo", (), {})
-
-# error: [no-matching-overload] "No overload of class `type` matches arguments"
-type("Foo", Base, {})
-
-# TODO: this should be an error
-type("Foo", (1, 2), {})
-
-# TODO: this should be an error
-type("Foo", (Base,), {b"attr": 1})
-```
-
-## Calls to `str()`
-
-### Valid calls
-
-```py
-str()
-str("")
-str(b"")
-str(1)
-str(object=1)
-
-str(b"M\xc3\xbcsli", "utf-8")
-str(b"M\xc3\xbcsli", "utf-8", "replace")
-
-str(b"M\x00\xfc\x00s\x00l\x00i\x00", encoding="utf-16")
-str(b"M\x00\xfc\x00s\x00l\x00i\x00", encoding="utf-16", errors="ignore")
-
-str(bytearray.fromhex("4d c3 bc 73 6c 69"), "utf-8")
-str(bytearray(), "utf-8")
-
-str(encoding="utf-8", object=b"M\xc3\xbcsli")
-str(b"", errors="replace")
-str(encoding="utf-8")
-str(errors="replace")
-```
-
-### Invalid calls
-
-```py
-str(1, 2)  # error: [no-matching-overload]
-str(o=1)  # error: [no-matching-overload]
-
-# First argument is not a bytes-like object:
-str("Müsli", "utf-8")  # error: [no-matching-overload]
-
-# Second argument is not a valid encoding:
-str(b"M\xc3\xbcsli", b"utf-8")  # error: [no-matching-overload]
-```

crates/red_knot_python_semantic/resources/mdtest/call/constructor.md

@@ -1,325 +1,7 @@
 # Constructor
 
-When classes are instantiated, Python calls the meta-class `__call__` method, which can either be
-customized by the user or `type.__call__` is used.
-
-The latter calls the `__new__` method of the class, which is responsible for creating the instance
-and then calls the `__init__` method on the resulting instance to initialize it with the same
-arguments.
-
-Both `__new__` and `__init__` are looked up using full descriptor protocol, but `__new__` is then
-called as an implicit static, rather than bound method with `cls` passed as the first argument.
-`__init__` has no special handling, it is fetched as bound method and is called just like any other
-dunder method.
-
-`type.__call__` does other things too, but this is not yet handled by us.
-
-Since every class has `object` in it's MRO, the default implementations are `object.__new__` and
-`object.__init__`. They have some special behavior, namely:
-
-- If neither `__new__` nor `__init__` are defined anywhere in the MRO of class (except for `object`)
-    \- no arguments are accepted and `TypeError` is raised if any are passed.
-- If `__new__` is defined, but `__init__` is not - `object.__init__` will allow arbitrary arguments!
-
-As of today there are a number of behaviors that we do not support:
-
-- `__new__` is assumed to return an instance of the class on which it is called
-- User defined `__call__` on metaclass is ignored
-
-## Creating an instance of the `object` class itself
-
-Test the behavior of the `object` class itself. As implementation has to ignore `object` own methods
-as defined in typeshed due to behavior not expressible in typeshed (see above how `__init__` behaves
-differently depending on whether `__new__` is defined or not), we have to test the behavior of
-`object` itself.
-
-```py
-reveal_type(object())  # revealed: object
-
-# error: [too-many-positional-arguments] "Too many positional arguments to class `object`: expected 0, got 1"
-reveal_type(object(1))  # revealed: object
-```
-
-## No init or new
-
 ```py
 class Foo: ...
 
 reveal_type(Foo())  # revealed: Foo
-
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 0, got 1"
-reveal_type(Foo(1))  # revealed: Foo
-```
-
-## `__new__` present on the class itself
-
-```py
-class Foo:
-    def __new__(cls, x: int) -> "Foo":
-        return object.__new__(cls)
-
-reveal_type(Foo(1))  # revealed: Foo
-
-# error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
-reveal_type(Foo())  # revealed: Foo
-# error: [too-many-positional-arguments] "Too many positional arguments to function `__new__`: expected 1, got 2"
-reveal_type(Foo(1, 2))  # revealed: Foo
-```
-
-## `__new__` present on a superclass
-
-If the `__new__` method is defined on a superclass, we can still infer the signature of the
-constructor from it.
-
-```py
-from typing_extensions import Self
-
-class Base:
-    def __new__(cls, x: int) -> Self: ...
-
-class Foo(Base): ...
-
-reveal_type(Foo(1))  # revealed: Foo
-
-# error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
-reveal_type(Foo())  # revealed: Foo
-# error: [too-many-positional-arguments] "Too many positional arguments to function `__new__`: expected 1, got 2"
-reveal_type(Foo(1, 2))  # revealed: Foo
-```
-
-## Conditional `__new__`
-
-```py
-def _(flag: bool) -> None:
-    class Foo:
-        if flag:
-            def __new__(cls, x: int): ...
-        else:
-            def __new__(cls, x: int, y: int = 1): ...
-
-    reveal_type(Foo(1))  # revealed: Foo
-    # error: [invalid-argument-type] "Object of type `Literal["1"]` cannot be assigned to parameter 2 (`x`) of function `__new__`; expected type `int`"
-    reveal_type(Foo("1"))  # revealed: Foo
-    # error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
-    reveal_type(Foo())  # revealed: Foo
-    # error: [too-many-positional-arguments] "Too many positional arguments to function `__new__`: expected 1, got 2"
-    reveal_type(Foo(1, 2))  # revealed: Foo
-```
-
-## A descriptor in place of `__new__`
-
-```py
-class SomeCallable:
-    def __call__(self, cls, x: int) -> "Foo":
-        obj = object.__new__(cls)
-        obj.x = x
-        return obj
-
-class Descriptor:
-    def __get__(self, instance, owner) -> SomeCallable:
-        return SomeCallable()
-
-class Foo:
-    __new__: Descriptor = Descriptor()
-
-reveal_type(Foo(1))  # revealed: Foo
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__call__`"
-reveal_type(Foo())  # revealed: Foo
-```
-
-## A callable instance in place of `__new__`
-
-### Bound
-
-```py
-class Callable:
-    def __call__(self, cls, x: int) -> "Foo":
-        return object.__new__(cls)
-
-class Foo:
-    __new__ = Callable()
-
-reveal_type(Foo(1))  # revealed: Foo
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__call__`"
-reveal_type(Foo())  # revealed: Foo
-```
-
-### Possibly Unbound
-
-```py
-def _(flag: bool) -> None:
-    class Callable:
-        if flag:
-            def __call__(self, cls, x: int) -> "Foo":
-                return object.__new__(cls)
-
-    class Foo:
-        __new__ = Callable()
-
-    # error: [call-non-callable] "Object of type `Callable` is not callable (possibly unbound `__call__` method)"
-    reveal_type(Foo(1))  # revealed: Foo
-    # TODO should be - error: [missing-argument] "No argument provided for required parameter `x` of bound method `__call__`"
-    # but we currently infer the signature of `__call__` as unknown, so it accepts any arguments
-    # error: [call-non-callable] "Object of type `Callable` is not callable (possibly unbound `__call__` method)"
-    reveal_type(Foo())  # revealed: Foo
-```
-
-## `__init__` present on the class itself
-
-If the class has an `__init__` method, we can infer the signature of the constructor from it.
-
-```py
-class Foo:
-    def __init__(self, x: int): ...
-
-reveal_type(Foo(1))  # revealed: Foo
-
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
-reveal_type(Foo())  # revealed: Foo
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 1, got 2"
-reveal_type(Foo(1, 2))  # revealed: Foo
-```
-
-## `__init__` present on a superclass
-
-If the `__init__` method is defined on a superclass, we can still infer the signature of the
-constructor from it.
-
-```py
-class Base:
-    def __init__(self, x: int): ...
-
-class Foo(Base): ...
-
-reveal_type(Foo(1))  # revealed: Foo
-
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
-reveal_type(Foo())  # revealed: Foo
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 1, got 2"
-reveal_type(Foo(1, 2))  # revealed: Foo
-```
-
-## Conditional `__init__`
-
-```py
-def _(flag: bool) -> None:
-    class Foo:
-        if flag:
-            def __init__(self, x: int): ...
-        else:
-            def __init__(self, x: int, y: int = 1): ...
-
-    reveal_type(Foo(1))  # revealed: Foo
-    # error: [invalid-argument-type] "Object of type `Literal["1"]` cannot be assigned to parameter 2 (`x`) of bound method `__init__`; expected type `int`"
-    reveal_type(Foo("1"))  # revealed: Foo
-    # error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
-    reveal_type(Foo())  # revealed: Foo
-    # error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 1, got 2"
-    reveal_type(Foo(1, 2))  # revealed: Foo
-```
-
-## A descriptor in place of `__init__`
-
-```py
-class SomeCallable:
-    # TODO: at runtime `__init__` is checked to return `None` and
-    # a `TypeError` is raised if it doesn't. However, apparently
-    # this is not true when the descriptor is used as `__init__`.
-    # However, we may still want to check this.
-    def __call__(self, x: int) -> str:
-        return "a"
-
-class Descriptor:
-    def __get__(self, instance, owner) -> SomeCallable:
-        return SomeCallable()
-
-class Foo:
-    __init__: Descriptor = Descriptor()
-
-reveal_type(Foo(1))  # revealed: Foo
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__call__`"
-reveal_type(Foo())  # revealed: Foo
-```
-
-## A callable instance in place of `__init__`
-
-### Bound
-
-```py
-class Callable:
-    def __call__(self, x: int) -> None:
-        pass
-
-class Foo:
-    __init__ = Callable()
-
-reveal_type(Foo(1))  # revealed: Foo
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__call__`"
-reveal_type(Foo())  # revealed: Foo
-```
-
-### Possibly Unbound
-
-```py
-def _(flag: bool) -> None:
-    class Callable:
-        if flag:
-            def __call__(self, x: int) -> None:
-                pass
-
-    class Foo:
-        __init__ = Callable()
-
-    # error: [call-non-callable] "Object of type `Callable` is not callable (possibly unbound `__call__` method)"
-    reveal_type(Foo(1))  # revealed: Foo
-    # TODO should be - error: [missing-argument] "No argument provided for required parameter `x` of bound method `__call__`"
-    # but we currently infer the signature of `__call__` as unknown, so it accepts any arguments
-    # error: [call-non-callable] "Object of type `Callable` is not callable (possibly unbound `__call__` method)"
-    reveal_type(Foo())  # revealed: Foo
-```
-
-## `__new__` and `__init__` both present
-
-### Identical signatures
-
-A common case is to have `__new__` and `__init__` with identical signatures (except for the first
-argument). We report errors for both `__new__` and `__init__` if the arguments are incorrect.
-
-At runtime `__new__` is called first and will fail without executing `__init__` if the arguments are
-incorrect. However, we decided that it is better to report errors for both methods, since after
-fixing the `__new__` method, the user may forget to fix the `__init__` method.
-
-```py
-class Foo:
-    def __new__(cls, x: int) -> "Foo":
-        return object.__new__(cls)
-
-    def __init__(self, x: int): ...
-
-# error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
-reveal_type(Foo())  # revealed: Foo
-
-reveal_type(Foo(1))  # revealed: Foo
-```
-
-### Compatible signatures
-
-But they can also be compatible, but not identical. We should correctly report errors only for the
-mthod that would fail.
-
-```py
-class Foo:
-    def __new__(cls, *args, **kwargs):
-        return object.__new__(cls)
-
-    def __init__(self, x: int) -> None:
-        self.x = x
-
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
-reveal_type(Foo())  # revealed: Foo
-reveal_type(Foo(1))  # revealed: Foo
-
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 1, got 2"
-reveal_type(Foo(1, 2))  # revealed: Foo
 ```

crates/red_knot_python_semantic/resources/mdtest/call/dunder.md

@@ -204,28 +204,6 @@ def _(flag: bool):
     reveal_type(d[0])  # revealed: str | bytes
 ```
 
-## Calling a union of types without dunder methods
-
-We add instance attributes here to make sure that we don't treat the implicit dunder calls here like
-regular method calls.
-
-```py
-def external_getitem(instance, key: int) -> str:
-    return str(key)
-
-class NotSubscriptable1:
-    def __init__(self, value: int):
-        self.__getitem__ = external_getitem
-
-class NotSubscriptable2:
-    def __init__(self, value: int):
-        self.__getitem__ = external_getitem
-
-def _(union: NotSubscriptable1 | NotSubscriptable2):
-    # error: [non-subscriptable]
-    union[0]
-```
-
 ## Calling a possibly-unbound dunder method
 
 ```py

crates/red_knot_python_semantic/resources/mdtest/call/function.md

@@ -43,7 +43,8 @@ def decorator(func) -> Callable[[], int]:
 def bar() -> str:
     return "bar"
 
-reveal_type(bar())  # revealed: int
+# TODO: should reveal `int`, as the decorator replaces `bar` with `foo`
+reveal_type(bar())  # revealed: @Todo(return type of decorated function)
 ```
 
 ## Invalid callable

crates/red_knot_python_semantic/resources/mdtest/call/getattr_static.md

@@ -56,10 +56,10 @@ We can access attributes on objects of all kinds:
 ```py
 import sys
 
-reveal_type(inspect.getattr_static(sys, "dont_write_bytecode"))  # revealed: bool
+reveal_type(inspect.getattr_static(sys, "platform"))  # revealed: LiteralString
 reveal_type(inspect.getattr_static(inspect, "getattr_static"))  # revealed: Literal[getattr_static]
 
-reveal_type(inspect.getattr_static(1, "real"))  # revealed: property
+reveal_type(inspect.getattr_static(1, "real"))  # revealed: Literal[real]
 ```
 
 (Implicit) instance attributes can also be accessed through `inspect.getattr_static`:

crates/red_knot_python_semantic/resources/mdtest/call/methods.md

@@ -410,29 +410,23 @@ def does_nothing[T](f: T) -> T:
 
 class C:
     @classmethod
-    # TODO: no error should be emitted here (needs support for generics)
-    # error: [invalid-argument-type]
     @does_nothing
     def f1(cls: type[C], x: int) -> str:
         return "a"
-    # TODO: no error should be emitted here (needs support for generics)
-    # error: [invalid-argument-type]
+
     @does_nothing
     @classmethod
     def f2(cls: type[C], x: int) -> str:
         return "a"
 
-# TODO: All of these should be `str` (and not emit an error), once we support generics
+# TODO: We do not support decorators yet (only limited special cases). Eventually,
+# these should all return `str`:
 
-# error: [call-non-callable]
-reveal_type(C.f1(1))  # revealed: Unknown
-# error: [call-non-callable]
-reveal_type(C().f1(1))  # revealed: Unknown
+reveal_type(C.f1(1))  # revealed: @Todo(return type of decorated function)
+reveal_type(C().f1(1))  # revealed: @Todo(return type of decorated function)
 
-# error: [call-non-callable]
-reveal_type(C.f2(1))  # revealed: Unknown
-# error: [call-non-callable]
-reveal_type(C().f2(1))  # revealed: Unknown
+reveal_type(C.f2(1))  # revealed: @Todo(return type of decorated function)
+reveal_type(C().f2(1))  # revealed: @Todo(return type of decorated function)
 ```
 
 [functions and methods]: https://docs.python.org/3/howto/descriptor.html#functions-and-methods

crates/red_knot_python_semantic/resources/mdtest/call/subclass_of.md

@@ -20,11 +20,9 @@ class C:
 def _(subclass_of_c: type[C]):
     reveal_type(subclass_of_c(1))  # revealed: C
 
-    # error: [invalid-argument-type] "Object of type `Literal["a"]` cannot be assigned to parameter 2 (`x`) of bound method `__init__`; expected type `int`"
+    # TODO: Those should all be errors
     reveal_type(subclass_of_c("a"))  # revealed: C
-    # error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
     reveal_type(subclass_of_c())  # revealed: C
-    # error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 1, got 2"
     reveal_type(subclass_of_c(1, 2))  # revealed: C
 ```
 

crates/red_knot_python_semantic/resources/mdtest/comparison/tuples.md

@@ -382,13 +382,13 @@ arbitrary objects to a `bool`, but a comparison of tuples will fail if the resul
 pair of elements at equivalent positions cannot be converted to a `bool`:
 
 ```py
-class NotBoolable:
-    __bool__: None = None
-
 class A:
     def __eq__(self, other) -> NotBoolable:
         return NotBoolable()
 
+class NotBoolable:
+    __bool__: None = None
+
 # error: [unsupported-bool-conversion]
 (A(),) == (A(),)
 ```

crates/red_knot_python_semantic/resources/mdtest/conditional/match.md

@@ -44,240 +44,6 @@ def _(target: int):
     reveal_type(y)  # revealed: Literal[2, 3, 4]
 ```
 
-## Value match
-
-A value pattern matches based on equality: the first `case` branch here will be taken if `subject`
-is equal to `2`, even if `subject` is not an instance of `int`. We can't know whether `C` here has a
-custom `__eq__` implementation that might cause it to compare equal to `2`, so we have to consider
-the possibility that the `case` branch might be taken even though the type `C` is disjoint from the
-type `Literal[2]`.
-
-This leads us to infer `Literal[1, 3]` as the type of `y` after the `match` statement, rather than
-`Literal[1]`:
-
-```py
-from typing import final
-
-@final
-class C:
-    pass
-
-def _(subject: C):
-    y = 1
-    match subject:
-        case 2:
-            y = 3
-    reveal_type(y)  # revealed: Literal[1, 3]
-```
-
-## Class match
-
-A `case` branch with a class pattern is taken if the subject is an instance of the given class, and
-all subpatterns in the class pattern match.
-
-```py
-from typing import final
-
-class Foo:
-    pass
-
-class FooSub(Foo):
-    pass
-
-class Bar:
-    pass
-
-@final
-class Baz:
-    pass
-
-def _(target: FooSub):
-    y = 1
-
-    match target:
-        case Baz():
-            y = 2
-        case Foo():
-            y = 3
-        case Bar():
-            y = 4
-
-    reveal_type(y)  # revealed: Literal[3]
-
-def _(target: FooSub):
-    y = 1
-
-    match target:
-        case Baz():
-            y = 2
-        case Bar():
-            y = 3
-        case Foo():
-            y = 4
-
-    reveal_type(y)  # revealed: Literal[3, 4]
-
-def _(target: FooSub | str):
-    y = 1
-
-    match target:
-        case Baz():
-            y = 2
-        case Foo():
-            y = 3
-        case Bar():
-            y = 4
-
-    reveal_type(y)  # revealed: Literal[1, 3, 4]
-```
-
-## Singleton match
-
-Singleton patterns are matched based on identity, not equality comparisons or `isinstance()` checks.
-
-```py
-from typing import Literal
-
-def _(target: Literal[True, False]):
-    y = 1
-
-    match target:
-        case True:
-            y = 2
-        case False:
-            y = 3
-        case None:
-            y = 4
-
-    # TODO: with exhaustiveness checking, this should be Literal[2, 3]
-    reveal_type(y)  # revealed: Literal[1, 2, 3]
-
-def _(target: bool):
-    y = 1
-
-    match target:
-        case True:
-            y = 2
-        case False:
-            y = 3
-        case None:
-            y = 4
-
-    # TODO: with exhaustiveness checking, this should be Literal[2, 3]
-    reveal_type(y)  # revealed: Literal[1, 2, 3]
-
-def _(target: None):
-    y = 1
-
-    match target:
-        case True:
-            y = 2
-        case False:
-            y = 3
-        case None:
-            y = 4
-
-    reveal_type(y)  # revealed: Literal[4]
-
-def _(target: None | Literal[True]):
-    y = 1
-
-    match target:
-        case True:
-            y = 2
-        case False:
-            y = 3
-        case None:
-            y = 4
-
-    # TODO: with exhaustiveness checking, this should be Literal[2, 4]
-    reveal_type(y)  # revealed: Literal[1, 2, 4]
-
-# bool is an int subclass
-def _(target: int):
-    y = 1
-
-    match target:
-        case True:
-            y = 2
-        case False:
-            y = 3
-        case None:
-            y = 4
-
-    reveal_type(y)  # revealed: Literal[1, 2, 3]
-
-def _(target: str):
-    y = 1
-
-    match target:
-        case True:
-            y = 2
-        case False:
-            y = 3
-        case None:
-            y = 4
-
-    reveal_type(y)  # revealed: Literal[1]
-```
-
-## Or match
-
-A `|` pattern matches if any of the subpatterns match.
-
-```py
-from typing import Literal, final
-
-def _(target: Literal["foo", "baz"]):
-    y = 1
-
-    match target:
-        case "foo" | "bar":
-            y = 2
-        case "baz":
-            y = 3
-
-    # TODO: with exhaustiveness, this should be Literal[2, 3]
-    reveal_type(y)  # revealed: Literal[1, 2, 3]
-
-def _(target: None):
-    y = 1
-
-    match target:
-        case None | 3:
-            y = 2
-        case "foo" | 4 | True:
-            y = 3
-
-    reveal_type(y)  # revealed: Literal[2]
-
-@final
-class Baz:
-    pass
-
-def _(target: int | None | float):
-    y = 1
-
-    match target:
-        case None | 3:
-            y = 2
-        case Baz():
-            y = 3
-
-    reveal_type(y)  # revealed: Literal[1, 2]
-
-def _(target: None | str):
-    y = 1
-
-    match target:
-        case Baz() | True | False:
-            y = 2
-        case int():
-            y = 3
-
-    reveal_type(y)  # revealed: Literal[1, 3]
-```
-
 ## Guard with object that implements `__bool__` incorrectly
 
 ```py

crates/red_knot_python_semantic/resources/mdtest/decorators.md

@@ -1,237 +0,0 @@
-# Decorators
-
-Decorators are a way to modify function and class behavior. A decorator is a callable that takes the
-function or class as an argument and returns a modified version of it.
-
-## Basic example
-
-A decorated function definition is conceptually similar to `def f(x): ...` followed by
-`f = decorator(f)`. This means that the type of a decorated function is the same as the return type
-of the decorator (which does not necessarily need to be a callable type):
-
-```py
-def custom_decorator(f) -> int:
-    return 1
-
-@custom_decorator
-def f(x): ...
-
-reveal_type(f)  # revealed: int
-```
-
-## Type-annotated decorator
-
-More commonly, a decorator returns a modified callable type:
-
-```py
-from typing import Callable
-
-def ensure_positive(wrapped: Callable[[int], bool]) -> Callable[[int], bool]:
-    return lambda x: wrapped(x) and x > 0
-
-@ensure_positive
-def even(x: int) -> bool:
-    return x % 2 == 0
-
-reveal_type(even)  # revealed: (int, /) -> bool
-reveal_type(even(4))  # revealed: bool
-```
-
-## Decorators which take arguments
-
-Decorators can be arbitrary expressions. This is often useful when the decorator itself takes
-arguments:
-
-```py
-from typing import Callable
-
-def ensure_larger_than(lower_bound: int) -> Callable[[Callable[[int], bool]], Callable[[int], bool]]:
-    def decorator(wrapped: Callable[[int], bool]) -> Callable[[int], bool]:
-        return lambda x: wrapped(x) and x >= lower_bound
-    return decorator
-
-@ensure_larger_than(10)
-def even(x: int) -> bool:
-    return x % 2 == 0
-
-reveal_type(even)  # revealed: (int, /) -> bool
-reveal_type(even(14))  # revealed: bool
-```
-
-## Multiple decorators
-
-Multiple decorators can be applied to a single function. They are applied in "bottom-up" order,
-meaning that the decorator closest to the function definition is applied first:
-
-```py
-def maps_to_str(f) -> str:
-    return "a"
-
-def maps_to_int(f) -> int:
-    return 1
-
-def maps_to_bytes(f) -> bytes:
-    return b"a"
-
-@maps_to_str
-@maps_to_int
-@maps_to_bytes
-def f(x): ...
-
-reveal_type(f)  # revealed: str
-```
-
-## Decorating with a class
-
-When a function is decorated with a class-based decorator, the decorated function turns into an
-instance of the class (see also: [properties](properties.md)). Attributes of the class can be
-accessed on the decorated function.
-
-```py
-class accept_strings:
-    custom_attribute: str = "a"
-
-    def __init__(self, f):
-        self.f = f
-
-    def __call__(self, x: str | int) -> bool:
-        return self.f(int(x))
-
-@accept_strings
-def even(x: int) -> bool:
-    return x > 0
-
-reveal_type(even)  # revealed: accept_strings
-reveal_type(even.custom_attribute)  # revealed: str
-reveal_type(even("1"))  # revealed: bool
-reveal_type(even(1))  # revealed: bool
-
-# error: [invalid-argument-type]
-even(None)
-```
-
-## Common decorator patterns
-
-### `functools.wraps`
-
-This test mainly makes sure that we do not emit any diagnostics in a case where the decorator is
-implemented using `functools.wraps`.
-
-```py
-from typing import Callable
-from functools import wraps
-
-def custom_decorator(f) -> Callable[[int], str]:
-    @wraps(f)
-    def wrapper(*args, **kwargs):
-        print("Calling decorated function")
-        return f(*args, **kwargs)
-    return wrapper
-
-@custom_decorator
-def f(x: int) -> str:
-    return str(x)
-
-reveal_type(f)  # revealed: (int, /) -> str
-```
-
-### `functools.cache`
-
-```py
-from functools import cache
-
-@cache
-def f(x: int) -> int:
-    return x**2
-
-# TODO: Should be `_lru_cache_wrapper[int]`
-reveal_type(f)  # revealed: @Todo(generics)
-
-# TODO: Should be `int`
-reveal_type(f(1))  # revealed: @Todo(generics)
-```
-
-## Lambdas as decorators
-
-```py
-@lambda f: f
-def g(x: int) -> str:
-    return "a"
-
-# TODO: This should be `Literal[g]` or `(int, /) -> str`
-reveal_type(g)  # revealed: Unknown
-```
-
-## Error cases
-
-### Unknown decorator
-
-```py
-# error: [unresolved-reference] "Name `unknown_decorator` used when not defined"
-@unknown_decorator
-def f(x): ...
-
-reveal_type(f)  # revealed: Unknown
-```
-
-### Error in the decorator expression
-
-```py
-# error: [unsupported-operator]
-@(1 + "a")
-def f(x): ...
-
-reveal_type(f)  # revealed: Unknown
-```
-
-### Non-callable decorator
-
-```py
-non_callable = 1
-
-# error: [call-non-callable] "Object of type `Literal[1]` is not callable"
-@non_callable
-def f(x): ...
-
-reveal_type(f)  # revealed: Unknown
-```
-
-### Wrong signature
-
-#### Wrong argument type
-
-Here, we emit a diagnostic since `wrong_signature` takes an `int` instead of a callable type as the
-first argument:
-
-```py
-def wrong_signature(f: int) -> str:
-    return "a"
-
-# error: [invalid-argument-type] "Object of type `Literal[f]` cannot be assigned to parameter 1 (`f`) of function `wrong_signature`; expected type `int`"
-@wrong_signature
-def f(x): ...
-
-reveal_type(f)  # revealed: str
-```
-
-#### Wrong number of arguments
-
-Decorators need to be callable with a single argument. If they are not, we emit a diagnostic:
-
-```py
-def takes_two_arguments(f, g) -> str:
-    return "a"
-
-# error: [missing-argument] "No argument provided for required parameter `g` of function `takes_two_arguments`"
-@takes_two_arguments
-def f(x): ...
-
-reveal_type(f)  # revealed: str
-
-def takes_no_argument() -> str:
-    return "a"
-
-# error: [too-many-positional-arguments] "Too many positional arguments to function `takes_no_argument`: expected 0, got 1"
-@takes_no_argument
-def g(x): ...
-```

crates/red_knot_python_semantic/resources/mdtest/descriptor_protocol.md

@@ -506,7 +506,8 @@ class C:
     @property
     def name(self) -> str:
         return self._name or "Unset"
-
+    # TODO: No diagnostic should be emitted here
+    # error: [unresolved-attribute] "Type `Literal[name]` has no attribute `setter`"
     @name.setter
     def name(self, value: str | None) -> None:
         self._value = value
@@ -514,13 +515,22 @@ class C:
 c = C()
 
 reveal_type(c._name)  # revealed: str | None
-reveal_type(c.name)  # revealed: str
-reveal_type(C.name)  # revealed: property
 
+# TODO: Should be `str`
+reveal_type(c.name)  # revealed: <bound method `name` of `C`>
+
+# Should be `builtins.property`
+reveal_type(C.name)  # revealed: Literal[name]
+
+# TODO: These should not emit errors
+# error: [invalid-assignment]
 c.name = "new"
+
+# error: [invalid-assignment]
 c.name = None
 
-# error: [invalid-assignment] "Invalid assignment to data descriptor attribute `name` on type `C` with custom `__set__` method"
+# TODO: this should be an error, but with a proper error message
+# error: [invalid-assignment] "Implicit shadowing of function `name`; annotate to make it explicit if this is intentional"
 c.name = 42
 ```
 
@@ -577,7 +587,7 @@ reveal_type(wrapper_descriptor(f, None, type(f)))  # revealed: Literal[f]
 reveal_type(f.__get__.__hash__)  # revealed: <bound method `__hash__` of `MethodWrapperType`>
 
 # Attribute access on the wrapper-descriptor falls back to `WrapperDescriptorType`:
-reveal_type(wrapper_descriptor.__qualname__)  # revealed: str
+reveal_type(wrapper_descriptor.__qualname__)  # revealed: @Todo(@property)
 ```
 
 We can also bind the free function `f` to an instance of a class `C`:

crates/red_knot_python_semantic/resources/mdtest/directives/assert_never.md

@@ -1,106 +0,0 @@
-# `assert_never`
-
-## Basic functionality
-
-`assert_never` makes sure that the type of the argument is `Never`. If it is not, a
-`type-assertion-failure` diagnostic is emitted.
-
-```py
-from typing_extensions import assert_never, Never, Any
-from knot_extensions import Unknown
-
-def _(never: Never, any_: Any, unknown: Unknown, flag: bool):
-    assert_never(never)  # fine
-
-    assert_never(0)  # error: [type-assertion-failure]
-    assert_never("")  # error: [type-assertion-failure]
-    assert_never(None)  # error: [type-assertion-failure]
-    assert_never([])  # error: [type-assertion-failure]
-    assert_never({})  # error: [type-assertion-failure]
-    assert_never(())  # error: [type-assertion-failure]
-    assert_never(1 if flag else never)  # error: [type-assertion-failure]
-
-    assert_never(any_)  # error: [type-assertion-failure]
-    assert_never(unknown)  # error: [type-assertion-failure]
-```
-
-## Use case: Type narrowing and exhaustiveness checking
-
-`assert_never` can be used in combination with type narrowing as a way to make sure that all cases
-are handled in a series of `isinstance` checks or other narrowing patterns that are supported.
-
-```py
-from typing_extensions import assert_never, Literal
-
-class A: ...
-class B: ...
-class C: ...
-
-def if_else_isinstance_success(obj: A | B):
-    if isinstance(obj, A):
-        pass
-    elif isinstance(obj, B):
-        pass
-    elif isinstance(obj, C):
-        pass
-    else:
-        assert_never(obj)
-
-def if_else_isinstance_error(obj: A | B):
-    if isinstance(obj, A):
-        pass
-    # B is missing
-    elif isinstance(obj, C):
-        pass
-    else:
-        # error: [type-assertion-failure] "Expected type `Never`, got `B & ~A & ~C` instead"
-        assert_never(obj)
-
-def if_else_singletons_success(obj: Literal[1, "a"] | None):
-    if obj == 1:
-        pass
-    elif obj == "a":
-        pass
-    elif obj is None:
-        pass
-    else:
-        assert_never(obj)
-
-def if_else_singletons_error(obj: Literal[1, "a"] | None):
-    if obj == 1:
-        pass
-    elif obj is "A":  # "A" instead of "a"
-        pass
-    elif obj is None:
-        pass
-    else:
-        # error: [type-assertion-failure] "Expected type `Never`, got `Literal["a"]` instead"
-        assert_never(obj)
-
-def match_singletons_success(obj: Literal[1, "a"] | None):
-    match obj:
-        case 1:
-            pass
-        case "a":
-            pass
-        case None:
-            pass
-        case _ as obj:
-            # TODO: Ideally, we would not emit an error here
-            # error: [type-assertion-failure] "Expected type `Never`, got `@Todo"
-            assert_never(obj)
-
-def match_singletons_error(obj: Literal[1, "a"] | None):
-    match obj:
-        case 1:
-            pass
-        case "A":  # "A" instead of "a"
-            pass
-        case None:
-            pass
-        case _ as obj:
-            # TODO: We should emit an error here, but the message should
-            # show the type `Literal["a"]` instead of `@Todo(…)`.
-            # error: [type-assertion-failure] "Expected type `Never`, got `@Todo"
-            assert_never(obj)
-```

crates/red_knot_python_semantic/resources/mdtest/directives/cast.md

@@ -5,7 +5,7 @@
 The (inferred) type of the value and the given type do not need to have any correlation.
 
 ```py
-from typing import Literal, cast, Any
+from typing import Literal, cast
 
 reveal_type(True)  # revealed: Literal[True]
 reveal_type(cast(str, True))  # revealed: str
@@ -25,46 +25,4 @@ reveal_type(cast(1, True))  # revealed: Unknown
 cast(str)
 # error: [too-many-positional-arguments] "Too many positional arguments to function `cast`: expected 2, got 3"
 cast(str, b"ar", "foo")
-
-def function_returning_int() -> int:
-    return 10
-
-# error: [redundant-cast] "Value is already of type `int`"
-cast(int, function_returning_int())
-
-def function_returning_any() -> Any:
-    return "blah"
-
-# error: [redundant-cast] "Value is already of type `Any`"
-cast(Any, function_returning_any())
-```
-
-Complex type expressions (which may be unsupported) do not lead to spurious `[redundant-cast]`
-diagnostics.
-
-```py
-from typing import Callable
-
-def f(x: Callable[[dict[str, int]], None], y: tuple[dict[str, int]]):
-    a = cast(Callable[[list[bytes]], None], x)
-    b = cast(tuple[list[bytes]], y)
-```
-
-A cast from `Todo` or `Unknown` to `Any` is not considered a "redundant cast": even if these are
-understood as gradually equivalent types by red-knot, they are understood as different types by
-human readers of red-knot's output. For `Unknown` in particular, we may consider it differently in
-the context of some opt-in diagnostics, as it indicates that the gradual type has come about due to
-an invalid annotation, missing annotation or missing type argument somewhere.
-
-```py
-from knot_extensions import Unknown
-
-def f(x: Any, y: Unknown, z: Any | str | int):
-    a = cast(dict[str, Any], x)
-    reveal_type(a)  # revealed: @Todo(generics)
-
-    b = cast(Any, y)
-    reveal_type(b)  # revealed: Any
-
-    c = cast(str | int | Any, z)  # error: [redundant-cast]
 ```

crates/red_knot_python_semantic/resources/mdtest/doc/public_type_undeclared_symbols.md

@@ -122,4 +122,4 @@ class Wrapper:
 reveal_type(Wrapper.value)  # revealed: Unknown | None
 ```
 
-[gradual guarantee]: https://typing.python.org/en/latest/spec/concepts.html#the-gradual-guarantee
+[gradual guarantee]: https://typing.readthedocs.io/en/latest/spec/concepts.html#the-gradual-guarantee

crates/red_knot_python_semantic/resources/mdtest/function/parameters.md

@@ -73,42 +73,3 @@ from typing import Any
 def g(x: Any = "foo"):
     reveal_type(x)  # revealed: Any | Literal["foo"]
 ```
-
-## Stub functions
-
-### In Protocol
-
-```py
-from typing import Protocol
-
-class Foo(Protocol):
-    def x(self, y: bool = ...): ...
-    def y[T](self, y: T = ...) -> T: ...
-
-class GenericFoo[T](Protocol):
-    def x(self, y: bool = ...) -> T: ...
-```
-
-### In abstract method
-
-```py
-from abc import abstractmethod
-
-class Bar:
-    @abstractmethod
-    def x(self, y: bool = ...): ...
-    @abstractmethod
-    def y[T](self, y: T = ...) -> T: ...
-```
-
-### In function overload
-
-```py
-from typing import overload
-
-@overload
-def x(y: None = ...) -> None: ...
-@overload
-def x(y: int) -> str: ...
-def x(y: int | None = None) -> str | None: ...
-```

crates/red_knot_python_semantic/resources/mdtest/function/return_type.md

@@ -269,66 +269,3 @@ def f(cond: bool) -> int:
     if cond:
         return 2
 ```
-
-## NotImplemented
-
-### Default Python version
-
-`NotImplemented` is a special symbol in Python. It is commonly used to control the fallback behavior
-of special dunder methods. You can find more details in the
-[documentation](https://docs.python.org/3/library/numbers.html#implementing-the-arithmetic-operations).
-
-```py
-from __future__ import annotations
-
-class A:
-    def __add__(self, o: A) -> A:
-        return NotImplemented
-```
-
-However, as shown below, `NotImplemented` should not cause issues with the declared return type.
-
-```py
-def f() -> int:
-    return NotImplemented
-
-def f(cond: bool) -> int:
-    if cond:
-        return 1
-    else:
-        return NotImplemented
-
-def f(x: int) -> int | str:
-    if x < 0:
-        return -1
-    elif x == 0:
-        return NotImplemented
-    else:
-        return "test"
-
-def f(cond: bool) -> str:
-    return "hello" if cond else NotImplemented
-
-def f(cond: bool) -> int:
-    # error: [invalid-return-type] "Object of type `Literal["hello"]` is not assignable to return type `int`"
-    return "hello" if cond else NotImplemented
-```
-
-### Python 3.10+
-
-Unlike Ellipsis, `_NotImplementedType` remains in `builtins.pyi` regardless of the Python version.
-Even if `builtins._NotImplementedType` is fully replaced by `types.NotImplementedType` in the
-future, it should still work as expected.
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-def f() -> int:
-    return NotImplemented
-
-def f(cond: bool) -> str:
-    return "hello" if cond else NotImplemented
-```

crates/red_knot_python_semantic/resources/mdtest/generics/classes.md

@@ -13,6 +13,8 @@ class C[T]: ...
 A class that inherits from a generic class, and fills its type parameters with typevars, is generic:
 
 ```py
+# TODO: no error
+# error: [non-subscriptable]
 class D[U](C[U]): ...
 ```
 
@@ -20,6 +22,8 @@ A class that inherits from a generic class, but fills its type parameters with c
 _not_ generic:
 
 ```py
+# TODO: no error
+# error: [non-subscriptable]
 class E(C[int]): ...
 ```
 
@@ -53,7 +57,7 @@ class D(C[T]): ...
 
 (Examples `E` and `F` from above do not have analogues in the legacy syntax.)
 
-## Specializing generic classes explicitly
+## Inferring generic class parameters
 
 The type parameter can be specified explicitly:
 
@@ -61,77 +65,25 @@ The type parameter can be specified explicitly:
 class C[T]:
     x: T
 
-reveal_type(C[int]())  # revealed: C[int]
+# TODO: no error
+# TODO: revealed: C[int]
+# error: [non-subscriptable]
+reveal_type(C[int]())  # revealed: C
 ```
 
-The specialization must match the generic types:
-
-```py
-# error: [too-many-positional-arguments] "Too many positional arguments to class `C`: expected 1, got 2"
-reveal_type(C[int, int]())  # revealed: Unknown
-```
-
-If the type variable has an upper bound, the specialized type must satisfy that bound:
-
-```py
-class Bounded[T: int]: ...
-class BoundedByUnion[T: int | str]: ...
-class IntSubclass(int): ...
-
-reveal_type(Bounded[int]())  # revealed: Bounded[int]
-reveal_type(Bounded[IntSubclass]())  # revealed: Bounded[IntSubclass]
-
-# error: [invalid-argument-type] "Object of type `str` cannot be assigned to parameter 1 (`T`) of class `Bounded`; expected type `int`"
-reveal_type(Bounded[str]())  # revealed: Unknown
-
-# error:  [invalid-argument-type] "Object of type `int | str` cannot be assigned to parameter 1 (`T`) of class `Bounded`; expected type `int`"
-reveal_type(Bounded[int | str]())  # revealed: Unknown
-
-reveal_type(BoundedByUnion[int]())  # revealed: BoundedByUnion[int]
-reveal_type(BoundedByUnion[IntSubclass]())  # revealed: BoundedByUnion[IntSubclass]
-reveal_type(BoundedByUnion[str]())  # revealed: BoundedByUnion[str]
-reveal_type(BoundedByUnion[int | str]())  # revealed: BoundedByUnion[int | str]
-```
-
-If the type variable is constrained, the specialized type must satisfy those constraints:
-
-```py
-class Constrained[T: (int, str)]: ...
-
-reveal_type(Constrained[int]())  # revealed: Constrained[int]
-
-# TODO: error: [invalid-argument-type]
-# TODO: revealed: Constrained[Unknown]
-reveal_type(Constrained[IntSubclass]())  # revealed: Constrained[IntSubclass]
-
-reveal_type(Constrained[str]())  # revealed: Constrained[str]
-
-# TODO: error: [invalid-argument-type]
-# TODO: revealed: Unknown
-reveal_type(Constrained[int | str]())  # revealed: Constrained[int | str]
-
-# error: [invalid-argument-type] "Object of type `object` cannot be assigned to parameter 1 (`T`) of class `Constrained`; expected type `int | str`"
-reveal_type(Constrained[object]())  # revealed: Unknown
-```
-
-## Inferring generic class parameters
-
 We can infer the type parameter from a type context:
 
 ```py
-class C[T]:
-    x: T
-
 c: C[int] = C()
 # TODO: revealed: C[int]
-reveal_type(c)  # revealed: C[Unknown]
+reveal_type(c)  # revealed: C
 ```
 
 The typevars of a fully specialized generic class should no longer be visible:
 
 ```py
 # TODO: revealed: int
-reveal_type(c.x)  # revealed: Unknown
+reveal_type(c.x)  # revealed: T
 ```
 
 If the type parameter is not specified explicitly, and there are no constraints that let us infer a
@@ -140,13 +92,15 @@ specific type, we infer the typevar's default type:
 ```py
 class D[T = int]: ...
 
-reveal_type(D())  # revealed: D[int]
+# TODO: revealed: D[int]
+reveal_type(D())  # revealed: D
 ```
 
 If a typevar does not provide a default, we use `Unknown`:
 
 ```py
-reveal_type(C())  # revealed: C[Unknown]
+# TODO: revealed: C[Unknown]
+reveal_type(C())  # revealed: C
 ```
 
 If the type of a constructor parameter is a class typevar, we can use that to infer the type
@@ -157,14 +111,14 @@ class E[T]:
     def __init__(self, x: T) -> None: ...
 
 # TODO: revealed: E[int] or E[Literal[1]]
-reveal_type(E(1))  # revealed: E[Unknown]
+reveal_type(E(1))  # revealed: E
 ```
 
 The types inferred from a type context and from a constructor parameter must be consistent with each
 other:
 
 ```py
-# TODO: error: [invalid-argument-type]
+# TODO: error
 wrong_innards: E[int] = E("five")
 ```
 
@@ -177,33 +131,17 @@ propagate through:
 class Base[T]:
     x: T | None = None
 
+# TODO: no error
+# error: [non-subscriptable]
 class Sub[U](Base[U]): ...
 
-reveal_type(Base[int].x)  # revealed: int | None
-reveal_type(Sub[int].x)  # revealed: int | None
-```
-
-## Generic methods
-
-Generic classes can contain methods that are themselves generic. The generic methods can refer to
-the typevars of the enclosing generic class, and introduce new (distinct) typevars that are only in
-scope for the method.
-
-```py
-class C[T]:
-    def method[U](self, u: U) -> U:
-        return u
-    # error: [unresolved-reference]
-    def cannot_use_outside_of_method(self, u: U): ...
-
-    # TODO: error
-    def cannot_shadow_class_typevar[T](self, t: T): ...
-
-c: C[int] = C[int]()
 # TODO: no error
-# TODO: revealed: str or Literal["string"]
-# error: [invalid-argument-type]
-reveal_type(c.method("string"))  # revealed: U
+# TODO: revealed: int | None
+# error: [non-subscriptable]
+reveal_type(Base[int].x)  # revealed: T | None
+# TODO: revealed: int | None
+# error: [non-subscriptable]
+reveal_type(Sub[int].x)  # revealed: T | None
 ```
 
 ## Cyclic class definition
@@ -217,6 +155,8 @@ Here, `Sub` is not a generic class, since it fills its superclass's type paramet
 
 ```pyi
 class Base[T]: ...
+# TODO: no error
+# error: [non-subscriptable]
 class Sub(Base[Sub]): ...
 
 reveal_type(Sub)  # revealed: Literal[Sub]
@@ -228,6 +168,9 @@ A similar case can work in a non-stub file, if forward references are stringifie
 
 ```py
 class Base[T]: ...
+
+# TODO: no error
+# error: [non-subscriptable]
 class Sub(Base["Sub"]): ...
 
 reveal_type(Sub)  # revealed: Literal[Sub]
@@ -240,6 +183,8 @@ In a non-stub file, without stringified forward references, this raises a `NameE
 ```py
 class Base[T]: ...
 
+# TODO: the unresolved-reference error is correct, the non-subscriptable is not
+# error: [non-subscriptable]
 # error: [unresolved-reference]
 class Sub(Base[Sub]): ...
 ```

crates/red_knot_python_semantic/resources/mdtest/generics/functions.md

@@ -107,7 +107,8 @@ def good_return[T: int](x: T) -> T:
     return x
 
 def bad_return[T: int](x: T) -> T:
-    # error: [invalid-return-type] "Object of type `int` is not assignable to return type `T`"
+    # TODO: error: int is not assignable to T
+    # error: [unsupported-operator] "Operator `+` is unsupported between objects of type `T` and `Literal[1]`"
     return x + 1
 ```
 

crates/red_knot_python_semantic/resources/mdtest/generics/legacy.md

@@ -69,4 +69,4 @@ from typing import TypeVar
 T = TypeVar("T", int)
 ```
 
-[generics]: https://typing.python.org/en/latest/spec/generics.html
+[generics]: https://typing.readthedocs.io/en/latest/spec/generics.html

crates/red_knot_python_semantic/resources/mdtest/generics/pep695.md

@@ -48,523 +48,4 @@ class C[T]:
         reveal_type(x)  # revealed: T
 ```
 
-## Fully static typevars
-
-We consider a typevar to be fully static unless it has a non-fully-static bound or constraint. This
-is true even though a fully static typevar might be specialized to a gradual form like `Any`. (This
-is similar to how you can assign an expression whose type is not fully static to a target whose type
-is.)
-
-```py
-from knot_extensions import is_fully_static, static_assert
-from typing import Any
-
-def unbounded_unconstrained[T](t: list[T]) -> None:
-    static_assert(is_fully_static(T))
-
-def bounded[T: int](t: list[T]) -> None:
-    static_assert(is_fully_static(T))
-
-def bounded_by_gradual[T: Any](t: list[T]) -> None:
-    static_assert(not is_fully_static(T))
-
-def constrained[T: (int, str)](t: list[T]) -> None:
-    static_assert(is_fully_static(T))
-
-def constrained_by_gradual[T: (int, Any)](t: list[T]) -> None:
-    static_assert(not is_fully_static(T))
-```
-
-## Subtyping and assignability
-
-(Note: for simplicity, all of the prose in this section refers to _subtyping_ involving fully static
-typevars. Unless otherwise noted, all of the claims also apply to _assignability_ involving gradual
-typevars.)
-
-We can make no assumption about what type an unbounded, unconstrained, fully static typevar will be
-specialized to. Properties are true of the typevar only if they are true for every valid
-specialization. Thus, the typevar is a subtype of itself and of `object`, but not of any other type
-(including other typevars).
-
-```py
-from knot_extensions import is_assignable_to, is_subtype_of, static_assert
-
-class Super: ...
-class Base(Super): ...
-class Sub(Base): ...
-class Unrelated: ...
-
-def unbounded_unconstrained[T, U](t: list[T], u: list[U]) -> None:
-    static_assert(is_assignable_to(T, T))
-    static_assert(is_assignable_to(T, object))
-    static_assert(not is_assignable_to(T, Super))
-    static_assert(is_assignable_to(U, U))
-    static_assert(is_assignable_to(U, object))
-    static_assert(not is_assignable_to(U, Super))
-    static_assert(not is_assignable_to(T, U))
-    static_assert(not is_assignable_to(U, T))
-
-    static_assert(is_subtype_of(T, T))
-    static_assert(is_subtype_of(T, object))
-    static_assert(not is_subtype_of(T, Super))
-    static_assert(is_subtype_of(U, U))
-    static_assert(is_subtype_of(U, object))
-    static_assert(not is_subtype_of(U, Super))
-    static_assert(not is_subtype_of(T, U))
-    static_assert(not is_subtype_of(U, T))
-```
-
-A bounded typevar is assignable to its bound, and a bounded, fully static typevar is a subtype of
-its bound. (A typevar with a non-fully-static bound is itself non-fully-static, and therefore does
-not participate in subtyping.) A fully static bound is not assignable to, nor a subtype of, the
-typevar, since the typevar might be specialized to a smaller type. (This is true even if the bound
-is a final class, since the typevar can still be specialized to `Never`.)
-
-```py
-from typing import Any
-from typing_extensions import final
-
-def bounded[T: Super](t: list[T]) -> None:
-    static_assert(is_assignable_to(T, Super))
-    static_assert(not is_assignable_to(T, Sub))
-    static_assert(not is_assignable_to(Super, T))
-    static_assert(not is_assignable_to(Sub, T))
-
-    static_assert(is_subtype_of(T, Super))
-    static_assert(not is_subtype_of(T, Sub))
-    static_assert(not is_subtype_of(Super, T))
-    static_assert(not is_subtype_of(Sub, T))
-
-def bounded_by_gradual[T: Any](t: list[T]) -> None:
-    static_assert(is_assignable_to(T, Any))
-    static_assert(is_assignable_to(Any, T))
-    static_assert(is_assignable_to(T, Super))
-    static_assert(not is_assignable_to(Super, T))
-    static_assert(is_assignable_to(T, Sub))
-    static_assert(not is_assignable_to(Sub, T))
-
-    static_assert(not is_subtype_of(T, Any))
-    static_assert(not is_subtype_of(Any, T))
-    static_assert(not is_subtype_of(T, Super))
-    static_assert(not is_subtype_of(Super, T))
-    static_assert(not is_subtype_of(T, Sub))
-    static_assert(not is_subtype_of(Sub, T))
-
-@final
-class FinalClass: ...
-
-def bounded_final[T: FinalClass](t: list[T]) -> None:
-    static_assert(is_assignable_to(T, FinalClass))
-    static_assert(not is_assignable_to(FinalClass, T))
-
-    static_assert(is_subtype_of(T, FinalClass))
-    static_assert(not is_subtype_of(FinalClass, T))
-```
-
-Two distinct fully static typevars are not subtypes of each other, even if they have the same
-bounds, since there is (still) no guarantee that they will be specialized to the same type. This is
-true even if both typevars are bounded by the same final class, since you can specialize the
-typevars to `Never` in addition to that final class.
-
-```py
-def two_bounded[T: Super, U: Super](t: list[T], u: list[U]) -> None:
-    static_assert(not is_assignable_to(T, U))
-    static_assert(not is_assignable_to(U, T))
-
-    static_assert(not is_subtype_of(T, U))
-    static_assert(not is_subtype_of(U, T))
-
-def two_final_bounded[T: FinalClass, U: FinalClass](t: list[T], u: list[U]) -> None:
-    static_assert(not is_assignable_to(T, U))
-    static_assert(not is_assignable_to(U, T))
-
-    static_assert(not is_subtype_of(T, U))
-    static_assert(not is_subtype_of(U, T))
-```
-
-A constrained fully static typevar is assignable to the union of its constraints, but not to any of
-the constraints individually. None of the constraints are subtypes of the typevar, though the
-intersection of all of its constraints is a subtype of the typevar.
-
-```py
-from knot_extensions import Intersection
-
-def constrained[T: (Base, Unrelated)](t: list[T]) -> None:
-    static_assert(not is_assignable_to(T, Super))
-    static_assert(not is_assignable_to(T, Base))
-    static_assert(not is_assignable_to(T, Sub))
-    static_assert(not is_assignable_to(T, Unrelated))
-    static_assert(is_assignable_to(T, Super | Unrelated))
-    static_assert(is_assignable_to(T, Base | Unrelated))
-    static_assert(not is_assignable_to(T, Sub | Unrelated))
-    static_assert(not is_assignable_to(Super, T))
-    static_assert(not is_assignable_to(Unrelated, T))
-    static_assert(not is_assignable_to(Super | Unrelated, T))
-    static_assert(is_assignable_to(Intersection[Base, Unrelated], T))
-
-    static_assert(not is_subtype_of(T, Super))
-    static_assert(not is_subtype_of(T, Base))
-    static_assert(not is_subtype_of(T, Sub))
-    static_assert(not is_subtype_of(T, Unrelated))
-    static_assert(is_subtype_of(T, Super | Unrelated))
-    static_assert(is_subtype_of(T, Base | Unrelated))
-    static_assert(not is_subtype_of(T, Sub | Unrelated))
-    static_assert(not is_subtype_of(Super, T))
-    static_assert(not is_subtype_of(Unrelated, T))
-    static_assert(not is_subtype_of(Super | Unrelated, T))
-    static_assert(is_subtype_of(Intersection[Base, Unrelated], T))
-
-def constrained_by_gradual[T: (Base, Any)](t: list[T]) -> None:
-    static_assert(is_assignable_to(T, Super))
-    static_assert(is_assignable_to(T, Base))
-    static_assert(not is_assignable_to(T, Sub))
-    static_assert(not is_assignable_to(T, Unrelated))
-    static_assert(is_assignable_to(T, Any))
-    static_assert(is_assignable_to(T, Super | Any))
-    static_assert(is_assignable_to(T, Super | Unrelated))
-    static_assert(not is_assignable_to(Super, T))
-    static_assert(is_assignable_to(Base, T))
-    static_assert(not is_assignable_to(Unrelated, T))
-    static_assert(is_assignable_to(Any, T))
-    static_assert(not is_assignable_to(Super | Any, T))
-    static_assert(is_assignable_to(Base | Any, T))
-    static_assert(not is_assignable_to(Super | Unrelated, T))
-    static_assert(is_assignable_to(Intersection[Base, Unrelated], T))
-    static_assert(is_assignable_to(Intersection[Base, Any], T))
-
-    static_assert(not is_subtype_of(T, Super))
-    static_assert(not is_subtype_of(T, Base))
-    static_assert(not is_subtype_of(T, Sub))
-    static_assert(not is_subtype_of(T, Unrelated))
-    static_assert(not is_subtype_of(T, Any))
-    static_assert(not is_subtype_of(T, Super | Any))
-    static_assert(not is_subtype_of(T, Super | Unrelated))
-    static_assert(not is_subtype_of(Super, T))
-    static_assert(not is_subtype_of(Base, T))
-    static_assert(not is_subtype_of(Unrelated, T))
-    static_assert(not is_subtype_of(Any, T))
-    static_assert(not is_subtype_of(Super | Any, T))
-    static_assert(not is_subtype_of(Base | Any, T))
-    static_assert(not is_subtype_of(Super | Unrelated, T))
-    static_assert(not is_subtype_of(Intersection[Base, Unrelated], T))
-    static_assert(not is_subtype_of(Intersection[Base, Any], T))
-```
-
-Two distinct fully static typevars are not subtypes of each other, even if they have the same
-constraints, and even if any of the constraints are final. There must always be at least two
-distinct constraints, meaning that there is (still) no guarantee that they will be specialized to
-the same type.
-
-```py
-def two_constrained[T: (int, str), U: (int, str)](t: list[T], u: list[U]) -> None:
-    static_assert(not is_assignable_to(T, U))
-    static_assert(not is_assignable_to(U, T))
-
-    static_assert(not is_subtype_of(T, U))
-    static_assert(not is_subtype_of(U, T))
-
-@final
-class AnotherFinalClass: ...
-
-def two_final_constrained[T: (FinalClass, AnotherFinalClass), U: (FinalClass, AnotherFinalClass)](t: list[T], u: list[U]) -> None:
-    static_assert(not is_assignable_to(T, U))
-    static_assert(not is_assignable_to(U, T))
-
-    static_assert(not is_subtype_of(T, U))
-    static_assert(not is_subtype_of(U, T))
-```
-
-## Singletons and single-valued types
-
-(Note: for simplicity, all of the prose in this section refers to _singleton_ types, but all of the
-claims also apply to _single-valued_ types.)
-
-An unbounded, unconstrained typevar is not a singleton, because it can be specialized to a
-non-singleton type.
-
-```py
-from knot_extensions import is_singleton, is_single_valued, static_assert
-
-def unbounded_unconstrained[T](t: list[T]) -> None:
-    static_assert(not is_singleton(T))
-    static_assert(not is_single_valued(T))
-```
-
-A bounded typevar is not a singleton, even if its bound is a singleton, since it can still be
-specialized to `Never`.
-
-```py
-def bounded[T: None](t: list[T]) -> None:
-    static_assert(not is_singleton(T))
-    static_assert(not is_single_valued(T))
-```
-
-A constrained typevar is a singleton if all of its constraints are singletons. (Note that you cannot
-specialize a constrained typevar to a subtype of a constraint.)
-
-```py
-from typing_extensions import Literal
-
-def constrained_non_singletons[T: (int, str)](t: list[T]) -> None:
-    static_assert(not is_singleton(T))
-    static_assert(not is_single_valued(T))
-
-def constrained_singletons[T: (Literal[True], Literal[False])](t: list[T]) -> None:
-    static_assert(is_singleton(T))
-
-def constrained_single_valued[T: (Literal[True], tuple[()])](t: list[T]) -> None:
-    static_assert(is_single_valued(T))
-```
-
-## Unions involving typevars
-
-The union of an unbounded unconstrained typevar with any other type cannot be simplified, since
-there is no guarantee what type the typevar will be specialized to.
-
-```py
-from typing import Any
-
-class Super: ...
-class Base(Super): ...
-class Sub(Base): ...
-class Unrelated: ...
-
-def unbounded_unconstrained[T](t: T) -> None:
-    def _(x: T | Super) -> None:
-        reveal_type(x)  # revealed: T | Super
-
-    def _(x: T | Base) -> None:
-        reveal_type(x)  # revealed: T | Base
-
-    def _(x: T | Sub) -> None:
-        reveal_type(x)  # revealed: T | Sub
-
-    def _(x: T | Unrelated) -> None:
-        reveal_type(x)  # revealed: T | Unrelated
-
-    def _(x: T | Any) -> None:
-        reveal_type(x)  # revealed: T | Any
-```
-
-The union of a bounded typevar with its bound is that bound. (The typevar is guaranteed to be
-specialized to a subtype of the bound.) The union of a bounded typevar with a subtype of its bound
-cannot be simplified. (The typevar might be specialized to a different subtype of the bound.)
-
-```py
-def bounded[T: Base](t: T) -> None:
-    def _(x: T | Super) -> None:
-        reveal_type(x)  # revealed: Super
-
-    def _(x: T | Base) -> None:
-        reveal_type(x)  # revealed: Base
-
-    def _(x: T | Sub) -> None:
-        reveal_type(x)  # revealed: T | Sub
-
-    def _(x: T | Unrelated) -> None:
-        reveal_type(x)  # revealed: T | Unrelated
-
-    def _(x: T | Any) -> None:
-        reveal_type(x)  # revealed: T | Any
-```
-
-The union of a constrained typevar with a type depends on how that type relates to the constraints.
-If all of the constraints are a subtype of that type, the union simplifies to that type. Inversely,
-if the type is a subtype of every constraint, the union simplifies to the typevar. Otherwise, the
-union cannot be simplified.
-
-```py
-def constrained[T: (Base, Sub)](t: T) -> None:
-    def _(x: T | Super) -> None:
-        reveal_type(x)  # revealed: Super
-
-    def _(x: T | Base) -> None:
-        reveal_type(x)  # revealed: Base
-
-    def _(x: T | Sub) -> None:
-        reveal_type(x)  # revealed: T
-
-    def _(x: T | Unrelated) -> None:
-        reveal_type(x)  # revealed: T | Unrelated
-
-    def _(x: T | Any) -> None:
-        reveal_type(x)  # revealed: T | Any
-```
-
-## Intersections involving typevars
-
-The intersection of an unbounded unconstrained typevar with any other type cannot be simplified,
-since there is no guarantee what type the typevar will be specialized to.
-
-```py
-from knot_extensions import Intersection
-from typing import Any
-
-class Super: ...
-class Base(Super): ...
-class Sub(Base): ...
-class Unrelated: ...
-
-def unbounded_unconstrained[T](t: T) -> None:
-    def _(x: Intersection[T, Super]) -> None:
-        reveal_type(x)  # revealed: T & Super
-
-    def _(x: Intersection[T, Base]) -> None:
-        reveal_type(x)  # revealed: T & Base
-
-    def _(x: Intersection[T, Sub]) -> None:
-        reveal_type(x)  # revealed: T & Sub
-
-    def _(x: Intersection[T, Unrelated]) -> None:
-        reveal_type(x)  # revealed: T & Unrelated
-
-    def _(x: Intersection[T, Any]) -> None:
-        reveal_type(x)  # revealed: T & Any
-```
-
-The intersection of a bounded typevar with its bound or a supertype of its bound is the typevar
-itself. (The typevar might be specialized to a subtype of the bound.) The intersection of a bounded
-typevar with a subtype of its bound cannot be simplified. (The typevar might be specialized to a
-different subtype of the bound.) The intersection of a bounded typevar with a type that is disjoint
-from its bound is `Never`.
-
-```py
-def bounded[T: Base](t: T) -> None:
-    def _(x: Intersection[T, Super]) -> None:
-        reveal_type(x)  # revealed: T
-
-    def _(x: Intersection[T, Base]) -> None:
-        reveal_type(x)  # revealed: T
-
-    def _(x: Intersection[T, Sub]) -> None:
-        reveal_type(x)  # revealed: T & Sub
-
-    def _(x: Intersection[T, None]) -> None:
-        reveal_type(x)  # revealed: Never
-
-    def _(x: Intersection[T, Any]) -> None:
-        reveal_type(x)  # revealed: T & Any
-```
-
-Constrained typevars can be modeled using a hypothetical `OneOf` connector, where the typevar must
-be specialized to _one_ of its constraints. The typevar is not the _union_ of those constraints,
-since that would allow the typevar to take on values from _multiple_ constraints simultaneously. The
-`OneOf` connector would not be a “type” according to a strict reading of the typing spec, since it
-would not represent a single set of runtime objects; it would instead represent a _set of_ sets of
-runtime objects. This is one reason we have not actually added this connector to our data model yet.
-Nevertheless, describing constrained typevars this way helps explain how we simplify intersections
-involving them.
-
-This means that when intersecting a constrained typevar with a type `T`, constraints that are
-supertypes of `T` can be simplified to `T`, since intersection distributes over `OneOf`. Moreover,
-constraints that are disjoint from `T` are no longer valid specializations of the typevar, since
-`Never` is an identity for `OneOf`. After these simplifications, if only one constraint remains, we
-can simplify the intersection as a whole to that constraint.
-
-```py
-def constrained[T: (Base, Sub, Unrelated)](t: T) -> None:
-    def _(x: Intersection[T, Base]) -> None:
-        # With OneOf this would be OneOf[Base, Sub]
-        reveal_type(x)  # revealed: T & Base
-
-    def _(x: Intersection[T, Unrelated]) -> None:
-        reveal_type(x)  # revealed: Unrelated
-
-    def _(x: Intersection[T, Sub]) -> None:
-        reveal_type(x)  # revealed: Sub
-
-    def _(x: Intersection[T, None]) -> None:
-        reveal_type(x)  # revealed: Never
-
-    def _(x: Intersection[T, Any]) -> None:
-        reveal_type(x)  # revealed: T & Any
-```
-
-We can simplify the intersection similarly when removing a type from a constrained typevar, since
-this is modeled internally as an intersection with a negation.
-
-```py
-from knot_extensions import Not
-
-def remove_constraint[T: (int, str, bool)](t: T) -> None:
-    def _(x: Intersection[T, Not[int]]) -> None:
-        reveal_type(x)  # revealed: str & ~int
-
-    def _(x: Intersection[T, Not[str]]) -> None:
-        # With OneOf this would be OneOf[int, bool]
-        reveal_type(x)  # revealed: T & ~str
-
-    def _(x: Intersection[T, Not[bool]]) -> None:
-        reveal_type(x)  # revealed: T & ~bool
-
-    def _(x: Intersection[T, Not[int], Not[str]]) -> None:
-        reveal_type(x)  # revealed: Never
-
-    def _(x: Intersection[T, Not[None]]) -> None:
-        reveal_type(x)  # revealed: T
-
-    def _(x: Intersection[T, Not[Any]]) -> None:
-        reveal_type(x)  # revealed: T & Any
-```
-
-## Narrowing
-
-We can use narrowing expressions to eliminate some of the possibilities of a constrained typevar:
-
-```py
-class P: ...
-class Q: ...
-class R: ...
-
-def f[T: (P, Q)](t: T) -> None:
-    if isinstance(t, P):
-        reveal_type(t)  # revealed: P
-        p: P = t
-    else:
-        reveal_type(t)  # revealed: Q & ~P
-        q: Q = t
-
-    if isinstance(t, Q):
-        reveal_type(t)  # revealed: Q
-        q: Q = t
-    else:
-        reveal_type(t)  # revealed: P & ~Q
-        p: P = t
-
-def g[T: (P, Q, R)](t: T) -> None:
-    if isinstance(t, P):
-        reveal_type(t)  # revealed: P
-        p: P = t
-    elif isinstance(t, Q):
-        reveal_type(t)  # revealed: Q & ~P
-        q: Q = t
-    else:
-        reveal_type(t)  # revealed: R & ~P & ~Q
-        r: R = t
-
-    if isinstance(t, P):
-        reveal_type(t)  # revealed: P
-        p: P = t
-    elif isinstance(t, Q):
-        reveal_type(t)  # revealed: Q & ~P
-        q: Q = t
-    elif isinstance(t, R):
-        reveal_type(t)  # revealed: R & ~P & ~Q
-        r: R = t
-    else:
-        reveal_type(t)  # revealed: Never
-```
-
-If the constraints are disjoint, simplification does eliminate the redundant negative:
-
-```py
-def h[T: (P, None)](t: T) -> None:
-    if t is None:
-        reveal_type(t)  # revealed: None
-        p: None = t
-    else:
-        reveal_type(t)  # revealed: P
-        p: P = t
-```
-
 [pep 695]: https://peps.python.org/pep-0695/

crates/red_knot_python_semantic/resources/mdtest/generics/scoping.md

@@ -82,51 +82,18 @@ class C[T]:
     def m2(self, x: T) -> T:
         return x
 
-c: C[int] = C[int]()
+c: C[int] = C()
+# TODO: no error
+# error: [invalid-argument-type]
 c.m1(1)
+# TODO: no error
+# error: [invalid-argument-type]
 c.m2(1)
-# error: [invalid-argument-type] "Object of type `Literal["string"]` cannot be assigned to parameter 2 (`x`) of bound method `m2`; expected type `int`"
+# TODO: expected type `int`
+# error: [invalid-argument-type] "Object of type `Literal["string"]` cannot be assigned to parameter 2 (`x`) of bound method `m2`; expected type `T`"
 c.m2("string")
 ```
 
-## Functions on generic classes are descriptors
-
-This repeats the tests in the [Functions as descriptors](./call/methods.md) test suite, but on a
-generic class. This ensures that we are carrying any specializations through the entirety of the
-descriptor protocol, which is how `self` parameters are bound to instance methods.
-
-```py
-from inspect import getattr_static
-
-class C[T]:
-    def f(self, x: T) -> str:
-        return "a"
-
-reveal_type(getattr_static(C[int], "f"))  # revealed: Literal[f[int]]
-reveal_type(getattr_static(C[int], "f").__get__)  # revealed: <method-wrapper `__get__` of `f[int]`>
-reveal_type(getattr_static(C[int], "f").__get__(None, C[int]))  # revealed: Literal[f[int]]
-# revealed: <bound method `f` of `C[int]`>
-reveal_type(getattr_static(C[int], "f").__get__(C[int](), C[int]))
-
-reveal_type(C[int].f)  # revealed: Literal[f[int]]
-reveal_type(C[int]().f)  # revealed: <bound method `f` of `C[int]`>
-
-bound_method = C[int]().f
-reveal_type(bound_method.__self__)  # revealed: C[int]
-reveal_type(bound_method.__func__)  # revealed: Literal[f[int]]
-
-reveal_type(C[int]().f(1))  # revealed: str
-reveal_type(bound_method(1))  # revealed: str
-
-C[int].f(1)  # error: [missing-argument]
-reveal_type(C[int].f(C[int](), 1))  # revealed: str
-
-class D[U](C[U]):
-    pass
-
-reveal_type(D[int]().f)  # revealed: <bound method `f` of `D[int]`>
-```
-
 ## Methods can mention other typevars
 
 > A type variable used in a method that does not match any of the variables that parameterize the
@@ -160,6 +127,7 @@ c: C[int] = C()
 # TODO: no errors
 # TODO: revealed: str
 # error: [invalid-argument-type]
+# error: [invalid-argument-type]
 reveal_type(c.m(1, "string"))  # revealed: S
 ```
 
@@ -299,4 +267,4 @@ class C[T]:
     ok2: Inner[T]
 ```
 
-[scoping]: https://typing.python.org/en/latest/spec/generics.html#scoping-rules-for-type-variables
+[scoping]: https://typing.readthedocs.io/en/latest/spec/generics.html#scoping-rules-for-type-variables

crates/red_knot_python_semantic/resources/mdtest/import/conventions.md

@@ -4,7 +4,7 @@ This document describes the conventions for importing symbols.
 
 Reference:
 
-- <https://typing.python.org/en/latest/spec/distributing.html#import-conventions>
+- <https://typing.readthedocs.io/en/latest/spec/distributing.html#import-conventions>
 
 ## Builtins scope
 

crates/red_knot_python_semantic/resources/mdtest/import/relative.md

@@ -236,36 +236,3 @@ X: int = 42
 ```py
 from .parser import X  # error: [unresolved-import]
 ```
-
-## Relative imports in `site-packages`
-
-Relative imports in `site-packages` are correctly resolved even when the `site-packages` search path
-is a subdirectory of the first-party search path. Note that mdtest sets the first-party search path
-to `/src/`, which is why the virtual environment in this test is a subdirectory of `/src/`, even
-though this is not how a typical Python project would be structured:
-
-```toml
-[environment]
-python = "/src/.venv"
-python-version = "3.13"
-```
-
-`/src/bar.py`:
-
-```py
-from foo import A
-
-reveal_type(A)  # revealed: Literal[A]
-```
-
-`/src/.venv/<path-to-site-packages>/foo/__init__.py`:
-
-```py
-from .a import A as A
-```
-
-`/src/.venv/<path-to-site-packages>/foo/a.py`:
-
-```py
-class A: ...
-```

crates/red_knot_python_semantic/resources/mdtest/import/star.md

@@ -6,52 +6,52 @@ See the [Python language reference for import statements].
 
 ### A simple `*` import
 
-`exporter.py`:
+`a.py`:
 
 ```py
 X: bool = True
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 reveal_type(X)  # revealed: bool
 print(Y)  # error: [unresolved-reference]
 ```
 
-### Overriding an existing definition
+### Overriding existing definition
 
-`exporter.py`:
+`a.py`:
 
 ```py
 X: bool = True
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
 X = 42
 reveal_type(X)  # revealed: Literal[42]
 
-from exporter import *
+from a import *
 
 reveal_type(X)  # revealed: bool
 ```
 
-### Overridden by a later definition
+### Overridden by later definition
 
-`exporter.py`:
+`a.py`:
 
 ```py
 X: bool = True
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 reveal_type(X)  # revealed: bool
 X = False
@@ -78,7 +78,7 @@ from a import *
 from b import *
 ```
 
-`main.py`:
+`d.py`:
 
 ```py
 from c import *
@@ -88,9 +88,6 @@ reveal_type(X)  # revealed: bool
 
 ### A wildcard import constitutes a re-export
 
-This is specified
-[here](https://typing.python.org/en/latest/spec/distributing.html#import-conventions).
-
 `a.pyi`:
 
 ```pyi
@@ -110,7 +107,7 @@ from a import *
 from b import Y
 ```
 
-`main.py`:
+`d.py`:
 
 ```py
 # `X` is accessible because the `*` import in `c` re-exports it from `c`
@@ -120,15 +117,9 @@ from c import X
 from c import Y  # error: [unresolved-import]
 ```
 
-## Esoteric definitions and redefinintions
-
-We understand all public symbols defined in an external module as being imported by a `*` import,
-not just those that are defined in `StmtAssign` nodes and `StmtAnnAssign` nodes. This section
-provides tests for definitions, and redefinitions, that use more esoteric AST nodes.
-
 ### Global-scope symbols defined using walrus expressions
 
-`exporter.py`:
+`a.py`:
 
 ```py
 X = (Y := 3) + 4
@@ -137,7 +128,7 @@ X = (Y := 3) + 4
 `b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 reveal_type(X)  # revealed: Unknown | Literal[7]
 reveal_type(Y)  # revealed: Unknown | Literal[3]
@@ -145,7 +136,7 @@ reveal_type(Y)  # revealed: Unknown | Literal[3]
 
 ### Global-scope symbols defined in many other ways
 
-`exporter.py`:
+`a.py`:
 
 ```py
 import typing
@@ -167,15 +158,8 @@ def J(): ...
 
 type K = int
 
-class ContextManagerThatMightNotRunToCompletion:
-    def __enter__(self) -> "ContextManagerThatMightNotRunToCompletion":
-        return self
-
-    def __exit__(self, *args) -> typing.Literal[True]:
-        return True
-
-with ContextManagerThatMightNotRunToCompletion() as L:
-    U = ...
+with () as L:  # error: [invalid-context-manager]
+    ...
 
 match 42:
     case {"something": M}:
@@ -188,35 +172,16 @@ match 42:
         ...
     case object(foo=R):
         ...
-
-match 56:
-    case x if something_unresolvable:  # error: [unresolved-reference]
-        ...
-
     case object(S):
         ...
-
-match 12345:
-    case x if something_unresolvable:  # error: [unresolved-reference]
-        ...
-
     case T:
         ...
-
-def boolean_condition() -> bool:
-    return True
-
-if boolean_condition():
-    V = ...
-
-while boolean_condition():
-    W = ...
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 # fmt: off
 
@@ -227,197 +192,31 @@ print((
     D,
     E,
     F,
-    G,  # error: [possibly-unresolved-reference]
-    H,  # error: [possibly-unresolved-reference]
+    G,  # TODO: could emit diagnostic about being possibly unbound
+    H,
     I,
     J,
     K,
     L,
-    M,  # error: [possibly-unresolved-reference]
-    N,  # error: [possibly-unresolved-reference]
-    O,  # error: [possibly-unresolved-reference]
-    P,  # error: [possibly-unresolved-reference]
-    Q,  # error: [possibly-unresolved-reference]
-    R,  # error: [possibly-unresolved-reference]
-    S,  # error: [possibly-unresolved-reference]
-    T,  # error: [possibly-unresolved-reference]
-    U,  # TODO: could emit [possibly-unresolved-reference here] (https://github.com/astral-sh/ruff/issues/16996)
-    V,  # error: [possibly-unresolved-reference]
-    W,  # error: [possibly-unresolved-reference]
+    M,  # TODO: could emit diagnostic about being possibly unbound
+    N,  # TODO: could emit diagnostic about being possibly unbound
+    O,  # TODO: could emit diagnostic about being possibly unbound
+    P,  # TODO: could emit diagnostic about being possibly unbound
+    Q,  # TODO: could emit diagnostic about being possibly unbound
+    R,  # TODO: could emit diagnostic about being possibly unbound
+    S,  # TODO: could emit diagnostic about being possibly unbound
+    T,  # TODO: could emit diagnostic about being possibly unbound
     typing,
     OrderedDict,
     Foo,
 ))
 ```
 
-### Esoteric possible redefinitions following definitely bound prior definitions
-
-There should be no complaint about the symbols being possibly unbound in `b.py` here: although the
-second definition might or might not take place, each symbol is definitely bound by a prior
-definition.
-
-`exporter.py`:
-
-```py
-from typing import Literal
-
-A = 1
-B = 2
-C = 3
-D = 4
-E = 5
-F = 6
-G = 7
-H = 8
-I = 9
-J = 10
-K = 11
-L = 12
-
-for A in [1]:
-    ...
-
-match 42:
-    case {"something": B}:
-        ...
-    case [*C]:
-        ...
-    case [D]:
-        ...
-    case E | F:
-        ...
-    case object(foo=G):
-        ...
-    case object(H):
-        ...
-    case I:
-        ...
-
-def boolean_condition() -> bool:
-    return True
-
-if boolean_condition():
-    J = ...
-
-while boolean_condition():
-    K = ...
-
-class ContextManagerThatMightNotRunToCompletion:
-    def __enter__(self) -> "ContextManagerThatMightNotRunToCompletion":
-        return self
-
-    def __exit__(self, *args) -> Literal[True]:
-        return True
-
-with ContextManagerThatMightNotRunToCompletion():
-    L = ...
-```
-
-`importer.py`:
-
-```py
-from exporter import *
-
-print(A)
-print(B)
-print(C)
-print(D)
-print(E)
-print(F)
-print(G)
-print(H)
-print(I)
-print(J)
-print(K)
-print(L)
-```
-
-### Esoteric possible definitions prior to definitely bound prior redefinitions
-
-The same principle applies here to the symbols in `b.py`. Although the first definition might or
-might not take place, each symbol is definitely bound by a later definition.
-
-`exporter.py`:
-
-```py
-from typing import Literal
-
-for A in [1]:
-    ...
-
-match 42:
-    case {"something": B}:
-        ...
-    case [*C]:
-        ...
-    case [D]:
-        ...
-    case E | F:
-        ...
-    case object(foo=G):
-        ...
-    case object(H):
-        ...
-    case I:
-        ...
-
-def boolean_condition() -> bool:
-    return True
-
-if boolean_condition():
-    J = ...
-
-while boolean_condition():
-    K = ...
-
-class ContextManagerThatMightNotRunToCompletion:
-    def __enter__(self) -> "ContextManagerThatMightNotRunToCompletion":
-        return self
-
-    def __exit__(self, *args) -> Literal[True]:
-        return True
-
-with ContextManagerThatMightNotRunToCompletion():
-    L = ...
-
-A = 1
-B = 2
-C = 3
-D = 4
-E = 5
-F = 6
-G = 7
-H = 8
-I = 9
-J = 10
-K = 11
-L = 12
-```
-
-`importer.py`:
-
-```py
-from exporter import *
-
-print(A)
-print(B)
-print(C)
-print(D)
-print(E)
-print(F)
-print(G)
-print(H)
-print(I)
-print(J)
-print(K)
-print(L)
-```
-
 ### Definitions in function-like scopes are not global definitions
 
 Except for some cases involving walrus expressions inside comprehension scopes.
 
-`exporter.py`:
+`a.py`:
 
 ```py
 class Iterator:
@@ -449,10 +248,10 @@ list(((o := p * 2) for p in Iterable()))
 [(lambda s=s: (t := 42))() for s in Iterable()]
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 # error: [unresolved-reference]
 reveal_type(a)  # revealed: Unknown
@@ -479,21 +278,15 @@ reveal_type(s)  # revealed: Unknown
 # error: [unresolved-reference]
 reveal_type(t)  # revealed: Unknown
 
-# TODO: these should all reveal `Unknown | int` and should not emit errors.
+# TODO: these should all reveal `Unknown | int`.
 # (We don't generally model elsewhere in red-knot that bindings from walruses
 # "leak" from comprehension scopes into outer scopes, but we should.)
 # See https://github.com/astral-sh/ruff/issues/16954
-# error: [unresolved-reference]
 reveal_type(g)  # revealed: Unknown
-# error: [unresolved-reference]
 reveal_type(i)  # revealed: Unknown
-# error: [unresolved-reference]
 reveal_type(k)  # revealed: Unknown
-# error: [unresolved-reference]
 reveal_type(m)  # revealed: Unknown
-# error: [unresolved-reference]
 reveal_type(o)  # revealed: Unknown
-# error: [unresolved-reference]
 reveal_type(q)  # revealed: Unknown
 ```
 
@@ -522,19 +315,12 @@ reveal_type(X)  # revealed: bool
 reveal_type(Y)  # revealed: Unknown
 ```
 
-## Which symbols are exported
-
-Not all symbols in the global namespace are considered "public". As a result, not all symbols bound
-in the global namespace of an `exporter.py` module will be imported by a `from exporter import *`
-statement in an `importer.py` module. The tests in this section elaborate on these semantics.
-
 ### Global-scope names starting with underscores
 
-Global-scope names starting with underscores are not imported from a `*` import (unless the
-exporting module has an `__all__` symbol in its global scope, and the underscore-prefixed symbols
-are included in `__all__`):
+Global-scope names starting with underscores are not imported from a `*` import (unless the module
+has `__all__` and they are included in `__all__`):
 
-`exporter.py`:
+`a.py`:
 
 ```py
 _private: bool = False
@@ -545,10 +331,10 @@ ___thunder___: bool = False
 Y: bool = True
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 # error: [unresolved-reference]
 reveal_type(_private)  # revealed: Unknown
@@ -568,11 +354,8 @@ For `.py` files, we should consider all public symbols in the global namespace e
 module when considering which symbols are made available by a `*` import. Here, `b.py` does not use
 the explicit `from a import X as X` syntax to explicitly mark it as publicly re-exported, and `X` is
 not included in `__all__`; whether it should be considered a "public name" in module `b` is
-ambiguous.
-
-We should consider `X` bound in `c.py`. However, we could consider adding an opt-in rule to warn the
-user when they use `X` in `c.py` that it was neither included in `b.__all__` nor marked as an
-explicit re-export from `b` through the "redundant alias" convention.
+ambiguous. We could consider an opt-in rule to warn the user when they use `X` in `c.py` that it was
+not included in `__all__` and was not marked as an explicit re-export.
 
 `a.py`:
 
@@ -597,7 +380,7 @@ reveal_type(X)  # revealed: bool
 
 ### Only explicit re-exports are considered re-exported from `.pyi` files
 
-For `.pyi` files, we should consider all imports "private to the stub" unless they are included in
+For `.pyi` files, we should consider all imports private to the stub unless they are included in
 `__all__` or use the explicit `from foo import X as X` syntax.
 
 `a.pyi`:
@@ -626,32 +409,14 @@ reveal_type(X)  # revealed: Unknown
 reveal_type(Y)  # revealed: bool
 ```
 
-## Visibility constraints
-
-If an `importer` module contains a `from exporter import *` statement in its global namespace, the
-statement will *not* necessarily import *all* symbols that have definitions in `exporter.py`'s
-global scope. For any given symbol in `exporter.py`'s global scope, that symbol will *only* be
-imported by the `*` import if at least one definition for that symbol is visible from the *end* of
-`exporter.py`'s global scope.
-
-For example, say that `exporter.py` contains a symbol `X` in its global scope, and the definition
-for `X` in `exporter.py` has visibility constraints <code>vis<sub>1</sub></code>. The
-`from exporter import *` statement in `importer.py` creates a definition for `X` in `importer`, and
-there are visibility constraints <code>vis<sub>2</sub></code> on the import statement in
-`importer.py`. This means that the overall visibility constraints on the `X` definnition created by
-the import statement in `importer.py` will be <code>vis<sub>1</sub> AND vis<sub>2</sub></code>.
-
-A visibility constraint in the external module must be understood and evaluated whether or not its
-truthiness can be statically determined.
-
-### Statically known branches in the external module
+### Symbols in statically known branches
 
 ```toml
 [environment]
 python-version = "3.11"
 ```
 
-`exporter.py`:
+`a.py`:
 
 ```py
 import sys
@@ -663,158 +428,27 @@ else:
     Z: int = 42
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-import sys
-
 Z: bool = True
 
-from exporter import *
+from a import *
 
 reveal_type(X)  # revealed: bool
 
-# error: [unresolved-reference]
+# TODO: should emit error: [unresolved-reference]
 reveal_type(Y)  # revealed: Unknown
 
-# The `*` import is not considered a redefinition
-# of the global variable `Z` in this module, as the symbol in
+# TODO: The `*` import should not be considered a redefinition
+# of the global variable in this module, as the symbol in
 # the `a` module is in a branch that is statically known
 # to be dead code given the `python-version` configuration.
-# Thus this still reveals `Literal[True]`.
-reveal_type(Z)  # revealed: Literal[True]
+# Thus this should reveal `Literal[True]`.
+reveal_type(Z)  # revealed: Unknown
 ```
 
-### Multiple `*` imports with always-false visibility constraints
-
-Our understanding of visibility constraints in an external module remains accurate, even if there
-are multiple `*` imports from that module.
-
-```toml
-[environment]
-python-version = "3.11"
-```
-
-`exporter.py`:
-
-```py
-import sys
-
-if sys.version_info >= (3, 12):
-    Z: str = "foo"
-```
-
-`importer.py`:
-
-```py
-Z = True
-
-from exporter import *
-from exporter import *
-from exporter import *
-
-reveal_type(Z)  # revealed: Literal[True]
-```
-
-### Ambiguous visibility constraints
-
-Some constraints in the external module may resolve to an "ambiguous truthiness". For these, we
-should emit `possibly-unresolved-reference` diagnostics when they are used in the module in which
-the `*` import occurs.
-
-`exporter.py`:
-
-```py
-def coinflip() -> bool:
-    return True
-
-if coinflip():
-    A = 1
-    B = 2
-else:
-    B = 3
-```
-
-`importer.py`:
-
-```py
-from exporter import *
-
-# error: [possibly-unresolved-reference]
-reveal_type(A)  # revealed: Unknown | Literal[1]
-
-reveal_type(B)  # revealed: Unknown | Literal[2, 3]
-```
-
-### Visibility constraints in the importing module
-
-`exporter.py`:
-
-```py
-A = 1
-```
-
-`importer.py`:
-
-```py
-def coinflip() -> bool:
-    return True
-
-if coinflip():
-    from exporter import *
-
-# error: [possibly-unresolved-reference]
-reveal_type(A)  # revealed: Unknown | Literal[1]
-```
-
-### Visibility constraints in the exporting module *and* the importing module
-
-```toml
-[environment]
-python-version = "3.11"
-```
-
-`exporter.py`:
-
-```py
-import sys
-
-if sys.version_info >= (3, 12):
-    A: bool = True
-
-def coinflip() -> bool:
-    return True
-
-if coinflip():
-    B: bool = True
-```
-
-`importer.py`:
-
-```py
-import sys
-
-if sys.version_info >= (3, 12):
-    from exporter import *
-
-    # it's correct to have no diagnostics here as this branch is unreachable
-    reveal_type(A)  # revealed: Unknown
-    reveal_type(B)  # revealed: bool
-else:
-    from exporter import *
-
-    # error: [unresolved-reference]
-    reveal_type(A)  # revealed: Unknown
-    # error: [possibly-unresolved-reference]
-    reveal_type(B)  # revealed: bool
-
-# error: [unresolved-reference]
-reveal_type(A)  # revealed: Unknown
-# error: [possibly-unresolved-reference]
-reveal_type(B)  # revealed: bool
-```
-
-## Relative `*` imports
+### Relative `*` imports
 
 Relative `*` imports are also supported by Python:
 
@@ -844,7 +478,7 @@ If a module `x` contains `__all__`, all symbols included in `x.__all__` are impo
 
 ### Simple tuple `__all__`
 
-`exporter.py`:
+`a.py`:
 
 ```py
 __all__ = ("X", "_private", "__protected", "__dunder__", "___thunder___")
@@ -858,10 +492,10 @@ ___thunder___: bool = True
 Y: bool = False
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 reveal_type(X)  # revealed: bool
 
@@ -881,7 +515,7 @@ reveal_type(Y)  # revealed: bool
 
 ### Simple list `__all__`
 
-`exporter.py`:
+`a.py`:
 
 ```py
 __all__ = ["X"]
@@ -890,10 +524,10 @@ X: bool = True
 Y: bool = False
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 reveal_type(X)  # revealed: bool
 
@@ -903,9 +537,7 @@ reveal_type(Y)  # revealed: bool
 
 ### `__all__` with additions later on in the global scope
 
-The
-[typing spec](https://typing.python.org/en/latest/spec/distributing.html#library-interface-public-and-private-symbols)
-lists certain modifications to `__all__` that must be understood by type checkers.
+The [typing spec] lists certain modifications to `__all__` that must be understood by type checkers.
 
 `a.py`:
 
@@ -957,7 +589,7 @@ reveal_type(F)  # revealed: bool
 Whereas there are many ways of adding to `__all__` that type checkers must support, there is only
 one way of subtracting from `__all__` that type checkers are required to support:
 
-`exporter.py`:
+`a.py`:
 
 ```py
 __all__ = ["A", "B"]
@@ -967,10 +599,10 @@ A: bool = True
 B: bool = True
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 reveal_type(A)  # revealed: bool
 
@@ -986,11 +618,11 @@ a wildcard import from module `a` will fail at runtime.
 TODO: Should we:
 
 1. Emit a diagnostic at the invalid definition of `__all__` (which will not fail at runtime)?
-1. Emit a diagnostic at the star-import from the module with the invalid `__all__` (which *will*
+1. Emit a diagnostic at the star-import from the module with the invalid `__all__` (which _will_
     fail at runtime)?
 1. Emit a diagnostic on both?
 
-`exporter.py`:
+`a.py`:
 
 ```py
 __all__ = ["a", "b"]
@@ -998,11 +630,11 @@ __all__ = ["a", "b"]
 a = 42
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
 # TODO we should consider emitting a diagnostic here (see prose description above)
-from exporter import *  # fails with `AttributeError: module 'foo' has no attribute 'b'` at runtime
+from a import *  # fails with `AttributeError: module 'foo' has no attribute 'b'` at runtime
 ```
 
 ### Dynamic `__all__`
@@ -1013,7 +645,7 @@ treat the module as though it has no `__all__` at all: all global-scope members
 be considered imported by the import statement. We should probably also emit a warning telling the
 user that we cannot statically determine the elements of `__all__`.
 
-`exporter.py`:
+`a.py`:
 
 ```py
 def f() -> str:
@@ -1026,10 +658,10 @@ def g() -> int:
 __all__ = [f()]
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 # At runtime, `f` is imported but `g` is not; to avoid false positives, however,
 # we treat `a` as though it does not have `__all__` at all,
@@ -1045,7 +677,7 @@ reveal_type(g)  # revealed: Literal[g]
 python-version = "3.11"
 ```
 
-`exporter.py`:
+`a.py`:
 
 ```py
 import sys
@@ -1060,15 +692,15 @@ else:
     Z: bool = True
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 reveal_type(X)  # revealed: bool
 reveal_type(Y)  # revealed: bool
 
-# error: [unresolved-reference]
+# TODO: should error with [unresolved-reference]
 reveal_type(Z)  # revealed: Unknown
 ```
 
@@ -1079,7 +711,7 @@ reveal_type(Z)  # revealed: Unknown
 python-version = "3.11"
 ```
 
-`exporter.py`:
+`a.py`:
 
 ```py
 import sys
@@ -1095,15 +727,15 @@ else:
     Z: bool = True
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
-from exporter import *
+from a import *
 
 reveal_type(X)  # revealed: bool
 reveal_type(Y)  # revealed: bool
 
-# error: [unresolved-reference]
+# TODO should have an [unresolved-reference] diagnostic
 reveal_type(Z)  # revealed: Unknown
 ```
 
@@ -1144,16 +776,16 @@ reveal_type(Y)  # revealed: bool
 If a name is included in `__all__` in a stub file, it is considered re-exported even if it was only
 defined using an import without the explicit `from foo import X as X` syntax:
 
-`a.pyi`:
+`a.py`:
 
-```pyi
+```py
 X: bool = True
 Y: bool = True
 ```
 
-`b.pyi`:
+`b.py`:
 
-```pyi
+```py
 from a import X, Y
 
 __all__ = ["X"]
@@ -1164,17 +796,10 @@ __all__ = ["X"]
 ```py
 from b import *
 
-# TODO: should not error, should reveal `bool`
-# (`X` is re-exported from `b.pyi` due to presence in `__all__`)
-#
-# error: [unresolved-reference]
-reveal_type(X)  # revealed: Unknown
+reveal_type(X)  # revealed: bool
 
-# This diagnostic is accurate: `Y` does not use the "redundant alias" convention in `b.pyi`,
-# nor is it included in `b.__all__`, so it is not exported from `b.pyi`
-#
-# error: [unresolved-reference]
-reveal_type(Y)  # revealed: Unknown
+# TODO this should have an [unresolved-reference] diagnostic and reveal `Unknown`
+reveal_type(Y)  # revealed: bool
 ```
 
 ## `global` statements in non-global scopes
@@ -1200,12 +825,7 @@ from a import *
 
 reveal_type(f)  # revealed: Literal[f]
 
-# TODO: we're undecided about whether we should consider this a false positive or not.
-# Mutating the global scope to add a symbol from an inner scope will not *necessarily* result
-# in the symbol being bound from the perspective of other modules (the function that creates
-# the inner scope, and adds the symbol to the global scope, might never be called!)
-# See discussion in https://github.com/astral-sh/ruff/pull/16959
-#
+# TODO: false positive, should be `bool` with no diagnostic
 # error: [unresolved-reference]
 reveal_type(g)  # revealed: Unknown
 
@@ -1216,7 +836,7 @@ reveal_type(h)  # revealed: Unknown
 
 ## Cyclic star imports
 
-Believe it or not, this code does *not* raise an exception at runtime!
+Believe it or not, this code does _not_ raise an exception at runtime!
 
 `a.py`:
 
@@ -1249,14 +869,11 @@ The `collections.abc` standard-library module provides a good integration test,
 are present due to `*` imports.
 
 ```py
+import typing
 import collections.abc
 
 reveal_type(collections.abc.Sequence)  # revealed: Literal[Sequence]
 reveal_type(collections.abc.Callable)  # revealed: typing.Callable
-
-# TODO: false positive as it's only re-exported from `_collections.abc` due to presence in `__all__`
-# error: [unresolved-attribute]
-reveal_type(collections.abc.Set)  # revealed: Unknown
 ```
 
 ## Invalid `*` imports
@@ -1275,18 +892,18 @@ from foo import *  # error: [unresolved-import] "Cannot resolve import `foo`"
 A `*` import in a nested scope are always a syntax error. Red-knot does not infer any bindings from
 them:
 
-`exporter.py`:
+`a.py`:
 
 ```py
 X: bool = True
 ```
 
-`importer.py`:
+`b.py`:
 
 ```py
 def f():
     # TODO: we should emit a syntax errror here (tracked by https://github.com/astral-sh/ruff/issues/11934)
-    from exporter import *
+    from a import *
 
     # error: [unresolved-reference]
     reveal_type(X)  # revealed: Unknown
@@ -1331,3 +948,4 @@ from a import *, *, _Y  # error: [invalid-syntax]
 <!-- blacken-docs:on -->
 
 [python language reference for import statements]: https://docs.python.org/3/reference/simple_stmts.html#the-import-statement
+[typing spec]: https://typing.python.org/en/latest/spec/distributing.html#library-interface-public-and-private-symbols

crates/red_knot_python_semantic/resources/mdtest/import/stub_packages.md

@@ -1,286 +0,0 @@
-# Stub packages
-
-Stub packages are packages named `<package>-stubs` that provide typing stubs for `<package>`. See
-[specification](https://typing.python.org/en/latest/spec/distributing.html#stub-only-packages).
-
-## Simple stub
-
-```toml
-[environment]
-extra-paths = ["/packages"]
-```
-
-`/packages/foo-stubs/__init__.pyi`:
-
-```pyi
-class Foo:
-    name: str
-    age: int
-```
-
-`/packages/foo/__init__.py`:
-
-```py
-class Foo: ...
-```
-
-`main.py`:
-
-```py
-from foo import Foo
-
-reveal_type(Foo().name)  # revealed: str
-```
-
-## Stubs only
-
-The regular package isn't required for type checking.
-
-```toml
-[environment]
-extra-paths = ["/packages"]
-```
-
-`/packages/foo-stubs/__init__.pyi`:
-
-```pyi
-class Foo:
-    name: str
-    age: int
-```
-
-`main.py`:
-
-```py
-from foo import Foo
-
-reveal_type(Foo().name)  # revealed: str
-```
-
-## `-stubs` named module
-
-A module named `<module>-stubs` isn't a stub package.
-
-```toml
-[environment]
-extra-paths = ["/packages"]
-```
-
-`/packages/foo-stubs.pyi`:
-
-```pyi
-class Foo:
-    name: str
-    age: int
-```
-
-`main.py`:
-
-```py
-from foo import Foo  # error: [unresolved-import]
-
-reveal_type(Foo().name)  # revealed: Unknown
-```
-
-## Namespace package in different search paths
-
-A namespace package with multiple stub packages spread over multiple search paths.
-
-```toml
-[environment]
-extra-paths = ["/stubs1", "/stubs2", "/packages"]
-```
-
-`/stubs1/shapes-stubs/polygons/pentagon.pyi`:
-
-```pyi
-class Pentagon:
-    sides: int
-    area: float
-```
-
-`/stubs2/shapes-stubs/polygons/hexagon.pyi`:
-
-```pyi
-class Hexagon:
-    sides: int
-    area: float
-```
-
-`/packages/shapes/polygons/pentagon.py`:
-
-```py
-class Pentagon: ...
-```
-
-`/packages/shapes/polygons/hexagon.py`:
-
-```py
-class Hexagon: ...
-```
-
-`main.py`:
-
-```py
-from shapes.polygons.hexagon import Hexagon
-from shapes.polygons.pentagon import Pentagon
-
-reveal_type(Pentagon().sides)  # revealed: int
-reveal_type(Hexagon().area)  # revealed: int | float
-```
-
-## Inconsistent stub packages
-
-Stub packages where one is a namespace package and the other is a regular package. Module resolution
-should stop after the first non-namespace stub package. This matches Pyright's behavior.
-
-```toml
-[environment]
-extra-paths = ["/stubs1", "/stubs2", "/packages"]
-```
-
-`/stubs1/shapes-stubs/__init__.pyi`:
-
-```pyi
-```
-
-`/stubs1/shapes-stubs/polygons/__init__.pyi`:
-
-```pyi
-```
-
-`/stubs1/shapes-stubs/polygons/pentagon.pyi`:
-
-```pyi
-class Pentagon:
-    sides: int
-    area: float
-```
-
-`/stubs2/shapes-stubs/polygons/hexagon.pyi`:
-
-```pyi
-class Hexagon:
-    sides: int
-    area: float
-```
-
-`/packages/shapes/polygons/pentagon.py`:
-
-```py
-class Pentagon: ...
-```
-
-`/packages/shapes/polygons/hexagon.py`:
-
-```py
-class Hexagon: ...
-```
-
-`main.py`:
-
-```py
-from shapes.polygons.pentagon import Pentagon
-from shapes.polygons.hexagon import Hexagon  # error: [unresolved-import]
-
-reveal_type(Pentagon().sides)  # revealed: int
-reveal_type(Hexagon().area)  # revealed: Unknown
-```
-
-## Namespace stubs for non-namespace package
-
-The runtime package is a regular package but the stubs are namespace packages. Pyright skips the
-stub package if the "regular" package isn't a namespace package. I'm not aware that the behavior
-here is specified, and using the stubs without probing the runtime package first requires slightly
-fewer lookups.
-
-```toml
-[environment]
-extra-paths = ["/packages"]
-```
-
-`/packages/shapes-stubs/polygons/pentagon.pyi`:
-
-```pyi
-class Pentagon:
-    sides: int
-    area: float
-```
-
-`/packages/shapes-stubs/polygons/hexagon.pyi`:
-
-```pyi
-class Hexagon:
-    sides: int
-    area: float
-```
-
-`/packages/shapes/__init__.py`:
-
-```py
-```
-
-`/packages/shapes/polygons/__init__.py`:
-
-```py
-```
-
-`/packages/shapes/polygons/pentagon.py`:
-
-```py
-class Pentagon: ...
-```
-
-`/packages/shapes/polygons/hexagon.py`:
-
-```py
-class Hexagon: ...
-```
-
-`main.py`:
-
-```py
-from shapes.polygons.pentagon import Pentagon
-from shapes.polygons.hexagon import Hexagon
-
-reveal_type(Pentagon().sides)  # revealed: int
-reveal_type(Hexagon().area)  # revealed: int | float
-```
-
-## Stub package using `__init__.py` over `.pyi`
-
-It's recommended that stub packages use `__init__.pyi` files over `__init__.py` but it doesn't seem
-to be an enforced convention. At least, Pyright is fine with the following.
-
-```toml
-[environment]
-extra-paths = ["/packages"]
-```
-
-`/packages/shapes-stubs/__init__.py`:
-
-```py
-class Pentagon:
-    sides: int
-    area: float
-
-class Hexagon:
-    sides: int
-    area: float
-```
-
-`/packages/shapes/__init__.py`:
-
-```py
-class Pentagon: ...
-class Hexagon: ...
-```
-
-`main.py`:
-
-```py
-from shapes import Hexagon, Pentagon
-
-reveal_type(Pentagon().sides)  # revealed: int
-reveal_type(Hexagon().area)  # revealed: int | float
-```

crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/in.md

@@ -1,80 +0,0 @@
-# Narrowing for `in` conditionals
-
-## `in` for tuples
-
-```py
-def _(x: int):
-    if x in (1, 2, 3):
-        reveal_type(x)  # revealed: int
-    else:
-        reveal_type(x)  # revealed: int
-```
-
-```py
-def _(x: str):
-    if x in ("a", "b", "c"):
-        reveal_type(x)  # revealed: str
-    else:
-        reveal_type(x)  # revealed: str
-```
-
-```py
-from typing import Literal
-
-def _(x: Literal[1, 2, "a", "b", False, b"abc"]):
-    if x in (1,):
-        reveal_type(x)  # revealed: Literal[1]
-    elif x in (2, "a"):
-        reveal_type(x)  # revealed: Literal[2, "a"]
-    elif x in (b"abc",):
-        reveal_type(x)  # revealed: Literal[b"abc"]
-    elif x not in (3,):
-        reveal_type(x)  # revealed: Literal["b", False]
-    else:
-        reveal_type(x)  # revealed: Never
-```
-
-```py
-def _(x: Literal["a", "b", "c", 1]):
-    if x in ("a", "b", "c", 2):
-        reveal_type(x)  # revealed: Literal["a", "b", "c"]
-    else:
-        reveal_type(x)  # revealed: Literal[1]
-```
-
-## `in` for `str` and literal strings
-
-```py
-def _(x: str):
-    if x in "abc":
-        reveal_type(x)  # revealed: str
-    else:
-        reveal_type(x)  # revealed: str
-```
-
-```py
-from typing import Literal
-
-def _(x: Literal["a", "b", "c", "d"]):
-    if x in "abc":
-        reveal_type(x)  # revealed: Literal["a", "b", "c"]
-    else:
-        reveal_type(x)  # revealed: Literal["d"]
-```
-
-```py
-def _(x: Literal["a", "b", "c", "e"]):
-    if x in "abcd":
-        reveal_type(x)  # revealed: Literal["a", "b", "c"]
-    else:
-        reveal_type(x)  # revealed: Literal["e"]
-```
-
-```py
-def _(x: Literal[1, "a", "b", "c", "d"]):
-    # error: [unsupported-operator]
-    if x in "abc":
-        reveal_type(x)  # revealed: Literal["a", "b", "c"]
-    else:
-        reveal_type(x)  # revealed: Literal[1, "d"]
-```

crates/red_knot_python_semantic/resources/mdtest/narrow/match.md

@@ -64,99 +64,3 @@ match x:
 
 reveal_type(x)  # revealed: object
 ```
-
-## Value patterns
-
-```py
-def get_object() -> object:
-    return object()
-
-x = get_object()
-
-reveal_type(x)  # revealed: object
-
-match x:
-    case "foo":
-        reveal_type(x)  # revealed: Literal["foo"]
-    case 42:
-        reveal_type(x)  # revealed: Literal[42]
-    case 6.0:
-        reveal_type(x)  # revealed: float
-    case 1j:
-        reveal_type(x)  # revealed: complex
-    case b"foo":
-        reveal_type(x)  # revealed: Literal[b"foo"]
-
-reveal_type(x)  # revealed: object
-```
-
-## Value patterns with guard
-
-```py
-def get_object() -> object:
-    return object()
-
-x = get_object()
-
-reveal_type(x)  # revealed: object
-
-match x:
-    case "foo" if reveal_type(x):  # revealed: Literal["foo"]
-        pass
-    case 42 if reveal_type(x):  # revealed: Literal[42]
-        pass
-    case 6.0 if reveal_type(x):  # revealed: float
-        pass
-    case 1j if reveal_type(x):  # revealed: complex
-        pass
-    case b"foo" if reveal_type(x):  # revealed: Literal[b"foo"]
-        pass
-
-reveal_type(x)  # revealed: object
-```
-
-## Or patterns
-
-```py
-def get_object() -> object:
-    return object()
-
-x = get_object()
-
-reveal_type(x)  # revealed: object
-
-match x:
-    case "foo" | 42 | None:
-        reveal_type(x)  # revealed: Literal["foo", 42] | None
-    case "foo" | tuple():
-        reveal_type(x)  # revealed: Literal["foo"] | tuple
-    case True | False:
-        reveal_type(x)  # revealed: bool
-    case 3.14 | 2.718 | 1.414:
-        reveal_type(x)  # revealed: float
-
-reveal_type(x)  # revealed: object
-```
-
-## Or patterns with guard
-
-```py
-def get_object() -> object:
-    return object()
-
-x = get_object()
-
-reveal_type(x)  # revealed: object
-
-match x:
-    case "foo" | 42 | None if reveal_type(x):  # revealed: Literal["foo", 42] | None
-        pass
-    case "foo" | tuple() if reveal_type(x):  # revealed: Literal["foo"] | tuple
-        pass
-    case True | False if reveal_type(x):  # revealed: bool
-        pass
-    case 3.14 | 2.718 | 1.414 if reveal_type(x):  # revealed: float
-        pass
-
-reveal_type(x)  # revealed: object
-```

crates/red_knot_python_semantic/resources/mdtest/narrow/type.md

@@ -76,9 +76,6 @@ No narrowing should occur if `type` is used to dynamically create a class:
 
 ```py
 def _(x: str | int):
-    # The following diagnostic is valid, since the three-argument form of `type`
-    # can only be called with `str` as the first argument.
-    # error: [no-matching-overload] "No overload of class `type` matches arguments"
     if type(x, (), {}) is str:
         reveal_type(x)  # revealed: str | int
     else:
@@ -109,24 +106,6 @@ def _(x: A | B):
         reveal_type(x)  # revealed: A
 ```
 
-## Narrowing for generic classes
-
-Note that `type` returns the runtime class of an object, which does _not_ include specializations in
-the case of a generic class. (The typevars are erased.) That means we cannot narrow the type to the
-specialization that we compare with; we must narrow to an unknown specialization of the generic
-class.
-
-```py
-class A[T = int]: ...
-class B: ...
-
-def _[T](x: A | B):
-    if type(x) is A[str]:
-        reveal_type(x)  # revealed: A[int] & A[Unknown] | B & A[Unknown]
-    else:
-        reveal_type(x)  # revealed: A[int] | B
-```
-
 ## Limitations
 
 ```py

crates/red_knot_python_semantic/resources/mdtest/pep695_type_aliases.md

@@ -28,7 +28,10 @@ def f() -> None:
 ```py
 type IntOrStr = int | str
 
-reveal_type(IntOrStr.__value__)  # revealed: Any
+# TODO: This should either fall back to the specified type from typeshed,
+# which is `Any`, or be the actual type of the runtime value expression
+# `int | str`, i.e. `types.UnionType`.
+reveal_type(IntOrStr.__value__)  # revealed: @Todo(@property)
 ```
 
 ## Invalid assignment
@@ -71,7 +74,7 @@ type ListOrSet[T] = list[T] | set[T]
 
 # TODO: Should be `tuple[typing.TypeVar | typing.ParamSpec | typing.TypeVarTuple, ...]`,
 # as specified in the `typeshed` stubs.
-reveal_type(ListOrSet.__type_params__)  # revealed: @Todo(full tuple[...] support)
+reveal_type(ListOrSet.__type_params__)  # revealed: @Todo(@property)
 ```
 
 ## `TypeAliasType` properties

crates/red_knot_python_semantic/resources/mdtest/properties.md

@@ -1,305 +0,0 @@
-# Properties
-
-`property` is a built-in class in Python that can be used to model class attributes with custom
-getters, setters, and deleters.
-
-## Basic getter
-
-`property` is typically used as a decorator on a getter method. It turns the method into a property
-object. When accessing the property on an instance, the descriptor protocol is invoked, which calls
-the getter method:
-
-```py
-class C:
-    @property
-    def my_property(self) -> int:
-        return 1
-
-reveal_type(C().my_property)  # revealed: int
-```
-
-When a property is accessed on the class directly, the descriptor protocol is also invoked, but
-`property.__get__` simply returns itself in this case (when `instance` is `None`):
-
-```py
-reveal_type(C.my_property)  # revealed: property
-```
-
-## Getter and setter
-
-A property can also have a setter method, which is used to set the value of the property. The setter
-method is defined using the `@<property_name>.setter` decorator. The setter method takes the value
-to be set as an argument.
-
-```py
-class C:
-    @property
-    def my_property(self) -> int:
-        return 1
-
-    @my_property.setter
-    def my_property(self, value: int) -> None:
-        pass
-
-c = C()
-reveal_type(c.my_property)  # revealed: int
-c.my_property = 2
-
-# error: [invalid-assignment]
-c.my_property = "a"
-```
-
-## `property.getter`
-
-`property.getter` can be used to overwrite the getter method of a property. This does not overwrite
-the existing setter:
-
-```py
-class C:
-    @property
-    def my_property(self) -> int:
-        return 1
-
-    @my_property.setter
-    def my_property(self, value: int) -> None:
-        pass
-
-    @my_property.getter
-    def my_property(self) -> str:
-        return "a"
-
-c = C()
-reveal_type(c.my_property)  # revealed: str
-c.my_property = 2
-
-# error: [invalid-assignment]
-c.my_property = "b"
-```
-
-## `property.deleter`
-
-We do not support `property.deleter` yet, but we make sure that it does not invalidate the getter or
-setter:
-
-```py
-class C:
-    @property
-    def my_property(self) -> int:
-        return 1
-
-    @my_property.setter
-    def my_property(self, value: int) -> None:
-        pass
-
-    @my_property.deleter
-    def my_property(self) -> None:
-        pass
-
-c = C()
-reveal_type(c.my_property)  # revealed: int
-c.my_property = 2
-# error: [invalid-assignment]
-c.my_property = "a"
-```
-
-## Failure cases
-
-### Attempting to write to a read-only property
-
-When attempting to write to a read-only property, we emit an error:
-
-```py
-class C:
-    @property
-    def attr(self) -> int:
-        return 1
-
-c = C()
-
-# error: [invalid-assignment]
-c.attr = 2
-```
-
-### Attempting to read a write-only property
-
-When attempting to read a write-only property, we emit an error:
-
-```py
-class C:
-    def attr_setter(self, value: int) -> None:
-        pass
-    attr = property(fset=attr_setter)
-
-c = C()
-c.attr = 1
-
-# TODO: An error should be emitted here, and the type should be `Unknown`
-# or `Never`. See https://github.com/astral-sh/ruff/issues/16298 for more
-# details.
-reveal_type(c.attr)  # revealed: Unknown | property
-```
-
-### Wrong setter signature
-
-```py
-class C:
-    @property
-    def attr(self) -> int:
-        return 1
-    # error: [invalid-argument-type] "Object of type `Literal[attr]` cannot be assigned to parameter 2 (`fset`) of bound method `setter`; expected type `(Any, Any, /) -> None`"
-    @attr.setter
-    def attr(self) -> None:
-        pass
-```
-
-### Wrong getter signature
-
-```py
-class C:
-    # error: [invalid-argument-type] "Object of type `Literal[attr]` cannot be assigned to parameter 1 (`fget`) of class `property`; expected type `((Any, /) -> Any) | None`"
-    @property
-    def attr(self, x: int) -> int:
-        return 1
-```
-
-## Limitations
-
-### Manually constructed property
-
-Properties can also be constructed manually using the `property` class. We partially support this:
-
-```py
-class C:
-    def attr_getter(self) -> int:
-        return 1
-    attr = property(attr_getter)
-
-c = C()
-reveal_type(c.attr)  # revealed: Unknown | int
-```
-
-But note that we return `Unknown | int` because we did not declare the `attr` attribute. This is
-consistent with how we usually treat attributes, but here, if we try to declare `attr` as
-`property`, we fail to understand the property, since the `property` declaration shadows the more
-precise type that we infer for `property(attr_getter)` (which includes the actual information about
-the getter).
-
-```py
-class C:
-    def attr_getter(self) -> int:
-        return 1
-    attr: property = property(attr_getter)
-
-c = C()
-reveal_type(c.attr)  # revealed: Unknown
-```
-
-## Behind the scenes
-
-In this section, we trace through some of the steps that make properties work. We start with a
-simple class `C` and a property `attr`:
-
-```py
-class C:
-    def __init__(self):
-        self._attr: int = 0
-
-    @property
-    def attr(self) -> int:
-        return self._attr
-
-    @attr.setter
-    def attr(self, value: str) -> None:
-        self._attr = len(value)
-```
-
-Next, we create an instance of `C`. As we have seen above, accessing `attr` on the instance will
-return an `int`:
-
-```py
-c = C()
-
-reveal_type(c.attr)  # revealed: int
-```
-
-Behind the scenes, when we write `c.attr`, the first thing that happens is that we statically look
-up the symbol `attr` on the meta-type of `c`, i.e. the class `C`. We can emulate this static lookup
-using `inspect.getattr_static`, to see that `attr` is actually an instance of the `property` class:
-
-```py
-from inspect import getattr_static
-
-attr_property = getattr_static(C, "attr")
-reveal_type(attr_property)  # revealed: property
-```
-
-The `property` class has a `__get__` method, which makes it a descriptor. It also has a `__set__`
-method, which means that it is a *data* descriptor (if there is no setter, `__set__` is still
-available but yields an `AttributeError` at runtime).
-
-```py
-reveal_type(type(attr_property).__get__)  # revealed: <wrapper-descriptor `__get__` of `property` objects>
-reveal_type(type(attr_property).__set__)  # revealed: <wrapper-descriptor `__set__` of `property` objects>
-```
-
-When we access `c.attr`, the `__get__` method of the `property` class is called, passing the
-property object itself as the first argument, and the class instance `c` as the second argument. The
-third argument is the "owner" which can be set to `None` or to `C` in this case:
-
-```py
-reveal_type(type(attr_property).__get__(attr_property, c, C))  # revealed: int
-reveal_type(type(attr_property).__get__(attr_property, c, None))  # revealed: int
-```
-
-Alternatively, the above can also be written as a method call:
-
-```py
-reveal_type(attr_property.__get__(c, C))  # revealed: int
-```
-
-When we access `attr` on the class itself, the descriptor protocol is also invoked, but the instance
-argument is set to `None`. When `instance` is `None`, the call to `property.__get__` returns the
-property instance itself. So the following expressions are all equivalent
-
-```py
-reveal_type(attr_property)  # revealed: property
-reveal_type(C.attr)  # revealed: property
-reveal_type(attr_property.__get__(None, C))  # revealed: property
-reveal_type(type(attr_property).__get__(attr_property, None, C))  # revealed: property
-```
-
-When we set the property using `c.attr = "a"`, the `__set__` method of the property class is called.
-This attribute access desugars to
-
-```py
-type(attr_property).__set__(attr_property, c, "a")
-
-# error: [call-non-callable] "Call of wrapper descriptor `property.__set__` failed: calling the setter failed"
-type(attr_property).__set__(attr_property, c, 1)
-```
-
-which is also equivalent to the following expressions:
-
-```py
-attr_property.__set__(c, "a")
-# error: [call-non-callable]
-attr_property.__set__(c, 1)
-
-C.attr.__set__(c, "a")
-# error: [call-non-callable]
-C.attr.__set__(c, 1)
-```
-
-Properties also have `fget` and `fset` attributes that can be used to retrieve the original getter
-and setter functions, respectively.
-
-```py
-reveal_type(attr_property.fget)  # revealed: Literal[attr]
-reveal_type(attr_property.fget(c))  # revealed: int
-
-reveal_type(attr_property.fset)  # revealed: Literal[attr]
-reveal_type(attr_property.fset(c, "a"))  # revealed: None
-
-# error: [invalid-argument-type]
-attr_property.fset(c, 1)
-```

crates/red_knot_python_semantic/resources/mdtest/scopes/eager.md

@@ -154,10 +154,6 @@ x = 1
 [reveal_type(x) for a in range(1)]
 
 x = 2
-
-# error: [unresolved-reference]
-[y for a in range(1)]
-y = 1
 ```
 
 ### Set comprehensions
@@ -169,10 +165,6 @@ x = 1
 {reveal_type(x) for a in range(1)}
 
 x = 2
-
-# error: [unresolved-reference]
-{y for a in range(1)}
-y = 1
 ```
 
 ### Dict comprehensions
@@ -184,10 +176,6 @@ x = 1
 {a: reveal_type(x) for a in range(1)}
 
 x = 2
-
-# error: [unresolved-reference]
-{a: y for a in range(1)}
-y = 1
 ```
 
 ### Generator expressions
@@ -199,10 +187,6 @@ x = 1
 list(reveal_type(x) for a in range(1))
 
 x = 2
-
-# error: [unresolved-reference]
-list(y for a in range(1))
-y = 1
 ```
 
 `evaluated_later.py`:
@@ -278,14 +262,6 @@ def _():
             [reveal_type(x) for a in range(1)]
 
     x = 2
-
-x = 1
-
-def _():
-    class C:
-        # revealed: Unknown | Literal[1]
-        [reveal_type(x) for _ in [1]]
-        x = 2
 ```
 
 ### Eager scope within a lazy scope

crates/red_knot_python_semantic/resources/mdtest/scopes/moduletype_attrs.md

@@ -58,8 +58,9 @@ reveal_type(typing.__eq__)  # revealed: <bound method `__eq__` of `ModuleType`>
 
 reveal_type(typing.__class__)  # revealed: Literal[ModuleType]
 
-# TODO: needs support generics; should be `dict[str, Any]`:
-reveal_type(typing.__dict__)  # revealed: @Todo(generics)
+# TODO: needs support for attribute access on instances, properties and generics;
+# should be `dict[str, Any]`
+reveal_type(typing.__dict__)  # revealed: @Todo(@property)
 ```
 
 Typeshed includes a fake `__getattr__` method in the stub for `types.ModuleType` to help out with
@@ -91,9 +92,10 @@ reveal_type(__dict__)  # revealed: Literal["foo"]
 import foo
 from foo import __dict__ as foo_dict
 
-# TODO: needs support generics; should be `dict[str, Any]` for both of these:
-reveal_type(foo.__dict__)  # revealed: @Todo(generics)
-reveal_type(foo_dict)  # revealed: @Todo(generics)
+# TODO: needs support for attribute access on instances, properties, and generics;
+# should be `dict[str, Any]` for both of these:
+reveal_type(foo.__dict__)  # revealed: @Todo(@property)
+reveal_type(foo_dict)  # revealed: @Todo(@property)
 ```
 
 ## Conditionally global or `ModuleType` attribute

crates/red_knot_python_semantic/resources/mdtest/snapshots/tuples.md_-_Comparison___Tuples_-_Equality_with_elements_that_incorrectly_implement_`__bool__`.snap

@@ -12,12 +12,12 @@ mdtest path: crates/red_knot_python_semantic/resources/mdtest/comparison/tuples.
 ## mdtest_snippet.py
 
 ```
-1 | class NotBoolable:
-2 |     __bool__: None = None
-3 | 
-4 | class A:
-5 |     def __eq__(self, other) -> NotBoolable:
-6 |         return NotBoolable()
+1 | class A:
+2 |     def __eq__(self, other) -> NotBoolable:
+3 |         return NotBoolable()
+4 | 
+5 | class NotBoolable:
+6 |     __bool__: None = None
 7 | 
 8 | # error: [unsupported-bool-conversion]
 9 | (A(),) == (A(),)

crates/red_knot_python_semantic/resources/mdtest/statically_known_branches.md

@@ -1502,14 +1502,13 @@ if True:
 from module import symbol
 ```
 
-## Unreachable code
+## Unsupported features
 
-A closely related feature is the ability to detect unreachable code. For example, we do not emit a
-diagnostic here:
+We do not support full unreachable code analysis yet. We also raise diagnostics from
+statically-known to be false branches:
 
 ```py
 if False:
+    # error: [unresolved-reference]
     x
 ```
-
-See [unreachable.md](unreachable.md) for more tests on this topic.

crates/red_knot_python_semantic/resources/mdtest/stubs/class.md

@@ -8,10 +8,13 @@ In type stubs, classes can reference themselves in their base class definitions.
 ```pyi
 class Foo[T]: ...
 
+# TODO: actually is subscriptable
+# error: [non-subscriptable]
 class Bar(Foo[Bar]): ...
 
 reveal_type(Bar)  # revealed: Literal[Bar]
-reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Literal[Foo[Bar]], Literal[object]]
+# TODO: Instead of `Literal[Foo]`, we might eventually want to show a type that involves the type parameter.
+reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Literal[Foo], Literal[object]]
 ```
 
 ## Access to attributes declared in stubs

crates/red_knot_python_semantic/resources/mdtest/subscript/bytes.md

@@ -25,7 +25,7 @@ reveal_type(y)  # revealed: Unknown
 def _(n: int):
     a = b"abcde"[n]
     # TODO: Support overloads... Should be `bytes`
-    reveal_type(a)  # revealed: @Todo(return type of overloaded function)
+    reveal_type(a)  # revealed: @Todo(return type of decorated function)
 ```
 
 ## Slices
@@ -44,10 +44,10 @@ b[::0]  # error: [zero-stepsize-in-slice]
 def _(m: int, n: int):
     byte_slice1 = b[m:n]
     # TODO: Support overloads... Should be `bytes`
-    reveal_type(byte_slice1)  # revealed: @Todo(return type of overloaded function)
+    reveal_type(byte_slice1)  # revealed: @Todo(return type of decorated function)
 
 def _(s: bytes) -> bytes:
     byte_slice2 = s[0:5]
     # TODO: Support overloads... Should be `bytes`
-    return reveal_type(byte_slice2)  # revealed: @Todo(return type of overloaded function)
+    return reveal_type(byte_slice2)  # revealed: @Todo(return type of decorated function)
 ```

crates/red_knot_python_semantic/resources/mdtest/subscript/lists.md

@@ -12,13 +12,13 @@ x = [1, 2, 3]
 reveal_type(x)  # revealed: list
 
 # TODO reveal int
-reveal_type(x[0])  # revealed: @Todo(return type of overloaded function)
+reveal_type(x[0])  # revealed: @Todo(return type of decorated function)
 
 # TODO reveal list
-reveal_type(x[0:1])  # revealed: @Todo(return type of overloaded function)
+reveal_type(x[0:1])  # revealed: @Todo(return type of decorated function)
 
 # TODO error
-reveal_type(x["a"])  # revealed: @Todo(return type of overloaded function)
+reveal_type(x["a"])  # revealed: @Todo(return type of decorated function)
 ```
 
 ## Assignments within list assignment

crates/red_knot_python_semantic/resources/mdtest/subscript/string.md

@@ -22,7 +22,7 @@ reveal_type(b)  # revealed: Unknown
 def _(n: int):
     a = "abcde"[n]
     # TODO: Support overloads... Should be `str`
-    reveal_type(a)  # revealed: @Todo(return type of overloaded function)
+    reveal_type(a)  # revealed: @Todo(return type of decorated function)
 ```
 
 ## Slices
@@ -76,11 +76,11 @@ def _(m: int, n: int, s2: str):
 
     substring1 = s[m:n]
     # TODO: Support overloads... Should be `LiteralString`
-    reveal_type(substring1)  # revealed: @Todo(return type of overloaded function)
+    reveal_type(substring1)  # revealed: @Todo(return type of decorated function)
 
     substring2 = s2[0:5]
     # TODO: Support overloads... Should be `str`
-    reveal_type(substring2)  # revealed: @Todo(return type of overloaded function)
+    reveal_type(substring2)  # revealed: @Todo(return type of decorated function)
 ```
 
 ## Unsupported slice types

crates/red_knot_python_semantic/resources/mdtest/subscript/tuple.md

@@ -70,7 +70,7 @@ def _(m: int, n: int):
 
     tuple_slice = t[m:n]
     # TODO: Support overloads... Should be `tuple[Literal[1, 'a', b"b"] | None, ...]`
-    reveal_type(tuple_slice)  # revealed: @Todo(return type of overloaded function)
+    reveal_type(tuple_slice)  # revealed: @Todo(return type of decorated function)
 ```
 
 ## Inheritance

crates/red_knot_python_semantic/resources/mdtest/suppressions/no_type_check.md

@@ -3,7 +3,7 @@
 > If a type checker supports the `no_type_check` decorator for functions, it should suppress all
 > type errors for the def statement and its body including any nested functions or classes. It
 > should also ignore all parameter and return type annotations and treat the function as if it were
-> unannotated. [source](https://typing.python.org/en/latest/spec/directives.html#no-type-check)
+> unannotated. [source](https://typing.readthedocs.io/en/latest/spec/directives.html#no-type-check)
 
 ## Error in the function body
 
@@ -48,8 +48,6 @@ from typing import no_type_check
 @unknown_decorator  # error: [unresolved-reference]
 @no_type_check
 def test() -> int:
-    # TODO: this should not be an error
-    # error: [unresolved-reference]
     return a + 5
 ```
 
@@ -66,8 +64,6 @@ from typing import no_type_check
 @no_type_check
 @unknown_decorator
 def test() -> int:
-    # TODO: this should not be an error
-    # error: [unresolved-reference]
     return a + 5
 ```
 
@@ -95,7 +91,7 @@ def test() -> Undefined:
 
 Red Knot does not support decorating classes with `no_type_check`. The behaviour of `no_type_check`
 when applied to classes is
-[not specified currently](https://typing.python.org/en/latest/spec/directives.html#no-type-check),
+[not specified currently](https://typing.readthedocs.io/en/latest/spec/directives.html#no-type-check),
 and is not supported by Pyright or mypy.
 
 A future improvement might be to emit a diagnostic if a `no_type_check` annotation is applied to a

crates/red_knot_python_semantic/resources/mdtest/sys_platform.md

@@ -1,10 +1,23 @@
 # `sys.platform`
 
-## Explicit selection of `all` platforms
+## Default value
 
-When `python-platform="all"` is specified, we fall back to the type of `sys.platform` declared in
+When no target platform is specified, we fall back to the type of `sys.platform` declared in
 typeshed:
 
+```toml
+[environment]
+# No python-platform entry
+```
+
+```py
+import sys
+
+reveal_type(sys.platform)  # revealed: LiteralString
+```
+
+## Explicit selection of `all` platforms
+
 ```toml
 [environment]
 python-platform = "all"

crates/red_knot_python_semantic/resources/mdtest/sys_version_info.md

@@ -121,9 +121,9 @@ But the `micro`, `releaselevel` and `serial` fields are inferred as `@Todo` unti
 properties on instance types:
 
 ```py
-reveal_type(sys.version_info.micro)  # revealed: int
-reveal_type(sys.version_info.releaselevel)  # revealed: @Todo(Support for `typing.TypeAlias`)
-reveal_type(sys.version_info.serial)  # revealed: int
+reveal_type(sys.version_info.micro)  # revealed: @Todo(@property)
+reveal_type(sys.version_info.releaselevel)  # revealed: @Todo(@property)
+reveal_type(sys.version_info.serial)  # revealed: @Todo(@property)
 ```
 
 ## Accessing fields by index/slice

crates/red_knot_python_semantic/resources/mdtest/terminal_statements.md

@@ -654,7 +654,9 @@ def f(cond: bool) -> str:
         reveal_type(x)  # revealed: Literal["before"]
         return "a"
         x = "after-return"
-        reveal_type(x)  # revealed: Never
+        # TODO: no unresolved-reference error
+        # error: [unresolved-reference]
+        reveal_type(x)  # revealed: Unknown
     else:
         x = "else"
     return reveal_type(x)  # revealed: Literal["else"]

crates/red_knot_python_semantic/resources/mdtest/type_api.md

@@ -398,16 +398,16 @@ def f(x: TypeOf) -> None:
     reveal_type(x)  # revealed: Unknown
 ```
 
-## `CallableTypeOf`
+## `CallableTypeFromFunction`
 
-The `CallableTypeOf` special form can be used to extract the `Callable` structural type inhabited by
-a given callable object. This can be used to get the externally visibly signature of the object,
-which can then be used to test various type properties.
+The `CallableTypeFromFunction` special form can be used to extract the type of a function literal as
+a callable type. This can be used to get the externally-visibly signature of the function, which can
+then be used to test various type properties.
 
-It accepts a single type parameter which is expected to be a callable object.
+It accepts a single type parameter which is expected to be a function literal.
 
 ```py
-from knot_extensions import CallableTypeOf
+from knot_extensions import CallableTypeFromFunction
 
 def f1():
     return
@@ -418,40 +418,25 @@ def f2() -> int:
 def f3(x: int, y: str) -> None:
     return
 
-# error: [invalid-type-form] "Special form `knot_extensions.CallableTypeOf` expected exactly one type parameter"
-c1: CallableTypeOf[f1, f2]
+# error: [invalid-type-form] "Special form `knot_extensions.CallableTypeFromFunction` expected exactly one type parameter"
+c1: CallableTypeFromFunction[f1, f2]
+# error: [invalid-type-form] "Expected the first argument to `knot_extensions.CallableTypeFromFunction` to be a function literal, but got `Literal[int]`"
+c2: CallableTypeFromFunction[int]
 
-# error: [invalid-type-form] "Expected the first argument to `knot_extensions.CallableTypeOf` to be a callable object, but got an object of type `Literal["foo"]`"
-c2: CallableTypeOf["foo"]
-
-# error: [invalid-type-form] "`knot_extensions.CallableTypeOf` requires exactly one argument when used in a type expression"
-def f(x: CallableTypeOf) -> None:
+# error: [invalid-type-form] "`knot_extensions.CallableTypeFromFunction` requires exactly one argument when used in a type expression"
+def f(x: CallableTypeFromFunction) -> None:
     reveal_type(x)  # revealed: Unknown
 ```
 
-Using it in annotation to reveal the signature of the callable object:
+Using it in annotation to reveal the signature of the function:
 
 ```py
-class Foo:
-    def __init__(self, x: int) -> None:
-        pass
-
-    def __call__(self, x: int) -> str:
-        return "foo"
-
 def _(
-    c1: CallableTypeOf[f1],
-    c2: CallableTypeOf[f2],
-    c3: CallableTypeOf[f3],
-    c4: CallableTypeOf[Foo],
-    c5: CallableTypeOf[Foo(42).__call__],
+    c1: CallableTypeFromFunction[f1],
+    c2: CallableTypeFromFunction[f2],
+    c3: CallableTypeFromFunction[f3],
 ) -> None:
     reveal_type(c1)  # revealed: () -> Unknown
     reveal_type(c2)  # revealed: () -> int
     reveal_type(c3)  # revealed: (x: int, y: str) -> None
-
-    # TODO: should be `(x: int) -> Foo`
-    reveal_type(c4)  # revealed: (...) -> Foo
-
-    reveal_type(c5)  #  revealed: (x: int) -> str
 ```

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_assignable_to.md

@@ -183,7 +183,7 @@ static_assert(is_assignable_to(Meta, type[Unknown]))
 ## Tuple types
 
 ```py
-from knot_extensions import static_assert, is_assignable_to, AlwaysTruthy, AlwaysFalsy
+from knot_extensions import static_assert, is_assignable_to
 from typing import Literal, Any
 
 static_assert(is_assignable_to(tuple[()], tuple[()]))
@@ -194,17 +194,6 @@ static_assert(is_assignable_to(tuple[int, str], tuple[int, str]))
 static_assert(is_assignable_to(tuple[Literal[1], Literal[2]], tuple[int, int]))
 static_assert(is_assignable_to(tuple[Any, Literal[2]], tuple[int, int]))
 static_assert(is_assignable_to(tuple[Literal[1], Any], tuple[int, int]))
-static_assert(is_assignable_to(tuple[()], tuple))
-static_assert(is_assignable_to(tuple[int, str], tuple))
-static_assert(is_assignable_to(tuple[Any], tuple))
-
-# TODO: It is not yet clear if we want the following two assertions to hold.
-# See https://github.com/astral-sh/ruff/issues/15528 for more details. The
-# short version is: We either need to special-case enforcement of the Liskov
-# substitution principle on `__bool__` and `__len__` for tuple subclasses,
-# or we need to negate these assertions.
-static_assert(is_assignable_to(tuple[()], AlwaysFalsy))
-static_assert(is_assignable_to(tuple[int], AlwaysTruthy))
 
 static_assert(not is_assignable_to(tuple[()], tuple[int]))
 static_assert(not is_assignable_to(tuple[int], tuple[str]))
@@ -413,7 +402,7 @@ are covered in the [subtyping tests](./is_subtype_of.md#callable).
 ### Return type
 
 ```py
-from knot_extensions import CallableTypeOf, Unknown, static_assert, is_assignable_to
+from knot_extensions import CallableTypeFromFunction, Unknown, static_assert, is_assignable_to
 from typing import Any, Callable
 
 static_assert(is_assignable_to(Callable[[], Any], Callable[[], int]))
@@ -443,7 +432,7 @@ A `Callable` which uses the gradual form (`...`) for the parameter types is cons
 input signature.
 
 ```py
-from knot_extensions import CallableTypeOf, static_assert, is_assignable_to
+from knot_extensions import CallableTypeFromFunction, static_assert, is_assignable_to
 from typing import Any, Callable
 
 static_assert(is_assignable_to(Callable[[], None], Callable[..., None]))
@@ -461,12 +450,12 @@ def keyword_only(*, a: int, b: int) -> None: ...
 def keyword_variadic(**kwargs: int) -> None: ...
 def mixed(a: int, /, b: int, *args: int, c: int, **kwargs: int) -> None: ...
 
-static_assert(is_assignable_to(CallableTypeOf[positional_only], Callable[..., None]))
-static_assert(is_assignable_to(CallableTypeOf[positional_or_keyword], Callable[..., None]))
-static_assert(is_assignable_to(CallableTypeOf[variadic], Callable[..., None]))
-static_assert(is_assignable_to(CallableTypeOf[keyword_only], Callable[..., None]))
-static_assert(is_assignable_to(CallableTypeOf[keyword_variadic], Callable[..., None]))
-static_assert(is_assignable_to(CallableTypeOf[mixed], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[positional_only], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[positional_or_keyword], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[variadic], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[keyword_only], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[keyword_variadic], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[mixed], Callable[..., None]))
 ```
 
 And, even if the parameters are unannotated.
@@ -479,29 +468,12 @@ def keyword_only(*, a, b) -> None: ...
 def keyword_variadic(**kwargs) -> None: ...
 def mixed(a, /, b, *args, c, **kwargs) -> None: ...
 
-static_assert(is_assignable_to(CallableTypeOf[positional_only], Callable[..., None]))
-static_assert(is_assignable_to(CallableTypeOf[positional_or_keyword], Callable[..., None]))
-static_assert(is_assignable_to(CallableTypeOf[variadic], Callable[..., None]))
-static_assert(is_assignable_to(CallableTypeOf[keyword_only], Callable[..., None]))
-static_assert(is_assignable_to(CallableTypeOf[keyword_variadic], Callable[..., None]))
-static_assert(is_assignable_to(CallableTypeOf[mixed], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[positional_only], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[positional_or_keyword], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[variadic], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[keyword_only], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[keyword_variadic], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[mixed], Callable[..., None]))
 ```
 
-### Function types
-
-```py
-from typing import Any, Callable
-
-def f(x: Any) -> str:
-    return ""
-
-def g(x: Any) -> int:
-    return 1
-
-c: Callable[[Any], str] = f
-
-# error: [invalid-assignment] "Object of type `Literal[g]` is not assignable to `(Any, /) -> str`"
-c: Callable[[Any], str] = g
-```
-
-[typing documentation]: https://typing.python.org/en/latest/spec/concepts.html#the-assignable-to-or-consistent-subtyping-relation
+[typing documentation]: https://typing.readthedocs.io/en/latest/spec/concepts.html#the-assignable-to-or-consistent-subtyping-relation

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_disjoint_from.md

@@ -61,7 +61,7 @@ static_assert(is_disjoint_from(B2, FinalSubclass))
 ## Tuple types
 
 ```py
-from typing_extensions import Literal, Never
+from typing_extensions import Literal
 from knot_extensions import TypeOf, is_disjoint_from, static_assert
 
 static_assert(is_disjoint_from(tuple[()], TypeOf[object]))
@@ -353,41 +353,3 @@ class UsesMeta2(metaclass=Meta2): ...
 
 static_assert(is_disjoint_from(type[UsesMeta1], type[UsesMeta2]))
 ```
-
-## Callables
-
-No two callable types are disjoint because there exists a non-empty callable type
-`(*args: object, **kwargs: object) -> Never` that is a subtype of all fully static callable types.
-As such, for any two callable types, it is possible to conceive of a runtime callable object that
-would inhabit both types simultaneously.
-
-```py
-from knot_extensions import CallableTypeOf, is_disjoint_from, static_assert
-from typing_extensions import Callable, Literal, Never
-
-def mixed(a: int, /, b: str, *args: int, c: int = 2, **kwargs: int) -> None: ...
-
-static_assert(not is_disjoint_from(Callable[[], Never], CallableTypeOf[mixed]))
-static_assert(not is_disjoint_from(Callable[[int, str], float], CallableTypeOf[mixed]))
-
-# Using gradual form
-static_assert(not is_disjoint_from(Callable[..., None], Callable[[], None]))
-static_assert(not is_disjoint_from(Callable[..., None], Callable[..., None]))
-static_assert(not is_disjoint_from(Callable[..., None], Callable[[Literal[1]], None]))
-
-# Using `Never`
-static_assert(not is_disjoint_from(Callable[[], Never], Callable[[], Never]))
-static_assert(not is_disjoint_from(Callable[[Never], str], Callable[[Never], int]))
-```
-
-A callable type is disjoint from all literal types.
-
-```py
-from knot_extensions import CallableTypeOf, is_disjoint_from, static_assert
-from typing_extensions import Callable, Literal, Never
-
-static_assert(is_disjoint_from(Callable[[], None], Literal[""]))
-static_assert(is_disjoint_from(Callable[[], None], Literal[b""]))
-static_assert(is_disjoint_from(Callable[[], None], Literal[1]))
-static_assert(is_disjoint_from(Callable[[], None], Literal[True]))
-```

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_equivalent_to.md

@@ -127,14 +127,13 @@ the parameter in one of the callable has a default value then the corresponding
 other callable should also have a default value.
 
 ```py
-from knot_extensions import CallableTypeOf, is_equivalent_to, static_assert
+from knot_extensions import CallableTypeFromFunction, is_equivalent_to, static_assert
 from typing import Callable
 
 def f1(a: int = 1) -> None: ...
 def f2(a: int = 2) -> None: ...
 
-static_assert(is_equivalent_to(CallableTypeOf[f1], CallableTypeOf[f2]))
-static_assert(is_equivalent_to(CallableTypeOf[f1] | bool | CallableTypeOf[f2], CallableTypeOf[f2] | bool | CallableTypeOf[f1]))
+static_assert(is_equivalent_to(CallableTypeFromFunction[f1], CallableTypeFromFunction[f2]))
 ```
 
 The names of the positional-only, variadic and keyword-variadic parameters does not need to be the
@@ -144,8 +143,7 @@ same.
 def f3(a1: int, /, *args1: int, **kwargs2: int) -> None: ...
 def f4(a2: int, /, *args2: int, **kwargs1: int) -> None: ...
 
-static_assert(is_equivalent_to(CallableTypeOf[f3], CallableTypeOf[f4]))
-static_assert(is_equivalent_to(CallableTypeOf[f3] | bool | CallableTypeOf[f4], CallableTypeOf[f4] | bool | CallableTypeOf[f3]))
+static_assert(is_equivalent_to(CallableTypeFromFunction[f3], CallableTypeFromFunction[f4]))
 ```
 
 Putting it all together, the following two callables are equivalent:
@@ -154,8 +152,7 @@ Putting it all together, the following two callables are equivalent:
 def f5(a1: int, /, b: float, c: bool = False, *args1: int, d: int = 1, e: str, **kwargs1: float) -> None: ...
 def f6(a2: int, /, b: float, c: bool = True, *args2: int, d: int = 2, e: str, **kwargs2: float) -> None: ...
 
-static_assert(is_equivalent_to(CallableTypeOf[f5], CallableTypeOf[f6]))
-static_assert(is_equivalent_to(CallableTypeOf[f5] | bool | CallableTypeOf[f6], CallableTypeOf[f6] | bool | CallableTypeOf[f5]))
+static_assert(is_equivalent_to(CallableTypeFromFunction[f5], CallableTypeFromFunction[f6]))
 ```
 
 ### Not equivalent
@@ -163,7 +160,7 @@ static_assert(is_equivalent_to(CallableTypeOf[f5] | bool | CallableTypeOf[f6], C
 There are multiple cases when two callable types are not equivalent which are enumerated below.
 
 ```py
-from knot_extensions import CallableTypeOf, is_equivalent_to, static_assert
+from knot_extensions import CallableTypeFromFunction, is_equivalent_to, static_assert
 from typing import Callable
 ```
 
@@ -173,7 +170,7 @@ When the number of parameters is different:
 def f1(a: int) -> None: ...
 def f2(a: int, b: int) -> None: ...
 
-static_assert(not is_equivalent_to(CallableTypeOf[f1], CallableTypeOf[f2]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f1], CallableTypeFromFunction[f2]))
 ```
 
 When either of the callable types uses a gradual form for the parameters:
@@ -190,9 +187,9 @@ def f3(): ...
 def f4() -> None: ...
 
 static_assert(not is_equivalent_to(Callable[[], int], Callable[[], None]))
-static_assert(not is_equivalent_to(CallableTypeOf[f3], CallableTypeOf[f3]))
-static_assert(not is_equivalent_to(CallableTypeOf[f3], CallableTypeOf[f4]))
-static_assert(not is_equivalent_to(CallableTypeOf[f4], CallableTypeOf[f3]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f3], CallableTypeFromFunction[f3]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f3], CallableTypeFromFunction[f4]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f4], CallableTypeFromFunction[f3]))
 ```
 
 When the parameter names are different:
@@ -201,13 +198,13 @@ When the parameter names are different:
 def f5(a: int) -> None: ...
 def f6(b: int) -> None: ...
 
-static_assert(not is_equivalent_to(CallableTypeOf[f5], CallableTypeOf[f6]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f5], CallableTypeFromFunction[f6]))
 ```
 
 When only one of the callable types has parameter names:
 
 ```py
-static_assert(not is_equivalent_to(CallableTypeOf[f5], Callable[[int], None]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f5], Callable[[int], None]))
 ```
 
 When the parameter kinds are different:
@@ -216,7 +213,7 @@ When the parameter kinds are different:
 def f7(a: int, /) -> None: ...
 def f8(a: int) -> None: ...
 
-static_assert(not is_equivalent_to(CallableTypeOf[f7], CallableTypeOf[f8]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f7], CallableTypeFromFunction[f8]))
 ```
 
 When the annotated types of the parameters are not equivalent or absent in one or both of the
@@ -227,10 +224,10 @@ def f9(a: int) -> None: ...
 def f10(a: str) -> None: ...
 def f11(a) -> None: ...
 
-static_assert(not is_equivalent_to(CallableTypeOf[f9], CallableTypeOf[f10]))
-static_assert(not is_equivalent_to(CallableTypeOf[f10], CallableTypeOf[f11]))
-static_assert(not is_equivalent_to(CallableTypeOf[f11], CallableTypeOf[f10]))
-static_assert(not is_equivalent_to(CallableTypeOf[f11], CallableTypeOf[f11]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f9], CallableTypeFromFunction[f10]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f10], CallableTypeFromFunction[f11]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f11], CallableTypeFromFunction[f10]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f11], CallableTypeFromFunction[f11]))
 ```
 
 When the default value for a parameter is present only in one of the callable type:
@@ -239,19 +236,8 @@ When the default value for a parameter is present only in one of the callable ty
 def f12(a: int) -> None: ...
 def f13(a: int = 2) -> None: ...
 
-static_assert(not is_equivalent_to(CallableTypeOf[f12], CallableTypeOf[f13]))
-static_assert(not is_equivalent_to(CallableTypeOf[f13], CallableTypeOf[f12]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f12], CallableTypeFromFunction[f13]))
+static_assert(not is_equivalent_to(CallableTypeFromFunction[f13], CallableTypeFromFunction[f12]))
 ```
 
-### Unions containing `Callable`s containing unions
-
-Differently ordered unions inside `Callable`s inside unions can still be equivalent:
-
-```py
-from typing import Callable
-from knot_extensions import is_equivalent_to, static_assert
-
-static_assert(is_equivalent_to(int | Callable[[int | str], None], Callable[[str | int], None] | int))
-```
-
-[the equivalence relation]: https://typing.python.org/en/latest/spec/glossary.html#term-equivalent
+[the equivalence relation]: https://typing.readthedocs.io/en/latest/spec/glossary.html#term-equivalent

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_fully_static.md

@@ -80,7 +80,7 @@ Using function literals, we can check more variations of callable types as it al
 parameters without annotations and no return type.
 
 ```py
-from knot_extensions import CallableTypeOf, is_fully_static, static_assert
+from knot_extensions import CallableTypeFromFunction, is_fully_static, static_assert
 
 def f00() -> None: ...
 def f01(a: int, b: str) -> None: ...
@@ -90,12 +90,12 @@ def f13(a, b: int): ...
 def f14(a, b: int) -> None: ...
 def f15(a, b) -> None: ...
 
-static_assert(is_fully_static(CallableTypeOf[f00]))
-static_assert(is_fully_static(CallableTypeOf[f01]))
+static_assert(is_fully_static(CallableTypeFromFunction[f00]))
+static_assert(is_fully_static(CallableTypeFromFunction[f01]))
 
-static_assert(not is_fully_static(CallableTypeOf[f11]))
-static_assert(not is_fully_static(CallableTypeOf[f12]))
-static_assert(not is_fully_static(CallableTypeOf[f13]))
-static_assert(not is_fully_static(CallableTypeOf[f14]))
-static_assert(not is_fully_static(CallableTypeOf[f15]))
+static_assert(not is_fully_static(CallableTypeFromFunction[f11]))
+static_assert(not is_fully_static(CallableTypeFromFunction[f12]))
+static_assert(not is_fully_static(CallableTypeFromFunction[f13]))
+static_assert(not is_fully_static(CallableTypeFromFunction[f14]))
+static_assert(not is_fully_static(CallableTypeFromFunction[f15]))
 ```

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_gradual_equivalent_to.md

@@ -73,7 +73,7 @@ gradual types. The cases with fully static types and using different combination
 are covered in the [equivalence tests](./is_equivalent_to.md#callable).
 
 ```py
-from knot_extensions import Unknown, CallableTypeOf, is_gradual_equivalent_to, static_assert
+from knot_extensions import Unknown, CallableTypeFromFunction, is_gradual_equivalent_to, static_assert
 from typing import Any, Callable
 
 static_assert(is_gradual_equivalent_to(Callable[..., int], Callable[..., int]))
@@ -92,7 +92,7 @@ type of `Any`.
 def f1():
     return
 
-static_assert(is_gradual_equivalent_to(CallableTypeOf[f1], Callable[[], Any]))
+static_assert(is_gradual_equivalent_to(CallableTypeFromFunction[f1], Callable[[], Any]))
 ```
 
 And, similarly for parameters with no annotations.
@@ -101,7 +101,7 @@ And, similarly for parameters with no annotations.
 def f2(a, b, /) -> None:
     return
 
-static_assert(is_gradual_equivalent_to(CallableTypeOf[f2], Callable[[Any, Any], None]))
+static_assert(is_gradual_equivalent_to(CallableTypeFromFunction[f2], Callable[[Any, Any], None]))
 ```
 
 Additionally, as per the spec, a function definition that includes both `*args` and `**kwargs`
@@ -115,8 +115,8 @@ def variadic_without_annotation(*args, **kwargs):
 def variadic_with_annotation(*args: Any, **kwargs: Any) -> Any:
     return
 
-static_assert(is_gradual_equivalent_to(CallableTypeOf[variadic_without_annotation], Callable[..., Any]))
-static_assert(is_gradual_equivalent_to(CallableTypeOf[variadic_with_annotation], Callable[..., Any]))
+static_assert(is_gradual_equivalent_to(CallableTypeFromFunction[variadic_without_annotation], Callable[..., Any]))
+static_assert(is_gradual_equivalent_to(CallableTypeFromFunction[variadic_with_annotation], Callable[..., Any]))
 ```
 
 But, a function with either `*args` or `**kwargs` (and not both) is not gradual equivalent to a
@@ -129,8 +129,8 @@ def variadic_args(*args):
 def variadic_kwargs(**kwargs):
     return
 
-static_assert(not is_gradual_equivalent_to(CallableTypeOf[variadic_args], Callable[..., Any]))
-static_assert(not is_gradual_equivalent_to(CallableTypeOf[variadic_kwargs], Callable[..., Any]))
+static_assert(not is_gradual_equivalent_to(CallableTypeFromFunction[variadic_args], Callable[..., Any]))
+static_assert(not is_gradual_equivalent_to(CallableTypeFromFunction[variadic_kwargs], Callable[..., Any]))
 ```
 
 Parameter names, default values, and it's kind should also be considered when checking for gradual
@@ -140,21 +140,18 @@ equivalence.
 def f1(a): ...
 def f2(b): ...
 
-static_assert(not is_gradual_equivalent_to(CallableTypeOf[f1], CallableTypeOf[f2]))
+static_assert(not is_gradual_equivalent_to(CallableTypeFromFunction[f1], CallableTypeFromFunction[f2]))
 
 def f3(a=1): ...
 def f4(a=2): ...
 def f5(a): ...
 
-static_assert(is_gradual_equivalent_to(CallableTypeOf[f3], CallableTypeOf[f4]))
-static_assert(
-    is_gradual_equivalent_to(CallableTypeOf[f3] | bool | CallableTypeOf[f4], CallableTypeOf[f4] | bool | CallableTypeOf[f3])
-)
-static_assert(not is_gradual_equivalent_to(CallableTypeOf[f3], CallableTypeOf[f5]))
+static_assert(is_gradual_equivalent_to(CallableTypeFromFunction[f3], CallableTypeFromFunction[f4]))
+static_assert(not is_gradual_equivalent_to(CallableTypeFromFunction[f3], CallableTypeFromFunction[f5]))
 
 def f6(a, /): ...
 
-static_assert(not is_gradual_equivalent_to(CallableTypeOf[f1], CallableTypeOf[f6]))
+static_assert(not is_gradual_equivalent_to(CallableTypeFromFunction[f1], CallableTypeFromFunction[f6]))
 ```
 
-[materializations]: https://typing.python.org/en/latest/spec/glossary.html#term-materialize
+[materializations]: https://typing.readthedocs.io/en/latest/spec/glossary.html#term-materialize