[red-knot] Completely hide unreachable symbols

.github/workflows/build-binaries.yml

@@ -49,7 +49,7 @@ jobs:
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build sdist"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
+        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
         with:
           command: sdist
           args: --out dist
@@ -79,7 +79,7 @@ jobs:
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels - x86_64"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
+        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
         with:
           target: x86_64
           args: --release --locked --out dist
@@ -121,7 +121,7 @@ jobs:
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels - aarch64"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
+        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
         with:
           target: aarch64
           args: --release --locked --out dist
@@ -177,7 +177,7 @@ jobs:
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
+        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
         with:
           target: ${{ matrix.platform.target }}
           args: --release --locked --out dist
@@ -230,7 +230,7 @@ jobs:
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
+        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
         with:
           target: ${{ matrix.target }}
           manylinux: auto
@@ -304,7 +304,7 @@ jobs:
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
+        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
         with:
           target: ${{ matrix.platform.target }}
           manylinux: auto
@@ -370,14 +370,14 @@ jobs:
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
+        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.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@4f65fabd2431ebc8d299f8e5a018d79a769ae185 # v3
+        uses: addnab/docker-run-action@v3
         with:
           image: alpine:latest
           options: -v ${{ github.workspace }}:/io -w /io
@@ -435,7 +435,7 @@ jobs:
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
+        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
         with:
           target: ${{ matrix.platform.target }}
           manylinux: musllinux_1_2

.github/workflows/ci.yaml

@@ -237,13 +237,13 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
-        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
+        uses: rui314/setup-mold@v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
+        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
+        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
         with:
           tool: cargo-insta
       - name: Red-knot mdtests (GitHub annotations)
@@ -291,13 +291,13 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
-        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
+        uses: rui314/setup-mold@v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
+        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
+        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
         with:
           tool: cargo-insta
       - name: "Run tests"
@@ -320,7 +320,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
+        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
         with:
           tool: cargo-nextest
       - name: "Run tests"
@@ -376,7 +376,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
-        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
+        uses: rui314/setup-mold@v1
       - name: "Build"
         run: cargo build --release --locked
 
@@ -401,13 +401,13 @@ jobs:
           MSRV: ${{ steps.msrv.outputs.value }}
         run: rustup default "${MSRV}"
       - name: "Install mold"
-        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
+        uses: rui314/setup-mold@v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
+        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
+        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
         with:
           tool: cargo-insta
       - name: "Run tests"
@@ -433,7 +433,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install cargo-binstall"
-        uses: cargo-bins/cargo-binstall@63aaa5c1932cebabc34eceda9d92a70215dcead6 # v1.12.3
+        uses: cargo-bins/cargo-binstall@main
         with:
           tool: cargo-fuzz@0.11.2
       - name: "Install cargo-fuzz"
@@ -455,7 +455,7 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
+      - uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
       - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
         name: Download Ruff binary to test
         id: download-cached-binary
@@ -641,7 +641,7 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: cargo-bins/cargo-binstall@63aaa5c1932cebabc34eceda9d92a70215dcead6 # v1.12.3
+      - uses: cargo-bins/cargo-binstall@main
       - run: cargo binstall --no-confirm cargo-shear
       - run: cargo shear
 
@@ -662,7 +662,7 @@ jobs:
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
+        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
         with:
           args: --out dist
       - name: "Test wheel"
@@ -681,7 +681,7 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
+      - uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
       - name: "Cache pre-commit"
         uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3
         with:
@@ -720,7 +720,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: Install uv
-        uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
+        uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
         run: uv pip install -r docs/requirements-insiders.txt --system
@@ -857,7 +857,7 @@ jobs:
         run: rustup show
 
       - name: "Install codspeed"
-        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
+        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
         with:
           tool: cargo-codspeed
 

.github/workflows/daily_fuzz.yaml

@@ -34,11 +34,11 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
+      - uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
-        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
+        uses: rui314/setup-mold@v1
       - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: Build ruff
         # A debug build means the script runs slower once it gets started,

.github/workflows/daily_property_tests.yaml

@@ -36,7 +36,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
-        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
+        uses: rui314/setup-mold@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

.github/workflows/mypy_primer.yaml

@@ -35,7 +35,7 @@ jobs:
           persist-credentials: false
 
       - name: Install the latest version of uv
-        uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
+        uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
 
       - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
         with:
@@ -45,15 +45,13 @@ jobs:
 
       - name: Install mypy_primer
         run: |
-          uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support-v5"
+          uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support-v4"
 
       - 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"
 
@@ -64,14 +62,13 @@ 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 "/($PRIMER_SELECTOR)\$" \
+            --project-selector '/(mypy_primer|black|pyp|git-revise|zipp|arrow|isort|itsdangerous|rich|packaging|pybind11|pyinstrument|typeshed-stats|scrapy|werkzeug|bidict|async-utils)$' \
             --output concise \
             --debug > mypy_primer.diff || [ $? -eq 1 ]
 

.github/workflows/publish-pypi.yml

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

.github/workflows/release.yml

@@ -1,6 +1,5 @@
 # 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
 #
@@ -60,17 +59,16 @@ jobs:
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
-          persist-credentials: false
           submodules: recursive
       - name: Install dist
         # we specify bash to get pipefail; it guards against the `curl` command
         # failing. otherwise `sh` won't catch that `curl` returned non-0
         shell: bash
-        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/astral-sh/cargo-dist/releases/download/v0.28.4-prerelease.1/cargo-dist-installer.sh | sh"
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/astral-sh/cargo-dist/releases/download/v0.28.3/cargo-dist-installer.sh | sh"
       - name: Cache dist
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/dist
@@ -86,7 +84,7 @@ jobs:
           cat plan-dist-manifest.json
           echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
       - name: "Upload dist-manifest.json"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: artifacts-plan-dist-manifest
           path: plan-dist-manifest.json
@@ -123,19 +121,18 @@ jobs:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
-          persist-credentials: false
           submodules: recursive
       - name: Install cached dist
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/
       - run: chmod +x ~/.cargo/bin/dist
       # Get all the local artifacts for the global tasks to use (for e.g. checksums)
       - name: Fetch local artifacts
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
         with:
           pattern: artifacts-*
           path: target/distrib/
@@ -153,7 +150,7 @@ jobs:
 
           cp dist-manifest.json "$BUILD_MANIFEST_NAME"
       - name: "Upload artifacts"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: artifacts-build-global
           path: |
@@ -174,19 +171,18 @@ jobs:
     outputs:
       val: ${{ steps.host.outputs.manifest }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
-          persist-credentials: false
           submodules: recursive
       - name: Install cached dist
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/
       - run: chmod +x ~/.cargo/bin/dist
       # Fetch artifacts from scratch-storage
       - name: Fetch artifacts
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
         with:
           pattern: artifacts-*
           path: target/distrib/
@@ -200,7 +196,7 @@ jobs:
           cat dist-manifest.json
           echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
       - name: "Upload dist-manifest.json"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           # Overwrite the previous copy
           name: artifacts-dist-manifest
@@ -250,13 +246,12 @@ jobs:
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
-          persist-credentials: false
           submodules: recursive
       # Create a GitHub Release while uploading all files to it
       - name: "Download GitHub Artifacts"
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
         with:
           pattern: artifacts-*
           path: artifacts

.pre-commit-config.yaml

@@ -18,11 +18,6 @@ exclude: |
   )$
 
 repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
-    hooks:
-      - id: check-merge-conflict
-
   - repo: https://github.com/abravalheri/validate-pyproject
     rev: v0.24.1
     hooks:
@@ -79,7 +74,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.6
+    rev: v0.11.4
     hooks:
       - id: ruff-format
       - id: ruff
@@ -97,12 +92,12 @@ repos:
   # zizmor detects security vulnerabilities in GitHub Actions workflows.
   # Additional configuration for the tool is found in `.github/zizmor.yml`
   - repo: https://github.com/woodruffw/zizmor-pre-commit
-    rev: v1.6.0
+    rev: v1.5.2
     hooks:
       - id: zizmor
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.33.0
+    rev: 0.32.1
     hooks:
       - id: check-github-workflows
 

CHANGELOG.md

@@ -1,41 +1,5 @@
 # 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

Cargo.lock

@@ -128,9 +128,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.98"
+version = "1.0.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
 
 [[package]]
 name = "argfile"
