[pygrep-hooks]: Detect file-level suppressions comments without rule codes (PGH004)

[pylint] Better inference for str.strip (PLE310) (#16671 )
## Summary This PR stabilizes the behavior introduced in https://github.com/astral-sh/ruff/pull/15985 The new behavior improves the inference of `str.strip` calls: * before: The rule only considered calls on string or byte literals (`"abcd".strip`) * now: The rule also catches calls to `strip` on object where the type is known to be a `str` or `bytes` (e.g. `a = "abc"; a.strip("//")`) The new behavior shipped as part of Ruff 0.9.6 on the 10th of Feb which is a little more than a month ago. There have been now new issues or PRs related to the new behavior.
2025-03-13 09:36:00 +01:00 · 2025-03-13 09:35:41 +01:00 · 2025-03-13 09:22:29 +01:00 · 2025-03-13 08:59:48 +01:00 · 2025-03-13 08:47:59 +01:00 · 2025-03-13 08:46:23 +01:00
1095 changed files with 27032 additions and 76815 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -18,7 +18,6 @@
 /python/py-fuzzer/ @AlexWaygood

 # red-knot
-/crates/red_knot* @carljm @MichaReiser @AlexWaygood @sharkdp @dcreager
-/crates/ruff_db/ @carljm @MichaReiser @AlexWaygood @sharkdp @dcreager
-/scripts/knot_benchmark/ @carljm @MichaReiser @AlexWaygood @sharkdp @dcreager
-/crates/red_knot_python_semantic @carljm @AlexWaygood @sharkdp @dcreager
+/crates/red_knot* @carljm @MichaReiser @AlexWaygood @sharkdp
+/crates/ruff_db/ @carljm @MichaReiser @AlexWaygood @sharkdp
+/scripts/knot_benchmark/ @carljm @MichaReiser @AlexWaygood @sharkdp
--- a/.github/renovate.json5
+++ b/.github/renovate.json5
@@ -40,17 +40,6 @@
    enabled: true,
  },
  packageRules: [
-    // Pin GitHub Actions to immutable SHAs.
-    {
-      matchDepTypes: ["action"],
-      pinDigests: true,
-    },
-    // Annotate GitHub Actions SHAs with a SemVer version.
-    {
-      extends: ["helpers:pinGitHubActionDigests"],
-      extractVersion: "^(?<version>v?\\d+\\.\\d+\\.\\d+)$",
-      versioning: "regex:^v?(?<major>\\d+)(\\.(?<minor>\\d+)\\.(?<patch>\\d+))?$",
-    },
    {
      // Group upload/download artifact updates, the versions are dependent
      groupName: "Artifact GitHub Actions dependencies",
--- a/.github/workflows/build-binaries.yml
+++ b/.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@v4
        with:
          submodules: recursive
          persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@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@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@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@v4
        with:
          submodules: recursive
          persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@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@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@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@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@v4
        with:
          submodules: recursive
          persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@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@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@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@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@v4
        with:
          submodules: recursive
          persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@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@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@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@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@v4
        with:
          submodules: recursive
          persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@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@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@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@v4
        with:
          name: artifacts-${{ matrix.target }}
          path: |
@@ -294,24 +294,24 @@ jobs:
            arch: arm

    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@v4
        with:
          submodules: recursive
          persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@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@v1
        with:
          target: ${{ matrix.platform.target }}
          manylinux: auto
          docker-options: ${{ matrix.platform.maturin_docker_options }}
          args: --release --locked --out dist
-      - uses: uraimo/run-on-arch-action@ac33288c3728ca72563c97b8b88dda5a65a84448 # v2
-        if: ${{ matrix.platform.arch != 'ppc64' && matrix.platform.arch != 'ppc64le'}}
+      - uses: uraimo/run-on-arch-action@v2
+        if: matrix.platform.arch != 'ppc64'
        name: Test wheel
        with:
          arch: ${{ matrix.platform.arch == 'arm' && 'armv6' || matrix.platform.arch }}
@@ -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@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@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@v4
        with:
          submodules: recursive
          persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@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@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@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@v4
        with:
          name: artifacts-${{ matrix.target }}
          path: |
@@ -425,23 +425,23 @@ jobs:
            arch: armv7

    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@v4
        with:
          submodules: recursive
          persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@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@v1
        with:
          target: ${{ matrix.platform.target }}
          manylinux: musllinux_1_2
          args: --release --locked --out dist
          docker-options: ${{ matrix.platform.maturin_docker_options }}
-      - uses: uraimo/run-on-arch-action@ac33288c3728ca72563c97b8b88dda5a65a84448 # v2
+      - uses: uraimo/run-on-arch-action@v2
        name: Test wheel
        with:
          arch: ${{ matrix.platform.arch }}
@@ -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@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@v4
        with:
          name: artifacts-${{ matrix.platform.target }}
          path: |
--- a/.github/workflows/build-docker.yml
+++ b/.github/workflows/build-docker.yml
@@ -33,14 +33,14 @@ jobs:
          - linux/amd64
          - linux/arm64
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@v4
        with:
          submodules: recursive
          persist-credentials: false

-      - uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3
+      - uses: docker/setup-buildx-action@v3

-      - uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3
+      - uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
@@ -63,7 +63,7 @@ jobs:

      - name: Extract metadata (tags, labels) for Docker
        id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5
+        uses: docker/metadata-action@v5
        with:
          images: ${{ env.RUFF_BASE_IMG }}
          # Defining this makes sure the org.opencontainers.image.version OCI label becomes the actual release version and not the branch name
@@ -79,7 +79,7 @@ jobs:
      # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
      - name: Build and push by digest
        id: build
-        uses: docker/build-push-action@471d1dc4e07e5cdedd4c2171150001c434f0b7a4 # v6
+        uses: docker/build-push-action@v6
        with:
          context: .
          platforms: ${{ matrix.platform }}
@@ -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@v4
        with:
          name: digests-${{ env.PLATFORM_TUPLE }}
          path: /tmp/digests/*
@@ -113,17 +113,17 @@ 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@v4
        with:
          path: /tmp/digests
          pattern: digests-*
          merge-multiple: true

-      - uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3
+      - uses: docker/setup-buildx-action@v3

      - name: Extract metadata (tags, labels) for Docker
        id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5
+        uses: docker/metadata-action@v5
        with:
          images: ${{ env.RUFF_BASE_IMG }}
          # Order is on purpose such that the label org.opencontainers.image.version has the first pattern with the full version
@@ -131,7 +131,7 @@ jobs:
            type=pep440,pattern={{ version }},value=${{ fromJson(inputs.plan).announcement_tag }}
            type=pep440,pattern={{ major }}.{{ minor }},value=${{ fromJson(inputs.plan).announcement_tag }}

-      - uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3
+      - uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
@@ -167,9 +167,9 @@ jobs:
          - debian:bookworm-slim,bookworm-slim,debian-slim
          - buildpack-deps:bookworm,bookworm,debian
    steps:
-      - uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3
+      - uses: docker/setup-buildx-action@v3

-      - uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3
+      - uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
@@ -219,7 +219,7 @@ jobs:

      - name: Extract metadata (tags, labels) for Docker
        id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5
+        uses: docker/metadata-action@v5
        # ghcr.io prefers index level annotations
        env:
          DOCKER_METADATA_ANNOTATIONS_LEVELS: index
@@ -231,7 +231,7 @@ jobs:
            ${{ env.TAG_PATTERNS }}

      - name: Build and push
-        uses: docker/build-push-action@471d1dc4e07e5cdedd4c2171150001c434f0b7a4 # v6
+        uses: docker/build-push-action@v6
        with:
          context: .
          platforms: linux/amd64,linux/arm64
@@ -256,17 +256,17 @@ 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@v4
        with:
          path: /tmp/digests
          pattern: digests-*
          merge-multiple: true

-      - uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3
+      - uses: docker/setup-buildx-action@v3

      - name: Extract metadata (tags, labels) for Docker
        id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5
+        uses: docker/metadata-action@v5
        env:
          DOCKER_METADATA_ANNOTATIONS_LEVELS: index
        with:
@@ -276,7 +276,7 @@ jobs:
            type=pep440,pattern={{ version }},value=${{ fromJson(inputs.plan).announcement_tag }}
            type=pep440,pattern={{ major }}.{{ minor }},value=${{ fromJson(inputs.plan).announcement_tag }}

-      - uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3
+      - uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
--- a/.github/workflows/ci.yaml
+++ b/.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:
@@ -26,177 +26,83 @@ jobs:
    runs-on: ubuntu-latest
    outputs:
      # Flag that is raised when any code that affects parser is changed
-      parser: ${{ steps.check_parser.outputs.changed }}
+      parser: ${{ steps.changed.outputs.parser_any_changed }}
      # Flag that is raised when any code that affects linter is changed
-      linter: ${{ steps.check_linter.outputs.changed }}
+      linter: ${{ steps.changed.outputs.linter_any_changed }}
      # Flag that is raised when any code that affects formatter is changed
-      formatter: ${{ steps.check_formatter.outputs.changed }}
+      formatter: ${{ steps.changed.outputs.formatter_any_changed }}
      # Flag that is raised when any code is changed
      # This is superset of the linter and formatter
-      code: ${{ steps.check_code.outputs.changed }}
+      code: ${{ steps.changed.outputs.code_any_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 }}
+      fuzz: ${{ steps.changed.outputs.fuzz_any_changed }}
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
          persist-credentials: false

-      - name: Determine merge base
-        id: merge_base
-        env:
-          BASE_REF: ${{ github.event.pull_request.base.ref || 'main' }}
-        run: |
-          sha=$(git merge-base HEAD "origin/${BASE_REF}")
-          echo "sha=${sha}" >> "$GITHUB_OUTPUT"
+      - uses: tj-actions/changed-files@v45
+        id: changed
+        with:
+          files_yaml: |
+            parser:
+              - Cargo.toml
+              - Cargo.lock
+              - crates/ruff_python_trivia/**
+              - crates/ruff_source_file/**
+              - crates/ruff_text_size/**
+              - crates/ruff_python_ast/**
+              - crates/ruff_python_parser/**
+              - python/py-fuzzer/**
+              - .github/workflows/ci.yaml

-      - name: Check if the parser code changed
-        id: check_parser
-        env:
-          MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
-        run: |
-          if git diff --quiet "${MERGE_BASE}...HEAD" -- \
-            ':Cargo.toml' \
-            ':Cargo.lock' \
-            ':crates/ruff_python_trivia/**' \
-            ':crates/ruff_source_file/**' \
-            ':crates/ruff_text_size/**' \
-            ':crates/ruff_python_ast/**' \
-            ':crates/ruff_python_parser/**' \
-            ':python/py-fuzzer/**' \
-            ':.github/workflows/ci.yaml' \
-          ; then
-              echo "changed=false" >> "$GITHUB_OUTPUT"
-          else
-              echo "changed=true" >> "$GITHUB_OUTPUT"
-          fi
+            linter:
+              - Cargo.toml
+              - Cargo.lock
+              - crates/**
+              - "!crates/red_knot*/**"
+              - "!crates/ruff_python_formatter/**"
+              - "!crates/ruff_formatter/**"
+              - "!crates/ruff_dev/**"
+              - scripts/*
+              - python/**
+              - .github/workflows/ci.yaml

-      - name: Check if the linter code changed
-        id: check_linter
-        env:
-          MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
-        run: |
-          if git diff --quiet "${MERGE_BASE}...HEAD" -- ':Cargo.toml' \
-            ':Cargo.lock' \
-            ':crates/**' \
-            ':!crates/red_knot*/**' \
-            ':!crates/ruff_python_formatter/**' \
-            ':!crates/ruff_formatter/**' \
-            ':!crates/ruff_dev/**' \
-            ':!crates/ruff_db/**' \
-            ':scripts/*' \
-            ':python/**' \
-            ':.github/workflows/ci.yaml' \
-          ; then
-              echo "changed=false" >> "$GITHUB_OUTPUT"
-          else
-              echo "changed=true" >> "$GITHUB_OUTPUT"
-          fi
+            formatter:
+              - Cargo.toml
+              - Cargo.lock
+              - crates/ruff_python_formatter/**
+              - crates/ruff_formatter/**
+              - crates/ruff_python_trivia/**
+              - crates/ruff_python_ast/**
+              - crates/ruff_source_file/**
+              - crates/ruff_python_index/**
+              - crates/ruff_text_size/**
+              - crates/ruff_python_parser/**
+              - crates/ruff_dev/**
+              - scripts/*
+              - python/**
+              - .github/workflows/ci.yaml

-      - name: Check if the formatter code changed
-        id: check_formatter
-        env:
-          MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
-        run: |
-          if git diff --quiet "${MERGE_BASE}...HEAD" -- ':Cargo.toml' \
-            ':Cargo.lock' \
-            ':crates/ruff_python_formatter/**' \
-            ':crates/ruff_formatter/**' \
-            ':crates/ruff_python_trivia/**' \
-            ':crates/ruff_python_ast/**' \
-            ':crates/ruff_source_file/**' \
-            ':crates/ruff_python_index/**' \
-            ':crates/ruff_python_index/**' \
-            ':crates/ruff_text_size/**' \
-            ':crates/ruff_python_parser/**' \
-            ':scripts/*' \
-            ':python/**' \
-            ':.github/workflows/ci.yaml' \
-          ; then
-              echo "changed=false" >> "$GITHUB_OUTPUT"
-          else
-              echo "changed=true" >> "$GITHUB_OUTPUT"
-          fi
+            fuzz:
+              - fuzz/Cargo.toml
+              - fuzz/Cargo.lock
+              - fuzz/fuzz_targets/**

-      - name: Check if the fuzzer code changed
-        id: check_fuzzer
-        env:
-          MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
-        run: |
-          if git diff --quiet "${MERGE_BASE}...HEAD" -- ':Cargo.toml' \
-            ':Cargo.lock' \
-            ':fuzz/fuzz_targets/**' \
-            ':.github/workflows/ci.yaml' \
-          ; then
-              echo "changed=false" >> "$GITHUB_OUTPUT"
-          else
-              echo "changed=true" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Check if there was any code related change
-        id: check_code
-        env:
-          MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
-        run: |
-          if git diff --quiet "${MERGE_BASE}...HEAD" -- ':**' \
-            ':!**/*.md' \
-            ':crates/red_knot_python_semantic/resources/mdtest/**/*.md' \
-            ':!docs/**' \
-            ':!assets/**' \
-            ':.github/workflows/ci.yaml' \
-          ; then
-              echo "changed=false" >> "$GITHUB_OUTPUT"
-          else
-              echo "changed=true" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Check if there was any playground related change
-        id: check_playground
-        env:
-          MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
-        run: |
-          if git diff --quiet "${MERGE_BASE}...HEAD" -- \
-            ':playground/**' \
-          ; then
-              echo "changed=false" >> "$GITHUB_OUTPUT"
-          else
-              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
+            code:
+              - "**/*"
+              - "!**/*.md"
+              - "crates/red_knot_python_semantic/resources/mdtest/**/*.md"
+              - "!docs/**"
+              - "!assets/**"

  cargo-fmt:
    name: "cargo fmt"
    runs-on: ubuntu-latest
    timeout-minutes: 10
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@v4
        with:
          persist-credentials: false
      - name: "Install Rust toolchain"
@@ -210,10 +116,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@v4
        with:
          persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@v2
      - name: "Install Rust toolchain"
        run: |
          rustup component add clippy
@@ -230,30 +136,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@v4
        with:
          persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@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@v2
        with:
          tool: cargo-nextest
      - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@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 +170,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@v4
        with:
          name: ruff
          path: target/debug/ruff
@@ -284,20 +182,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@v4
        with:
          persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@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@v2
        with:
          tool: cargo-nextest
      - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@v2
        with:
          tool: cargo-insta
      - name: "Run tests"
@@ -313,14 +211,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@v4
        with:
          persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@v2
      - name: "Install Rust toolchain"
        run: rustup show
      - name: "Install cargo nextest"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@v2
        with:
          tool: cargo-nextest
      - name: "Run tests"
@@ -340,18 +238,18 @@ 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@v4
        with:
          persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@v2
      - name: "Install Rust toolchain"
        run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
+      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: "npm"
          cache-dependency-path: playground/package-lock.json
-      - uses: jetli/wasm-pack-action@0d096b08b4e5a7de8c28de67e11e945404e9eefa # v0.4.0
+      - uses: jetli/wasm-pack-action@v0.4.0
        with:
          version: v0.13.1
      - name: "Test ruff_wasm"
@@ -369,10 +267,10 @@ jobs:
    if: ${{ github.ref == 'refs/heads/main' }}
    timeout-minutes: 20
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@v4
        with:
          persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@v2
      - name: "Install Rust toolchain"
        run: rustup show
      - name: "Install mold"
@@ -387,15 +285,15 @@ 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@v4
        with:
          persist-credentials: false
-      - uses: SebRollen/toml-action@b1b3628f55fc3a28208d4203ada8b737e9687876 # v1.2.0
+      - uses: SebRollen/toml-action@v1.2.0
        id: msrv
        with:
          file: "Cargo.toml"
          field: "workspace.package.rust-version"
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@v2
      - name: "Install Rust toolchain"
        env:
          MSRV: ${{ steps.msrv.outputs.value }}
@@ -403,11 +301,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@v2
        with:
          tool: cargo-nextest
      - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@v2
        with:
          tool: cargo-insta
      - name: "Run tests"
@@ -424,10 +322,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@v4
        with:
          persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@v2
        with:
          workspaces: "fuzz -> target"
      - name: "Install Rust toolchain"
@@ -452,11 +350,11 @@ jobs:
    env:
      FORCE_COLOR: 1
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@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@v5
+      - uses: actions/download-artifact@v4
        name: Download Ruff binary to test
        id: download-cached-binary
        with:
@@ -486,10 +384,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@v4
        with:
          persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@v2
      - name: "Install Rust toolchain"
        run: rustup component add rustfmt
      # Run all code generation scripts, and verify that the current output is
@@ -518,21 +416,21 @@ 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@v4
        with:
          persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@v5
        with:
          python-version: ${{ env.PYTHON_VERSION }}

-      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
+      - uses: actions/download-artifact@v4
        name: Download comparison Ruff binary
        id: ruff-target
        with:
          name: ruff
          path: target/debug

-      - uses: dawidd6/action-download-artifact@20319c5641d495c8a52e688b7dc5fada6c3a9fbc # v8
+      - uses: dawidd6/action-download-artifact@v8
        name: Download baseline Ruff binary
        with:
          name: ruff
@@ -620,13 +518,13 @@ jobs:
        run: |
          echo ${{ github.event.number }} > pr-number

-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+      - uses: actions/upload-artifact@v4
        name: Upload PR Number
        with:
          name: pr-number
          path: pr-number

-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+      - uses: actions/upload-artifact@v4
        name: Upload Results
        with:
          name: ecosystem-result
@@ -638,7 +536,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@v4
        with:
          persist-credentials: false
      - uses: cargo-bins/cargo-binstall@main
@@ -651,18 +549,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@v4
        with:
          persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@v5
        with:
          python-version: ${{ env.PYTHON_VERSION }}
          architecture: x64
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@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@v1
        with:
          args: --out dist
      - name: "Test wheel"
@@ -675,15 +573,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@v4
        with:
          persist-credentials: false
-      - uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - uses: Swatinem/rust-cache@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@v4
        with:
          path: ~/.cache/pre-commit
          key: pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
@@ -692,7 +597,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 +610,22 @@ jobs:
    env:
      MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@v4
        with:
          persist-credentials: false
-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@v5
        with:
          python-version: "3.13"
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@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@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@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 +652,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@v4
        with:
          persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@v2
      - name: "Install Rust toolchain"
        run: rustup show
      - name: "Run checks"
@@ -769,22 +674,21 @@ jobs:
      - determine_changes
    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
    steps:
-      - uses: extractions/setup-just@dd310ad5a97d8e7b41793f8ef055398d51ad4de6 # v2
+      - uses: extractions/setup-just@v2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@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@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@v4
        name: Download development ruff binary
        id: ruff-target
        with:
@@ -807,39 +711,6 @@ jobs:

          just test

-  check-playground:
-    name: "check playground"
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    needs:
-      - determine_changes
-    if: ${{ (needs.determine_changes.outputs.playground == 'true') }}
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        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
-        with:
-          node-version: 22
-          cache: "npm"
-          cache-dependency-path: playground/package-lock.json
-      - uses: jetli/wasm-bindgen-action@20b33e20595891ab1a0ed73145d8a21fc96e7c29 # v0.2.0
-      - name: "Install Node dependencies"
-        run: npm ci
-        working-directory: playground
-      - name: "Build playgrounds"
-        run: npm run dev:wasm
-        working-directory: playground
-      - name: "Run TypeScript checks"
-        run: npm run check
-        working-directory: playground
-      - name: "Check formatting"
-        run: npm run fmt:check
-        working-directory: playground
-
  benchmarks:
    runs-on: ubuntu-24.04
    needs: determine_changes
@@ -847,17 +718,17 @@ jobs:
    timeout-minutes: 20
    steps:
      - name: "Checkout Branch"
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@v4
        with:
          persist-credentials: false

-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@v2

      - name: "Install Rust toolchain"
        run: rustup show

      - name: "Install codspeed"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@v2
        with:
          tool: cargo-codspeed

@@ -865,7 +736,7 @@ jobs:
        run: cargo codspeed build --features codspeed -p ruff_benchmark

      - name: "Run benchmarks"
-        uses: CodSpeedHQ/action@0010eb0ca6e89b80c88e8edaaa07cfe5f3e6664d # v3.5.0
+        uses: CodSpeedHQ/action@v3
        with:
          run: cargo codspeed run
          token: ${{ secrets.CODSPEED_TOKEN }}
--- a/.github/workflows/daily_fuzz.yaml
+++ b/.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@v4
        with:
          persist-credentials: false
-      - uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
+      - uses: astral-sh/setup-uv@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@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@v7
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
--- a/.github/workflows/daily_property_tests.yaml
+++ b/.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@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@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@v7
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
--- a/.github/workflows/mypy_primer.yaml
+++ b/.github/workflows/mypy_primer.yaml
@@ -10,7 +10,6 @@ on:
      - "crates/ruff_python_ast"
      - "crates/ruff_python_parser"
      - ".github/workflows/mypy_primer.yaml"
-      - ".github/workflows/mypy_primer_comment.yaml"

 concurrency:
  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }}
@@ -25,28 +24,24 @@ 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@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@v5

-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@v2
        with:
          workspaces: "ruff"
      - name: Install Rust toolchain
        run: rustup show

-      - name: Install mypy_primer
-        run: |
-          uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support-v5"
-
      - name: Run mypy_primer
        shell: bash
        run: |
@@ -62,32 +57,13 @@ jobs:

          cd ..

-          # Allow the exit code to be 0 or 1, only fail for actual mypy_primer crashes/bugs
-          uvx mypy_primer \
+          echo "Running mypy_primer"
+
+          uvx --from "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support" mypy_primer \
            --repo ruff \
            --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)$' \
            --output concise \
-            --debug > mypy_primer.diff || [ $? -eq 1 ]
-
-          # Output diff with ANSI color codes
-          cat mypy_primer.diff
-
-          # Remove ANSI color codes before uploading
-          sed -ie 's/\x1b\[[0-9;]*m//g' mypy_primer.diff
-
-          echo ${{ github.event.number }} > pr-number
-
-      - name: Upload diff
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: mypy_primer_diff
-          path: mypy_primer.diff
-
-      - name: Upload pr-number
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: pr-number
-          path: pr-number
+            --debug
--- a/.github/workflows/mypy_primer_comment.yaml
+++ b/.github/workflows/mypy_primer_comment.yaml
@@ -1,97 +0,0 @@
-name: PR comment (mypy_primer)
-
-on: # zizmor: ignore[dangerous-triggers]
-  workflow_run:
-    workflows: [Run mypy_primer]
-    types: [completed]
-  workflow_dispatch:
-    inputs:
-      workflow_run_id:
-        description: The mypy_primer workflow that triggers the workflow run
-        required: true
-
-jobs:
-  comment:
-    runs-on: ubuntu-24.04
-    permissions:
-      pull-requests: write
-    steps:
-      - uses: dawidd6/action-download-artifact@20319c5641d495c8a52e688b7dc5fada6c3a9fbc # v8
-        name: Download PR number
-        with:
-          name: pr-number
-          run_id: ${{ github.event.workflow_run.id ||  github.event.inputs.workflow_run_id }}
-          if_no_artifact_found: ignore
-          allow_forks: true
-
-      - name: Parse pull request number
-        id: pr-number
-        run: |
-          if [[ -f pr-number ]]
-          then
-            echo "pr-number=$(<pr-number)" >> "$GITHUB_OUTPUT"
-          fi
-
-      - uses: dawidd6/action-download-artifact@20319c5641d495c8a52e688b7dc5fada6c3a9fbc # v8
-        name: "Download mypy_primer results"
-        id: download-mypy_primer_diff
-        if: steps.pr-number.outputs.pr-number
-        with:
-          name: mypy_primer_diff
-          workflow: mypy_primer.yaml
-          pr: ${{ steps.pr-number.outputs.pr-number }}
-          path: pr/mypy_primer_diff
-          workflow_conclusion: completed
-          if_no_artifact_found: ignore
-          allow_forks: true
-
-      - name: Generate comment content
-        id: generate-comment
-        if: steps.download-mypy_primer_diff.outputs.found_artifact == 'true'
-        run: |
-          # Guard against malicious mypy_primer results that symlink to a secret
-          # file on this runner
-          if [[ -L pr/mypy_primer_diff/mypy_primer.diff ]]
-          then
-              echo "Error: mypy_primer.diff cannot be a symlink"
-              exit 1
-          fi
-
-          # Note this identifier is used to find the comment to update on
-          # subsequent runs
-          echo '<!-- generated-comment mypy_primer -->' >> comment.txt
-
-          echo '## `mypy_primer` results' >> comment.txt
-          if [ -s "pr/mypy_primer_diff/mypy_primer.diff" ]; then
-            echo '<details>' >> comment.txt
-            echo '<summary>Changes were detected when running on open source projects</summary>' >> comment.txt
-            echo '' >> comment.txt
-            echo '```diff' >> comment.txt
-            cat pr/mypy_primer_diff/mypy_primer.diff >> comment.txt
-            echo '```' >> comment.txt
-            echo '</details>' >> comment.txt
-          else
-            echo 'No ecosystem changes detected ✅' >> comment.txt
-          fi
-
-          echo 'comment<<EOF' >> "$GITHUB_OUTPUT"
-          cat comment.txt >> "$GITHUB_OUTPUT"
-          echo 'EOF' >> "$GITHUB_OUTPUT"
-
-      - name: Find existing comment
-        uses: peter-evans/find-comment@3eae4d37986fb5a8592848f6a574fdf654e61f9e # v3
-        if: steps.generate-comment.outcome == 'success'
-        id: find-comment
-        with:
-          issue-number: ${{ steps.pr-number.outputs.pr-number }}
-          comment-author: "github-actions[bot]"
-          body-includes: "<!-- generated-comment mypy_primer -->"
-
-      - name: Create or update comment
-        if: steps.find-comment.outcome == 'success'
-        uses: peter-evans/create-or-update-comment@71345be0265236311c031f5c7866368bd1eff043 # v4
-        with:
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          issue-number: ${{ steps.pr-number.outputs.pr-number }}
-          body-path: comment.txt
-          edit-mode: replace
--- a/.github/workflows/notify-dependents.yml
+++ b/.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@v7
        with:
          github-token: ${{ secrets.RUFF_PRE_COMMIT_PAT }}
          script: |
