Merge branch 'main' into dcreager/function-enum

* main:
  Update pre-commit dependencies (#17506)
  [red-knot] Simplify visibility constraint handling for `*`-import definitions (#17486)
  [red-knot] Detect (some) invalid protocols (#17488)
  [red-knot] Correctly identify protocol classes (#17487)
  Update dependency ruff to v0.11.6 (#17516)
  Update Rust crate shellexpand to v3.1.1 (#17512)
  Update Rust crate proc-macro2 to v1.0.95 (#17510)
  Update Rust crate rand to v0.9.1 (#17511)
  Update Rust crate libc to v0.2.172 (#17509)
  Update Rust crate jiff to v0.2.9 (#17508)
  Update Rust crate clap to v4.5.37 (#17507)
  Update astral-sh/setup-uv action to v5.4.2 (#17504)
  Update taiki-e/install-action digest to 09dc018 (#17503)
  [red-knot] infer attribute assignments bound in comprehensions (#17396)
  [red-knot] simplify gradually-equivalent types out of unions and intersections (#17467)
  [red-knot] pull primer projects to run from file (#17473)

.github/workflows/build-binaries.yml

@@ -28,7 +28,7 @@ permissions: {}
 env:
   PACKAGE_NAME: ruff
   MODULE_NAME: ruff
-  PYTHON_VERSION: "3.11"
+  PYTHON_VERSION: "3.13"
   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
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         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@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
         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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         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@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
         with:
           target: x86_64
           args: --release --locked --out dist
       - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         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@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
         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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         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@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
         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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         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@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
         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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: artifacts-${{ matrix.target }}
           path: |
@@ -294,17 +294,17 @@ jobs:
             arch: arm
 
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         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@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
         with:
           target: ${{ matrix.platform.target }}
           manylinux: auto
@@ -325,7 +325,7 @@ jobs:
             pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
             ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: artifacts-${{ matrix.platform.target }}
           path: |
@@ -359,25 +359,25 @@ jobs:
           - x86_64-unknown-linux-musl
           - i686-unknown-linux-musl
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         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@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
         with:
           target: ${{ matrix.target }}
           manylinux: musllinux_1_2
           args: --release --locked --out dist
       - name: "Test wheel"
         if: matrix.target == 'x86_64-unknown-linux-musl'
-        uses: addnab/docker-run-action@v3
+        uses: addnab/docker-run-action@4f65fabd2431ebc8d299f8e5a018d79a769ae185 # v3
         with:
           image: alpine:latest
           options: -v ${{ github.workspace }}:/io -w /io
@@ -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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: artifacts-${{ matrix.target }}
           path: |
@@ -425,17 +425,17 @@ jobs:
             arch: armv7
 
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           submodules: recursive
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         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@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
         with:
           target: ${{ matrix.platform.target }}
           manylinux: musllinux_1_2
@@ -454,7 +454,7 @@ jobs:
             .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
             .venv/bin/${{ env.MODULE_NAME }} --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: artifacts-${{ matrix.platform.target }}
           path: |

.github/workflows/build-docker.yml

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

.github/workflows/ci.yaml

@@ -18,7 +18,7 @@ env:
   CARGO_TERM_COLOR: always
   RUSTUP_MAX_RETRIES: 10
   PACKAGE_NAME: ruff
-  PYTHON_VERSION: "3.12"
+  PYTHON_VERSION: "3.13"
 
 jobs:
   determine_changes:
@@ -36,11 +36,13 @@ jobs:
       code: ${{ steps.check_code.outputs.changed }}
       # Flag that is raised when any code that affects the fuzzer is changed
       fuzz: ${{ steps.check_fuzzer.outputs.changed }}
+      # Flag that is set to "true" when code related to red-knot changes.
+      red_knot: ${{ steps.check_red_knot.outputs.changed }}
 
       # Flag that is set to "true" when code related to the playground changes.
       playground: ${{ steps.check_playground.outputs.changed }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           fetch-depth: 0
           persist-credentials: false
@@ -141,7 +143,7 @@ jobs:
         env:
           MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
         run: |
-          if git diff --quiet "${MERGE_BASE}...HEAD" -- ':**/*' \
+          if git diff --quiet "${MERGE_BASE}...HEAD" -- ':**' \
             ':!**/*.md' \
             ':crates/red_knot_python_semantic/resources/mdtest/**/*.md' \
             ':!docs/**' \
@@ -166,12 +168,35 @@ jobs:
               echo "changed=true" >> "$GITHUB_OUTPUT"
           fi
 
+      - name: Check if the red-knot code changed
+        id: check_red_knot
+        env:
+          MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
+        run: |
+          if git diff --quiet "${MERGE_BASE}...HEAD" -- \
+            ':Cargo.toml' \
+            ':Cargo.lock' \
+            ':crates/red_knot*/**' \
+            ':crates/ruff_db/**' \
+            ':crates/ruff_annotate_snippets/**' \
+            ':crates/ruff_python_ast/**' \
+            ':crates/ruff_python_parser/**' \
+            ':crates/ruff_python_trivia/**' \
+            ':crates/ruff_source_file/**' \
+            ':crates/ruff_text_size/**' \
+            ':.github/workflows/ci.yaml' \
+          ; then
+              echo "changed=false" >> "$GITHUB_OUTPUT"
+          else
+              echo "changed=true" >> "$GITHUB_OUTPUT"
+          fi
+
   cargo-fmt:
     name: "cargo fmt"
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
       - name: "Install Rust toolchain"
@@ -185,10 +210,10 @@ jobs:
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Install Rust toolchain"
         run: |
           rustup component add clippy
@@ -205,22 +230,30 @@ 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
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
-        uses: rui314/setup-mold@v1
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # 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:
@@ -239,7 +272,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
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: ruff
           path: target/debug/ruff
@@ -251,20 +284,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
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
-        uses: rui314/setup-mold@v1
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
         with:
           tool: cargo-insta
       - name: "Run tests"
@@ -280,14 +313,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
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
         with:
           tool: cargo-nextest
       - name: "Run tests"
@@ -307,13 +340,13 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
+      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
         with:
           node-version: 20
           cache: "npm"
@@ -336,14 +369,14 @@ jobs:
     if: ${{ github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
-        uses: rui314/setup-mold@v1
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
       - name: "Build"
         run: cargo build --release --locked
 
@@ -354,7 +387,7 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
       - uses: SebRollen/toml-action@b1b3628f55fc3a28208d4203ada8b737e9687876 # v1.2.0
@@ -362,19 +395,19 @@ jobs:
         with:
           file: "Cargo.toml"
           field: "workspace.package.rust-version"
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Install Rust toolchain"
         env:
           MSRV: ${{ steps.msrv.outputs.value }}
         run: rustup default "${MSRV}"
       - name: "Install mold"
-        uses: rui314/setup-mold@v1
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
         with:
           tool: cargo-insta
       - name: "Run tests"
@@ -391,16 +424,16 @@ 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
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
         with:
           workspaces: "fuzz -> target"
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install cargo-binstall"
-        uses: cargo-bins/cargo-binstall@main
+        uses: cargo-bins/cargo-binstall@63aaa5c1932cebabc34eceda9d92a70215dcead6 # v1.12.3
         with:
           tool: cargo-fuzz@0.11.2
       - name: "Install cargo-fuzz"
@@ -419,11 +452,11 @@ jobs:
     env:
       FORCE_COLOR: 1
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@22695119d769bdb6f7032ad67b9bca0ef8c4a174 # v5
-      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
+      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
+      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
         name: Download Ruff binary to test
         id: download-cached-binary
         with:
@@ -453,10 +486,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
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Install Rust toolchain"
         run: rustup component add rustfmt
       # Run all code generation scripts, and verify that the current output is
@@ -485,14 +518,14 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && github.event_name == 'pull_request' && needs.determine_changes.outputs.code == 'true' }}
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
+      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
         name: Download comparison Ruff binary
         id: ruff-target
         with:
@@ -587,13 +620,13 @@ jobs:
         run: |
           echo ${{ github.event.number }} > pr-number
 
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         name: Upload PR Number
         with:
           name: pr-number
           path: pr-number
 
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         name: Upload Results
         with:
           name: ecosystem-result
@@ -605,10 +638,10 @@ jobs:
     needs: determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: cargo-bins/cargo-binstall@main
+      - uses: cargo-bins/cargo-binstall@63aaa5c1932cebabc34eceda9d92a70215dcead6 # v1.12.3
       - run: cargo binstall --no-confirm cargo-shear
       - run: cargo shear
 
@@ -618,18 +651,18 @@ jobs:
     timeout-minutes: 20
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@22fe573c6ed0c03ab9b84e631cbfa49bddf6e20e # v1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
         with:
           args: --out dist
       - name: "Test wheel"
@@ -642,22 +675,15 @@ jobs:
 
   pre-commit:
     name: "pre-commit"
-    runs-on: ubuntu-latest
+    runs-on: depot-ubuntu-22.04-16
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - name: "Install pre-commit"
-        run: pip install pre-commit
+      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
       - name: "Cache pre-commit"
-        uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4
+        uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3
         with:
           path: ~/.cache/pre-commit
           key: pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
@@ -666,7 +692,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 pre-commit run --all-files --show-diff-on-failure --color=always --hook-stage=manual | \
+          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 | \
             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"
@@ -679,22 +705,22 @@ jobs:
     env:
       MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         with:
           python-version: "3.13"
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Add SSH key"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        uses: webfactory/ssh-agent@dc588b651fe13675774614f8e6a936a468676387 # v0.9.0
+        uses: webfactory/ssh-agent@a6f90b1f127823b31d4d4a8d96047790581349bd # v0.9.1
         with:
           ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
       - name: "Install Rust toolchain"
         run: rustup show
       - name: Install uv
-        uses: astral-sh/setup-uv@22695119d769bdb6f7032ad67b9bca0ef8c4a174 # v5
+        uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
         run: uv pip install -r docs/requirements-insiders.txt --system
@@ -721,10 +747,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
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Run checks"
@@ -747,17 +773,18 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         name: "Download ruff-lsp source"
         with:
           persist-credentials: false
           repository: "astral-sh/ruff-lsp"
 
-      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5.5.0
         with:
-          python-version: ${{ env.PYTHON_VERSION }}
+          # installation fails on 3.13 and newer
+          python-version: "3.12"
 
-      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
+      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
         name: Download development ruff binary
         id: ruff-target
         with:
@@ -788,13 +815,13 @@ jobs:
       - determine_changes
     if: ${{ (needs.determine_changes.outputs.playground == 'true') }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - 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
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
         with:
           node-version: 22
           cache: "npm"
@@ -820,17 +847,17 @@ jobs:
     timeout-minutes: 20
     steps:
       - name: "Checkout Branch"
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
 
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
 
       - name: "Install Rust toolchain"
         run: rustup show
 
       - name: "Install codspeed"
-        uses: taiki-e/install-action@914ac1e29db2d22aef69891f032778d9adc3990d # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
         with:
           tool: cargo-codspeed
 
@@ -838,7 +865,7 @@ jobs:
         run: cargo codspeed build --features codspeed -p ruff_benchmark
 
       - name: "Run benchmarks"
-        uses: CodSpeedHQ/action@0010eb0ca6e89b80c88e8edaaa07cfe5f3e6664d # v3
+        uses: CodSpeedHQ/action@0010eb0ca6e89b80c88e8edaaa07cfe5f3e6664d # v3.5.0
         with:
           run: cargo codspeed run
           token: ${{ secrets.CODSPEED_TOKEN }}

.github/workflows/daily_fuzz.yaml

@@ -31,15 +31,15 @@ jobs:
     # Don't run the cron job on forks:
     if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@22695119d769bdb6f7032ad67b9bca0ef8c4a174 # v5
+      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
-        uses: rui314/setup-mold@v1
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - 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
+      - uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |

.github/workflows/daily_property_tests.yaml

@@ -30,14 +30,14 @@ jobs:
     # Don't run the cron job on forks:
     if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         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
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - 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
+      - uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |

.github/workflows/mypy_primer.yaml

@@ -25,19 +25,19 @@ env:
 jobs:
   mypy_primer:
     name: Run mypy_primer
-    runs-on: ubuntu-24.04
+    runs-on: depot-ubuntu-22.04-16
     timeout-minutes: 20
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           path: ruff
           fetch-depth: 0
           persist-credentials: false
 
       - name: Install the latest version of uv
-        uses: astral-sh/setup-uv@22695119d769bdb6f7032ad67b9bca0ef8c4a174 # v5
+        uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
 
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2
+      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
         with:
           workspaces: "ruff"
       - name: Install Rust toolchain
@@ -45,13 +45,15 @@ jobs:
 
       - name: Install mypy_primer
         run: |
-          uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support"
+          uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support-v5"
 
       - name: Run mypy_primer
         shell: bash
         run: |
           cd ruff
 
+          PRIMER_SELECTOR="$(paste -s -d'|' crates/red_knot_python_semantic/resources/primer/good.txt)"
+
           echo "new commit"
           git rev-list --format=%s --max-count=1 "$GITHUB_SHA"
 
@@ -62,13 +64,14 @@ jobs:
 
           cd ..
 
+          echo "Project selector: $PRIMER_SELECTOR"
           # Allow the exit code to be 0 or 1, only fail for actual mypy_primer crashes/bugs
           uvx 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)$' \
+            --project-selector "/($PRIMER_SELECTOR)\$" \
             --output concise \
             --debug > mypy_primer.diff || [ $? -eq 1 ]
 
@@ -81,13 +84,13 @@ jobs:
           echo ${{ github.event.number }} > pr-number
 
       - name: Upload diff
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        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
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: pr-number
           path: pr-number

.github/workflows/notify-dependents.yml

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

.github/workflows/publish-docs.yml

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

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

@@ -30,12 +30,12 @@ jobs:
     env:
       CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - 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
+      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
         with:
           node-version: 22
       - uses: jetli/wasm-bindgen-action@20b33e20595891ab1a0ed73145d8a21fc96e7c29 # v0.2.0

.github/workflows/publish-playground.yml

@@ -24,12 +24,12 @@ jobs:
     env:
       CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - 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
+      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
         with:
           node-version: 22
           cache: "npm"

.github/workflows/publish-pypi.yml

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

.github/workflows/publish-wasm.yml

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

.github/workflows/release.yml

@@ -1,6 +1,7 @@
-# This file was autogenerated by dist: https://opensource.axo.dev/cargo-dist/
+# This file was autogenerated by dist: https://github.com/astral-sh/cargo-dist
 #
 # Copyright 2022-2024, axodotdev
+# Copyright 2025 Astral Software Inc.
 # SPDX-License-Identifier: MIT or Apache-2.0
 #
 # CI that:
@@ -59,16 +60,17 @@ jobs:
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
         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/axodotdev/cargo-dist/releases/download/v0.25.2-prerelease.3/cargo-dist-installer.sh | sh"
+        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"
       - name: Cache dist
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/dist
@@ -84,7 +86,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 # v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
         with:
           name: artifacts-plan-dist-manifest
           path: plan-dist-manifest.json
@@ -121,18 +123,19 @@ jobs:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
         with:
+          persist-credentials: false
           submodules: recursive
       - name: Install cached dist
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
         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 # v4
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
         with:
           pattern: artifacts-*
           path: target/distrib/
@@ -150,7 +153,7 @@ jobs:
 
           cp dist-manifest.json "$BUILD_MANIFEST_NAME"
       - name: "Upload artifacts"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
         with:
           name: artifacts-build-global
           path: |
@@ -171,18 +174,19 @@ jobs:
     outputs:
       val: ${{ steps.host.outputs.manifest }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
         with:
+          persist-credentials: false
           submodules: recursive
       - name: Install cached dist
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
         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 # v4
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
         with:
           pattern: artifacts-*
           path: target/distrib/
@@ -196,7 +200,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 # v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
         with:
           # Overwrite the previous copy
           name: artifacts-dist-manifest
@@ -246,12 +250,13 @@ jobs:
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
         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 # v4
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
         with:
           pattern: artifacts-*
           path: artifacts

.github/workflows/sync_typeshed.yaml

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

.pre-commit-config.yaml

@@ -18,8 +18,13 @@ 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
+    rev: v0.24.1
     hooks:
       - id: validate-pyproject
 
@@ -60,7 +65,7 @@ repos:
           - black==25.1.0
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.30.2
+    rev: v1.31.1
     hooks:
       - id: typos
 
@@ -74,7 +79,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.0
+    rev: v0.11.6
     hooks:
       - id: ruff-format
       - id: ruff
@@ -92,12 +97,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.1
+    rev: v1.6.0
     hooks:
       - id: zizmor
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.31.3
+    rev: 0.33.0
     hooks:
       - id: check-github-workflows
 

CHANGELOG.md

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

Cargo.lock

@@ -128,9 +128,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.97"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "argfile"
@@ -207,18 +207,18 @@ dependencies = [
 
 [[package]]
 name = "boxcar"
-version = "0.2.10"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225450ee9328e1e828319b48a89726cffc1b0ad26fd9211ad435de9fa376acae"
+checksum = "6740c6e2fc6360fa57c35214c7493826aee95993926092606f27c983b40837be"
 dependencies = [
  "loom",
 ]
 
 [[package]]
 name = "bstr"
-version = "1.11.3"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "531a9155a481e2ee699d4f98f43c0ca4ff8ee1bfd55c31e9e98fb29d2b176fe0"
+checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
 dependencies = [
  "memchr",
  "regex-automata 0.4.9",
@@ -334,9 +334,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.32"
+version = "4.5.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6088f3ae8c3608d19260cd7445411865a485688711b78b5be70d78cd96136f83"
+checksum = "eccb054f56cbd38340b380d4a8e69ef1f02f1af43db2f0cc817a4774d80ae071"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -344,9 +344,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.32"
+version = "4.5.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22a7ef7f676155edfb82daa97f99441f3ebf4a58d5e32f295a56259f1b6facc8"
+checksum = "efd9466fac8543255d3b1fcad4762c5e116ffe808c8a3043d4263cd4fd4862a2"
 dependencies = [
  "anstream",
  "anstyle",
@@ -478,7 +478,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
 dependencies = [
  "lazy_static",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -487,7 +487,7 @@ version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fde0e0ec90c9dfb3b4b1a0891a7dcd0e2bffde2f7efed5fe7c9bb00e5bfb915e"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -695,9 +695,9 @@ dependencies = [
 
 [[package]]
 name = "ctrlc"
-version = "3.4.5"
+version = "3.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90eeab0aa92f3f9b4e87f258c72b139c207d251f9cbc1080a0086b86a8870dd3"
+checksum = "697b5419f348fd5ae2478e8018cb016c00a5881c7f46c717de98ffd135a5651c"
 dependencies = [
  "nix",
  "windows-sys 0.59.0",
@@ -894,9 +894,9 @@ checksum = "c7f84e12ccf0a7ddc17a6c41c93326024c42920d7ee630d04950e6926645c0fe"
 
 [[package]]
 name = "env_logger"
-version = "0.11.7"
+version = "0.11.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3716d7a920fb4fac5d84e9d4bce8ceb321e9414b4409da61b07b75c1e3d0697"
+checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1390,9 +1390,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.8.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3954d50fe15b02142bf25d3b8bdadb634ec3948f103d04ffe3031bc8fe9d7058"
+checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.2",
@@ -1553,28 +1553,45 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "jiff"
-version = "0.2.4"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d699bc6dfc879fb1bf9bdff0d4c56f0884fc6f0d0eb0fba397a6d00cd9a6b85e"
+checksum = "59ec30f7142be6fe14e1b021f50b85db8df2d4324ea6e91ec3e5dcde092021d0"
 dependencies = [
  "jiff-static",
+ "jiff-tzdb-platform",
  "log",
  "portable-atomic",
  "portable-atomic-util",
  "serde",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "jiff-static"
-version = "0.2.4"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d16e75759ee0aa64c57a56acbf43916987b20c77373cb7e808979e02b93c9f9"
+checksum = "526b834d727fd59d37b076b0c3236d9adde1b1729a4361e20b2026f738cc1dbe"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn 2.0.100",
 ]
 
+[[package]]
+name = "jiff-tzdb"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1283705eb0a21404d2bfd6eef2a7593d240bc42a0bdb39db0ad6fa2ec026524"
+
+[[package]]
+name = "jiff-tzdb-platform"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
+dependencies = [
+ "jiff-tzdb",
+]
+
 [[package]]
 name = "jobserver"
 version = "0.1.32"
@@ -1628,9 +1645,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.171"
+version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
 [[package]]
 name = "libcst"
@@ -1659,9 +1676,9 @@ dependencies = [
 
 [[package]]
 name = "libmimalloc-sys"
-version = "0.1.40"
+version = "0.1.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07d0e07885d6a754b9c7993f2625187ad694ee985d60f23355ff0e7077261502"
+checksum = "ec9d6fac27761dabcd4ee73571cdb06b7022dc99089acbe5435691edffaac0f4"
 dependencies = [
  "cc",
  "libc",
@@ -1726,9 +1743,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.26"
+version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30bde2b3dc3671ae49d8e2e9f044c7c005836e7a023ee57cffa25ab82764bb9e"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
 [[package]]
 name = "loom"
@@ -1797,9 +1814,9 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "mimalloc"
-version = "0.1.44"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99585191385958383e13f6b822e6b6d8d9cf928e7d286ceb092da92b43c87bc1"
+checksum = "995942f432bbb4822a7e9c3faa87a695185b0d09273ba85f097b54f4e458f2af"
 dependencies = [
  "libmimalloc-sys",
 ]
@@ -1973,9 +1990,9 @@ checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
 [[package]]
 name = "ordermap"
-version = "0.5.6"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e98f974336ceffd5b1b1f4fcbb89a23c8dcd334adc4b8612f11b7fa99944535"
+checksum = "7d31b8b7a99f71bdff4235faf9ce9eada0ad3562c8fbeb7d607d9f41a6ec569d"
 dependencies = [
  "indexmap",
 ]
@@ -2310,9 +2327,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.94"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
@@ -2403,13 +2420,12 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
- "zerocopy",
 ]
 
 [[package]]
@@ -2476,7 +2492,6 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "argfile",
- "chrono",
  "clap",
  "colored 3.0.0",
  "countme",
@@ -2485,6 +2500,7 @@ dependencies = [
  "filetime",
  "insta",
  "insta-cmd",
+ "jiff",
  "rayon",
  "red_knot_project",
  "red_knot_python_semantic",
@@ -2503,6 +2519,23 @@ dependencies = [
  "wild",
 ]
 
+[[package]]
+name = "red_knot_ide"
+version = "0.0.0"
+dependencies = [
+ "insta",
+ "red_knot_python_semantic",
+ "red_knot_vendored",
+ "ruff_db",
+ "ruff_python_ast",
+ "ruff_python_parser",
+ "ruff_text_size",
+ "rustc-hash 2.1.1",
+ "salsa",
+ "smallvec",
+ "tracing",
+]
+
 [[package]]
 name = "red_knot_project"
 version = "0.0.0"
@@ -2514,12 +2547,14 @@ dependencies = [
  "notify",
  "pep440_rs",
  "rayon",
+ "red_knot_ide",
  "red_knot_python_semantic",
  "red_knot_vendored",
  "ruff_cache",
  "ruff_db",
  "ruff_macros",
  "ruff_python_ast",
+ "ruff_python_formatter",
  "ruff_text_size",
  "rustc-hash 2.1.1",
  "salsa",
@@ -2585,10 +2620,11 @@ dependencies = [
  "libc",
  "lsp-server",
  "lsp-types",
+ "red_knot_ide",
  "red_knot_project",
+ "red_knot_python_semantic",
  "ruff_db",
  "ruff_notebook",
- "ruff_python_ast",
  "ruff_source_file",
  "ruff_text_size",
  "rustc-hash 2.1.1",
@@ -2646,10 +2682,12 @@ dependencies = [
  "getrandom 0.3.2",
  "js-sys",
  "log",
+ "red_knot_ide",
  "red_knot_project",
  "red_knot_python_semantic",
  "ruff_db",
  "ruff_notebook",
+ "ruff_python_formatter",
  "ruff_source_file",
  "ruff_text_size",
  "serde-wasm-bindgen",
@@ -2734,7 +2772,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.11.2"
+version = "0.11.6"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2742,7 +2780,6 @@ dependencies = [
  "bincode",
  "bitflags 2.9.0",
  "cachedir",
- "chrono",
  "clap",
  "clap_complete_command",
  "clearscreen",
@@ -2755,6 +2792,7 @@ dependencies = [
  "insta-cmd",
  "is-macro",
  "itertools 0.14.0",
+ "jiff",
  "log",
  "mimalloc",
  "notify",
@@ -2969,12 +3007,11 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.11.2"
+version = "0.11.6"
 dependencies = [
  "aho-corasick",
  "anyhow",
  "bitflags 2.9.0",
- "chrono",
  "clap",
  "colored 3.0.0",
  "fern",
@@ -2985,6 +3022,7 @@ dependencies = [
  "is-macro",
  "is-wsl",
  "itertools 0.14.0",
+ "jiff",
  "libcst",
  "log",
  "memchr",
@@ -2998,7 +3036,6 @@ dependencies = [
  "ruff_annotate_snippets",
  "ruff_cache",
  "ruff_diagnostics",
- "ruff_index",
  "ruff_macros",
  "ruff_notebook",
  "ruff_python_ast",
@@ -3046,7 +3083,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
- "rand 0.9.0",
+ "rand 0.9.1",
  "ruff_diagnostics",
  "ruff_source_file",
  "ruff_text_size",
@@ -3114,6 +3151,7 @@ dependencies = [
  "memchr",
  "regex",
  "ruff_cache",
+ "ruff_db",
  "ruff_formatter",
  "ruff_macros",
  "ruff_python_ast",
@@ -3122,6 +3160,7 @@ dependencies = [
  "ruff_source_file",
  "ruff_text_size",
  "rustc-hash 2.1.1",
+ "salsa",
  "schemars",
  "serde",
  "serde_json",
@@ -3193,6 +3232,7 @@ name = "ruff_python_semantic"
 version = "0.0.0"
 dependencies = [
  "bitflags 2.9.0",
+ "insta",
  "is-macro",
  "ruff_cache",
  "ruff_index",
@@ -3205,6 +3245,7 @@ dependencies = [
  "schemars",
  "serde",
  "smallvec",
+ "test-case",
 ]
 
 [[package]]
@@ -3292,7 +3333,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.11.2"
+version = "0.11.6"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -3417,7 +3458,7 @@ checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 [[package]]
 name = "salsa"
 version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=d758691ba17ee1a60c5356ea90888d529e1782ad#d758691ba17ee1a60c5356ea90888d529e1782ad"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
 dependencies = [
  "boxcar",
  "compact_str 0.8.1",
@@ -3433,18 +3474,19 @@ dependencies = [
  "salsa-macro-rules",
  "salsa-macros",
  "smallvec",
+ "thin-vec",
  "tracing",
 ]
 
 [[package]]
 name = "salsa-macro-rules"
 version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=d758691ba17ee1a60c5356ea90888d529e1782ad#d758691ba17ee1a60c5356ea90888d529e1782ad"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
 
 [[package]]
 name = "salsa-macros"
 version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=d758691ba17ee1a60c5356ea90888d529e1782ad#d758691ba17ee1a60c5356ea90888d529e1782ad"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -3632,9 +3674,9 @@ dependencies = [
 
 [[package]]
 name = "shellexpand"
-version = "3.1.0"
+version = "3.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da03fa3b94cc19e3ebfc88c4229c49d8f08cdbd1228870a45f0ffdf84988e14b"
+checksum = "8b1fdf65dd6331831494dd616b30351c38e96e45921a27745cf98490458b90bb"
 dependencies = [
  "dirs",
 ]
@@ -3659,9 +3701,9 @@ checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
 name = "smallvec"
-version = "1.14.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
+checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
 
 [[package]]
 name = "snapbox"
@@ -3857,6 +3899,12 @@ dependencies = [
  "test-case-core",
 ]
 
+[[package]]
+name = "thin-vec"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "144f754d318415ac792f9d69fc87abbbfc043ce2ef041c60f16ad828f638717d"
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -4279,7 +4327,7 @@ checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
 dependencies = [
  "getrandom 0.3.2",
  "js-sys",
- "rand 0.9.0",
+ "rand 0.9.1",
  "uuid-macro-internal",
  "wasm-bindgen",
 ]
@@ -4550,7 +4598,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]

Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-rust-version = "1.83"
+rust-version = "1.84"
 homepage = "https://docs.astral.sh/ruff"
 documentation = "https://docs.astral.sh/ruff"
 repository = "https://github.com/astral-sh/ruff"
@@ -38,10 +38,11 @@ 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" }
@@ -54,7 +55,6 @@ bitflags = { version = "2.5.0" }
 bstr = { version = "1.9.1" }
 cachedir = { version = "0.3.1" }
 camino = { version = "1.1.7" }
-chrono = { version = "0.4.35", default-features = false, features = ["clock"] }
 clap = { version = "4.5.3", features = ["derive"] }
 clap_complete_command = { version = "0.6.0" }
 clearscreen = { version = "4.0.0" }
@@ -94,6 +94,7 @@ insta-cmd = { version = "0.6.0" }
 is-macro = { version = "0.3.5" }
 is-wsl = { version = "0.4.0" }
 itertools = { version = "0.14.0" }
+jiff = { version = "0.2.0" }
 js-sys = { version = "0.3.69" }
 jod-thread = { version = "0.1.2" }
 libc = { version = "0.2.153" }
@@ -123,7 +124,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 = "d758691ba17ee1a60c5356ea90888d529e1782ad" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "87bf6b6c2d5f6479741271da73bd9d30c2580c26" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -208,6 +209,7 @@ 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
@@ -270,7 +272,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.25.2-prerelease.3"
+cargo-dist-version = "0.28.4-prerelease.1"
 # CI backends to support
 ci = "github"
 # The installers to generate for each app
@@ -327,9 +329,12 @@ github-custom-job-permissions = { "build-docker" = { packages = "write", content
 install-updater = false
 # Path that installers should place binaries in
 install-path = ["$XDG_BIN_HOME/", "$XDG_DATA_HOME/../bin", "~/.local/bin"]
-# Temporarily allow changes to the `release` workflow, in which we pin actions
-# to a SHA instead of a tag (https://github.com/astral-sh/uv/issues/12253)
-allow-dirty = ["ci"]
 
 [workspace.metadata.dist.github-custom-runners]
 global = "depot-ubuntu-latest-4"
+
+[workspace.metadata.dist.github-action-commits]
+"actions/checkout" = "11bd71901bbe5b1630ceea73d27597364c9af683" # v4
+"actions/upload-artifact" = "ea165f8d65b6e75b540449e92b4886f43607fa02" # v4.6.2
+"actions/download-artifact" = "95815c38cf2ff2164869cbab79da8d1f422bc89e" # v4.2.1
+"actions/attest-build-provenance" = "c074443f1aee8d4aeeae555aebba3282517141b2" #v2.2.3

README.md

@@ -149,8 +149,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.11.2/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.11.2/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.11.6/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.11.6/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.2
+  rev: v0.11.6
   hooks:
     # Run the linter.
     - id: ruff

crates/red_knot/Cargo.toml

@@ -20,12 +20,12 @@ ruff_python_ast = { workspace = true }
 
 anyhow = { workspace = true }
 argfile = { workspace = true }
-chrono = { workspace = true }
 clap = { workspace = true, features = ["wrap_help"] }
 colored = { workspace = true }
 countme = { workspace = true, features = ["enable"] }
 crossbeam = { workspace = true }
 ctrlc = { version = "3.4.4" }
+jiff = { workspace = true }
 rayon = { workspace = true }
 salsa = { workspace = true }
 tracing = { workspace = true, features = ["release_max_level_debug"] }

crates/red_knot/docs/mypy_primer.md

@@ -31,7 +31,7 @@ mypy_primer \
 ```
 
 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`.
+diff for all projects we currently enable in CI, use `--project-selector "/($(paste -s -d'|' crates/red_knot_python_semantic/resources/primer/good.txt))\$"`.
 
 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.

crates/red_knot/src/args.rs

@@ -71,6 +71,15 @@ 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,
 
@@ -116,6 +125,9 @@ 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| {
@@ -124,7 +136,6 @@ impl CheckCommand {
                         .map(RelativePathBuf::cli)
                         .collect()
                 }),
-                ..EnvironmentOptions::default()
             }),
             terminal: Some(TerminalOptions {
                 output_format: self

crates/red_knot/src/logging.rs

@@ -190,8 +190,8 @@ where
         let ansi = writer.has_ansi_escapes();
 
         if self.display_timestamp {
-            let timestamp = chrono::Local::now()
-                .format("%Y-%m-%d %H:%M:%S.%f")
+            let timestamp = jiff::Zoned::now()
+                .strftime("%Y-%m-%d %H:%M:%S.%f")
                 .to_string();
             if ansi {
                 write!(writer, "{} ", timestamp.dimmed())?;
@@ -199,7 +199,7 @@ where
                 write!(
                     writer,
                     "{} ",
-                    chrono::Local::now().format("%Y-%m-%d %H:%M:%S.%f")
+                    jiff::Zoned::now().strftime("%Y-%m-%d %H:%M:%S.%f")
                 )?;
             }
         }

crates/red_knot/src/main.rs

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

crates/red_knot/tests/cli.rs

@@ -6,9 +6,9 @@ use std::process::Command;
 use tempfile::TempDir;
 
 /// Specifying an option on the CLI should take precedence over the same setting in the
-/// project's configuration.
+/// project's configuration. Here, this is tested for the Python version.
 #[test]
-fn config_override() -> anyhow::Result<()> {
+fn config_override_python_version() -> anyhow::Result<()> {
     let case = TestCase::with_files([
         (
             "pyproject.toml",
@@ -57,6 +57,67 @@ fn config_override() -> 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
@@ -191,7 +252,7 @@ fn configuration_rule_severity() -> anyhow::Result<()> {
         r#"
             y = 4 / 0
 
-            for a in range(0, y):
+            for a in range(0, int(y)):
                 x = a
 
             print(x)  # possibly-unresolved-reference
@@ -210,7 +271,7 @@ fn configuration_rule_severity() -> anyhow::Result<()> {
     2 | y = 4 / 0
       |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
     warning: lint:possibly-unresolved-reference
@@ -246,7 +307,7 @@ fn configuration_rule_severity() -> anyhow::Result<()> {
     2 | y = 4 / 0
       |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
     Found 1 diagnostic
@@ -267,7 +328,7 @@ fn cli_rule_severity() -> anyhow::Result<()> {
 
         y = 4 / 0
 
-        for a in range(0, y):
+        for a in range(0, int(y)):
             x = a
 
         print(x)  # possibly-unresolved-reference
@@ -297,7 +358,7 @@ fn cli_rule_severity() -> anyhow::Result<()> {
     4 | y = 4 / 0
       |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
     5 |
-    6 | for a in range(0, y):
+    6 | for a in range(0, int(y)):
       |
 
     warning: lint:possibly-unresolved-reference
@@ -344,7 +405,7 @@ fn cli_rule_severity() -> anyhow::Result<()> {
     4 | y = 4 / 0
       |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
     5 |
-    6 | for a in range(0, y):
+    6 | for a in range(0, int(y)):
       |
 
     Found 2 diagnostics
@@ -365,7 +426,7 @@ fn cli_rule_severity_precedence() -> anyhow::Result<()> {
         r#"
         y = 4 / 0
 
-        for a in range(0, y):
+        for a in range(0, int(y)):
             x = a
 
         print(x)  # possibly-unresolved-reference
@@ -384,7 +445,7 @@ fn cli_rule_severity_precedence() -> anyhow::Result<()> {
     2 | y = 4 / 0
       |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
     warning: lint:possibly-unresolved-reference
@@ -421,7 +482,7 @@ fn cli_rule_severity_precedence() -> anyhow::Result<()> {
     2 | y = 4 / 0
       |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
     Found 1 diagnostic
@@ -523,12 +584,12 @@ fn exit_code_only_info() -> anyhow::Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
-    info: revealed-type
+    info: revealed-type: Revealed type
      --> <temp_dir>/test.py:3:1
       |
     2 | from typing_extensions import reveal_type
     3 | reveal_type(1)
-      | ^^^^^^^^^^^^^^ Revealed type is `Literal[1]`
+      | ^^^^^^^^^^^^^^ `Literal[1]`
       |
 
     Found 1 diagnostic
@@ -553,12 +614,12 @@ fn exit_code_only_info_and_error_on_warning_is_true() -> anyhow::Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
-    info: revealed-type
+    info: revealed-type: Revealed type
      --> <temp_dir>/test.py:3:1
       |
     2 | from typing_extensions import reveal_type
     3 | reveal_type(1)
-      | ^^^^^^^^^^^^^^ Revealed type is `Literal[1]`
+      | ^^^^^^^^^^^^^^ `Literal[1]`
       |
 
     Found 1 diagnostic
@@ -753,7 +814,7 @@ fn user_configuration() -> anyhow::Result<()> {
             r#"
             y = 4 / 0
 
-            for a in range(0, y):
+            for a in range(0, int(y)):
                 x = a
 
             print(x)
@@ -780,7 +841,7 @@ fn user_configuration() -> anyhow::Result<()> {
     2 | y = 4 / 0
       |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
     warning: lint:possibly-unresolved-reference
@@ -822,7 +883,7 @@ fn user_configuration() -> anyhow::Result<()> {
     2 | y = 4 / 0
       |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
     error: lint:possibly-unresolved-reference
@@ -991,6 +1052,39 @@ fn concise_diagnostics() -> anyhow::Result<()> {
     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,

crates/red_knot/tests/file_watching.rs

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

crates/red_knot_ide/Cargo.toml

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

crates/red_knot_ide/src/db.rs

@@ -0,0 +1,138 @@
+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, Program};
+    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
+        }
+
+        fn python_version(&self) -> ruff_python_ast::PythonVersion {
+            Program::get(self).python_version(self)
+        }
+    }
+
+    impl Upcast<dyn SourceDb> for TestDb {
+        fn upcast(&self) -> &(dyn SourceDb + 'static) {
+            self
+        }
+        fn upcast_mut(&mut self) -> &mut (dyn SourceDb + 'static) {
+            self
+        }
+    }
+
+    impl Upcast<dyn SemanticDb> for TestDb {
+        fn upcast(&self) -> &(dyn SemanticDb + 'static) {
+            self
+        }
+
+        fn upcast_mut(&mut self) -> &mut dyn SemanticDb {
+            self
+        }
+    }
+
+    #[salsa::db]
+    impl SemanticDb for TestDb {
+        fn is_file_open(&self, file: File) -> bool {
+            !file.path(self).is_vendored_path()
+        }
+
+        fn rule_selection(&self) -> Arc<RuleSelection> {
+            self.rule_selection.clone()
+        }
+
+        fn lint_registry(&self) -> &LintRegistry {
+            default_lint_registry()
+        }
+    }
+
+    #[salsa::db]
+    impl Db for TestDb {}
+
+    #[salsa::db]
+    impl salsa::Database for TestDb {
+        fn salsa_event(&self, event: &dyn Fn() -> salsa::Event) {
+            let event = event();
+            tracing::trace!("event: {event:?}");
+            let mut events = self.events.lock().unwrap();
+            events.push(event);
+        }
+    }
+}

crates/red_knot_ide/src/find_node.rs

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

crates/red_knot_ide/src/goto.rs

@@ -0,0 +1,851 @@
+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
+        }
+    }
+}

crates/red_knot_ide/src/hover.rs

@@ -0,0 +1,602 @@
+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
+        }
+    }
+}

crates/red_knot_ide/src/inlay_hints.rs

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

crates/red_knot_ide/src/lib.rs

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

crates/red_knot_ide/src/markup.rs

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

crates/red_knot_project/Cargo.toml

@@ -16,7 +16,9 @@ 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 }
 
@@ -42,8 +44,13 @@ insta = { workspace = true, features = ["redactions", "ron"] }
 [features]
 default = ["zstd"]
 deflate = ["red_knot_vendored/deflate"]
-schemars = ["dep:schemars", "ruff_db/schemars", "red_knot_python_semantic/schemars"]
+schemars = [
+    "dep:schemars",
+    "ruff_db/schemars",
+    "red_knot_python_semantic/schemars",
+]
 zstd = ["red_knot_vendored/zstd"]
+format = ["ruff_python_formatter"]
 
 [lints]
 workspace = true

crates/red_knot_project/resources/test/corpus/cycle_narrowing_constraints.py

@@ -0,0 +1,15 @@
+# Regression test for https://github.com/astral-sh/ruff/issues/17215
+# panicked in commit 1a6a10b30
+# error message:
+# dependency graph cycle querying all_narrowing_constraints_for_expression(Id(8591))
+
+def f(a: A, b: B, c: C):
+    unknown_a: UA = make_unknown()
+    unknown_b: UB = make_unknown()
+    unknown_c: UC = make_unknown()
+    unknown_d: UD = make_unknown()
+
+    if unknown_a and unknown_b:
+        if unknown_c:
+            if unknown_d:
+                return a, b, c

crates/red_knot_project/resources/test/corpus/cycle_negative_narrowing_constraints.py

@@ -0,0 +1,22 @@
+# Regression test for https://github.com/astral-sh/ruff/issues/17215
+# panicked in commit 1a6a10b30
+# error message:
+# dependency graph cycle querying all_negative_narrowing_constraints_for_expression(Id(859f))
+
+def f(f1: bool, f2: bool, f3: bool, f4: bool):
+    o1: UnknownClass = make_o()
+    o2: UnknownClass = make_o()
+    o3: UnknownClass = make_o()
+    o4: UnknownClass = make_o()
+
+    if f1 and f2 and f3 and f4:
+        if o1 == o2:
+            return None
+        if o2 == o3:
+            return None
+        if o3 == o4:
+            return None
+        if o4 == o1:
+            return None
+
+    return o1, o2, o3, o4

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 specyifing `extra-paths`
+/// because only then is the user in full control of where to insert the path when specifying `extra-paths`
 /// in multiple sources.
 ///
 /// ## Macro

crates/red_knot_project/src/db.rs

@@ -3,9 +3,10 @@ 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::OldDiagnosticTrait;
+use ruff_db::diagnostic::Diagnostic;
 use ruff_db::files::{File, Files};
 use ruff_db::system::System;
 use ruff_db::vendored::VendoredFileSystem;
@@ -55,12 +56,12 @@ impl ProjectDatabase {
     }
 
     /// Checks all open files in the project and its dependencies.
-    pub fn check(&self) -> Result<Vec<Box<dyn OldDiagnosticTrait>>, Cancelled> {
+    pub fn check(&self) -> Result<Vec<Diagnostic>, Cancelled> {
         self.with_db(|db| db.project().check(db))
     }
 
     #[tracing::instrument(level = "debug", skip(self))]
-    pub fn check_file(&self, file: File) -> Result<Vec<Box<dyn OldDiagnosticTrait>>, Cancelled> {
+    pub fn check_file(&self, file: File) -> Result<Vec<Diagnostic>, Cancelled> {
         self.with_db(|db| self.project().check_file(db, file))
     }
 
@@ -103,6 +104,19 @@ 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 {
@@ -135,6 +149,10 @@ impl SourceDb for ProjectDatabase {
     fn files(&self) -> &Files {
         &self.files
     }
+
+    fn python_version(&self) -> ruff_python_ast::PythonVersion {
+        Program::get(self).python_version(self)
+    }
 }
 
 #[salsa::db]
@@ -145,7 +163,7 @@ impl salsa::Database for ProjectDatabase {
         }
 
         let event = event();
-        if matches!(event.kind, salsa::EventKind::WillCheckCancellation { .. }) {
+        if matches!(event.kind, salsa::EventKind::WillCheckCancellation) {
             return;
         }
 
@@ -160,6 +178,32 @@ 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;
@@ -167,7 +211,7 @@ pub(crate) mod tests {
     use salsa::Event;
 
     use red_knot_python_semantic::lint::{LintRegistry, RuleSelection};
-    use red_knot_python_semantic::Db as SemanticDb;
+    use red_knot_python_semantic::{Db as SemanticDb, Program};
     use ruff_db::files::Files;
     use ruff_db::system::{DbWithTestSystem, System, TestSystem};
     use ruff_db::vendored::VendoredFileSystem;
@@ -241,6 +285,10 @@ pub(crate) mod tests {
         fn files(&self) -> &Files {
             &self.files
         }
+
+        fn python_version(&self) -> ruff_python_ast::PythonVersion {
+            Program::get(self).python_version(self)
+        }
     }
 
     impl Upcast<dyn SemanticDb> for TestDb {

crates/red_knot_project/src/db/changes.rs

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

crates/red_knot_project/src/lib.rs

@@ -9,7 +9,10 @@ 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::{DiagnosticId, OldDiagnosticTrait, OldParseDiagnostic, Severity, Span};
+use ruff_db::diagnostic::{
+    create_parse_diagnostic, create_unsupported_syntax_diagnostic, Annotation, Diagnostic,
+    DiagnosticId, Severity, Span,
+};
 use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
 use ruff_db::source::{source_text, SourceTextError};
@@ -17,7 +20,6 @@ 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;
 
@@ -163,24 +165,27 @@ impl Project {
     }
 
     /// Checks all open files in the project and its dependencies.
-    pub(crate) fn check(self, db: &ProjectDatabase) -> Vec<Box<dyn OldDiagnosticTrait>> {
+    pub(crate) fn check(self, db: &ProjectDatabase) -> Vec<Diagnostic> {
         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<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 mut diagnostics: Vec<Diagnostic> = Vec::new();
+        diagnostics.extend(
+            self.settings_diagnostics(db)
+                .iter()
+                .map(OptionDiagnostic::to_diagnostic),
+        );
 
         let files = ProjectFiles::new(db, self);
 
-        diagnostics.extend(files.diagnostics().iter().cloned().map(|diagnostic| {
-            let diagnostic: Box<dyn OldDiagnosticTrait> = Box::new(diagnostic);
-            diagnostic
-        }));
+        diagnostics.extend(
+            files
+                .diagnostics()
+                .iter()
+                .map(IOErrorDiagnostic::to_diagnostic),
+        );
 
         let result = Arc::new(std::sync::Mutex::new(diagnostics));
         let inner_result = Arc::clone(&result);
@@ -208,14 +213,11 @@ impl Project {
         Arc::into_inner(result).unwrap().into_inner().unwrap()
     }
 
-    pub(crate) fn check_file(self, db: &dyn Db, file: File) -> Vec<Box<dyn OldDiagnosticTrait>> {
+    pub(crate) fn check_file(self, db: &dyn Db, file: File) -> Vec<Diagnostic> {
         let mut file_diagnostics: Vec<_> = self
             .settings_diagnostics(db)
             .iter()
-            .map(|diagnostic| {
-                let diagnostic: Box<dyn OldDiagnosticTrait> = Box::new(diagnostic.clone());
-                diagnostic
-            })
+            .map(OptionDiagnostic::to_diagnostic)
             .collect();
 
         let check_diagnostics = check_file_impl(db, file);
@@ -398,35 +400,43 @@ impl Project {
     }
 }
 
-fn check_file_impl(db: &dyn Db, file: File) -> Vec<Box<dyn OldDiagnosticTrait>> {
-    let mut diagnostics: Vec<Box<dyn OldDiagnosticTrait>> = Vec::new();
+fn check_file_impl(db: &dyn Db, file: File) -> Vec<Diagnostic> {
+    let mut diagnostics: Vec<Diagnostic> = 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(Box::new(IOErrorDiagnostic {
-            file: Some(file),
-            error: read_error.clone().into(),
-        }));
+        diagnostics.push(
+            IOErrorDiagnostic {
+                file: Some(file),
+                error: read_error.clone().into(),
+            }
+            .to_diagnostic(),
+        );
         return diagnostics;
     }
 
     let parsed = parsed_module(db.upcast(), file);
-    diagnostics.extend(parsed.errors().iter().map(|error| {
-        let diagnostic: Box<dyn OldDiagnosticTrait> =
-            Box::new(OldParseDiagnostic::new(file, error.clone()));
-        diagnostic
-    }));
+    diagnostics.extend(
+        parsed
+            .errors()
+            .iter()
+            .map(|error| create_parse_diagnostic(file, error)),
+    );
 
-    diagnostics.extend(check_types(db.upcast(), file).iter().map(|diagnostic| {
-        let boxed: Box<dyn OldDiagnosticTrait> = Box::new(diagnostic.clone());
-        boxed
-    }));
+    diagnostics.extend(
+        parsed
+            .unsupported_syntax_errors()
+            .iter()
+            .map(|error| create_unsupported_syntax_diagnostic(file, error)),
+    );
+
+    diagnostics.extend(check_types(db.upcast(), file).into_iter().cloned());
 
     diagnostics.sort_unstable_by_key(|diagnostic| {
         diagnostic
-            .span()
+            .primary_span()
             .and_then(|span| span.range())
             .unwrap_or_default()
             .start()
@@ -494,21 +504,13 @@ pub struct IOErrorDiagnostic {
     error: IOErrorKind,
 }
 
-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
+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
     }
 }
 
@@ -526,12 +528,13 @@ 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 red_knot_python_semantic::{Program, ProgramSettings, PythonPlatform, SearchPathSettings};
     use ruff_db::files::system_path_to_file;
     use ruff_db::source::source_text;
     use ruff_db::system::{DbWithTestSystem, DbWithWritableSystem as _, SystemPath, SystemPathBuf};
     use ruff_db::testing::assert_function_query_was_not_run;
     use ruff_python_ast::name::Name;
+    use ruff_python_ast::PythonVersion;
 
     #[test]
     fn check_file_skips_type_checking_when_file_cant_be_read() -> ruff_db::system::Result<()> {
@@ -539,6 +542,16 @@ mod tests {
         let mut db = TestDb::new(project);
         let path = SystemPath::new("test.py");
 
+        Program::from_settings(
+            &db,
+            ProgramSettings {
+                python_version: PythonVersion::default(),
+                python_platform: PythonPlatform::default(),
+                search_paths: SearchPathSettings::new(vec![SystemPathBuf::from(".")]),
+            },
+        )
+        .expect("Failed to configure program settings");
+
         db.write_file(path, "x = 10")?;
         let file = system_path_to_file(&db, path).unwrap();
 
@@ -550,7 +563,7 @@ mod tests {
         assert_eq!(
             check_file_impl(&db, file)
                 .into_iter()
-                .map(|diagnostic| diagnostic.message().into_owned())
+                .map(|diagnostic| diagnostic.primary_message().to_string())
                 .collect::<Vec<_>>(),
             vec!["Failed to read file: No such file or directory".to_string()]
         );
@@ -566,7 +579,7 @@ mod tests {
         assert_eq!(
             check_file_impl(&db, file)
                 .into_iter()
-                .map(|diagnostic| diagnostic.message().into_owned())
+                .map(|diagnostic| diagnostic.primary_message().to_string())
                 .collect::<Vec<_>>(),
             vec![] as Vec<String>
         );

crates/red_knot_project/src/metadata/options.rs

@@ -2,14 +2,13 @@ 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::{DiagnosticFormat, DiagnosticId, OldDiagnosticTrait, Severity, Span};
+use ruff_db::diagnostic::{Annotation, Diagnostic, DiagnosticFormat, DiagnosticId, 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;
 
@@ -55,20 +54,25 @@ impl Options {
         project_root: &SystemPath,
         system: &dyn System,
     ) -> ProgramSettings {
-        let (python_version, python_platform) = self
+        let python_version = self
             .environment
             .as_ref()
-            .map(|env| {
-                (
-                    env.python_version.as_deref().copied(),
-                    env.python_platform.as_deref(),
-                )
-            })
+            .and_then(|env| env.python_version.as_deref().copied())
             .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_version.unwrap_or_default(),
-            python_platform: python_platform.cloned().unwrap_or_default(),
+            python_version,
+            python_platform,
             search_paths: self.to_search_path_settings(project_root, system),
         }
     }
@@ -121,7 +125,7 @@ impl Options {
                         .ok()
                         .map(PythonPath::from_virtual_env_var)
                 })
-                .unwrap_or_else(|| PythonPath::KnownSitePackages(vec![])),
+                .unwrap_or_else(|| PythonPath::Discover(project_root.to_path_buf())),
         }
     }
 
@@ -225,7 +229,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 execute the source code.
+    /// Specifies the version of Python that will be used to analyze 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
@@ -234,11 +238,16 @@ 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 execute the source code.
+    /// Specifies the target platform that will be used to analyze 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 `all` or the current platform in the LSP use case.
+    /// 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
     #[serde(skip_serializing_if = "Option::is_none")]
     pub python_platform: Option<RangedValue<PythonPlatform>>,
 
@@ -397,22 +406,14 @@ impl OptionDiagnostic {
     fn with_span(self, span: Option<Span>) -> Self {
         OptionDiagnostic { span, ..self }
     }
-}
 
-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
+    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)
+        }
     }
 }

crates/red_knot_project/tests/check.rs

@@ -6,7 +6,9 @@ use ruff_db::parsed::parsed_module;
 use ruff_db::system::{SystemPath, SystemPathBuf, TestSystem};
 use ruff_python_ast::visitor::source_order;
 use ruff_python_ast::visitor::source_order::SourceOrderVisitor;
-use ruff_python_ast::{self as ast, Alias, Expr, Parameter, ParameterWithDefault, Stmt};
+use ruff_python_ast::{
+    self as ast, Alias, Comprehension, Expr, Parameter, ParameterWithDefault, Stmt,
+};
 
 fn setup_db(project_root: &SystemPath, system: TestSystem) -> anyhow::Result<ProjectDatabase> {
     let project = ProjectMetadata::discover(project_root, &system)?;
@@ -258,6 +260,14 @@ impl SourceOrderVisitor<'_> for PullTypesVisitor<'_> {
         source_order::walk_expr(self, expr);
     }
 
+    fn visit_comprehension(&mut self, comprehension: &Comprehension) {
+        self.visit_expr(&comprehension.iter);
+        self.visit_target(&comprehension.target);
+        for if_expr in &comprehension.ifs {
+            self.visit_expr(if_expr);
+        }
+    }
+
     fn visit_parameter(&mut self, parameter: &Parameter) {
         let _ty = parameter.inferred_type(&self.model);
 

crates/red_knot_python_semantic/mdtest.py

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

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

@@ -2,7 +2,7 @@
 
 References:
 
-- <https://typing.readthedocs.io/en/latest/spec/callables.html#callable>
+- <https://typing.python.org/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
@@ -237,6 +237,11 @@ def _(c: Callable[[Concatenate[int, str, ...], int], int]):
 
 ## Using `typing.ParamSpec`
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 Using a `ParamSpec` in a `Callable` annotation:
 
 ```py
@@ -289,7 +294,7 @@ def _(c: Callable[[int, Unpack[Ts]], int]):
 from typing import Callable
 
 def _(c: Callable[[int], int]):
-    reveal_type(c.__init__)  # revealed: Literal[__init__]
+    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__`
@@ -299,4 +304,4 @@ def _(c: Callable[[int], int]):
     reveal_type(c.__call__)  # revealed: Unknown
 ```
 
-[gradual form]: https://typing.readthedocs.io/en/latest/spec/glossary.html#term-gradual-form
+[gradual form]: https://typing.python.org/en/latest/spec/glossary.html#term-gradual-form

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

@@ -45,3 +45,135 @@ class Foo: ...
 
 reveal_type(get_foo())  # revealed: Foo
 ```
+
+## Deferred self-reference annotations in a class definition
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```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
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```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
+```
+
+## Base class references
+
+### Not deferred by __future__.annotations
+
+```py
+from __future__ import annotations
+
+class A(B):  # error: [unresolved-reference]
+    pass
+
+class B:
+    pass
+```
+
+### Deferred in stub files
+
+```pyi
+class A(B): ...
+class 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.readthedocs.io/en/latest/spec/special-types.html#special-cases-for-float-and-complex)
+[the specification](https://typing.python.org/en/latest/spec/special-types.html#special-cases-for-float-and-complex)
 
 ## float
 

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

@@ -89,7 +89,7 @@ def _(
     reveal_type(k)  # revealed: Unknown
     reveal_type(p)  # revealed: Unknown
     reveal_type(q)  # revealed: int | Unknown
-    reveal_type(r)  # revealed: @Todo(generics)
+    reveal_type(r)  # revealed: @Todo(unknown type subscript)
 ```
 
 ## Invalid Collection based AST nodes

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

@@ -1,6 +1,6 @@
 # Literal
 
-<https://typing.readthedocs.io/en/latest/spec/literal.html#literals>
+<https://typing.python.org/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: Unknown | Literal[0]
+    reveal_type(b1)  # revealed: @Todo(Attribute access on enum classes)
 
 # error: [invalid-type-form]
 invalid1: Literal[3 + 4]
@@ -68,7 +68,7 @@ def x(
     a3: Literal[Literal["w"], Literal["r"], Literal[Literal["w+"]]],
     a4: Literal[True] | Literal[1, 2] | Literal["foo"],
 ):
-    reveal_type(a1)  # revealed: Literal[1, 2, 3, "foo", 5] | None
+    reveal_type(a1)  # revealed: Literal[1, 2, 3, 5, "foo"] | None
     reveal_type(a2)  # revealed: Literal["w", "r"]
     reveal_type(a3)  # revealed: Literal["w", "r", "w+"]
     reveal_type(a4)  # revealed: Literal[True, 1, 2, "foo"]
@@ -108,7 +108,7 @@ def union_example(
         None,
     ],
 ):
-    reveal_type(x)  # revealed: Unknown | Literal[-1, "A", b"A", b"\x00", b"\x07", 0, 1, "B", "foo", "bar", True] | None
+    reveal_type(x)  # revealed: Unknown | Literal[-1, 0, 1, "A", "B", "foo", "bar", b"A", b"\x00", b"\x07", True] | None
 ```
 
 ## Detecting Literal outside typing and typing_extensions
@@ -137,7 +137,7 @@ from other import Literal
 a1: Literal[26]
 
 def f():
-    reveal_type(a1)  # revealed: @Todo(generics)
+    reveal_type(a1)  # revealed: @Todo(unknown type subscript)
 ```
 
 ## Detecting typing_extensions.Literal

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

@@ -72,13 +72,11 @@ reveal_type(baz)  # revealed: Literal["bazfoo"]
 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 decorated function)
+reveal_type(foo.join(qux))  # revealed: LiteralString
 
 template: LiteralString = "{}, {}"
 reveal_type(template)  # revealed: Literal["{}, {}"]
-# TODO: Infer `LiteralString`
-reveal_type(template.format(foo, bar))  # revealed: @Todo(return type of decorated function)
+reveal_type(template.format(foo, bar))  # revealed: LiteralString
 ```
 
 ### Assignability
@@ -147,4 +145,4 @@ def f():
     reveal_type(x)  # revealed: LiteralString
 ```
 
-[1]: https://typing.readthedocs.io/en/latest/spec/literal.html#literalstring
+[1]: https://typing.python.org/en/latest/spec/literal.html#literalstring

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

@@ -8,7 +8,11 @@ Currently, red-knot doesn't support `typing.NewType` in type annotations.
 from typing_extensions import NewType
 from types import GenericAlias
 
+X = GenericAlias(type, ())
 A = NewType("A", int)
+# TODO: typeshed for `typing.GenericAlias` uses `type` for the first argument. `NewType` should be special-cased
+# to be compatible with `type`
+# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `type`, found `NewType`"
 B = GenericAlias(A, ())
 
 def _(

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

@@ -1,5 +1,10 @@
 # Starred expression annotations
 
+```toml
+[environment]
+python-version = "3.11"
+```
+
 Type annotations for `*args` can be starred expressions themselves:
 
 ```py

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

@@ -67,21 +67,24 @@ import typing
 
 ####################
 ### Built-ins
+####################
 
 class ListSubclass(typing.List): ...
 
-# revealed: tuple[Literal[ListSubclass], Literal[list], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(protocol), Literal[object]]
+# TODO: generic protocols
+# revealed: tuple[Literal[ListSubclass], Literal[list], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), @Todo(`Generic[]` subscript), Literal[object]]
 reveal_type(ListSubclass.__mro__)
 
 class DictSubclass(typing.Dict): ...
 
-# TODO: should have `Generic`, should not have `Unknown`
-# revealed: tuple[Literal[DictSubclass], Literal[dict], Unknown, Literal[object]]
+# TODO: generic protocols
+# revealed: tuple[Literal[DictSubclass], Literal[dict], Literal[MutableMapping], Literal[Mapping], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), @Todo(`Generic[]` subscript), Literal[object]]
 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: generic protocols
+# revealed: tuple[Literal[SetSubclass], Literal[set], Literal[MutableSet], Literal[AbstractSet], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), @Todo(`Generic[]` subscript), Literal[object]]
 reveal_type(SetSubclass.__mro__)
 
 class FrozenSetSubclass(typing.FrozenSet): ...
@@ -92,11 +95,12 @@ reveal_type(FrozenSetSubclass.__mro__)
 
 ####################
 ### `collections`
+####################
 
 class ChainMapSubclass(typing.ChainMap): ...
 
-# TODO: Should be (ChainMapSubclass, ChainMap, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
-# revealed: tuple[Literal[ChainMapSubclass], Literal[ChainMap], Unknown, Literal[object]]
+# TODO: generic protocols
+# revealed: tuple[Literal[ChainMapSubclass], Literal[ChainMap], Literal[MutableMapping], Literal[Mapping], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), @Todo(`Generic[]` subscript), Literal[object]]
 reveal_type(ChainMapSubclass.__mro__)
 
 class CounterSubclass(typing.Counter): ...
@@ -113,7 +117,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: generic protocols
+# revealed: tuple[Literal[DequeSubclass], Literal[deque], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), @Todo(`Generic[]` subscript), Literal[object]]
 reveal_type(DequeSubclass.__mro__)
 
 class OrderedDictSubclass(typing.OrderedDict): ...

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

@@ -105,7 +105,7 @@ def f1(
 from typing import Literal
 
 def f(v: Literal["a", r"b", b"c", "d" "e", "\N{LATIN SMALL LETTER F}", "\x67", """h"""]):
-    reveal_type(v)  # revealed: Literal["a", "b", b"c", "de", "f", "g", "h"]
+    reveal_type(v)  # revealed: Literal["a", "b", "de", "f", "g", "h", b"c"]
 ```
 
 ## Class variables

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

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

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

@@ -41,7 +41,7 @@ class Foo:
 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
+from typing_extensions import Unpack, TypeGuard, TypeIs, Concatenate, ParamSpec, Generic
 
 def _(
     a: Unpack,  # error: [invalid-type-form] "`typing.Unpack` requires exactly one argument when used in a type expression"
@@ -49,6 +49,7 @@ def _(
     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,
+    f: Generic,  # error: [invalid-type-form] "`typing.Generic` is not allowed in type expressions"
 ) -> None:
     reveal_type(a)  # revealed: Unknown
     reveal_type(b)  # revealed: Unknown
@@ -56,7 +57,7 @@ def _(
     reveal_type(d)  # revealed: Unknown
 
     def foo(a_: e) -> None:
-        reveal_type(a_)  # revealed: @Todo(Support for `typing.ParamSpec` instances in type expressions)
+        reveal_type(a_)  # revealed: @Todo(Support for `typing.ParamSpec`)
 ```
 
 ## Inheritance
@@ -65,7 +66,7 @@ You can't inherit from most of these. `typing.Callable` is an exception.
 
 ```py
 from typing import Callable
-from typing_extensions import Self, Unpack, TypeGuard, TypeIs, Concatenate
+from typing_extensions import Self, Unpack, TypeGuard, TypeIs, Concatenate, Generic
 
 class A(Self): ...  # error: [invalid-base]
 class B(Unpack): ...  # error: [invalid-base]
@@ -73,12 +74,18 @@ class C(TypeGuard): ...  # error: [invalid-base]
 class D(TypeIs): ...  # error: [invalid-base]
 class E(Concatenate): ...  # error: [invalid-base]
 class F(Callable): ...
+class G(Generic): ...  # error: [invalid-base] "Cannot inherit from plain `Generic`"
 
 reveal_type(F.__mro__)  # revealed: tuple[Literal[F], @Todo(Support for Callable as a base class), Literal[object]]
 ```
 
 ## Subscriptability
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 Some of these are not subscriptable:
 
 ```py

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

@@ -25,6 +25,11 @@ x = "foo"  # error: [invalid-assignment] "Object of type `Literal["foo"]` is not
 
 ## Tuple annotations are understood
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 `module.py`:
 
 ```py
@@ -52,13 +57,11 @@ 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
+# TODO: homogeneous tuples, PEP-646 tuples, generics
 reveal_type(e)  # revealed: @Todo(full tuple[...] support)
 reveal_type(f)  # revealed: @Todo(full tuple[...] support)
 reveal_type(g)  # revealed: @Todo(full tuple[...] support)
-
-# TODO: support more kinds of type expressions in annotations
-reveal_type(h)  # revealed: @Todo(full tuple[...] support)
+reveal_type(h)  # revealed: tuple[@Todo(specialized non-generic class), @Todo(specialized non-generic class)]
 
 reveal_type(i)  # revealed: tuple[str | int, str | int]
 reveal_type(j)  # revealed: tuple[str | int]

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -41,8 +41,7 @@ reveal_type(c_instance.declared_only)  # revealed: bytes
 
 reveal_type(c_instance.declared_and_bound)  # revealed: bool
 
-# We probably don't want to emit a diagnostic for this being possibly undeclared/unbound.
-# mypy and pyright do not show an error here.
+# error: [possibly-unbound-attribute]
 reveal_type(c_instance.possibly_undeclared_unbound)  # revealed: str
 
 # This assignment is fine, as we infer `Unknown | Literal[1, "a"]` for `inferred_from_value`.
@@ -303,7 +302,7 @@ class C:
 
 c_instance = C()
 reveal_type(c_instance.a)  # revealed: Unknown | Literal[1]
-reveal_type(c_instance.b)  # revealed: Unknown | @Todo(starred unpacking)
+reveal_type(c_instance.b)  # revealed: Unknown
 ```
 
 #### Attributes defined in for-loop (unpacking)
@@ -339,8 +338,10 @@ 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
 ```
 
@@ -396,21 +397,33 @@ class IntIterable:
     def __iter__(self) -> IntIterator:
         return IntIterator()
 
+class TupleIterator:
+    def __next__(self) -> tuple[int, str]:
+        return (1, "a")
+
+class TupleIterable:
+    def __iter__(self) -> TupleIterator:
+        return TupleIterator()
+
 class C:
     def __init__(self) -> None:
         [... for self.a in IntIterable()]
+        [... for (self.b, self.c) in TupleIterable()]
+        [... for self.d in IntIterable() for self.e in IntIterable()]
 
 c_instance = C()
 
-# TODO: Should be `Unknown | int`
-# error: [unresolved-attribute]
-reveal_type(c_instance.a)  # revealed: Unknown
+reveal_type(c_instance.a)  # revealed: Unknown | int
+reveal_type(c_instance.b)  # revealed: Unknown | int
+reveal_type(c_instance.c)  # revealed: Unknown | str
+reveal_type(c_instance.d)  # revealed: Unknown | int
+reveal_type(c_instance.e)  # revealed: Unknown | int
 ```
 
 #### Conditionally declared / bound attributes
 
-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.
+Attributes are possibly unbound if they, or the method to which they are added are conditionally
+declared / bound.
 
 ```py
 def flag() -> bool:
@@ -428,9 +441,13 @@ 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]
 ```
 
@@ -539,10 +556,88 @@ class C:
         if (2 + 3) < 4:
             self.x: str = "a"
 
-# 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
+# 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]
 ```
 
 #### Diagnostics are reported for the right-hand side of attribute assignments
@@ -1046,13 +1141,18 @@ def _(flag: bool):
         def __init(self):
             if flag:
                 self.x = 1
+                self.y = "a"
+            else:
+                self.y = "b"
 
-    # Emitting a diagnostic in a case like this is not something we support, and it's unclear
-    # if we ever will (or want to)
+    # error: [possibly-unbound-attribute]
     reveal_type(Foo().x)  # revealed: Unknown | Literal[1]
 
-    # Same here
+    # error: [possibly-unbound-attribute]
     Foo().x = 2
+
+    reveal_type(Foo().y)  # revealed: Unknown | Literal["a", "b"]
+    Foo().y = "c"
 ```
 
 ### Unions with all paths unbound
@@ -1285,7 +1385,7 @@ from typing import Any
 class Foo(Any): ...
 
 reveal_type(Foo.bar)  # revealed: Any
-reveal_type(Foo.__repr__)  # revealed: Literal[__repr__] & Any
+reveal_type(Foo.__repr__)  # revealed: (def __repr__(self) -> str) & Any
 ```
 
 Similar principles apply if `Any` appears in the middle of an inheritance hierarchy:
@@ -1395,6 +1495,59 @@ def _(ns: argparse.Namespace):
     reveal_type(ns.whatever)  # revealed: Any
 ```
 
+## Classes with custom `__setattr__` methods
+
+### Basic
+
+If a type provides a custom `__setattr__` method, we use the parameter type of that method as the
+type to validate attribute assignments. Consider the following `CustomSetAttr` class:
+
+```py
+class CustomSetAttr:
+    def __setattr__(self, name: str, value: int) -> None:
+        pass
+```
+
+We can set arbitrary attributes on instances of this class:
+
+```py
+c = CustomSetAttr()
+
+c.whatever = 42
+```
+
+### Type of the `name` parameter
+
+If the `name` parameter of the `__setattr__` method is annotated with a (union of) literal type(s),
+we only consider the attribute assignment to be valid if the assigned attribute is one of them:
+
+```py
+from typing import Literal
+
+class Date:
+    def __setattr__(self, name: Literal["day", "month", "year"], value: int) -> None:
+        pass
+
+date = Date()
+date.day = 8
+date.month = 4
+date.year = 2025
+
+# error: [unresolved-attribute] "Can not assign object of `Literal["UTC"]` to attribute `tz` on type `Date` with custom `__setattr__` method."
+date.tz = "UTC"
+```
+
+### `argparse.Namespace`
+
+A standard library example of a class with a custom `__setattr__` method is `argparse.Namespace`:
+
+```py
+import argparse
+
+def _(ns: argparse.Namespace):
+    ns.whatever = 42
+```
+
 ## Objects of all types have a `__class__` method
 
 The type of `x.__class__` is the same as `x`'s meta-type. `x.__class__` is always the same value as
@@ -1524,14 +1677,14 @@ functions are instances of that class:
 def f(): ...
 
 reveal_type(f.__defaults__)  # revealed: @Todo(full tuple[...] support) | None
-reveal_type(f.__kwdefaults__)  # revealed: @Todo(generics) | None
+reveal_type(f.__kwdefaults__)  # revealed: @Todo(specialized non-generic class) | None
 ```
 
 Some attributes are special-cased, however:
 
 ```py
 reveal_type(f.__get__)  # revealed: <method-wrapper `__get__` of `f`>
-reveal_type(f.__call__)  # revealed: <bound method `__call__` of `Literal[f]`>
+reveal_type(f.__call__)  # revealed: <method-wrapper `__call__` of `f`>
 ```
 
 ### Int-literal attributes
@@ -1540,8 +1693,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 `bit_length` of `Literal[2]`>
-reveal_type((2).denominator)  # revealed: @Todo(@property)
+reveal_type((2).bit_length)  # revealed: bound method Literal[2].bit_length() -> int
+reveal_type((2).denominator)  # revealed: Literal[1]
 ```
 
 Some attributes are special-cased, however:
@@ -1557,8 +1710,10 @@ Most attribute accesses on bool-literal types are delegated to `builtins.bool`,
 bools are instances of that class:
 
 ```py
-reveal_type(True.__and__)  # revealed: <bound method `__and__` of `Literal[True]`>
-reveal_type(False.__or__)  # revealed: <bound method `__or__` of `Literal[False]`>
+# revealed: Overload[(value: bool, /) -> bool, (value: int, /) -> int]
+reveal_type(True.__and__)
+# revealed: Overload[(value: bool, /) -> bool, (value: int, /) -> int]
+reveal_type(False.__or__)
 ```
 
 Some attributes are special-cased, however:
@@ -1573,8 +1728,10 @@ 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 `join` of `Literal[b"foo"]`>
-reveal_type(b"foo".endswith)  # revealed: <bound method `endswith` of `Literal[b"foo"]`>
+# revealed: bound method Literal[b"foo"].join(iterable_of_bytes: @Todo(specialized non-generic class), /) -> bytes
+reveal_type(b"foo".join)
+# 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)
 ```
 
 ## Instance attribute edge cases
@@ -1675,6 +1832,89 @@ def f(never: Never):
     never.another_attribute = never
 ```
 
+### Cyclic implicit attributes
+
+Inferring types for undeclared implicit attributes can be cyclic:
+
+```py
+class C:
+    def __init__(self):
+        self.x = 1
+
+    def copy(self, other: "C"):
+        self.x = other.x
+
+reveal_type(C().x)  # revealed: Unknown | Literal[1]
+```
+
+If the only assignment to a name is cyclic, we just infer `Unknown` for that attribute:
+
+```py
+class D:
+    def copy(self, other: "D"):
+        self.x = other.x
+
+reveal_type(D().x)  # revealed: Unknown
+```
+
+If there is an annotation for a name, we don't try to infer any type from the RHS of assignments to
+that name, so these cases don't trigger any cycle:
+
+```py
+class E:
+    def __init__(self):
+        self.x: int = 1
+
+    def copy(self, other: "E"):
+        self.x = other.x
+
+reveal_type(E().x)  # revealed: int
+
+class F:
+    def __init__(self):
+        self.x = 1
+
+    def copy(self, other: "F"):
+        self.x: int = other.x
+
+reveal_type(F().x)  # revealed: int
+
+class G:
+    def copy(self, other: "G"):
+        self.x: int = other.x
+
+reveal_type(G().x)  # revealed: int
+```
+
+We can even handle cycles involving multiple classes:
+
+```py
+class A:
+    def __init__(self):
+        self.x = 1
+
+    def copy(self, other: "B"):
+        self.x = other.x
+
+class B:
+    def copy(self, other: "A"):
+        self.x = other.x
+
+reveal_type(B().x)  # revealed: Unknown | Literal[1]
+reveal_type(A().x)  # revealed: Unknown | Literal[1]
+```
+
+This case additionally tests our union/intersection simplification logic:
+
+```py
+class H:
+    def __init__(self):
+        self.x = 1
+
+    def copy(self, other: "H"):
+        self.x = other.x or self.x
+```
+
 ### Builtin types attributes
 
 This test can probably be removed eventually, but we currently include it because we do not yet
@@ -1709,6 +1949,23 @@ 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)
+```
+
 ## References
 
 Some of the tests in the *Class and instance variables* section draw inspiration from
@@ -1716,5 +1973,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.readthedocs.io/en/latest/spec/class-compat.html#classvar
+[typing spec on `classvar`]: https://typing.python.org/en/latest/spec/class-compat.html#classvar
 [`typing.classvar`]: https://docs.python.org/3/library/typing.html#typing.ClassVar

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

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,19 +300,17 @@ 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
 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 decorated function)
+reveal_type("foo" + A())  # revealed: A
 
 reveal_type(A() + b"foo")  # revealed: A
 # TODO should be `A` since `bytes.__add__` doesn't support `A` instances
@@ -320,16 +318,14 @@ 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 decorated function)
+reveal_type(() + A())  # revealed: @Todo(full tuple[...] support)
 
 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`:
 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 decorated function)
+reveal_type(literal_string_instance + A())  # revealed: A
 ```
 
 ## Operations involving instances of classes inheriting from `Any`
@@ -371,6 +367,39 @@ 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
@@ -433,7 +462,7 @@ the unreflected dunder of the left-hand operand. For context, see
 
 ```py
 class Foo:
-    def __radd__(self, other: Foo) -> Foo:
+    def __radd__(self, other: "Foo") -> "Foo":
         return self
 
 # error: [unsupported-operator]

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

@@ -50,9 +50,23 @@ 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 decorated function)
-    reveal_type(2**x)  # revealed: @Todo(return type of decorated function)
-    reveal_type(x**x)  # revealed: @Todo(return type of decorated function)
+    reveal_type(x**2)  # revealed: int
+    # TODO: should be `Any` (overload 5 on `__pow__`), requires correct overload matching
+    reveal_type(2**x)  # revealed: int
+    # TODO: should be `Any` (overload 5 on `__pow__`), requires correct overload matching
+    reveal_type(x**x)  # revealed: int
+```
+
+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
 ```
 
 ## Division by Zero

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

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

crates/red_knot_python_semantic/resources/mdtest/boolean/short_circuit.md

@@ -43,7 +43,7 @@ if True and (x := 1):
 
 ```py
 def _(flag: bool):
-    flag or (x := 1) or reveal_type(x)  # revealed: Literal[1]
+    flag or (x := 1) or reveal_type(x)  # revealed: Never
 
     # error: [unresolved-reference]
     flag or reveal_type(y) or (y := 1)  # revealed: Unknown

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

@@ -9,8 +9,8 @@ def _(c: Callable[[], int]):
 def _(c: Callable[[int, str], int]):
     reveal_type(c(1, "a"))  # revealed: int
 
-    # error: [invalid-argument-type] "Object of type `Literal["a"]` cannot be assigned to parameter 1; expected type `int`"
-    # error: [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 2; expected type `str`"
+    # 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
 ```
 

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

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

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

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

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

@@ -1,7 +1,325 @@
 # 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
 ```

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

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

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

@@ -21,6 +21,11 @@ reveal_type(get_int_async())  # revealed: @Todo(generic types.CoroutineType)
 
 ## Generic
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 ```py
 def get_int[T]() -> int:
     return 42
@@ -43,8 +48,7 @@ def decorator(func) -> Callable[[], int]:
 def bar() -> str:
     return "bar"
 
-# TODO: should reveal `int`, as the decorator replaces `bar` with `foo`
-reveal_type(bar())  # revealed: @Todo(return type of decorated function)
+reveal_type(bar())  # revealed: int
 ```
 
 ## Invalid callable
@@ -73,7 +77,7 @@ def _(flag: bool):
 def f(x: int) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
+# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
 reveal_type(f("foo"))  # revealed: int
 ```
 
@@ -83,7 +87,7 @@ reveal_type(f("foo"))  # revealed: int
 def f(x: int, /) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
+# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
 reveal_type(f("foo"))  # revealed: int
 ```
 
@@ -93,7 +97,7 @@ reveal_type(f("foo"))  # revealed: int
 def f(*args: int) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `*args` of function `f`; expected type `int`"
+# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
 reveal_type(f("foo"))  # revealed: int
 ```
 
@@ -103,7 +107,7 @@ reveal_type(f("foo"))  # revealed: int
 def f(x: int) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `x` of function `f`; expected type `int`"
+# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
 reveal_type(f(x="foo"))  # revealed: int
 ```
 
@@ -113,7 +117,7 @@ reveal_type(f(x="foo"))  # revealed: int
 def f(*, x: int) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `x` of function `f`; expected type `int`"
+# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
 reveal_type(f(x="foo"))  # revealed: int
 ```
 
@@ -123,7 +127,7 @@ reveal_type(f(x="foo"))  # revealed: int
 def f(**kwargs: int) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `**kwargs` of function `f`; expected type `int`"
+# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
 reveal_type(f(x="foo"))  # revealed: int
 ```
 
@@ -133,8 +137,8 @@ reveal_type(f(x="foo"))  # revealed: int
 def f(x: int = 1, y: str = "foo") -> int:
     return 1
 
-# 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`"
+# 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"]`"
 reveal_type(f(y=2, x="bar"))  # revealed: int
 ```
 

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

@@ -56,10 +56,11 @@ We can access attributes on objects of all kinds:
 ```py
 import sys
 
-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(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(1, "real"))  # revealed: Literal[real]
+reveal_type(inspect.getattr_static(1, "real"))  # revealed: property
 ```
 
 (Implicit) instance attributes can also be accessed through `inspect.getattr_static`:
@@ -114,7 +115,7 @@ inspect.getattr_static()
 # error: [missing-argument] "No argument provided for required parameter `attr`"
 inspect.getattr_static(C())
 
-# error: [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 2 (`attr`) of function `getattr_static`; expected type `str`"
+# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[1]`"
 inspect.getattr_static(C(), 1)
 
 # error: [too-many-positional-arguments] "Too many positional arguments to function `getattr_static`: expected 3, got 4"
@@ -143,8 +144,9 @@ 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 `Literal[index]`
-    reveal_type(inspect.getattr_static(tuple_of_any, "index", "default"))  # revealed: Literal[index] | 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"))
 ```
 
 [official documentation]: https://docs.python.org/3/library/inspect.html#inspect.getattr_static

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] "Object of type `Literal[1]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `str`"
+# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[1]`"
 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] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
+# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
 # error: [missing-argument] "No argument provided for required parameter `y` of function `f`"
 reveal_type(f("foo"))  # revealed: int
 ```

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: Literal[f]
+reveal_type(getattr_static(C, "f"))  # revealed: def f(self, x: int) -> str
 
 reveal_type(getattr_static(C, "f").__get__)  # revealed: <method-wrapper `__get__` of `f`>
 
-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`>
+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
 ```
 
 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: Literal[f]
-reveal_type(C().f)  # revealed: <bound method `f` of `C`>
+reveal_type(C.f)  # revealed: def f(self, x: int) -> str
+reveal_type(C().f)  # revealed: bound method C.f(x: int) -> str
 ```
 
 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: Literal[f]
+reveal_type(bound_method.__func__)  # revealed: def f(self, x: int) -> str
 ```
 
 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 `f` of `D`>
+reveal_type(D().f)  # revealed: bound method D.f(x: int) -> str
 ```
 
 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 `__hash__` of `MethodType`>
+reveal_type(bound_method.__hash__)  # revealed: bound method MethodType.__hash__() -> int
 ```
 
 If an attribute is not available on the bound method object, it will be looked up on the underlying
@@ -94,7 +94,7 @@ function object. We model this explicitly, which means that we can access `__kwd
 methods, even though it is not available on `types.MethodType`:
 
 ```py
-reveal_type(bound_method.__kwdefaults__)  # revealed: @Todo(generics) | None
+reveal_type(bound_method.__kwdefaults__)  # revealed: @Todo(specialized non-generic class) | None
 ```
 
 ## Basic method calls on class objects and instances
@@ -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 `f` of `A`> | <bound method `f` of `B`>
+    reveal_type(a_or_b.f)  # revealed: (bound method A.f() -> int) | (bound method B.f() -> str)
     reveal_type(a_or_b.f())  # revealed: int | str
 
-    reveal_type(any_or_a.f)  # revealed: Any | <bound method `f` of `A`>
+    reveal_type(any_or_a.f)  # revealed: Any | (bound method A.f() -> int)
     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 `__or__` of `typing.TypeAliasType`>
+reveal_type(IntOrStr.__or__)  # revealed: bound method typing.TypeAliasType.__or__(right: Any) -> _SpecialForm
 ```
 
 ## Error cases: Calling `__get__` for methods
@@ -270,7 +270,7 @@ class Meta(type):
 class C(metaclass=Meta):
     pass
 
-reveal_type(C.f)  # revealed: <bound method `f` of `Literal[C]`>
+reveal_type(C.f)  # revealed: bound method Literal[C].f(arg: int) -> str
 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 `f` of `Literal[C]`>
-reveal_type(C().f)  # revealed: <bound method `f` of `type[C]`>
+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
 ```
 
 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] "Object of type `Literal[D]` cannot be assigned to parameter 1 (`cls`) of bound method `f`; expected type `D`"
+# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `D`, found `Literal[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 `f` of `Literal[Derived]`>
-reveal_type(Derived().f)  # revealed: <bound method `f` of `type[Derived]`>
+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(1))  # revealed: str
 reveal_type(Derived().f(1))  # revealed: str
@@ -379,26 +379,31 @@ class C:
     @classmethod
     def f(cls): ...
 
-reveal_type(getattr_static(C, "f"))  # revealed: Literal[f]
+reveal_type(getattr_static(C, "f"))  # revealed: def f(cls) -> Unknown
 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 `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]`>
+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
 ```
 
 The `owner` argument takes precedence over the `instance` argument:
 
 ```py
-reveal_type(getattr_static(C, "f").__get__("dummy", C))  # revealed: <bound method `f` of `Literal[C]`>
+reveal_type(getattr_static(C, "f").__get__("dummy", C))  # revealed: bound method Literal[C].f() -> Unknown
 ```
 
 ### Classmethods mixed with other decorators
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 When a `@classmethod` is additionally decorated with another decorator, it is still treated as a
 class method:
 
@@ -419,14 +424,10 @@ class C:
     def f2(cls: type[C], x: int) -> str:
         return "a"
 
-# TODO: We do not support decorators yet (only limited special cases). Eventually,
-# these should all return `str`:
-
-reveal_type(C.f1(1))  # revealed: @Todo(return type of decorated function)
-reveal_type(C().f1(1))  # revealed: @Todo(return type of decorated function)
-
-reveal_type(C.f2(1))  # revealed: @Todo(return type of decorated function)
-reveal_type(C().f2(1))  # revealed: @Todo(return type of decorated function)
+reveal_type(C.f1(1))  # revealed: str
+reveal_type(C().f1(1))  # revealed: str
+reveal_type(C.f2(1))  # revealed: str
+reveal_type(C().f2(1))  # revealed: str
 ```
 
 [functions and methods]: https://docs.python.org/3/howto/descriptor.html#functions-and-methods

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

@@ -0,0 +1,50 @@
+# `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

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

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

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

@@ -94,7 +94,7 @@ def _(flag: bool):
     else:
         f = f2
 
-    # error: [invalid-argument-type] "Object of type `Literal[3]` cannot be assigned to parameter 1 (`a`) of function `f2`; expected type `str`"
+    # error: [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[3]`"
     x = f(3)
     reveal_type(x)  # revealed: int | str
 ```
@@ -175,3 +175,41 @@ def _(flag: bool):
     # 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]
 ```
+
+## Size limit on unions of literals
+
+Beyond a certain size, large unions of literal types collapse to their nearest super-type (`int`,
+`bytes`, `str`).
+
+```py
+from typing import Literal
+
+def _(literals_2: Literal[0, 1], b: bool, flag: bool):
+    literals_4 = 2 * literals_2 + literals_2  # Literal[0, 1, 2, 3]
+    literals_16 = 4 * literals_4 + literals_4  # Literal[0, 1, .., 15]
+    literals_64 = 4 * literals_16 + literals_4  # Literal[0, 1, .., 63]
+    literals_128 = 2 * literals_64 + literals_2  # Literal[0, 1, .., 127]
+
+    # Going beyond the MAX_UNION_LITERALS limit (currently 200):
+    literals_256 = 16 * literals_16 + literals_16
+    reveal_type(literals_256)  # revealed: int
+
+    # Going beyond the limit when another type is already part of the union
+    bool_and_literals_128 = b if flag else literals_128  # bool | Literal[0, 1, ..., 127]
+    literals_128_shifted = literals_128 + 128  # Literal[128, 129, ..., 255]
+
+    # Now union the two:
+    reveal_type(bool_and_literals_128 if flag else literals_128_shifted)  # revealed: int
+```
+
+## Simplifying gradually-equivalent types
+
+If two types are gradually equivalent, we can keep just one of them in a union:
+
+```py
+from typing import Any, Union
+from knot_extensions import Intersection, Not
+
+def _(x: Union[Intersection[Any, Not[int]], Intersection[Any, Not[int]]]):
+    reveal_type(x)  # revealed: Any & ~int
+```

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

@@ -0,0 +1,410 @@
+# Super
+
+Python defines the terms *bound super object* and *unbound super object*.
+
+An **unbound super object** is created when `super` is called with only one argument. (e.g.
+`super(A)`). This object may later be bound using the `super.__get__` method. However, this form is
+rarely used in practice.
+
+A **bound super object** is created either by calling `super(pivot_class, owner)` or by using the
+implicit form `super()`, where both the pivot class and the owner are inferred. This is the most
+common usage.
+
+## Basic Usage
+
+### Explicit Super Object
+
+`super(pivot_class, owner)` performs attribute lookup along the MRO, starting immediately after the
+specified pivot class.
+
+```py
+class A:
+    def a(self): ...
+    aa: int = 1
+
+class B(A):
+    def b(self): ...
+    bb: int = 2
+
+class C(B):
+    def c(self): ...
+    cc: int = 3
+
+reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[B], Literal[A], Literal[object]]
+
+super(C, C()).a
+super(C, C()).b
+# error: [unresolved-attribute] "Type `<super: Literal[C], C>` has no attribute `c`"
+super(C, C()).c
+
+super(B, C()).a
+# error: [unresolved-attribute] "Type `<super: Literal[B], C>` has no attribute `b`"
+super(B, C()).b
+# error: [unresolved-attribute] "Type `<super: Literal[B], C>` has no attribute `c`"
+super(B, C()).c
+
+# error: [unresolved-attribute] "Type `<super: Literal[A], C>` has no attribute `a`"
+super(A, C()).a
+# error: [unresolved-attribute] "Type `<super: Literal[A], C>` has no attribute `b`"
+super(A, C()).b
+# error: [unresolved-attribute] "Type `<super: Literal[A], C>` has no attribute `c`"
+super(A, C()).c
+
+reveal_type(super(C, C()).a)  # revealed: bound method C.a() -> Unknown
+reveal_type(super(C, C()).b)  # revealed: bound method C.b() -> Unknown
+reveal_type(super(C, C()).aa)  # revealed: int
+reveal_type(super(C, C()).bb)  # revealed: int
+```
+
+### Implicit Super Object
+
+The implicit form `super()` is same as `super(__class__, <first argument>)`. The `__class__` refers
+to the class that contains the function where `super()` is used. The first argument refers to the
+current method’s first parameter (typically `self` or `cls`).
+
+```py
+from __future__ import annotations
+
+class A:
+    def __init__(self, a: int): ...
+    @classmethod
+    def f(cls): ...
+
+class B(A):
+    def __init__(self, a: int):
+        # TODO: Once `Self` is supported, this should be `<super: Literal[B], B>`
+        reveal_type(super())  # revealed: <super: Literal[B], Unknown>
+        super().__init__(a)
+
+    @classmethod
+    def f(cls):
+        # TODO: Once `Self` is supported, this should be `<super: Literal[B], Literal[B]>`
+        reveal_type(super())  # revealed: <super: Literal[B], Unknown>
+        super().f()
+
+super(B, B(42)).__init__(42)
+super(B, B).f()
+```
+
+### Unbound Super Object
+
+Calling `super(cls)` without a second argument returns an *unbound super object*. This is treated as
+a plain `super` instance and does not support name lookup via the MRO.
+
+```py
+class A:
+    a: int = 42
+
+class B(A): ...
+
+reveal_type(super(B))  # revealed: super
+
+# error: [unresolved-attribute] "Type `super` has no attribute `a`"
+super(B).a
+```
+
+## Attribute Assignment
+
+`super()` objects do not allow attribute assignment — even if the attribute is resolved
+successfully.
+
+```py
+class A:
+    a: int = 3
+
+class B(A): ...
+
+reveal_type(super(B, B()).a)  # revealed: int
+# error: [invalid-assignment] "Cannot assign to attribute `a` on type `<super: Literal[B], B>`"
+super(B, B()).a = 3
+# error: [invalid-assignment] "Cannot assign to attribute `a` on type `super`"
+super(B).a = 5
+```
+
+## Dynamic Types
+
+If any of the arguments is dynamic, we cannot determine the MRO to traverse. When accessing a
+member, it should effectively behave like a dynamic type.
+
+```py
+class A:
+    a: int = 1
+
+def f(x):
+    reveal_type(x)  # revealed: Unknown
+
+    reveal_type(super(x, x))  # revealed: <super: Unknown, Unknown>
+    reveal_type(super(A, x))  # revealed: <super: Literal[A], Unknown>
+    reveal_type(super(x, A()))  # revealed: <super: Unknown, A>
+
+    reveal_type(super(x, x).a)  # revealed: Unknown
+    reveal_type(super(A, x).a)  # revealed: Unknown
+    reveal_type(super(x, A()).a)  # revealed: Unknown
+```
+
+## Implicit `super()` in Complex Structure
+
+```py
+from __future__ import annotations
+
+class A:
+    def test(self):
+        reveal_type(super())  # revealed: <super: Literal[A], Unknown>
+
+    class B:
+        def test(self):
+            reveal_type(super())  # revealed: <super: Literal[B], Unknown>
+
+            class C(A.B):
+                def test(self):
+                    reveal_type(super())  # revealed: <super: Literal[C], Unknown>
+
+            def inner(t: C):
+                reveal_type(super())  # revealed: <super: Literal[B], C>
+            lambda x: reveal_type(super())  # revealed: <super: Literal[B], Unknown>
+```
+
+## Built-ins and Literals
+
+```py
+reveal_type(super(bool, True))  # revealed: <super: Literal[bool], bool>
+reveal_type(super(bool, bool()))  # revealed: <super: Literal[bool], bool>
+reveal_type(super(int, bool()))  # revealed: <super: Literal[int], bool>
+reveal_type(super(int, 3))  # revealed: <super: Literal[int], int>
+reveal_type(super(str, ""))  # revealed: <super: Literal[str], str>
+```
+
+## Descriptor Behavior with Super
+
+Accessing attributes through `super` still invokes descriptor protocol. However, the behavior can
+differ depending on whether the second argument to `super` is a class or an instance.
+
+```py
+class A:
+    def a1(self): ...
+    @classmethod
+    def a2(cls): ...
+
+class B(A): ...
+
+# A.__dict__["a1"].__get__(B(), B)
+reveal_type(super(B, B()).a1)  # revealed: bound method B.a1() -> Unknown
+# A.__dict__["a2"].__get__(B(), B)
+reveal_type(super(B, B()).a2)  # revealed: bound method type[B].a2() -> Unknown
+
+# A.__dict__["a1"].__get__(None, B)
+reveal_type(super(B, B).a1)  # revealed: def a1(self) -> Unknown
+# A.__dict__["a2"].__get__(None, B)
+reveal_type(super(B, B).a2)  # revealed: bound method Literal[B].a2() -> Unknown
+```
+
+## Union of Supers
+
+When the owner is a union type, `super()` is built separately for each branch, and the resulting
+super objects are combined into a union.
+
+```py
+class A: ...
+
+class B:
+    b: int = 42
+
+class C(A, B): ...
+class D(B, A): ...
+
+def f(x: C | D):
+    reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[A], Literal[B], Literal[object]]
+    reveal_type(D.__mro__)  # revealed: tuple[Literal[D], Literal[B], Literal[A], Literal[object]]
+
+    s = super(A, x)
+    reveal_type(s)  # revealed: <super: Literal[A], C> | <super: Literal[A], D>
+
+    # error: [possibly-unbound-attribute] "Attribute `b` on type `<super: Literal[A], C> | <super: Literal[A], D>` is possibly unbound"
+    s.b
+
+def f(flag: bool):
+    x = str() if flag else str("hello")
+    reveal_type(x)  # revealed: Literal["", "hello"]
+    reveal_type(super(str, x))  # revealed: <super: Literal[str], str>
+
+def f(x: int | str):
+    # error: [invalid-super-argument] "`str` is not an instance or subclass of `Literal[int]` in `super(Literal[int], str)` call"
+    super(int, x)
+```
+
+Even when `super()` is constructed separately for each branch of a union, it should behave correctly
+in all cases.
+
+```py
+def f(flag: bool):
+    if flag:
+        class A:
+            x = 1
+            y: int = 1
+
+            a: str = "hello"
+
+        class B(A): ...
+        s = super(B, B())
+    else:
+        class C:
+            x = 2
+            y: int | str = "test"
+
+        class D(C): ...
+        s = super(D, D())
+
+    reveal_type(s)  # revealed: <super: Literal[B], B> | <super: Literal[D], D>
+
+    reveal_type(s.x)  # revealed: Unknown | Literal[1, 2]
+    reveal_type(s.y)  # revealed: int | str
+
+    # error: [possibly-unbound-attribute] "Attribute `a` on type `<super: Literal[B], B> | <super: Literal[D], D>` is possibly unbound"
+    reveal_type(s.a)  # revealed: str
+```
+
+## Supers with Generic Classes
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+from knot_extensions import TypeOf, static_assert, is_subtype_of
+
+class A[T]:
+    def f(self, a: T) -> T:
+        return a
+
+class B[T](A[T]):
+    def f(self, b: T) -> T:
+        return super().f(b)
+```
+
+## Invalid Usages
+
+### Unresolvable `super()` Calls
+
+If an appropriate class and argument cannot be found, a runtime error will occur.
+
+```py
+from __future__ import annotations
+
+# error: [unavailable-implicit-super-arguments] "Cannot determine implicit arguments for 'super()' in this context"
+reveal_type(super())  # revealed: Unknown
+
+def f():
+    # error: [unavailable-implicit-super-arguments] "Cannot determine implicit arguments for 'super()' in this context"
+    super()
+
+# No first argument in its scope
+class A:
+    # error: [unavailable-implicit-super-arguments] "Cannot determine implicit arguments for 'super()' in this context"
+    s = super()
+
+    def f(self):
+        def g():
+            # error: [unavailable-implicit-super-arguments] "Cannot determine implicit arguments for 'super()' in this context"
+            super()
+        # error: [unavailable-implicit-super-arguments] "Cannot determine implicit arguments for 'super()' in this context"
+        lambda: super()
+
+        # error: [unavailable-implicit-super-arguments] "Cannot determine implicit arguments for 'super()' in this context"
+        (super() for _ in range(10))
+
+    @staticmethod
+    def h():
+        # error: [unavailable-implicit-super-arguments] "Cannot determine implicit arguments for 'super()' in this context"
+        super()
+```
+
+### Failing Condition Checks
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+`super()` requires its first argument to be a valid class, and its second argument to be either an
+instance or a subclass of the first. If either condition is violated, a `TypeError` is raised at
+runtime.
+
+```py
+def f(x: int):
+    # error: [invalid-super-argument] "`int` is not a valid class"
+    super(x, x)
+
+    type IntAlias = int
+    # error: [invalid-super-argument] "`typing.TypeAliasType` is not a valid class"
+    super(IntAlias, 0)
+
+# error: [invalid-super-argument] "`Literal[""]` is not an instance or subclass of `Literal[int]` in `super(Literal[int], Literal[""])` call"
+# revealed: Unknown
+reveal_type(super(int, str()))
+
+# error: [invalid-super-argument] "`Literal[str]` is not an instance or subclass of `Literal[int]` in `super(Literal[int], Literal[str])` call"
+# revealed: Unknown
+reveal_type(super(int, str))
+
+class A: ...
+class B(A): ...
+
+# error: [invalid-super-argument] "`A` is not an instance or subclass of `Literal[B]` in `super(Literal[B], A)` call"
+# revealed: Unknown
+reveal_type(super(B, A()))
+
+# error: [invalid-super-argument] "`object` is not an instance or subclass of `Literal[B]` in `super(Literal[B], object)` call"
+# revealed: Unknown
+reveal_type(super(B, object()))
+
+# error: [invalid-super-argument] "`Literal[A]` is not an instance or subclass of `Literal[B]` in `super(Literal[B], Literal[A])` call"
+# revealed: Unknown
+reveal_type(super(B, A))
+
+# error: [invalid-super-argument] "`Literal[object]` is not an instance or subclass of `Literal[B]` in `super(Literal[B], Literal[object])` call"
+# revealed: Unknown
+reveal_type(super(B, object))
+
+super(object, object()).__class__
+```
+
+### Instance Member Access via `super`
+
+Accessing instance members through `super()` is not allowed.
+
+```py
+from __future__ import annotations
+
+class A:
+    def __init__(self, a: int):
+        self.a = a
+
+class B(A):
+    def __init__(self, a: int):
+        super().__init__(a)
+        # TODO: Once `Self` is supported, this should raise `unresolved-attribute` error
+        super().a
+
+# error: [unresolved-attribute] "Type `<super: Literal[B], B>` has no attribute `a`"
+super(B, B(42)).a
+```
+
+### Dunder Method Resolution
+
+Dunder methods defined in the `owner` (from `super(pivot_class, owner)`) should not affect the super
+object itself. In other words, `super` should not be treated as if it inherits attributes of the
+`owner`.
+
+```py
+class A:
+    def __getitem__(self, key: int) -> int:
+        return 42
+
+class B(A): ...
+
+reveal_type(A()[0])  # revealed: int
+reveal_type(super(B, B()).__getitem__)  # revealed: bound method B.__getitem__(key: int) -> int
+# error: [non-subscriptable] "Cannot subscript object of type `<super: Literal[B], B>` with no `__getitem__` method"
+super(B, B())[0]
+```

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

@@ -50,13 +50,17 @@ reveal_type(x)  # revealed: LiteralString
 if x != "abc":
     reveal_type(x)  # revealed: LiteralString & ~Literal["abc"]
 
-    reveal_type(x == "abc")  # revealed: Literal[False]
-    reveal_type("abc" == x)  # revealed: Literal[False]
+    # TODO: This should be `Literal[False]`
+    reveal_type(x == "abc")  # revealed: bool
+    # TODO: This should be `Literal[False]`
+    reveal_type("abc" == x)  # revealed: bool
     reveal_type(x == "something else")  # revealed: bool
     reveal_type("something else" == x)  # revealed: bool
 
-    reveal_type(x != "abc")  # revealed: Literal[True]
-    reveal_type("abc" != x)  # revealed: Literal[True]
+    # TODO: This should be `Literal[True]`
+    reveal_type(x != "abc")  # revealed: bool
+    # TODO: This should be `Literal[True]`
+    reveal_type("abc" != x)  # revealed: bool
     reveal_type(x != "something else")  # revealed: bool
     reveal_type("something else" != x)  # revealed: bool
 
@@ -79,10 +83,10 @@ def _(x: int):
     if x != 1:
         reveal_type(x)  # revealed: int & ~Literal[1]
 
-        reveal_type(x != 1)  # revealed: Literal[True]
+        reveal_type(x != 1)  # revealed: bool
         reveal_type(x != 2)  # revealed: bool
 
-        reveal_type(x == 1)  # revealed: Literal[False]
+        reveal_type(x == 1)  # revealed: bool
         reveal_type(x == 2)  # revealed: bool
 ```
 

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

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

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

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

crates/red_knot_python_semantic/resources/mdtest/dataclasses.md

@@ -0,0 +1,731 @@
+# Dataclasses
+
+## Basic
+
+Decorating a class with `@dataclass` is a convenient way to add special methods such as `__init__`,
+`__repr__`, and `__eq__` to a class. The following example shows the basic usage of the `@dataclass`
+decorator. By default, only the three mentioned methods are generated.
+
+```py
+from dataclasses import dataclass
+
+@dataclass
+class Person:
+    name: str
+    age: int | None = None
+
+alice1 = Person("Alice", 30)
+alice2 = Person(name="Alice", age=30)
+alice3 = Person(age=30, name="Alice")
+alice4 = Person("Alice", age=30)
+
+reveal_type(alice1)  # revealed: Person
+reveal_type(type(alice1))  # revealed: type[Person]
+
+reveal_type(alice1.name)  # revealed: str
+reveal_type(alice1.age)  # revealed: int | None
+
+reveal_type(repr(alice1))  # revealed: str
+
+reveal_type(alice1 == alice2)  # revealed: bool
+reveal_type(alice1 == "Alice")  # revealed: bool
+
+bob = Person("Bob")
+bob2 = Person("Bob", None)
+bob3 = Person(name="Bob")
+bob4 = Person(name="Bob", age=None)
+```
+
+The signature of the `__init__` method is generated based on the classes attributes. The following
+calls are not valid:
+
+```py
+# error: [missing-argument]
+Person()
+
+# error: [too-many-positional-arguments]
+Person("Eve", 20, "too many arguments")
+
+# error: [invalid-argument-type]
+Person("Eve", "string instead of int")
+
+# error: [invalid-argument-type]
+# error: [invalid-argument-type]
+Person(20, "Eve")
+```
+
+## Signature of `__init__`
+
+TODO: All of the following tests are missing the `self` argument in the `__init__` signature.
+
+Declarations in the class body are used to generate the signature of the `__init__` method. If the
+attributes are not just declarations, but also bindings, the type inferred from bindings is used as
+the default value.
+
+```py
+from dataclasses import dataclass
+
+@dataclass
+class D:
+    x: int
+    y: str = "default"
+    z: int | None = 1 + 2
+
+reveal_type(D.__init__)  # revealed: (x: int, y: str = Literal["default"], z: int | None = Literal[3]) -> None
+```
+
+This also works if the declaration and binding are split:
+
+```py
+@dataclass
+class D:
+    x: int | None
+    x = None
+
+reveal_type(D.__init__)  # revealed: (x: int | None = None) -> None
+```
+
+Non-fully static types are handled correctly:
+
+```py
+from typing import Any
+
+@dataclass
+class C:
+    x: Any
+    y: int | Any
+    z: tuple[int, Any]
+
+reveal_type(C.__init__)  # revealed: (x: Any, y: int | Any, z: tuple[int, Any]) -> None
+```
+
+Variables without annotations are ignored:
+
+```py
+@dataclass
+class D:
+    x: int
+    y = 1
+
+reveal_type(D.__init__)  # revealed: (x: int) -> None
+```
+
+If attributes without default values are declared after attributes with default values, a
+`TypeError` will be raised at runtime. Ideally, we would emit a diagnostic in that case:
+
+```py
+@dataclass
+class D:
+    x: int = 1
+    # TODO: this should be an error: field without default defined after field with default
+    y: str
+```
+
+Pure class attributes (`ClassVar`) are not included in the signature of `__init__`:
+
+```py
+from typing import ClassVar
+
+@dataclass
+class D:
+    x: int
+    y: ClassVar[str] = "default"
+    z: bool
+
+reveal_type(D.__init__)  # revealed: (x: int, z: bool) -> None
+
+d = D(1, True)
+reveal_type(d.x)  # revealed: int
+reveal_type(d.y)  # revealed: str
+reveal_type(d.z)  # revealed: bool
+```
+
+Function declarations do not affect the signature of `__init__`:
+
+```py
+@dataclass
+class D:
+    x: int
+
+    def y(self) -> str:
+        return ""
+
+reveal_type(D.__init__)  # revealed: (x: int) -> None
+```
+
+And neither do nested class declarations:
+
+```py
+@dataclass
+class D:
+    x: int
+
+    class Nested:
+        y: str
+
+reveal_type(D.__init__)  # revealed: (x: int) -> None
+```
+
+But if there is a variable annotation with a function or class literal type, the signature of
+`__init__` will include this field:
+
+```py
+from knot_extensions import TypeOf
+
+class SomeClass: ...
+
+def some_function() -> None: ...
+@dataclass
+class D:
+    function_literal: TypeOf[some_function]
+    class_literal: TypeOf[SomeClass]
+    class_subtype_of: type[SomeClass]
+
+# revealed: (function_literal: def some_function() -> None, class_literal: Literal[SomeClass], class_subtype_of: type[SomeClass]) -> None
+reveal_type(D.__init__)
+```
+
+More realistically, dataclasses can have `Callable` attributes:
+
+```py
+from typing import Callable
+
+@dataclass
+class D:
+    c: Callable[[int], str]
+
+reveal_type(D.__init__)  # revealed: (c: (int, /) -> str) -> None
+```
+
+Implicit instance attributes do not affect the signature of `__init__`:
+
+```py
+@dataclass
+class D:
+    x: int
+
+    def f(self, y: str) -> None:
+        self.y: str = y
+
+reveal_type(D(1).y)  # revealed: str
+
+reveal_type(D.__init__)  # revealed: (x: int) -> None
+```
+
+Annotating expressions does not lead to an entry in `__annotations__` at runtime, and so it wouldn't
+be included in the signature of `__init__`. This is a case that we currently don't detect:
+
+```py
+@dataclass
+class D:
+    # (x) is an expression, not a "simple name"
+    (x): int = 1
+
+# TODO: should ideally not include a `x` parameter
+reveal_type(D.__init__)  # revealed: (x: int = Literal[1]) -> None
+```
+
+## `@dataclass` calls with arguments
+
+The `@dataclass` decorator can take several arguments to customize the existence of the generated
+methods. The following test makes sure that we still treat the class as a dataclass if (the default)
+arguments are passed in:
+
+```py
+from dataclasses import dataclass
+
+@dataclass(init=True, repr=True, eq=True)
+class Person:
+    name: str
+    age: int | None = None
+
+alice = Person("Alice", 30)
+reveal_type(repr(alice))  # revealed: str
+reveal_type(alice == alice)  # revealed: bool
+```
+
+If `init` is set to `False`, no `__init__` method is generated:
+
+```py
+from dataclasses import dataclass
+
+@dataclass(init=False)
+class C:
+    x: int
+
+C()  # Okay
+
+# error: [too-many-positional-arguments]
+C(1)
+
+repr(C())
+
+C() == C()
+```
+
+## Other dataclass parameters
+
+### `repr`
+
+A custom `__repr__` method is generated by default. It can be disabled by passing `repr=False`, but
+in that case `__repr__` is still available via `object.__repr__`:
+
+```py
+from dataclasses import dataclass
+
+@dataclass(repr=False)
+class WithoutRepr:
+    x: int
+
+reveal_type(WithoutRepr(1).__repr__)  # revealed: bound method WithoutRepr.__repr__() -> str
+```
+
+### `eq`
+
+The same is true for `__eq__`. Setting `eq=False` disables the generated `__eq__` method, but
+`__eq__` is still available via `object.__eq__`:
+
+```py
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class WithoutEq:
+    x: int
+
+reveal_type(WithoutEq(1) == WithoutEq(2))  # revealed: bool
+```
+
+### `order`
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+`order` is set to `False` by default. If `order=True`, `__lt__`, `__le__`, `__gt__`, and `__ge__`
+methods will be generated:
+
+```py
+from dataclasses import dataclass
+
+@dataclass
+class WithoutOrder:
+    x: int
+
+WithoutOrder(1) < WithoutOrder(2)  # error: [unsupported-operator]
+WithoutOrder(1) <= WithoutOrder(2)  # error: [unsupported-operator]
+WithoutOrder(1) > WithoutOrder(2)  # error: [unsupported-operator]
+WithoutOrder(1) >= WithoutOrder(2)  # error: [unsupported-operator]
+
+@dataclass(order=True)
+class WithOrder:
+    x: int
+
+WithOrder(1) < WithOrder(2)
+WithOrder(1) <= WithOrder(2)
+WithOrder(1) > WithOrder(2)
+WithOrder(1) >= WithOrder(2)
+```
+
+Comparisons are only allowed for `WithOrder` instances:
+
+```py
+WithOrder(1) < 2  # error: [unsupported-operator]
+WithOrder(1) <= 2  # error: [unsupported-operator]
+WithOrder(1) > 2  # error: [unsupported-operator]
+WithOrder(1) >= 2  # error: [unsupported-operator]
+```
+
+This also works for generic dataclasses:
+
+```py
+from dataclasses import dataclass
+
+@dataclass(order=True)
+class GenericWithOrder[T]:
+    x: T
+
+GenericWithOrder[int](1) < GenericWithOrder[int](1)
+
+GenericWithOrder[int](1) < GenericWithOrder[str]("a")  # error: [unsupported-operator]
+```
+
+If a class already defines one of the comparison methods, a `TypeError` is raised at runtime.
+Ideally, we would emit a diagnostic in that case:
+
+```py
+@dataclass(order=True)
+class AlreadyHasCustomDunderLt:
+    x: int
+
+    # TODO: Ideally, we would emit a diagnostic here
+    def __lt__(self, other: object) -> bool:
+        return False
+```
+
+### `unsafe_hash`
+
+To do
+
+### `frozen`
+
+To do
+
+### `match_args`
+
+To do
+
+### `kw_only`
+
+To do
+
+### `slots`
+
+To do
+
+### `weakref_slot`
+
+To do
+
+## Inheritance
+
+### Normal class inheriting from a dataclass
+
+```py
+from dataclasses import dataclass
+
+@dataclass
+class Base:
+    x: int
+
+class Derived(Base): ...
+
+d = Derived(1)  # OK
+reveal_type(d.x)  # revealed: int
+```
+
+### Dataclass inheriting from normal class
+
+```py
+from dataclasses import dataclass
+
+class Base:
+    x: int = 1
+
+@dataclass
+class Derived(Base):
+    y: str
+
+d = Derived("a")
+
+# error: [too-many-positional-arguments]
+# error: [invalid-argument-type]
+Derived(1, "a")
+```
+
+### Dataclass inheriting from another dataclass
+
+```py
+from dataclasses import dataclass
+
+@dataclass
+class Base:
+    x: int
+    y: str
+
+@dataclass
+class Derived(Base):
+    z: bool
+
+d = Derived(1, "a", True)  # OK
+
+reveal_type(d.x)  # revealed: int
+reveal_type(d.y)  # revealed: str
+reveal_type(d.z)  # revealed: bool
+
+# error: [missing-argument]
+Derived(1, "a")
+
+# error: [missing-argument]
+Derived(True)
+```
+
+### Overwriting attributes from base class
+
+The following example comes from the
+[Python documentation](https://docs.python.org/3/library/dataclasses.html#inheritance). The `x`
+attribute appears just once in the `__init__` signature, and the default value is taken from the
+derived class
+
+```py
+from dataclasses import dataclass
+from typing import Any
+
+@dataclass
+class Base:
+    x: Any = 15.0
+    y: int = 0
+
+@dataclass
+class C(Base):
+    z: int = 10
+    x: int = 15
+
+reveal_type(C.__init__)  # revealed: (x: int = Literal[15], y: int = Literal[0], z: int = Literal[10]) -> None
+```
+
+## Generic dataclasses
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+from dataclasses import dataclass
+
+@dataclass
+class DataWithDescription[T]:
+    data: T
+    description: str
+
+reveal_type(DataWithDescription[int])  # revealed: Literal[DataWithDescription[int]]
+
+d_int = DataWithDescription[int](1, "description")  # OK
+reveal_type(d_int.data)  # revealed: int
+reveal_type(d_int.description)  # revealed: str
+
+# error: [invalid-argument-type]
+DataWithDescription[int](None, "description")
+```
+
+## Descriptor-typed fields
+
+### Same type in `__get__` and `__set__`
+
+For the following descriptor, the return type of `__get__` and the type of the `value` parameter in
+`__set__` are the same. The generated `__init__` method takes an argument of this type (instead of
+the type of the descriptor), and the default value is also of this type:
+
+```py
+from typing import overload
+from dataclasses import dataclass
+
+class UppercaseString:
+    _value: str = ""
+
+    def __get__(self, instance: object, owner: None | type) -> str:
+        return self._value
+
+    def __set__(self, instance: object, value: str) -> None:
+        self._value = value.upper()
+
+@dataclass
+class C:
+    upper: UppercaseString = UppercaseString()
+
+reveal_type(C.__init__)  # revealed: (upper: str = str) -> None
+
+c = C("abc")
+reveal_type(c.upper)  # revealed: str
+
+# This is also okay:
+C()
+
+# error: [invalid-argument-type]
+C(1)
+
+# error: [too-many-positional-arguments]
+C("a", "b")
+```
+
+### Different types in `__get__` and `__set__`
+
+In general, the type of the `__init__` parameter is determined by the `value` parameter type of the
+`__set__` method (`str` in the example below). However, the default value is generated by calling
+the descriptor's `__get__` method as if it had been called on the class itself, i.e. passing `None`
+for the `instance` argument.
+
+```py
+from typing import Literal, overload
+from dataclasses import dataclass
+
+class ConvertToLength:
+    _len: int = 0
+
+    @overload
+    def __get__(self, instance: None, owner: type) -> Literal[""]: ...
+    @overload
+    def __get__(self, instance: object, owner: type | None) -> int: ...
+    def __get__(self, instance: object | None, owner: type | None) -> str | int:
+        if instance is None:
+            return ""
+
+        return self._len
+
+    def __set__(self, instance, value: str) -> None:
+        self._len = len(value)
+
+@dataclass
+class C:
+    converter: ConvertToLength = ConvertToLength()
+
+reveal_type(C.__init__)  # revealed: (converter: str = Literal[""]) -> None
+
+c = C("abc")
+reveal_type(c.converter)  # revealed: int
+
+# This is also okay:
+C()
+
+# error: [invalid-argument-type]
+C(1)
+
+# error: [too-many-positional-arguments]
+C("a", "b")
+```
+
+### With overloaded `__set__` method
+
+If the `__set__` method is overloaded, we determine the type for the `__init__` parameter as the
+union of all possible `value` parameter types:
+
+```py
+from typing import overload
+from dataclasses import dataclass
+
+class AcceptsStrAndInt:
+    def __get__(self, instance, owner) -> int:
+        return 0
+
+    @overload
+    def __set__(self, instance: object, value: str) -> None: ...
+    @overload
+    def __set__(self, instance: object, value: int) -> None: ...
+    def __set__(self, instance: object, value) -> None:
+        pass
+
+@dataclass
+class C:
+    field: AcceptsStrAndInt = AcceptsStrAndInt()
+
+reveal_type(C.__init__)  # revealed: (field: str | int = int) -> None
+```
+
+## `dataclasses.field`
+
+To do
+
+## Other special cases
+
+### `dataclasses.dataclass`
+
+We also understand dataclasses if they are decorated with the fully qualified name:
+
+```py
+import dataclasses
+
+@dataclasses.dataclass
+class C:
+    x: str
+
+reveal_type(C.__init__)  # revealed: (x: str) -> None
+```
+
+### Dataclass with custom `__init__` method
+
+If a class already defines `__init__`, it is not replaced by the `dataclass` decorator.
+
+```py
+from dataclasses import dataclass
+
+@dataclass(init=True)
+class C:
+    x: str
+
+    def __init__(self, x: int) -> None:
+        self.x = str(x)
+
+C(1)  # OK
+
+# error: [invalid-argument-type]
+C("a")
+```
+
+Similarly, if we set `init=False`, we still recognize the custom `__init__` method:
+
+```py
+@dataclass(init=False)
+class D:
+    def __init__(self, x: int) -> None:
+        self.x = str(x)
+
+D(1)  # OK
+D()  # error: [missing-argument]
+```
+
+### Accessing instance attributes on the class itself
+
+Just like for normal classes, accessing instance attributes on the class itself is not allowed:
+
+```py
+from dataclasses import dataclass
+
+@dataclass
+class C:
+    x: int
+
+# error: [unresolved-attribute] "Attribute `x` can only be accessed on instances, not on the class object `Literal[C]` itself."
+C.x
+```
+
+### Return type of `dataclass(...)`
+
+A call like `dataclass(order=True)` returns a callable itself, which is then used as the decorator.
+We can store the callable in a variable and later use it as a decorator:
+
+```py
+from dataclasses import dataclass
+
+dataclass_with_order = dataclass(order=True)
+
+reveal_type(dataclass_with_order)  # revealed: <decorator produced by dataclasses.dataclass>
+
+@dataclass_with_order
+class C:
+    x: int
+
+C(1) < C(2)  # ok
+```
+
+### Using `dataclass` as a function
+
+To do
+
+## Internals
+
+The `dataclass` decorator returns the class itself. This means that the type of `Person` is `type`,
+and attributes like the MRO are unchanged:
+
+```py
+from dataclasses import dataclass
+
+@dataclass
+class Person:
+    name: str
+    age: int | None = None
+
+reveal_type(type(Person))  # revealed: Literal[type]
+reveal_type(Person.__mro__)  # revealed: tuple[Literal[Person], Literal[object]]
+```
+
+The generated methods have the following signatures:
+
+```py
+# TODO: `self` is missing here
+reveal_type(Person.__init__)  # revealed: (name: str, age: int | None = None) -> None
+
+reveal_type(Person.__repr__)  # revealed: def __repr__(self) -> str
+
+reveal_type(Person.__eq__)  # revealed: def __eq__(self, value: object, /) -> bool
+```

crates/red_knot_python_semantic/resources/mdtest/decorators.md

@@ -0,0 +1,237 @@
+# 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(specialized non-generic class)
+
+# TODO: Should be `int`
+reveal_type(f(1))  # revealed: @Todo(specialized non-generic class)
+```
+
+## 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): ...
+```

crates/red_knot_python_semantic/resources/mdtest/descriptor_protocol.md

@@ -459,11 +459,9 @@ class Descriptor:
 class C:
     d: Descriptor = Descriptor()
 
-# TODO: should be `Literal["called on class object"]
-reveal_type(C.d)  # revealed: LiteralString
+reveal_type(C.d)  # revealed: Literal["called on class object"]
 
-# TODO: should be `Literal["called on instance"]
-reveal_type(C().d)  # revealed: LiteralString
+reveal_type(C().d)  # revealed: Literal["called on instance"]
 ```
 
 ## Descriptor protocol for dunder methods
@@ -506,8 +504,7 @@ class C:
     @property
     def name(self) -> str:
         return self._name or "Unset"
-    # TODO: No diagnostic should be emitted here
-    # error: [unresolved-attribute] "Type `Literal[name]` has no attribute `setter`"
+
     @name.setter
     def name(self, value: str | None) -> None:
         self._value = value
@@ -515,22 +512,13 @@ class C:
 c = C()
 
 reveal_type(c._name)  # revealed: str | None
+reveal_type(c.name)  # revealed: str
+reveal_type(C.name)  # revealed: property
 
-# TODO: Should be `str`
-reveal_type(c.name)  # revealed: <bound method `name` of `C`>
-
-# Should be `builtins.property`
-reveal_type(C.name)  # revealed: Literal[name]
-
-# TODO: These should not emit errors
-# error: [invalid-assignment]
 c.name = "new"
-
-# error: [invalid-assignment]
 c.name = None
 
-# TODO: this should be an error, but with a proper error message
-# error: [invalid-assignment] "Implicit shadowing of function `name`; annotate to make it explicit if this is intentional"
+# error: [invalid-assignment] "Invalid assignment to data descriptor attribute `name` on type `C` with custom `__set__` method"
 c.name = 42
 ```
 
@@ -573,21 +561,21 @@ from inspect import getattr_static
 def f(x: object) -> str:
     return "a"
 
-reveal_type(f)  # revealed: Literal[f]
+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: Literal[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: Literal[f]
+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 `__hash__` of `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: @Todo(@property)
+reveal_type(wrapper_descriptor.__qualname__)  # revealed: str
 ```
 
 We can also bind the free function `f` to an instance of a class `C`:
@@ -597,7 +585,7 @@ class C: ...
 
 bound_method = wrapper_descriptor(f, C(), C)
 
-reveal_type(bound_method)  # revealed: <bound method `f` of `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`

crates/red_knot_python_semantic/resources/mdtest/diagnostics/version_related_syntax_errors.md

@@ -0,0 +1,37 @@
+# Version-related syntax error diagnostics
+
+## `match` statement
+
+The `match` statement was introduced in Python 3.10.
+
+### Before 3.10
+
+<!-- snapshot-diagnostics -->
+
+We should emit a syntax error before 3.10.
+
+```toml
+[environment]
+python-version = "3.9"
+```
+
+```py
+match 2:  # error: 1 [invalid-syntax] "Cannot use `match` statement on Python 3.9 (syntax was added in Python 3.10)"
+    case 1:
+        print("it's one")
+```
+
+### After 3.10
+
+On or after 3.10, no error should be reported.
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+match 2:
+    case 1:
+        print("it's one")
+```

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

@@ -0,0 +1,111 @@
+# `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
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+`assert_never` can be used in combination with type narrowing as a way to make sure that all cases
+are handled in a series of `isinstance` checks or other narrowing patterns that are supported.
+
+```py
+from typing_extensions import assert_never, Literal
+
+class A: ...
+class B: ...
+class C: ...
+
+def if_else_isinstance_success(obj: A | B):
+    if isinstance(obj, A):
+        pass
+    elif isinstance(obj, B):
+        pass
+    elif isinstance(obj, C):
+        pass
+    else:
+        assert_never(obj)
+
+def if_else_isinstance_error(obj: A | B):
+    if isinstance(obj, A):
+        pass
+    # B is missing
+    elif isinstance(obj, C):
+        pass
+    else:
+        # error: [type-assertion-failure] "Expected type `Never`, got `B & ~A & ~C` instead"
+        assert_never(obj)
+
+def if_else_singletons_success(obj: Literal[1, "a"] | None):
+    if obj == 1:
+        pass
+    elif obj == "a":
+        pass
+    elif obj is None:
+        pass
+    else:
+        assert_never(obj)
+
+def if_else_singletons_error(obj: Literal[1, "a"] | None):
+    if obj == 1:
+        pass
+    elif obj is "A":  # "A" instead of "a"
+        pass
+    elif obj is None:
+        pass
+    else:
+        # error: [type-assertion-failure] "Expected type `Never`, got `Literal["a"]` instead"
+        assert_never(obj)
+
+def match_singletons_success(obj: Literal[1, "a"] | None):
+    match obj:
+        case 1:
+            pass
+        case "a":
+            pass
+        case None:
+            pass
+        case _ as obj:
+            # TODO: Ideally, we would not emit an error here
+            # error: [type-assertion-failure] "Expected type `Never`, got `@Todo"
+            assert_never(obj)
+
+def match_singletons_error(obj: Literal[1, "a"] | None):
+    match obj:
+        case 1:
+            pass
+        case "A":  # "A" instead of "a"
+            pass
+        case None:
+            pass
+        case _ as obj:
+            # TODO: We should emit an error here, but the message should
+            # show the type `Literal["a"]` instead of `@Todo(…)`.
+            # error: [type-assertion-failure] "Expected type `Never`, got `@Todo"
+            assert_never(obj)
+```

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

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

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

@@ -42,7 +42,7 @@ def f(w: Wrapper) -> None:
     v: int | None = w.value
 
     # This function call is incorrect, because `w.value` could be `None`. We therefore emit the following
-    # error: "`Unknown | None` cannot be assigned to parameter 1 (`i`) of function `accepts_int`; expected type `int`"
+    # error: "Argument to this function is incorrect: Expected `int`, found `Unknown | None`"
     c = accepts_int(w.value)
 ```
 
@@ -122,4 +122,4 @@ class Wrapper:
 reveal_type(Wrapper.value)  # revealed: Unknown | None
 ```
 
-[gradual guarantee]: https://typing.readthedocs.io/en/latest/spec/concepts.html#the-gradual-guarantee
+[gradual guarantee]: https://typing.python.org/en/latest/spec/concepts.html#the-gradual-guarantee

crates/red_knot_python_semantic/resources/mdtest/exception/control_flow.md

@@ -591,9 +591,9 @@ try:
             reveal_type(x)  # revealed: B | D
         reveal_type(x)  # revealed: B | D
     x = foo
-    reveal_type(x)  # revealed: Literal[foo]
+    reveal_type(x)  # revealed: def foo(param=A) -> Unknown
 except:
-    reveal_type(x)  # revealed: Literal[1] | Literal[foo]
+    reveal_type(x)  # revealed: Literal[1] | (def foo(param=A) -> Unknown)
 
     class Bar:
         x = could_raise_returns_E()
@@ -603,9 +603,9 @@ except:
     reveal_type(x)  # revealed: Literal[Bar]
 finally:
     # TODO: should be `Literal[1] | Literal[foo] | Literal[Bar]`
-    reveal_type(x)  # revealed: Literal[foo] | Literal[Bar]
+    reveal_type(x)  # revealed: (def foo(param=A) -> Unknown) | Literal[Bar]
 
-reveal_type(x)  # revealed: Literal[foo] | Literal[Bar]
+reveal_type(x)  # revealed: (def foo(param=A) -> Unknown) | Literal[Bar]
 ```
 
 [1]: https://astral-sh.notion.site/Exception-handler-control-flow-11348797e1ca80bb8ce1e9aedbbe439d

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

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

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

@@ -56,6 +56,11 @@ def f() -> int:
 
 ### In Protocol
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 ```py
 from typing import Protocol, TypeVar
 
@@ -69,8 +74,6 @@ class Baz(Bar):
 T = TypeVar("T")
 
 class Qux(Protocol[T]):
-    # TODO: no error
-    # error: [invalid-return-type]
     def f(self) -> int: ...
 
 class Foo(Protocol):
@@ -85,6 +88,11 @@ class Lorem(t[0]):
 
 ### In abstract method
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 ```py
 from abc import ABC, abstractmethod
 
@@ -269,3 +277,66 @@ def f(cond: bool) -> int:
     if cond:
         return 2
 ```
+
+## NotImplemented
+
+### Default Python version
+
+`NotImplemented` is a special symbol in Python. It is commonly used to control the fallback behavior
+of special dunder methods. You can find more details in the
+[documentation](https://docs.python.org/3/library/numbers.html#implementing-the-arithmetic-operations).
+
+```py
+from __future__ import annotations
+
+class A:
+    def __add__(self, o: A) -> A:
+        return NotImplemented
+```
+
+However, as shown below, `NotImplemented` should not cause issues with the declared return type.
+
+```py
+def f() -> int:
+    return NotImplemented
+
+def f(cond: bool) -> int:
+    if cond:
+        return 1
+    else:
+        return NotImplemented
+
+def f(x: int) -> int | str:
+    if x < 0:
+        return -1
+    elif x == 0:
+        return NotImplemented
+    else:
+        return "test"
+
+def f(cond: bool) -> str:
+    return "hello" if cond else NotImplemented
+
+def f(cond: bool) -> int:
+    # error: [invalid-return-type] "Return type does not match returned value: Expected `int`, found `Literal["hello"]`"
+    return "hello" if cond else NotImplemented
+```
+
+### Python 3.10+
+
+Unlike Ellipsis, `_NotImplementedType` remains in `builtins.pyi` regardless of the Python version.
+Even if `builtins._NotImplementedType` is fully replaced by `types.NotImplementedType` in the
+future, it should still work as expected.
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+def f() -> int:
+    return NotImplemented
+
+def f(cond: bool) -> str:
+    return "hello" if cond else NotImplemented
+```

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

@@ -1,5 +1,10 @@
 # Generic classes
 
+```toml
+[environment]
+python-version = "3.13"
+```
+
 ## PEP 695 syntax
 
 TODO: Add a `red_knot_extension` function that asserts whether a function or class is generic.
@@ -13,8 +18,6 @@ class C[T]: ...
 A class that inherits from a generic class, and fills its type parameters with typevars, is generic:
 
 ```py
-# TODO: no error
-# error: [non-subscriptable]
 class D[U](C[U]): ...
 ```
 
@@ -22,8 +25,6 @@ A class that inherits from a generic class, but fills its type parameters with c
 _not_ generic:
 
 ```py
-# TODO: no error
-# error: [non-subscriptable]
 class E(C[int]): ...
 ```
 
@@ -44,8 +45,6 @@ from typing import Generic, TypeVar
 
 T = TypeVar("T")
 
-# TODO: no error
-# error: [invalid-base]
 class C(Generic[T]): ...
 ```
 
@@ -57,7 +56,7 @@ class D(C[T]): ...
 
 (Examples `E` and `F` from above do not have analogues in the legacy syntax.)
 
-## Inferring generic class parameters
+## Specializing generic classes explicitly
 
 The type parameter can be specified explicitly:
 
@@ -65,25 +64,77 @@ The type parameter can be specified explicitly:
 class C[T]:
     x: T
 
-# TODO: no error
-# TODO: revealed: C[int]
-# error: [non-subscriptable]
-reveal_type(C[int]())  # revealed: C
+reveal_type(C[int]())  # revealed: C[int]
 ```
 
+The specialization must match the generic types:
+
+```py
+# error: [too-many-positional-arguments] "Too many positional arguments to class `C`: expected 1, got 2"
+reveal_type(C[int, int]())  # revealed: Unknown
+```
+
+If the type variable has an upper bound, the specialized type must satisfy that bound:
+
+```py
+class Bounded[T: int]: ...
+class BoundedByUnion[T: int | str]: ...
+class IntSubclass(int): ...
+
+reveal_type(Bounded[int]())  # revealed: Bounded[int]
+reveal_type(Bounded[IntSubclass]())  # revealed: Bounded[IntSubclass]
+
+# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `str`"
+reveal_type(Bounded[str]())  # revealed: Unknown
+
+# error:  [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `int | str`"
+reveal_type(Bounded[int | str]())  # revealed: Unknown
+
+reveal_type(BoundedByUnion[int]())  # revealed: BoundedByUnion[int]
+reveal_type(BoundedByUnion[IntSubclass]())  # revealed: BoundedByUnion[IntSubclass]
+reveal_type(BoundedByUnion[str]())  # revealed: BoundedByUnion[str]
+reveal_type(BoundedByUnion[int | str]())  # revealed: BoundedByUnion[int | str]
+```
+
+If the type variable is constrained, the specialized type must satisfy those constraints:
+
+```py
+class Constrained[T: (int, str)]: ...
+
+reveal_type(Constrained[int]())  # revealed: Constrained[int]
+
+# TODO: error: [invalid-argument-type]
+# TODO: revealed: Constrained[Unknown]
+reveal_type(Constrained[IntSubclass]())  # revealed: Constrained[IntSubclass]
+
+reveal_type(Constrained[str]())  # revealed: Constrained[str]
+
+# TODO: error: [invalid-argument-type]
+# TODO: revealed: Unknown
+reveal_type(Constrained[int | str]())  # revealed: Constrained[int | str]
+
+# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `int | str`, found `object`"
+reveal_type(Constrained[object]())  # revealed: Unknown
+```
+
+## Inferring generic class parameters
+
 We can infer the type parameter from a type context:
 
 ```py
+class C[T]:
+    x: T
+
 c: C[int] = C()
 # TODO: revealed: C[int]
-reveal_type(c)  # revealed: C
+reveal_type(c)  # revealed: C[Unknown]
 ```
 
 The typevars of a fully specialized generic class should no longer be visible:
 
 ```py
 # TODO: revealed: int
-reveal_type(c.x)  # revealed: T
+reveal_type(c.x)  # revealed: Unknown
 ```
 
 If the type parameter is not specified explicitly, and there are no constraints that let us infer a
@@ -92,34 +143,111 @@ specific type, we infer the typevar's default type:
 ```py
 class D[T = int]: ...
 
-# TODO: revealed: D[int]
-reveal_type(D())  # revealed: D
+reveal_type(D())  # revealed: D[int]
 ```
 
 If a typevar does not provide a default, we use `Unknown`:
 
 ```py
-# TODO: revealed: C[Unknown]
-reveal_type(C())  # revealed: C
+reveal_type(C())  # revealed: C[Unknown]
 ```
 
+## Inferring generic class parameters from constructors
+
 If the type of a constructor parameter is a class typevar, we can use that to infer the type
-parameter:
+parameter. The types inferred from a type context and from a constructor parameter must be
+consistent with each other.
+
+## `__new__` only
 
 ```py
-class E[T]:
-    def __init__(self, x: T) -> None: ...
+class C[T]:
+    def __new__(cls, x: T) -> "C[T]":
+        return object.__new__(cls)
 
-# TODO: revealed: E[int] or E[Literal[1]]
-reveal_type(E(1))  # revealed: E
+reveal_type(C(1))  # revealed: C[Literal[1]]
+
+# error: [invalid-assignment] "Object of type `C[Literal["five"]]` is not assignable to `C[int]`"
+wrong_innards: C[int] = C("five")
 ```
 
-The types inferred from a type context and from a constructor parameter must be consistent with each
-other:
+## `__init__` only
 
 ```py
-# TODO: error
-wrong_innards: E[int] = E("five")
+class C[T]:
+    def __init__(self, x: T) -> None: ...
+
+reveal_type(C(1))  # revealed: C[Literal[1]]
+
+# error: [invalid-assignment] "Object of type `C[Literal["five"]]` is not assignable to `C[int]`"
+wrong_innards: C[int] = C("five")
+```
+
+## Identical `__new__` and `__init__` signatures
+
+```py
+class C[T]:
+    def __new__(cls, x: T) -> "C[T]":
+        return object.__new__(cls)
+
+    def __init__(self, x: T) -> None: ...
+
+reveal_type(C(1))  # revealed: C[Literal[1]]
+
+# error: [invalid-assignment] "Object of type `C[Literal["five"]]` is not assignable to `C[int]`"
+wrong_innards: C[int] = C("five")
+```
+
+## Compatible `__new__` and `__init__` signatures
+
+```py
+class C[T]:
+    def __new__(cls, *args, **kwargs) -> "C[T]":
+        return object.__new__(cls)
+
+    def __init__(self, x: T) -> None: ...
+
+reveal_type(C(1))  # revealed: C[Literal[1]]
+
+# error: [invalid-assignment] "Object of type `C[Literal["five"]]` is not assignable to `C[int]`"
+wrong_innards: C[int] = C("five")
+
+class D[T]:
+    def __new__(cls, x: T) -> "D[T]":
+        return object.__new__(cls)
+
+    def __init__(self, *args, **kwargs) -> None: ...
+
+reveal_type(D(1))  # revealed: D[Literal[1]]
+
+# error: [invalid-assignment] "Object of type `D[Literal["five"]]` is not assignable to `D[int]`"
+wrong_innards: D[int] = D("five")
+```
+
+## `__init__` is itself generic
+
+TODO: These do not currently work yet, because we don't correctly model the nested generic contexts.
+
+```py
+class C[T]:
+    def __init__[S](self, x: T, y: S) -> None: ...
+
+# TODO: no error
+# TODO: revealed: C[Literal[1]]
+# error: [invalid-argument-type]
+reveal_type(C(1, 1))  # revealed: C[Unknown]
+# TODO: no error
+# TODO: revealed: C[Literal[1]]
+# error: [invalid-argument-type]
+reveal_type(C(1, "string"))  # revealed: C[Unknown]
+# TODO: no error
+# TODO: revealed: C[Literal[1]]
+# error: [invalid-argument-type]
+reveal_type(C(1, True))  # revealed: C[Unknown]
+
+# TODO: [invalid-assignment] "Object of type `C[Literal["five"]]` is not assignable to `C[int]`"
+# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `S`, found `Literal[1]`"
+wrong_innards: C[int] = C("five", 1)
 ```
 
 ## Generic subclass
@@ -131,17 +259,30 @@ propagate through:
 class Base[T]:
     x: T | None = None
 
-# TODO: no error
-# error: [non-subscriptable]
 class Sub[U](Base[U]): ...
 
-# TODO: no error
-# TODO: revealed: int | None
-# error: [non-subscriptable]
-reveal_type(Base[int].x)  # revealed: T | None
-# TODO: revealed: int | None
-# error: [non-subscriptable]
-reveal_type(Sub[int].x)  # revealed: T | None
+reveal_type(Base[int].x)  # revealed: int | None
+reveal_type(Sub[int].x)  # revealed: int | None
+```
+
+## Generic methods
+
+Generic classes can contain methods that are themselves generic. The generic methods can refer to
+the typevars of the enclosing generic class, and introduce new (distinct) typevars that are only in
+scope for the method.
+
+```py
+class C[T]:
+    def method[U](self, u: U) -> U:
+        return u
+    # error: [unresolved-reference]
+    def cannot_use_outside_of_method(self, u: U): ...
+
+    # TODO: error
+    def cannot_shadow_class_typevar[T](self, t: T): ...
+
+c: C[int] = C[int]()
+reveal_type(c.method("string"))  # revealed: Literal["string"]
 ```
 
 ## Cyclic class definition
@@ -155,8 +296,6 @@ Here, `Sub` is not a generic class, since it fills its superclass's type paramet
 
 ```pyi
 class Base[T]: ...
-# TODO: no error
-# error: [non-subscriptable]
 class Sub(Base[Sub]): ...
 
 reveal_type(Sub)  # revealed: Literal[Sub]
@@ -168,9 +307,6 @@ A similar case can work in a non-stub file, if forward references are stringifie
 
 ```py
 class Base[T]: ...
-
-# TODO: no error
-# error: [non-subscriptable]
 class Sub(Base["Sub"]): ...
 
 reveal_type(Sub)  # revealed: Literal[Sub]
@@ -183,8 +319,6 @@ In a non-stub file, without stringified forward references, this raises a `NameE
 ```py
 class Base[T]: ...
 
-# TODO: the unresolved-reference error is correct, the non-subscriptable is not
-# error: [non-subscriptable]
 # error: [unresolved-reference]
 class Sub(Base[Sub]): ...
 ```

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

@@ -1,5 +1,10 @@
 # Generic functions
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 ## Typevar must be used at least twice
 
 If you're only using a typevar for a single parameter, you don't need the typevar — just use
@@ -43,33 +48,14 @@ def absurd[T]() -> T:
 If the type of a generic function parameter is a typevar, then we can infer what type that typevar
 is bound to at each call site.
 
-TODO: Note that some of the TODO revealed types have two options, since we haven't decided yet
-whether we want to infer a more specific `Literal` type where possible, or use heuristics to weaken
-the inferred type to e.g. `int`.
-
 ```py
 def f[T](x: T) -> T:
     return x
 
-# TODO: no error
-# TODO: revealed: int or Literal[1]
-# error: [invalid-argument-type]
-reveal_type(f(1))  # revealed: T
-
-# TODO: no error
-# TODO: revealed: float
-# error: [invalid-argument-type]
-reveal_type(f(1.0))  # revealed: T
-
-# TODO: no error
-# TODO: revealed: bool or Literal[true]
-# error: [invalid-argument-type]
-reveal_type(f(True))  # revealed: T
-
-# TODO: no error
-# TODO: revealed: str or Literal["string"]
-# error: [invalid-argument-type]
-reveal_type(f("string"))  # revealed: T
+reveal_type(f(1))  # revealed: Literal[1]
+reveal_type(f(1.0))  # revealed: float
+reveal_type(f(True))  # revealed: Literal[True]
+reveal_type(f("string"))  # revealed: Literal["string"]
 ```
 
 ## Inferring “deep” generic parameter types
@@ -82,7 +68,7 @@ def f[T](x: list[T]) -> T:
     return x[0]
 
 # TODO: revealed: float
-reveal_type(f([1.0, 2.0]))  # revealed: T
+reveal_type(f([1.0, 2.0]))  # revealed: Unknown
 ```
 
 ## Typevar constraints
@@ -93,7 +79,6 @@ in the function.
 
 ```py
 def good_param[T: int](x: T) -> None:
-    # TODO: revealed: T & int
     reveal_type(x)  # revealed: T
 ```
 
@@ -107,8 +92,7 @@ def good_return[T: int](x: T) -> T:
     return x
 
 def bad_return[T: int](x: T) -> T:
-    # TODO: error: int is not assignable to T
-    # error: [unsupported-operator] "Operator `+` is unsupported between objects of type `T` and `Literal[1]`"
+    # error: [invalid-return-type] "Return type does not match returned value: Expected `T`, found `int`"
     return x + 1
 ```
 
@@ -121,7 +105,7 @@ def different_types[T, S](cond: bool, t: T, s: S) -> T:
     if cond:
         return t
     else:
-        # error: [invalid-return-type] "Object of type `S` is not assignable to return type `T`"
+        # error: [invalid-return-type] "Return type does not match returned value: Expected `T`, found `S`"
         return s
 
 def same_types[T](cond: bool, t1: T, t2: T) -> T:
@@ -163,61 +147,41 @@ parameters simultaneously.
 def two_params[T](x: T, y: T) -> T:
     return x
 
-# TODO: no error
-# TODO: revealed: str
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(two_params("a", "b"))  # revealed: T
+reveal_type(two_params("a", "b"))  # revealed: Literal["a", "b"]
+reveal_type(two_params("a", 1))  # revealed: Literal["a", 1]
+```
 
-# TODO: no error
-# TODO: revealed: str | int
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(two_params("a", 1))  # revealed: T
+When one of the parameters is a union, we attempt to find the smallest specialization that satisfies
+all of the constraints.
+
+```py
+def union_param[T](x: T | None) -> T:
+    if x is None:
+        raise ValueError
+    return x
+
+reveal_type(union_param("a"))  # revealed: Literal["a"]
+reveal_type(union_param(1))  # revealed: Literal[1]
+reveal_type(union_param(None))  # revealed: Unknown
 ```
 
 ```py
-def param_with_union[T](x: T | int, y: T) -> T:
+def union_and_nonunion_params[T](x: T | int, y: T) -> T:
     return y
 
-# TODO: no error
-# TODO: revealed: str
-# error: [invalid-argument-type]
-reveal_type(param_with_union(1, "a"))  # revealed: T
-
-# TODO: no error
-# TODO: revealed: str
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(param_with_union("a", "a"))  # revealed: T
-
-# TODO: no error
-# TODO: revealed: int
-# error: [invalid-argument-type]
-reveal_type(param_with_union(1, 1))  # revealed: T
-
-# TODO: no error
-# TODO: revealed: str | int
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(param_with_union("a", 1))  # revealed: T
+reveal_type(union_and_nonunion_params(1, "a"))  # revealed: Literal["a"]
+reveal_type(union_and_nonunion_params("a", "a"))  # revealed: Literal["a"]
+reveal_type(union_and_nonunion_params(1, 1))  # revealed: Literal[1]
+reveal_type(union_and_nonunion_params(3, 1))  # revealed: Literal[1]
+reveal_type(union_and_nonunion_params("a", 1))  # revealed: Literal["a", 1]
 ```
 
 ```py
 def tuple_param[T, S](x: T | S, y: tuple[T, S]) -> tuple[T, S]:
     return y
 
-# TODO: no error
-# TODO: revealed: tuple[str, int]
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(tuple_param("a", ("a", 1)))  # revealed: tuple[T, S]
-
-# TODO: no error
-# TODO: revealed: tuple[str, int]
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(tuple_param(1, ("a", 1)))  # revealed: tuple[T, S]
+reveal_type(tuple_param("a", ("a", 1)))  # revealed: tuple[Literal["a"], Literal[1]]
+reveal_type(tuple_param(1, ("a", 1)))  # revealed: tuple[Literal["a"], Literal[1]]
 ```
 
 ## Inferring nested generic function calls
@@ -232,15 +196,6 @@ def f[T](x: T) -> tuple[T, int]:
 def g[T](x: T) -> T | None:
     return x
 
-# TODO: no error
-# TODO: revealed: tuple[str | None, int]
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(f(g("a")))  # revealed: tuple[T, int]
-
-# TODO: no error
-# TODO: revealed: tuple[str, int] | None
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(g(f("a")))  # revealed: T | None
+reveal_type(f(g("a")))  # revealed: tuple[Literal["a"] | None, int]
+reveal_type(g(f("a")))  # revealed: tuple[Literal["a"], int] | None
 ```

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

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

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

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

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

@@ -1,5 +1,10 @@
 # Scoping rules for type variables
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 Most of these tests come from the [Scoping rules for type variables][scoping] section of the typing
 spec.
 
@@ -59,14 +64,8 @@ to a different type each time.
 def f[T](x: T) -> T:
     return x
 
-# TODO: no error
-# TODO: revealed: int or Literal[1]
-# error: [invalid-argument-type]
-reveal_type(f(1))  # revealed: T
-# TODO: no error
-# TODO: revealed: str or Literal["a"]
-# error: [invalid-argument-type]
-reveal_type(f("a"))  # revealed: T
+reveal_type(f(1))  # revealed: Literal[1]
+reveal_type(f("a"))  # revealed: Literal["a"]
 ```
 
 ## Methods can mention class typevars
@@ -82,18 +81,51 @@ class C[T]:
     def m2(self, x: T) -> T:
         return x
 
-c: C[int] = C()
-# TODO: no error
-# error: [invalid-argument-type]
+c: C[int] = C[int]()
 c.m1(1)
-# TODO: no error
-# error: [invalid-argument-type]
 c.m2(1)
-# TODO: expected type `int`
-# error: [invalid-argument-type] "Object of type `Literal["string"]` cannot be assigned to parameter 2 (`x`) of bound method `m2`; expected type `T`"
+# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["string"]`"
 c.m2("string")
 ```
 
+## Functions on generic classes are descriptors
+
+This repeats the tests in the [Functions as descriptors](./call/methods.md) test suite, but on a
+generic class. This ensures that we are carrying any specializations through the entirety of the
+descriptor protocol, which is how `self` parameters are bound to instance methods.
+
+```py
+from inspect import getattr_static
+
+class C[T]:
+    def f(self, x: T) -> str:
+        return "a"
+
+reveal_type(getattr_static(C[int], "f"))  # revealed: def f(self, x: int) -> str
+reveal_type(getattr_static(C[int], "f").__get__)  # revealed: <method-wrapper `__get__` of `f[int]`>
+reveal_type(getattr_static(C[int], "f").__get__(None, C[int]))  # revealed: def f(self, x: int) -> str
+# revealed: bound method C[int].f(x: int) -> str
+reveal_type(getattr_static(C[int], "f").__get__(C[int](), C[int]))
+
+reveal_type(C[int].f)  # revealed: def f(self, x: int) -> str
+reveal_type(C[int]().f)  # revealed: bound method C[int].f(x: int) -> str
+
+bound_method = C[int]().f
+reveal_type(bound_method.__self__)  # revealed: C[int]
+reveal_type(bound_method.__func__)  # revealed: def f(self, x: int) -> str
+
+reveal_type(C[int]().f(1))  # revealed: str
+reveal_type(bound_method(1))  # revealed: str
+
+C[int].f(1)  # error: [missing-argument]
+reveal_type(C[int].f(C[int](), 1))  # revealed: str
+
+class D[U](C[U]):
+    pass
+
+reveal_type(D[int]().f)  # revealed: bound method D[int].f(x: int) -> str
+```
+
 ## Methods can mention other typevars
 
 > A type variable used in a method that does not match any of the variables that parameterize the
@@ -105,8 +137,6 @@ from typing import TypeVar, Generic
 T = TypeVar("T")
 S = TypeVar("S")
 
-# TODO: no error
-# error: [invalid-base]
 class Legacy(Generic[T]):
     def m(self, x: T, y: S) -> S:
         return y
@@ -124,11 +154,7 @@ class C[T]:
         return y
 
 c: C[int] = C()
-# TODO: no errors
-# TODO: revealed: str
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(c.m(1, "string"))  # revealed: S
+reveal_type(c.m(1, "string"))  # revealed: Literal["string"]
 ```
 
 ## Unbound typevars
@@ -146,13 +172,11 @@ S = TypeVar("S")
 
 def f(x: T) -> None:
     x: list[T] = []
-    # TODO: error
+    # TODO: invalid-assignment error
     y: list[S] = []
 
-# TODO: no error
-# error: [invalid-base]
 class C(Generic[T]):
-    # TODO: error
+    # TODO: error: cannot use S if it's not in the current generic context
     x: list[S] = []
 
     # This is not an error, as shown in the previous test
@@ -172,11 +196,11 @@ S = TypeVar("S")
 
 def f[T](x: T) -> None:
     x: list[T] = []
-    # TODO: error
+    # TODO: invalid assignment error
     y: list[S] = []
 
 class C[T]:
-    # TODO: error
+    # TODO: error: cannot use S if it's not in the current generic context
     x: list[S] = []
 
     def m1(self, x: S) -> S:
@@ -231,8 +255,7 @@ def f[T](x: T, y: T) -> None:
     class Ok[S]: ...
     # TODO: error for reuse of typevar
     class Bad1[T]: ...
-    # TODO: no non-subscriptable error, error for reuse of typevar
-    # error: [non-subscriptable]
+    # TODO: error for reuse of typevar
     class Bad2(Iterable[T]): ...
 ```
 
@@ -245,8 +268,7 @@ class C[T]:
     class Ok1[S]: ...
     # TODO: error for reuse of typevar
     class Bad1[T]: ...
-    # TODO: no non-subscriptable error, error for reuse of typevar
-    # error: [non-subscriptable]
+    # TODO: error for reuse of typevar
     class Bad2(Iterable[T]): ...
 ```
 
@@ -260,11 +282,11 @@ class C[T]:
     ok1: list[T] = []
 
     class Bad:
-        # TODO: error
+        # TODO: error: cannot refer to T in nested scope
         bad: list[T] = []
 
     class Inner[S]: ...
     ok2: Inner[T]
 ```
 
-[scoping]: https://typing.readthedocs.io/en/latest/spec/generics.html#scoping-rules-for-type-variables
+[scoping]: https://typing.python.org/en/latest/spec/generics.html#scoping-rules-for-type-variables

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

@@ -0,0 +1,277 @@
+# Variance
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+Type variables have a property called _variance_ that affects the subtyping and assignability
+relations. Much more detail can be found in the [spec]. To summarize, each typevar is either
+**covariant**, **contravariant**, **invariant**, or **bivariant**. (Note that bivariance is not
+currently mentioned in the typing spec, but is a fourth case that we must consider.)
+
+For all of the examples below, we will consider a typevar `T`, a generic class using that typevar
+`C[T]`, and two types `A` and `B`.
+
+## Covariance
+
+With a covariant typevar, subtyping is in "alignment": if `A <: B`, then `C[A] <: C[B]`.
+
+Types that "produce" data on demand are covariant in their typevar. If you expect a sequence of
+`int`s, someone can safely provide a sequence of `bool`s, since each `bool` element that you would
+get from the sequence is a valid `int`.
+
+```py
+from knot_extensions import is_assignable_to, is_equivalent_to, is_gradual_equivalent_to, is_subtype_of, static_assert, Unknown
+from typing import Any
+
+class A: ...
+class B(A): ...
+
+class C[T]:
+    def receive(self) -> T:
+        raise ValueError
+
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_assignable_to(C[B], C[A]))
+static_assert(not is_assignable_to(C[A], C[B]))
+static_assert(is_assignable_to(C[A], C[Any]))
+static_assert(is_assignable_to(C[B], C[Any]))
+static_assert(is_assignable_to(C[Any], C[A]))
+static_assert(is_assignable_to(C[Any], C[B]))
+
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_subtype_of(C[B], C[A]))
+static_assert(not is_subtype_of(C[A], C[B]))
+static_assert(not is_subtype_of(C[A], C[Any]))
+static_assert(not is_subtype_of(C[B], C[Any]))
+static_assert(not is_subtype_of(C[Any], C[A]))
+static_assert(not is_subtype_of(C[Any], C[B]))
+
+static_assert(is_equivalent_to(C[A], C[A]))
+static_assert(is_equivalent_to(C[B], C[B]))
+static_assert(not is_equivalent_to(C[B], C[A]))
+static_assert(not is_equivalent_to(C[A], C[B]))
+static_assert(not is_equivalent_to(C[A], C[Any]))
+static_assert(not is_equivalent_to(C[B], C[Any]))
+static_assert(not is_equivalent_to(C[Any], C[A]))
+static_assert(not is_equivalent_to(C[Any], C[B]))
+
+static_assert(is_gradual_equivalent_to(C[A], C[A]))
+static_assert(is_gradual_equivalent_to(C[B], C[B]))
+static_assert(is_gradual_equivalent_to(C[Any], C[Any]))
+static_assert(is_gradual_equivalent_to(C[Any], C[Unknown]))
+static_assert(not is_gradual_equivalent_to(C[B], C[A]))
+static_assert(not is_gradual_equivalent_to(C[A], C[B]))
+static_assert(not is_gradual_equivalent_to(C[A], C[Any]))
+static_assert(not is_gradual_equivalent_to(C[B], C[Any]))
+static_assert(not is_gradual_equivalent_to(C[Any], C[A]))
+static_assert(not is_gradual_equivalent_to(C[Any], C[B]))
+```
+
+## Contravariance
+
+With a contravariant typevar, subtyping is in "opposition": if `A <: B`, then `C[B] <: C[A]`.
+
+Types that "consume" data are contravariant in their typevar. If you expect a consumer that receives
+`bool`s, someone can safely provide a consumer that expects to receive `int`s, since each `bool`
+that you pass into the consumer is a valid `int`.
+
+```py
+from knot_extensions import is_assignable_to, is_equivalent_to, is_gradual_equivalent_to, is_subtype_of, static_assert, Unknown
+from typing import Any
+
+class A: ...
+class B(A): ...
+
+class C[T]:
+    def send(self, value: T): ...
+
+static_assert(not is_assignable_to(C[B], C[A]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_assignable_to(C[A], C[B]))
+static_assert(is_assignable_to(C[A], C[Any]))
+static_assert(is_assignable_to(C[B], C[Any]))
+static_assert(is_assignable_to(C[Any], C[A]))
+static_assert(is_assignable_to(C[Any], C[B]))
+
+static_assert(not is_subtype_of(C[B], C[A]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_subtype_of(C[A], C[B]))
+static_assert(not is_subtype_of(C[A], C[Any]))
+static_assert(not is_subtype_of(C[B], C[Any]))
+static_assert(not is_subtype_of(C[Any], C[A]))
+static_assert(not is_subtype_of(C[Any], C[B]))
+
+static_assert(is_equivalent_to(C[A], C[A]))
+static_assert(is_equivalent_to(C[B], C[B]))
+static_assert(not is_equivalent_to(C[B], C[A]))
+static_assert(not is_equivalent_to(C[A], C[B]))
+static_assert(not is_equivalent_to(C[A], C[Any]))
+static_assert(not is_equivalent_to(C[B], C[Any]))
+static_assert(not is_equivalent_to(C[Any], C[A]))
+static_assert(not is_equivalent_to(C[Any], C[B]))
+
+static_assert(is_gradual_equivalent_to(C[A], C[A]))
+static_assert(is_gradual_equivalent_to(C[B], C[B]))
+static_assert(is_gradual_equivalent_to(C[Any], C[Any]))
+static_assert(is_gradual_equivalent_to(C[Any], C[Unknown]))
+static_assert(not is_gradual_equivalent_to(C[B], C[A]))
+static_assert(not is_gradual_equivalent_to(C[A], C[B]))
+static_assert(not is_gradual_equivalent_to(C[A], C[Any]))
+static_assert(not is_gradual_equivalent_to(C[B], C[Any]))
+static_assert(not is_gradual_equivalent_to(C[Any], C[A]))
+static_assert(not is_gradual_equivalent_to(C[Any], C[B]))
+```
+
+## Invariance
+
+With an invariant typevar, _no_ specializations of the generic class are subtypes of each other.
+
+This often occurs for types that are both producers _and_ consumers, like a mutable `list`.
+Iterating over the elements in a list would work with a covariant typevar, just like with the
+"producer" type above. Appending elements to a list would work with a contravariant typevar, just
+like with the "consumer" type above. However, a typevar cannot be both covariant and contravariant
+at the same time!
+
+If you expect a mutable list of `int`s, it's not safe for someone to provide you with a mutable list
+of `bool`s, since you might try to add an element to the list: if you try to add an `int`, the list
+would no longer only contain elements that are subtypes of `bool`.
+
+Conversely, if you expect a mutable list of `bool`s, it's not safe for someone to provide you with a
+mutable list of `int`s, since you might try to extract elements from the list: you expect every
+element that you extract to be a subtype of `bool`, but the list can contain any `int`.
+
+In the end, if you expect a mutable list, you must always be given a list of exactly that type,
+since we can't know in advance which of the allowed methods you'll want to use.
+
+```py
+from knot_extensions import is_assignable_to, is_equivalent_to, is_gradual_equivalent_to, is_subtype_of, static_assert, Unknown
+from typing import Any
+
+class A: ...
+class B(A): ...
+
+class C[T]:
+    def send(self, value: T): ...
+    def receive(self) -> T:
+        raise ValueError
+
+static_assert(not is_assignable_to(C[B], C[A]))
+static_assert(not is_assignable_to(C[A], C[B]))
+static_assert(is_assignable_to(C[A], C[Any]))
+static_assert(is_assignable_to(C[B], C[Any]))
+static_assert(is_assignable_to(C[Any], C[A]))
+static_assert(is_assignable_to(C[Any], C[B]))
+
+static_assert(not is_subtype_of(C[B], C[A]))
+static_assert(not is_subtype_of(C[A], C[B]))
+static_assert(not is_subtype_of(C[A], C[Any]))
+static_assert(not is_subtype_of(C[B], C[Any]))
+static_assert(not is_subtype_of(C[Any], C[A]))
+static_assert(not is_subtype_of(C[Any], C[B]))
+
+static_assert(is_equivalent_to(C[A], C[A]))
+static_assert(is_equivalent_to(C[B], C[B]))
+static_assert(not is_equivalent_to(C[B], C[A]))
+static_assert(not is_equivalent_to(C[A], C[B]))
+static_assert(not is_equivalent_to(C[A], C[Any]))
+static_assert(not is_equivalent_to(C[B], C[Any]))
+static_assert(not is_equivalent_to(C[Any], C[A]))
+static_assert(not is_equivalent_to(C[Any], C[B]))
+
+static_assert(is_gradual_equivalent_to(C[A], C[A]))
+static_assert(is_gradual_equivalent_to(C[B], C[B]))
+static_assert(is_gradual_equivalent_to(C[Any], C[Any]))
+static_assert(is_gradual_equivalent_to(C[Any], C[Unknown]))
+static_assert(not is_gradual_equivalent_to(C[B], C[A]))
+static_assert(not is_gradual_equivalent_to(C[A], C[B]))
+static_assert(not is_gradual_equivalent_to(C[A], C[Any]))
+static_assert(not is_gradual_equivalent_to(C[B], C[Any]))
+static_assert(not is_gradual_equivalent_to(C[Any], C[A]))
+static_assert(not is_gradual_equivalent_to(C[Any], C[B]))
+```
+
+## Bivariance
+
+With a bivariant typevar, _all_ specializations of the generic class are subtypes of (and in fact,
+equivalent to) each other.
+
+This is a bit of pathological case, which really only happens when the class doesn't use the typevar
+at all. (If it did, it would have to be covariant, contravariant, or invariant, depending on _how_
+the typevar was used.)
+
+```py
+from knot_extensions import is_assignable_to, is_equivalent_to, is_gradual_equivalent_to, is_subtype_of, static_assert, Unknown
+from typing import Any
+
+class A: ...
+class B(A): ...
+
+class C[T]:
+    pass
+
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_assignable_to(C[B], C[A]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_assignable_to(C[A], C[B]))
+static_assert(is_assignable_to(C[A], C[Any]))
+static_assert(is_assignable_to(C[B], C[Any]))
+static_assert(is_assignable_to(C[Any], C[A]))
+static_assert(is_assignable_to(C[Any], C[B]))
+
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_subtype_of(C[B], C[A]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_subtype_of(C[A], C[B]))
+static_assert(not is_subtype_of(C[A], C[Any]))
+static_assert(not is_subtype_of(C[B], C[Any]))
+static_assert(not is_subtype_of(C[Any], C[A]))
+static_assert(not is_subtype_of(C[Any], C[B]))
+
+static_assert(is_equivalent_to(C[A], C[A]))
+static_assert(is_equivalent_to(C[B], C[B]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_equivalent_to(C[B], C[A]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_equivalent_to(C[A], C[B]))
+static_assert(not is_equivalent_to(C[A], C[Any]))
+static_assert(not is_equivalent_to(C[B], C[Any]))
+static_assert(not is_equivalent_to(C[Any], C[A]))
+static_assert(not is_equivalent_to(C[Any], C[B]))
+
+static_assert(is_gradual_equivalent_to(C[A], C[A]))
+static_assert(is_gradual_equivalent_to(C[B], C[B]))
+static_assert(is_gradual_equivalent_to(C[Any], C[Any]))
+static_assert(is_gradual_equivalent_to(C[Any], C[Unknown]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_gradual_equivalent_to(C[B], C[A]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_gradual_equivalent_to(C[A], C[B]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_gradual_equivalent_to(C[A], C[Any]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_gradual_equivalent_to(C[B], C[Any]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_gradual_equivalent_to(C[Any], C[A]))
+# TODO: no error
+# error: [static-assert-error]
+static_assert(is_gradual_equivalent_to(C[Any], C[B]))
+```
+
+[spec]: https://typing.python.org/en/latest/spec/generics.html#variance

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

@@ -7,7 +7,7 @@ Builtin symbols can be explicitly imported:
 ```py
 import builtins
 
-reveal_type(builtins.chr)  # revealed: Literal[chr]
+reveal_type(builtins.chr)  # revealed: def chr(i: int | SupportsIndex, /) -> str
 ```
 
 ## Implicit use of builtin
@@ -15,7 +15,7 @@ reveal_type(builtins.chr)  # revealed: Literal[chr]
 Or used implicitly:
 
 ```py
-reveal_type(chr)  # revealed: Literal[chr]
+reveal_type(chr)  # revealed: def chr(i: int | SupportsIndex, /) -> str
 reveal_type(str)  # revealed: Literal[str]
 ```
 

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

@@ -103,8 +103,8 @@ else:
 ```py
 from b import f
 
-# TODO: We should disambiguate in such cases, showing `Literal[b.f, c.f]`.
-reveal_type(f)  # revealed: Literal[f, f]
+# TODO: We should disambiguate in such cases between `b.f` and `c.f`.
+reveal_type(f)  # revealed: (def f() -> Unknown) | (def f() -> Unknown)
 ```
 
 ## Reimport with stub declaration

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

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

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

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