@@ -216,9 +216,9 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.12.0"
+version = "1.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
+checksum = "531a9155a481e2ee699d4f98f43c0ca4ff8ee1bfd55c31e9e98fb29d2b176fe0"
 dependencies = [
  "memchr",
  "regex-automata 0.4.9",
@@ -334,9 +334,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.37"
+version = "4.5.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eccb054f56cbd38340b380d4a8e69ef1f02f1af43db2f0cc817a4774d80ae071"
+checksum = "d8aa86934b44c19c50f87cc2790e19f54f7a67aedb64101c2e1a2e5ecfb73944"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -344,9 +344,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.37"
+version = "4.5.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efd9466fac8543255d3b1fcad4762c5e116ffe808c8a3043d4263cd4fd4862a2"
+checksum = "2414dbb2dd0695280da6ea9261e327479e9d37b0630f6b53ba2a11c60c679fd9"
 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.52.0",
+ "windows-sys 0.48.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.52.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -1553,45 +1553,28 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "jiff"
-version = "0.2.9"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59ec30f7142be6fe14e1b021f50b85db8df2d4324ea6e91ec3e5dcde092021d0"
+checksum = "d699bc6dfc879fb1bf9bdff0d4c56f0884fc6f0d0eb0fba397a6d00cd9a6b85e"
 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.9"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "526b834d727fd59d37b076b0c3236d9adde1b1729a4361e20b2026f738cc1dbe"
+checksum = "8d16e75759ee0aa64c57a56acbf43916987b20c77373cb7e808979e02b93c9f9"
 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"
@@ -1645,9 +1628,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.172"
+version = "0.2.171"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
 
 [[package]]
 name = "libcst"
@@ -1676,9 +1659,9 @@ dependencies = [
 
 [[package]]
 name = "libmimalloc-sys"
-version = "0.1.42"
+version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec9d6fac27761dabcd4ee73571cdb06b7022dc99089acbe5435691edffaac0f4"
+checksum = "6b20daca3a4ac14dbdc753c5e90fc7b490a48a9131daed3c9a9ced7b2defd37b"
 dependencies = [
  "cc",
  "libc",
@@ -1814,9 +1797,9 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "mimalloc"
-version = "0.1.46"
+version = "0.1.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "995942f432bbb4822a7e9c3faa87a695185b0d09273ba85f097b54f4e458f2af"
+checksum = "03cb1f88093fe50061ca1195d336ffec131347c7b833db31f9ab62a2d1b7925f"
 dependencies = [
  "libmimalloc-sys",
 ]
@@ -2327,9 +2310,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
 dependencies = [
  "unicode-ident",
 ]
@@ -2420,12 +2403,13 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
+ "zerocopy",
 ]
 
 [[package]]
@@ -2492,6 +2476,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "argfile",
+ "chrono",
  "clap",
  "colored 3.0.0",
  "countme",
@@ -2500,7 +2485,6 @@ dependencies = [
  "filetime",
  "insta",
  "insta-cmd",
- "jiff",
  "rayon",
  "red_knot_project",
  "red_knot_python_semantic",
@@ -2772,7 +2756,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.11.6"
+version = "0.11.4"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2780,6 +2764,7 @@ dependencies = [
  "bincode",
  "bitflags 2.9.0",
  "cachedir",
+ "chrono",
  "clap",
  "clap_complete_command",
  "clearscreen",
@@ -2792,7 +2777,6 @@ dependencies = [
  "insta-cmd",
  "is-macro",
  "itertools 0.14.0",
- "jiff",
  "log",
  "mimalloc",
  "notify",
@@ -3007,11 +2991,12 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.11.6"
+version = "0.11.4"
 dependencies = [
  "aho-corasick",
  "anyhow",
  "bitflags 2.9.0",
+ "chrono",
  "clap",
  "colored 3.0.0",
  "fern",
@@ -3022,7 +3007,6 @@ dependencies = [
  "is-macro",
  "is-wsl",
  "itertools 0.14.0",
- "jiff",
  "libcst",
  "log",
  "memchr",
@@ -3083,7 +3067,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
- "rand 0.9.1",
+ "rand 0.9.0",
  "ruff_diagnostics",
  "ruff_source_file",
  "ruff_text_size",
@@ -3333,7 +3317,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.11.6"
+version = "0.11.4"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -3458,7 +3442,7 @@ checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 [[package]]
 name = "salsa"
 version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=296a8c78da1b54c76ff5795eb4c1e3fe2467e9fc#296a8c78da1b54c76ff5795eb4c1e3fe2467e9fc"
 dependencies = [
  "boxcar",
  "compact_str 0.8.1",
@@ -3481,12 +3465,12 @@ dependencies = [
 [[package]]
 name = "salsa-macro-rules"
 version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=296a8c78da1b54c76ff5795eb4c1e3fe2467e9fc#296a8c78da1b54c76ff5795eb4c1e3fe2467e9fc"
 
 [[package]]
 name = "salsa-macros"
 version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=296a8c78da1b54c76ff5795eb4c1e3fe2467e9fc#296a8c78da1b54c76ff5795eb4c1e3fe2467e9fc"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -3674,9 +3658,9 @@ dependencies = [
 
 [[package]]
 name = "shellexpand"
-version = "3.1.1"
+version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b1fdf65dd6331831494dd616b30351c38e96e45921a27745cf98490458b90bb"
+checksum = "da03fa3b94cc19e3ebfc88c4229c49d8f08cdbd1228870a45f0ffdf84988e14b"
 dependencies = [
  "dirs",
 ]
@@ -4327,7 +4311,7 @@ checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
 dependencies = [
  "getrandom 0.3.2",
  "js-sys",
- "rand 0.9.1",
+ "rand 0.9.0",
  "uuid-macro-internal",
  "wasm-bindgen",
 ]
@@ -4598,7 +4582,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]

Cargo.toml

@@ -55,6 +55,7 @@ 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,7 +95,6 @@ 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" }
@@ -124,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 = "87bf6b6c2d5f6479741271da73bd9d30c2580c26" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "296a8c78da1b54c76ff5795eb4c1e3fe2467e9fc" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -272,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.28.4-prerelease.1"
+cargo-dist-version = "0.28.3"
 # CI backends to support
 ci = "github"
 # The installers to generate for each app
@@ -329,12 +329,9 @@ github-custom-job-permissions = { "build-docker" = { packages = "write", content
 install-updater = false
 # Path that installers should place binaries in
 install-path = ["$XDG_BIN_HOME/", "$XDG_DATA_HOME/../bin", "~/.local/bin"]
+# Temporarily allow changes to the `release` workflow, in which we pin actions
+# to a SHA instead of a tag (https://github.com/astral-sh/uv/issues/12253)
+allow-dirty = ["ci"]
 
 [workspace.metadata.dist.github-custom-runners]
 global = "depot-ubuntu-latest-4"
-
-[workspace.metadata.dist.github-action-commits]
-"actions/checkout" = "11bd71901bbe5b1630ceea73d27597364c9af683" # v4
-"actions/upload-artifact" = "ea165f8d65b6e75b540449e92b4886f43607fa02" # v4.6.2
-"actions/download-artifact" = "95815c38cf2ff2164869cbab79da8d1f422bc89e" # v4.2.1
-"actions/attest-build-provenance" = "c074443f1aee8d4aeeae555aebba3282517141b2" #v2.2.3

README.md

@@ -149,8 +149,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.11.6/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.11.6/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.11.4/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.11.4/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.6
+  rev: v0.11.4
   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 we currently enable in CI, use `--project-selector "/($(paste -s -d'|' crates/red_knot_python_semantic/resources/primer/good.txt))\$"`.
+diff for all projects, you currently need to copy the project-selector regex from the CI pipeline in `.github/workflows/mypy_primer.yaml`.
 
 You can also take a look at the [full list of ecosystem projects]. Note that some of them might still need a `knot_paths` configuration
 option to work correctly.

crates/red_knot/src/logging.rs

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

crates/red_knot/tests/cli.rs

@@ -83,13 +83,13 @@ fn config_override_python_platform() -> anyhow::Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
-    info: revealed-type: Revealed type
+    info: revealed-type
      --> <temp_dir>/test.py:5:1
       |
     3 | from typing_extensions import reveal_type
     4 |
     5 | reveal_type(sys.platform)
-      | ^^^^^^^^^^^^^^^^^^^^^^^^^ `Literal["linux"]`
+      | ^^^^^^^^^^^^^^^^^^^^^^^^^ Revealed type is `Literal["linux"]`
       |
 
     Found 1 diagnostic
@@ -101,13 +101,13 @@ fn config_override_python_platform() -> anyhow::Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
-    info: revealed-type: Revealed type
+    info: revealed-type
      --> <temp_dir>/test.py:5:1
       |
     3 | from typing_extensions import reveal_type
     4 |
     5 | reveal_type(sys.platform)
-      | ^^^^^^^^^^^^^^^^^^^^^^^^^ `LiteralString`
+      | ^^^^^^^^^^^^^^^^^^^^^^^^^ Revealed type is `LiteralString`
       |
 
     Found 1 diagnostic
@@ -252,7 +252,7 @@ fn configuration_rule_severity() -> anyhow::Result<()> {
         r#"
             y = 4 / 0
 
-            for a in range(0, int(y)):
+            for a in range(0, y):
                 x = a
 
             print(x)  # possibly-unresolved-reference
@@ -271,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, int(y)):
+    4 | for a in range(0, y):
       |
 
     warning: lint:possibly-unresolved-reference
@@ -307,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, int(y)):
+    4 | for a in range(0, y):
       |
 
     Found 1 diagnostic
@@ -328,7 +328,7 @@ fn cli_rule_severity() -> anyhow::Result<()> {
 
         y = 4 / 0
 
-        for a in range(0, int(y)):
+        for a in range(0, y):
             x = a
 
         print(x)  # possibly-unresolved-reference
@@ -358,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, int(y)):
+    6 | for a in range(0, y):
       |
 
     warning: lint:possibly-unresolved-reference
@@ -405,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, int(y)):
+    6 | for a in range(0, y):
       |
 
     Found 2 diagnostics
@@ -426,7 +426,7 @@ fn cli_rule_severity_precedence() -> anyhow::Result<()> {
         r#"
         y = 4 / 0
 
-        for a in range(0, int(y)):
+        for a in range(0, y):
             x = a
 
         print(x)  # possibly-unresolved-reference
@@ -445,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, int(y)):
+    4 | for a in range(0, y):
       |
 
     warning: lint:possibly-unresolved-reference
@@ -482,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, int(y)):
+    4 | for a in range(0, y):
       |
 
     Found 1 diagnostic
@@ -584,12 +584,12 @@ fn exit_code_only_info() -> anyhow::Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
-    info: revealed-type: Revealed type
+    info: revealed-type
      --> <temp_dir>/test.py:3:1
       |
     2 | from typing_extensions import reveal_type
     3 | reveal_type(1)
-      | ^^^^^^^^^^^^^^ `Literal[1]`
+      | ^^^^^^^^^^^^^^ Revealed type is `Literal[1]`
       |
 
     Found 1 diagnostic
@@ -614,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: Revealed type
+    info: revealed-type
      --> <temp_dir>/test.py:3:1
       |
     2 | from typing_extensions import reveal_type
     3 | reveal_type(1)
-      | ^^^^^^^^^^^^^^ `Literal[1]`
+      | ^^^^^^^^^^^^^^ Revealed type is `Literal[1]`
       |
 
     Found 1 diagnostic
@@ -814,7 +814,7 @@ fn user_configuration() -> anyhow::Result<()> {
             r#"
             y = 4 / 0
 
-            for a in range(0, int(y)):
+            for a in range(0, y):
                 x = a
 
             print(x)
@@ -841,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, int(y)):
+    4 | for a in range(0, y):
       |
 
     warning: lint:possibly-unresolved-reference
@@ -883,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, int(y)):
+    4 | for a in range(0, y):
       |
 
     error: lint:possibly-unresolved-reference
@@ -1052,39 +1052,6 @@ 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_ide/src/db.rs

@@ -10,7 +10,7 @@ pub(crate) mod tests {
 
     use super::Db;
     use red_knot_python_semantic::lint::{LintRegistry, RuleSelection};
-    use red_knot_python_semantic::{default_lint_registry, Db as SemanticDb, Program};
+    use red_knot_python_semantic::{default_lint_registry, Db as SemanticDb};
     use ruff_db::files::{File, Files};
     use ruff_db::system::{DbWithTestSystem, System, TestSystem};
     use ruff_db::vendored::VendoredFileSystem;
@@ -83,10 +83,6 @@ 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 SourceDb> for TestDb {

crates/red_knot_ide/src/goto.rs

@@ -421,16 +421,16 @@ mod tests {
             "#,
         );
 
-        assert_snapshot!(test.goto_type_definition(), @r#"
+        assert_snapshot!(test.goto_type_definition(), @r###"
         info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:438:7
+           --> stdlib/builtins.pyi:443:7
             |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
+        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        442 |
+        443 | class str(Sequence[str]):
             |       ^^^
-        439 |     @overload
-        440 |     def __new__(cls, object: object = ...) -> Self: ...
+        444 |     @overload
+        445 |     def __new__(cls, object: object = ...) -> Self: ...
             |
         info: Source
          --> /main.py:4:13
@@ -440,7 +440,7 @@ mod tests {
         4 |             a
           |             ^
           |
-        "#);
+        "###);
     }
     #[test]
     fn goto_type_of_expression_with_literal_node() {
@@ -450,16 +450,16 @@ mod tests {
             "#,
         );
 
-        assert_snapshot!(test.goto_type_definition(), @r#"
+        assert_snapshot!(test.goto_type_definition(), @r###"
         info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:438:7
+           --> stdlib/builtins.pyi:443:7
             |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
+        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        442 |
+        443 | class str(Sequence[str]):
             |       ^^^
-        439 |     @overload
-        440 |     def __new__(cls, object: object = ...) -> Self: ...
+        444 |     @overload
+        445 |     def __new__(cls, object: object = ...) -> Self: ...
             |
         info: Source
          --> /main.py:2:22
@@ -467,7 +467,7 @@ mod tests {
         2 |             a: str = "test"
           |                      ^^^^^^
           |
-        "#);
+        "###);
     }
 
     #[test]
@@ -532,16 +532,16 @@ mod tests {
             "#,
         );
 
-        assert_snapshot!(test.goto_type_definition(), @r#"
+        assert_snapshot!(test.goto_type_definition(), @r###"
         info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:438:7
+           --> stdlib/builtins.pyi:443:7
             |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
+        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        442 |
+        443 | class str(Sequence[str]):
             |       ^^^
-        439 |     @overload
-        440 |     def __new__(cls, object: object = ...) -> Self: ...
+        444 |     @overload
+        445 |     def __new__(cls, object: object = ...) -> Self: ...
             |
         info: Source
          --> /main.py:4:18
@@ -551,7 +551,7 @@ mod tests {
         4 |             test(a= "123")
           |                  ^
           |
-        "#);
+        "###);
     }
 
     #[test]
@@ -567,16 +567,16 @@ mod tests {
         // 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"
+        assert_snapshot!(test.goto_type_definition(), @r###"
         info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:231:7
+           --> stdlib/builtins.pyi:234:7
             |
-        229 | _LiteralInteger = _PositiveInteger | _NegativeInteger | Literal[0]  # noqa: Y026  # TODO: Use TypeAlias once mypy bugs are fixed
-        230 |
-        231 | class int:
+        232 | _LiteralInteger = _PositiveInteger | _NegativeInteger | Literal[0]  # noqa: Y026  # TODO: Use TypeAlias once mypy bugs are fixed
+        233 |
+        234 | class int:
             |       ^^^
-        232 |     @overload
-        233 |     def __new__(cls, x: ConvertibleToInt = ..., /) -> Self: ...
+        235 |     @overload
+        236 |     def __new__(cls, x: ConvertibleToInt = ..., /) -> Self: ...
             |
         info: Source
          --> /main.py:4:18
@@ -586,7 +586,7 @@ mod tests {
         4 |             test(a= 123)
           |                  ^
           |
-        ");
+        "###);
     }
 
     #[test]
@@ -601,16 +601,16 @@ f(**kwargs<CURSOR>)
             "#,
         );
 
-        assert_snapshot!(test.goto_type_definition(), @r#"
+        assert_snapshot!(test.goto_type_definition(), @r###"
         info: lint:goto-type-definition: Type definition
-            --> stdlib/builtins.pyi:1086:7
+            --> stdlib/builtins.pyi:1098:7
              |
-        1084 |     def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
-        1085 |
-        1086 | class dict(MutableMapping[_KT, _VT]):
+        1096 |         def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        1097 |
+        1098 | 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()
+        1099 |     # __init__ should be kept roughly in line with `collections.UserDict.__init__`, which has similar semantics
+        1100 |     # Also multiprocessing.managers.SyncManager.dict()
              |
         info: Source
          --> /main.py:6:5
@@ -620,7 +620,7 @@ f(**kwargs<CURSOR>)
         6 | f(**kwargs)
           |     ^^^^^^
           |
-        "#);
+        "###);
     }
 
     #[test]
@@ -632,16 +632,16 @@ f(**kwargs<CURSOR>)
             "#,
         );
 
-        assert_snapshot!(test.goto_type_definition(), @r"
+        assert_snapshot!(test.goto_type_definition(), @r###"
         info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:438:7
+           --> stdlib/builtins.pyi:443:7
             |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
+        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        442 |
+        443 | class str(Sequence[str]):
             |       ^^^
-        439 |     @overload
-        440 |     def __new__(cls, object: object = ...) -> Self: ...
+        444 |     @overload
+        445 |     def __new__(cls, object: object = ...) -> Self: ...
             |
         info: Source
          --> /main.py:3:17
@@ -650,7 +650,7 @@ f(**kwargs<CURSOR>)
         3 |                 a
           |                 ^
           |
-        ");
+        "###);
     }
 
     #[test]
@@ -725,16 +725,16 @@ f(**kwargs<CURSOR>)
             "#,
         );
 
-        assert_snapshot!(test.goto_type_definition(), @r"
+        assert_snapshot!(test.goto_type_definition(), @r###"
         info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:438:7
+           --> stdlib/builtins.pyi:443:7
             |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
+        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        442 |
+        443 | class str(Sequence[str]):
             |       ^^^
-        439 |     @overload
-        440 |     def __new__(cls, object: object = ...) -> Self: ...
+        444 |     @overload
+        445 |     def __new__(cls, object: object = ...) -> Self: ...
             |
         info: Source
          --> /main.py:4:27
@@ -744,7 +744,7 @@ f(**kwargs<CURSOR>)
         4 |                     print(a)
           |                           ^
           |
-        ");
+        "###);
     }
 
     #[test]
@@ -758,13 +758,13 @@ f(**kwargs<CURSOR>)
 
         assert_snapshot!(test.goto_type_definition(), @r"
         info: lint:goto-type-definition: Type definition
-           --> stdlib/types.pyi:671:11
+           --> stdlib/types.pyi:677:11
             |
-        669 | if sys.version_info >= (3, 10):
-        670 |     @final
-        671 |     class NoneType:
+        675 | if sys.version_info >= (3, 10):
+        676 |     @final
+        677 |     class NoneType:
             |           ^^^^^^^^
-        672 |         def __bool__(self) -> Literal[False]: ...
+        678 |         def __bool__(self) -> Literal[False]: ...
             |
         info: Source
          --> /main.py:3:17
@@ -775,14 +775,14 @@ f(**kwargs<CURSOR>)
           |
 
         info: lint:goto-type-definition: Type definition
-           --> stdlib/builtins.pyi:438:7
+           --> stdlib/builtins.pyi:443:7
             |
-        436 |     def __getitem__(self, key: int, /) -> str | int | None: ...
-        437 |
-        438 | class str(Sequence[str]):
+        441 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        442 |
+        443 | class str(Sequence[str]):
             |       ^^^
-        439 |     @overload
-        440 |     def __new__(cls, object: object = ...) -> Self: ...
+        444 |     @overload
+        445 |     def __new__(cls, object: object = ...) -> Self: ...
             |
         info: Source
          --> /main.py:3:17

crates/red_knot_ide/src/hover.rs

@@ -214,11 +214,11 @@ mod tests {
         "#,
         );
 
-        assert_snapshot!(test.hover(), @r###"
-        def foo(a, b) -> Unknown
+        assert_snapshot!(test.hover(), @r"
+        Literal[foo]
         ---------------------------------------------
         ```text
-        def foo(a, b) -> Unknown
+        Literal[foo]
         ```
         ---------------------------------------------
         info: lint:hover: Hovered content is
@@ -231,7 +231,7 @@ mod tests {
           |             |
           |             source
           |
-        "###);
+        ");
     }
 
     #[test]
@@ -312,11 +312,11 @@ mod tests {
             "#,
         );
 
-        assert_snapshot!(test.hover(), @r###"
-        (def foo(a, b) -> Unknown) | (def bar(a, b) -> Unknown)
+        assert_snapshot!(test.hover(), @r"
+        Literal[foo, bar]
         ---------------------------------------------
         ```text
-        (def foo(a, b) -> Unknown) | (def bar(a, b) -> Unknown)
+        Literal[foo, bar]
         ```
         ---------------------------------------------
         info: lint:hover: Hovered content is
@@ -329,7 +329,7 @@ mod tests {
            |             |
            |             source
            |
-        "###);
+        ");
     }
 
     #[test]

crates/red_knot_ide/src/inlay_hints.rs

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

crates/red_knot_ide/src/lib.rs

@@ -2,13 +2,11 @@ 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;

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

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

@@ -1,22 +0,0 @@
-# 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/db.rs

@@ -149,10 +149,6 @@ 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]
@@ -211,7 +207,7 @@ pub(crate) mod tests {
     use salsa::Event;
 
     use red_knot_python_semantic::lint::{LintRegistry, RuleSelection};
-    use red_knot_python_semantic::{Db as SemanticDb, Program};
+    use red_knot_python_semantic::Db as SemanticDb;
     use ruff_db::files::Files;
     use ruff_db::system::{DbWithTestSystem, System, TestSystem};
     use ruff_db::vendored::VendoredFileSystem;
@@ -285,10 +281,6 @@ 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/lib.rs

@@ -10,8 +10,7 @@ use red_knot_python_semantic::lint::{LintRegistry, LintRegistryBuilder, RuleSele
 use red_knot_python_semantic::register_lints;
 use red_knot_python_semantic::types::check_types;
 use ruff_db::diagnostic::{
-    create_parse_diagnostic, create_unsupported_syntax_diagnostic, Annotation, Diagnostic,
-    DiagnosticId, Severity, Span,
+    create_parse_diagnostic, Annotation, Diagnostic, DiagnosticId, Severity, Span,
 };
 use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
@@ -425,13 +424,6 @@ fn check_file_impl(db: &dyn Db, file: File) -> Vec<Diagnostic> {
             .map(|error| create_parse_diagnostic(file, error)),
     );
 
-    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| {
@@ -528,13 +520,11 @@ mod tests {
     use crate::db::tests::TestDb;
     use crate::{check_file_impl, ProjectMetadata};
     use red_knot_python_semantic::types::check_types;
-    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<()> {
@@ -542,16 +532,6 @@ 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();
 

crates/red_knot_project/tests/check.rs

@@ -6,9 +6,7 @@ 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, Comprehension, Expr, Parameter, ParameterWithDefault, Stmt,
-};
+use ruff_python_ast::{self as ast, Alias, Expr, Parameter, ParameterWithDefault, Stmt};
 
 fn setup_db(project_root: &SystemPath, system: TestSystem) -> anyhow::Result<ProjectDatabase> {
     let project = ProjectMetadata::discover(project_root, &system)?;
@@ -260,14 +258,6 @@ 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/resources/mdtest/annotations/callable.md

@@ -2,7 +2,7 @@
 
 References:
 
-- <https://typing.python.org/en/latest/spec/callables.html#callable>
+- <https://typing.readthedocs.io/en/latest/spec/callables.html#callable>
 
 Note that `typing.Callable` is deprecated at runtime, in favour of `collections.abc.Callable` (see:
 <https://docs.python.org/3/library/typing.html#deprecated-aliases>). However, removal of
@@ -237,11 +237,6 @@ 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
@@ -294,7 +289,7 @@ def _(c: Callable[[int, Unpack[Ts]], int]):
 from typing import Callable
 
 def _(c: Callable[[int], int]):
-    reveal_type(c.__init__)  # revealed: def __init__(self) -> None
+    reveal_type(c.__init__)  # revealed: Literal[__init__]
     reveal_type(c.__class__)  # revealed: type
 
     # TODO: The member lookup for `Callable` uses `object` which does not have a `__call__`
@@ -304,4 +299,4 @@ def _(c: Callable[[int], int]):
     reveal_type(c.__call__)  # revealed: Unknown
 ```
 
-[gradual form]: https://typing.python.org/en/latest/spec/glossary.html#term-gradual-form
+[gradual form]: https://typing.readthedocs.io/en/latest/spec/glossary.html#term-gradual-form

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

@@ -48,11 +48,6 @@ 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
 
@@ -99,11 +94,6 @@ class Foo:
 
 ## Non-deferred self-reference annotations in a class definition
 
-```toml
-[environment]
-python-version = "3.12"
-```
-
 ```py
 class Foo:
     # error: [unresolved-reference]
@@ -156,24 +146,3 @@ def _():
         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.python.org/en/latest/spec/special-types.html#special-cases-for-float-and-complex)
+[the specification](https://typing.readthedocs.io/en/latest/spec/special-types.html#special-cases-for-float-and-complex)
 
 ## float
 

crates/red_knot_python_semantic/resources/mdtest/annotations/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(unknown type subscript)
+    reveal_type(r)  # revealed: @Todo(generics)
 ```
 
 ## Invalid Collection based AST nodes

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

@@ -1,6 +1,6 @@
 # Literal
 
-<https://typing.python.org/en/latest/spec/literal.html#literals>
+<https://typing.readthedocs.io/en/latest/spec/literal.html#literals>
 
 ## Parameterization
 
@@ -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, 5, "foo"] | None
+    reveal_type(a1)  # revealed: Literal[1, 2, 3, "foo", 5] | 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, 0, 1, "A", "B", "foo", "bar", b"A", b"\x00", b"\x07", True] | None
+    reveal_type(x)  # revealed: Unknown | Literal[-1, "A", b"A", b"\x00", b"\x07", 0, 1, "B", "foo", "bar", 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(unknown type subscript)
+    reveal_type(a1)  # revealed: @Todo(generics)
 ```
 
 ## Detecting typing_extensions.Literal

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

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

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

@@ -12,7 +12,7 @@ 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`"
+# error: [invalid-argument-type] "Object of type `NewType` cannot be assigned to parameter 2 (`origin`) of function `__new__`; expected type `type`"
 B = GenericAlias(A, ())
 
 def _(

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

@@ -1,10 +1,5 @@
 # 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,24 +67,21 @@ import typing
 
 ####################
 ### Built-ins
-####################
 
 class ListSubclass(typing.List): ...
 
-# 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]]
+# revealed: tuple[Literal[ListSubclass], Literal[list], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(protocol), Literal[object]]
 reveal_type(ListSubclass.__mro__)
 
 class DictSubclass(typing.Dict): ...
 
-# 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]]
+# TODO: should have `Generic`, should not have `Unknown`
+# revealed: tuple[Literal[DictSubclass], Literal[dict], Unknown, Literal[object]]
 reveal_type(DictSubclass.__mro__)
 
 class SetSubclass(typing.Set): ...
 
-# 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]]
+# revealed: tuple[Literal[SetSubclass], Literal[set], Literal[MutableSet], Literal[AbstractSet], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(protocol), Literal[object]]
 reveal_type(SetSubclass.__mro__)
 
 class FrozenSetSubclass(typing.FrozenSet): ...
@@ -95,12 +92,11 @@ reveal_type(FrozenSetSubclass.__mro__)
 
 ####################
 ### `collections`
-####################
 
 class ChainMapSubclass(typing.ChainMap): ...
 
-# 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]]
+# TODO: Should be (ChainMapSubclass, ChainMap, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
+# revealed: tuple[Literal[ChainMapSubclass], Literal[ChainMap], Unknown, Literal[object]]
 reveal_type(ChainMapSubclass.__mro__)
 
 class CounterSubclass(typing.Counter): ...
@@ -117,8 +113,7 @@ reveal_type(DefaultDictSubclass.__mro__)
 
 class DequeSubclass(typing.Deque): ...
 
-# 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]]
+# revealed: tuple[Literal[DequeSubclass], Literal[deque], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(protocol), 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", "de", "f", "g", "h", b"c"]
+    reveal_type(v)  # revealed: Literal["a", "b", b"c", "de", "f", "g", "h"]
 ```
 
 ## 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 in the same way as the `|` operator.
+`typing.Union` can be used to construct union types same as `|` operator.
 
 ```py
 from typing import Union
@@ -69,20 +69,3 @@ from typing import Union
 def f(x: Union) -> None:
     reveal_type(x)  # revealed: Unknown
 ```
-
-## Implicit type aliases using new-style unions
-
-We don't recognise these as type aliases yet, but we also don't emit false-positive diagnostics if
-you use them in type expressions:
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-X = int | str
-
-def f(y: X):
-    reveal_type(y)  # revealed: @Todo(Support for `types.UnionType` instances in type expressions)
-```

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

@@ -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, Generic
+from typing_extensions import Unpack, TypeGuard, TypeIs, Concatenate, ParamSpec
 
 def _(
     a: Unpack,  # error: [invalid-type-form] "`typing.Unpack` requires exactly one argument when used in a type expression"
@@ -49,7 +49,6 @@ 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
@@ -66,7 +65,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, Generic
+from typing_extensions import Self, Unpack, TypeGuard, TypeIs, Concatenate
 
 class A(Self): ...  # error: [invalid-base]
 class B(Unpack): ...  # error: [invalid-base]
@@ -74,18 +73,12 @@ 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,11 +25,6 @@ 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
@@ -61,7 +56,7 @@ reveal_type(d)  # revealed: tuple[tuple[str, str], tuple[int, int]]
 reveal_type(e)  # revealed: @Todo(full tuple[...] support)
 reveal_type(f)  # revealed: @Todo(full tuple[...] support)
 reveal_type(g)  # revealed: @Todo(full tuple[...] support)
-reveal_type(h)  # revealed: tuple[@Todo(specialized non-generic class), @Todo(specialized non-generic class)]
+reveal_type(h)  # revealed: tuple[@Todo(generics), @Todo(generics)]
 
 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,7 +41,8 @@ reveal_type(c_instance.declared_only)  # revealed: bytes
 
 reveal_type(c_instance.declared_and_bound)  # revealed: bool
 
-# error: [possibly-unbound-attribute]
+# We probably don't want to emit a diagnostic for this being possibly undeclared/unbound.
+# mypy and pyright do not show an error here.
 reveal_type(c_instance.possibly_undeclared_unbound)  # revealed: str
 
 # This assignment is fine, as we infer `Unknown | Literal[1, "a"]` for `inferred_from_value`.
@@ -302,7 +303,7 @@ class C:
 
 c_instance = C()
 reveal_type(c_instance.a)  # revealed: Unknown | Literal[1]
-reveal_type(c_instance.b)  # revealed: Unknown
+reveal_type(c_instance.b)  # revealed: Unknown | @Todo(starred unpacking)
 ```
 
 #### Attributes defined in for-loop (unpacking)
@@ -338,10 +339,8 @@ class C:
         for self.z in NonIterable():
             pass
 
-# Iterable might be empty
-# error: [possibly-unbound-attribute]
 reveal_type(C().x)  # revealed: Unknown | int
-# error: [possibly-unbound-attribute]
+
 reveal_type(C().y)  # revealed: Unknown | str
 ```
 
@@ -397,33 +396,21 @@ 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()
 
-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
+# TODO: Should be `Unknown | int`
+# error: [unresolved-attribute]
+reveal_type(c_instance.a)  # revealed: Unknown
 ```
 
 #### Conditionally declared / bound attributes
 
-Attributes are possibly unbound if they, or the method to which they are added are conditionally
-declared / bound.
+We currently do not raise a diagnostic or change behavior if an attribute is only conditionally
+defined. This is consistent with what mypy and pyright do.
 
 ```py
 def flag() -> bool:
@@ -441,13 +428,9 @@ class C:
 
 c_instance = C()
 
-# error: [possibly-unbound-attribute]
 reveal_type(c_instance.a1)  # revealed: str | None
-# error: [possibly-unbound-attribute]
 reveal_type(c_instance.a2)  # revealed: str | None
-# error: [possibly-unbound-attribute]
 reveal_type(c_instance.b1)  # revealed: Unknown | Literal[1]
-# error: [possibly-unbound-attribute]
 reveal_type(c_instance.b2)  # revealed: Unknown | Literal[1]
 ```
 
@@ -556,88 +539,10 @@ class C:
         if (2 + 3) < 4:
             self.x: str = "a"
 
-# error: [unresolved-attribute]
-reveal_type(C().x)  # revealed: Unknown
-```
-
-```py
-class C:
-    def __init__(self, cond: bool) -> None:
-        if True:
-            self.a = 1
-        else:
-            self.a = "a"
-
-        if False:
-            self.b = 2
-
-        if cond:
-            return
-
-        self.c = 3
-
-        self.d = 4
-        self.d = 5
-
-    def set_c(self, c: str) -> None:
-        self.c = c
-    if False:
-        def set_e(self, e: str) -> None:
-            self.e = e
-
-reveal_type(C(True).a)  # revealed: Unknown | Literal[1]
-# error: [unresolved-attribute]
-reveal_type(C(True).b)  # revealed: Unknown
-reveal_type(C(True).c)  # revealed: Unknown | Literal[3] | str
-# TODO: this attribute is possibly unbound
-reveal_type(C(True).d)  # revealed: Unknown | Literal[5]
-# error: [unresolved-attribute]
-reveal_type(C(True).e)  # revealed: Unknown
-```
-
-#### Attributes considered always bound
-
-```py
-class C:
-    def __init__(self, cond: bool):
-        self.x = 1
-        if cond:
-            raise ValueError("Something went wrong")
-
-        # We consider this attribute is always bound.
-        # This is because, it is not possible to access a partially-initialized object by normal means.
-        self.y = 2
-
-reveal_type(C(False).x)  # revealed: Unknown | Literal[1]
-reveal_type(C(False).y)  # revealed: Unknown | Literal[2]
-
-class C:
-    def __init__(self, b: bytes) -> None:
-        self.b = b
-
-        try:
-            s = b.decode()
-        except UnicodeDecodeError:
-            raise ValueError("Invalid UTF-8 sequence")
-
-        self.s = s
-
-reveal_type(C(b"abc").b)  # revealed: Unknown | bytes
-reveal_type(C(b"abc").s)  # revealed: Unknown | str
-
-class C:
-    def __init__(self, iter) -> None:
-        self.x = 1
-
-        for _ in iter:
-            pass
-
-        # The for-loop may not stop,
-        # but we consider the subsequent attributes to be definitely-bound.
-        self.y = 2
-
-reveal_type(C([]).x)  # revealed: Unknown | Literal[1]
-reveal_type(C([]).y)  # revealed: Unknown | Literal[2]
+# TODO: Ideally, this would result in a `unresolved-attribute` error. But mypy and pyright
+# do not support this either (for conditions that can only be resolved to `False` in type
+# inference), so it does not seem to be particularly important.
+reveal_type(C().x)  # revealed: str
 ```
 
 #### Diagnostics are reported for the right-hand side of attribute assignments
@@ -1141,18 +1046,13 @@ def _(flag: bool):
         def __init(self):
             if flag:
                 self.x = 1
-                self.y = "a"
-            else:
-                self.y = "b"
 
-    # error: [possibly-unbound-attribute]
+    # Emitting a diagnostic in a case like this is not something we support, and it's unclear
+    # if we ever will (or want to)
     reveal_type(Foo().x)  # revealed: Unknown | Literal[1]
 
-    # error: [possibly-unbound-attribute]
+    # Same here
     Foo().x = 2
-
-    reveal_type(Foo().y)  # revealed: Unknown | Literal["a", "b"]
-    Foo().y = "c"
 ```
 
 ### Unions with all paths unbound
@@ -1385,7 +1285,7 @@ from typing import Any
 class Foo(Any): ...
 
 reveal_type(Foo.bar)  # revealed: Any
-reveal_type(Foo.__repr__)  # revealed: (def __repr__(self) -> str) & Any
+reveal_type(Foo.__repr__)  # revealed: Literal[__repr__] & Any
 ```
 
 Similar principles apply if `Any` appears in the middle of an inheritance hierarchy:
@@ -1677,14 +1577,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(specialized non-generic class) | None
+reveal_type(f.__kwdefaults__)  # revealed: @Todo(generics) | None
 ```
 
 Some attributes are special-cased, however:
 
 ```py
 reveal_type(f.__get__)  # revealed: <method-wrapper `__get__` of `f`>
-reveal_type(f.__call__)  # revealed: <method-wrapper `__call__` of `f`>
+reveal_type(f.__call__)  # revealed: <bound method `__call__` of `Literal[f]`>
 ```
 
 ### Int-literal attributes
@@ -1693,7 +1593,7 @@ Most attribute accesses on int-literal types are delegated to `builtins.int`, si
 integers are instances of that class:
 
 ```py
-reveal_type((2).bit_length)  # revealed: bound method Literal[2].bit_length() -> int
+reveal_type((2).bit_length)  # revealed: <bound method `bit_length` of `Literal[2]`>
 reveal_type((2).denominator)  # revealed: Literal[1]
 ```
 
@@ -1710,10 +1610,8 @@ Most attribute accesses on bool-literal types are delegated to `builtins.bool`,
 bools are instances of that class:
 
 ```py
-# revealed: Overload[(value: bool, /) -> bool, (value: int, /) -> int]
-reveal_type(True.__and__)
-# revealed: Overload[(value: bool, /) -> bool, (value: int, /) -> int]
-reveal_type(False.__or__)
+reveal_type(True.__and__)  # revealed: <bound method `__and__` of `Literal[True]`>
+reveal_type(False.__or__)  # revealed: <bound method `__or__` of `Literal[False]`>
 ```
 
 Some attributes are special-cased, however:
@@ -1728,10 +1626,8 @@ reveal_type(False.real)  # revealed: Literal[0]
 All attribute access on literal `bytes` types is currently delegated to `builtins.bytes`:
 
 ```py
-# 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)
+reveal_type(b"foo".join)  # revealed: <bound method `join` of `Literal[b"foo"]`>
+reveal_type(b"foo".endswith)  # revealed: <bound method `endswith` of `Literal[b"foo"]`>
 ```
 
 ## Instance attribute edge cases
@@ -1832,89 +1728,6 @@ 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
@@ -1966,6 +1779,20 @@ reveal_type(Foo.BAR.value)  # revealed: @Todo(Attribute access on enum classes)
 reveal_type(Foo.__members__)  # revealed: @Todo(Attribute access on enum classes)
 ```
 
+## `super()`
+
+`super()` is not supported yet, but we do not emit false positives on `super()` calls.
+
+```py
+class Foo:
+    def bar(self) -> int:
+        return 42
+
+class Bar(Foo):
+    def bar(self) -> int:
+        return super().bar()
+```
+
 ## References
 
 Some of the tests in the *Class and instance variables* section draw inspiration from
@@ -1973,5 +1800,5 @@ Some of the tests in the *Class and instance variables* section draw inspiration
 
 [descriptor protocol tests]: descriptor_protocol.md
 [pyright's documentation]: https://microsoft.github.io/pyright/#/type-concepts-advanced?id=class-and-instance-variables
-[typing spec on `classvar`]: https://typing.python.org/en/latest/spec/class-compat.html#classvar
+[typing spec on `classvar`]: https://typing.readthedocs.io/en/latest/spec/class-compat.html#classvar
 [`typing.classvar`]: https://docs.python.org/3/library/typing.html#typing.ClassVar

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

@@ -350,30 +350,30 @@ reveal_type(no() + no())  # revealed: Unknown
 def f():
     pass
 
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f + f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `-` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `-` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f - f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `*` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `*` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f * f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `@` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `@` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f @ f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `/` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `/` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f / f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `%` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `%` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f % f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `**` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `**` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f**f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `<<` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `<<` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f << f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `>>` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `>>` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f >> f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `|` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `|` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f | f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `^` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `^` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f ^ f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `&` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `&` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f & f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `//` is unsupported between objects of type `def f() -> Unknown` and `def f() -> Unknown`"
+# error: [unsupported-operator] "Operator `//` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
 reveal_type(f // f)  # revealed: Unknown
 ```

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

@@ -310,7 +310,9 @@ reveal_type(A() + 1)  # revealed: A
 reveal_type(1 + A())  # revealed: A
 
 reveal_type(A() + "foo")  # revealed: A
-reveal_type("foo" + A())  # revealed: A
+# TODO should be `A` since `str.__add__` doesn't support `A` instances
+# TODO overloads
+reveal_type("foo" + A())  # revealed: @Todo(return type of overloaded function)
 
 reveal_type(A() + b"foo")  # revealed: A
 # TODO should be `A` since `bytes.__add__` doesn't support `A` instances
@@ -318,14 +320,16 @@ 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(full tuple[...] support)
+reveal_type(() + A())  # revealed: @Todo(return type of overloaded function)
 
 literal_string_instance = "foo" * 1_000_000_000
 # the test is not testing what it's meant to be testing if this isn't a `LiteralString`:
 reveal_type(literal_string_instance)  # revealed: LiteralString
 
 reveal_type(A() + literal_string_instance)  # revealed: A
-reveal_type(literal_string_instance + A())  # revealed: A
+# TODO should be `A` since `str.__add__` doesn't support `A` instances
+# TODO overloads
+reveal_type(literal_string_instance + A())  # revealed: @Todo(return type of overloaded function)
 ```
 
 ## Operations involving instances of classes inheriting from `Any`

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

@@ -50,11 +50,9 @@ reveal_type(1 ** (largest_u32 + 1))  # revealed: int
 reveal_type(2**largest_u32)  # revealed: int
 
 def variable(x: int):
-    reveal_type(x**2)  # revealed: 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
+    reveal_type(x**2)  # revealed: @Todo(return type of overloaded function)
+    reveal_type(2**x)  # revealed: @Todo(return type of overloaded function)
+    reveal_type(x**x)  # revealed: @Todo(return type of overloaded function)
 ```
 
 If the second argument is \<0, a `float` is returned at runtime. If the first argument is \<0 but

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: Never
+    flag or (x := 1) or reveal_type(x)  # revealed: Literal[1]
 
     # 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] "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]`"
+    # 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`"
     reveal_type(c("a", 1))  # revealed: int
 ```
 

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

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

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

@@ -98,7 +98,7 @@ def _(flag: bool) -> None:
             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"]`"
+    # error: [invalid-argument-type] "Object of type `Literal["1"]` cannot be assigned to parameter 2 (`x`) of function `__new__`; expected type `int`"
     reveal_type(Foo("1"))  # revealed: Foo
     # error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
     reveal_type(Foo())  # revealed: Foo
@@ -210,7 +210,7 @@ def _(flag: bool) -> None:
             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"]`"
+    # error: [invalid-argument-type] "Object of type `Literal["1"]` cannot be assigned to parameter 2 (`x`) of bound method `__init__`; expected type `int`"
     reveal_type(Foo("1"))  # revealed: Foo
     # error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
     reveal_type(Foo())  # revealed: Foo

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

@@ -21,11 +21,6 @@ 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
@@ -77,7 +72,7 @@ def _(flag: bool):
 def f(x: int) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
 reveal_type(f("foo"))  # revealed: int
 ```
 
@@ -87,7 +82,7 @@ reveal_type(f("foo"))  # revealed: int
 def f(x: int, /) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
 reveal_type(f("foo"))  # revealed: int
 ```
 
@@ -97,7 +92,7 @@ reveal_type(f("foo"))  # revealed: int
 def f(*args: int) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `*args` of function `f`; expected type `int`"
 reveal_type(f("foo"))  # revealed: int
 ```
 
@@ -107,7 +102,7 @@ reveal_type(f("foo"))  # revealed: int
 def f(x: int) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `x` of function `f`; expected type `int`"
 reveal_type(f(x="foo"))  # revealed: int
 ```
 
@@ -117,7 +112,7 @@ reveal_type(f(x="foo"))  # revealed: int
 def f(*, x: int) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `x` of function `f`; expected type `int`"
 reveal_type(f(x="foo"))  # revealed: int
 ```
 
@@ -127,7 +122,7 @@ reveal_type(f(x="foo"))  # revealed: int
 def f(**kwargs: int) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `**kwargs` of function `f`; expected type `int`"
 reveal_type(f(x="foo"))  # revealed: int
 ```
 
@@ -137,8 +132,8 @@ reveal_type(f(x="foo"))  # revealed: int
 def f(x: int = 1, y: str = "foo") -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[2]`"
-# error: 20 [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["bar"]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal[2]` cannot be assigned to parameter `y` of function `f`; expected type `str`"
+# error: 20 [invalid-argument-type] "Object of type `Literal["bar"]` cannot be assigned to parameter `x` of function `f`; expected type `int`"
 reveal_type(f(y=2, x="bar"))  # revealed: int
 ```
 

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

@@ -57,8 +57,7 @@ We can access attributes on objects of all kinds:
 import sys
 
 reveal_type(inspect.getattr_static(sys, "dont_write_bytecode"))  # revealed: bool
-# revealed: def getattr_static(obj: object, attr: str, default: Any | None = ellipsis) -> Any
-reveal_type(inspect.getattr_static(inspect, "getattr_static"))
+reveal_type(inspect.getattr_static(inspect, "getattr_static"))  # revealed: Literal[getattr_static]
 
 reveal_type(inspect.getattr_static(1, "real"))  # revealed: property
 ```
@@ -115,7 +114,7 @@ inspect.getattr_static()
 # error: [missing-argument] "No argument provided for required parameter `attr`"
 inspect.getattr_static(C())
 
-# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[1]`"
+# error: [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 2 (`attr`) of function `getattr_static`; expected type `str`"
 inspect.getattr_static(C(), 1)
 
 # error: [too-many-positional-arguments] "Too many positional arguments to function `getattr_static`: expected 3, got 4"
@@ -144,9 +143,8 @@ from typing import Any
 def _(a: Any, tuple_of_any: tuple[Any]):
     reveal_type(inspect.getattr_static(a, "x", "default"))  # revealed: Any | Literal["default"]
 
-    # TODO: Ideally, this would just be `def index(self, value: Any, start: SupportsIndex = Literal[0], stop: SupportsIndex = int, /) -> int`
-    # revealed: (def index(self, value: Any, start: SupportsIndex = Literal[0], stop: SupportsIndex = int, /) -> int) | Literal["default"]
-    reveal_type(inspect.getattr_static(tuple_of_any, "index", "default"))
+    # TODO: Ideally, this would just be `Literal[index]`
+    reveal_type(inspect.getattr_static(tuple_of_any, "index", "default"))  # revealed: Literal[index] | Literal["default"]
 ```
 
 [official documentation]: https://docs.python.org/3/library/inspect.html#inspect.getattr_static

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

@@ -24,7 +24,7 @@ to the valid order:
 def f(**kw: int, x: str) -> int:
     return 1
 
-# error: 15 [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[1]`"
+# error: 15 [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `str`"
 reveal_type(f(1))  # revealed: int
 ```
 
@@ -38,7 +38,7 @@ def f(x: int = 1, y: str) -> int:
     return 1
 
 reveal_type(f(y="foo"))  # revealed: int
-# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
 # error: [missing-argument] "No argument provided for required parameter `y` of function `f`"
 reveal_type(f("foo"))  # revealed: int
 ```

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

@@ -32,20 +32,20 @@ the latter case, it returns a *bound method* object:
 ```py
 from inspect import getattr_static
 
-reveal_type(getattr_static(C, "f"))  # revealed: def f(self, x: int) -> str
+reveal_type(getattr_static(C, "f"))  # revealed: Literal[f]
 
 reveal_type(getattr_static(C, "f").__get__)  # revealed: <method-wrapper `__get__` of `f`>
 
-reveal_type(getattr_static(C, "f").__get__(None, C))  # revealed: def f(self, x: int) -> str
-reveal_type(getattr_static(C, "f").__get__(C(), C))  # revealed: bound method C.f(x: int) -> str
+reveal_type(getattr_static(C, "f").__get__(None, C))  # revealed: Literal[f]
+reveal_type(getattr_static(C, "f").__get__(C(), C))  # revealed: <bound method `f` of `C`>
 ```
 
 In conclusion, this is why we see the following two types when accessing the `f` attribute on the
 class object `C` and on an instance `C()`:
 
 ```py
-reveal_type(C.f)  # revealed: def f(self, x: int) -> str
-reveal_type(C().f)  # revealed: bound method C.f(x: int) -> str
+reveal_type(C.f)  # revealed: Literal[f]
+reveal_type(C().f)  # revealed: <bound method `f` of `C`>
 ```
 
 A bound method is a callable object that contains a reference to the `instance` that it was called
@@ -56,7 +56,7 @@ via `__func__`):
 bound_method = C().f
 
 reveal_type(bound_method.__self__)  # revealed: C
-reveal_type(bound_method.__func__)  # revealed: def f(self, x: int) -> str
+reveal_type(bound_method.__func__)  # revealed: Literal[f]
 ```
 
 When we call the bound method, the `instance` is implicitly passed as the first argument (`self`):
@@ -80,13 +80,13 @@ When we access methods from derived classes, they will be bound to instances of
 class D(C):
     pass
 
-reveal_type(D().f)  # revealed: bound method D.f(x: int) -> str
+reveal_type(D().f)  # revealed: <bound method `f` of `D`>
 ```
 
 If we access an attribute on a bound method object itself, it will defer to `types.MethodType`:
 
 ```py
-reveal_type(bound_method.__hash__)  # revealed: bound method MethodType.__hash__() -> int
+reveal_type(bound_method.__hash__)  # revealed: <bound method `__hash__` of `MethodType`>
 ```
 
 If an attribute is not available on the bound method object, it will be looked up on the underlying
@@ -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(specialized non-generic class) | None
+reveal_type(bound_method.__kwdefaults__)  # revealed: @Todo(generics) | 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 A.f() -> int) | (bound method B.f() -> str)
+    reveal_type(a_or_b.f)  # revealed: <bound method `f` of `A`> | <bound method `f` of `B`>
     reveal_type(a_or_b.f())  # revealed: int | str
 
-    reveal_type(any_or_a.f)  # revealed: Any | (bound method A.f() -> int)
+    reveal_type(any_or_a.f)  # revealed: Any | <bound method `f` of `A`>
     reveal_type(any_or_a.f())  # revealed: Any | int
 ```
 
@@ -198,7 +198,7 @@ python-version = "3.12"
 ```py
 type IntOrStr = int | str
 
-reveal_type(IntOrStr.__or__)  # revealed: bound method typing.TypeAliasType.__or__(right: Any) -> _SpecialForm
+reveal_type(IntOrStr.__or__)  # revealed: <bound method `__or__` of `typing.TypeAliasType`>
 ```
 
 ## Error cases: Calling `__get__` for methods
@@ -270,7 +270,7 @@ class Meta(type):
 class C(metaclass=Meta):
     pass
 
-reveal_type(C.f)  # revealed: bound method Literal[C].f(arg: int) -> str
+reveal_type(C.f)  # revealed: <bound method `f` of `Literal[C]`>
 reveal_type(C.f(1))  # revealed: str
 ```
 
@@ -322,8 +322,8 @@ class C:
     def f(cls: type[C], x: int) -> str:
         return "a"
 
-reveal_type(C.f)  # revealed: bound method Literal[C].f(x: int) -> str
-reveal_type(C().f)  # revealed: bound method type[C].f(x: int) -> str
+reveal_type(C.f)  # revealed: <bound method `f` of `Literal[C]`>
+reveal_type(C().f)  # revealed: <bound method `f` of `type[C]`>
 ```
 
 The `cls` method argument is then implicitly passed as the first argument when calling the method:
@@ -350,7 +350,7 @@ class D:
         # This function is wrongly annotated, it should be `type[D]` instead of `D`
         pass
 
-# error: [invalid-argument-type] "Argument to this function is incorrect: Expected `D`, found `Literal[D]`"
+# error: [invalid-argument-type] "Object of type `Literal[D]` cannot be assigned to parameter 1 (`cls`) of bound method `f`; expected type `D`"
 D.f()
 ```
 
@@ -360,8 +360,8 @@ When a class method is accessed on a derived class, it is bound to that derived
 class Derived(C):
     pass
 
-reveal_type(Derived.f)  # revealed: bound method Literal[Derived].f(x: int) -> str
-reveal_type(Derived().f)  # revealed: bound method type[Derived].f(x: int) -> str
+reveal_type(Derived.f)  # revealed: <bound method `f` of `Literal[Derived]`>
+reveal_type(Derived().f)  # revealed: <bound method `f` of `type[Derived]`>
 
 reveal_type(Derived.f(1))  # revealed: str
 reveal_type(Derived().f(1))  # revealed: str
@@ -379,31 +379,26 @@ class C:
     @classmethod
     def f(cls): ...
 
-reveal_type(getattr_static(C, "f"))  # revealed: def f(cls) -> Unknown
+reveal_type(getattr_static(C, "f"))  # revealed: Literal[f]
 reveal_type(getattr_static(C, "f").__get__)  # revealed: <method-wrapper `__get__` of `f`>
 ```
 
 But we correctly model how the `classmethod` descriptor works:
 
 ```py
-reveal_type(getattr_static(C, "f").__get__(None, C))  # revealed: bound method Literal[C].f() -> Unknown
-reveal_type(getattr_static(C, "f").__get__(C(), C))  # revealed: bound method Literal[C].f() -> Unknown
-reveal_type(getattr_static(C, "f").__get__(C()))  # revealed: bound method type[C].f() -> Unknown
+reveal_type(getattr_static(C, "f").__get__(None, C))  # revealed: <bound method `f` of `Literal[C]`>
+reveal_type(getattr_static(C, "f").__get__(C(), C))  # revealed: <bound method `f` of `Literal[C]`>
+reveal_type(getattr_static(C, "f").__get__(C()))  # revealed: <bound method `f` of `type[C]`>
 ```
 
 The `owner` argument takes precedence over the `instance` argument:
 
 ```py
-reveal_type(getattr_static(C, "f").__get__("dummy", C))  # revealed: bound method Literal[C].f() -> Unknown
+reveal_type(getattr_static(C, "f").__get__("dummy", C))  # revealed: <bound method `f` of `Literal[C]`>
 ```
 
 ### Classmethods mixed with other decorators
 
-```toml
-[environment]
-python-version = "3.12"
-```
-
 When a `@classmethod` is additionally decorated with another decorator, it is still treated as a
 class method:
 
@@ -415,19 +410,29 @@ def does_nothing[T](f: T) -> T:
 
 class C:
     @classmethod
+    # TODO: no error should be emitted here (needs support for generics)
+    # error: [invalid-argument-type]
     @does_nothing
     def f1(cls: type[C], x: int) -> str:
         return "a"
-
+    # TODO: no error should be emitted here (needs support for generics)
+    # error: [invalid-argument-type]
     @does_nothing
     @classmethod
     def f2(cls: type[C], x: int) -> str:
         return "a"
 
-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
+# TODO: All of these should be `str` (and not emit an error), once we support generics
+
+# error: [call-non-callable]
+reveal_type(C.f1(1))  # revealed: Unknown
+# error: [call-non-callable]
+reveal_type(C().f1(1))  # revealed: Unknown
+
+# error: [call-non-callable]
+reveal_type(C.f2(1))  # revealed: Unknown
+# error: [call-non-callable]
+reveal_type(C().f2(1))  # revealed: Unknown
 ```
 
 [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

@@ -1,50 +0,0 @@
-# `str.startswith`
-
-We special-case `str.startswith` to allow inference of precise Boolean literal types, because those
-are used in [`sys.platform` checks].
-
-```py
-reveal_type("abc".startswith(""))  # revealed: Literal[True]
-reveal_type("abc".startswith("a"))  # revealed: Literal[True]
-reveal_type("abc".startswith("ab"))  # revealed: Literal[True]
-reveal_type("abc".startswith("abc"))  # revealed: Literal[True]
-
-reveal_type("abc".startswith("abcd"))  # revealed: Literal[False]
-reveal_type("abc".startswith("bc"))  # revealed: Literal[False]
-
-reveal_type("AbC".startswith(""))  # revealed: Literal[True]
-reveal_type("AbC".startswith("A"))  # revealed: Literal[True]
-reveal_type("AbC".startswith("Ab"))  # revealed: Literal[True]
-reveal_type("AbC".startswith("AbC"))  # revealed: Literal[True]
-
-reveal_type("AbC".startswith("a"))  # revealed: Literal[False]
-reveal_type("AbC".startswith("aB"))  # revealed: Literal[False]
-
-reveal_type("".startswith(""))  # revealed: Literal[True]
-
-reveal_type("".startswith(" "))  # revealed: Literal[False]
-```
-
-Make sure that we fall back to `bool` for more complex cases:
-
-```py
-reveal_type("abc".startswith("b", 1))  # revealed: bool
-reveal_type("abc".startswith("bc", 1, 3))  # revealed: bool
-
-reveal_type("abc".startswith(("a", "x")))  # revealed: bool
-```
-
-And similiarly, we should still infer `bool` if the instance or the prefix are not string literals:
-
-```py
-from typing_extensions import LiteralString
-
-def _(string_instance: str, literalstring: LiteralString):
-    reveal_type(string_instance.startswith("a"))  # revealed: bool
-    reveal_type(literalstring.startswith("a"))  # revealed: bool
-
-    reveal_type("a".startswith(string_instance))  # revealed: bool
-    reveal_type("a".startswith(literalstring))  # revealed: bool
-```
-
-[`sys.platform` checks]: https://docs.python.org/3/library/sys.html#sys.platform

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

@@ -20,7 +20,7 @@ class C:
 def _(subclass_of_c: type[C]):
     reveal_type(subclass_of_c(1))  # revealed: C
 
-    # error: [invalid-argument-type] "Argument to this function is incorrect: Expected `int`, found `Literal["a"]`"
+    # error: [invalid-argument-type] "Object of type `Literal["a"]` cannot be assigned to parameter 2 (`x`) of bound method `__init__`; expected type `int`"
     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

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

@@ -94,7 +94,7 @@ def _(flag: bool):
     else:
         f = f2
 
-    # error: [invalid-argument-type] "Argument to this function is incorrect: Expected `str`, found `Literal[3]`"
+    # error: [invalid-argument-type] "Object of type `Literal[3]` cannot be assigned to parameter 1 (`a`) of function `f2`; expected type `str`"
     x = f(3)
     reveal_type(x)  # revealed: int | str
 ```
@@ -175,41 +175,3 @@ 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

@@ -1,410 +0,0 @@
-# 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,17 +50,13 @@ reveal_type(x)  # revealed: LiteralString
 if x != "abc":
     reveal_type(x)  # revealed: LiteralString & ~Literal["abc"]
 
-    # 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 == "abc")  # revealed: Literal[False]
+    reveal_type("abc" == x)  # revealed: Literal[False]
     reveal_type(x == "something else")  # revealed: bool
     reveal_type("something else" == x)  # revealed: bool
 
-    # 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 != "abc")  # revealed: Literal[True]
+    reveal_type("abc" != x)  # revealed: Literal[True]
     reveal_type(x != "something else")  # revealed: bool
     reveal_type("something else" != x)  # revealed: bool
 
@@ -83,10 +79,10 @@ def _(x: int):
     if x != 1:
         reveal_type(x)  # revealed: int & ~Literal[1]
 
-        reveal_type(x != 1)  # revealed: bool
+        reveal_type(x != 1)  # revealed: Literal[True]
         reveal_type(x != 2)  # revealed: bool
 
-        reveal_type(x == 1)  # revealed: bool
+        reveal_type(x == 1)  # revealed: Literal[False]
         reveal_type(x == 2)  # revealed: bool
 ```
 

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

@@ -1,10 +1,5 @@
 # Pattern matching
 
-```toml
-[environment]
-python-version = "3.10"
-```
-
 ## With wildcard
 
 ```py

crates/red_knot_python_semantic/resources/mdtest/dataclasses.md

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

@@ -145,10 +145,10 @@ def f(x: int) -> int:
     return x**2
 
 # TODO: Should be `_lru_cache_wrapper[int]`
-reveal_type(f)  # revealed: @Todo(specialized non-generic class)
+reveal_type(f)  # revealed: @Todo(generics)
 
 # TODO: Should be `int`
-reveal_type(f(1))  # revealed: @Todo(specialized non-generic class)
+reveal_type(f(1))  # revealed: @Todo(generics)
 ```
 
 ## Lambdas as decorators
@@ -207,7 +207,7 @@ first argument:
 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`"
+# error: [invalid-argument-type] "Object of type `Literal[f]` cannot be assigned to parameter 1 (`f`) of function `wrong_signature`; expected type `int`"
 @wrong_signature
 def f(x): ...
 

crates/red_knot_python_semantic/resources/mdtest/descriptor_protocol.md

@@ -459,9 +459,11 @@ class Descriptor:
 class C:
     d: Descriptor = Descriptor()
 
-reveal_type(C.d)  # revealed: Literal["called on class object"]
+# TODO: should be `Literal["called on class object"]
+reveal_type(C.d)  # revealed: LiteralString
 
-reveal_type(C().d)  # revealed: Literal["called on instance"]
+# TODO: should be `Literal["called on instance"]
+reveal_type(C().d)  # revealed: LiteralString
 ```
 
 ## Descriptor protocol for dunder methods
@@ -561,18 +563,18 @@ from inspect import getattr_static
 def f(x: object) -> str:
     return "a"
 
-reveal_type(f)  # revealed: def f(x: object) -> str
+reveal_type(f)  # revealed: Literal[f]
 reveal_type(f.__get__)  # revealed: <method-wrapper `__get__` of `f`>
-reveal_type(f.__get__(None, type(f)))  # revealed: def f(x: object) -> str
+reveal_type(f.__get__(None, type(f)))  # revealed: Literal[f]
 reveal_type(f.__get__(None, type(f))(1))  # revealed: str
 
 wrapper_descriptor = getattr_static(f, "__get__")
 
 reveal_type(wrapper_descriptor)  # revealed: <wrapper-descriptor `__get__` of `function` objects>
-reveal_type(wrapper_descriptor(f, None, type(f)))  # revealed: def f(x: object) -> str
+reveal_type(wrapper_descriptor(f, None, type(f)))  # revealed: Literal[f]
 
 # Attribute access on the method-wrapper `f.__get__` falls back to `MethodWrapperType`:
-reveal_type(f.__get__.__hash__)  # revealed: bound method MethodWrapperType.__hash__() -> int
+reveal_type(f.__get__.__hash__)  # revealed: <bound method `__hash__` of `MethodWrapperType`>
 
 # Attribute access on the wrapper-descriptor falls back to `WrapperDescriptorType`:
 reveal_type(wrapper_descriptor.__qualname__)  # revealed: str
@@ -585,7 +587,7 @@ class C: ...
 
 bound_method = wrapper_descriptor(f, C(), C)
 
-reveal_type(bound_method)  # revealed: bound method C.f() -> str
+reveal_type(bound_method)  # revealed: <bound method `f` of `C`>
 ```
 
 We can then call it, and the instance of `C` is implicitly passed to the first parameter of `f`

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

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

@@ -26,11 +26,6 @@ def _(never: Never, any_: Any, unknown: Unknown, flag: bool):
 
 ## 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.
 

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

@@ -61,7 +61,7 @@ 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)
+    reveal_type(a)  # revealed: @Todo(generics)
 
     b = cast(Any, y)
     reveal_type(b)  # revealed: Any

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

crates/red_knot_python_semantic/resources/mdtest/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: def foo(param=A) -> Unknown
+    reveal_type(x)  # revealed: Literal[foo]
 except:
-    reveal_type(x)  # revealed: Literal[1] | (def foo(param=A) -> Unknown)
+    reveal_type(x)  # revealed: Literal[1] | Literal[foo]
 
     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: (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]
+reveal_type(x)  # revealed: Literal[foo] | Literal[Bar]
 ```
 
 [1]: https://astral-sh.notion.site/Exception-handler-control-flow-11348797e1ca80bb8ce1e9aedbbe439d

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

@@ -76,11 +76,6 @@ def g(x: Any = "foo"):
 
 ## Stub functions
 
-```toml
-[environment]
-python-version = "3.12"
-```
-
 ### In Protocol
 
 ```py

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

@@ -56,11 +56,6 @@ def f() -> int:
 
 ### In Protocol
 
-```toml
-[environment]
-python-version = "3.12"
-```
-
 ```py
 from typing import Protocol, TypeVar
 
@@ -74,6 +69,8 @@ class Baz(Bar):
 T = TypeVar("T")
 
 class Qux(Protocol[T]):
+    # TODO: no error
+    # error: [invalid-return-type]
     def f(self) -> int: ...
 
 class Foo(Protocol):
@@ -88,11 +85,6 @@ class Lorem(t[0]):
 
 ### In abstract method
 
-```toml
-[environment]
-python-version = "3.12"
-```
-
 ```py
 from abc import ABC, abstractmethod
 
@@ -318,7 +310,7 @@ 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"]`"
+    # error: [invalid-return-type] "Object of type `Literal["hello"]` is not assignable to return type `int`"
     return "hello" if cond else NotImplemented
 ```
 

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

@@ -1,10 +1,5 @@
 # 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.
@@ -18,6 +13,8 @@ class C[T]: ...
 A class that inherits from a generic class, and fills its type parameters with typevars, is generic:
 
 ```py
+# TODO: no error
+# error: [non-subscriptable]
 class D[U](C[U]): ...
 ```
 
@@ -25,6 +22,8 @@ A class that inherits from a generic class, but fills its type parameters with c
 _not_ generic:
 
 ```py
+# TODO: no error
+# error: [non-subscriptable]
 class E(C[int]): ...
 ```
 
@@ -45,6 +44,8 @@ from typing import Generic, TypeVar
 
 T = TypeVar("T")
 
+# TODO: no error
+# error: [invalid-base]
 class C(Generic[T]): ...
 ```
 
@@ -56,7 +57,7 @@ class D(C[T]): ...
 
 (Examples `E` and `F` from above do not have analogues in the legacy syntax.)
 
-## Specializing generic classes explicitly
+## Inferring generic class parameters
 
 The type parameter can be specified explicitly:
 
@@ -64,77 +65,25 @@ The type parameter can be specified explicitly:
 class C[T]:
     x: T
 
-reveal_type(C[int]())  # revealed: C[int]
+# TODO: no error
+# TODO: revealed: C[int]
+# error: [non-subscriptable]
+reveal_type(C[int]())  # revealed: C
 ```
 
-The specialization must match the generic types:
-
-```py
-# error: [too-many-positional-arguments] "Too many positional arguments to class `C`: expected 1, got 2"
-reveal_type(C[int, int]())  # revealed: Unknown
-```
-
-If the type variable has an upper bound, the specialized type must satisfy that bound:
-
-```py
-class Bounded[T: int]: ...
-class BoundedByUnion[T: int | str]: ...
-class IntSubclass(int): ...
-
-reveal_type(Bounded[int]())  # revealed: Bounded[int]
-reveal_type(Bounded[IntSubclass]())  # revealed: Bounded[IntSubclass]
-
-# error: [invalid-argument-type] "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[Unknown]
+reveal_type(c)  # revealed: C
 ```
 
 The typevars of a fully specialized generic class should no longer be visible:
 
 ```py
 # TODO: revealed: int
-reveal_type(c.x)  # revealed: Unknown
+reveal_type(c.x)  # revealed: T
 ```
 
 If the type parameter is not specified explicitly, and there are no constraints that let us infer a
@@ -143,111 +92,37 @@ specific type, we infer the typevar's default type:
 ```py
 class D[T = int]: ...
 
-reveal_type(D())  # revealed: D[int]
+# TODO: revealed: D[int]
+reveal_type(D())  # revealed: D
 ```
 
 If a typevar does not provide a default, we use `Unknown`:
 
 ```py
-reveal_type(C())  # revealed: C[Unknown]
+# TODO: revealed: C[Unknown]
+reveal_type(C())  # revealed: C
 ```
 
-## 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. The types inferred from a type context and from a constructor parameter must be
-consistent with each other.
-
-## `__new__` only
+parameter:
 
 ```py
-class C[T]:
-    def __new__(cls, x: T) -> "C[T]":
-        return object.__new__(cls)
-
-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")
-```
-
-## `__init__` only
-
-```py
-class C[T]:
+class E[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")
+# TODO: revealed: E[int] or E[Literal[1]]
+# TODO should not emit an error
+# error: [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 2 (`x`) of bound method `__init__`; expected type `T`"
+reveal_type(E(1))  # revealed: E
 ```
 
-## Identical `__new__` and `__init__` signatures
+The types inferred from a type context and from a constructor parameter must be consistent with each
+other:
 
 ```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)
+# TODO: the error should not leak the `T` typevar and should mention `E[int]`
+# error: [invalid-argument-type] "Object of type `Literal["five"]` cannot be assigned to parameter 2 (`x`) of bound method `__init__`; expected type `T`"
+wrong_innards: E[int] = E("five")
 ```
 
 ## Generic subclass
@@ -259,30 +134,17 @@ propagate through:
 class Base[T]:
     x: T | None = None
 
+# TODO: no error
+# error: [non-subscriptable]
 class Sub[U](Base[U]): ...
 
-reveal_type(Base[int].x)  # revealed: int | None
-reveal_type(Sub[int].x)  # revealed: int | None
-```
-
-## Generic methods
-
-Generic classes can contain methods that are themselves generic. The generic methods can refer to
-the typevars of the enclosing generic class, and introduce new (distinct) typevars that are only in
-scope for the method.
-
-```py
-class C[T]:
-    def method[U](self, u: U) -> U:
-        return u
-    # error: [unresolved-reference]
-    def cannot_use_outside_of_method(self, u: U): ...
-
-    # TODO: error
-    def cannot_shadow_class_typevar[T](self, t: T): ...
-
-c: C[int] = C[int]()
-reveal_type(c.method("string"))  # revealed: Literal["string"]
+# 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
 ```
 
 ## Cyclic class definition
@@ -296,6 +158,8 @@ Here, `Sub` is not a generic class, since it fills its superclass's type paramet
 
 ```pyi
 class Base[T]: ...
+# TODO: no error
+# error: [non-subscriptable]
 class Sub(Base[Sub]): ...
 
 reveal_type(Sub)  # revealed: Literal[Sub]
@@ -307,6 +171,9 @@ A similar case can work in a non-stub file, if forward references are stringifie
 
 ```py
 class Base[T]: ...
+
+# TODO: no error
+# error: [non-subscriptable]
 class Sub(Base["Sub"]): ...
 
 reveal_type(Sub)  # revealed: Literal[Sub]
@@ -319,6 +186,8 @@ In a non-stub file, without stringified forward references, this raises a `NameE
 ```py
 class Base[T]: ...
 
+# TODO: the unresolved-reference error is correct, the non-subscriptable is not
+# error: [non-subscriptable]
 # error: [unresolved-reference]
 class Sub(Base[Sub]): ...
 ```

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

@@ -1,10 +1,5 @@
 # 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
@@ -48,14 +43,33 @@ 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
 
-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"]
+# 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
 ```
 
 ## Inferring “deep” generic parameter types
@@ -68,7 +82,7 @@ def f[T](x: list[T]) -> T:
     return x[0]
 
 # TODO: revealed: float
-reveal_type(f([1.0, 2.0]))  # revealed: Unknown
+reveal_type(f([1.0, 2.0]))  # revealed: T
 ```
 
 ## Typevar constraints
@@ -79,6 +93,7 @@ in the function.
 
 ```py
 def good_param[T: int](x: T) -> None:
+    # TODO: revealed: T & int
     reveal_type(x)  # revealed: T
 ```
 
@@ -92,7 +107,7 @@ def good_return[T: int](x: T) -> T:
     return x
 
 def bad_return[T: int](x: T) -> T:
-    # error: [invalid-return-type] "Return type does not match returned value: Expected `T`, found `int`"
+    # error: [invalid-return-type] "Object of type `int` is not assignable to return type `T`"
     return x + 1
 ```
 
@@ -105,7 +120,7 @@ def different_types[T, S](cond: bool, t: T, s: S) -> T:
     if cond:
         return t
     else:
-        # error: [invalid-return-type] "Return type does not match returned value: Expected `T`, found `S`"
+        # error: [invalid-return-type] "Object of type `S` is not assignable to return type `T`"
         return s
 
 def same_types[T](cond: bool, t1: T, t2: T) -> T:
@@ -147,41 +162,61 @@ parameters simultaneously.
 def two_params[T](x: T, y: T) -> T:
     return x
 
-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
+# error: [invalid-argument-type]
+# error: [invalid-argument-type]
+reveal_type(two_params("a", "b"))  # 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
+# TODO: no error
+# TODO: revealed: str | int
+# error: [invalid-argument-type]
+# error: [invalid-argument-type]
+reveal_type(two_params("a", 1))  # revealed: T
 ```
 
 ```py
-def union_and_nonunion_params[T](x: T | int, y: T) -> T:
+def param_with_union[T](x: T | int, y: T) -> T:
     return y
 
-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]
+# 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
 ```
 
 ```py
 def tuple_param[T, S](x: T | S, y: tuple[T, S]) -> tuple[T, S]:
     return y
 
-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]]
+# 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]
 ```
 
 ## Inferring nested generic function calls
@@ -196,6 +231,15 @@ def f[T](x: T) -> tuple[T, int]:
 def g[T](x: T) -> T | None:
     return x
 
-reveal_type(f(g("a")))  # revealed: tuple[Literal["a"] | None, int]
-reveal_type(g(f("a")))  # revealed: tuple[Literal["a"], int] | None
+# 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
 ```

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

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

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

@@ -1,10 +1,5 @@
 # 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
@@ -64,19 +59,19 @@ is.)
 from knot_extensions import is_fully_static, static_assert
 from typing import Any
 
-def unbounded_unconstrained[T](t: T) -> None:
+def unbounded_unconstrained[T](t: list[T]) -> None:
     static_assert(is_fully_static(T))
 
-def bounded[T: int](t: T) -> None:
+def bounded[T: int](t: list[T]) -> None:
     static_assert(is_fully_static(T))
 
-def bounded_by_gradual[T: Any](t: T) -> None:
+def bounded_by_gradual[T: Any](t: list[T]) -> None:
     static_assert(not is_fully_static(T))
 
-def constrained[T: (int, str)](t: T) -> None:
+def constrained[T: (int, str)](t: list[T]) -> None:
     static_assert(is_fully_static(T))
 
-def constrained_by_gradual[T: (int, Any)](t: T) -> None:
+def constrained_by_gradual[T: (int, Any)](t: list[T]) -> None:
     static_assert(not is_fully_static(T))
 ```
 
@@ -99,7 +94,7 @@ class Base(Super): ...
 class Sub(Base): ...
 class Unrelated: ...
 
-def unbounded_unconstrained[T, U](t: T, u: U) -> None:
+def unbounded_unconstrained[T, U](t: list[T], u: list[U]) -> None:
     static_assert(is_assignable_to(T, T))
     static_assert(is_assignable_to(T, object))
     static_assert(not is_assignable_to(T, Super))
@@ -129,7 +124,7 @@ is a final class, since the typevar can still be specialized to `Never`.)
 from typing import Any
 from typing_extensions import final
 
-def bounded[T: Super](t: T) -> None:
+def bounded[T: Super](t: list[T]) -> None:
     static_assert(is_assignable_to(T, Super))
     static_assert(not is_assignable_to(T, Sub))
     static_assert(not is_assignable_to(Super, T))
@@ -140,7 +135,7 @@ def bounded[T: Super](t: T) -> None:
     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:
+def bounded_by_gradual[T: Any](t: list[T]) -> None:
     static_assert(is_assignable_to(T, Any))
     static_assert(is_assignable_to(Any, T))
     static_assert(is_assignable_to(T, Super))
@@ -158,7 +153,7 @@ def bounded_by_gradual[T: Any](t: T) -> None:
 @final
 class FinalClass: ...
 
-def bounded_final[T: FinalClass](t: T) -> None:
+def bounded_final[T: FinalClass](t: list[T]) -> None:
     static_assert(is_assignable_to(T, FinalClass))
     static_assert(not is_assignable_to(FinalClass, T))
 
@@ -172,14 +167,14 @@ true even if both typevars are bounded by the same final class, since you can sp
 typevars to `Never` in addition to that final class.
 
 ```py
-def two_bounded[T: Super, U: Super](t: T, u: U) -> None:
+def two_bounded[T: Super, U: Super](t: list[T], u: list[U]) -> None:
     static_assert(not is_assignable_to(T, U))
     static_assert(not is_assignable_to(U, T))
 
     static_assert(not is_subtype_of(T, U))
     static_assert(not is_subtype_of(U, T))
 
-def two_final_bounded[T: FinalClass, U: FinalClass](t: T, u: U) -> None:
+def two_final_bounded[T: FinalClass, U: FinalClass](t: list[T], u: list[U]) -> None:
     static_assert(not is_assignable_to(T, U))
     static_assert(not is_assignable_to(U, T))
 
@@ -194,7 +189,7 @@ 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:
+def constrained[T: (Base, Unrelated)](t: list[T]) -> None:
     static_assert(not is_assignable_to(T, Super))
     static_assert(not is_assignable_to(T, Base))
     static_assert(not is_assignable_to(T, Sub))
@@ -219,7 +214,7 @@ def constrained[T: (Base, Unrelated)](t: T) -> None:
     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:
+def constrained_by_gradual[T: (Base, Any)](t: list[T]) -> None:
     static_assert(is_assignable_to(T, Super))
     static_assert(is_assignable_to(T, Base))
     static_assert(not is_assignable_to(T, Sub))
@@ -261,7 +256,7 @@ distinct constraints, meaning that there is (still) no guarantee that they will
 the same type.
 
 ```py
-def two_constrained[T: (int, str), U: (int, str)](t: T, u: U) -> None:
+def two_constrained[T: (int, str), U: (int, str)](t: list[T], u: list[U]) -> None:
     static_assert(not is_assignable_to(T, U))
     static_assert(not is_assignable_to(U, T))
 
@@ -271,7 +266,7 @@ def two_constrained[T: (int, str), U: (int, str)](t: T, u: U) -> None:
 @final
 class AnotherFinalClass: ...
 
-def two_final_constrained[T: (FinalClass, AnotherFinalClass), U: (FinalClass, AnotherFinalClass)](t: T, u: U) -> None:
+def two_final_constrained[T: (FinalClass, AnotherFinalClass), U: (FinalClass, AnotherFinalClass)](t: list[T], u: list[U]) -> None:
     static_assert(not is_assignable_to(T, U))
     static_assert(not is_assignable_to(U, T))
 
@@ -290,7 +285,7 @@ non-singleton type.
 ```py
 from knot_extensions import is_singleton, is_single_valued, static_assert
 
-def unbounded_unconstrained[T](t: T) -> None:
+def unbounded_unconstrained[T](t: list[T]) -> None:
     static_assert(not is_singleton(T))
     static_assert(not is_single_valued(T))
 ```
@@ -299,7 +294,7 @@ A bounded typevar is not a singleton, even if its bound is a singleton, since it
 specialized to `Never`.
 
 ```py
-def bounded[T: None](t: T) -> None:
+def bounded[T: None](t: list[T]) -> None:
     static_assert(not is_singleton(T))
     static_assert(not is_single_valued(T))
 ```
@@ -310,14 +305,14 @@ 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:
+def constrained_non_singletons[T: (int, str)](t: list[T]) -> None:
     static_assert(not is_singleton(T))
     static_assert(not is_single_valued(T))
 
-def constrained_singletons[T: (Literal[True], Literal[False])](t: T) -> None:
+def constrained_singletons[T: (Literal[True], Literal[False])](t: list[T]) -> None:
     static_assert(is_singleton(T))
 
-def constrained_single_valued[T: (Literal[True], tuple[()])](t: T) -> None:
+def constrained_single_valued[T: (Literal[True], tuple[()])](t: list[T]) -> None:
     static_assert(is_single_valued(T))
 ```
 
@@ -512,20 +507,6 @@ def remove_constraint[T: (int, str, bool)](t: T) -> 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:

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

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

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

@@ -1,277 +0,0 @@
-# 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: def chr(i: int | SupportsIndex, /) -> str
+reveal_type(builtins.chr)  # revealed: Literal[chr]
 ```
 
 ## Implicit use of builtin
@@ -15,7 +15,7 @@ reveal_type(builtins.chr)  # revealed: def chr(i: int | SupportsIndex, /) -> str
 Or used implicitly:
 
 ```py
-reveal_type(chr)  # revealed: def chr(i: int | SupportsIndex, /) -> str
+reveal_type(chr)  # revealed: Literal[chr]
 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 between `b.f` and `c.f`.
-reveal_type(f)  # revealed: (def f() -> Unknown) | (def f() -> Unknown)
+# TODO: We should disambiguate in such cases, showing `Literal[b.f, c.f]`.
+reveal_type(f)  # revealed: Literal[f, f]
 ```
 
 ## 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.python.org/en/latest/spec/distributing.html#import-conventions>
+- <https://typing.readthedocs.io/en/latest/spec/distributing.html#import-conventions>
 
 ## Builtins scope
 

crates/red_knot_python_semantic/resources/mdtest/intersection_types.md

@@ -842,7 +842,7 @@ def unknown(
 
 ### Mixed dynamic types
 
-Gradually-equivalent types can be simplified out of intersections:
+We currently do not simplify mixed dynamic types, but might consider doing so in the future:
 
 ```py
 from typing import Any
@@ -854,10 +854,10 @@ def mixed(
     i3: Intersection[Not[Any], Unknown],
     i4: Intersection[Not[Any], Not[Unknown]],
 ) -> None:
-    reveal_type(i1)  # revealed: Any
-    reveal_type(i2)  # revealed: Any
-    reveal_type(i3)  # revealed: Any
-    reveal_type(i4)  # revealed: Any
+    reveal_type(i1)  # revealed: Any & Unknown
+    reveal_type(i2)  # revealed: Any & Unknown
+    reveal_type(i3)  # revealed: Any & Unknown
+    reveal_type(i4)  # revealed: Any & Unknown
 ```
 
 ## Invalid

crates/red_knot_python_semantic/resources/mdtest/loops/for.md

@@ -321,7 +321,7 @@ def _(flag: bool):
         # TODO... `int` might be ideal here?
         reveal_type(x)  # revealed: int | Unknown
 
-    # error: [not-iterable] "Object of type `Iterable2` may not be iterable because its `__iter__` attribute (with type `(bound method Iterable2.__iter__() -> Iterator) | None`) may not be callable"
+    # error: [not-iterable] "Object of type `Iterable2` may not be iterable because its `__iter__` attribute (with type `<bound method `__iter__` of `Iterable2`> | None`) may not be callable"
     for y in Iterable2():
         # TODO... `int` might be ideal here?
         reveal_type(y)  # revealed: int | Unknown

crates/red_knot_python_semantic/resources/mdtest/metaclass.md

@@ -216,11 +216,6 @@ reveal_type(A.__class__)  # revealed: type[Unknown]
 
 ## PEP 695 generic
 
-```toml
-[environment]
-python-version = "3.12"
-```
-
 ```py
 class M(type): ...
 class A[T: str](metaclass=M): ...

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

@@ -1,53 +0,0 @@
-# Narrowing with assert statements
-
-## `assert` a value `is None` or `is not None`
-
-```py
-def _(x: str | None, y: str | None):
-    assert x is not None
-    reveal_type(x)  # revealed: str
-    assert y is None
-    reveal_type(y)  # revealed: None
-```
-
-## `assert` a value is truthy or falsy
-
-```py
-def _(x: bool, y: bool):
-    assert x
-    reveal_type(x)  # revealed: Literal[True]
-    assert not y
-    reveal_type(y)  # revealed: Literal[False]
-```
-
-## `assert` with `is` and `==` for literals
-
-```py
-from typing import Literal
-
-def _(x: Literal[1, 2, 3], y: Literal[1, 2, 3]):
-    assert x is 2
-    reveal_type(x)  # revealed: Literal[2]
-    assert y == 2
-    reveal_type(y)  # revealed: Literal[1, 2, 3]
-```
-
-## `assert` with `isinstance`
-
-```py
-def _(x: int | str):
-    assert isinstance(x, int)
-    reveal_type(x)  # revealed: int
-```
-
-## `assert` a value `in` a tuple
-
-```py
-from typing import Literal
-
-def _(x: Literal[1, 2, 3], y: Literal[1, 2, 3]):
-    assert x in (1, 2)
-    reveal_type(x)  # revealed: Literal[1, 2]
-    assert y not in (1, 2)
-    reveal_type(y)  # revealed: Literal[3]
-```

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

@@ -223,15 +223,3 @@ def _(x: str | None, y: str | None):
     if y is not x:
         reveal_type(y)  # revealed: str | None
 ```
-
-## Assignment expressions
-
-```py
-def f() -> bool:
-    return True
-
-if x := f():
-    reveal_type(x)  # revealed: Literal[True]
-else:
-    reveal_type(x)  # revealed: Literal[False]
-```

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

@@ -47,16 +47,3 @@ def _(flag1: bool, flag2: bool):
         # TODO should be Never
         reveal_type(x)  # revealed: Literal[1, 2]
 ```
-
-## Assignment expressions
-
-```py
-def f() -> int | str | None: ...
-
-if isinstance(x := f(), int):
-    reveal_type(x)  # revealed: int
-elif isinstance(x, str):
-    reveal_type(x)  # revealed: str & ~int
-else:
-    reveal_type(x)  # revealed: None
-```

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

@@ -78,17 +78,3 @@ def _(x: Literal[1, "a", "b", "c", "d"]):
     else:
         reveal_type(x)  # revealed: Literal[1, "d"]
 ```
-
-## Assignment expressions
-
-```py
-from typing import Literal
-
-def f() -> Literal[1, 2, 3]:
-    return 1
-
-if (x := f()) in (1,):
-    reveal_type(x)  # revealed: Literal[1]
-else:
-    reveal_type(x)  # revealed: Literal[2, 3]
-```

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

@@ -100,16 +100,3 @@ def _(flag: bool):
     else:
         reveal_type(x)  # revealed: Literal[42]
 ```
-
-## Assignment expressions
-
-```py
-from typing import Literal
-
-def f() -> Literal[1, 2] | None: ...
-
-if (x := f()) is None:
-    reveal_type(x)  # revealed: None
-else:
-    reveal_type(x)  # revealed: Literal[1, 2]
-```

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

@@ -82,14 +82,3 @@ def _(x_flag: bool, y_flag: bool):
         reveal_type(x)  # revealed: bool
         reveal_type(y)  # revealed: bool
 ```
-
-## Assignment expressions
-
-```py
-def f() -> int | str | None: ...
-
-if (x := f()) is not None:
-    reveal_type(x)  # revealed: int | str
-else:
-    reveal_type(x)  # revealed: None
-```

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

@@ -89,18 +89,3 @@ def _(flag1: bool, flag2: bool, a: int):
     else:
         reveal_type(x)  # revealed: Literal[1, 2]
 ```
-
-## Assignment expressions
-
-```py
-from typing import Literal
-
-def f() -> Literal[1, 2, 3]:
-    return 1
-
-if (x := f()) != 1:
-    reveal_type(x)  # revealed: Literal[2, 3]
-else:
-    # TODO should be Literal[1]
-    reveal_type(x)  # revealed: Literal[1, 2, 3]
-```

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

@@ -1,10 +1,5 @@
 # Narrowing for `match` statements
 
-```toml
-[environment]
-python-version = "3.10"
-```
-
 ## Single `match` pattern
 
 ```py
@@ -39,7 +34,8 @@ match x:
     case A():
         reveal_type(x)  # revealed: A
     case B():
-        reveal_type(x)  # revealed: B & ~A
+        # TODO could be `B & ~A`
+        reveal_type(x)  # revealed: B
 
 reveal_type(x)  # revealed: object
 ```
@@ -87,7 +83,7 @@ match x:
     case 6.0:
         reveal_type(x)  # revealed: float
     case 1j:
-        reveal_type(x)  # revealed: complex & ~float
+        reveal_type(x)  # revealed: complex
     case b"foo":
         reveal_type(x)  # revealed: Literal[b"foo"]
 
@@ -133,11 +129,11 @@ match x:
     case "foo" | 42 | None:
         reveal_type(x)  # revealed: Literal["foo", 42] | None
     case "foo" | tuple():
-        reveal_type(x)  # revealed: tuple
+        reveal_type(x)  # revealed: Literal["foo"] | tuple
     case True | False:
         reveal_type(x)  # revealed: bool
     case 3.14 | 2.718 | 1.414:
-        reveal_type(x)  # revealed: float & ~tuple
+        reveal_type(x)  # revealed: float
 
 reveal_type(x)  # revealed: object
 ```
@@ -164,49 +160,3 @@ match x:
 
 reveal_type(x)  # revealed: object
 ```
-
-## Narrowing due to guard
-
-```py
-def get_object() -> object:
-    return object()
-
-x = get_object()
-
-reveal_type(x)  # revealed: object
-
-match x:
-    case str() | float() if type(x) is str:
-        reveal_type(x)  #  revealed: str
-    case "foo" | 42 | None if isinstance(x, int):
-        reveal_type(x)  #  revealed: Literal[42]
-    case False if x:
-        reveal_type(x)  #  revealed: Never
-    case "foo" if x := "bar":
-        reveal_type(x)  # revealed: Literal["bar"]
-
-reveal_type(x)  # revealed: object
-```
-
-## Guard and reveal_type in guard
-
-```py
-def get_object() -> object:
-    return object()
-
-x = get_object()
-
-reveal_type(x)  # revealed: object
-
-match x:
-    case str() | float() if type(x) is str and reveal_type(x):  # revealed: str
-        pass
-    case "foo" | 42 | None if isinstance(x, int) and reveal_type(x):  #  revealed: Literal[42]
-        pass
-    case False if x and reveal_type(x):  #  revealed: Never
-        pass
-    case "foo" if (x := "bar") and reveal_type(x):  #  revealed: Literal["bar"]
-        pass
-
-reveal_type(x)  # revealed: object
-```

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

@@ -63,7 +63,7 @@ def bar(world: str, *args, **kwargs) -> float:
 x = foo if flag() else bar
 
 if x:
-    reveal_type(x)  # revealed: (def foo(hello: int) -> bytes) | (def bar(world: str, *args, **kwargs) -> int | float)
+    reveal_type(x)  # revealed: Literal[foo, bar]
 else:
     reveal_type(x)  # revealed: Never
 ```
@@ -246,7 +246,7 @@ class MetaTruthy(type):
 
 class MetaDeferred(type):
     def __bool__(self) -> MetaAmbiguous:
-        raise NotImplementedError
+        return MetaAmbiguous()
 
 class AmbiguousClass(metaclass=MetaAmbiguous): ...
 class FalsyClass(metaclass=MetaFalsy): ...

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

@@ -109,29 +109,6 @@ def _(x: A | B):
         reveal_type(x)  # revealed: A
 ```
 
-## Narrowing for generic classes
-
-```toml
-[environment]
-python-version = "3.13"
-```
-
-Note that `type` returns the runtime class of an object, which does _not_ include specializations in
-the case of a generic class. (The typevars are erased.) That means we cannot narrow the type to the
-specialization that we compare with; we must narrow to an unknown specialization of the generic
-class.
-
-```py
-class A[T = int]: ...
-class B: ...
-
-def _[T](x: A | B):
-    if type(x) is A[str]:
-        reveal_type(x)  # revealed: A[int] & A[Unknown] | B & A[Unknown]
-    else:
-        reveal_type(x)  # revealed: A[int] | B
-```
-
 ## Limitations
 
 ```py
@@ -144,13 +121,3 @@ def _(x: Base):
         # express a constraint like `Base & ~ProperSubtypeOf[Base]`.
         reveal_type(x)  # revealed: Base
 ```
-
-## Assignment expressions
-
-```py
-def _(x: object):
-    if (y := type(x)) is bool:
-        reveal_type(y)  # revealed: Literal[bool]
-    if (type(y := x)) is bool:
-        reveal_type(y)  # revealed: bool
-```

crates/red_knot_python_semantic/resources/mdtest/overloads.md

@@ -1,638 +0,0 @@
-# Overloads
-
-Reference: <https://typing.python.org/en/latest/spec/overload.html>
-
-## `typing.overload`
-
-The definition of `typing.overload` in typeshed is an identity function.
-
-```py
-from typing import overload
-
-def foo(x: int) -> int:
-    return x
-
-reveal_type(foo)  # revealed: def foo(x: int) -> int
-bar = overload(foo)
-reveal_type(bar)  # revealed: def foo(x: int) -> int
-```
-
-## Functions
-
-```py
-from typing import overload
-
-@overload
-def add() -> None: ...
-@overload
-def add(x: int) -> int: ...
-@overload
-def add(x: int, y: int) -> int: ...
-def add(x: int | None = None, y: int | None = None) -> int | None:
-    return (x or 0) + (y or 0)
-
-reveal_type(add)  # revealed: Overload[() -> None, (x: int) -> int, (x: int, y: int) -> int]
-reveal_type(add())  # revealed: None
-reveal_type(add(1))  # revealed: int
-reveal_type(add(1, 2))  # revealed: int
-```
-
-## Overriding
-
-These scenarios are to verify that the overloaded and non-overloaded definitions are correctly
-overridden by each other.
-
-An overloaded function is overriding another overloaded function:
-
-```py
-from typing import overload
-
-@overload
-def foo() -> None: ...
-@overload
-def foo(x: int) -> int: ...
-def foo(x: int | None = None) -> int | None:
-    return x
-
-reveal_type(foo)  # revealed: Overload[() -> None, (x: int) -> int]
-reveal_type(foo())  # revealed: None
-reveal_type(foo(1))  # revealed: int
-
-@overload
-def foo() -> None: ...
-@overload
-def foo(x: str) -> str: ...
-def foo(x: str | None = None) -> str | None:
-    return x
-
-reveal_type(foo)  # revealed: Overload[() -> None, (x: str) -> str]
-reveal_type(foo())  # revealed: None
-reveal_type(foo(""))  # revealed: str
-```
-
-A non-overloaded function is overriding an overloaded function:
-
-```py
-def foo(x: int) -> int:
-    return x
-
-reveal_type(foo)  # revealed: def foo(x: int) -> int
-```
-
-An overloaded function is overriding a non-overloaded function:
-
-```py
-reveal_type(foo)  # revealed: def foo(x: int) -> int
-
-@overload
-def foo() -> None: ...
-@overload
-def foo(x: bytes) -> bytes: ...
-def foo(x: bytes | None = None) -> bytes | None:
-    return x
-
-reveal_type(foo)  # revealed: Overload[() -> None, (x: bytes) -> bytes]
-reveal_type(foo())  # revealed: None
-reveal_type(foo(b""))  # revealed: bytes
-```
-
-## Methods
-
-```py
-from typing import overload
-
-class Foo1:
-    @overload
-    def method(self) -> None: ...
-    @overload
-    def method(self, x: int) -> int: ...
-    def method(self, x: int | None = None) -> int | None:
-        return x
-
-foo1 = Foo1()
-reveal_type(foo1.method)  # revealed: Overload[() -> None, (x: int) -> int]
-reveal_type(foo1.method())  # revealed: None
-reveal_type(foo1.method(1))  # revealed: int
-
-class Foo2:
-    @overload
-    def method(self) -> None: ...
-    @overload
-    def method(self, x: str) -> str: ...
-    def method(self, x: str | None = None) -> str | None:
-        return x
-
-foo2 = Foo2()
-reveal_type(foo2.method)  # revealed: Overload[() -> None, (x: str) -> str]
-reveal_type(foo2.method())  # revealed: None
-reveal_type(foo2.method(""))  # revealed: str
-```
-
-## Constructor
-
-```py
-from typing import overload
-
-class Foo:
-    @overload
-    def __init__(self) -> None: ...
-    @overload
-    def __init__(self, x: int) -> None: ...
-    def __init__(self, x: int | None = None) -> None:
-        self.x = x
-
-foo = Foo()
-reveal_type(foo)  # revealed: Foo
-reveal_type(foo.x)  # revealed: Unknown | int | None
-
-foo1 = Foo(1)
-reveal_type(foo1)  # revealed: Foo
-reveal_type(foo1.x)  # revealed: Unknown | int | None
-```
-
-## Version specific
-
-Function definitions can vary between multiple Python versions.
-
-### Overload and non-overload (3.9)
-
-Here, the same function is overloaded in one version and not in another.
-
-```toml
-[environment]
-python-version = "3.9"
-```
-
-```py
-import sys
-from typing import overload
-
-if sys.version_info < (3, 10):
-    def func(x: int) -> int:
-        return x
-
-elif sys.version_info <= (3, 12):
-    @overload
-    def func() -> None: ...
-    @overload
-    def func(x: int) -> int: ...
-    def func(x: int | None = None) -> int | None:
-        return x
-
-reveal_type(func)  # revealed: def func(x: int) -> int
-func()  # error: [missing-argument]
-```
-
-### Overload and non-overload (3.10)
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-import sys
-from typing import overload
-
-if sys.version_info < (3, 10):
-    def func(x: int) -> int:
-        return x
-
-elif sys.version_info <= (3, 12):
-    @overload
-    def func() -> None: ...
-    @overload
-    def func(x: int) -> int: ...
-    def func(x: int | None = None) -> int | None:
-        return x
-
-reveal_type(func)  # revealed: Overload[() -> None, (x: int) -> int]
-reveal_type(func())  # revealed: None
-reveal_type(func(1))  # revealed: int
-```
-
-### Some overloads are version specific (3.9)
-
-```toml
-[environment]
-python-version = "3.9"
-```
-
-`overloaded.pyi`:
-
-```pyi
-import sys
-from typing import overload
-
-if sys.version_info >= (3, 10):
-    @overload
-    def func() -> None: ...
-
-@overload
-def func(x: int) -> int: ...
-@overload
-def func(x: str) -> str: ...
-```
-
-`main.py`:
-
-```py
-from overloaded import func
-
-reveal_type(func)  # revealed: Overload[(x: int) -> int, (x: str) -> str]
-func()  # error: [no-matching-overload]
-reveal_type(func(1))  # revealed: int
-reveal_type(func(""))  # revealed: str
-```
-
-### Some overloads are version specific (3.10)
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-`overloaded.pyi`:
-
-```pyi
-import sys
-from typing import overload
-
-@overload
-def func() -> None: ...
-
-if sys.version_info >= (3, 10):
-    @overload
-    def func(x: int) -> int: ...
-
-@overload
-def func(x: str) -> str: ...
-```
-
-`main.py`:
-
-```py
-from overloaded import func
-
-reveal_type(func)  # revealed: Overload[() -> None, (x: int) -> int, (x: str) -> str]
-reveal_type(func())  # revealed: None
-reveal_type(func(1))  # revealed: int
-reveal_type(func(""))  # revealed: str
-```
-
-## Generic
-
-```toml
-[environment]
-python-version = "3.12"
-```
-
-For an overloaded generic function, it's not necessary for all overloads to be generic.
-
-```py
-from typing import overload
-
-@overload
-def func() -> None: ...
-@overload
-def func[T](x: T) -> T: ...
-def func[T](x: T | None = None) -> T | None:
-    return x
-
-reveal_type(func)  # revealed: Overload[() -> None, (x: T) -> T]
-reveal_type(func())  # revealed: None
-reveal_type(func(1))  # revealed: Literal[1]
-reveal_type(func(""))  # revealed: Literal[""]
-```
-
-## Invalid
-
-### At least two overloads
-
-At least two `@overload`-decorated definitions must be present.
-
-```py
-from typing import overload
-
-# TODO: error
-@overload
-def func(x: int) -> int: ...
-def func(x: int | str) -> int | str:
-    return x
-```
-
-### Overload without an implementation
-
-#### Regular modules
-
-In regular modules, a series of `@overload`-decorated definitions must be followed by exactly one
-non-`@overload`-decorated definition (for the same function/method).
-
-```py
-from typing import overload
-
-# TODO: error because implementation does not exists
-@overload
-def func(x: int) -> int: ...
-@overload
-def func(x: str) -> str: ...
-
-class Foo:
-    # TODO: error because implementation does not exists
-    @overload
-    def method(self, x: int) -> int: ...
-    @overload
-    def method(self, x: str) -> str: ...
-```
-
-#### Stub files
-
-Overload definitions within stub files are exempt from this check.
-
-```pyi
-from typing import overload
-
-@overload
-def func(x: int) -> int: ...
-@overload
-def func(x: str) -> str: ...
-```
-
-#### Protocols
-
-Overload definitions within protocols are exempt from this check.
-
-```py
-from typing import Protocol, overload
-
-class Foo(Protocol):
-    @overload
-    def f(self, x: int) -> int: ...
-    @overload
-    def f(self, x: str) -> str: ...
-```
-
-#### Abstract methods
-
-Overload definitions within abstract base classes are exempt from this check.
-
-```py
-from abc import ABC, abstractmethod
-from typing import overload
-
-class AbstractFoo(ABC):
-    @overload
-    @abstractmethod
-    def f(self, x: int) -> int: ...
-    @overload
-    @abstractmethod
-    def f(self, x: str) -> str: ...
-```
-
-Using the `@abstractmethod` decorator requires that the class's metaclass is `ABCMeta` or is derived
-from it.
-
-```py
-class Foo:
-    # TODO: Error because implementation does not exists
-    @overload
-    @abstractmethod
-    def f(self, x: int) -> int: ...
-    @overload
-    @abstractmethod
-    def f(self, x: str) -> str: ...
-```
-
-And, the `@abstractmethod` decorator must be present on all the `@overload`-ed methods.
-
-```py
-class PartialFoo1(ABC):
-    @overload
-    @abstractmethod
-    def f(self, x: int) -> int: ...
-    @overload
-    def f(self, x: str) -> str: ...
-
-class PartialFoo(ABC):
-    @overload
-    def f(self, x: int) -> int: ...
-    @overload
-    @abstractmethod
-    def f(self, x: str) -> str: ...
-```
-
-### Inconsistent decorators
-
-#### `@staticmethod` / `@classmethod`
-
-If one overload signature is decorated with `@staticmethod` or `@classmethod`, all overload
-signatures must be similarly decorated. The implementation, if present, must also have a consistent
-decorator.
-
-```py
-from __future__ import annotations
-
-from typing import overload
-
-class CheckStaticMethod:
-    # TODO: error because `@staticmethod` does not exist on all overloads
-    @overload
-    def method1(x: int) -> int: ...
-    @overload
-    def method1(x: str) -> str: ...
-    @staticmethod
-    def method1(x: int | str) -> int | str:
-        return x
-    # TODO: error because `@staticmethod` does not exist on all overloads
-    @overload
-    def method2(x: int) -> int: ...
-    @overload
-    @staticmethod
-    def method2(x: str) -> str: ...
-    @staticmethod
-    def method2(x: int | str) -> int | str:
-        return x
-    # TODO: error because `@staticmethod` does not exist on the implementation
-    @overload
-    @staticmethod
-    def method3(x: int) -> int: ...
-    @overload
-    @staticmethod
-    def method3(x: str) -> str: ...
-    def method3(x: int | str) -> int | str:
-        return x
-
-    @overload
-    @staticmethod
-    def method4(x: int) -> int: ...
-    @overload
-    @staticmethod
-    def method4(x: str) -> str: ...
-    @staticmethod
-    def method4(x: int | str) -> int | str:
-        return x
-
-class CheckClassMethod:
-    def __init__(self, x: int) -> None:
-        self.x = x
-    # TODO: error because `@classmethod` does not exist on all overloads
-    @overload
-    @classmethod
-    def try_from1(cls, x: int) -> CheckClassMethod: ...
-    @overload
-    def try_from1(cls, x: str) -> None: ...
-    @classmethod
-    def try_from1(cls, x: int | str) -> CheckClassMethod | None:
-        if isinstance(x, int):
-            return cls(x)
-        return None
-    # TODO: error because `@classmethod` does not exist on all overloads
-    @overload
-    def try_from2(cls, x: int) -> CheckClassMethod: ...
-    @overload
-    @classmethod
-    def try_from2(cls, x: str) -> None: ...
-    @classmethod
-    def try_from2(cls, x: int | str) -> CheckClassMethod | None:
-        if isinstance(x, int):
-            return cls(x)
-        return None
-    # TODO: error because `@classmethod` does not exist on the implementation
-    @overload
-    @classmethod
-    def try_from3(cls, x: int) -> CheckClassMethod: ...
-    @overload
-    @classmethod
-    def try_from3(cls, x: str) -> None: ...
-    def try_from3(cls, x: int | str) -> CheckClassMethod | None:
-        if isinstance(x, int):
-            return cls(x)
-        return None
-
-    @overload
-    @classmethod
-    def try_from4(cls, x: int) -> CheckClassMethod: ...
-    @overload
-    @classmethod
-    def try_from4(cls, x: str) -> None: ...
-    @classmethod
-    def try_from4(cls, x: int | str) -> CheckClassMethod | None:
-        if isinstance(x, int):
-            return cls(x)
-        return None
-```
-
-#### `@final` / `@override`
-
-If a `@final` or `@override` decorator is supplied for a function with overloads, the decorator
-should be applied only to the overload implementation if it is present.
-
-```py
-from typing_extensions import final, overload, override
-
-class Foo:
-    @overload
-    def method1(self, x: int) -> int: ...
-    @overload
-    def method1(self, x: str) -> str: ...
-    @final
-    def method1(self, x: int | str) -> int | str:
-        return x
-    # TODO: error because `@final` is not on the implementation
-    @overload
-    @final
-    def method2(self, x: int) -> int: ...
-    @overload
-    def method2(self, x: str) -> str: ...
-    def method2(self, x: int | str) -> int | str:
-        return x
-    # TODO: error because `@final` is not on the implementation
-    @overload
-    def method3(self, x: int) -> int: ...
-    @overload
-    @final
-    def method3(self, x: str) -> str: ...
-    def method3(self, x: int | str) -> int | str:
-        return x
-
-class Base:
-    @overload
-    def method(self, x: int) -> int: ...
-    @overload
-    def method(self, x: str) -> str: ...
-    def method(self, x: int | str) -> int | str:
-        return x
-
-class Sub1(Base):
-    @overload
-    def method(self, x: int) -> int: ...
-    @overload
-    def method(self, x: str) -> str: ...
-    @override
-    def method(self, x: int | str) -> int | str:
-        return x
-
-class Sub2(Base):
-    # TODO: error because `@override` is not on the implementation
-    @overload
-    def method(self, x: int) -> int: ...
-    @overload
-    @override
-    def method(self, x: str) -> str: ...
-    def method(self, x: int | str) -> int | str:
-        return x
-
-class Sub3(Base):
-    # TODO: error because `@override` is not on the implementation
-    @overload
-    @override
-    def method(self, x: int) -> int: ...
-    @overload
-    def method(self, x: str) -> str: ...
-    def method(self, x: int | str) -> int | str:
-        return x
-```
-
-#### `@final` / `@override` in stub files
-
-If an overload implementation isn’t present (for example, in a stub file), the `@final` or
-`@override` decorator should be applied only to the first overload.
-
-```pyi
-from typing_extensions import final, overload, override
-
-class Foo:
-    @overload
-    @final
-    def method1(self, x: int) -> int: ...
-    @overload
-    def method1(self, x: str) -> str: ...
-
-    # TODO: error because `@final` is not on the first overload
-    @overload
-    def method2(self, x: int) -> int: ...
-    @final
-    @overload
-    def method2(self, x: str) -> str: ...
-
-class Base:
-    @overload
-    def method(self, x: int) -> int: ...
-    @overload
-    def method(self, x: str) -> str: ...
-
-class Sub1(Base):
-    @overload
-    @override
-    def method(self, x: int) -> int: ...
-    @overload
-    def method(self, x: str) -> str: ...
-
-class Sub2(Base):
-    # TODO: error because `@override` is not on the first overload
-    @overload
-    def method(self, x: int) -> int: ...
-    @overload
-    @override
-    def method(self, x: str) -> str: ...
-```

crates/red_knot_python_semantic/resources/mdtest/properties.md

@@ -146,7 +146,7 @@ class C:
     @property
     def attr(self) -> int:
         return 1
-    # error: [invalid-argument-type] "Argument to this function is incorrect: Expected `(Any, Any, /) -> None`, found `def attr(self) -> None`"
+    # error: [invalid-argument-type] "Object of type `Literal[attr]` cannot be assigned to parameter 2 (`fset`) of bound method `setter`; expected type `(Any, Any, /) -> None`"
     @attr.setter
     def attr(self) -> None:
         pass
@@ -156,7 +156,7 @@ class C:
 
 ```py
 class C:
-    # error: [invalid-argument-type] "Argument to this function is incorrect: Expected `((Any, /) -> Any) | None`, found `def attr(self, x: int) -> int`"
+    # error: [invalid-argument-type] "Object of type `Literal[attr]` cannot be assigned to parameter 1 (`fget`) of class `property`; expected type `((Any, /) -> Any) | None`"
     @property
     def attr(self, x: int) -> int:
         return 1
@@ -294,10 +294,10 @@ Properties also have `fget` and `fset` attributes that can be used to retrieve t
 and setter functions, respectively.
 
 ```py
-reveal_type(attr_property.fget)  # revealed: def attr(self) -> int
+reveal_type(attr_property.fget)  # revealed: Literal[attr]
 reveal_type(attr_property.fget(c))  # revealed: int
 
-reveal_type(attr_property.fset)  # revealed: def attr(self, value: str) -> None
+reveal_type(attr_property.fset)  # revealed: Literal[attr]
 reveal_type(attr_property.fset(c, "a"))  # revealed: None
 
 # error: [invalid-argument-type]

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

@@ -13,7 +13,7 @@ if returns_bool():
     chr: int = 1
 
 def f():
-    reveal_type(chr)  # revealed: int | (def chr(i: int | SupportsIndex, /) -> str)
+    reveal_type(chr)  # revealed: int | Literal[chr]
 ```
 
 ## Conditionally global or builtin, with annotation
@@ -28,5 +28,5 @@ if returns_bool():
     chr: int = 1
 
 def f():
-    reveal_type(chr)  # revealed: int | (def chr(i: int | SupportsIndex, /) -> str)
+    reveal_type(chr)  # revealed: int | Literal[chr]
 ```

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

@@ -14,7 +14,7 @@ reveal_type(__package__)  # revealed: str | None
 reveal_type(__doc__)  # revealed: str | None
 reveal_type(__spec__)  # revealed: ModuleSpec | None
 
-reveal_type(__path__)  # revealed: @Todo(specialized non-generic class)
+reveal_type(__path__)  # revealed: @Todo(generics)
 
 class X:
     reveal_type(__name__)  # revealed: str
@@ -51,15 +51,15 @@ inside the module:
 import typing
 
 reveal_type(typing.__name__)  # revealed: str
-reveal_type(typing.__init__)  # revealed: bound method ModuleType.__init__(name: str, doc: str | None = ellipsis) -> None
+reveal_type(typing.__init__)  # revealed: <bound method `__init__` of `ModuleType`>
 
 # These come from `builtins.object`, not `types.ModuleType`:
-reveal_type(typing.__eq__)  # revealed: bound method ModuleType.__eq__(value: object, /) -> bool
+reveal_type(typing.__eq__)  # revealed: <bound method `__eq__` of `ModuleType`>
 
 reveal_type(typing.__class__)  # revealed: Literal[ModuleType]
 
 # TODO: needs support generics; should be `dict[str, Any]`:
-reveal_type(typing.__dict__)  # revealed: @Todo(specialized non-generic class)
+reveal_type(typing.__dict__)  # revealed: @Todo(generics)
 ```
 
 Typeshed includes a fake `__getattr__` method in the stub for `types.ModuleType` to help out with
@@ -92,8 +92,8 @@ import foo
 from foo import __dict__ as foo_dict
 
 # TODO: needs support generics; should be `dict[str, Any]` for both of these:
-reveal_type(foo.__dict__)  # revealed: @Todo(specialized non-generic class)
-reveal_type(foo_dict)  # revealed: @Todo(specialized non-generic class)
+reveal_type(foo.__dict__)  # revealed: @Todo(generics)
+reveal_type(foo_dict)  # revealed: @Todo(generics)
 ```
 
 ## Conditionally global or `ModuleType` attribute

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

@@ -37,17 +37,17 @@ reveal_type(f)  # revealed: Literal[1]
 
 def f(): ...
 
-reveal_type(f)  # revealed: def f() -> Unknown
+reveal_type(f)  # revealed: Literal[f]
 
 def f(x: int) -> int:
     raise NotImplementedError
 
-reveal_type(f)  # revealed: def f(x: int) -> int
+reveal_type(f)  # revealed: Literal[f]
 
 f: int = 1
 reveal_type(f)  # revealed: Literal[1]
 
 def f(): ...
 
-reveal_type(f)  # revealed: def f() -> Unknown
+reveal_type(f)  # revealed: Literal[f]
 ```

crates/red_knot_python_semantic/resources/mdtest/snapshots/for.md_-_For_loops_-_Bad_`__getitem__`_method.snap

@@ -40,13 +40,13 @@ error: lint:not-iterable
 ```
 
 ```
-info: revealed-type: Revealed type
+info: revealed-type
   --> /src/mdtest_snippet.py:11:5
    |
  9 | # error: [not-iterable]
 10 | for x in Iterable():
 11 |     reveal_type(x)  # revealed: int
-   |     ^^^^^^^^^^^^^^ `int`
+   |     ^^^^^^^^^^^^^^ Revealed type is `int`
    |
 
 ```

crates/red_knot_python_semantic/resources/mdtest/snapshots/for.md_-_For_loops_-_No_`__iter__`_method_and_`__getitem__`_is_not_callable.snap

@@ -37,13 +37,13 @@ error: lint:not-iterable
 ```
 
 ```
-info: revealed-type: Revealed type
+info: revealed-type
  --> /src/mdtest_snippet.py:8:5
   |
 6 | # error: [not-iterable]
 7 | for x in Bad():
 8 |     reveal_type(x)  # revealed: Unknown
-  |     ^^^^^^^^^^^^^^ `Unknown`
+  |     ^^^^^^^^^^^^^^ Revealed type is `Unknown`
   |
 
 ```

crates/red_knot_python_semantic/resources/mdtest/snapshots/for.md_-_For_loops_-_Possibly-not-callable_`__getitem__`_method.snap

@@ -59,13 +59,13 @@ error: lint:not-iterable
 ```
 
 ```
-info: revealed-type: Revealed type
+info: revealed-type
   --> /src/mdtest_snippet.py:24:9
    |
 22 |     for x in Iterable1():
 23 |         # TODO... `int` might be ideal here?
 24 |         reveal_type(x)  # revealed: int | Unknown
-   |         ^^^^^^^^^^^^^^ `int | Unknown`
+   |         ^^^^^^^^^^^^^^ Revealed type is `int | Unknown`
 25 |
 26 |     # error: [not-iterable]
    |
@@ -78,7 +78,7 @@ error: lint:not-iterable
    |
 26 |     # error: [not-iterable]
 27 |     for y in Iterable2():
-   |              ^^^^^^^^^^^ Object of type `Iterable2` may not be iterable because it has no `__iter__` method and its `__getitem__` attribute (with type `(bound method Iterable2.__getitem__(key: int) -> int) | None`) may not be callable
+   |              ^^^^^^^^^^^ Object of type `Iterable2` may not be iterable because it has no `__iter__` method and its `__getitem__` attribute (with type `<bound method `__getitem__` of `Iterable2`> | None`) may not be callable
 28 |         # TODO... `int` might be ideal here?
 29 |         reveal_type(y)  # revealed: int | Unknown
    |
@@ -86,13 +86,13 @@ error: lint:not-iterable
 ```
 
 ```
-info: revealed-type: Revealed type
+info: revealed-type
   --> /src/mdtest_snippet.py:29:9
    |
 27 |     for y in Iterable2():
 28 |         # TODO... `int` might be ideal here?
 29 |         reveal_type(y)  # revealed: int | Unknown
-   |         ^^^^^^^^^^^^^^ `int | Unknown`
+   |         ^^^^^^^^^^^^^^ Revealed type is `int | Unknown`
    |
 
 ```

crates/red_knot_python_semantic/resources/mdtest/snapshots/for.md_-_For_loops_-_Possibly_invalid_`__getitem__`_methods.snap

@@ -48,7 +48,7 @@ error: lint:not-iterable
    |
 19 |     # error: [not-iterable]
 20 |     for x in Iterable1():
-   |              ^^^^^^^^^^^ Object of type `Iterable1` may not be iterable because it has no `__iter__` method and its `__getitem__` attribute (with type `(bound method Iterable1.__getitem__(item: int) -> str) | None`) may not be callable
+   |              ^^^^^^^^^^^ Object of type `Iterable1` may not be iterable because it has no `__iter__` method and its `__getitem__` attribute (with type `<bound method `__getitem__` of `Iterable1`> | None`) may not be callable
 21 |         # TODO: `str` might be better
 22 |         reveal_type(x)  # revealed: str | Unknown
    |
@@ -56,13 +56,13 @@ error: lint:not-iterable
 ```
 
 ```
-info: revealed-type: Revealed type
+info: revealed-type
   --> /src/mdtest_snippet.py:22:9
    |
 20 |     for x in Iterable1():
 21 |         # TODO: `str` might be better
 22 |         reveal_type(x)  # revealed: str | Unknown
-   |         ^^^^^^^^^^^^^^ `str | Unknown`
+   |         ^^^^^^^^^^^^^^ Revealed type is `str | Unknown`
 23 |
 24 |     # error: [not-iterable]
    |
@@ -75,20 +75,20 @@ error: lint:not-iterable
    |
 24 |     # error: [not-iterable]
 25 |     for y in Iterable2():
-   |              ^^^^^^^^^^^ Object of type `Iterable2` may not be iterable because it has no `__iter__` method and its `__getitem__` method (with type `(bound method Iterable2.__getitem__(item: int) -> str) | (bound method Iterable2.__getitem__(item: str) -> int)`) may have an incorrect signature for the old-style iteration protocol (expected a signature at least as permissive as `def __getitem__(self, key: int): ...`)
+   |              ^^^^^^^^^^^ Object of type `Iterable2` may not be iterable because it has no `__iter__` method and its `__getitem__` method (with type `<bound method `__getitem__` of `Iterable2`> | <bound method `__getitem__` of `Iterable2`>`) may have an incorrect signature for the old-style iteration protocol (expected a signature at least as permissive as `def __getitem__(self, key: int): ...`)
 26 |         reveal_type(y)  # revealed: str | int
    |
 
 ```
 
 ```
-info: revealed-type: Revealed type
+info: revealed-type
   --> /src/mdtest_snippet.py:26:9
    |
 24 |     # error: [not-iterable]
 25 |     for y in Iterable2():
 26 |         reveal_type(y)  # revealed: str | int
-   |         ^^^^^^^^^^^^^^ `str | int`
+   |         ^^^^^^^^^^^^^^ Revealed type is `str | int`
    |
 
 ```