--- a/.github/workflows/pr-comment.yaml
+++ b/.github/workflows/pr-comment.yaml
@@ -16,7 +16,7 @@ jobs:
    permissions:
      pull-requests: write
    steps:
-      - uses: dawidd6/action-download-artifact@20319c5641d495c8a52e688b7dc5fada6c3a9fbc # v8
+      - uses: dawidd6/action-download-artifact@v8
        name: Download pull request number
        with:
          name: pr-number
@@ -32,7 +32,7 @@ jobs:
            echo "pr-number=$(<pr-number)" >> "$GITHUB_OUTPUT"
          fi

-      - uses: dawidd6/action-download-artifact@20319c5641d495c8a52e688b7dc5fada6c3a9fbc # v8
+      - uses: dawidd6/action-download-artifact@v8
        name: "Download ecosystem results"
        id: download-ecosystem-result
        if: steps.pr-number.outputs.pr-number
@@ -70,7 +70,7 @@ jobs:
          echo 'EOF' >> "$GITHUB_OUTPUT"

      - name: Find existing comment
-        uses: peter-evans/find-comment@3eae4d37986fb5a8592848f6a574fdf654e61f9e # v3
+        uses: peter-evans/find-comment@v3
        if: steps.generate-comment.outcome == 'success'
        id: find-comment
        with:
@@ -80,7 +80,7 @@ jobs:

      - name: Create or update comment
        if: steps.find-comment.outcome == 'success'
-        uses: peter-evans/create-or-update-comment@71345be0265236311c031f5c7866368bd1eff043 # v4
+        uses: peter-evans/create-or-update-comment@v4
        with:
          comment-id: ${{ steps.find-comment.outputs.comment-id }}
          issue-number: ${{ steps.pr-number.outputs.pr-number }}
--- a/.github/workflows/publish-docs.yml
+++ b/.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@v4
        with:
          ref: ${{ inputs.ref }}
          persist-credentials: true

-      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
+      - uses: actions/setup-python@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@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@v2

      - name: "Install Insiders dependencies"
        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
--- a/.github/workflows/publish-knot-playground.yml
+++ b/.github/workflows/publish-knot-playground.yml
@@ -1,58 +0,0 @@
-# Publish the Red Knot playground.
-name: "[Knot Playground] Release"
-
-permissions: {}
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - "crates/red_knot*/**"
-      - "crates/ruff_db/**"
-      - "crates/ruff_python_ast/**"
-      - "crates/ruff_python_parser/**"
-      - "playground/**"
-      - ".github/workflows/publish-knot-playground.yml"
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    env:
-      CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          persist-credentials: false
-      - name: "Install Rust toolchain"
-        run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
-        with:
-          node-version: 22
-      - uses: jetli/wasm-bindgen-action@20b33e20595891ab1a0ed73145d8a21fc96e7c29 # v0.2.0
-      - name: "Install Node dependencies"
-        run: npm ci
-        working-directory: playground
-      - name: "Run TypeScript checks"
-        run: npm run check
-        working-directory: playground
-      - name: "Build Knot playground"
-        run: npm run build --workspace knot-playground
-        working-directory: playground
-      - name: "Deploy to Cloudflare Pages"
-        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@da0e0dfe58b7a431659754fdf3f186c529afbe65 # v3.14.1
-        with:
-          apiToken: ${{ secrets.CF_API_TOKEN }}
-          accountId: ${{ secrets.CF_ACCOUNT_ID }}
-          # `github.head_ref` is only set during pull requests and for manual runs or tags we use `main` to deploy to production
-          command: pages deploy playground/knot/dist --project-name=knot-playground --branch ${{ github.head_ref || 'main' }} --commit-hash ${GITHUB_SHA}
--- a/.github/workflows/publish-playground.yml
+++ b/.github/workflows/publish-playground.yml
@@ -24,31 +24,36 @@ jobs:
    env:
      CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@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@v4
        with:
-          node-version: 22
+          node-version: 20
          cache: "npm"
          cache-dependency-path: playground/package-lock.json
-      - uses: jetli/wasm-bindgen-action@20b33e20595891ab1a0ed73145d8a21fc96e7c29 # v0.2.0
+      - uses: jetli/wasm-pack-action@v0.4.0
+        with:
+          version: v0.13.1
+      - uses: jetli/wasm-bindgen-action@v0.2.0
+      - name: "Run wasm-pack"
+        run: wasm-pack build --target web --out-dir ../../playground/src/pkg crates/ruff_wasm
      - name: "Install Node dependencies"
        run: npm ci
        working-directory: playground
      - name: "Run TypeScript checks"
        run: npm run check
        working-directory: playground
-      - name: "Build Ruff playground"
-        run: npm run build --workspace ruff-playground
+      - name: "Build JavaScript bundle"
+        run: npm run build
        working-directory: playground
      - name: "Deploy to Cloudflare Pages"
        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@da0e0dfe58b7a431659754fdf3f186c529afbe65 # v3.14.1
+        uses: cloudflare/wrangler-action@v3.14.0
        with:
          apiToken: ${{ secrets.CF_API_TOKEN }}
          accountId: ${{ secrets.CF_ACCOUNT_ID }}
          # `github.head_ref` is only set during pull requests and for manual runs or tags we use `main` to deploy to production
-          command: pages deploy playground/ruff/dist --project-name=ruff-playground --branch ${{ github.head_ref || 'main' }} --commit-hash ${GITHUB_SHA}
+          command: pages deploy playground/dist --project-name=ruff-playground --branch ${{ github.head_ref || 'main' }} --commit-hash ${GITHUB_SHA}
--- a/.github/workflows/publish-pypi.yml
+++ b/.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@v5
+      - uses: actions/download-artifact@v4
        with:
          pattern: wheels-*
          path: wheels
--- a/.github/workflows/publish-wasm.yml
+++ b/.github/workflows/publish-wasm.yml
@@ -29,15 +29,15 @@ jobs:
        target: [web, bundler, nodejs]
      fail-fast: false
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@v4
        with:
          persist-credentials: false
      - name: "Install Rust toolchain"
        run: rustup target add wasm32-unknown-unknown
-      - uses: jetli/wasm-pack-action@0d096b08b4e5a7de8c28de67e11e945404e9eefa # v0.4.0
+      - uses: jetli/wasm-pack-action@v0.4.0
        with:
          version: v0.13.1
-      - uses: jetli/wasm-bindgen-action@20b33e20595891ab1a0ed73145d8a21fc96e7c29 # v0.2.0
+      - uses: jetli/wasm-bindgen-action@v0.2.0
      - name: "Run wasm-pack build"
        run: wasm-pack build --target ${{ matrix.target }} crates/ruff_wasm
      - name: "Rename generated package"
@@ -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@v4
        with:
          node-version: 20
          registry-url: "https://registry.npmjs.org"
--- a/.github/workflows/release.yml
+++ b/.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:
@@ -51,7 +50,7 @@ on:
 jobs:
  # Run 'dist plan' (or host) to determine what tasks we need to do
  plan:
-    runs-on: "depot-ubuntu-latest-4"
+    runs-on: "ubuntu-20.04"
    outputs:
      val: ${{ steps.plan.outputs.manifest }}
      tag: ${{ (inputs.tag != 'dry-run' && inputs.tag) || '' }}
@@ -60,17 +59,16 @@ jobs:
    env:
      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@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@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@v4
        with:
          name: artifacts-plan-dist-manifest
          path: plan-dist-manifest.json
@@ -118,24 +116,23 @@ jobs:
      - plan
      - custom-build-binaries
      - custom-build-docker
-    runs-on: "depot-ubuntu-latest-4"
+    runs-on: "ubuntu-20.04"
    env:
      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@v4
        with:
-          persist-credentials: false
          submodules: recursive
      - name: Install cached dist
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@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@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@v4
        with:
          name: artifacts-build-global
          path: |
@@ -170,23 +167,22 @@ jobs:
    if: ${{ always() && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.custom-build-binaries.result == 'skipped' || needs.custom-build-binaries.result == 'success') && (needs.custom-build-docker.result == 'skipped' || needs.custom-build-docker.result == 'success') }}
    env:
      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    runs-on: "depot-ubuntu-latest-4"
+    runs-on: "ubuntu-20.04"
    outputs:
      val: ${{ steps.host.outputs.manifest }}
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@v4
        with:
-          persist-credentials: false
          submodules: recursive
      - name: Install cached dist
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@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@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@v4
        with:
          # Overwrite the previous copy
          name: artifacts-dist-manifest
@@ -246,17 +242,16 @@ jobs:
    # still allowing individual publish jobs to skip themselves (for prereleases).
    # "host" however must run to completion, no skipping allowed!
    if: ${{ always() && needs.host.result == 'success' && (needs.custom-publish-pypi.result == 'skipped' || needs.custom-publish-pypi.result == 'success') && (needs.custom-publish-wasm.result == 'skipped' || needs.custom-publish-wasm.result == 'success') }}
-    runs-on: "depot-ubuntu-latest-4"
+    runs-on: "ubuntu-20.04"
    env:
      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@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@v4
        with:
          pattern: artifacts-*
          path: artifacts
--- a/.github/workflows/sync_typeshed.yaml
+++ b/.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@v4
        name: Checkout Ruff
        with:
          path: ruff
          persist-credentials: true
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@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@v7
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
--- a/.ignore
+++ b/.ignore
@@ -1 +0,0 @@
-!/.github/
--- a/.pre-commit-config.yaml
+++ b/.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.23
    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.0
    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.5
+    rev: v0.9.9
    hooks:
      - id: ruff-format
      - id: ruff
@@ -89,7 +84,7 @@ repos:

  # Prettier
  - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.5.3
+    rev: v3.5.2
    hooks:
      - id: prettier
        types: [yaml]
@@ -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.4.1
    hooks:
      - id: zizmor

  - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.33.0
+    rev: 0.31.2
    hooks:
      - id: check-github-workflows

--- a/BREAKING_CHANGES.md
+++ b/BREAKING_CHANGES.md
@@ -1,55 +1,5 @@
 # Breaking Changes

-## 0.11.0
-
-This is a follow-up to release 0.10.0. Because of a mistake in the release process, the `requires-python` inference changes were not included in that release. Ruff 0.11.0 now includes this change as well as the stabilization of the preview behavior for `PGH004`.
-
- **Changes to how the Python version is inferred when a `target-version` is not specified** ([#16319](https://github.com/astral-sh/ruff/pull/16319))
-
-    In previous versions of Ruff, you could specify your Python version with:
-
-    - The `target-version` option in a `ruff.toml` file or the `[tool.ruff]` section of a pyproject.toml file.
-    - The `project.requires-python` field in a `pyproject.toml` file with a `[tool.ruff]` section.
-
-    These options worked well in most cases, and are still recommended for fine control of the Python version. However, because of the way Ruff discovers config files, `pyproject.toml` files without a `[tool.ruff]` section would be ignored, including the `requires-python` setting. Ruff would then use the default Python version (3.9 as of this writing) instead, which is surprising when you've attempted to request another version.
-
-    In v0.10, config discovery has been updated to address this issue:
-
-    - If Ruff finds a `ruff.toml` file without a `target-version`, it will check
-        for a `pyproject.toml` file in the same directory and respect its
-        `requires-python` version, even if it does not contain a `[tool.ruff]`
-        section.
-    - If Ruff finds a user-level configuration, the `requires-python` field of the closest `pyproject.toml` in a parent directory will take precedence.
-    - If there is no config file (`ruff.toml`or `pyproject.toml` with a
-        `[tool.ruff]` section) in the directory of the file being checked, Ruff will
-        search for the closest `pyproject.toml` in the parent directories and use its
-        `requires-python` setting.
-
-## 0.10.0
-
- **Changes to how the Python version is inferred when a `target-version` is not specified** ([#16319](https://github.com/astral-sh/ruff/pull/16319))
-
-    Because of a mistake in the release process, the `requires-python` inference changes are not included in this release and instead shipped as part of 0.11.0.
-    You can find a description of this change in the 0.11.0 section.
-
- **Updated `TYPE_CHECKING` behavior** ([#16669](https://github.com/astral-sh/ruff/pull/16669))
-
-    Previously, Ruff only recognized typechecking blocks that tested the `typing.TYPE_CHECKING` symbol. Now, Ruff recognizes any local variable named `TYPE_CHECKING`. This release also removes support for the legacy `if 0:` and `if False:` typechecking checks. Use a local `TYPE_CHECKING` variable instead.
-
- **More robust noqa parsing** ([#16483](https://github.com/astral-sh/ruff/pull/16483))
-
-    The syntax for both file-level and in-line suppression comments has been unified and made more robust to certain errors. In most cases, this will result in more suppression comments being read by Ruff, but there are a few instances where previously read comments will now log an error to the user instead. Please refer to the documentation on [_Error suppression_](https://docs.astral.sh/ruff/linter/#error-suppression) for the full specification.
-
- **Avoid unnecessary parentheses around with statements with a single context manager and a trailing comment** ([#14005](https://github.com/astral-sh/ruff/pull/14005))
-
-    This change fixes a bug in the formatter where it introduced unnecessary parentheses around with statements with a single context manager and a trailing comment. This change may result in a change in formatting for some users.
-
- **Bump alpine default tag to 3.21 for derived Docker images** ([#16456](https://github.com/astral-sh/ruff/pull/16456))
-
-    Alpine 3.21 was released in Dec 2024 and is used in the official Alpine-based Python images. Now the ruff:alpine image will use 3.21 instead of 3.20 and ruff:alpine3.20 will no longer be updated.
-
- **\[`unsafe-markup-use`\]: `RUF035` has been recoded to `S704`** ([#15957](https://github.com/astral-sh/ruff/pull/15957))
-
 ## 0.9.0

 Ruff now formats your code according to the 2025 style guide. As a result, your code might now get formatted differently. See the [changelog](./CHANGELOG.md#090) for a detailed list of changes.
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,254 +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
-
- [syntax-errors] Fix false-positive syntax errors emitted for annotations on variadic parameters before Python 3.11 ([#16878](https://github.com/astral-sh/ruff/pull/16878))
-
-## 0.11.1
-
-### Preview features
-
- \[`airflow`\] Add `chain`, `chain_linear` and `cross_downstream` for `AIR302` ([#16647](https://github.com/astral-sh/ruff/pull/16647))
- [syntax-errors] Improve error message and range for pre-PEP-614 decorator syntax errors ([#16581](https://github.com/astral-sh/ruff/pull/16581))
- [syntax-errors] PEP 701 f-strings before Python 3.12 ([#16543](https://github.com/astral-sh/ruff/pull/16543))
- [syntax-errors] Parenthesized context managers before Python 3.9 ([#16523](https://github.com/astral-sh/ruff/pull/16523))
- [syntax-errors] Star annotations before Python 3.11 ([#16545](https://github.com/astral-sh/ruff/pull/16545))
- [syntax-errors] Star expression in index before Python 3.11 ([#16544](https://github.com/astral-sh/ruff/pull/16544))
- [syntax-errors] Unparenthesized assignment expressions in sets and indexes ([#16404](https://github.com/astral-sh/ruff/pull/16404))
-
-### Bug fixes
-
- Server: Allow `FixAll` action in presence of version-specific syntax errors ([#16848](https://github.com/astral-sh/ruff/pull/16848))
- \[`flake8-bandit`\] Allow raw strings in `suspicious-mark-safe-usage` (`S308`) #16702 ([#16770](https://github.com/astral-sh/ruff/pull/16770))
- \[`refurb`\] Avoid panicking `unwrap` in `verbose-decimal-constructor` (`FURB157`) ([#16777](https://github.com/astral-sh/ruff/pull/16777))
- \[`refurb`\] Fix starred expressions fix (`FURB161`) ([#16550](https://github.com/astral-sh/ruff/pull/16550))
- Fix `--statistics` reporting for unsafe fixes ([#16756](https://github.com/astral-sh/ruff/pull/16756))
-
-### Rule changes
-
- \[`flake8-executables`\] Allow `uv run` in shebang line for `shebang-missing-python` (`EXE003`) ([#16849](https://github.com/astral-sh/ruff/pull/16849),[#16855](https://github.com/astral-sh/ruff/pull/16855))
-
-### CLI
-
- Add `--exit-non-zero-on-format` ([#16009](https://github.com/astral-sh/ruff/pull/16009))
-
-### Documentation
-
- Update Ruff tutorial to avoid non-existent fix in `__init__.py` ([#16818](https://github.com/astral-sh/ruff/pull/16818))
- \[`flake8-gettext`\] Swap `format-` and `printf-in-get-text-func-call` examples (`INT002`, `INT003`) ([#16769](https://github.com/astral-sh/ruff/pull/16769))
-
-## 0.11.0
-
-This is a follow-up to release 0.10.0. Because of a mistake in the release process, the `requires-python` inference changes were not included in that release. Ruff 0.11.0 now includes this change as well as the stabilization of the preview behavior for `PGH004`.
-
-### Breaking changes
-
- **Changes to how the Python version is inferred when a `target-version` is not specified** ([#16319](https://github.com/astral-sh/ruff/pull/16319))
-
-    In previous versions of Ruff, you could specify your Python version with:
-
-    - The `target-version` option in a `ruff.toml` file or the `[tool.ruff]` section of a pyproject.toml file.
-    - The `project.requires-python` field in a `pyproject.toml` file with a `[tool.ruff]` section.
-
-    These options worked well in most cases, and are still recommended for fine control of the Python version. However, because of the way Ruff discovers config files, `pyproject.toml` files without a `[tool.ruff]` section would be ignored, including the `requires-python` setting. Ruff would then use the default Python version (3.9 as of this writing) instead, which is surprising when you've attempted to request another version.
-
-    In v0.10, config discovery has been updated to address this issue:
-
-    - If Ruff finds a `ruff.toml` file without a `target-version`, it will check
-        for a `pyproject.toml` file in the same directory and respect its
-        `requires-python` version, even if it does not contain a `[tool.ruff]`
-        section.
-    - If Ruff finds a user-level configuration, the `requires-python` field of the closest `pyproject.toml` in a parent directory will take precedence.
-    - If there is no config file (`ruff.toml`or `pyproject.toml` with a
-        `[tool.ruff]` section) in the directory of the file being checked, Ruff will
-        search for the closest `pyproject.toml` in the parent directories and use its
-        `requires-python` setting.
-
-### Stabilization
-
-The following behaviors have been stabilized:
-
- [`blanket-noqa`](https://docs.astral.sh/ruff/rules/blanket-noqa/) (`PGH004`): Also detect blanked file-level noqa comments (and not just line level comments).
-
-### Preview features
-
- [syntax-errors] Tuple unpacking in `for` statement iterator clause before Python 3.9 ([#16558](https://github.com/astral-sh/ruff/pull/16558))
-
-## 0.10.0
-
-Check out the [blog post](https://astral.sh/blog/ruff-v0.10.0) for a migration guide and overview of the changes!
-
-### Breaking changes
-
-See also, the "Remapped rules" section which may result in disabled rules.
-
- **Changes to how the Python version is inferred when a `target-version` is not specified** ([#16319](https://github.com/astral-sh/ruff/pull/16319))
-
-    Because of a mistake in the release process, the `requires-python` inference changes are not included in this release and instead shipped as part of 0.11.0.
-    You can find a description of this change in the 0.11.0 section.
-
- **Updated `TYPE_CHECKING` behavior** ([#16669](https://github.com/astral-sh/ruff/pull/16669))
-
-    Previously, Ruff only recognized typechecking blocks that tested the `typing.TYPE_CHECKING` symbol. Now, Ruff recognizes any local variable named `TYPE_CHECKING`. This release also removes support for the legacy `if 0:` and `if False:` typechecking checks. Use a local `TYPE_CHECKING` variable instead.
-
- **More robust noqa parsing** ([#16483](https://github.com/astral-sh/ruff/pull/16483))
-
-    The syntax for both file-level and in-line suppression comments has been unified and made more robust to certain errors. In most cases, this will result in more suppression comments being read by Ruff, but there are a few instances where previously read comments will now log an error to the user instead. Please refer to the documentation on [*Error suppression*](https://docs.astral.sh/ruff/linter/#error-suppression) for the full specification.
-
- **Avoid unnecessary parentheses around with statements with a single context manager and a trailing comment** ([#14005](https://github.com/astral-sh/ruff/pull/14005))
-
-    This change fixes a bug in the formatter where it introduced unnecessary parentheses around with statements with a single context manager and a trailing comment. This change may result in a change in formatting for some users.
-
- **Bump alpine default tag to 3.21 for derived Docker images** ([#16456](https://github.com/astral-sh/ruff/pull/16456))
-
-    Alpine 3.21 was released in Dec 2024 and is used in the official Alpine-based Python images. Now the ruff:alpine image will use 3.21 instead of 3.20 and ruff:alpine3.20 will no longer be updated.
-
-### Deprecated Rules
-
-The following rules have been deprecated:
-
- [`non-pep604-isinstance`](https://docs.astral.sh/ruff/rules/non-pep604-isinstance/) (`UP038`)
- [`suspicious-xmle-tree-usage`](https://docs.astral.sh/ruff/rules/suspicious-xmle-tree-usage/) (`S320`)
-
-### Remapped rules
-
-The following rules have been remapped to new rule codes:
-
- \[`unsafe-markup-use`\]: `RUF035` to `S704`
-
-### Stabilization
-
-The following rules have been stabilized and are no longer in preview:
-
- [`batched-without-explicit-strict`](https://docs.astral.sh/ruff/rules/batched-without-explicit-strict) (`B911`)
- [`unnecessary-dict-comprehension-for-iterable`](https://docs.astral.sh/ruff/rules/unnecessary-dict-comprehension-for-iterable) (`C420`)
- [`datetime-min-max`](https://docs.astral.sh/ruff/rules/datetime-min-max) (`DTZ901`)
- [`fast-api-unused-path-parameter`](https://docs.astral.sh/ruff/rules/fast-api-unused-path-parameter) (`FAST003`)
- [`root-logger-call`](https://docs.astral.sh/ruff/rules/root-logger-call) (`LOG015`)
- [`len-test`](https://docs.astral.sh/ruff/rules/len-test) (`PLC1802`)
- [`shallow-copy-environ`](https://docs.astral.sh/ruff/rules/shallow-copy-environ) (`PLW1507`)
- [`os-listdir`](https://docs.astral.sh/ruff/rules/os-listdir) (`PTH208`)
- [`invalid-pathlib-with-suffix`](https://docs.astral.sh/ruff/rules/invalid-pathlib-with-suffix) (`PTH210`)
- [`invalid-assert-message-literal-argument`](https://docs.astral.sh/ruff/rules/invalid-assert-message-literal-argument) (`RUF040`)
- [`unnecessary-nested-literal`](https://docs.astral.sh/ruff/rules/unnecessary-nested-literal) (`RUF041`)
- [`unnecessary-cast-to-int`](https://docs.astral.sh/ruff/rules/unnecessary-cast-to-int) (`RUF046`)
- [`map-int-version-parsing`](https://docs.astral.sh/ruff/rules/map-int-version-parsing) (`RUF048`)
- [`if-key-in-dict-del`](https://docs.astral.sh/ruff/rules/if-key-in-dict-del) (`RUF051`)
- [`unsafe-markup-use`](https://docs.astral.sh/ruff/rules/unsafe-markup-use) (`S704`). This rule has also been renamed from `RUF035`.
- [`split-static-string`](https://docs.astral.sh/ruff/rules/split-static-string) (`SIM905`)
- [`runtime-cast-value`](https://docs.astral.sh/ruff/rules/runtime-cast-value) (`TC006`)
- [`unquoted-type-alias`](https://docs.astral.sh/ruff/rules/unquoted-type-alias) (`TC007`)
- [`non-pep646-unpack`](https://docs.astral.sh/ruff/rules/non-pep646-unpack) (`UP044`)
-
-The following behaviors have been stabilized:
-
- [`bad-staticmethod-argument`](https://docs.astral.sh/ruff/rules/bad-staticmethod-argument/) (`PLW0211`) [`invalid-first-argument-name-for-class-method`](https://docs.astral.sh/ruff/rules/invalid-first-argument-name-for-class-method/) (`N804`): `__new__` methods are now no longer flagged by `invalid-first-argument-name-for-class-method` (`N804`) but instead by `bad-staticmethod-argument` (`PLW0211`)
- [`bad-str-strip-call`](https://docs.astral.sh/ruff/rules/bad-str-strip-call/) (`PLE1310`): The rule now applies to objects which are known to have type `str` or `bytes`.
- [`custom-type-var-for-self`](https://docs.astral.sh/ruff/rules/custom-type-var-for-self/) (`PYI019`): More accurate detection of custom `TypeVars` replaceable by `Self`. The range of the diagnostic is now the full function header rather than just the return annotation.
- [`invalid-argument-name`](https://docs.astral.sh/ruff/rules/invalid-argument-name/) (`N803`): Ignore argument names of functions decorated with `typing.override`
- [`invalid-envvar-default`](https://docs.astral.sh/ruff/rules/invalid-envvar-default/) (`PLW1508`): Detect default value arguments to `os.environ.get` with invalid type.
- [`pytest-raises-with-multiple-statements`](https://docs.astral.sh/ruff/rules/pytest-raises-with-multiple-statements/) (`PT012`) [`pytest-warns-with-multiple-statements`](https://docs.astral.sh/ruff/rules/pytest-warns-with-multiple-statements/) (`PT031`): Allow `for` statements with an empty body in `pytest.raises` and `pytest.warns` `with` statements.
- [`redundant-open-modes`](https://docs.astral.sh/ruff/rules/redundant-open-modes/) (`UP015`): The diagnostic range is now the range of the redundant mode argument where it previously was the range of the entire open call. You may have to replace your `noqa` comments when suppressing `UP015`.
- [`stdlib-module-shadowing`](https://docs.astral.sh/ruff/rules/stdlib-module-shadowing/) (`A005`): Changes the default value of `lint.flake8-builtins.strict-checking` from `true` to `false`.
- [`type-none-comparison`](https://docs.astral.sh/ruff/rules/type-none-comparison/) (`FURB169`): Now also recognizes `type(expr) is type(None)` comparisons where `expr` isn't a name expression.
-
-The following fixes or improvements to fixes have been stabilized:
-
- [`repeated-equality-comparison`](https://docs.astral.sh/ruff/rules/repeated-equality-comparison/) (`PLR1714`) ([#16685](https://github.com/astral-sh/ruff/pull/16685))
- [`needless-bool`](https://docs.astral.sh/ruff/rules/needless-bool/) (`SIM103`) ([#16684](https://github.com/astral-sh/ruff/pull/16684))
- [`unused-private-type-var`](https://docs.astral.sh/ruff/rules/unused-private-type-var/) (`PYI018`) ([#16682](https://github.com/astral-sh/ruff/pull/16682))
-
-### Server
-
- Remove logging output for `ruff.printDebugInformation` ([#16617](https://github.com/astral-sh/ruff/pull/16617))
-
-### Configuration
-
- \[`flake8-builtins`\] Deprecate the `builtins-` prefixed options in favor of the unprefixed options (e.g. `builtins-allowed-modules` is now deprecated in favor of `allowed-modules`) ([#16092](https://github.com/astral-sh/ruff/pull/16092))
-
-### Bug fixes
-
- [flake8-bandit] Fix mixed-case hash algorithm names (S324) ([#16552](https://github.com/astral-sh/ruff/pull/16552))
-
-### CLI
-
- [ruff] Fix `last_tag`/`commits_since_last_tag` for `version` command ([#16686](https://github.com/astral-sh/ruff/pull/16686))
-
 ## 0.9.10

 ### Preview features
@@ -1494,11 +1245,11 @@ The following rules have been stabilized and are no longer in preview:

 The following behaviors have been stabilized:

- [`cancel-scope-no-checkpoint`](https://docs.astral.sh/ruff/rules/cancel-scope-no-checkpoint/) (`ASYNC100`): Support `asyncio` and `anyio` context managers.
- [`async-function-with-timeout`](https://docs.astral.sh/ruff/rules/async-function-with-timeout/) (`ASYNC109`): Support `asyncio` and `anyio` context managers.
- [`async-busy-wait`](https://docs.astral.sh/ruff/rules/async-busy-wait/) (`ASYNC110`): Support `asyncio` and `anyio` context managers.
- [`async-zero-sleep`](https://docs.astral.sh/ruff/rules/async-zero-sleep/) (`ASYNC115`): Support `anyio` context managers.
- [`long-sleep-not-forever`](https://docs.astral.sh/ruff/rules/long-sleep-not-forever/) (`ASYNC116`): Support `anyio` context managers.
+- [`cancel-scope-no-checkpoint`](https://docs.astral.sh/ruff/rules/cancel-scope-no-checkpoint/) (`ASYNC100`): Support `asyncio` and `anyio` context mangers.
+- [`async-function-with-timeout`](https://docs.astral.sh/ruff/rules/async-function-with-timeout/) (`ASYNC109`): Support `asyncio` and `anyio` context mangers.
+- [`async-busy-wait`](https://docs.astral.sh/ruff/rules/async-busy-wait/) (`ASYNC110`): Support `asyncio` and `anyio` context mangers.
+- [`async-zero-sleep`](https://docs.astral.sh/ruff/rules/async-zero-sleep/) (`ASYNC115`): Support `anyio` context mangers.
+- [`long-sleep-not-forever`](https://docs.astral.sh/ruff/rules/long-sleep-not-forever/) (`ASYNC116`): Support `anyio` context mangers.

 The following fixes have been stabilized:

--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/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" }
@@ -64,7 +63,7 @@ colored = { version = "3.0.0" }
 console_error_panic_hook = { version = "0.1.7" }
 console_log = { version = "1.0.0" }
 countme = { version = "3.0.1" }
-compact_str = "0.9.0"
+compact_str = "0.8.0"
 criterion = { version = "0.5.1", default-features = false }
 crossbeam = { version = "0.8.4" }
 dashmap = { version = "6.0.1" }
@@ -72,7 +71,7 @@ dir-test = { version = "0.4.0" }
 dunce = { version = "1.0.5" }
 drop_bomb = { version = "0.1.5" }
 env_logger = { version = "0.11.0" }
-etcetera = { version = "0.10.0" }
+etcetera = { version = "0.8.0" }
 fern = { version = "0.7.0" }
 filetime = { version = "0.2.23" }
 getrandom = { version = "0.3.1" }
@@ -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 = "99be5d9917c3dd88e19735a82ef6bf39ba84bd7e" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -155,7 +154,6 @@ toml = { version = "0.8.11" }
 tracing = { version = "0.1.40" }
 tracing-flame = { version = "0.2.0" }
 tracing-indicatif = { version = "0.3.6" }
-tracing-log = { version = "0.2.0" }
 tracing-subscriber = { version = "0.3.18", default-features = false, features = [
    "env-filter",
    "fmt",
@@ -209,7 +207,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 +269,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 +326,3 @@ 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"]
-
-[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
--- a/README.md
+++ b/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.9.10/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.9.10/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.9.10
  hooks:
    # Run the linter.
    - id: ruff
--- a/crates/red_knot/docs/mypy_primer.md
+++ b/crates/red_knot/docs/mypy_primer.md
@@ -1,61 +0,0 @@
-# Running `mypy_primer`
-
-## Basics
-
-For now, we use our own [fork of mypy primer]. It can be run using `uvx --from "…" mypy_primer`. For example, to see the help message, run:
-
-```sh
-uvx --from "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support" mypy_primer -h
-```
-
-Alternatively, you can install the forked version of `mypy_primer` using:
-
-```sh
-uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support"
-```
-
-and then run it using `uvx mypy_primer` or just `mypy_primer`, if your `PATH` is set up accordingly (see: [Tool executables]).
-
-## Showing the diagnostics diff between two Git revisions
-
-To show the diagnostics diff between two Git revisions (e.g. your feature branch and `main`), run:
-
-```sh
-mypy_primer \
-    --type-checker knot \
-    --old origin/main \
-    --new my/feature \
-    --debug \
-    --output concise \
-    --project-selector '/black$'
-```
-
-This will show the diagnostics diff for the `black` project between the `main` branch and your `my/feature` branch. To run the
-diff for all projects, you currently need to copy the project-selector regex from the CI pipeline in `.github/workflows/mypy_primer.yaml`.
-
-You can also take a look at the [full list of ecosystem projects]. Note that some of them might still need a `knot_paths` configuration
-option to work correctly.
-
-## Avoiding recompilation
-
-If you want to run `mypy_primer` repeatedly, e.g. for different projects, but for the same combination of `--old` and `--new`, you
-can use set the `MYPY_PRIMER_NO_REBUILD` environment variable to avoid recompilation of Red Knot:
-
-```sh
-MYPY_PRIMER_NO_REBUILD=1 mypy_primer …
-```
-
-## Running from a local copy of the repository
-
-If you are working on a local branch, you can use `mypy_primer`'s `--repo` option to specify the path to your local copy of the `ruff` repository.
-This allows `mypy_primer` to check out local branches:
-
-```sh
-mypy_primer --repo /path/to/ruff --old origin/main --new my/local-branch …
-```
-
-Note that you might need to clean up `/tmp/mypy_primer` in order for this to work correctly.
-
-[fork of mypy primer]: https://github.com/astral-sh/mypy_primer/tree/add-red-knot-support
-[full list of ecosystem projects]: https://github.com/astral-sh/mypy_primer/blob/add-red-knot-support/mypy_primer/projects.py
-[tool executables]: https://docs.astral.sh/uv/concepts/tools/#tool-executables
--- a/crates/red_knot/src/args.rs
+++ b/crates/red_knot/src/args.rs
@@ -50,8 +50,6 @@ pub(crate) struct CheckCommand {

    /// Path to the Python installation from which Red Knot resolves type information and third-party dependencies.
    ///
-    /// If not specified, Red Knot will look at the `VIRTUAL_ENV` environment variable.
-    ///
    /// Red Knot will search in the path's `site-packages` directories for type information and
    /// third-party imports.
    ///
@@ -71,29 +69,12 @@ 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,

    #[clap(flatten)]
    pub(crate) rules: RulesArg,

-    /// The format to use for printing diagnostic messages.
-    #[arg(long)]
-    pub(crate) output_format: Option<OutputFormat>,
-
-    /// Control when colored output is used.
-    #[arg(long, value_name = "WHEN")]
-    pub(crate) color: Option<TerminalColor>,
-
    /// Use exit code 1 if there are any warning-level diagnostics.
    #[arg(long, conflicts_with = "exit_zero", default_missing_value = "true", num_args=0..1)]
    pub(crate) error_on_warning: Option<bool>,
@@ -125,9 +106,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,11 +114,9 @@ impl CheckCommand {
                        .map(RelativePathBuf::cli)
                        .collect()
                }),
+                ..EnvironmentOptions::default()
            }),
            terminal: Some(TerminalOptions {
-                output_format: self
-                    .output_format
-                    .map(|output_format| RangedValue::cli(output_format.into())),
                error_on_warning: self.error_on_warning,
            }),
            rules,
@@ -235,46 +211,3 @@ impl clap::Args for RulesArg {
        Self::augment_args(cmd)
    }
 }
-
-/// The diagnostic output format.
-#[derive(Copy, Clone, Hash, Debug, PartialEq, Eq, PartialOrd, Ord, Default, clap::ValueEnum)]
-pub enum OutputFormat {
-    /// Print diagnostics verbosely, with context and helpful hints.
-    ///
-    /// Diagnostic messages may include additional context and
-    /// annotations on the input to help understand the message.
-    #[default]
-    #[value(name = "full")]
-    Full,
-    /// Print diagnostics concisely, one per line.
-    ///
-    /// This will guarantee that each diagnostic is printed on
-    /// a single line. Only the most important or primary aspects
-    /// of the diagnostic are included. Contextual information is
-    /// dropped.
-    #[value(name = "concise")]
-    Concise,
-}
-
-impl From<OutputFormat> for ruff_db::diagnostic::DiagnosticFormat {
-    fn from(format: OutputFormat) -> ruff_db::diagnostic::DiagnosticFormat {
-        match format {
-            OutputFormat::Full => Self::Full,
-            OutputFormat::Concise => Self::Concise,
-        }
-    }
-}
-
-/// Control when colored output is used.
-#[derive(Copy, Clone, Hash, Debug, PartialEq, Eq, PartialOrd, Ord, Default, clap::ValueEnum)]
-pub(crate) enum TerminalColor {
-    /// Display colors if the output goes to an interactive terminal.
-    #[default]
-    Auto,
-
-    /// Always display colors.
-    Always,
-
-    /// Never display colors.
-    Never,
-}
--- a/crates/red_knot/src/main.rs
+++ b/crates/red_knot/src/main.rs
@@ -4,7 +4,7 @@ use std::process::{ExitCode, Termination};
 use anyhow::Result;
 use std::sync::Mutex;

-use crate::args::{Args, CheckCommand, Command, TerminalColor};
+use crate::args::{Args, CheckCommand, Command};
 use crate::logging::setup_tracing;
 use anyhow::{anyhow, Context};
 use clap::Parser;
@@ -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;

@@ -76,14 +76,10 @@ pub(crate) fn version() -> Result<()> {
 }

 fn run_check(args: CheckCommand) -> anyhow::Result<ExitStatus> {
-    set_colored_override(args.color);
-
    let verbosity = args.verbosity.level();
    countme::enable(verbosity.is_trace());
    let _guard = setup_tracing(verbosity)?;

-    tracing::debug!("Version: {}", version::version());
-
    // The base path to which all CLI arguments are relative to.
    let cwd = {
        let cwd = std::env::current_dir().context("Failed to get the current working directory")?;
@@ -259,16 +255,15 @@ impl MainLoop {
                    result,
                    revision: check_revision,
                } => {
-                    let terminal_settings = db.project().settings(db).terminal();
                    let display_config = DisplayDiagnosticConfig::default()
-                        .format(terminal_settings.output_format)
                        .color(colored::control::SHOULD_COLORIZE.should_colorize());

-                    let min_error_severity = if terminal_settings.error_on_warning {
-                        Severity::Warning
-                    } else {
-                        Severity::Error
-                    };
+                    let min_error_severity =
+                        if db.project().settings(db).terminal().error_on_warning {
+                            Severity::Warning
+                        } else {
+                            Severity::Error
+                        };

                    if check_revision == revision {
                        if db.project().files(db).is_empty() {
@@ -288,7 +283,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,27 +354,9 @@ 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>),
    Exit,
 }
-
-fn set_colored_override(color: Option<TerminalColor>) {
-    let Some(color) = color else {
-        return;
-    };
-
-    match color {
-        TerminalColor::Auto => {
-            colored::control::unset_override();
-        }
-        TerminalColor::Always => {
-            colored::control::set_override(true);
-        }
-        TerminalColor::Never => {
-            colored::control::set_override(false);
-        }
-    }
-}
--- a/crates/red_knot/src/python_version.rs
+++ b/crates/red_knot/src/python_version.rs
@@ -3,6 +3,10 @@
 /// TODO: unify with the `PythonVersion` enum in the linter/formatter crates?
 #[derive(Copy, Clone, Hash, Debug, PartialEq, Eq, PartialOrd, Ord, Default, clap::ValueEnum)]
 pub enum PythonVersion {
+    #[value(name = "3.7")]
+    Py37,
+    #[value(name = "3.8")]
+    Py38,
    #[default]
    #[value(name = "3.9")]
    Py39,
@@ -19,6 +23,8 @@ pub enum PythonVersion {
 impl PythonVersion {
    const fn as_str(self) -> &'static str {
        match self {
+            Self::Py37 => "3.7",
+            Self::Py38 => "3.8",
            Self::Py39 => "3.9",
            Self::Py310 => "3.10",
            Self::Py311 => "3.11",
@@ -37,6 +43,8 @@ impl std::fmt::Display for PythonVersion {
 impl From<PythonVersion> for ruff_python_ast::PythonVersion {
    fn from(value: PythonVersion) -> Self {
        match value {
+            PythonVersion::Py37 => Self::PY37,
+            PythonVersion::Py38 => Self::PY38,
            PythonVersion::Py39 => Self::PY39,
            PythonVersion::Py310 => Self::PY310,
            PythonVersion::Py311 => Self::PY311,
--- a/crates/red_knot/tests/cli.rs
+++ b/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: Revealed type
-     --> <temp_dir>/test.py:5:1
-      |
-    3 | from typing_extensions import reveal_type
-    4 |
-    5 | reveal_type(sys.platform)
-      | ^^^^^^^^^^^^^^^^^^^^^^^^^ `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: Revealed type
-     --> <temp_dir>/test.py:5:1
-      |
-    3 | from typing_extensions import reveal_type
-    4 |
-    5 | reveal_type(sys.platform)
-      | ^^^^^^^^^^^^^^^^^^^^^^^^^ `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
@@ -147,7 +86,7 @@ fn cli_arguments_are_relative_to_the_current_directory() -> anyhow::Result<()> {
            "libs/utils.py",
            r#"
            def add(a: int, b: int) -> int:
-                return a + b
+                a + b
            "#,
        ),
        (
@@ -219,7 +158,7 @@ fn paths_in_configuration_files_are_relative_to_the_project_root() -> anyhow::Re
            "libs/utils.py",
            r#"
            def add(a: int, b: int) -> int:
-                return a + b
+                a + b
            "#,
        ),
        (
@@ -280,7 +219,7 @@ fn configuration_rule_severity() -> anyhow::Result<()> {
    5 |     x = a
    6 |
    7 | print(x)  # possibly-unresolved-reference
-      |       ^ Name `x` used when possibly not defined
+      |       - Name `x` used when possibly not defined
      |

    Found 2 diagnostics
@@ -305,7 +244,7 @@ fn configuration_rule_severity() -> anyhow::Result<()> {
     --> <temp_dir>/test.py:2:5
      |
    2 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ----- Cannot divide object of type `Literal[4]` by zero
    3 |
    4 | for a in range(0, y):
      |
@@ -367,7 +306,7 @@ fn cli_rule_severity() -> anyhow::Result<()> {
    7 |     x = a
    8 |
    9 | print(x)  # possibly-unresolved-reference
-      |       ^ Name `x` used when possibly not defined
+      |       - Name `x` used when possibly not defined
      |

    Found 3 diagnostics
@@ -392,7 +331,7 @@ fn cli_rule_severity() -> anyhow::Result<()> {
     --> <temp_dir>/test.py:2:8
      |
    2 | import does_not_exit
-      |        ^^^^^^^^^^^^^ Cannot resolve import `does_not_exit`
+      |        ------------- Cannot resolve import `does_not_exit`
    3 |
    4 | y = 4 / 0
      |
@@ -403,7 +342,7 @@ fn cli_rule_severity() -> anyhow::Result<()> {
    2 | import does_not_exit
    3 |
    4 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ----- Cannot divide object of type `Literal[4]` by zero
    5 |
    6 | for a in range(0, y):
      |
@@ -454,7 +393,7 @@ fn cli_rule_severity_precedence() -> anyhow::Result<()> {
    5 |     x = a
    6 |
    7 | print(x)  # possibly-unresolved-reference
-      |       ^ Name `x` used when possibly not defined
+      |       - Name `x` used when possibly not defined
      |

    Found 2 diagnostics
@@ -480,7 +419,7 @@ fn cli_rule_severity_precedence() -> anyhow::Result<()> {
     --> <temp_dir>/test.py:2:5
      |
    2 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ----- Cannot divide object of type `Literal[4]` by zero
    3 |
    4 | for a in range(0, y):
      |
@@ -517,7 +456,7 @@ fn configuration_unknown_rules() -> anyhow::Result<()> {
      |
    2 | [tool.knot.rules]
    3 | division-by-zer = "warn" # incorrect rule name
-      | ^^^^^^^^^^^^^^^ Unknown lint rule `division-by-zer`
+      | --------------- Unknown lint rule `division-by-zer`
      |

    Found 1 diagnostic
@@ -559,7 +498,7 @@ fn exit_code_only_warnings() -> anyhow::Result<()> {
     --> <temp_dir>/test.py:1:7
      |
    1 | print(x)  # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       - Name `x` used when not defined
      |

    Found 1 diagnostic
@@ -584,12 +523,12 @@ fn exit_code_only_info() -> anyhow::Result<()> {
    success: true
    exit_code: 0
    ----- stdout -----
-    info: revealed-type: Revealed type
+    info: revealed-type
     --> <temp_dir>/test.py:3:1
      |
    2 | from typing_extensions import reveal_type
    3 | reveal_type(1)
-      | ^^^^^^^^^^^^^^ `Literal[1]`
+      | -------------- info: Revealed type is `Literal[1]`
      |

    Found 1 diagnostic
@@ -614,12 +553,12 @@ fn exit_code_only_info_and_error_on_warning_is_true() -> anyhow::Result<()> {
    success: true
    exit_code: 0
    ----- stdout -----
-    info: revealed-type: Revealed type
+    info: revealed-type
     --> <temp_dir>/test.py:3:1
      |
    2 | from typing_extensions import reveal_type
    3 | reveal_type(1)
-      | ^^^^^^^^^^^^^^ `Literal[1]`
+      | -------------- info: Revealed type is `Literal[1]`
      |

    Found 1 diagnostic
@@ -642,7 +581,7 @@ fn exit_code_no_errors_but_error_on_warning_is_true() -> anyhow::Result<()> {
     --> <temp_dir>/test.py:1:7
      |
    1 | print(x)  # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       - Name `x` used when not defined
      |

    Found 1 diagnostic
@@ -674,7 +613,7 @@ fn exit_code_no_errors_but_error_on_warning_is_enabled_in_configuration() -> any
     --> <temp_dir>/test.py:1:7
      |
    1 | print(x)  # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       - Name `x` used when not defined
      |

    Found 1 diagnostic
@@ -703,7 +642,7 @@ fn exit_code_both_warnings_and_errors() -> anyhow::Result<()> {
     --> <temp_dir>/test.py:2:7
      |
    2 | print(x)     # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       - Name `x` used when not defined
    3 | print(4[1])  # [non-subscriptable]
      |

@@ -741,7 +680,7 @@ fn exit_code_both_warnings_and_errors_and_error_on_warning_is_true() -> anyhow::
     --> <temp_dir>/test.py:2:7
      |
    2 | print(x)     # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       - Name `x` used when not defined
    3 | print(4[1])  # [non-subscriptable]
      |

@@ -779,7 +718,7 @@ fn exit_code_exit_zero_is_true() -> anyhow::Result<()> {
     --> <temp_dir>/test.py:2:7
      |
    2 | print(x)     # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       - Name `x` used when not defined
    3 | print(4[1])  # [non-subscriptable]
      |

@@ -839,7 +778,7 @@ fn user_configuration() -> anyhow::Result<()> {
     --> <temp_dir>/project/main.py:2:5
      |
    2 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ----- Cannot divide object of type `Literal[4]` by zero
    3 |
    4 | for a in range(0, y):
      |
@@ -850,7 +789,7 @@ fn user_configuration() -> anyhow::Result<()> {
    5 |     x = a
    6 |
    7 | print(x)
-      |       ^ Name `x` used when possibly not defined
+      |       - Name `x` used when possibly not defined
      |

    Found 2 diagnostics
@@ -881,7 +820,7 @@ fn user_configuration() -> anyhow::Result<()> {
     --> <temp_dir>/project/main.py:2:5
      |
    2 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ----- Cannot divide object of type `Literal[4]` by zero
    3 |
    4 | for a in range(0, y):
      |
@@ -1028,63 +967,6 @@ fn check_non_existing_path() -> anyhow::Result<()> {
    Ok(())
 }

-#[test]
-fn concise_diagnostics() -> anyhow::Result<()> {
-    let case = TestCase::with_file(
-        "test.py",
-        r#"
-        print(x)     # [unresolved-reference]
-        print(4[1])  # [non-subscriptable]
-        "#,
-    )?;
-
-    assert_cmd_snapshot!(case.command().arg("--output-format=concise"), @r"
-    success: false
-    exit_code: 1
-    ----- stdout -----
-    warning[lint:unresolved-reference] <temp_dir>/test.py:2:7: Name `x` used when not defined
-    error[lint:non-subscriptable] <temp_dir>/test.py:3:7: Cannot subscript object of type `Literal[4]` with no `__getitem__` method
-    Found 2 diagnostics
-
-    ----- stderr -----
-    ");
-
-    Ok(())
-}
-
-/// This tests the diagnostic format for revealed type.
-///
-/// This test was introduced because changes were made to
-/// how the revealed type diagnostic was constructed and
-/// formatted in "verbose" mode. But it required extra
-/// logic to ensure the concise version didn't regress on
-/// information content. So this test was introduced to
-/// capture that.
-#[test]
-fn concise_revealed_type() -> anyhow::Result<()> {
-    let case = TestCase::with_file(
-        "test.py",
-        r#"
-        from typing_extensions import reveal_type
-
-        x = "hello"
-        reveal_type(x)
-        "#,
-    )?;
-
-    assert_cmd_snapshot!(case.command().arg("--output-format=concise"), @r#"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    info[revealed-type] <temp_dir>/test.py:5:1: Revealed type: `Literal["hello"]`
-    Found 1 diagnostic
-
-    ----- stderr -----
-    "#);
-
-    Ok(())
-}
-
 struct TestCase {
    _temp_dir: TempDir,
    _settings_scope: SettingsBindDropGuard,
--- a/crates/red_knot/tests/file_watching.rs
+++ b/crates/red_knot/tests/file_watching.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::disallowed_names)]
+
 use std::collections::HashSet;
 use std::io::Write;
 use std::time::{Duration, Instant};
@@ -12,9 +14,9 @@ use red_knot_python_semantic::{resolve_module, ModuleName, PythonPlatform};
 use ruff_db::files::{system_path_to_file, File, FileError};
 use ruff_db::source::source_text;
 use ruff_db::system::{
-    file_time_now, OsSystem, System, SystemPath, SystemPathBuf, UserConfigDirectoryOverrideGuard,
+    OsSystem, System, SystemPath, SystemPathBuf, UserConfigDirectoryOverrideGuard,
 };
-use ruff_db::{Db as _, Upcast};
+use ruff_db::Upcast;
 use ruff_python_ast::PythonVersion;

 struct TestCase {
@@ -462,7 +464,7 @@ fn update_file(path: impl AsRef<SystemPath>, content: &str) -> anyhow::Result<()

        std::thread::sleep(Duration::from_nanos(10));

-        filetime::set_file_handle_times(&file, None, Some(file_time_now()))?;
+        filetime::set_file_handle_times(&file, None, Some(filetime::FileTime::now()))?;
    }
 }

@@ -1125,11 +1127,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`"
    );

@@ -1788,82 +1790,3 @@ fn changes_to_user_configuration() -> anyhow::Result<()> {

    Ok(())
 }
-
-/// Tests that renaming a file from `lib.py` to `Lib.py` is correctly reflected.
-///
-/// This test currently fails on case-insensitive systems because `Files` is case-sensitive
-/// but the `System::metadata` call isn't. This means that
-/// Red Knot considers both `Lib.py` and `lib.py` to exist when only `lib.py` does
-///
-/// The incoming change events then are no-ops because they don't change either file's
-/// status nor does it update their last modified time (renaming a file doesn't bump it's
-/// last modified timestamp).
-///
-/// Fixing this requires to either make `Files` case-insensitive and store the
-/// real-case path (if it differs) on `File` or make `Files` use a
-/// case-sensitive `System::metadata` call. This does open the question if all
-/// `System` calls should be case sensitive. This would be the most consistent
-/// but might be hard to pull off.
-///
-/// What the right solution is also depends on if Red Knot itself should be case
-/// sensitive or not. E.g. should `include="src"` be case sensitive on all systems
-/// or only on case-sensitive systems?
-///
-/// Lastly, whatever solution we pick must also work well with VS Code which,
-/// unfortunately ,doesn't propagate casing-only renames.
-/// <https://github.com/rust-lang/rust-analyzer/issues/9581>
-#[ignore]
-#[test]
-fn rename_files_casing_only() -> anyhow::Result<()> {
-    let mut case = setup([("lib.py", "class Foo: ...")])?;
-
-    assert!(
-        resolve_module(case.db(), &ModuleName::new("lib").unwrap()).is_some(),
-        "Expected `lib` module to exist."
-    );
-    assert_eq!(
-        resolve_module(case.db(), &ModuleName::new("Lib").unwrap()),
-        None,
-        "Expected `Lib` module not to exist"
-    );
-
-    // Now rename `lib.py` to `Lib.py`
-    if case.db().system().case_sensitivity().is_case_sensitive() {
-        std::fs::rename(
-            case.project_path("lib.py").as_std_path(),
-            case.project_path("Lib.py").as_std_path(),
-        )
-        .context("Failed to rename `lib.py` to `Lib.py`")?;
-    } else {
-        // On case-insensitive file systems, renaming a file to a different casing is a no-op.
-        // Rename to a different name first
-        std::fs::rename(
-            case.project_path("lib.py").as_std_path(),
-            case.project_path("temp.py").as_std_path(),
-        )
-        .context("Failed to rename `lib.py` to `temp.py`")?;
-
-        std::fs::rename(
-            case.project_path("temp.py").as_std_path(),
-            case.project_path("Lib.py").as_std_path(),
-        )
-        .context("Failed to rename `temp.py` to `Lib.py`")?;
-    }
-
-    let changes = case.stop_watch(event_for_file("Lib.py"));
-    case.apply_changes(changes);
-
-    // Resolving `lib` should now fail but `Lib` should now succeed
-    assert_eq!(
-        resolve_module(case.db(), &ModuleName::new("lib").unwrap()),
-        None,
-        "Expected `lib` module to no longer exist."
-    );
-
-    assert!(
-        resolve_module(case.db(), &ModuleName::new("Lib").unwrap()).is_some(),
-        "Expected `Lib` module to exist"
-    );
-
-    Ok(())
-}
--- a/crates/red_knot_ide/Cargo.toml
+++ b/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
--- a/crates/red_knot_ide/src/db.rs
+++ b/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);
-        }
-    }
-}
--- a/crates/red_knot_ide/src/find_node.rs
+++ b/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()
-    }
-}
--- a/crates/red_knot_ide/src/goto.rs
+++ b/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:438:7
-            |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
-            |       ^^^
-        439 |     @overload
-        440 |     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:438:7
-            |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
-            |       ^^^
-        439 |     @overload
-        440 |     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:438:7
-            |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
-            |       ^^^
-        439 |     @overload
-        440 |     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:231:7
-            |
-        229 | _LiteralInteger = _PositiveInteger | _NegativeInteger | Literal[0]  # noqa: Y026  # TODO: Use TypeAlias once mypy bugs are fixed
-        230 |
-        231 | class int:
-            |       ^^^
-        232 |     @overload
-        233 |     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:1086:7
-             |
-        1084 |     def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
-        1085 |
-        1086 | class dict(MutableMapping[_KT, _VT]):
-             |       ^^^^
-        1087 |     # __init__ should be kept roughly in line with `collections.UserDict.__init__`, which has similar semantics
-        1088 |     # 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:438:7
-            |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
-            |       ^^^
-        439 |     @overload
-        440 |     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:438:7
-            |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
-            |       ^^^
-        439 |     @overload
-        440 |     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:671:11
-            |
-        669 | if sys.version_info >= (3, 10):
-        670 |     @final
-        671 |     class NoneType:
-            |           ^^^^^^^^
-        672 |         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:438:7
-            |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
-            |       ^^^
-        439 |     @overload
-        440 |     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
-        }
-    }
-}
--- a/crates/red_knot_ide/src/hover.rs
+++ b/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###"
-        def foo(a, b) -> Unknown
-        ---------------------------------------------
-        ```text
-        def foo(a, b) -> Unknown
-        ```
-        ---------------------------------------------
-        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###"
-        (def foo(a, b) -> Unknown) | (def bar(a, b) -> Unknown)
-        ---------------------------------------------
-        ```text
-        (def foo(a, b) -> Unknown) | (def bar(a, b) -> Unknown)
-        ```
-        ---------------------------------------------
-        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
-        }
-    }
-}
--- a/crates/red_knot_ide/src/inlay_hints.rs
+++ b/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
-        ");
-    }
-}
--- a/crates/red_knot_ide/src/lib.rs
+++ b/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;
-    }
-}
--- a/crates/red_knot_ide/src/markup.rs
+++ b/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")
-            }
-        }
-    }
-}
--- a/crates/red_knot_project/Cargo.toml
+++ b/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
--- a/crates/red_knot_project/src/combine.rs
+++ b/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
--- a/crates/red_knot_project/src/db.rs
+++ b/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,13 @@ 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> {
+        let _span = tracing::debug_span!("check_file", file=%file.path(self)).entered();
+
        self.with_db(|db| self.project().check_file(db, file))
    }

@@ -104,19 +104,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 +146,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 +161,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;
--- a/crates/red_knot_project/src/db/changes.rs
+++ b/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");
--- a/crates/red_knot_project/src/lib.rs
+++ b/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);
@@ -199,8 +195,7 @@ impl Project {
                let project_span = project_span.clone();

                scope.spawn(move |_| {
-                    let check_file_span =
-                        tracing::debug_span!(parent: &project_span, "check_file", ?file);
+                    let check_file_span = tracing::debug_span!(parent: &project_span, "check_file", file=%file.path(&db));
                    let _entered = check_file_span.entered();

                    let file_diagnostics = check_file_impl(&db, file);
@@ -212,11 +207,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);
@@ -327,7 +325,7 @@ impl Project {
        self.files(db).contains(&file)
    }

-    #[tracing::instrument(level = "debug", skip(self, db))]
+    #[tracing::instrument(level = "debug", skip(db))]
    pub fn remove_file(self, db: &mut dyn Db, file: File) {
        tracing::debug!(
            "Removing file `{}` from project `{}`",
@@ -399,36 +397,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 +493,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 +525,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 +549,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 +565,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>
        );
--- a/crates/red_knot_project/src/metadata.rs
+++ b/crates/red_knot_project/src/metadata.rs
@@ -64,7 +64,7 @@ impl ProjectMetadata {
    }

    /// Loads a project from a set of options with an optional pyproject-project table.
-    pub fn from_options(
+    pub(crate) fn from_options(
        mut options: Options,
        root: SystemPathBuf,
        project: Option<&Project>,
--- a/crates/red_knot_project/src/metadata/options.rs
+++ b/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::{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;

@@ -36,43 +37,30 @@ pub struct Options {

 impl Options {
    pub(crate) fn from_toml_str(content: &str, source: ValueSource) -> Result<Self, KnotTomlError> {
-        let _guard = ValueSourceGuard::new(source, true);
+        let _guard = ValueSourceGuard::new(source);
        let options = toml::from_str(content)?;
        Ok(options)
    }

-    pub fn deserialize_with<'de, D>(source: ValueSource, deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let _guard = ValueSourceGuard::new(source, false);
-        Self::deserialize(deserializer)
-    }
-
    pub(crate) fn to_program_settings(
        &self,
        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),
        }
    }
@@ -118,14 +106,9 @@ impl Options {
            custom_typeshed: typeshed.map(|path| path.absolute(project_root, system)),
            python_path: python
                .map(|python_path| {
-                    PythonPath::from_cli_flag(python_path.absolute(project_root, system))
+                    PythonPath::SysPrefix(python_path.absolute(project_root, system))
                })
-                .or_else(|| {
-                    std::env::var("VIRTUAL_ENV")
-                        .ok()
-                        .map(PythonPath::from_virtual_env_var)
-                })
-                .unwrap_or_else(|| PythonPath::Discover(project_root.to_path_buf())),
+                .unwrap_or(PythonPath::KnownSitePackages(vec![])),
        }
    }

@@ -137,11 +120,6 @@ impl Options {

        if let Some(terminal) = self.terminal.as_ref() {
            settings.set_terminal(TerminalSettings {
-                output_format: terminal
-                    .output_format
-                    .as_deref()
-                    .copied()
-                    .unwrap_or_default(),
                error_on_warning: terminal.error_on_warning.unwrap_or_default(),
            });
        }
@@ -229,7 +207,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 +216,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>>,

@@ -304,11 +277,6 @@ impl FromIterator<(RangedValue<String>, RangedValue<Level>)> for Rules {
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct TerminalOptions {
-    /// The format to use for printing diagnostic messages.
-    ///
-    /// Defaults to `full`.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_format: Option<RangedValue<DiagnosticFormat>>,
    /// Use exit code 1 if there are any warning-level diagnostics.
    ///
    /// Defaults to `false`.
@@ -406,14 +374,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
    }
 }
--- a/crates/red_knot_project/src/metadata/pyproject.rs
+++ b/crates/red_knot_project/src/metadata/pyproject.rs
@@ -34,7 +34,7 @@ impl PyProject {
        content: &str,
        source: ValueSource,
    ) -> Result<Self, PyProjectError> {
-        let _guard = ValueSourceGuard::new(source, true);
+        let _guard = ValueSourceGuard::new(source);
        toml::from_str(content).map_err(PyProjectError::TomlSyntax)
    }
 }
@@ -96,10 +96,7 @@ impl Project {
            return Ok(None);
        };

-        let mut minor = versions.next().copied().unwrap_or_default();
-
-        // Ensure minor is at least 9
-        minor = minor.max(9);
+        let minor = versions.next().copied().unwrap_or_default();

        tracing::debug!("Resolved requires-python constraint to: {major}.{minor}");

--- a/crates/red_knot_project/src/metadata/settings.rs
+++ b/crates/red_knot_project/src/metadata/settings.rs
@@ -1,7 +1,6 @@
 use std::sync::Arc;

 use red_knot_python_semantic::lint::RuleSelection;
-use ruff_db::diagnostic::DiagnosticFormat;

 /// The resolved [`super::Options`] for the project.
 ///
@@ -50,6 +49,5 @@ impl Settings {

 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct TerminalSettings {
-    pub output_format: DiagnosticFormat,
    pub error_on_warning: bool,
 }
--- a/crates/red_knot_project/src/metadata/value.rs
+++ b/crates/red_knot_project/src/metadata/value.rs
@@ -19,7 +19,6 @@ pub enum ValueSource {
    /// Ideally, we'd use [`ruff_db::files::File`] but we can't because the database hasn't been
    /// created when loading the configuration.
    File(Arc<SystemPathBuf>),
-
    /// The value comes from a CLI argument, while it's left open if specified using a short argument,
    /// long argument (`--extra-paths`) or `--config key=value`.
    Cli,
@@ -42,18 +41,18 @@ thread_local! {
    /// Use the [`ValueSourceGuard`] to initialize the thread local before calling into any
    /// deserialization code. It ensures that the thread local variable gets cleaned up
    /// once deserialization is done (once the guard gets dropped).
-    static VALUE_SOURCE: RefCell<Option<(ValueSource, bool)>> = const { RefCell::new(None) };
+    static VALUE_SOURCE: RefCell<Option<ValueSource>> = const { RefCell::new(None) };
 }

 /// Guard to safely change the [`VALUE_SOURCE`] for the current thread.
 #[must_use]
 pub(super) struct ValueSourceGuard {
-    prev_value: Option<(ValueSource, bool)>,
+    prev_value: Option<ValueSource>,
 }

 impl ValueSourceGuard {
-    pub(super) fn new(source: ValueSource, is_toml: bool) -> Self {
-        let prev = VALUE_SOURCE.replace(Some((source, is_toml)));
+    pub(super) fn new(source: ValueSource) -> Self {
+        let prev = VALUE_SOURCE.replace(Some(source));
        Self { prev_value: prev }
    }
 }
@@ -266,24 +265,18 @@ where
    where
        D: Deserializer<'de>,
    {
-        VALUE_SOURCE.with_borrow(|source| {
-            let (source, has_span) = source.clone().unwrap();
+        let spanned: Spanned<T> = Spanned::deserialize(deserializer)?;
+        let span = spanned.span();
+        let range = TextRange::new(
+            TextSize::try_from(span.start).expect("Configuration file to be smaller than 4GB"),
+            TextSize::try_from(span.end).expect("Configuration file to be smaller than 4GB"),
+        );

-            if has_span {
-                let spanned: Spanned<T> = Spanned::deserialize(deserializer)?;
-                let span = spanned.span();
-                let range = TextRange::new(
-                    TextSize::try_from(span.start)
-                        .expect("Configuration file to be smaller than 4GB"),
-                    TextSize::try_from(span.end)
-                        .expect("Configuration file to be smaller than 4GB"),
-                );
+        Ok(VALUE_SOURCE.with_borrow(|source| {
+            let source = source.clone().unwrap();

-                Ok(Self::with_range(spanned.into_inner(), source, range))
-            } else {
-                Ok(Self::new(T::deserialize(deserializer)?, source))
-            }
-        })
+            Self::with_range(spanned.into_inner(), source, range)
+        }))
    }
 }

--- a/crates/red_knot_project/tests/check.rs
+++ b/crates/red_knot_project/tests/check.rs
@@ -279,4 +279,23 @@ impl SourceOrderVisitor<'_> for PullTypesVisitor<'_> {

 /// Whether or not the .py/.pyi version of this file is expected to fail
 #[rustfmt::skip]
-const KNOWN_FAILURES: &[(&str, bool, bool)] = &[];
+const KNOWN_FAILURES: &[(&str, bool, bool)] = &[
+    // related to circular references in nested functions
+    ("crates/ruff_linter/resources/test/fixtures/flake8_return/RET503.py", false, true),
+    // related to circular references in class definitions
+    ("crates/ruff_linter/resources/test/fixtures/pyflakes/F821_26.py", true, true),
+    ("crates/ruff_linter/resources/test/fixtures/pyflakes/F821_27.py", true, true),
+    ("crates/ruff_linter/resources/test/fixtures/pyflakes/F811_19.py", true, false),
+    ("crates/ruff_linter/resources/test/fixtures/pyupgrade/UP039.py", true, false),
+    // related to circular references in type aliases (salsa cycle panic):
+    ("crates/ruff_python_parser/resources/inline/err/type_alias_invalid_value_expr.py", true, true),
+    ("crates/ruff_linter/resources/test/fixtures/flake8_type_checking/TC008.py", true, true),
+    // related to circular references in f-string annotations (invalid syntax)
+    ("crates/ruff_linter/resources/test/fixtures/pyflakes/F821_15.py", true, true),
+    ("crates/ruff_linter/resources/test/fixtures/pyflakes/F821_14.py", false, true),
+    // related to circular references in stub type annotations (salsa cycle panic):
+    ("crates/ruff_linter/resources/test/fixtures/pycodestyle/E501_4.py", false, true),
+    ("crates/ruff_linter/resources/test/fixtures/pyflakes/F401_0.py", false, true),
+    ("crates/ruff_linter/resources/test/fixtures/pyflakes/F401_12.py", false, true),
+    ("crates/ruff_linter/resources/test/fixtures/pyflakes/F401_14.py", false, true),
+];
--- a/crates/red_knot_python_semantic/mdtest.py
+++ b/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):
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/annotated.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/annotated.md
@@ -29,7 +29,7 @@ It is invalid to parameterize `Annotated` with less than two arguments.
 ```py
 from typing_extensions import Annotated

-# error: [invalid-type-form] "`typing.Annotated` requires at least two arguments when used in a type expression"
+# error: [invalid-type-form] "`Annotated` requires at least two arguments when used in an annotation or type expression"
 def _(x: Annotated):
    reveal_type(x)  # revealed: Unknown

@@ -39,11 +39,11 @@ def _(flag: bool):
    else:
        X = bool

-    # error: [invalid-type-form] "`typing.Annotated` requires at least two arguments when used in a type expression"
+    # error: [invalid-type-form] "`Annotated` requires at least two arguments when used in an annotation or type expression"
    def f(y: X):
        reveal_type(y)  # revealed: Unknown | bool

-# error: [invalid-type-form] "`typing.Annotated` requires at least two arguments when used in a type expression"
+# error: [invalid-type-form] "`Annotated` requires at least two arguments when used in an annotation or type expression"
 def _(x: Annotated | bool):
    reveal_type(x)  # revealed: Unknown | bool

@@ -73,10 +73,12 @@ Inheriting from `Annotated[T, ...]` is equivalent to inheriting from `T` itself.
 ```py
 from typing_extensions import Annotated

+# TODO: False positive
+# error: [invalid-base]
 class C(Annotated[int, "foo"]): ...

 # TODO: Should be `tuple[Literal[C], Literal[int], Literal[object]]`
-reveal_type(C.__mro__)  # revealed: tuple[Literal[C], @Todo(Inference of subscript on special form), Literal[object]]
+reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Unknown, Literal[object]]
 ```

 ### Not parameterized
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/callable.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/callable.md
@@ -2,12 +2,10 @@

 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
-`typing.Callable` is not currently planned, and the canonical location of the stub for the symbol in
-typeshed is still `typing.pyi`.
+TODO: Use `collections.abc` as importing from `typing` is deprecated but this requires support for
+`*` imports. See: <https://docs.python.org/3/library/typing.html#deprecated-aliases>.

 ## Invalid forms

@@ -49,10 +47,8 @@ def _(c: Callable[42, str]):
 Or, when one of the parameter type is invalid in the list:

 ```py
-# error: [invalid-type-form] "Int literals are not allowed in this context in a type expression"
-# error: [invalid-type-form] "Boolean literals are not allowed in this context in a type expression"
 def _(c: Callable[[int, 42, str, False], None]):
-    # revealed: (int, Unknown, str, Unknown, /) -> None
+    # revealed: (int, @Todo(number literal in type expression), str, @Todo(boolean literal in type expression), /) -> None
    reveal_type(c)
 ```

@@ -65,7 +61,7 @@ from typing import Callable

 # error: [invalid-type-form] "Special form `typing.Callable` expected exactly two arguments (parameter types and return type)"
 def _(c: Callable[[int, str]]):
-    reveal_type(c)  # revealed: (...) -> Unknown
+    reveal_type(c)  # revealed: (int, str, /) -> Unknown
 ```

 Or, an ellipsis:
@@ -76,18 +72,6 @@ def _(c: Callable[...]):
    reveal_type(c)  # revealed: (...) -> Unknown
 ```

-Or something else that's invalid in a type expression generally:
-
-```py
-# fmt: off
-
-def _(c: Callable[  # error: [invalid-type-form] "Special form `typing.Callable` expected exactly two arguments (parameter types and return type)"
-            {1, 2}  # error: [invalid-type-form] "The first argument to `Callable` must be either a list of types, ParamSpec, Concatenate, or `...`"
-        ]
-    ):
-    reveal_type(c)  # revealed: (...) -> Unknown
-```
-
 ### More than two arguments

 We can't reliably infer the callable type if there are more then 2 arguments because we don't know
@@ -101,48 +85,6 @@ def _(c: Callable[[int], str, str]):
    reveal_type(c)  # revealed: (...) -> Unknown
 ```

-### List as the second argument
-
-```py
-from typing import Callable
-
-# fmt: off
-
-def _(c: Callable[
-            int,  # error: [invalid-type-form] "The first argument to `Callable` must be either a list of types, ParamSpec, Concatenate, or `...`"
-            [str]  # error: [invalid-type-form] "List literals are not allowed in this context in a type expression"
-        ]
-    ):
-    reveal_type(c)  # revealed: (...) -> Unknown
-```
-
-### List as both arguments
-
-```py
-from typing import Callable
-
-# error: [invalid-type-form] "List literals are not allowed in this context in a type expression"
-def _(c: Callable[[int], [str]]):
-    reveal_type(c)  # revealed: (int, /) -> Unknown
-```
-
-### Three list arguments
-
-```py
-from typing import Callable
-
-# fmt: off
-
-
-def _(c: Callable[  # error: [invalid-type-form] "Special form `typing.Callable` expected exactly two arguments (parameter types and return type)"
-            [int],
-            [str],  # error: [invalid-type-form] "List literals are not allowed in this context in a type expression"
-            [bytes]  # error: [invalid-type-form] "List literals are not allowed in this context in a type expression"
-        ]
-    ):
-    reveal_type(c)  # revealed: (...) -> Unknown
-```
-
 ## Simple

 A simple `Callable` with multiple parameters and a return type:
@@ -154,39 +96,6 @@ def _(c: Callable[[int, str], int]):
    reveal_type(c)  # revealed: (int, str, /) -> int
 ```

-## Union
-
-```py
-from typing import Callable, Union
-
-def _(
-    c: Callable[[Union[int, str]], int] | None,
-    d: None | Callable[[Union[int, str]], int],
-    e: None | Callable[[Union[int, str]], int] | int,
-):
-    reveal_type(c)  # revealed: ((int | str, /) -> int) | None
-    reveal_type(d)  # revealed: None | ((int | str, /) -> int)
-    reveal_type(e)  # revealed: None | ((int | str, /) -> int) | int
-```
-
-## Intersection
-
-```py
-from typing import Callable, Union
-from knot_extensions import Intersection, Not
-
-def _(
-    c: Intersection[Callable[[Union[int, str]], int], int],
-    d: Intersection[int, Callable[[Union[int, str]], int]],
-    e: Intersection[int, Callable[[Union[int, str]], int], str],
-    f: Intersection[Not[Callable[[int, str], Intersection[int, str]]]],
-):
-    reveal_type(c)  # revealed: ((int | str, /) -> int) & int
-    reveal_type(d)  # revealed: int & ((int | str, /) -> int)
-    reveal_type(e)  # revealed: int & ((int | str, /) -> int) & str
-    reveal_type(f)  # revealed: ~((int, str, /) -> int & str)
-```
-
 ## Nested

 A nested `Callable` as one of the parameter types:
@@ -283,20 +192,4 @@ def _(c: Callable[[int, Unpack[Ts]], int]):
    reveal_type(c)  # revealed: (*args: @Todo(todo signature *args), **kwargs: @Todo(todo signature **kwargs)) -> int
 ```

-## Member lookup
-
-```py
-from typing import Callable
-
-def _(c: Callable[[int], int]):
-    reveal_type(c.__init__)  # revealed: def __init__(self) -> None
-    reveal_type(c.__class__)  # revealed: type
-
-    # TODO: The member lookup for `Callable` uses `object` which does not have a `__call__`
-    # attribute. We could special case `__call__` in this context. Refer to
-    # https://github.com/astral-sh/ruff/pull/16493#discussion_r1985098508 for more details.
-    # error: [unresolved-attribute] "Type `(int, /) -> int` has no attribute `__call__`"
-    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
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/deferred.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/deferred.md
@@ -38,111 +38,9 @@ If `__future__.annotations` is imported, annotations *are* deferred.
 ```py
 from __future__ import annotations

-def get_foo() -> Foo:
-    return Foo()
+def get_foo() -> Foo: ...

 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
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/int_float_complex.md
+++ b/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

--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/invalid.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/invalid.md
@@ -9,8 +9,6 @@ import typing
 from knot_extensions import AlwaysTruthy, AlwaysFalsy
 from typing_extensions import Literal, Never

-class A: ...
-
 def _(
    a: type[int],
    b: AlwaysTruthy,
@@ -20,95 +18,28 @@ def _(
    f: Literal[b"foo"],
    g: tuple[int, str],
    h: Never,
-    i: int,
-    j: A,
 ):
    def foo(): ...
    def invalid(
-        a_: a,  # error: [invalid-type-form] "Variable of type `type[int]` is not allowed in a type expression"
-        b_: b,  # error: [invalid-type-form]
-        c_: c,  # error: [invalid-type-form]
-        d_: d,  # error: [invalid-type-form]
-        e_: e,  # error: [invalid-type-form]
-        f_: f,  # error: [invalid-type-form]
-        g_: g,  # error: [invalid-type-form]
-        h_: h,  # error: [invalid-type-form]
-        i_: typing,  # error: [invalid-type-form]
-        j_: foo,  # error: [invalid-type-form]
-        k_: i,  # error: [invalid-type-form] "Variable of type `int` is not allowed in a type expression"
-        l_: j,  # error: [invalid-type-form] "Variable of type `A` is not allowed in a type expression"
+        i: a,  # error: [invalid-type-form] "Variable of type `type[int]` is not allowed in a type expression"
+        j: b,  # error: [invalid-type-form]
+        k: c,  # error: [invalid-type-form]
+        l: d,  # error: [invalid-type-form]
+        m: e,  # error: [invalid-type-form]
+        n: f,  # error: [invalid-type-form]
+        o: g,  # error: [invalid-type-form]
+        p: h,  # error: [invalid-type-form]
+        q: typing,  # error: [invalid-type-form]
+        r: foo,  # error: [invalid-type-form]
    ):
-        reveal_type(a_)  # revealed: Unknown
-        reveal_type(b_)  # revealed: Unknown
-        reveal_type(c_)  # revealed: Unknown
-        reveal_type(d_)  # revealed: Unknown
-        reveal_type(e_)  # revealed: Unknown
-        reveal_type(f_)  # revealed: Unknown
-        reveal_type(g_)  # revealed: Unknown
-        reveal_type(h_)  # revealed: Unknown
-        reveal_type(i_)  # revealed: Unknown
-        reveal_type(j_)  # revealed: Unknown
-```
-
-## Invalid AST nodes
-
-```py
-def bar() -> None:
-    return None
-
-def _(
-    a: 1,  # error: [invalid-type-form] "Int literals are not allowed in this context in a type expression"
-    b: 2.3,  # error: [invalid-type-form] "Float literals are not allowed in type expressions"
-    c: 4j,  # error: [invalid-type-form] "Complex literals are not allowed in type expressions"
-    d: True,  # error: [invalid-type-form] "Boolean literals are not allowed in this context in a type expression"
-    e: int | b"foo",  # error: [invalid-type-form] "Bytes literals are not allowed in this context in a type expression"
-    f: 1 and 2,  # error: [invalid-type-form] "Boolean operations are not allowed in type expressions"
-    g: 1 or 2,  # error: [invalid-type-form] "Boolean operations are not allowed in type expressions"
-    h: (foo := 1),  # error: [invalid-type-form] "Named expressions are not allowed in type expressions"
-    i: not 1,  # error: [invalid-type-form] "Unary operations are not allowed in type expressions"
-    j: lambda: 1,  # error: [invalid-type-form] "`lambda` expressions are not allowed in type expressions"
-    k: 1 if True else 2,  # error: [invalid-type-form] "`if` expressions are not allowed in type expressions"
-    l: await 1,  # error: [invalid-type-form] "`await` expressions are not allowed in type expressions"
-    m: (yield 1),  # error: [invalid-type-form] "`yield` expressions are not allowed in type expressions"
-    n: (yield from [1]),  # error: [invalid-type-form] "`yield from` expressions are not allowed in type expressions"
-    o: 1 < 2,  # error: [invalid-type-form] "Comparison expressions are not allowed in type expressions"
-    p: bar(),  # error: [invalid-type-form] "Function calls are not allowed in type expressions"
-    q: int | f"foo",  # error: [invalid-type-form] "F-strings are not allowed in type expressions"
-    r: [1, 2, 3][1:2],  # error: [invalid-type-form] "Slices are not allowed in type expressions"
-):
-    reveal_type(a)  # revealed: Unknown
-    reveal_type(b)  # revealed: Unknown
-    reveal_type(c)  # revealed: Unknown
-    reveal_type(d)  # revealed: Unknown
-    reveal_type(e)  # revealed: int | Unknown
-    reveal_type(f)  # revealed: Unknown
-    reveal_type(g)  # revealed: Unknown
-    reveal_type(h)  # revealed: Unknown
-    reveal_type(i)  # revealed: Unknown
-    reveal_type(j)  # revealed: Unknown
-    reveal_type(k)  # revealed: Unknown
-    reveal_type(p)  # revealed: Unknown
-    reveal_type(q)  # revealed: int | Unknown
-    reveal_type(r)  # revealed: @Todo(generics)
-```
-
-## Invalid Collection based AST nodes
-
-```py
-def _(
-    a: {1: 2},  # error: [invalid-type-form] "Dict literals are not allowed in type expressions"
-    b: {1, 2},  # error: [invalid-type-form] "Set literals are not allowed in type expressions"
-    c: {k: v for k, v in [(1, 2)]},  # error: [invalid-type-form] "Dict comprehensions are not allowed in type expressions"
-    d: [k for k in [1, 2]],  # error: [invalid-type-form] "List comprehensions are not allowed in type expressions"
-    e: {k for k in [1, 2]},  # error: [invalid-type-form] "Set comprehensions are not allowed in type expressions"
-    f: (k for k in [1, 2]),  # error: [invalid-type-form] "Generator expressions are not allowed in type expressions"
-    g: [int, str],  # error: [invalid-type-form] "List literals are not allowed in this context in a type expression"
-):
-    reveal_type(a)  # revealed: Unknown
-    reveal_type(b)  # revealed: Unknown
-    reveal_type(c)  # revealed: Unknown
-    reveal_type(d)  # revealed: Unknown
-    reveal_type(e)  # revealed: Unknown
-    reveal_type(f)  # revealed: Unknown
-    reveal_type(g)  # revealed: Unknown
+        reveal_type(i)  # revealed: Unknown
+        reveal_type(j)  # revealed: Unknown
+        reveal_type(k)  # revealed: Unknown
+        reveal_type(l)  # revealed: Unknown
+        reveal_type(m)  # revealed: Unknown
+        reveal_type(n)  # revealed: Unknown
+        reveal_type(o)  # revealed: Unknown
+        reveal_type(p)  # revealed: Unknown
+        reveal_type(q)  # revealed: Unknown
+        reveal_type(r)  # revealed: Unknown
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/literal.md
+++ b/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]
@@ -127,13 +127,6 @@ Literal: _SpecialForm
 ```py
 from other import Literal

-# TODO: can we add a subdiagnostic here saying something like:
-#
-#     `other.Literal` and `typing.Literal` have similar names, but are different symbols and don't have the same semantics
-#
-# ?
-#
-# error: [invalid-type-form] "Int literals are not allowed in this context in a type expression"
 a1: Literal[26]

 def f():
@@ -156,7 +149,7 @@ def f():
 ```py
 from typing import Literal

-# error: [invalid-type-form] "`typing.Literal` requires at least one argument when used in a type expression"
+# error: [invalid-type-form] "`Literal` requires at least one argument when used in a type expression"
 def _(x: Literal):
    reveal_type(x)  # revealed: Unknown
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/literal_string.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/new_types.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/new_types.md
@@ -1,24 +0,0 @@
-# NewType
-
-Currently, red-knot doesn't support `typing.NewType` in type annotations.
-
-## Valid forms
-
-```py
-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] "Argument to this function is incorrect: Expected `type`, found `NewType`"
-B = GenericAlias(A, ())
-
-def _(
-    a: A,
-    b: B,
-):
-    reveal_type(a)  # revealed: @Todo(Support for `typing.NewType` instances in type expressions)
-    reveal_type(b)  # revealed: @Todo(Support for `typing.GenericAlias` instances in type expressions)
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/optional.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/optional.md
@@ -45,13 +45,3 @@ def f():
    # revealed: int | None
    reveal_type(a)
 ```
-
-## Invalid
-
-```py
-from typing import Optional
-
-# error: [invalid-type-form] "`typing.Optional` requires exactly one argument when used in a type expression"
-def f(x: Optional) -> None:
-    reveal_type(x)  # revealed: Unknown
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/stdlib_typing_aliases.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/stdlib_typing_aliases.md
@@ -81,7 +81,8 @@ reveal_type(DictSubclass.__mro__)

 class SetSubclass(typing.Set): ...

-# revealed: tuple[Literal[SetSubclass], Literal[set], Literal[MutableSet], Literal[AbstractSet], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(protocol), Literal[object]]
+# TODO: should have `Generic`, should not have `Unknown`
+# revealed: tuple[Literal[SetSubclass], Literal[set], Unknown, Literal[object]]
 reveal_type(SetSubclass.__mro__)

 class FrozenSetSubclass(typing.FrozenSet): ...
@@ -113,7 +114,8 @@ reveal_type(DefaultDictSubclass.__mro__)

 class DequeSubclass(typing.Deque): ...

-# revealed: tuple[Literal[DequeSubclass], Literal[deque], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(protocol), Literal[object]]
+# TODO: Should be (DequeSubclass, deque, MutableSequence, Sequence, Reversible, Collection, Sized, Iterable, Container, Generic, object)
+# revealed: tuple[Literal[DequeSubclass], Literal[deque], Unknown, Literal[object]]
 reveal_type(DequeSubclass.__mro__)

 class OrderedDictSubclass(typing.OrderedDict): ...
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/union.md
+++ b/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
@@ -59,30 +59,3 @@ def f():
    # revealed: int | str
    reveal_type(a)
 ```
-
-## Invalid
-
-```py
-from typing import Union
-
-# error: [invalid-type-form] "`typing.Union` requires at least one argument when used in a type expression"
-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)
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md
@@ -18,7 +18,7 @@ def f(*args: Unpack[Ts]) -> tuple[Unpack[Ts]]:
    # TODO: should understand the annotation
    reveal_type(args)  # revealed: tuple

-    reveal_type(Alias)  # revealed: @Todo(Support for `typing.TypeAlias`)
+    reveal_type(Alias)  # revealed: @Todo(Invalid or unsupported `KnownInstanceType` in `Type::to_type_expression`)

 def g() -> TypeGuard[int]: ...
 def h() -> TypeIs[int]: ...
@@ -29,34 +29,13 @@ def i(callback: Callable[Concatenate[int, P], R_co], *args: P.args, **kwargs: P.
    # TODO: should understand the annotation
    reveal_type(kwargs)  # revealed: dict

+    # TODO: not an error; remove once `call` is implemented for `Callable`
+    # error: [call-non-callable]
    return callback(42, *args, **kwargs)

 class Foo:
    def method(self, x: Self):
-        reveal_type(x)  # revealed: @Todo(Support for `typing.Self`)
-```
-
-## Type expressions
-
-One thing that is supported is error messages for using special forms in type expressions.
-
-```py
-from typing_extensions import Unpack, TypeGuard, TypeIs, Concatenate, ParamSpec
-
-def _(
-    a: Unpack,  # error: [invalid-type-form] "`typing.Unpack` requires exactly one argument when used in a type expression"
-    b: TypeGuard,  # error: [invalid-type-form] "`typing.TypeGuard` requires exactly one argument when used in a type expression"
-    c: TypeIs,  # error: [invalid-type-form] "`typing.TypeIs` requires exactly one argument when used in a type expression"
-    d: Concatenate,  # error: [invalid-type-form] "`typing.Concatenate` requires at least two arguments when used in a type expression"
-    e: ParamSpec,
-) -> None:
-    reveal_type(a)  # revealed: Unknown
-    reveal_type(b)  # revealed: Unknown
-    reveal_type(c)  # revealed: Unknown
-    reveal_type(d)  # revealed: Unknown
-
-    def foo(a_: e) -> None:
-        reveal_type(a_)  # revealed: @Todo(Support for `typing.ParamSpec`)
+        reveal_type(x)  # revealed: @Todo(Invalid or unsupported `KnownInstanceType` in `Type::to_type_expression`)
 ```

 ## Inheritance
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_type_qualifiers.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_type_qualifiers.md
@@ -1,6 +1,6 @@
 # Unsupported type qualifiers

-## Not yet fully supported
+## Not yet supported

 Several type qualifiers are unsupported by red-knot currently. However, we also don't emit
 false-positive errors if you use one in an annotation:
@@ -19,33 +19,6 @@ class Bar(TypedDict):
    z: ReadOnly[bytes]
 ```

-## Type expressions
-
-One thing that is supported is error messages for using type qualifiers in type expressions.
-
-```py
-from typing_extensions import Final, ClassVar, Required, NotRequired, ReadOnly
-
-def _(
-    a: (
-        Final  # error: [invalid-type-form] "Type qualifier `typing.Final` is not allowed in type expressions (only in annotation expressions)"
-        | int
-    ),
-    b: (
-        ClassVar  # error: [invalid-type-form] "Type qualifier `typing.ClassVar` is not allowed in type expressions (only in annotation expressions)"
-        | int
-    ),
-    c: Required,  # error: [invalid-type-form] "Type qualifier `typing.Required` is not allowed in type expressions (only in annotation expressions, and only with exactly one argument)"
-    d: NotRequired,  # error: [invalid-type-form] "Type qualifier `typing.NotRequired` is not allowed in type expressions (only in annotation expressions, and only with exactly one argument)"
-    e: ReadOnly,  # error: [invalid-type-form] "Type qualifier `typing.ReadOnly` is not allowed in type expressions (only in annotation expressions, and only with exactly one argument)"
-) -> None:
-    reveal_type(a)  # revealed: Unknown | int
-    reveal_type(b)  # revealed: Unknown | int
-    reveal_type(c)  # revealed: Unknown
-    reveal_type(d)  # revealed: Unknown
-    reveal_type(e)  # revealed: Unknown
-```
-
 ## Inheritance

 You can't inherit from a type qualifier.
--- a/crates/red_knot_python_semantic/resources/mdtest/assignment/annotations.md
+++ b/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]
--- a/crates/red_knot_python_semantic/resources/mdtest/assignment/augmented.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/assignment/augmented.md
@@ -10,10 +10,6 @@ reveal_type(x)  # revealed: Literal[2]
 x = 1.0
 x /= 2
 reveal_type(x)  # revealed: int | float
-
-x = (1, 2)
-x += (3, 4)
-reveal_type(x)  # revealed: tuple[Literal[1], Literal[2], Literal[3], Literal[4]]
 ```

 ## Dunder methods
@@ -165,18 +161,3 @@ def f(flag: bool, flag2: bool):

    reveal_type(f)  # revealed: int | str | float
 ```
-
-## Implicit dunder calls on class objects
-
-```py
-class Meta(type):
-    def __iadd__(cls, other: int) -> str:
-        return ""
-
-class C(metaclass=Meta): ...
-
-cls = C
-cls += 1
-
-reveal_type(cls)  # revealed: str
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/attributes.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/attributes.md
@@ -41,7 +41,8 @@ reveal_type(c_instance.declared_only)  # revealed: bytes

 reveal_type(c_instance.declared_and_bound)  # revealed: bool

-# error: [possibly-unbound-attribute]
+# We probably don't want to emit a diagnostic for this being possibly undeclared/unbound.
+# mypy and pyright do not show an error here.
 reveal_type(c_instance.possibly_undeclared_unbound)  # revealed: str

 # This assignment is fine, as we infer `Unknown | Literal[1, "a"]` for `inferred_from_value`.
@@ -338,10 +339,8 @@ class C:
        for self.z in NonIterable():
            pass

-# Iterable might be empty
-# error: [possibly-unbound-attribute]
 reveal_type(C().x)  # revealed: Unknown | int
-# error: [possibly-unbound-attribute]
+
 reveal_type(C().y)  # revealed: Unknown | str
 ```

@@ -349,11 +348,8 @@ reveal_type(C().y)  # revealed: Unknown | str

 ```py
 class ContextManager:
-    def __enter__(self) -> int | None:
-        return 1
-
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
-        pass
+    def __enter__(self) -> int | None: ...
+    def __exit__(self, exc_type, exc_value, traceback) -> None: ...

 class C:
    def __init__(self) -> None:
@@ -369,11 +365,8 @@ reveal_type(c_instance.x)  # revealed: Unknown | int | None

 ```py
 class ContextManager:
-    def __enter__(self) -> tuple[int | None, int]:
-        return 1, 2
-
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
-        pass
+    def __enter__(self) -> tuple[int | None, int]: ...
+    def __exit__(self, exc_type, exc_value, traceback) -> None: ...

 class C:
    def __init__(self) -> None:
@@ -410,8 +403,8 @@ reveal_type(c_instance.a)  # revealed: Unknown

 #### Conditionally declared / bound attributes

-Attributes are possibly unbound if they, or the method to which they are added are conditionally
-declared / bound.
+We currently do not raise a diagnostic or change behavior if an attribute is only conditionally
+defined. This is consistent with what mypy and pyright do.

 ```py
 def flag() -> bool:
@@ -429,13 +422,9 @@ class C:

 c_instance = C()

-# error: [possibly-unbound-attribute]
 reveal_type(c_instance.a1)  # revealed: str | None
-# error: [possibly-unbound-attribute]
 reveal_type(c_instance.a2)  # revealed: str | None
-# error: [possibly-unbound-attribute]
 reveal_type(c_instance.b1)  # revealed: Unknown | Literal[1]
-# error: [possibly-unbound-attribute]
 reveal_type(c_instance.b2)  # revealed: Unknown | Literal[1]
 ```

@@ -544,88 +533,10 @@ class C:
        if (2 + 3) < 4:
            self.x: str = "a"

-# error: [unresolved-attribute]
-reveal_type(C().x)  # revealed: Unknown
-```
-
-```py
-class C:
-    def __init__(self, cond: bool) -> None:
-        if True:
-            self.a = 1
-        else:
-            self.a = "a"
-
-        if False:
-            self.b = 2
-
-        if cond:
-            return
-
-        self.c = 3
-
-        self.d = 4
-        self.d = 5
-
-    def set_c(self, c: str) -> None:
-        self.c = c
-    if False:
-        def set_e(self, e: str) -> None:
-            self.e = e
-
-reveal_type(C(True).a)  # revealed: Unknown | Literal[1]
-# error: [unresolved-attribute]
-reveal_type(C(True).b)  # revealed: Unknown
-reveal_type(C(True).c)  # revealed: Unknown | Literal[3] | str
-# TODO: this attribute is possibly unbound
-reveal_type(C(True).d)  # revealed: Unknown | Literal[5]
-# error: [unresolved-attribute]
-reveal_type(C(True).e)  # revealed: Unknown
-```
-
-#### Attributes considered always bound
-
-```py
-class C:
-    def __init__(self, cond: bool):
-        self.x = 1
-        if cond:
-            raise ValueError("Something went wrong")
-
-        # We consider this attribute is always bound.
-        # This is because, it is not possible to access a partially-initialized object by normal means.
-        self.y = 2
-
-reveal_type(C(False).x)  # revealed: Unknown | Literal[1]
-reveal_type(C(False).y)  # revealed: Unknown | Literal[2]
-
-class C:
-    def __init__(self, b: bytes) -> None:
-        self.b = b
-
-        try:
-            s = b.decode()
-        except UnicodeDecodeError:
-            raise ValueError("Invalid UTF-8 sequence")
-
-        self.s = s
-
-reveal_type(C(b"abc").b)  # revealed: Unknown | bytes
-reveal_type(C(b"abc").s)  # revealed: Unknown | str
-
-class C:
-    def __init__(self, iter) -> None:
-        self.x = 1
-
-        for _ in iter:
-            pass
-
-        # The for-loop may not stop,
-        # but we consider the subsequent attributes to be definitely-bound.
-        self.y = 2
-
-reveal_type(C([]).x)  # revealed: Unknown | Literal[1]
-reveal_type(C([]).y)  # revealed: Unknown | Literal[2]
+# TODO: Ideally, this would result in a `unresolved-attribute` error. But mypy and pyright
+# do not support this either (for conditions that can only be resolved to `False` in type
+# inference), so it does not seem to be particularly important.
+reveal_type(C().x)  # revealed: str
 ```

 #### Diagnostics are reported for the right-hand side of attribute assignments
@@ -634,7 +545,6 @@ reveal_type(C([]).y)  # revealed: Unknown | Literal[2]
 class C:
    def __init__(self) -> None:
        # error: [too-many-positional-arguments]
-        # error: [invalid-argument-type]
        self.x: int = len(1, 2, 3)
 ```

@@ -781,10 +691,10 @@ class Base:
        self.defined_in_init: str | None = "value in base"

 class Intermediate(Base):
-    # Redeclaring base class attributes with the *same *type is fine:
+    # Re-declaring base class attributes with the *same *type is fine:
    base_class_attribute_1: str | None = None

-    # Redeclaring them with a *narrower type* is unsound, because modifications
+    # Re-declaring them with a *narrower type* is unsound, because modifications
    # through a `Base` reference could violate that constraint.
    #
    # Mypy does not report an error here, but pyright does: "… overrides symbol
@@ -796,7 +706,7 @@ class Intermediate(Base):
    # TODO: This should be an error
    base_class_attribute_2: str

-    # Redeclaring attributes with a *wider type* directly violates LSP.
+    # Re-declaring attributes with a *wider type* directly violates LSP.
    #
    # In this case, both mypy and pyright report an error.
    #
@@ -892,7 +802,7 @@ def _(flag1: bool, flag2: bool):
    reveal_type(C5.attr1)  # revealed: Unknown | Literal["metaclass value", "class value"]
 ```

-## Unions of attributes
+## Union of attributes

 If the (meta)class is a union type or if the attribute on the (meta) class has a union type, we
 infer those union types accordingly:
@@ -902,74 +812,77 @@ def _(flag: bool):
    if flag:
        class C1:
            x = 1
-            y: int = 1

    else:
        class C1:
            x = 2
-            y: int | str = "b"

    reveal_type(C1.x)  # revealed: Unknown | Literal[1, 2]
-    reveal_type(C1.y)  # revealed: int | str
-
-    C1.y = 100
-    # error: [invalid-assignment] "Object of type `Literal["problematic"]` is not assignable to attribute `y` on type `Literal[C1, C1]`"
-    C1.y = "problematic"

    class C2:
        if flag:
            x = 3
-            y: int = 3
        else:
            x = 4
-            y: int | str = "d"

    reveal_type(C2.x)  # revealed: Unknown | Literal[3, 4]
-    reveal_type(C2.y)  # revealed: int | str
-
-    C2.y = 100
-    # error: [invalid-assignment] "Object of type `None` is not assignable to attribute `y` of type `int | str`"
-    C2.y = None
-    # TODO: should be an error, needs more sophisticated union handling in `validate_attribute_assignment`
-    C2.y = "problematic"

    if flag:
        class Meta3(type):
            x = 5
-            y: int = 5

    else:
        class Meta3(type):
            x = 6
-            y: int | str = "f"

    class C3(metaclass=Meta3): ...
    reveal_type(C3.x)  # revealed: Unknown | Literal[5, 6]
-    reveal_type(C3.y)  # revealed: int | str
-
-    C3.y = 100
-    # error: [invalid-assignment] "Object of type `None` is not assignable to attribute `y` of type `int | str`"
-    C3.y = None
-    # TODO: should be an error, needs more sophisticated union handling in `validate_attribute_assignment`
-    C3.y = "problematic"

    class Meta4(type):
        if flag:
            x = 7
-            y: int = 7
        else:
            x = 8
-            y: int | str = "h"

    class C4(metaclass=Meta4): ...
    reveal_type(C4.x)  # revealed: Unknown | Literal[7, 8]
-    reveal_type(C4.y)  # revealed: int | str
+```

-    C4.y = 100
-    # error: [invalid-assignment] "Object of type `None` is not assignable to attribute `y` of type `int | str`"
-    C4.y = None
-    # TODO: should be an error, needs more sophisticated union handling in `validate_attribute_assignment`
-    C4.y = "problematic"
+## Inherited class attributes
+
+### Basic
+
+```py
+class A:
+    X = "foo"
+
+class B(A): ...
+class C(B): ...
+
+reveal_type(C.X)  # revealed: Unknown | Literal["foo"]
+```
+
+### Multiple inheritance
+
+```py
+class O: ...
+
+class F(O):
+    X = 56
+
+class E(O):
+    X = 42
+
+class D(O): ...
+class C(D, F): ...
+class B(E, D): ...
+class A(B, C): ...
+
+# revealed: tuple[Literal[A], Literal[B], Literal[E], Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
+reveal_type(A.__mro__)
+
+# `E` is earlier in the MRO than `F`, so we should use the type of `E.X`
+reveal_type(A.X)  # revealed: Unknown | Literal[42]
 ```

 ## Unions with possibly unbound paths
@@ -993,14 +906,8 @@ def _(flag1: bool, flag2: bool):
    # error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C1, C2, C3]` is possibly unbound"
    reveal_type(C.x)  # revealed: Unknown | Literal[1, 3]

-    # error: [invalid-assignment] "Object of type `Literal[100]` is not assignable to attribute `x` on type `Literal[C1, C2, C3]`"
-    C.x = 100
-
    # error: [possibly-unbound-attribute] "Attribute `x` on type `C1 | C2 | C3` is possibly unbound"
    reveal_type(C().x)  # revealed: Unknown | Literal[1, 3]
-
-    # error: [invalid-assignment] "Object of type `Literal[100]` is not assignable to attribute `x` on type `C1 | C2 | C3`"
-    C().x = 100
 ```

 ### Possibly-unbound within a class
@@ -1025,16 +932,10 @@ def _(flag: bool, flag1: bool, flag2: bool):
    # error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C1, C2, C3]` is possibly unbound"
    reveal_type(C.x)  # revealed: Unknown | Literal[1, 2, 3]

-    # error: [possibly-unbound-attribute]
-    C.x = 100
-
    # Note: we might want to consider ignoring possibly-unbound diagnostics for instance attributes eventually,
    # see the "Possibly unbound/undeclared instance attribute" section below.
    # error: [possibly-unbound-attribute] "Attribute `x` on type `C1 | C2 | C3` is possibly unbound"
    reveal_type(C().x)  # revealed: Unknown | Literal[1, 2, 3]
-
-    # error: [possibly-unbound-attribute]
-    C().x = 100
 ```

 ### Possibly-unbound within gradual types
@@ -1052,9 +953,6 @@ def _(flag: bool):
            x: int

    reveal_type(Derived().x)  # revealed: int | Any
-
-    Derived().x = 1
-    Derived().x = "a"
 ```

 ### Attribute possibly unbound on a subclass but not on a superclass
@@ -1069,10 +967,8 @@ def _(flag: bool):
            x = 2

    reveal_type(Bar.x)  # revealed: Unknown | Literal[2, 1]
-    Bar.x = 3

    reveal_type(Bar().x)  # revealed: Unknown | Literal[2, 1]
-    Bar().x = 3
 ```

 ### Attribute possibly unbound on a subclass and on a superclass
@@ -1090,14 +986,8 @@ def _(flag: bool):
    # error: [possibly-unbound-attribute]
    reveal_type(Bar.x)  # revealed: Unknown | Literal[2, 1]

-    # error: [possibly-unbound-attribute]
-    Bar.x = 3
-
    # error: [possibly-unbound-attribute]
    reveal_type(Bar().x)  # revealed: Unknown | Literal[2, 1]
-
-    # error: [possibly-unbound-attribute]
-    Bar().x = 3
 ```

 ### Possibly unbound/undeclared instance attribute
@@ -1116,9 +1006,6 @@ def _(flag: bool):

    # error: [possibly-unbound-attribute]
    reveal_type(Foo().x)  # revealed: int | Unknown
-
-    # error: [possibly-unbound-attribute]
-    Foo().x = 1
 ```

 #### Possibly unbound
@@ -1129,238 +1016,13 @@ def _(flag: bool):
        def __init(self):
            if flag:
                self.x = 1
-                self.y = "a"
-            else:
-                self.y = "b"

-    # error: [possibly-unbound-attribute]
+    # Emitting a diagnostic in a case like this is not something we support, and it's unclear
+    # if we ever will (or want to)
    reveal_type(Foo().x)  # revealed: Unknown | Literal[1]
-
-    # error: [possibly-unbound-attribute]
-    Foo().x = 2
-
-    reveal_type(Foo().y)  # revealed: Unknown | Literal["a", "b"]
-    Foo().y = "c"
 ```

-### Unions with all paths unbound
-
-If the symbol is unbound in all elements of the union, we detect that:
-
-```py
-def _(flag: bool):
-    class C1: ...
-    class C2: ...
-    C = C1 if flag else C2
-
-    # error: [unresolved-attribute] "Type `Literal[C1, C2]` has no attribute `x`"
-    reveal_type(C.x)  # revealed: Unknown
-
-    # TODO: This should ideally be a `unresolved-attribute` error. We need better union
-    # handling in `validate_attribute_assignment` for this.
-    # error: [invalid-assignment] "Object of type `Literal[1]` is not assignable to attribute `x` on type `Literal[C1, C2]`"
-    C.x = 1
-```
-
-## Inherited class attributes
-
-### Basic
-
-```py
-class A:
-    X = "foo"
-
-class B(A): ...
-class C(B): ...
-
-reveal_type(C.X)  # revealed: Unknown | Literal["foo"]
-
-C.X = "bar"
-```
-
-### Multiple inheritance
-
-```py
-class O: ...
-
-class F(O):
-    X = 56
-
-class E(O):
-    X = 42
-
-class D(O): ...
-class C(D, F): ...
-class B(E, D): ...
-class A(B, C): ...
-
-# revealed: tuple[Literal[A], Literal[B], Literal[E], Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
-reveal_type(A.__mro__)
-
-# `E` is earlier in the MRO than `F`, so we should use the type of `E.X`
-reveal_type(A.X)  # revealed: Unknown | Literal[42]
-
-A.X = 100
-```
-
-## Intersections of attributes
-
-### Attribute only available on one element
-
-```py
-from knot_extensions import Intersection
-
-class A:
-    x: int = 1
-
-class B: ...
-
-def _(a_and_b: Intersection[A, B]):
-    reveal_type(a_and_b.x)  # revealed: int
-
-    a_and_b.x = 2
-
-# Same for class objects
-def _(a_and_b: Intersection[type[A], type[B]]):
-    reveal_type(a_and_b.x)  # revealed: int
-
-    a_and_b.x = 2
-```
-
-### Attribute available on both elements
-
-```py
-from knot_extensions import Intersection
-
-class P: ...
-class Q: ...
-class R(P, Q): ...
-
-class A:
-    x: P = P()
-
-class B:
-    x: Q = Q()
-
-def _(a_and_b: Intersection[A, B]):
-    reveal_type(a_and_b.x)  # revealed: P & Q
-    a_and_b.x = R()
-
-# Same for class objects
-def _(a_and_b: Intersection[type[A], type[B]]):
-    reveal_type(a_and_b.x)  # revealed: P & Q
-    a_and_b.x = R()
-```
-
-### Possible unboundness
-
-```py
-from knot_extensions import Intersection
-
-class P: ...
-class Q: ...
-class R(P, Q): ...
-
-def _(flag: bool):
-    class A1:
-        if flag:
-            x: P = P()
-
-    class B1: ...
-
-    def inner1(a_and_b: Intersection[A1, B1]):
-        # error: [possibly-unbound-attribute]
-        reveal_type(a_and_b.x)  # revealed: P
-
-        # error: [possibly-unbound-attribute]
-        a_and_b.x = R()
-    # Same for class objects
-    def inner1_class(a_and_b: Intersection[type[A1], type[B1]]):
-        # error: [possibly-unbound-attribute]
-        reveal_type(a_and_b.x)  # revealed: P
-
-        # error: [possibly-unbound-attribute]
-        a_and_b.x = R()
-
-    class A2:
-        if flag:
-            x: P = P()
-
-    class B1:
-        x: Q = Q()
-
-    def inner2(a_and_b: Intersection[A2, B1]):
-        reveal_type(a_and_b.x)  # revealed: P & Q
-
-        # TODO: this should not be an error, we need better intersection
-        # handling in `validate_attribute_assignment` for this
-        # error: [possibly-unbound-attribute]
-        a_and_b.x = R()
-    # Same for class objects
-    def inner2_class(a_and_b: Intersection[type[A2], type[B1]]):
-        reveal_type(a_and_b.x)  # revealed: P & Q
-
-    class A3:
-        if flag:
-            x: P = P()
-
-    class B3:
-        if flag:
-            x: Q = Q()
-
-    def inner3(a_and_b: Intersection[A3, B3]):
-        # error: [possibly-unbound-attribute]
-        reveal_type(a_and_b.x)  # revealed: P & Q
-
-        # error: [possibly-unbound-attribute]
-        a_and_b.x = R()
-    # Same for class objects
-    def inner3_class(a_and_b: Intersection[type[A3], type[B3]]):
-        # error: [possibly-unbound-attribute]
-        reveal_type(a_and_b.x)  # revealed: P & Q
-
-        # error: [possibly-unbound-attribute]
-        a_and_b.x = R()
-
-    class A4: ...
-    class B4: ...
-
-    def inner4(a_and_b: Intersection[A4, B4]):
-        # error: [unresolved-attribute]
-        reveal_type(a_and_b.x)  # revealed: Unknown
-
-        # error: [invalid-assignment]
-        a_and_b.x = R()
-    # Same for class objects
-    def inner4_class(a_and_b: Intersection[type[A4], type[B4]]):
-        # error: [unresolved-attribute]
-        reveal_type(a_and_b.x)  # revealed: Unknown
-
-        # error: [invalid-assignment]
-        a_and_b.x = R()
-```
-
-### Intersection of implicit instance attributes
-
-```py
-from knot_extensions import Intersection
-
-class P: ...
-class Q: ...
-
-class A:
-    def __init__(self):
-        self.x: P = P()
-
-class B:
-    def __init__(self):
-        self.x: Q = Q()
-
-def _(a_and_b: Intersection[A, B]):
-    reveal_type(a_and_b.x)  # revealed: P & Q
-```
-
-## Attribute access on `Any`
+### Attribute access on `Any`

 The union of the set of types that `Any` could materialise to is equivalent to `object`. It follows
 from this that attribute access on `Any` resolves to `Any` if the attribute does not exist on
@@ -1373,7 +1035,7 @@ from typing import Any
 class Foo(Any): ...

 reveal_type(Foo.bar)  # revealed: Any
-reveal_type(Foo.__repr__)  # revealed: (def __repr__(self) -> str) & Any
+reveal_type(Foo.__repr__)  # revealed: Literal[__repr__] & Any
 ```

 Similar principles apply if `Any` appears in the middle of an inheritance hierarchy:
@@ -1391,149 +1053,18 @@ reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[B], Any, Literal[A
 reveal_type(C.x)  # revealed: Literal[1] & Any
 ```

-## Classes with custom `__getattr__` methods
+### Unions with all paths unbound

-### Basic
-
-If a type provides a custom `__getattr__` method, we use the return type of that method as the type
-for unknown attributes. Consider the following `CustomGetAttr` class:
+If the symbol is unbound in all elements of the union, we detect that:

 ```py
-from typing import Literal
+def _(flag: bool):
+    class C1: ...
+    class C2: ...
+    C = C1 if flag else C2

-def flag() -> bool:
-    return True
-
-class GetAttrReturnType: ...
-
-class CustomGetAttr:
-    class_attr: int = 1
-
-    if flag():
-        possibly_unbound: bytes = b"a"
-
-    def __init__(self) -> None:
-        self.instance_attr: str = "a"
-
-    def __getattr__(self, name: str) -> GetAttrReturnType:
-        return GetAttrReturnType()
-```
-
-We can access arbitrary attributes on instances of this class, and the type of the attribute will be
-`GetAttrReturnType`:
-
-```py
-c = CustomGetAttr()
-
-reveal_type(c.whatever)  # revealed: GetAttrReturnType
-```
-
-If an attribute is defined on the class, it takes precedence over the `__getattr__` method:
-
-```py
-reveal_type(c.class_attr)  # revealed: int
-```
-
-If the class attribute is possibly unbound, we union the type of the attribute with the fallback
-type of the `__getattr__` method:
-
-```py
-reveal_type(c.possibly_unbound)  # revealed: bytes | GetAttrReturnType
-```
-
-Instance attributes also take precedence over the `__getattr__` method:
-
-```py
-# Note: we could attempt to union with the fallback type of `__getattr__` here, as we currently do not
-# attempt to determine if instance attributes are always bound or not. Neither mypy nor pyright do this,
-# so it's not a priority.
-reveal_type(c.instance_attr)  # revealed: str
-```
-
-### Type of the `name` parameter
-
-If the `name` parameter of the `__getattr__` method is annotated with a (union of) literal type(s),
-we only consider the attribute access to be valid if the accessed attribute is one of them:
-
-```py
-from typing import Literal
-
-class Date:
-    def __getattr__(self, name: Literal["day", "month", "year"]) -> int:
-        return 0
-
-date = Date()
-
-reveal_type(date.day)  # revealed: int
-reveal_type(date.month)  # revealed: int
-reveal_type(date.year)  # revealed: int
-
-# error: [unresolved-attribute] "Type `Date` has no attribute `century`"
-reveal_type(date.century)  # revealed: Unknown
-```
-
-### `argparse.Namespace`
-
-A standard library example of a class with a custom `__getattr__` method is `argparse.Namespace`:
-
-```py
-import argparse
-
-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
+    # error: [unresolved-attribute] "Type `Literal[C1, C2]` has no attribute `x`"
+    reveal_type(C.x)  # revealed: Unknown
 ```

 ## Objects of all types have a `__class__` method
@@ -1588,8 +1119,6 @@ reveal_type(Foo.__class__)  # revealed: Literal[type]

 ## Module attributes

-### Basic
-
 `mod.py`:

 ```py
@@ -1624,7 +1153,7 @@ for mod.global_symbol in IntIterable():
    pass
 ```

-### Nested module attributes
+## Nested attributes

 `outer/__init__.py`:

@@ -1672,7 +1201,7 @@ Some attributes are special-cased, however:

 ```py
 reveal_type(f.__get__)  # revealed: <method-wrapper `__get__` of `f`>
-reveal_type(f.__call__)  # revealed: <method-wrapper `__call__` of `f`>
+reveal_type(f.__call__)  # revealed: <bound method `__call__` of `Literal[f]`>
 ```

 ### Int-literal attributes
@@ -1681,8 +1210,8 @@ Most attribute accesses on int-literal types are delegated to `builtins.int`, si
 integers are instances of that class:

 ```py
-reveal_type((2).bit_length)  # revealed: bound method Literal[2].bit_length() -> int
-reveal_type((2).denominator)  # revealed: Literal[1]
+reveal_type((2).bit_length)  # revealed: <bound method `bit_length` of `Literal[2]`>
+reveal_type((2).denominator)  # revealed: @Todo(@property)
 ```

 Some attributes are special-cased, however:
@@ -1698,10 +1227,8 @@ Most attribute accesses on bool-literal types are delegated to `builtins.bool`,
 bools are instances of that class:

 ```py
-# revealed: bound method Literal[True].__and__(**kwargs: @Todo(todo signature **kwargs)) -> @Todo(return type of overloaded function)
-reveal_type(True.__and__)
-# revealed: bound method Literal[False].__or__(**kwargs: @Todo(todo signature **kwargs)) -> @Todo(return type of overloaded function)
-reveal_type(False.__or__)
+reveal_type(True.__and__)  # revealed: <bound method `__and__` of `Literal[True]`>
+reveal_type(False.__or__)  # revealed: <bound method `__or__` of `Literal[False]`>
 ```

 Some attributes are special-cased, however:
@@ -1716,9 +1243,8 @@ reveal_type(False.real)  # revealed: Literal[0]
 All attribute access on literal `bytes` types is currently delegated to `builtins.bytes`:

 ```py
-reveal_type(b"foo".join)  # revealed: bound method Literal[b"foo"].join(iterable_of_bytes: @Todo(generics), /) -> bytes
-# revealed: bound method Literal[b"foo"].endswith(suffix: @Todo(Support for `typing.TypeAlias`), start: SupportsIndex | None = ellipsis, end: SupportsIndex | None = ellipsis, /) -> bool
-reveal_type(b"foo".endswith)
+reveal_type(b"foo".join)  # revealed: <bound method `join` of `Literal[b"foo"]`>
+reveal_type(b"foo".endswith)  # revealed: <bound method `endswith` of `Literal[b"foo"]`>
 ```

 ## Instance attribute edge cases
@@ -1853,37 +1379,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
@@ -1891,5 +1386,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
--- a/crates/red_knot_python_semantic/resources/mdtest/binary/custom.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/binary/custom.md
@@ -350,30 +350,30 @@ reveal_type(no() + no())  # revealed: Unknown
 def f():
    pass

-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f + f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `-` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `-` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f - f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `*` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `*` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f * f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `@` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `@` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f @ f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `/` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `/` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f / f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `%` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `%` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f % f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `**` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `**` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f**f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `<<` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `<<` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f << f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `>>` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `>>` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f >> f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `|` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `|` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f | f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `^` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `^` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f ^ f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `&` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `&` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f & f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `//` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `//` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f // f)  # revealed: Unknown
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/binary/instances.md
+++ b/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`
@@ -363,7 +363,7 @@ reveal_type(X() + Y())  # revealed: int

 ```py
 class NotBoolable:
-    __bool__: int = 3
+    __bool__ = 3

 a = NotBoolable()

@@ -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
@@ -439,12 +406,10 @@ A left-hand dunder method doesn't apply for the right-hand operand, or vice vers

 ```py
 class A:
-    def __add__(self, other) -> int:
-        return 1
+    def __add__(self, other) -> int: ...

 class B:
-    def __radd__(self, other) -> int:
-        return 1
+    def __radd__(self, other) -> int: ...

 class C: ...

@@ -466,7 +431,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]
--- a/crates/red_knot_python_semantic/resources/mdtest/binary/integers.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/binary/tuples.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/binary/tuples.md
@@ -1,22 +0,0 @@
-# Binary operations on tuples
-
-## Concatenation for heterogeneous tuples
-
-```py
-reveal_type((1, 2) + (3, 4))  # revealed: tuple[Literal[1], Literal[2], Literal[3], Literal[4]]
-reveal_type(() + (1, 2))  # revealed: tuple[Literal[1], Literal[2]]
-reveal_type((1, 2) + ())  # revealed: tuple[Literal[1], Literal[2]]
-reveal_type(() + ())  # revealed: tuple[()]
-
-def _(x: tuple[int, str], y: tuple[None, tuple[int]]):
-    reveal_type(x + y)  # revealed: tuple[int, str, None, tuple[int]]
-    reveal_type(y + x)  # revealed: tuple[None, tuple[int], int, str]
-```
-
-## Concatenation for homogeneous tuples
-
-```py
-def _(x: tuple[int, ...], y: tuple[str, ...]):
-    reveal_type(x + y)  # revealed: @Todo(full tuple[...] support)
-    reveal_type(x + (1, 2))  # revealed: @Todo(full tuple[...] support)
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/binary/unions.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/binary/unions.md
@@ -1,59 +0,0 @@
-# Binary operations on union types
-
-Binary operations on union types are only available if they are supported for all possible
-combinations of types:
-
-```py
-def f1(i: int, u: int | None):
-    # error: [unsupported-operator] "Operator `+` is unsupported between objects of type `int` and `int | None`"
-    reveal_type(i + u)  # revealed: Unknown
-    # error: [unsupported-operator] "Operator `+` is unsupported between objects of type `int | None` and `int`"
-    reveal_type(u + i)  # revealed: Unknown
-```
-
-`int` can be added to `int`, and `str` can be added to `str`, but expressions of type `int | str`
-cannot be added, because that would require addition of `int` and `str` or vice versa:
-
-```py
-def f2(i: int, s: str, int_or_str: int | str):
-    i + i
-    s + s
-    # error: [unsupported-operator] "Operator `+` is unsupported between objects of type `int | str` and `int | str`"
-    reveal_type(int_or_str + int_or_str)  # revealed: Unknown
-```
-
-However, if an operation is supported for all possible combinations, the result will be a union of
-the possible outcomes:
-
-```py
-from typing import Literal
-
-def f3(two_or_three: Literal[2, 3], a_or_b: Literal["a", "b"]):
-    reveal_type(two_or_three + two_or_three)  # revealed: Literal[4, 5, 6]
-    reveal_type(two_or_three**two_or_three)  # revealed: Literal[4, 8, 9, 27]
-
-    reveal_type(a_or_b + a_or_b)  # revealed: Literal["aa", "ab", "ba", "bb"]
-
-    reveal_type(two_or_three * a_or_b)  # revealed: Literal["aa", "bb", "aaa", "bbb"]
-```
-
-We treat a type annotation of `float` as a union of `int` and `float`, so union handling is relevant
-here:
-
-```py
-def f4(x: float, y: float):
-    reveal_type(x + y)  # revealed: int | float
-    reveal_type(x - y)  # revealed: int | float
-    reveal_type(x * y)  # revealed: int | float
-    reveal_type(x / y)  # revealed: int | 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
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/boundness_declaredness/public.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/boundness_declaredness/public.md
@@ -69,8 +69,7 @@ without raising an error.
 from typing import Any

 def any() -> Any: ...
-def flag() -> bool:
-    return True
+def flag() -> bool: ...

 a: int
 b: str
@@ -127,8 +126,7 @@ inferred types:
 from typing import Any

 def any() -> Any: ...
-def flag() -> bool:
-    return True
+def flag() -> bool: ...

 a = 1
 b = 2
@@ -166,8 +164,7 @@ error for both `a` and `b`:
 ```py
 from typing import Any

-def flag() -> bool:
-    return True
+def flag() -> bool: ...

 if flag():
    a: Any = 1
@@ -197,8 +194,7 @@ seems inconsistent when compared to the case just above.
 `mod.py`:

 ```py
-def flag() -> bool:
-    return True
+def flag() -> bool: ...

 if flag():
    a: int
@@ -252,8 +248,7 @@ inconsistent when compared to the "possibly-undeclared-and-possibly-unbound" cas
 `mod.py`:

 ```py
-def flag() -> bool:
-    return True
+def flag() -> bool: ...

 if flag:
    a = 1
--- a/crates/red_knot_python_semantic/resources/mdtest/call/annotation.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/annotation.md
@@ -1,43 +0,0 @@
-# `typing.Callable`
-
-```py
-from typing import Callable
-
-def _(c: Callable[[], int]):
-    reveal_type(c())  # revealed: int
-
-def _(c: Callable[[int, str], int]):
-    reveal_type(c(1, "a"))  # revealed: int
-
-    # error: [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["a"]`"
-    # error: [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[1]`"
-    reveal_type(c("a", 1))  # revealed: int
-```
-
-The `Callable` annotation can only be used to describe positional-only parameters.
-
-```py
-def _(c: Callable[[int, str], None]):
-    # error: [unknown-argument] "Argument `a` does not match any known parameter"
-    # error: [unknown-argument] "Argument `b` does not match any known parameter"
-    # error: [missing-argument] "No arguments provided for required parameters 1, 2"
-    reveal_type(c(a=1, b="b"))  # revealed: None
-```
-
-If the annotation uses a gradual form (`...`) for the parameter list, then it can accept any kind of
-parameter with any type.
-
-```py
-def _(c: Callable[..., int]):
-    reveal_type(c())  # revealed: int
-    reveal_type(c(1))  # revealed: int
-    reveal_type(c(1, "str", False, a=[1, 2], b=(3, 4)))  # revealed: int
-```
-
-An invalid `Callable` form can accept any parameters and will return `Unknown`.
-
-```py
-# error: [invalid-type-form]
-def _(c: Callable[42, str]):
-    reveal_type(c())  # revealed: Unknown
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/call/builtins.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/builtins.md
@@ -6,7 +6,7 @@
 class NotBool:
    __bool__ = None

-# error: [too-many-positional-arguments] "Too many positional arguments to class `bool`: expected 1, got 2"
+# TODO: We should emit an `invalid-argument` error here for `2` because `bool` only takes one argument.
 bool(1, 2)

 # TODO: We should emit an `unsupported-bool-conversion` error here because the argument doesn't implement `__bool__` correctly.
@@ -26,76 +26,12 @@ 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
+Other numbers of arguments are invalid (TODO -- these should emit a diagnostic)

 ```py
-# error: [no-matching-overload] "No overload of class `type` matches arguments"
 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]
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/call/callable_instance.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/callable_instance.md
@@ -25,8 +25,7 @@ reveal_type(b)  # revealed: Unknown
 def _(flag: bool):
    class PossiblyNotCallable:
        if flag:
-            def __call__(self) -> int:
-                return 1
+            def __call__(self) -> int: ...

    a = PossiblyNotCallable()
    result = a()  # error: "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
@@ -39,8 +38,7 @@ def _(flag: bool):
 def _(flag: bool):
    if flag:
        class PossiblyUnbound:
-            def __call__(self) -> int:
-                return 1
+            def __call__(self) -> int: ...

    # error: [possibly-unresolved-reference]
    a = PossiblyUnbound()
@@ -66,12 +64,11 @@ def _(flag: bool):
        if flag:
            __call__ = 1
        else:
-            def __call__(self) -> int:
-                return 1
+            def __call__(self) -> int: ...

    a = NonCallable()
    # error: [call-non-callable] "Object of type `Literal[1]` is not callable"
-    reveal_type(a())  # revealed: Unknown | int
+    reveal_type(a())  # revealed: int | Unknown
 ```

 ## Call binding errors
@@ -85,7 +82,7 @@ class C:

 c = C()

-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 2 (`x`) of bound method `__call__`; expected type `int`"
 reveal_type(c("foo"))  # revealed: int
 ```

@@ -99,7 +96,7 @@ class C:

 c = C()

-# error: 13 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `C`"
+# error: 13 [invalid-argument-type] "Object of type `C` cannot be assigned to parameter 1 (`self`) of bound method `__call__`; expected type `int`"
 reveal_type(c())  # revealed: int
 ```

--- a/crates/red_knot_python_semantic/resources/mdtest/call/constructor.md
+++ b/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] "Argument to this function is incorrect: Expected `int`, found `Literal["1"]`"
-    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] "Argument to this function is incorrect: Expected `int`, found `Literal["1"]`"
-    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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/call/dunder.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/dunder.md
@@ -185,7 +185,7 @@ def _(flag: bool):
                return str(key)
        else:
            def __getitem__(self, key: int) -> bytes:
-                return bytes()
+                return key

    c = C()
    reveal_type(c[0])  # revealed: str | bytes
@@ -198,34 +198,12 @@ def _(flag: bool):
    else:
        class D:
            def __getitem__(self, key: int) -> bytes:
-                return bytes()
+                return key

    d = D()
    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
--- a/crates/red_knot_python_semantic/resources/mdtest/call/function.md
+++ b/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
@@ -72,7 +73,7 @@ def _(flag: bool):
 def f(x: int) -> int:
    return 1

-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
 reveal_type(f("foo"))  # revealed: int
 ```

@@ -82,7 +83,7 @@ reveal_type(f("foo"))  # revealed: int
 def f(x: int, /) -> int:
    return 1

-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
 reveal_type(f("foo"))  # revealed: int
 ```

@@ -92,7 +93,7 @@ reveal_type(f("foo"))  # revealed: int
 def f(*args: int) -> int:
    return 1

-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `*args` of function `f`; expected type `int`"
 reveal_type(f("foo"))  # revealed: int
 ```

@@ -102,7 +103,7 @@ reveal_type(f("foo"))  # revealed: int
 def f(x: int) -> int:
    return 1

-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `x` of function `f`; expected type `int`"
 reveal_type(f(x="foo"))  # revealed: int
 ```

@@ -112,7 +113,7 @@ reveal_type(f(x="foo"))  # revealed: int
 def f(*, x: int) -> int:
    return 1

-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `x` of function `f`; expected type `int`"
 reveal_type(f(x="foo"))  # revealed: int
 ```

@@ -122,7 +123,7 @@ reveal_type(f(x="foo"))  # revealed: int
 def f(**kwargs: int) -> int:
    return 1

-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `**kwargs` of function `f`; expected type `int`"
 reveal_type(f(x="foo"))  # revealed: int
 ```

@@ -132,8 +133,8 @@ reveal_type(f(x="foo"))  # revealed: int
 def f(x: int = 1, y: str = "foo") -> int:
    return 1

-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[2]`"
-# error: 20 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["bar"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal[2]` cannot be assigned to parameter `y` of function `f`; expected type `str`"
+# error: 20 [invalid-argument-type] "Object of type `Literal["bar"]` cannot be assigned to parameter `x` of function `f`; expected type `int`"
 reveal_type(f(y=2, x="bar"))  # revealed: int
 ```

--- a/crates/red_knot_python_semantic/resources/mdtest/call/getattr_static.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/getattr_static.md
@@ -56,11 +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
-# revealed: def getattr_static(obj: object, attr: str, default: Any | None = ellipsis) -> Any
-reveal_type(inspect.getattr_static(inspect, "getattr_static"))
+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`:
@@ -115,7 +114,7 @@ inspect.getattr_static()
 # error: [missing-argument] "No argument provided for required parameter `attr`"
 inspect.getattr_static(C())

-# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[1]`"
+# error: [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 2 (`attr`) of function `getattr_static`; expected type `str`"
 inspect.getattr_static(C(), 1)

 # error: [too-many-positional-arguments] "Too many positional arguments to function `getattr_static`: expected 3, got 4"
@@ -144,9 +143,8 @@ from typing import Any
 def _(a: Any, tuple_of_any: tuple[Any]):
    reveal_type(inspect.getattr_static(a, "x", "default"))  # revealed: Any | Literal["default"]

-    # TODO: Ideally, this would just be `def index(self, value: Any, start: SupportsIndex = Literal[0], stop: SupportsIndex = int, /) -> int`
-    # revealed: (def index(self, value: Any, start: SupportsIndex = Literal[0], stop: SupportsIndex = int, /) -> int) | Literal["default"]
-    reveal_type(inspect.getattr_static(tuple_of_any, "index", "default"))
+    # TODO: Ideally, this would just be `Literal[index]`
+    reveal_type(inspect.getattr_static(tuple_of_any, "index", "default"))  # revealed: Literal[index] | Literal["default"]
 ```

 [official documentation]: https://docs.python.org/3/library/inspect.html#inspect.getattr_static
--- a/crates/red_knot_python_semantic/resources/mdtest/call/invalid_syntax.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/invalid_syntax.md
@@ -24,7 +24,7 @@ to the valid order:
 def f(**kw: int, x: str) -> int:
    return 1

-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[1]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `str`"
 reveal_type(f(1))  # revealed: int
 ```

@@ -38,7 +38,7 @@ def f(x: int = 1, y: str) -> int:
    return 1

 reveal_type(f(y="foo"))  # revealed: int
-# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
 # error: [missing-argument] "No argument provided for required parameter `y` of function `f`"
 reveal_type(f("foo"))  # revealed: int
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/call/methods.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/methods.md
@@ -32,20 +32,20 @@ the latter case, it returns a *bound method* object:
 ```py
 from inspect import getattr_static

-reveal_type(getattr_static(C, "f"))  # revealed: def f(self, x: int) -> str
+reveal_type(getattr_static(C, "f"))  # revealed: Literal[f]

 reveal_type(getattr_static(C, "f").__get__)  # revealed: <method-wrapper `__get__` of `f`>

-reveal_type(getattr_static(C, "f").__get__(None, C))  # revealed: def f(self, x: int) -> str
-reveal_type(getattr_static(C, "f").__get__(C(), C))  # revealed: bound method C.f(x: int) -> str
+reveal_type(getattr_static(C, "f").__get__(None, C))  # revealed: Literal[f]
+reveal_type(getattr_static(C, "f").__get__(C(), C))  # revealed: <bound method `f` of `C`>
 ```

 In conclusion, this is why we see the following two types when accessing the `f` attribute on the
 class object `C` and on an instance `C()`:

 ```py
-reveal_type(C.f)  # revealed: def f(self, x: int) -> str
-reveal_type(C().f)  # revealed: bound method C.f(x: int) -> str
+reveal_type(C.f)  # revealed: Literal[f]
+reveal_type(C().f)  # revealed: <bound method `f` of `C`>
 ```

 A bound method is a callable object that contains a reference to the `instance` that it was called
@@ -56,7 +56,7 @@ via `__func__`):
 bound_method = C().f

 reveal_type(bound_method.__self__)  # revealed: C
-reveal_type(bound_method.__func__)  # revealed: def f(self, x: int) -> str
+reveal_type(bound_method.__func__)  # revealed: Literal[f]
 ```

 When we call the bound method, the `instance` is implicitly passed as the first argument (`self`):
@@ -80,13 +80,13 @@ When we access methods from derived classes, they will be bound to instances of
 class D(C):
    pass

-reveal_type(D().f)  # revealed: bound method D.f(x: int) -> str
+reveal_type(D().f)  # revealed: <bound method `f` of `D`>
 ```

 If we access an attribute on a bound method object itself, it will defer to `types.MethodType`:

 ```py
-reveal_type(bound_method.__hash__)  # revealed: bound method MethodType.__hash__() -> int
+reveal_type(bound_method.__hash__)  # revealed: <bound method `__hash__` of `MethodType`>
 ```

 If an attribute is not available on the bound method object, it will be looked up on the underlying
@@ -181,10 +181,10 @@ class B:
        return "a"

 def f(a_or_b: A | B, any_or_a: Any | A):
-    reveal_type(a_or_b.f)  # revealed: (bound method A.f() -> int) | (bound method B.f() -> str)
+    reveal_type(a_or_b.f)  # revealed: <bound method `f` of `A`> | <bound method `f` of `B`>
    reveal_type(a_or_b.f())  # revealed: int | str

-    reveal_type(any_or_a.f)  # revealed: Any | (bound method A.f() -> int)
+    reveal_type(any_or_a.f)  # revealed: Any | <bound method `f` of `A`>
    reveal_type(any_or_a.f())  # revealed: Any | int
 ```

@@ -198,7 +198,7 @@ python-version = "3.12"
 ```py
 type IntOrStr = int | str

-reveal_type(IntOrStr.__or__)  # revealed: bound method typing.TypeAliasType.__or__(right: Any) -> _SpecialForm
+reveal_type(IntOrStr.__or__)  # revealed: <bound method `__or__` of `typing.TypeAliasType`>
 ```

 ## Error cases: Calling `__get__` for methods
@@ -235,23 +235,23 @@ method_wrapper(C(), None)
 method_wrapper(None, C)

 # Passing `None` without an `owner` argument is an
-# error: [no-matching-overload] "No overload of method wrapper `__get__` of function `f` matches arguments"
+# error: [missing-argument] "No argument provided for required parameter `owner`"
 method_wrapper(None)

 # Passing something that is not assignable to `type` as the `owner` argument is an
-# error: [no-matching-overload] "No overload of method wrapper `__get__` of function `f` matches arguments"
+# error: [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 2 (`owner`) of method wrapper `__get__` of function `f`; expected type `type`"
 method_wrapper(None, 1)

 # Passing `None` as the `owner` argument when `instance` is `None` is an
-# error: [no-matching-overload] "No overload of method wrapper `__get__` of function `f` matches arguments"
+# error: [invalid-argument-type] "Object of type `None` cannot be assigned to parameter 2 (`owner`) of method wrapper `__get__` of function `f`; expected type `type`"
 method_wrapper(None, None)

 # Calling `__get__` without any arguments is an
-# error: [no-matching-overload] "No overload of method wrapper `__get__` of function `f` matches arguments"
+# error: [missing-argument] "No argument provided for required parameter `instance`"
 method_wrapper()

 # Calling `__get__` with too many positional arguments is an
-# error: [no-matching-overload] "No overload of method wrapper `__get__` of function `f` matches arguments"
+# error: [too-many-positional-arguments] "Too many positional arguments to method wrapper `__get__` of function `f`: expected 2, got 3"
 method_wrapper(C(), C, "one too many")
 ```

@@ -270,7 +270,7 @@ class Meta(type):
 class C(metaclass=Meta):
    pass

-reveal_type(C.f)  # revealed: bound method Literal[C].f(arg: int) -> str
+reveal_type(C.f)  # revealed: <bound method `f` of `Literal[C]`>
 reveal_type(C.f(1))  # revealed: str
 ```

@@ -322,8 +322,8 @@ class C:
    def f(cls: type[C], x: int) -> str:
        return "a"

-reveal_type(C.f)  # revealed: bound method Literal[C].f(x: int) -> str
-reveal_type(C().f)  # revealed: bound method type[C].f(x: int) -> str
+reveal_type(C.f)  # revealed: <bound method `f` of `Literal[C]`>
+reveal_type(C().f)  # revealed: <bound method `f` of `type[C]`>
 ```

 The `cls` method argument is then implicitly passed as the first argument when calling the method:
@@ -350,7 +350,7 @@ class D:
        # This function is wrongly annotated, it should be `type[D]` instead of `D`
        pass

-# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `D`, found `Literal[D]`"
+# error: [invalid-argument-type] "Object of type `Literal[D]` cannot be assigned to parameter 1 (`cls`) of bound method `f`; expected type `D`"
 D.f()
 ```

@@ -360,8 +360,8 @@ When a class method is accessed on a derived class, it is bound to that derived
 class Derived(C):
    pass

-reveal_type(Derived.f)  # revealed: bound method Literal[Derived].f(x: int) -> str
-reveal_type(Derived().f)  # revealed: bound method type[Derived].f(x: int) -> str
+reveal_type(Derived.f)  # revealed: <bound method `f` of `Literal[Derived]`>
+reveal_type(Derived().f)  # revealed: <bound method `f` of `type[Derived]`>

 reveal_type(Derived.f(1))  # revealed: str
 reveal_type(Derived().f(1))  # revealed: str
@@ -379,22 +379,22 @@ class C:
    @classmethod
    def f(cls): ...

-reveal_type(getattr_static(C, "f"))  # revealed: def f(cls) -> Unknown
+reveal_type(getattr_static(C, "f"))  # revealed: Literal[f]
 reveal_type(getattr_static(C, "f").__get__)  # revealed: <method-wrapper `__get__` of `f`>
 ```

 But we correctly model how the `classmethod` descriptor works:

 ```py
-reveal_type(getattr_static(C, "f").__get__(None, C))  # revealed: bound method Literal[C].f() -> Unknown
-reveal_type(getattr_static(C, "f").__get__(C(), C))  # revealed: bound method Literal[C].f() -> Unknown
-reveal_type(getattr_static(C, "f").__get__(C()))  # revealed: bound method type[C].f() -> Unknown
+reveal_type(getattr_static(C, "f").__get__(None, C))  # revealed: <bound method `f` of `Literal[C]`>
+reveal_type(getattr_static(C, "f").__get__(C(), C))  # revealed: <bound method `f` of `Literal[C]`>
+reveal_type(getattr_static(C, "f").__get__(C()))  # revealed: <bound method `f` of `type[C]`>
 ```

 The `owner` argument takes precedence over the `instance` argument:

 ```py
-reveal_type(getattr_static(C, "f").__get__("dummy", C))  # revealed: bound method Literal[C].f() -> Unknown
+reveal_type(getattr_static(C, "f").__get__("dummy", C))  # revealed: <bound method `f` of `Literal[C]`>
 ```

 ### Classmethods mixed with other decorators
@@ -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
--- a/crates/red_knot_python_semantic/resources/mdtest/call/str_startswith.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/str_startswith.md
@@ -1,50 +0,0 @@
-# `str.startswith`
-
-We special-case `str.startswith` to allow inference of precise Boolean literal types, because those
-are used in [`sys.platform` checks].
-
-```py
-reveal_type("abc".startswith(""))  # revealed: Literal[True]
-reveal_type("abc".startswith("a"))  # revealed: Literal[True]
-reveal_type("abc".startswith("ab"))  # revealed: Literal[True]
-reveal_type("abc".startswith("abc"))  # revealed: Literal[True]
-
-reveal_type("abc".startswith("abcd"))  # revealed: Literal[False]
-reveal_type("abc".startswith("bc"))  # revealed: Literal[False]
-
-reveal_type("AbC".startswith(""))  # revealed: Literal[True]
-reveal_type("AbC".startswith("A"))  # revealed: Literal[True]
-reveal_type("AbC".startswith("Ab"))  # revealed: Literal[True]
-reveal_type("AbC".startswith("AbC"))  # revealed: Literal[True]
-
-reveal_type("AbC".startswith("a"))  # revealed: Literal[False]
-reveal_type("AbC".startswith("aB"))  # revealed: Literal[False]
-
-reveal_type("".startswith(""))  # revealed: Literal[True]
-
-reveal_type("".startswith(" "))  # revealed: Literal[False]
-```
-
-Make sure that we fall back to `bool` for more complex cases:
-
-```py
-reveal_type("abc".startswith("b", 1))  # revealed: bool
-reveal_type("abc".startswith("bc", 1, 3))  # revealed: bool
-
-reveal_type("abc".startswith(("a", "x")))  # revealed: bool
-```
-
-And similiarly, we should still infer `bool` if the instance or the prefix are not string literals:
-
-```py
-from typing_extensions import LiteralString
-
-def _(string_instance: str, literalstring: LiteralString):
-    reveal_type(string_instance.startswith("a"))  # revealed: bool
-    reveal_type(literalstring.startswith("a"))  # revealed: bool
-
-    reveal_type("a".startswith(string_instance))  # revealed: bool
-    reveal_type("a".startswith(literalstring))  # revealed: bool
-```
-
-[`sys.platform` checks]: https://docs.python.org/3/library/sys.html#sys.platform
--- a/crates/red_knot_python_semantic/resources/mdtest/call/subclass_of.md
+++ b/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] "Argument to this function is incorrect: Expected `int`, found `Literal["a"]`"
+    # 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
 ```

--- a/crates/red_knot_python_semantic/resources/mdtest/call/union.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/union.md
@@ -40,7 +40,7 @@ def _(flag: bool):
        def f() -> int:
            return 1
    x = f()  # error: [call-non-callable] "Object of type `Literal[1]` is not callable"
-    reveal_type(x)  # revealed: Unknown | int
+    reveal_type(x)  # revealed: int | Unknown
 ```

 ## Multiple non-callable elements in a union
@@ -58,7 +58,7 @@ def _(flag: bool, flag2: bool):
            return 1
    # TODO we should mention all non-callable elements of the union
    # error: [call-non-callable] "Object of type `Literal[1]` is not callable"
-    # revealed: Unknown | int
+    # revealed: int | Unknown
    reveal_type(f())
 ```

@@ -82,19 +82,15 @@ def _(flag: bool):
 Calling a union where the arguments don't match the signature of all variants.

 ```py
-def f1(a: int) -> int:
-    return a
-
-def f2(a: str) -> str:
-    return a
-
+def f1(a: int) -> int: ...
+def f2(a: str) -> str: ...
 def _(flag: bool):
    if flag:
        f = f1
    else:
        f = f2

-    # error: [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[3]`"
+    # error: [invalid-argument-type] "Object of type `Literal[3]` cannot be assigned to parameter 1 (`a`) of function `f2`; expected type `str`"
    x = f(3)
    reveal_type(x)  # revealed: int | str
 ```
@@ -148,30 +144,3 @@ def _(flag: bool):
    x = f(3)
    reveal_type(x)  # revealed: Unknown
 ```
-
-## Union including a special-cased function
-
-```py
-def _(flag: bool):
-    if flag:
-        f = str
-    else:
-        f = repr
-    reveal_type(str("string"))  # revealed: Literal["string"]
-    reveal_type(repr("string"))  # revealed: Literal["'string'"]
-    reveal_type(f("string"))  # revealed: Literal["string", "'string'"]
-```
-
-## Cannot use an argument as both a value and a type form
-
-```py
-from knot_extensions import is_fully_static
-
-def _(flag: bool):
-    if flag:
-        f = repr
-    else:
-        f = is_fully_static
-    # error: [conflicting-argument-forms] "Argument is used as both a value and a type form in call"
-    reveal_type(f(int))  # revealed: str | Literal[True]
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/instances/membership_test.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/instances/membership_test.md
@@ -191,7 +191,7 @@ It may also be more appropriate to use `unsupported-operator` as the error code.

 ```py
 class NotBoolable:
-    __bool__: int = 3
+    __bool__ = 3

 class WithContains:
    def __contains__(self, item) -> NotBoolable:
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/instances/rich_comparison.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/instances/rich_comparison.md
@@ -154,7 +154,7 @@ reveal_type(B() >= A())  # revealed: LeReturnType

 class C:
    def __gt__(self, other: C) -> EqReturnType:
-        return EqReturnType()
+        return 42

    def __ge__(self, other: C) -> NeReturnType:
        return NeReturnType()
@@ -355,7 +355,7 @@ element) of a chained comparison.

 ```py
 class NotBoolable:
-    __bool__: int = 3
+    __bool__ = 3

 class Comparable:
    def __lt__(self, item) -> NotBoolable:
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/intersections.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/intersections.md
@@ -110,8 +110,7 @@ given operator:

 ```py
 class Container:
-    def __contains__(self, x) -> bool:
-        return False
+    def __contains__(self, x) -> bool: ...

 class NonContainer: ...

@@ -131,8 +130,7 @@ unsupported for the given operator:

 ```py
 class Container:
-    def __contains__(self, x) -> bool:
-        return False
+    def __contains__(self, x) -> bool: ...

 class NonContainer: ...

--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/non_bool_returns.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/non_bool_returns.md
@@ -22,19 +22,14 @@ Walking through examples:
 from __future__ import annotations

 class A:
-    def __lt__(self, other) -> A:
-        return self
-
-    def __gt__(self, other) -> bool:
-        return False
+    def __lt__(self, other) -> A: ...
+    def __gt__(self, other) -> bool: ...

 class B:
-    def __lt__(self, other) -> B:
-        return self
+    def __lt__(self, other) -> B: ...

 class C:
-    def __lt__(self, other) -> C:
-        return self
+    def __lt__(self, other) -> C: ...

 x = A() < B() < C()
 reveal_type(x)  # revealed: A & ~AlwaysTruthy | B
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/tuples.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/tuples.md
@@ -197,7 +197,7 @@ class LtReturnTypeOnB: ...

 class B:
    def __lt__(self, o: B) -> LtReturnTypeOnB:
-        return LtReturnTypeOnB()
+        return set()

 reveal_type((A(), B()) < (A(), B()))  # revealed: LtReturnType | LtReturnTypeOnB | Literal[False]
 ```
@@ -355,7 +355,7 @@ def compute_chained_comparison():

 ```py
 class NotBoolable:
-    __bool__: int = 5
+    __bool__ = 5

 class Comparable:
    def __lt__(self, other) -> NotBoolable:
@@ -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
+
 # error: [unsupported-bool-conversion]
 (A(),) == (A(),)
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/comprehensions/basic.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comprehensions/basic.md
@@ -104,8 +104,7 @@ class Iterator:
        return 42

 class Iterable:
-    def __iter__(self) -> Iterator:
-        return Iterator()
+    def __iter__(self) -> Iterator: ...

 # This is fine:
 x = [*Iterable()]
--- a/crates/red_knot_python_semantic/resources/mdtest/conditional/if_expression.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/conditional/if_expression.md
@@ -40,7 +40,7 @@ def _(flag: bool):

 ```py
 class NotBoolable:
-    __bool__: int = 3
+    __bool__ = 3

 # error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`; its `__bool__` method isn't callable"
 3 if NotBoolable() else 4
--- a/crates/red_knot_python_semantic/resources/mdtest/conditional/if_statement.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/conditional/if_statement.md
@@ -152,7 +152,7 @@ def _(flag: bool):

 ```py
 class NotBoolable:
-    __bool__: int = 3
+    __bool__ = 3

 # error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`; its `__bool__` method isn't callable"
 if NotBoolable():
--- a/crates/red_knot_python_semantic/resources/mdtest/conditional/match.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/conditional/match.md
@@ -44,245 +44,11 @@ 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
 class NotBoolable:
-    __bool__: int = 3
+    __bool__ = 3

 def _(target: int, flag: NotBoolable):
    y = 1
--- a/crates/red_knot_python_semantic/resources/mdtest/decorators.md
+++ b/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] "Argument to this function is incorrect: Expected `int`, found `def f(x) -> Unknown`"
-@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): ...
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/descriptor_protocol.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/descriptor_protocol.md
@@ -6,9 +6,7 @@ A descriptor is an attribute value that has one of the methods in the descriptor
 methods are `__get__()`, `__set__()`, and `__delete__()`. If any of those methods are defined for an
 attribute, it is said to be a descriptor.

-## Basic properties
-
-### Example
+## Basic example

 An introductory example, modeled after a [simple example] in the primer on descriptors, involving a
 descriptor that returns a constant value:
@@ -32,26 +30,18 @@ reveal_type(c.ten)  # revealed: Literal[10]

 reveal_type(C.ten)  # revealed: Literal[10]

-# This is fine:
+# These are fine:
 c.ten = 10
-
-# error: [invalid-assignment] "Invalid assignment to data descriptor attribute `ten` on type `C` with custom `__set__` method"
-c.ten = 11
-```
-
-When assigning to the `ten` attribute from the class object, we get an error. The descriptor
-protocol is *not* triggered in this case. Since the attribute is declared as `Ten` in the class
-body, we do not allow these assignments, preventing users from accidentally overwriting the data
-descriptor, which is what would happen at runtime:
-
-```py
-# error: [invalid-assignment] "Object of type `Literal[10]` is not assignable to attribute `ten` of type `Ten`"
 C.ten = 10
-# error: [invalid-assignment] "Object of type `Literal[11]` is not assignable to attribute `ten` of type `Ten`"
+
+# error: [invalid-assignment] "Object of type `Literal[11]` is not assignable to attribute `ten` of type `Literal[10]`"
+c.ten = 11
+
+# error: [invalid-assignment] "Object of type `Literal[11]` is not assignable to attribute `ten` of type `Literal[10]`"
 C.ten = 11
 ```

-### Different types for `__get__` and `__set__`
+## Different types for `__get__` and `__set__`

 The return type of `__get__` and the value type of `__set__` can be different:

@@ -74,17 +64,19 @@ c = C()
 reveal_type(c.flexible_int)  # revealed: int | None

 c.flexible_int = 42  # okay
+# TODO: This should not be an error
+# error: [invalid-assignment]
 c.flexible_int = "42"  # also okay!

 reveal_type(c.flexible_int)  # revealed: int | None

-# error: [invalid-assignment] "Invalid assignment to data descriptor attribute `flexible_int` on type `C` with custom `__set__` method"
+# TODO: This should be an error
 c.flexible_int = None  # not okay

 reveal_type(c.flexible_int)  # revealed: int | None
 ```

-### Data and non-data descriptors
+## Data and non-data descriptors

 Descriptors that define `__set__` or `__delete__` are called *data descriptors*. An example of a
 data descriptor is a `property` with a setter and/or a deleter. Descriptors that only define
@@ -139,84 +131,6 @@ reveal_type(C.non_data_descriptor)  # revealed: Unknown | Literal["non-data"]
 C.data_descriptor = "something else"  # This is okay
 ```

-### Partial fall back
-
-Our implementation of the descriptor protocol takes into account that symbols can be possibly
-unbound. In those cases, we fall back to lower precedence steps of the descriptor protocol and union
-all possible results accordingly. We start by defining a data and a non-data descriptor:
-
-```py
-from typing import Literal
-
-class DataDescriptor:
-    def __get__(self, instance: object, owner: type | None = None) -> Literal["data"]:
-        return "data"
-
-    def __set__(self, instance: object, value: int) -> None:
-        pass
-
-class NonDataDescriptor:
-    def __get__(self, instance: object, owner: type | None = None) -> Literal["non-data"]:
-        return "non-data"
-```
-
-Then, we demonstrate that we fall back to an instance attribute if a data descriptor is possibly
-unbound:
-
-```py
-def f1(flag: bool):
-    class C1:
-        if flag:
-            attr = DataDescriptor()
-
-        def f(self):
-            self.attr = "normal"
-
-    reveal_type(C1().attr)  # revealed: Unknown | Literal["data", "normal"]
-
-    # Assigning to the attribute also causes no `possibly-unbound` diagnostic:
-    C1().attr = 1
-```
-
-We never treat implicit instance attributes as definitely bound, so we fall back to the non-data
-descriptor here:
-
-```py
-class C2:
-    def f(self):
-        self.attr = "normal"
-    attr = NonDataDescriptor()
-
-reveal_type(C2().attr)  # revealed: Unknown | Literal["non-data", "normal"]
-
-# Assignments always go to the instance attribute in this case
-C2().attr = 1
-```
-
-### Descriptors only work when used as class variables
-
-Descriptors only work when used as class variables. When put in instances, they have no effect.
-
-```py
-from typing import Literal
-
-class Ten:
-    def __get__(self, instance: object, owner: type | None = None) -> Literal[10]:
-        return 10
-
-class C:
-    def __init__(self):
-        self.ten: Ten = Ten()
-
-reveal_type(C().ten)  # revealed: Ten
-
-C().ten = Ten()
-
-# The instance attribute is declared as `Ten`, so this is an
-# error: [invalid-assignment] "Object of type `Literal[10]` is not assignable to attribute `ten` of type `Ten`"
-C().ten = 10
-```
-
 ## Descriptor protocol for class objects

 When attributes are accessed on a class object, the following [precedence chain] is used:
@@ -236,7 +150,7 @@ class DataDescriptor:
    def __get__(self, instance: object, owner: type | None = None) -> Literal["data"]:
        return "data"

-    def __set__(self, instance: object, value: int) -> None:
+    def __set__(self, instance: object, value: str) -> None:
        pass

 class NonDataDescriptor:
@@ -263,28 +177,7 @@ reveal_type(C1.class_data_descriptor)  # revealed: Literal["data"]
 reveal_type(C1.class_non_data_descriptor)  # revealed: Literal["non-data"]
 ```

-Assignments to class object attribute only trigger the descriptor protocol if the data descriptor is
-on the metaclass:
-
-```py
-C1.meta_data_descriptor = 1
-
-# error: [invalid-assignment] "Invalid assignment to data descriptor attribute `meta_data_descriptor` on type `Literal[C1]` with custom `__set__` method"
-C1.meta_data_descriptor = "invalid"
-```
-
-When writing to a class-level data descriptor from the class object itself, the descriptor protocol
-is *not* triggered (this is in contrast to what happens when you read class-level descriptor
-attributes!). So the following assignment does not call `__set__`. At runtime, the assignment would
-overwrite the data descriptor, but the attribute is declared as `DataDescriptor` in the class body,
-so we do not allow this:
-
-```py
-# error: [invalid-assignment] "Object of type `Literal[1]` is not assignable to attribute `class_data_descriptor` of type `DataDescriptor`"
-C1.class_data_descriptor = 1
-```
-
-We now demonstrate that a *metaclass data descriptor* takes precedence over all class-level
+Next, we demonstrate that a *metaclass data descriptor* takes precedence over all class-level
 attributes:

 ```py
@@ -305,14 +198,6 @@ class C2(metaclass=Meta2):

 reveal_type(C2.meta_data_descriptor1)  # revealed: Literal["data"]
 reveal_type(C2.meta_data_descriptor2)  # revealed: Literal["data"]
-
-C2.meta_data_descriptor1 = 1
-C2.meta_data_descriptor2 = 1
-
-# error: [invalid-assignment]
-C2.meta_data_descriptor1 = "invalid"
-# error: [invalid-assignment]
-C2.meta_data_descriptor2 = "invalid"
 ```

 On the other hand, normal metaclass attributes and metaclass non-data descriptors are shadowed by
@@ -367,16 +252,6 @@ def _(flag: bool):
    reveal_type(C5.meta_data_descriptor1)  # revealed: Literal["data", "value on class"]
    # error: [possibly-unbound-attribute]
    reveal_type(C5.meta_data_descriptor2)  # revealed: Literal["data"]
-
-    # TODO: We currently emit two diagnostics here, corresponding to the two states of `flag`. The diagnostics are not
-    # wrong, but they could be subsumed under a higher-level diagnostic.
-
-    # error: [invalid-assignment] "Invalid assignment to data descriptor attribute `meta_data_descriptor1` on type `Literal[C5]` with custom `__set__` method"
-    # error: [invalid-assignment] "Object of type `None` is not assignable to attribute `meta_data_descriptor1` of type `Literal["value on class"]`"
-    C5.meta_data_descriptor1 = None
-
-    # error: [possibly-unbound-attribute]
-    C5.meta_data_descriptor2 = 1
 ```

 When a class-level attribute is possibly unbound, we union its (descriptor protocol) type with the
@@ -429,11 +304,143 @@ def _(flag: bool):
    reveal_type(C7.union_of_metaclass_data_descriptor_and_attribute)  # revealed: Literal["data", 2]
    reveal_type(C7.union_of_class_attributes)  # revealed: Literal[1, 2]
    reveal_type(C7.union_of_class_data_descriptor_and_attribute)  # revealed: Literal["data", 2]
+```

-    C7.union_of_metaclass_attributes = 2 if flag else 1
-    C7.union_of_metaclass_data_descriptor_and_attribute = 2 if flag else 100
-    C7.union_of_class_attributes = 2 if flag else 1
-    C7.union_of_class_data_descriptor_and_attribute = 2 if flag else DataDescriptor()
+## Partial fall back
+
+Our implementation of the descriptor protocol takes into account that symbols can be possibly
+unbound. In those cases, we fall back to lower precedence steps of the descriptor protocol and union
+all possible results accordingly. We start by defining a data and a non-data descriptor:
+
+```py
+from typing import Literal
+
+class DataDescriptor:
+    def __get__(self, instance: object, owner: type | None = None) -> Literal["data"]:
+        return "data"
+
+    def __set__(self, instance: object, value: int) -> None:
+        pass
+
+class NonDataDescriptor:
+    def __get__(self, instance: object, owner: type | None = None) -> Literal["non-data"]:
+        return "non-data"
+```
+
+Then, we demonstrate that we fall back to an instance attribute if a data descriptor is possibly
+unbound:
+
+```py
+def f1(flag: bool):
+    class C1:
+        if flag:
+            attr = DataDescriptor()
+
+        def f(self):
+            self.attr = "normal"
+
+    reveal_type(C1().attr)  # revealed: Unknown | Literal["data", "normal"]
+```
+
+We never treat implicit instance attributes as definitely bound, so we fall back to the non-data
+descriptor here:
+
+```py
+def f2(flag: bool):
+    class C2:
+        def f(self):
+            self.attr = "normal"
+        attr = NonDataDescriptor()
+
+    reveal_type(C2().attr)  # revealed: Unknown | Literal["non-data", "normal"]
+```
+
+## Built-in `property` descriptor
+
+The built-in `property` decorator creates a descriptor. The names for attribute reads/writes are
+determined by the return type of the `name` method and the parameter type of the setter,
+respectively.
+
+```py
+class C:
+    _name: str | None = None
+
+    @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
+
+c = C()
+
+reveal_type(c._name)  # revealed: str | None
+
+# 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
+
+# TODO: this should be an error, but with a proper error message
+# error: [invalid-assignment] "Object of type `Literal[42]` is not assignable to attribute `name` of type `<bound method `name` of `C`>`"
+c.name = 42
+```
+
+## Built-in `classmethod` descriptor
+
+Similarly to `property`, `classmethod` decorator creates an implicit descriptor that binds the first
+argument to the class instead of the instance.
+
+```py
+class C:
+    def __init__(self, value: str) -> None:
+        self._name: str = value
+
+    @classmethod
+    def factory(cls, value: str) -> "C":
+        return cls(value)
+
+    @classmethod
+    def get_name(cls) -> str:
+        return cls.__name__
+
+c1 = C.factory("test")  # okay
+
+reveal_type(c1)  # revealed: C
+
+reveal_type(C.get_name())  # revealed: str
+
+reveal_type(C("42").get_name())  # revealed: str
+```
+
+## Descriptors only work when used as class variables
+
+From the descriptor guide:
+
+> Descriptors only work when used as class variables. When put in instances, they have no effect.
+
+```py
+from typing import Literal
+
+class Ten:
+    def __get__(self, instance: object, owner: type | None = None) -> Literal[10]:
+        return 10
+
+class C:
+    def __init__(self):
+        self.ten: Ten = Ten()
+
+reveal_type(C().ten)  # revealed: Ten
 ```

 ## Descriptors distinguishing between class and instance access
@@ -466,173 +473,30 @@ reveal_type(C.d)  # revealed: LiteralString
 reveal_type(C().d)  # revealed: LiteralString
 ```

-## Descriptor protocol for dunder methods
+## Undeclared descriptor arguments

-Dunder methods are always looked up on the meta-type. There is no instance fallback. This means that
-an implicit dunder call on an instance-like object will not only look up the dunder method on the
-class object, without considering instance attributes. And an implicit dunder call on a class object
-will look up the dunder method on the metaclass, without considering class attributes.
+If a descriptor attribute is not declared, we union with `Unknown`, just like for regular
+attributes, since that attribute could be overwritten externally. Even a data descriptor with a
+`__set__` method can be overwritten when accessed through a class object.

 ```py
-class SomeCallable:
-    def __call__(self, x: int) -> str:
-        return "a"
-
 class Descriptor:
-    def __get__(self, instance: object, owner: type | None = None) -> SomeCallable:
-        return SomeCallable()
+    def __get__(self, instance: object, owner: type | None = None) -> int:
+        return 1

-class B:
-    __call__: Descriptor = Descriptor()
+    def __set__(self, instance: object, value: int) -> None:
+        pass

-b_instance = B()
-reveal_type(b_instance(1))  # revealed: str
-
-b_instance("bla")  # error: [invalid-argument-type]
-```
-
-## Special descriptors
-
-### Built-in `property` descriptor
-
-The built-in `property` decorator creates a descriptor. The names for attribute reads/writes are
-determined by the return type of the `name` method and the parameter type of the setter,
-respectively.
-
-```py
 class C:
-    _name: str | None = None
+    descriptor = Descriptor()

-    @property
-    def name(self) -> str:
-        return self._name or "Unset"
+C.descriptor = "something else"

-    @name.setter
-    def name(self, value: str | None) -> None:
-        self._value = value
-
-c = C()
-
-reveal_type(c._name)  # revealed: str | None
-reveal_type(c.name)  # revealed: str
-reveal_type(C.name)  # revealed: property
-
-c.name = "new"
-c.name = None
-
-# error: [invalid-assignment] "Invalid assignment to data descriptor attribute `name` on type `C` with custom `__set__` method"
-c.name = 42
+# This could also be `Literal["something else"]` if we support narrowing of attribute types based on assignments
+reveal_type(C.descriptor)  # revealed: Unknown | int
 ```

-### Built-in `classmethod` descriptor
-
-Similarly to `property`, `classmethod` decorator creates an implicit descriptor that binds the first
-argument to the class instead of the instance.
-
-```py
-class C:
-    def __init__(self, value: str) -> None:
-        self._name: str = value
-
-    @classmethod
-    def factory(cls, value: str) -> "C":
-        return cls(value)
-
-    @classmethod
-    def get_name(cls) -> str:
-        return cls.__name__
-
-c1 = C.factory("test")  # okay
-
-reveal_type(c1)  # revealed: C
-
-reveal_type(C.get_name())  # revealed: str
-
-reveal_type(C("42").get_name())  # revealed: str
-```
-
-### Functions as descriptors
-
-Functions are descriptors because they implement a `__get__` method. This is crucial in making sure
-that method calls work as expected. See [this test suite](./call/methods.md) for more information.
-Here, we only demonstrate how `__get__` works on functions:
-
-```py
-from inspect import getattr_static
-
-def f(x: object) -> str:
-    return "a"
-
-reveal_type(f)  # revealed: def f(x: object) -> str
-reveal_type(f.__get__)  # revealed: <method-wrapper `__get__` of `f`>
-reveal_type(f.__get__(None, type(f)))  # revealed: def f(x: object) -> str
-reveal_type(f.__get__(None, type(f))(1))  # revealed: str
-
-wrapper_descriptor = getattr_static(f, "__get__")
-
-reveal_type(wrapper_descriptor)  # revealed: <wrapper-descriptor `__get__` of `function` objects>
-reveal_type(wrapper_descriptor(f, None, type(f)))  # revealed: def f(x: object) -> str
-
-# Attribute access on the method-wrapper `f.__get__` falls back to `MethodWrapperType`:
-reveal_type(f.__get__.__hash__)  # revealed: bound method MethodWrapperType.__hash__() -> int
-
-# Attribute access on the wrapper-descriptor falls back to `WrapperDescriptorType`:
-reveal_type(wrapper_descriptor.__qualname__)  # revealed: str
-```
-
-We can also bind the free function `f` to an instance of a class `C`:
-
-```py
-class C: ...
-
-bound_method = wrapper_descriptor(f, C(), C)
-
-reveal_type(bound_method)  # revealed: bound method C.f() -> str
-```
-
-We can then call it, and the instance of `C` is implicitly passed to the first parameter of `f`
-(`x`):
-
-```py
-reveal_type(bound_method())  # revealed: str
-```
-
-Finally, we test some error cases for the call to the wrapper descriptor:
-
-```py
-# Calling the wrapper descriptor without any arguments is an
-# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
-wrapper_descriptor()
-
-# Calling it without the `instance` argument is an also an
-# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
-wrapper_descriptor(f)
-
-# Calling it without the `owner` argument if `instance` is not `None` is an
-# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
-wrapper_descriptor(f, None)
-
-# But calling it with an instance is fine (in this case, the `owner` argument is optional):
-wrapper_descriptor(f, C())
-
-# Calling it with something that is not a `FunctionType` as the first argument is an
-# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
-wrapper_descriptor(1, None, type(f))
-
-# Calling it with something that is not a `type` as the `owner` argument is an
-# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
-wrapper_descriptor(f, None, f)
-
-# Calling it with too many positional arguments is an
-# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
-wrapper_descriptor(f, None, type(f), "one too many")
-```
-
-## Error handling and edge cases
-
-### `__get__` is called with correct arguments
-
-This test makes sure that we call `__get__` with the right argument types for various scenarios:
+## `__get__` is called with correct arguments

 ```py
 from __future__ import annotations
@@ -665,7 +529,7 @@ reveal_type(C().class_object_access)  # revealed: TailoredForClassObjectAccess
 reveal_type(C.instance_access)  # revealed: TailoredForInstanceAccess
 ```

-### Descriptors with incorrect `__get__` signature
+## Descriptors with incorrect `__get__` signature

 ```py
 class Descriptor:
@@ -683,30 +547,7 @@ reveal_type(C.descriptor)  # revealed: Descriptor
 reveal_type(C().descriptor)  # revealed: Descriptor
 ```

-### Undeclared descriptor arguments
-
-If a descriptor attribute is not declared, we union with `Unknown`, just like for regular
-attributes, since that attribute could be overwritten externally. Even a data descriptor with a
-`__set__` method can be overwritten when accessed through a class object.
-
-```py
-class Descriptor:
-    def __get__(self, instance: object, owner: type | None = None) -> int:
-        return 1
-
-    def __set__(self, instance: object, value: int) -> None:
-        pass
-
-class C:
-    descriptor = Descriptor()
-
-C.descriptor = "something else"
-
-# This could also be `Literal["something else"]` if we support narrowing of attribute types based on assignments
-reveal_type(C.descriptor)  # revealed: Unknown | int
-```
-
-### Possibly unbound descriptor attributes
+## Possibly unbound descriptor attributes

 ```py
 class DataDescriptor:
@@ -739,7 +580,7 @@ def _(flag: bool):
    reveal_type(PossiblyUnbound().data)  # revealed: int
 ```

-### Possibly-unbound `__get__` method
+## Possibly-unbound `__get__` method

 ```py
 def _(flag: bool):
@@ -756,7 +597,7 @@ def _(flag: bool):
    reveal_type(C().descriptor)  # revealed: int | MaybeDescriptor
 ```

-### Descriptors with non-function `__get__` callables that are descriptors themselves
+## Descriptors with non-function `__get__` callables that are descriptors themselves

 The descriptor protocol is recursive, i.e. looking up `__get__` can involve triggering the
 descriptor protocol on the callable's `__call__` method:
@@ -797,6 +638,105 @@ class C:
 reveal_type(C.d)  # revealed: int
 ```

+## Dunder methods
+
+Dunder methods are looked up on the meta-type, but we still need to invoke the descriptor protocol:
+
+```py
+class SomeCallable:
+    def __call__(self, x: int) -> str:
+        return "a"
+
+class Descriptor:
+    def __get__(self, instance: object, owner: type | None = None) -> SomeCallable:
+        return SomeCallable()
+
+class B:
+    __call__: Descriptor = Descriptor()
+
+b_instance = B()
+reveal_type(b_instance(1))  # revealed: str
+
+b_instance("bla")  # error: [invalid-argument-type]
+```
+
+## Functions as descriptors
+
+Functions are descriptors because they implement a `__get__` method. This is crucial in making sure
+that method calls work as expected. See [this test suite](./call/methods.md) for more information.
+Here, we only demonstrate how `__get__` works on functions:
+
+```py
+from inspect import getattr_static
+
+def f(x: object) -> str:
+    return "a"
+
+reveal_type(f)  # revealed: Literal[f]
+reveal_type(f.__get__)  # revealed: <method-wrapper `__get__` of `f`>
+reveal_type(f.__get__(None, type(f)))  # revealed: Literal[f]
+reveal_type(f.__get__(None, type(f))(1))  # revealed: str
+
+wrapper_descriptor = getattr_static(f, "__get__")
+
+reveal_type(wrapper_descriptor)  # revealed: <wrapper-descriptor `__get__` of `function` objects>
+reveal_type(wrapper_descriptor(f, None, type(f)))  # revealed: Literal[f]
+
+# Attribute access on the method-wrapper `f.__get__` falls back to `MethodWrapperType`:
+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: @Todo(@property)
+```
+
+We can also bind the free function `f` to an instance of a class `C`:
+
+```py
+class C: ...
+
+bound_method = wrapper_descriptor(f, C(), C)
+
+reveal_type(bound_method)  # revealed: <bound method `f` of `C`>
+```
+
+We can then call it, and the instance of `C` is implicitly passed to the first parameter of `f`
+(`x`):
+
+```py
+reveal_type(bound_method())  # revealed: str
+```
+
+Finally, we test some error cases for the call to the wrapper descriptor:
+
+```py
+# Calling the wrapper descriptor without any arguments is an
+# error: [missing-argument] "No arguments provided for required parameters `self`, `instance`"
+wrapper_descriptor()
+
+# Calling it without the `instance` argument is an also an
+# error: [missing-argument] "No argument provided for required parameter `instance`"
+wrapper_descriptor(f)
+
+# Calling it without the `owner` argument if `instance` is not `None` is an
+# error: [missing-argument] "No argument provided for required parameter `owner`"
+wrapper_descriptor(f, None)
+
+# But calling it with an instance is fine (in this case, the `owner` argument is optional):
+wrapper_descriptor(f, C())
+
+# Calling it with something that is not a `FunctionType` as the first argument is an
+# error: [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 1 (`self`) of wrapper descriptor `FunctionType.__get__`; expected type `FunctionType`"
+wrapper_descriptor(1, None, type(f))
+
+# Calling it with something that is not a `type` as the `owner` argument is an
+# error: [invalid-argument-type] "Object of type `Literal[f]` cannot be assigned to parameter 3 (`owner`) of wrapper descriptor `FunctionType.__get__`; expected type `type`"
+wrapper_descriptor(f, None, f)
+
+# Calling it with too many positional arguments is an
+# error: [too-many-positional-arguments] "Too many positional arguments to wrapper descriptor `FunctionType.__get__`: expected 3, got 4"
+wrapper_descriptor(f, None, type(f), "one too many")
+```
+
 [descriptors]: https://docs.python.org/3/howto/descriptor.html
 [precedence chain]: https://github.com/python/cpython/blob/3.13/Objects/typeobject.c#L5393-L5481
 [simple example]: https://docs.python.org/3/howto/descriptor.html#simple-example-a-descriptor-that-returns-a-constant
--- a/crates/red_knot_python_semantic/resources/mdtest/diagnostics/attribute_assignment.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/diagnostics/attribute_assignment.md
@@ -1,149 +0,0 @@
-# Attribute assignment
-
-<!-- snapshot-diagnostics -->
-
-This test suite demonstrates various kinds of diagnostics that can be emitted in a
-`obj.attr = value` assignment.
-
-## Instance attributes with class-level defaults
-
-These can be set on instances and on class objects.
-
-```py
-class C:
-    attr: int = 0
-
-instance = C()
-instance.attr = 1  # fine
-instance.attr = "wrong"  # error: [invalid-assignment]
-
-C.attr = 1  # fine
-C.attr = "wrong"  # error: [invalid-assignment]
-```
-
-## Pure instance attributes
-
-These can only be set on instances. When trying to set them on class objects, we generate a useful
-diagnostic that mentions that the attribute is only available on instances.
-
-```py
-class C:
-    def __init__(self):
-        self.attr: int = 0
-
-instance = C()
-instance.attr = 1  # fine
-instance.attr = "wrong"  # error: [invalid-assignment]
-
-C.attr = 1  # error: [invalid-attribute-access]
-```
-
-## `ClassVar`s
-
-These can only be set on class objects. When trying to set them on instances, we generate a useful
-diagnostic that mentions that the attribute is only available on class objects.
-
-```py
-from typing import ClassVar
-
-class C:
-    attr: ClassVar[int] = 0
-
-C.attr = 1  # fine
-C.attr = "wrong"  # error: [invalid-assignment]
-
-instance = C()
-instance.attr = 1  # error: [invalid-attribute-access]
-```
-
-## Unknown attributes
-
-When trying to set an attribute that is not defined, we also emit errors:
-
-```py
-class C: ...
-
-C.non_existent = 1  # error: [unresolved-attribute]
-
-instance = C()
-instance.non_existent = 1  # error: [unresolved-attribute]
-```
-
-## Possibly-unbound attributes
-
-When trying to set an attribute that is not defined in all branches, we emit errors:
-
-```py
-def _(flag: bool) -> None:
-    class C:
-        if flag:
-            attr: int = 0
-
-    C.attr = 1  # error: [possibly-unbound-attribute]
-
-    instance = C()
-    instance.attr = 1  # error: [possibly-unbound-attribute]
-```
-
-## Data descriptors
-
-When assigning to a data descriptor attribute, we implicitly call the descriptor's `__set__` method.
-This can lead to various kinds of diagnostics.
-
-### Invalid argument type
-
-```py
-class Descriptor:
-    def __set__(self, instance: object, value: int) -> None:
-        pass
-
-class C:
-    attr: Descriptor = Descriptor()
-
-instance = C()
-instance.attr = 1  # fine
-
-# TODO: ideally, we would mention why this is an invalid assignment (wrong argument type for `value` parameter)
-instance.attr = "wrong"  # error: [invalid-assignment]
-```
-
-### Invalid `__set__` method signature
-
-```py
-class WrongDescriptor:
-    def __set__(self, instance: object, value: int, extra: int) -> None:
-        pass
-
-class C:
-    attr: WrongDescriptor = WrongDescriptor()
-
-instance = C()
-
-# TODO: ideally, we would mention why this is an invalid assignment (wrong number of arguments for `__set__`)
-instance.attr = 1  # error: [invalid-assignment]
-```
-
-## Setting attributes on union types
-
-```py
-def _(flag: bool) -> None:
-    if flag:
-        class C1:
-            attr: int = 0
-
-    else:
-        class C1:
-            attr: str = ""
-
-    # TODO: The error message here could be improved to explain why the assignment fails.
-    C1.attr = 1  # error: [invalid-assignment]
-
-    class C2:
-        if flag:
-            attr: int = 0
-        else:
-            attr: str = ""
-
-    # TODO: This should be an error
-    C2.attr = 1
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/diagnostics/no_matching_overload.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/diagnostics/no_matching_overload.md
@@ -1,14 +0,0 @@
-# No matching overload diagnostics
-
-<!-- snapshot-diagnostics -->
-
-## Calls to overloaded functions
-
-TODO: Note that we do not yet support the `@overload` decorator to define overloaded functions in
-real Python code. We are instead testing a special-cased function where we create an overloaded
-signature internally. Update this to an `@overload` function in the Python snippet itself once we
-can.
-
-```py
-type("Foo", ())  # error: [no-matching-overload]
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/directives/assert_never.md
+++ b/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)
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/directives/cast.md
+++ b/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
@@ -13,58 +13,15 @@ reveal_type(cast("str", True))  # revealed: str

 reveal_type(cast(int | str, 1))  # revealed: int | str

-reveal_type(cast(val="foo", typ=int))  # revealed: int
-
 # error: [invalid-type-form]
 reveal_type(cast(Literal, True))  # revealed: Unknown

-# error: [invalid-type-form]
-reveal_type(cast(1, True))  # revealed: Unknown
-
-# error: [missing-argument] "No argument provided for required parameter `val` of function `cast`"
+# TODO: These should be errors
+cast(1)
 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]
+# TODO: Either support keyword arguments properly,
+# or give a comprehensible error message saying they're unsupported
+cast(val="foo", typ=int)  # error: [unresolved-reference] "Name `foo` used when not defined"
 ```
--- a/Show More
+++ b/Show More