[red-knot] remove fixpoint handling from inheritance_cycle query

## Summary

Tracked structs have some issues with fixpoint iteration in Salsa, and
there's not actually any need for this to be tracked, it should be
interned like most of our type structs.

The removed comment was probably never correct (in that we could have
disambiguated sufficiently), and is definitely not relevant now that
`TypeVarInstance` also holds its `Definition`.

## Test Plan

Existing tests.

.gitattributes

@@ -12,6 +12,12 @@ crates/ruff_python_parser/resources/invalid/re_lexing/line_continuation_windows_
 crates/ruff_python_parser/resources/invalid/re_lex_logical_token_windows_eol.py text eol=crlf
 crates/ruff_python_parser/resources/invalid/re_lex_logical_token_mac_eol.py text eol=cr
 
+crates/ruff_linter/resources/test/fixtures/ruff/RUF046_CR.py text eol=cr
+crates/ruff_linter/resources/test/fixtures/ruff/RUF046_LF.py text eol=lf
+
+crates/ruff_linter/resources/test/fixtures/pyupgrade/UP018_CR.py text eol=cr
+crates/ruff_linter/resources/test/fixtures/pyupgrade/UP018_LF.py text eol=lf
+
 crates/ruff_python_parser/resources/inline linguist-generated=true
 
 ruff.schema.json -diff linguist-generated=true text=auto eol=lf

.github/actionlint.yaml

@@ -6,5 +6,6 @@ self-hosted-runner:
   labels:
     - depot-ubuntu-latest-8
     - depot-ubuntu-22.04-16
+    - depot-ubuntu-22.04-32
     - github-windows-2025-x86_64-8
     - github-windows-2025-x86_64-16

.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@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.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@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.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@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.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@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.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@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.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@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.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@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
         with:
           target: ${{ matrix.target }}
           manylinux: musllinux_1_2
           args: --release --locked --out dist
       - name: "Test wheel"
         if: matrix.target == 'x86_64-unknown-linux-musl'
-        uses: addnab/docker-run-action@v3
+        uses: addnab/docker-run-action@4f65fabd2431ebc8d299f8e5a018d79a769ae185 # v3
         with:
           image: alpine:latest
           options: -v ${{ github.workspace }}:/io -w /io
@@ -435,7 +435,7 @@ jobs:
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.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@v1
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # 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@v1
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # 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@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
         with:
           tool: cargo-nextest
       - name: "Run tests"
@@ -346,7 +346,7 @@ jobs:
       - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: 20
           cache: "npm"
@@ -376,7 +376,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
-        uses: rui314/setup-mold@v1
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
       - name: "Build"
         run: cargo build --release --locked
 
@@ -401,13 +401,13 @@ jobs:
           MSRV: ${{ steps.msrv.outputs.value }}
         run: rustup default "${MSRV}"
       - name: "Install mold"
-        uses: rui314/setup-mold@v1
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # v2
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # 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@main
+        uses: cargo-bins/cargo-binstall@63aaa5c1932cebabc34eceda9d92a70215dcead6 # v1.12.3
         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@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
+      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
       - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
         name: Download Ruff binary to test
         id: download-cached-binary
@@ -641,7 +641,7 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: cargo-bins/cargo-binstall@main
+      - uses: cargo-bins/cargo-binstall@63aaa5c1932cebabc34eceda9d92a70215dcead6 # v1.12.3
       - run: cargo binstall --no-confirm cargo-shear
       - run: cargo shear
 
@@ -662,7 +662,7 @@ jobs:
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
       - name: "Build wheels"
-        uses: PyO3/maturin-action@44479ae1b6b1a57f561e03add8832e62c185eb17 # v1.48.1
+        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.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@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
+      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
       - 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@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
+        uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
         run: uv pip install -r docs/requirements-insiders.txt --system
@@ -821,7 +821,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
       - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: 22
           cache: "npm"
@@ -857,7 +857,7 @@ jobs:
         run: rustup show
 
       - name: "Install codspeed"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@09dc018eee06ae1c9e0409786563f534210ceb83 # 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@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
+      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
-        uses: rui314/setup-mold@v1
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
       - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: Build ruff
         # A debug build means the script runs slower once it gets started,

.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@v1
+        uses: rui314/setup-mold@e16410e7f8d9e167b74ad5697a9089a35126eb50 # v1
       - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
       - name: Build Red Knot
         # A release build takes longer (2 min vs 1 min), but the property tests run much faster in release

.github/workflows/mypy_primer.yaml

@@ -21,11 +21,12 @@ env:
   CARGO_NET_RETRY: 10
   CARGO_TERM_COLOR: always
   RUSTUP_MAX_RETRIES: 10
+  RUST_BACKTRACE: 1
 
 jobs:
   mypy_primer:
     name: Run mypy_primer
-    runs-on: depot-ubuntu-22.04-16
+    runs-on: depot-ubuntu-22.04-32
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
@@ -35,7 +36,7 @@ jobs:
           persist-credentials: false
 
       - name: Install the latest version of uv
-        uses: astral-sh/setup-uv@0c5e2b8115b80b4c7c5ddf6ffdd634974642d182 # v5.4.1
+        uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2
 
       - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
         with:
@@ -45,13 +46,15 @@ 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/hauntsaninja/mypy_primer@4c22d192a456e27badf85b3ea0f830707375d2b7"
 
       - name: Run mypy_primer
         shell: bash
         run: |
           cd ruff
 
+          PRIMER_SELECTOR="$(paste -s -d'|' crates/red_knot_python_semantic/resources/primer/good.txt)"
+
           echo "new commit"
           git rev-list --format=%s --max-count=1 "$GITHUB_SHA"
 
@@ -62,13 +65,14 @@ jobs:
 
           cd ..
 
+          echo "Project selector: $PRIMER_SELECTOR"
           # Allow the exit code to be 0 or 1, only fail for actual mypy_primer crashes/bugs
           uvx mypy_primer \
             --repo ruff \
             --type-checker knot \
             --old base_commit \
             --new "$GITHUB_SHA" \
-            --project-selector '/(mypy_primer|black|pyp|git-revise|zipp|arrow|isort|itsdangerous|rich|packaging|pybind11|pyinstrument|typeshed-stats|scrapy|werkzeug|bidict|async-utils)$' \
+            --project-selector "/($PRIMER_SELECTOR)\$" \
             --output concise \
             --debug > mypy_primer.diff || [ $? -eq 1 ]
 

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

@@ -35,7 +35,7 @@ jobs:
           persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: 22
       - uses: jetli/wasm-bindgen-action@20b33e20595891ab1a0ed73145d8a21fc96e7c29 # v0.2.0

.github/workflows/publish-playground.yml

@@ -29,7 +29,7 @@ jobs:
           persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: 22
           cache: "npm"

.github/workflows/publish-pypi.yml

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

.github/workflows/publish-wasm.yml

@@ -45,7 +45,7 @@ jobs:
           jq '.name="@astral-sh/ruff-wasm-${{ matrix.target }}"' crates/ruff_wasm/pkg/package.json > /tmp/package.json
           mv /tmp/package.json crates/ruff_wasm/pkg
       - run: cp LICENSE crates/ruff_wasm/pkg # wasm-pack does not put the LICENSE file in the pkg
-      - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4.3.0
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: 20
           registry-url: "https://registry.npmjs.org"

.github/workflows/release.yml

@@ -40,6 +40,7 @@ permissions:
 # If there's a prerelease-style suffix to the version, then the release(s)
 # will be marked as a prerelease.
 on:
+  pull_request:
   workflow_dispatch:
     inputs:
       tag:
@@ -60,7 +61,7 @@ jobs:
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
         with:
           persist-credentials: false
           submodules: recursive
@@ -68,9 +69,9 @@ jobs:
         # 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.4/cargo-dist-installer.sh | sh"
       - name: Cache dist
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@6027e3dd177782cd8ab9af838c04fd81a07f1d47
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/dist
@@ -86,7 +87,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@6027e3dd177782cd8ab9af838c04fd81a07f1d47
         with:
           name: artifacts-plan-dist-manifest
           path: plan-dist-manifest.json
@@ -123,7 +124,7 @@ jobs:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
         with:
           persist-credentials: false
           submodules: recursive
@@ -153,7 +154,7 @@ jobs:
 
           cp dist-manifest.json "$BUILD_MANIFEST_NAME"
       - name: "Upload artifacts"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@6027e3dd177782cd8ab9af838c04fd81a07f1d47
         with:
           name: artifacts-build-global
           path: |
@@ -174,7 +175,7 @@ jobs:
     outputs:
       val: ${{ steps.host.outputs.manifest }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
         with:
           persist-credentials: false
           submodules: recursive
@@ -200,7 +201,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@6027e3dd177782cd8ab9af838c04fd81a07f1d47
         with:
           # Overwrite the previous copy
           name: artifacts-dist-manifest
@@ -250,7 +251,7 @@ jobs:
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
         with:
           persist-credentials: false
           submodules: recursive

.pre-commit-config.yaml

@@ -79,7 +79,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.5
+    rev: v0.11.6
     hooks:
       - id: ruff-format
       - id: ruff
@@ -97,7 +97,7 @@ repos:
   # zizmor detects security vulnerabilities in GitHub Actions workflows.
   # Additional configuration for the tool is found in `.github/zizmor.yml`
   - repo: https://github.com/woodruffw/zizmor-pre-commit
-    rev: v1.5.2
+    rev: v1.6.0
     hooks:
       - id: zizmor
 

CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.11.7
+
+### Preview features
+
+- \[`airflow`\] Apply auto fixes to cases where the names have changed in Airflow 3 (`AIR301`) ([#17355](https://github.com/astral-sh/ruff/pull/17355))
+- \[`perflint`\] Implement fix for `manual-dict-comprehension` (`PERF403`) ([#16719](https://github.com/astral-sh/ruff/pull/16719))
+- [syntax-errors] Make duplicate parameter names a semantic error ([#17131](https://github.com/astral-sh/ruff/pull/17131))
+
+### Bug fixes
+
+- \[`airflow`\] Fix typos in provider package names (`AIR302`, `AIR312`) ([#17574](https://github.com/astral-sh/ruff/pull/17574))
+- \[`flake8-type-checking`\] Visit keyword arguments in checks involving `typing.cast`/`typing.NewType` arguments ([#17538](https://github.com/astral-sh/ruff/pull/17538))
+- \[`pyupgrade`\] Preserve parenthesis when fixing native literals containing newlines (`UP018`) ([#17220](https://github.com/astral-sh/ruff/pull/17220))
+- \[`refurb`\] Mark the `FURB161` fix unsafe except for integers and booleans ([#17240](https://github.com/astral-sh/ruff/pull/17240))
+
+### Rule changes
+
+- \[`perflint`\] Allow list function calls to be replaced with a comprehension (`PERF401`) ([#17519](https://github.com/astral-sh/ruff/pull/17519))
+- \[`pycodestyle`\] Auto-fix redundant boolean comparison (`E712`) ([#17090](https://github.com/astral-sh/ruff/pull/17090))
+- \[`pylint`\] make fix unsafe if delete comments (`PLR1730`) ([#17459](https://github.com/astral-sh/ruff/pull/17459))
+
+### Documentation
+
+- Add fix safety sections to docs for several rules ([#17410](https://github.com/astral-sh/ruff/pull/17410),[#17440](https://github.com/astral-sh/ruff/pull/17440),[#17441](https://github.com/astral-sh/ruff/pull/17441),[#17443](https://github.com/astral-sh/ruff/pull/17443),[#17444](https://github.com/astral-sh/ruff/pull/17444))
+
+## 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

Cargo.lock

@@ -128,9 +128,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.97"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "argfile"
@@ -216,9 +216,9 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.11.3"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "531a9155a481e2ee699d4f98f43c0ca4ff8ee1bfd55c31e9e98fb29d2b176fe0"
+checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
 dependencies = [
  "memchr",
  "regex-automata 0.4.9",
@@ -334,9 +334,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.35"
+version = "4.5.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8aa86934b44c19c50f87cc2790e19f54f7a67aedb64101c2e1a2e5ecfb73944"
+checksum = "eccb054f56cbd38340b380d4a8e69ef1f02f1af43db2f0cc817a4774d80ae071"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -344,9 +344,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.35"
+version = "4.5.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2414dbb2dd0695280da6ea9261e327479e9d37b0630f6b53ba2a11c60c679fd9"
+checksum = "efd9466fac8543255d3b1fcad4762c5e116ffe808c8a3043d4263cd4fd4862a2"
 dependencies = [
  "anstream",
  "anstyle",
@@ -478,7 +478,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
 dependencies = [
  "lazy_static",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -487,7 +487,7 @@ version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fde0e0ec90c9dfb3b4b1a0891a7dcd0e2bffde2f7efed5fe7c9bb00e5bfb915e"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1553,28 +1553,45 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "jiff"
-version = "0.2.4"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d699bc6dfc879fb1bf9bdff0d4c56f0884fc6f0d0eb0fba397a6d00cd9a6b85e"
+checksum = "59ec30f7142be6fe14e1b021f50b85db8df2d4324ea6e91ec3e5dcde092021d0"
 dependencies = [
  "jiff-static",
+ "jiff-tzdb-platform",
  "log",
  "portable-atomic",
  "portable-atomic-util",
  "serde",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "jiff-static"
-version = "0.2.4"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d16e75759ee0aa64c57a56acbf43916987b20c77373cb7e808979e02b93c9f9"
+checksum = "526b834d727fd59d37b076b0c3236d9adde1b1729a4361e20b2026f738cc1dbe"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn 2.0.100",
 ]
 
+[[package]]
+name = "jiff-tzdb"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1283705eb0a21404d2bfd6eef2a7593d240bc42a0bdb39db0ad6fa2ec026524"
+
+[[package]]
+name = "jiff-tzdb-platform"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
+dependencies = [
+ "jiff-tzdb",
+]
+
 [[package]]
 name = "jobserver"
 version = "0.1.32"
@@ -1628,9 +1645,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.171"
+version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
 [[package]]
 name = "libcst"
@@ -1659,9 +1676,9 @@ dependencies = [
 
 [[package]]
 name = "libmimalloc-sys"
-version = "0.1.41"
+version = "0.1.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b20daca3a4ac14dbdc753c5e90fc7b490a48a9131daed3c9a9ced7b2defd37b"
+checksum = "ec9d6fac27761dabcd4ee73571cdb06b7022dc99089acbe5435691edffaac0f4"
 dependencies = [
  "cc",
  "libc",
@@ -1797,9 +1814,9 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "mimalloc"
-version = "0.1.45"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03cb1f88093fe50061ca1195d336ffec131347c7b833db31f9ab62a2d1b7925f"
+checksum = "995942f432bbb4822a7e9c3faa87a695185b0d09273ba85f097b54f4e458f2af"
 dependencies = [
  "libmimalloc-sys",
 ]
@@ -2310,9 +2327,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.94"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
@@ -2403,13 +2420,12 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
- "zerocopy",
 ]
 
 [[package]]
@@ -2476,7 +2492,6 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "argfile",
- "chrono",
  "clap",
  "colored 3.0.0",
  "countme",
@@ -2485,6 +2500,7 @@ dependencies = [
  "filetime",
  "insta",
  "insta-cmd",
+ "jiff",
  "rayon",
  "red_knot_project",
  "red_knot_python_semantic",
@@ -2756,7 +2772,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.11.5"
+version = "0.11.7"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2764,7 +2780,6 @@ dependencies = [
  "bincode",
  "bitflags 2.9.0",
  "cachedir",
- "chrono",
  "clap",
  "clap_complete_command",
  "clearscreen",
@@ -2777,6 +2792,7 @@ dependencies = [
  "insta-cmd",
  "is-macro",
  "itertools 0.14.0",
+ "jiff",
  "log",
  "mimalloc",
  "notify",
@@ -2991,12 +3007,11 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.11.5"
+version = "0.11.7"
 dependencies = [
  "aho-corasick",
  "anyhow",
  "bitflags 2.9.0",
- "chrono",
  "clap",
  "colored 3.0.0",
  "fern",
@@ -3007,6 +3022,7 @@ dependencies = [
  "is-macro",
  "is-wsl",
  "itertools 0.14.0",
+ "jiff",
  "libcst",
  "log",
  "memchr",
@@ -3067,7 +3083,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
- "rand 0.9.0",
+ "rand 0.9.1",
  "ruff_diagnostics",
  "ruff_source_file",
  "ruff_text_size",
@@ -3317,7 +3333,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.11.5"
+version = "0.11.7"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -3658,9 +3674,9 @@ dependencies = [
 
 [[package]]
 name = "shellexpand"
-version = "3.1.0"
+version = "3.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da03fa3b94cc19e3ebfc88c4229c49d8f08cdbd1228870a45f0ffdf84988e14b"
+checksum = "8b1fdf65dd6331831494dd616b30351c38e96e45921a27745cf98490458b90bb"
 dependencies = [
  "dirs",
 ]
@@ -4311,7 +4327,7 @@ checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
 dependencies = [
  "getrandom 0.3.2",
  "js-sys",
- "rand 0.9.0",
+ "rand 0.9.1",
  "uuid-macro-internal",
  "wasm-bindgen",
 ]
@@ -4582,7 +4598,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]

Cargo.toml

@@ -55,7 +55,6 @@ bitflags = { version = "2.5.0" }
 bstr = { version = "1.9.1" }
 cachedir = { version = "0.3.1" }
 camino = { version = "1.1.7" }
-chrono = { version = "0.4.35", default-features = false, features = ["clock"] }
 clap = { version = "4.5.3", features = ["derive"] }
 clap_complete_command = { version = "0.6.0" }
 clearscreen = { version = "4.0.0" }
@@ -95,6 +94,7 @@ insta-cmd = { version = "0.6.0" }
 is-macro = { version = "0.3.5" }
 is-wsl = { version = "0.4.0" }
 itertools = { version = "0.14.0" }
+jiff = { version = "0.2.0" }
 js-sys = { version = "0.3.69" }
 jod-thread = { version = "0.1.2" }
 libc = { version = "0.2.153" }
@@ -231,6 +231,10 @@ unused_peekable = "warn"
 # Diagnostics are not actionable: Enable once https://github.com/rust-lang/rust-clippy/issues/13774 is resolved.
 large_stack_arrays = "allow"
 
+# Salsa generates functions with parameters for each field of a `salsa::interned` struct.
+# If we don't allow this, we get warnings for structs with too many fields.
+too_many_arguments = "allow"
+
 [profile.release]
 # Note that we set these explicitly, and these values
 # were chosen based on a trade-off between compile times
@@ -272,7 +276,9 @@ 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.4"
+# Make distability of apps opt-in instead of opt-out
+dist = false
 # CI backends to support
 ci = "github"
 # The installers to generate for each app
@@ -306,7 +312,7 @@ auto-includes = false
 # Whether dist should create a Github Release or use an existing draft
 create-release = true
 # Which actions to run on pull requests
-pr-run-mode = "skip"
+pr-run-mode = "plan"
 # Whether CI should trigger releases with dispatches instead of tag pushes
 dispatch-releases = true
 # Which phase dist should use to create the GitHub release
@@ -334,7 +340,7 @@ install-path = ["$XDG_BIN_HOME/", "$XDG_DATA_HOME/../bin", "~/.local/bin"]
 global = "depot-ubuntu-latest-4"
 
 [workspace.metadata.dist.github-action-commits]
-"actions/checkout" = "11bd71901bbe5b1630ceea73d27597364c9af683" # v4
-"actions/upload-artifact" = "ea165f8d65b6e75b540449e92b4886f43607fa02" # v4.6.2
+"actions/checkout" = "85e6279cec87321a52edac9c87bce653a07cf6c2" # v4
+"actions/upload-artifact" = "6027e3dd177782cd8ab9af838c04fd81a07f1d47" # v4.6.2
 "actions/download-artifact" = "95815c38cf2ff2164869cbab79da8d1f422bc89e" # v4.2.1
 "actions/attest-build-provenance" = "c074443f1aee8d4aeeae555aebba3282517141b2" #v2.2.3

README.md

@@ -149,8 +149,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.11.5/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.11.5/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.11.7/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.11.7/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -183,7 +183,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.11.5
+  rev: v0.11.7
   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

@@ -2,16 +2,16 @@
 
 ## Basics
 
-For now, we use our own [fork of mypy primer]. It can be run using `uvx --from "…" mypy_primer`. For example, to see the help message, run:
+`mypy_primer` can be run using `uvx --from "…" mypy_primer`. For example, to see the help message, run:
 
 ```sh
-uvx --from "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support" mypy_primer -h
+uvx --from "git+https://github.com/hauntsaninja/mypy_primer" mypy_primer -h
 ```
 
 Alternatively, you can install the forked version of `mypy_primer` using:
 
 ```sh
-uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support"
+uv tool install "git+https://github.com/hauntsaninja/mypy_primer"
 ```
 
 and then run it using `uvx mypy_primer` or just `mypy_primer`, if your `PATH` is set up accordingly (see: [Tool executables]).
@@ -31,7 +31,7 @@ mypy_primer \
 ```
 
 This will show the diagnostics diff for the `black` project between the `main` branch and your `my/feature` branch. To run the
-diff for all projects, you currently need to copy the project-selector regex from the CI pipeline in `.github/workflows/mypy_primer.yaml`.
+diff for all projects we currently enable in CI, use `--project-selector "/($(paste -s -d'|' crates/red_knot_python_semantic/resources/primer/good.txt))\$"`.
 
 You can also take a look at the [full list of ecosystem projects]. Note that some of them might still need a `knot_paths` configuration
 option to work correctly.
@@ -56,6 +56,5 @@ mypy_primer --repo /path/to/ruff --old origin/main --new my/local-branch …
 
 Note that you might need to clean up `/tmp/mypy_primer` in order for this to work correctly.
 
-[fork of mypy primer]: https://github.com/astral-sh/mypy_primer/tree/add-red-knot-support
-[full list of ecosystem projects]: https://github.com/astral-sh/mypy_primer/blob/add-red-knot-support/mypy_primer/projects.py
+[full list of ecosystem projects]: https://github.com/hauntsaninja/mypy_primer/blob/master/mypy_primer/projects.py
 [tool executables]: https://docs.astral.sh/uv/concepts/tools/#tool-executables

crates/red_knot/src/logging.rs

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

crates/red_knot/tests/cli.rs

@@ -32,12 +32,12 @@ fn config_override_python_version() -> anyhow::Result<()> {
     success: false
     exit_code: 1
     ----- stdout -----
-    error: lint:unresolved-attribute
+    error: lint:unresolved-attribute: Type `<module 'sys'>` has no attribute `last_exc`
      --> <temp_dir>/test.py:5:7
       |
     4 | # Access `sys.last_exc` that was only added in Python 3.12
     5 | print(sys.last_exc)
-      |       ^^^^^^^^^^^^ Type `<module 'sys'>` has no attribute `last_exc`
+      |       ^^^^^^^^^^^^
       |
 
     Found 1 diagnostic
@@ -165,11 +165,11 @@ fn cli_arguments_are_relative_to_the_current_directory() -> anyhow::Result<()> {
     success: false
     exit_code: 1
     ----- stdout -----
-    error: lint:unresolved-import
+    error: lint:unresolved-import: Cannot resolve import `utils`
      --> <temp_dir>/child/test.py:2:6
       |
     2 | from utils import add
-      |      ^^^^^ Cannot resolve import `utils`
+      |      ^^^^^
     3 |
     4 | stat = add(10, 15)
       |
@@ -252,7 +252,7 @@ fn configuration_rule_severity() -> anyhow::Result<()> {
         r#"
             y = 4 / 0
 
-            for a in range(0, y):
+            for a in range(0, int(y)):
                 x = a
 
             print(x)  # possibly-unresolved-reference
@@ -265,22 +265,22 @@ fn configuration_rule_severity() -> anyhow::Result<()> {
     success: false
     exit_code: 1
     ----- stdout -----
-    error: lint:division-by-zero
+    error: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
      --> <temp_dir>/test.py:2:5
       |
     2 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ^^^^^
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
-    warning: lint:possibly-unresolved-reference
+    warning: lint:possibly-unresolved-reference: Name `x` used when possibly not defined
      --> <temp_dir>/test.py:7:7
       |
     5 |     x = a
     6 |
     7 | print(x)  # possibly-unresolved-reference
-      |       ^ Name `x` used when possibly not defined
+      |       ^
       |
 
     Found 2 diagnostics
@@ -301,13 +301,13 @@ fn configuration_rule_severity() -> anyhow::Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
-    warning: lint:division-by-zero
+    warning: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
      --> <temp_dir>/test.py:2:5
       |
     2 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ^^^^^
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
     Found 1 diagnostic
@@ -328,7 +328,7 @@ fn cli_rule_severity() -> anyhow::Result<()> {
 
         y = 4 / 0
 
-        for a in range(0, y):
+        for a in range(0, int(y)):
             x = a
 
         print(x)  # possibly-unresolved-reference
@@ -341,33 +341,33 @@ fn cli_rule_severity() -> anyhow::Result<()> {
     success: false
     exit_code: 1
     ----- stdout -----
-    error: lint:unresolved-import
+    error: lint:unresolved-import: Cannot resolve import `does_not_exit`
      --> <temp_dir>/test.py:2:8
       |
     2 | import does_not_exit
-      |        ^^^^^^^^^^^^^ Cannot resolve import `does_not_exit`
+      |        ^^^^^^^^^^^^^
     3 |
     4 | y = 4 / 0
       |
 
-    error: lint:division-by-zero
+    error: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
      --> <temp_dir>/test.py:4:5
       |
     2 | import does_not_exit
     3 |
     4 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ^^^^^
     5 |
-    6 | for a in range(0, y):
+    6 | for a in range(0, int(y)):
       |
 
-    warning: lint:possibly-unresolved-reference
+    warning: lint:possibly-unresolved-reference: Name `x` used when possibly not defined
      --> <temp_dir>/test.py:9:7
       |
     7 |     x = a
     8 |
     9 | print(x)  # possibly-unresolved-reference
-      |       ^ Name `x` used when possibly not defined
+      |       ^
       |
 
     Found 3 diagnostics
@@ -388,24 +388,24 @@ fn cli_rule_severity() -> anyhow::Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
-    warning: lint:unresolved-import
+    warning: lint:unresolved-import: Cannot resolve import `does_not_exit`
      --> <temp_dir>/test.py:2:8
       |
     2 | import does_not_exit
-      |        ^^^^^^^^^^^^^ Cannot resolve import `does_not_exit`
+      |        ^^^^^^^^^^^^^
     3 |
     4 | y = 4 / 0
       |
 
-    warning: lint:division-by-zero
+    warning: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
      --> <temp_dir>/test.py:4:5
       |
     2 | import does_not_exit
     3 |
     4 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ^^^^^
     5 |
-    6 | for a in range(0, y):
+    6 | for a in range(0, int(y)):
       |
 
     Found 2 diagnostics
@@ -426,7 +426,7 @@ fn cli_rule_severity_precedence() -> anyhow::Result<()> {
         r#"
         y = 4 / 0
 
-        for a in range(0, y):
+        for a in range(0, int(y)):
             x = a
 
         print(x)  # possibly-unresolved-reference
@@ -439,22 +439,22 @@ fn cli_rule_severity_precedence() -> anyhow::Result<()> {
     success: false
     exit_code: 1
     ----- stdout -----
-    error: lint:division-by-zero
+    error: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
      --> <temp_dir>/test.py:2:5
       |
     2 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ^^^^^
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
-    warning: lint:possibly-unresolved-reference
+    warning: lint:possibly-unresolved-reference: Name `x` used when possibly not defined
      --> <temp_dir>/test.py:7:7
       |
     5 |     x = a
     6 |
     7 | print(x)  # possibly-unresolved-reference
-      |       ^ Name `x` used when possibly not defined
+      |       ^
       |
 
     Found 2 diagnostics
@@ -476,13 +476,13 @@ fn cli_rule_severity_precedence() -> anyhow::Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
-    warning: lint:division-by-zero
+    warning: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
      --> <temp_dir>/test.py:2:5
       |
     2 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ^^^^^
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
     Found 1 diagnostic
@@ -555,11 +555,11 @@ fn exit_code_only_warnings() -> anyhow::Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
-    warning: lint:unresolved-reference
+    warning: lint:unresolved-reference: Name `x` used when not defined
      --> <temp_dir>/test.py:1:7
       |
     1 | print(x)  # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       ^
       |
 
     Found 1 diagnostic
@@ -638,11 +638,11 @@ fn exit_code_no_errors_but_error_on_warning_is_true() -> anyhow::Result<()> {
     success: false
     exit_code: 1
     ----- stdout -----
-    warning: lint:unresolved-reference
+    warning: lint:unresolved-reference: Name `x` used when not defined
      --> <temp_dir>/test.py:1:7
       |
     1 | print(x)  # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       ^
       |
 
     Found 1 diagnostic
@@ -670,11 +670,11 @@ fn exit_code_no_errors_but_error_on_warning_is_enabled_in_configuration() -> any
     success: false
     exit_code: 1
     ----- stdout -----
-    warning: lint:unresolved-reference
+    warning: lint:unresolved-reference: Name `x` used when not defined
      --> <temp_dir>/test.py:1:7
       |
     1 | print(x)  # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       ^
       |
 
     Found 1 diagnostic
@@ -699,20 +699,20 @@ fn exit_code_both_warnings_and_errors() -> anyhow::Result<()> {
     success: false
     exit_code: 1
     ----- stdout -----
-    warning: lint:unresolved-reference
+    warning: lint:unresolved-reference: Name `x` used when not defined
      --> <temp_dir>/test.py:2:7
       |
     2 | print(x)     # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       ^
     3 | print(4[1])  # [non-subscriptable]
       |
 
-    error: lint:non-subscriptable
+    error: lint:non-subscriptable: Cannot subscript object of type `Literal[4]` with no `__getitem__` method
      --> <temp_dir>/test.py:3:7
       |
     2 | print(x)     # [unresolved-reference]
     3 | print(4[1])  # [non-subscriptable]
-      |       ^ Cannot subscript object of type `Literal[4]` with no `__getitem__` method
+      |       ^
       |
 
     Found 2 diagnostics
@@ -737,20 +737,20 @@ fn exit_code_both_warnings_and_errors_and_error_on_warning_is_true() -> anyhow::
     success: false
     exit_code: 1
     ----- stdout -----
-    warning: lint:unresolved-reference
+    warning: lint:unresolved-reference: Name `x` used when not defined
      --> <temp_dir>/test.py:2:7
       |
     2 | print(x)     # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       ^
     3 | print(4[1])  # [non-subscriptable]
       |
 
-    error: lint:non-subscriptable
+    error: lint:non-subscriptable: Cannot subscript object of type `Literal[4]` with no `__getitem__` method
      --> <temp_dir>/test.py:3:7
       |
     2 | print(x)     # [unresolved-reference]
     3 | print(4[1])  # [non-subscriptable]
-      |       ^ Cannot subscript object of type `Literal[4]` with no `__getitem__` method
+      |       ^
       |
 
     Found 2 diagnostics
@@ -775,20 +775,20 @@ fn exit_code_exit_zero_is_true() -> anyhow::Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
-    warning: lint:unresolved-reference
+    warning: lint:unresolved-reference: Name `x` used when not defined
      --> <temp_dir>/test.py:2:7
       |
     2 | print(x)     # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       ^
     3 | print(4[1])  # [non-subscriptable]
       |
 
-    error: lint:non-subscriptable
+    error: lint:non-subscriptable: Cannot subscript object of type `Literal[4]` with no `__getitem__` method
      --> <temp_dir>/test.py:3:7
       |
     2 | print(x)     # [unresolved-reference]
     3 | print(4[1])  # [non-subscriptable]
-      |       ^ Cannot subscript object of type `Literal[4]` with no `__getitem__` method
+      |       ^
       |
 
     Found 2 diagnostics
@@ -814,7 +814,7 @@ fn user_configuration() -> anyhow::Result<()> {
             r#"
             y = 4 / 0
 
-            for a in range(0, y):
+            for a in range(0, int(y)):
                 x = a
 
             print(x)
@@ -835,22 +835,22 @@ fn user_configuration() -> anyhow::Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
-    warning: lint:division-by-zero
+    warning: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
      --> <temp_dir>/project/main.py:2:5
       |
     2 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ^^^^^
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
-    warning: lint:possibly-unresolved-reference
+    warning: lint:possibly-unresolved-reference: Name `x` used when possibly not defined
      --> <temp_dir>/project/main.py:7:7
       |
     5 |     x = a
     6 |
     7 | print(x)
-      |       ^ Name `x` used when possibly not defined
+      |       ^
       |
 
     Found 2 diagnostics
@@ -877,22 +877,22 @@ fn user_configuration() -> anyhow::Result<()> {
     success: false
     exit_code: 1
     ----- stdout -----
-    warning: lint:division-by-zero
+    warning: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
      --> <temp_dir>/project/main.py:2:5
       |
     2 | y = 4 / 0
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ^^^^^
     3 |
-    4 | for a in range(0, y):
+    4 | for a in range(0, int(y)):
       |
 
-    error: lint:possibly-unresolved-reference
+    error: lint:possibly-unresolved-reference: Name `x` used when possibly not defined
      --> <temp_dir>/project/main.py:7:7
       |
     5 |     x = a
     6 |
     7 | print(x)
-      |       ^ Name `x` used when possibly not defined
+      |       ^
       |
 
     Found 2 diagnostics
@@ -935,25 +935,25 @@ fn check_specific_paths() -> anyhow::Result<()> {
     success: false
     exit_code: 1
     ----- stdout -----
-    error: lint:unresolved-import
+    error: lint:unresolved-import: Cannot resolve import `does_not_exist`
      --> <temp_dir>/project/tests/test_main.py:2:8
       |
     2 | import does_not_exist  # error: unresolved-import
-      |        ^^^^^^^^^^^^^^ Cannot resolve import `does_not_exist`
+      |        ^^^^^^^^^^^^^^
       |
 
-    error: lint:division-by-zero
+    error: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
      --> <temp_dir>/project/main.py:2:5
       |
     2 | y = 4 / 0  # error: division-by-zero
-      |     ^^^^^ Cannot divide object of type `Literal[4]` by zero
+      |     ^^^^^
       |
 
-    error: lint:unresolved-import
+    error: lint:unresolved-import: Cannot resolve import `main2`
      --> <temp_dir>/project/other.py:2:6
       |
     2 | from main2 import z  # error: unresolved-import
-      |      ^^^^^ Cannot resolve import `main2`
+      |      ^^^^^
     3 |
     4 | print(z)
       |
@@ -972,18 +972,18 @@ fn check_specific_paths() -> anyhow::Result<()> {
     success: false
     exit_code: 1
     ----- stdout -----
-    error: lint:unresolved-import
+    error: lint:unresolved-import: Cannot resolve import `does_not_exist`
      --> <temp_dir>/project/tests/test_main.py:2:8
       |
     2 | import does_not_exist  # error: unresolved-import
-      |        ^^^^^^^^^^^^^^ Cannot resolve import `does_not_exist`
+      |        ^^^^^^^^^^^^^^
       |
 
-    error: lint:unresolved-import
+    error: lint:unresolved-import: Cannot resolve import `main2`
      --> <temp_dir>/project/other.py:2:6
       |
     2 | from main2 import z  # error: unresolved-import
-      |      ^^^^^ Cannot resolve import `main2`
+      |      ^^^^^
     3 |
     4 | print(z)
       |

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};
+    use red_knot_python_semantic::{default_lint_registry, Db as SemanticDb, Program};
     use ruff_db::files::{File, Files};
     use ruff_db::system::{DbWithTestSystem, System, TestSystem};
     use ruff_db::vendored::VendoredFileSystem;
@@ -83,6 +83,10 @@ pub(crate) mod tests {
         fn files(&self) -> &Files {
             &self.files
         }
+
+        fn python_version(&self) -> ruff_python_ast::PythonVersion {
+            Program::get(self).python_version(self)
+        }
     }
 
     impl Upcast<dyn SourceDb> for TestDb {

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

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

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

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

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

@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+def foo(a: foo()):
+    pass

crates/red_knot_project/src/db.rs

@@ -149,6 +149,10 @@ impl SourceDb for ProjectDatabase {
     fn files(&self) -> &Files {
         &self.files
     }
+
+    fn python_version(&self) -> ruff_python_ast::PythonVersion {
+        Program::get(self).python_version(self)
+    }
 }
 
 #[salsa::db]
@@ -207,7 +211,7 @@ pub(crate) mod tests {
     use salsa::Event;
 
     use red_knot_python_semantic::lint::{LintRegistry, RuleSelection};
-    use red_knot_python_semantic::Db as SemanticDb;
+    use red_knot_python_semantic::{Db as SemanticDb, Program};
     use ruff_db::files::Files;
     use ruff_db::system::{DbWithTestSystem, System, TestSystem};
     use ruff_db::vendored::VendoredFileSystem;
@@ -281,6 +285,10 @@ pub(crate) mod tests {
         fn files(&self) -> &Files {
             &self.files
         }
+
+        fn python_version(&self) -> ruff_python_ast::PythonVersion {
+            Program::get(self).python_version(self)
+        }
     }
 
     impl Upcast<dyn SemanticDb> for TestDb {

crates/red_knot_project/src/lib.rs

@@ -10,7 +10,8 @@ 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, Annotation, Diagnostic, DiagnosticId, Severity, Span,
+    create_parse_diagnostic, create_unsupported_syntax_diagnostic, Annotation, Diagnostic,
+    DiagnosticId, Severity, Span,
 };
 use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
@@ -313,20 +314,23 @@ impl Project {
     /// * It has a [`SystemPath`] and belongs to a package's `src` files
     /// * It has a [`SystemVirtualPath`](ruff_db::system::SystemVirtualPath)
     pub fn is_file_open(self, db: &dyn Db, file: File) -> bool {
+        let path = file.path(db);
+
+        // Try to return early to avoid adding a dependency on `open_files` or `file_set` which
+        // both have a durability of `LOW`.
+        if path.is_vendored_path() {
+            return false;
+        }
+
         if let Some(open_files) = self.open_files(db) {
             open_files.contains(&file)
         } else if file.path(db).is_system_path() {
-            self.contains_file(db, file)
+            self.files(db).contains(&file)
         } else {
             file.path(db).is_system_virtual_path()
         }
     }
 
-    /// Returns `true` if `file` is a first-party file part of this package.
-    pub fn contains_file(self, db: &dyn Db, file: File) -> bool {
-        self.files(db).contains(&file)
-    }
-
     #[tracing::instrument(level = "debug", skip(self, db))]
     pub fn remove_file(self, db: &mut dyn Db, file: File) {
         tracing::debug!(
@@ -424,6 +428,13 @@ 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| {
@@ -520,11 +531,13 @@ 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<()> {
@@ -532,6 +545,16 @@ mod tests {
         let mut db = TestDb::new(project);
         let path = SystemPath::new("test.py");
 
+        Program::from_settings(
+            &db,
+            ProgramSettings {
+                python_version: PythonVersion::default(),
+                python_platform: PythonPlatform::default(),
+                search_paths: SearchPathSettings::new(vec![SystemPathBuf::from(".")]),
+            },
+        )
+        .expect("Failed to configure program settings");
+
         db.write_file(path, "x = 10")?;
         let file = system_path_to_file(&db, path).unwrap();
 

crates/red_knot_project/tests/check.rs

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

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

@@ -50,10 +50,9 @@ y: Any = "not an Any"  # error: [invalid-assignment]
 
 The spec allows you to define subclasses of `Any`.
 
-TODO: Handle assignments correctly. `Subclass` has an unknown superclass, which might be `int`. The
-assignment to `x` should not be allowed, even when the unknown superclass is `int`. The assignment
-to `y` should be allowed, since `Subclass` might have `int` as a superclass, and is therefore
-assignable to `int`.
+`Subclass` has an unknown superclass, which might be `int`. The assignment to `x` should not be
+allowed, even when the unknown superclass is `int`. The assignment to `y` should be allowed, since
+`Subclass` might have `int` as a superclass, and is therefore assignable to `int`.
 
 ```py
 from typing import Any
@@ -63,13 +62,33 @@ class Subclass(Any): ...
 reveal_type(Subclass.__mro__)  # revealed: tuple[Literal[Subclass], Any, Literal[object]]
 
 x: Subclass = 1  # error: [invalid-assignment]
-# TODO: no diagnostic
-y: int = Subclass()  # error: [invalid-assignment]
+y: int = Subclass()
 
 def _(s: Subclass):
     reveal_type(s)  # revealed: Subclass
 ```
 
+`Subclass` should not be assignable to a final class though, because `Subclass` could not possibly
+be a subclass of `FinalClass`:
+
+```py
+from typing import final
+
+@final
+class FinalClass: ...
+
+f: FinalClass = Subclass()  # error: [invalid-assignment]
+```
+
+A use case where this comes up is with mocking libraries, where the mock object should be assignable
+to any type:
+
+```py
+from unittest.mock import MagicMock
+
+x: int = MagicMock()
+```
+
 ## Invalid
 
 `Any` cannot be parameterized:

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

@@ -237,6 +237,11 @@ def _(c: Callable[[Concatenate[int, str, ...], int], int]):
 
 ## Using `typing.ParamSpec`
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 Using a `ParamSpec` in a `Callable` annotation:
 
 ```py

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

@@ -48,6 +48,11 @@ 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
 
@@ -94,6 +99,11 @@ class Foo:
 
 ## Non-deferred self-reference annotations in a class definition
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 ```py
 class Foo:
     # error: [unresolved-reference]
@@ -146,3 +156,24 @@ 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/invalid.md

@@ -56,40 +56,41 @@ def _(
 def bar() -> None:
     return None
 
-def _(
-    a: 1,  # error: [invalid-type-form] "Int literals are not allowed in this context in a type expression"
-    b: 2.3,  # error: [invalid-type-form] "Float literals are not allowed in type expressions"
-    c: 4j,  # error: [invalid-type-form] "Complex literals are not allowed in type expressions"
-    d: True,  # error: [invalid-type-form] "Boolean literals are not allowed in this context in a type expression"
-    e: int | b"foo",  # error: [invalid-type-form] "Bytes literals are not allowed in this context in a type expression"
-    f: 1 and 2,  # error: [invalid-type-form] "Boolean operations are not allowed in type expressions"
-    g: 1 or 2,  # error: [invalid-type-form] "Boolean operations are not allowed in type expressions"
-    h: (foo := 1),  # error: [invalid-type-form] "Named expressions are not allowed in type expressions"
-    i: not 1,  # error: [invalid-type-form] "Unary operations are not allowed in type expressions"
-    j: lambda: 1,  # error: [invalid-type-form] "`lambda` expressions are not allowed in type expressions"
-    k: 1 if True else 2,  # error: [invalid-type-form] "`if` expressions are not allowed in type expressions"
-    l: await 1,  # error: [invalid-type-form] "`await` expressions are not allowed in type expressions"
-    m: (yield 1),  # error: [invalid-type-form] "`yield` expressions are not allowed in type expressions"
-    n: (yield from [1]),  # error: [invalid-type-form] "`yield from` expressions are not allowed in type expressions"
-    o: 1 < 2,  # error: [invalid-type-form] "Comparison expressions are not allowed in type expressions"
-    p: bar(),  # error: [invalid-type-form] "Function calls are not allowed in type expressions"
-    q: int | f"foo",  # error: [invalid-type-form] "F-strings are not allowed in type expressions"
-    r: [1, 2, 3][1:2],  # error: [invalid-type-form] "Slices are not allowed in type expressions"
-):
-    reveal_type(a)  # revealed: Unknown
-    reveal_type(b)  # revealed: Unknown
-    reveal_type(c)  # revealed: Unknown
-    reveal_type(d)  # revealed: Unknown
-    reveal_type(e)  # revealed: int | Unknown
-    reveal_type(f)  # revealed: Unknown
-    reveal_type(g)  # revealed: Unknown
-    reveal_type(h)  # revealed: Unknown
-    reveal_type(i)  # revealed: Unknown
-    reveal_type(j)  # revealed: Unknown
-    reveal_type(k)  # revealed: Unknown
-    reveal_type(p)  # revealed: Unknown
-    reveal_type(q)  # revealed: int | Unknown
-    reveal_type(r)  # revealed: @Todo(generics)
+async def outer():  # avoid unrelated syntax errors on yield, yield from, and await
+    def _(
+        a: 1,  # error: [invalid-type-form] "Int literals are not allowed in this context in a type expression"
+        b: 2.3,  # error: [invalid-type-form] "Float literals are not allowed in type expressions"
+        c: 4j,  # error: [invalid-type-form] "Complex literals are not allowed in type expressions"
+        d: True,  # error: [invalid-type-form] "Boolean literals are not allowed in this context in a type expression"
+        e: int | b"foo",  # error: [invalid-type-form] "Bytes literals are not allowed in this context in a type expression"
+        f: 1 and 2,  # error: [invalid-type-form] "Boolean operations are not allowed in type expressions"
+        g: 1 or 2,  # error: [invalid-type-form] "Boolean operations are not allowed in type expressions"
+        h: (foo := 1),  # error: [invalid-type-form] "Named expressions are not allowed in type expressions"
+        i: not 1,  # error: [invalid-type-form] "Unary operations are not allowed in type expressions"
+        j: lambda: 1,  # error: [invalid-type-form] "`lambda` expressions are not allowed in type expressions"
+        k: 1 if True else 2,  # error: [invalid-type-form] "`if` expressions are not allowed in type expressions"
+        l: await 1,  # error: [invalid-type-form] "`await` expressions are not allowed in type expressions"
+        m: (yield 1),  # error: [invalid-type-form] "`yield` expressions are not allowed in type expressions"
+        n: (yield from [1]),  # error: [invalid-type-form] "`yield from` expressions are not allowed in type expressions"
+        o: 1 < 2,  # error: [invalid-type-form] "Comparison expressions are not allowed in type expressions"
+        p: bar(),  # error: [invalid-type-form] "Function calls are not allowed in type expressions"
+        q: int | f"foo",  # error: [invalid-type-form] "F-strings are not allowed in type expressions"
+        r: [1, 2, 3][1:2],  # error: [invalid-type-form] "Slices are not allowed in type expressions"
+    ):
+        reveal_type(a)  # revealed: Unknown
+        reveal_type(b)  # revealed: Unknown
+        reveal_type(c)  # revealed: Unknown
+        reveal_type(d)  # revealed: Unknown
+        reveal_type(e)  # revealed: int | Unknown
+        reveal_type(f)  # revealed: Unknown
+        reveal_type(g)  # revealed: Unknown
+        reveal_type(h)  # revealed: Unknown
+        reveal_type(i)  # revealed: Unknown
+        reveal_type(j)  # revealed: Unknown
+        reveal_type(k)  # revealed: Unknown
+        reveal_type(p)  # revealed: Unknown
+        reveal_type(q)  # revealed: int | Unknown
+        reveal_type(r)  # revealed: @Todo(unknown type subscript)
 ```
 
 ## Invalid Collection based AST nodes

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

@@ -68,7 +68,7 @@ def x(
     a3: Literal[Literal["w"], Literal["r"], Literal[Literal["w+"]]],
     a4: Literal[True] | Literal[1, 2] | Literal["foo"],
 ):
-    reveal_type(a1)  # revealed: Literal[1, 2, 3, "foo", 5] | None
+    reveal_type(a1)  # revealed: Literal[1, 2, 3, 5, "foo"] | None
     reveal_type(a2)  # revealed: Literal["w", "r"]
     reveal_type(a3)  # revealed: Literal["w", "r", "w+"]
     reveal_type(a4)  # revealed: Literal[True, 1, 2, "foo"]
@@ -108,7 +108,7 @@ def union_example(
         None,
     ],
 ):
-    reveal_type(x)  # revealed: Unknown | Literal[-1, "A", b"A", b"\x00", b"\x07", 0, 1, "B", "foo", "bar", True] | None
+    reveal_type(x)  # revealed: Unknown | Literal[-1, 0, 1, "A", "B", "foo", "bar", b"A", b"\x00", b"\x07", True] | None
 ```
 
 ## Detecting Literal outside typing and typing_extensions
@@ -137,7 +137,7 @@ from other import Literal
 a1: Literal[26]
 
 def f():
-    reveal_type(a1)  # revealed: @Todo(generics)
+    reveal_type(a1)  # revealed: @Todo(unknown type subscript)
 ```
 
 ## Detecting typing_extensions.Literal

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

@@ -72,13 +72,11 @@ reveal_type(baz)  # revealed: Literal["bazfoo"]
 qux = (foo, bar)
 reveal_type(qux)  # revealed: tuple[Literal["foo"], Literal["bar"]]
 
-# TODO: Infer "LiteralString"
-reveal_type(foo.join(qux))  # revealed: @Todo(return type of overloaded function)
+reveal_type(foo.join(qux))  # revealed: LiteralString
 
 template: LiteralString = "{}, {}"
 reveal_type(template)  # revealed: Literal["{}, {}"]
-# TODO: Infer `LiteralString`
-reveal_type(template.format(foo, bar))  # revealed: @Todo(return type of overloaded function)
+reveal_type(template.format(foo, bar))  # revealed: LiteralString
 ```
 
 ### Assignability

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

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

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

@@ -67,21 +67,24 @@ import typing
 
 ####################
 ### Built-ins
+####################
 
 class ListSubclass(typing.List): ...
 
-# revealed: tuple[Literal[ListSubclass], Literal[list], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(protocol), Literal[object]]
+# TODO: generic protocols
+# revealed: tuple[Literal[ListSubclass], Literal[list], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), @Todo(`Generic[]` subscript), Literal[object]]
 reveal_type(ListSubclass.__mro__)
 
 class DictSubclass(typing.Dict): ...
 
-# TODO: should have `Generic`, should not have `Unknown`
-# revealed: tuple[Literal[DictSubclass], Literal[dict], Unknown, Literal[object]]
+# TODO: generic protocols
+# revealed: tuple[Literal[DictSubclass], Literal[dict], Literal[MutableMapping], Literal[Mapping], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), @Todo(`Generic[]` subscript), Literal[object]]
 reveal_type(DictSubclass.__mro__)
 
 class SetSubclass(typing.Set): ...
 
-# revealed: tuple[Literal[SetSubclass], Literal[set], Literal[MutableSet], Literal[AbstractSet], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(protocol), Literal[object]]
+# TODO: generic protocols
+# revealed: tuple[Literal[SetSubclass], Literal[set], Literal[MutableSet], Literal[AbstractSet], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), @Todo(`Generic[]` subscript), Literal[object]]
 reveal_type(SetSubclass.__mro__)
 
 class FrozenSetSubclass(typing.FrozenSet): ...
@@ -92,33 +95,35 @@ reveal_type(FrozenSetSubclass.__mro__)
 
 ####################
 ### `collections`
+####################
 
 class ChainMapSubclass(typing.ChainMap): ...
 
-# TODO: Should be (ChainMapSubclass, ChainMap, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
-# revealed: tuple[Literal[ChainMapSubclass], Literal[ChainMap], Unknown, Literal[object]]
+# TODO: generic protocols
+# revealed: tuple[Literal[ChainMapSubclass], Literal[ChainMap], Literal[MutableMapping], Literal[Mapping], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), @Todo(`Generic[]` subscript), Literal[object]]
 reveal_type(ChainMapSubclass.__mro__)
 
 class CounterSubclass(typing.Counter): ...
 
 # TODO: Should be (CounterSubclass, Counter, dict, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
-# revealed: tuple[Literal[CounterSubclass], Literal[Counter], Unknown, Literal[object]]
+# revealed: tuple[Literal[CounterSubclass], Literal[Counter], @Todo(GenericAlias instance), @Todo(`Generic[]` subscript), Literal[object]]
 reveal_type(CounterSubclass.__mro__)
 
 class DefaultDictSubclass(typing.DefaultDict): ...
 
 # TODO: Should be (DefaultDictSubclass, defaultdict, dict, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
-# revealed: tuple[Literal[DefaultDictSubclass], Literal[defaultdict], Unknown, Literal[object]]
+# revealed: tuple[Literal[DefaultDictSubclass], Literal[defaultdict], @Todo(GenericAlias instance), Literal[object]]
 reveal_type(DefaultDictSubclass.__mro__)
 
 class DequeSubclass(typing.Deque): ...
 
-# revealed: tuple[Literal[DequeSubclass], Literal[deque], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(protocol), Literal[object]]
+# TODO: generic protocols
+# revealed: tuple[Literal[DequeSubclass], Literal[deque], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), @Todo(`Generic[]` subscript), Literal[object]]
 reveal_type(DequeSubclass.__mro__)
 
 class OrderedDictSubclass(typing.OrderedDict): ...
 
 # TODO: Should be (OrderedDictSubclass, OrderedDict, dict, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
-# revealed: tuple[Literal[OrderedDictSubclass], Literal[OrderedDict], Unknown, Literal[object]]
+# revealed: tuple[Literal[OrderedDictSubclass], Literal[OrderedDict], @Todo(GenericAlias instance), Literal[object]]
 reveal_type(OrderedDictSubclass.__mro__)
 ```

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

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

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

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

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

@@ -25,6 +25,11 @@ x = "foo"  # error: [invalid-assignment] "Object of type `Literal["foo"]` is not
 
 ## Tuple annotations are understood
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 `module.py`:
 
 ```py
@@ -56,7 +61,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(generics), @Todo(generics)]
+reveal_type(h)  # revealed: tuple[@Todo(specialized non-generic class), @Todo(specialized non-generic class)]
 
 reveal_type(i)  # revealed: tuple[str | int, str | int]
 reveal_type(j)  # revealed: tuple[str | int]

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -302,7 +302,7 @@ class C:
 
 c_instance = C()
 reveal_type(c_instance.a)  # revealed: Unknown | Literal[1]
-reveal_type(c_instance.b)  # revealed: Unknown | @Todo(starred unpacking)
+reveal_type(c_instance.b)  # revealed: Unknown
 ```
 
 #### Attributes defined in for-loop (unpacking)
@@ -397,15 +397,27 @@ class IntIterable:
     def __iter__(self) -> IntIterator:
         return IntIterator()
 
+class TupleIterator:
+    def __next__(self) -> tuple[int, str]:
+        return (1, "a")
+
+class TupleIterable:
+    def __iter__(self) -> TupleIterator:
+        return TupleIterator()
+
 class C:
     def __init__(self) -> None:
         [... for self.a in IntIterable()]
+        [... for (self.b, self.c) in TupleIterable()]
+        [... for self.d in IntIterable() for self.e in IntIterable()]
 
 c_instance = C()
 
-# TODO: Should be `Unknown | int`
-# error: [unresolved-attribute]
-reveal_type(c_instance.a)  # revealed: Unknown
+reveal_type(c_instance.a)  # revealed: Unknown | int
+reveal_type(c_instance.b)  # revealed: Unknown | int
+reveal_type(c_instance.c)  # revealed: Unknown | str
+reveal_type(c_instance.d)  # revealed: Unknown | int
+reveal_type(c_instance.e)  # revealed: Unknown | int
 ```
 
 #### Conditionally declared / bound attributes
@@ -1665,7 +1677,7 @@ functions are instances of that class:
 def f(): ...
 
 reveal_type(f.__defaults__)  # revealed: @Todo(full tuple[...] support) | None
-reveal_type(f.__kwdefaults__)  # revealed: @Todo(generics) | None
+reveal_type(f.__kwdefaults__)  # revealed: @Todo(specialized non-generic class) | None
 ```
 
 Some attributes are special-cased, however:
@@ -1698,9 +1710,9 @@ Most attribute accesses on bool-literal types are delegated to `builtins.bool`,
 bools are instances of that class:
 
 ```py
-# revealed: bound method Literal[True].__and__(**kwargs: @Todo(todo signature **kwargs)) -> @Todo(return type of overloaded function)
+# revealed: Overload[(value: bool, /) -> bool, (value: int, /) -> int]
 reveal_type(True.__and__)
-# revealed: bound method Literal[False].__or__(**kwargs: @Todo(todo signature **kwargs)) -> @Todo(return type of overloaded function)
+# revealed: Overload[(value: bool, /) -> bool, (value: int, /) -> int]
 reveal_type(False.__or__)
 ```
 
@@ -1716,7 +1728,8 @@ reveal_type(False.real)  # revealed: Literal[0]
 All attribute access on literal `bytes` types is currently delegated to `builtins.bytes`:
 
 ```py
-reveal_type(b"foo".join)  # revealed: bound method Literal[b"foo"].join(iterable_of_bytes: @Todo(generics), /) -> bytes
+# revealed: bound method Literal[b"foo"].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)
 ```
@@ -1819,6 +1832,89 @@ def f(never: Never):
     never.another_attribute = never
 ```
 
+### Cyclic implicit attributes
+
+Inferring types for undeclared implicit attributes can be cyclic:
+
+```py
+class C:
+    def __init__(self):
+        self.x = 1
+
+    def copy(self, other: "C"):
+        self.x = other.x
+
+reveal_type(C().x)  # revealed: Unknown | Literal[1]
+```
+
+If the only assignment to a name is cyclic, we just infer `Unknown` for that attribute:
+
+```py
+class D:
+    def copy(self, other: "D"):
+        self.x = other.x
+
+reveal_type(D().x)  # revealed: Unknown
+```
+
+If there is an annotation for a name, we don't try to infer any type from the RHS of assignments to
+that name, so these cases don't trigger any cycle:
+
+```py
+class E:
+    def __init__(self):
+        self.x: int = 1
+
+    def copy(self, other: "E"):
+        self.x = other.x
+
+reveal_type(E().x)  # revealed: int
+
+class F:
+    def __init__(self):
+        self.x = 1
+
+    def copy(self, other: "F"):
+        self.x: int = other.x
+
+reveal_type(F().x)  # revealed: int
+
+class G:
+    def copy(self, other: "G"):
+        self.x: int = other.x
+
+reveal_type(G().x)  # revealed: int
+```
+
+We can even handle cycles involving multiple classes:
+
+```py
+class A:
+    def __init__(self):
+        self.x = 1
+
+    def copy(self, other: "B"):
+        self.x = other.x
+
+class B:
+    def copy(self, other: "A"):
+        self.x = other.x
+
+reveal_type(B().x)  # revealed: Unknown | Literal[1]
+reveal_type(A().x)  # revealed: Unknown | Literal[1]
+```
+
+This case additionally tests our union/intersection simplification logic:
+
+```py
+class H:
+    def __init__(self):
+        self.x = 1
+
+    def copy(self, other: "H"):
+        self.x = other.x or self.x
+```
+
 ### Builtin types attributes
 
 This test can probably be removed eventually, but we currently include it because we do not yet
@@ -1870,20 +1966,6 @@ 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

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

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

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

@@ -50,9 +50,11 @@ reveal_type(1 ** (largest_u32 + 1))  # revealed: int
 reveal_type(2**largest_u32)  # revealed: int
 
 def variable(x: int):
-    reveal_type(x**2)  # revealed: @Todo(return type of overloaded function)
-    reveal_type(2**x)  # revealed: @Todo(return type of overloaded function)
-    reveal_type(x**x)  # revealed: @Todo(return type of overloaded function)
+    reveal_type(x**2)  # revealed: int
+    # TODO: should be `Any` (overload 5 on `__pow__`), requires correct overload matching
+    reveal_type(2**x)  # revealed: int
+    # TODO: should be `Any` (overload 5 on `__pow__`), requires correct overload matching
+    reveal_type(x**x)  # revealed: int
 ```
 
 If the second argument is \<0, a `float` is returned at runtime. If the first argument is \<0 but

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

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

crates/red_knot_python_semantic/resources/mdtest/boundness_declaredness/public.md

@@ -292,3 +292,66 @@ reveal_type(a)  # revealed: Unknown
 # Modifications allowed in this case:
 a = None
 ```
+
+## In stub files
+
+In stub files, we have a minor modification to the rules above: we do not union with `Unknown` for
+undeclared symbols.
+
+### Undeclared and bound
+
+`mod.pyi`:
+
+```pyi
+MyInt = int
+
+class C:
+    MyStr = str
+```
+
+```py
+from mod import MyInt, C
+
+reveal_type(MyInt)  # revealed: Literal[int]
+reveal_type(C.MyStr)  # revealed: Literal[str]
+```
+
+### Undeclared and possibly unbound
+
+`mod.pyi`:
+
+```pyi
+def flag() -> bool:
+    return True
+
+if flag():
+    MyInt = int
+
+    class C:
+        MyStr = str
+```
+
+```py
+# error: [possibly-unbound-import]
+# error: [possibly-unbound-import]
+from mod import MyInt, C
+
+reveal_type(MyInt)  # revealed: Literal[int]
+reveal_type(C.MyStr)  # revealed: Literal[str]
+```
+
+### Undeclared and unbound
+
+`mod.pyi`:
+
+```pyi
+if False:
+    MyInt = int
+```
+
+```py
+# error: [unresolved-import]
+from mod import MyInt
+
+reveal_type(MyInt)  # revealed: Unknown
+```

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

@@ -21,6 +21,11 @@ reveal_type(get_int_async())  # revealed: @Todo(generic types.CoroutineType)
 
 ## Generic
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 ```py
 def get_int[T]() -> int:
     return 42

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

@@ -94,7 +94,7 @@ function object. We model this explicitly, which means that we can access `__kwd
 methods, even though it is not available on `types.MethodType`:
 
 ```py
-reveal_type(bound_method.__kwdefaults__)  # revealed: @Todo(generics) | None
+reveal_type(bound_method.__kwdefaults__)  # revealed: @Todo(specialized non-generic class) | None
 ```
 
 ## Basic method calls on class objects and instances
@@ -399,6 +399,11 @@ reveal_type(getattr_static(C, "f").__get__("dummy", C))  # revealed: bound metho
 
 ### 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:
 
@@ -410,29 +415,19 @@ def does_nothing[T](f: T) -> T:
 
 class C:
     @classmethod
-    # TODO: no error should be emitted here (needs support for generics)
-    # error: [invalid-argument-type]
     @does_nothing
     def f1(cls: type[C], x: int) -> str:
         return "a"
-    # TODO: no error should be emitted here (needs support for generics)
-    # error: [invalid-argument-type]
+
     @does_nothing
     @classmethod
     def f2(cls: type[C], x: int) -> str:
         return "a"
 
-# TODO: All of these should be `str` (and not emit an error), once we support generics
-
-# 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
+reveal_type(C.f1(1))  # revealed: str
+reveal_type(C().f1(1))  # revealed: str
+reveal_type(C.f2(1))  # revealed: str
+reveal_type(C().f2(1))  # revealed: str
 ```
 
 [functions and methods]: https://docs.python.org/3/howto/descriptor.html#functions-and-methods

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

@@ -162,6 +162,44 @@ def _(flag: bool):
     reveal_type(f("string"))  # revealed: Literal["string", "'string'"]
 ```
 
+## Unions with literals and negations
+
+```py
+from typing import Literal
+from knot_extensions import Not, AlwaysFalsy, static_assert, is_subtype_of, is_assignable_to
+
+static_assert(is_subtype_of(Literal["a", ""], Literal["a", ""] | Not[AlwaysFalsy]))
+static_assert(is_subtype_of(Not[AlwaysFalsy], Literal["", "a"] | Not[AlwaysFalsy]))
+static_assert(is_subtype_of(Literal["a", ""], Not[AlwaysFalsy] | Literal["a", ""]))
+static_assert(is_subtype_of(Not[AlwaysFalsy], Not[AlwaysFalsy] | Literal["a", ""]))
+
+static_assert(is_subtype_of(Literal["a", ""], Literal["a", ""] | Not[Literal[""]]))
+static_assert(is_subtype_of(Not[Literal[""]], Literal["a", ""] | Not[Literal[""]]))
+static_assert(is_subtype_of(Literal["a", ""], Not[Literal[""]] | Literal["a", ""]))
+static_assert(is_subtype_of(Not[Literal[""]], Not[Literal[""]] | Literal["a", ""]))
+
+def _(
+    a: Literal["a", ""] | Not[AlwaysFalsy],
+    b: Literal["a", ""] | Not[Literal[""]],
+    c: Literal[""] | Not[Literal[""]],
+    d: Not[Literal[""]] | Literal[""],
+    e: Literal["a"] | Not[Literal["a"]],
+    f: Literal[b"b"] | Not[Literal[b"b"]],
+    g: Not[Literal[b"b"]] | Literal[b"b"],
+    h: Literal[42] | Not[Literal[42]],
+    i: Not[Literal[42]] | Literal[42],
+):
+    reveal_type(a)  # revealed: Literal[""] | ~AlwaysFalsy
+    reveal_type(b)  # revealed: object
+    reveal_type(c)  # revealed: object
+    reveal_type(d)  # revealed: object
+    reveal_type(e)  # revealed: object
+    reveal_type(f)  # revealed: object
+    reveal_type(g)  # revealed: object
+    reveal_type(h)  # revealed: object
+    reveal_type(i)  # revealed: object
+```
+
 ## Cannot use an argument as both a value and a type form
 
 ```py
@@ -175,3 +213,41 @@ def _(flag: bool):
     # error: [conflicting-argument-forms] "Argument is used as both a value and a type form in call"
     reveal_type(f(int))  # revealed: str | Literal[True]
 ```
+
+## Size limit on unions of literals
+
+Beyond a certain size, large unions of literal types collapse to their nearest super-type (`int`,
+`bytes`, `str`).
+
+```py
+from typing import Literal
+
+def _(literals_2: Literal[0, 1], b: bool, flag: bool):
+    literals_4 = 2 * literals_2 + literals_2  # Literal[0, 1, 2, 3]
+    literals_16 = 4 * literals_4 + literals_4  # Literal[0, 1, .., 15]
+    literals_64 = 4 * literals_16 + literals_4  # Literal[0, 1, .., 63]
+    literals_128 = 2 * literals_64 + literals_2  # Literal[0, 1, .., 127]
+
+    # Going beyond the MAX_UNION_LITERALS limit (currently 200):
+    literals_256 = 16 * literals_16 + literals_16
+    reveal_type(literals_256)  # revealed: int
+
+    # Going beyond the limit when another type is already part of the union
+    bool_and_literals_128 = b if flag else literals_128  # bool | Literal[0, 1, ..., 127]
+    literals_128_shifted = literals_128 + 128  # Literal[128, 129, ..., 255]
+
+    # Now union the two:
+    reveal_type(bool_and_literals_128 if flag else literals_128_shifted)  # revealed: int
+```
+
+## Simplifying gradually-equivalent types
+
+If two types are gradually equivalent, we can keep just one of them in a union:
+
+```py
+from typing import Any, Union
+from knot_extensions import Intersection, Not
+
+def _(x: Union[Intersection[Any, Not[int]], Intersection[Any, Not[int]]]):
+    reveal_type(x)  # revealed: Any & ~int
+```

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

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

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

@@ -13,7 +13,7 @@ reveal_type(1 is not 1)  # revealed: bool
 reveal_type(1 is 2)  # revealed: Literal[False]
 reveal_type(1 is not 7)  # revealed: Literal[True]
 # error: [unsupported-operator] "Operator `<=` is not supported for types `int` and `str`, in comparing `Literal[1]` with `Literal[""]`"
-reveal_type(1 <= "" and 0 < 1)  # revealed: Unknown & ~AlwaysTruthy | Literal[True]
+reveal_type(1 <= "" and 0 < 1)  # revealed: (Unknown & ~AlwaysTruthy) | Literal[True]
 ```
 
 ## Integer instance

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

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

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

@@ -37,7 +37,7 @@ class C:
         return self
 
 x = A() < B() < C()
-reveal_type(x)  # revealed: A & ~AlwaysTruthy | B
+reveal_type(x)  # revealed: (A & ~AlwaysTruthy) | B
 
 y = 0 < 1 < A() < 3
 reveal_type(y)  # revealed: Literal[False] | A

crates/red_knot_python_semantic/resources/mdtest/comprehensions/basic.md

@@ -127,8 +127,9 @@ class AsyncIterable:
     def __aiter__(self) -> AsyncIterator:
         return AsyncIterator()
 
-# revealed: @Todo(async iterables/iterators)
-[reveal_type(x) async for x in AsyncIterable()]
+async def _():
+    # revealed: @Todo(async iterables/iterators)
+    [reveal_type(x) async for x in AsyncIterable()]
 ```
 
 ### Invalid async comprehension
@@ -145,6 +146,7 @@ class Iterable:
     def __iter__(self) -> Iterator:
         return Iterator()
 
-# revealed: @Todo(async iterables/iterators)
-[reveal_type(x) async for x in Iterable()]
+async def _():
+    # revealed: @Todo(async iterables/iterators)
+    [reveal_type(x) async for x in Iterable()]
 ```

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

@@ -42,6 +42,6 @@ def _(flag: bool):
 class NotBoolable:
     __bool__: int = 3
 
-# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`; its `__bool__` method isn't callable"
+# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`"
 3 if NotBoolable() else 4
 ```

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

@@ -154,10 +154,10 @@ def _(flag: bool):
 class NotBoolable:
     __bool__: int = 3
 
-# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`; its `__bool__` method isn't callable"
+# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`"
 if NotBoolable():
     ...
-# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`; its `__bool__` method isn't callable"
+# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`"
 elif NotBoolable():
     ...
 ```

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

@@ -1,5 +1,10 @@
 # Pattern matching
 
+```toml
+[environment]
+python-version = "3.10"
+```
+
 ## With wildcard
 
 ```py
@@ -287,7 +292,7 @@ class NotBoolable:
 def _(target: int, flag: NotBoolable):
     y = 1
     match target:
-        # error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`; its `__bool__` method isn't callable"
+        # error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`"
         case 1 if flag:
             y = 2
         case 2:

crates/red_knot_python_semantic/resources/mdtest/dataclass_transform.md

@@ -0,0 +1,293 @@
+# `typing.dataclass_transform`
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+`dataclass_transform` is a decorator that can be used to let type checkers know that a function,
+class, or metaclass is a `dataclass`-like construct.
+
+## Basic example
+
+```py
+from typing_extensions import dataclass_transform
+
+@dataclass_transform()
+def my_dataclass[T](cls: type[T]) -> type[T]:
+    # modify cls
+    return cls
+
+@my_dataclass
+class Person:
+    name: str
+    age: int | None = None
+
+Person("Alice", 20)
+Person("Bob", None)
+Person("Bob")
+
+# error: [missing-argument]
+Person()
+```
+
+## Decorating decorators that take parameters themselves
+
+If we want our `dataclass`-like decorator to also take parameters, that is also possible:
+
+```py
+from typing_extensions import dataclass_transform, Callable
+
+@dataclass_transform()
+def versioned_class[T](*, version: int = 1):
+    def decorator(cls):
+        # modify cls
+        return cls
+    return decorator
+
+@versioned_class(version=2)
+class Person:
+    name: str
+    age: int | None = None
+
+Person("Alice", 20)
+
+# error: [missing-argument]
+Person()
+```
+
+We properly type-check the arguments to the decorator:
+
+```py
+from typing_extensions import dataclass_transform, Callable
+
+# error: [invalid-argument-type]
+@versioned_class(version="a string")
+class C:
+    name: str
+```
+
+## Types of decorators
+
+The examples from this section are straight from the Python documentation on
+[`typing.dataclass_transform`].
+
+### Decorating a decorator function
+
+```py
+from typing_extensions import dataclass_transform
+
+@dataclass_transform()
+def create_model[T](cls: type[T]) -> type[T]:
+    ...
+    return cls
+
+@create_model
+class CustomerModel:
+    id: int
+    name: str
+
+CustomerModel(id=1, name="Test")
+```
+
+### Decorating a metaclass
+
+```py
+from typing_extensions import dataclass_transform
+
+@dataclass_transform()
+class ModelMeta(type): ...
+
+class ModelBase(metaclass=ModelMeta): ...
+
+class CustomerModel(ModelBase):
+    id: int
+    name: str
+
+CustomerModel(id=1, name="Test")
+
+# error: [missing-argument]
+CustomerModel()
+```
+
+### Decorating a base class
+
+```py
+from typing_extensions import dataclass_transform
+
+@dataclass_transform()
+class ModelBase: ...
+
+class CustomerModel(ModelBase):
+    id: int
+    name: str
+
+# TODO: this is not supported yet
+# error: [unknown-argument]
+# error: [unknown-argument]
+CustomerModel(id=1, name="Test")
+```
+
+## Arguments to `dataclass_transform`
+
+### `eq_default`
+
+`eq=True/False` does not have a observable effect (apart from a minor change regarding whether
+`other` is positional-only or not, which is not modelled at the moment).
+
+### `order_default`
+
+The `order_default` argument controls whether methods such as `__lt__` are generated by default.
+This can be overwritten using the `order` argument to the custom decorator:
+
+```py
+from typing_extensions import dataclass_transform
+
+@dataclass_transform()
+def normal(*, order: bool = False):
+    raise NotImplementedError
+
+@dataclass_transform(order_default=False)
+def order_default_false(*, order: bool = False):
+    raise NotImplementedError
+
+@dataclass_transform(order_default=True)
+def order_default_true(*, order: bool = True):
+    raise NotImplementedError
+
+@normal
+class Normal:
+    inner: int
+
+Normal(1) < Normal(2)  # error: [unsupported-operator]
+
+@normal(order=True)
+class NormalOverwritten:
+    inner: int
+
+NormalOverwritten(1) < NormalOverwritten(2)
+
+@order_default_false
+class OrderFalse:
+    inner: int
+
+OrderFalse(1) < OrderFalse(2)  # error: [unsupported-operator]
+
+@order_default_false(order=True)
+class OrderFalseOverwritten:
+    inner: int
+
+OrderFalseOverwritten(1) < OrderFalseOverwritten(2)
+
+@order_default_true
+class OrderTrue:
+    inner: int
+
+OrderTrue(1) < OrderTrue(2)
+
+@order_default_true(order=False)
+class OrderTrueOverwritten:
+    inner: int
+
+# error: [unsupported-operator]
+OrderTrueOverwritten(1) < OrderTrueOverwritten(2)
+```
+
+### `kw_only_default`
+
+To do
+
+### `field_specifiers`
+
+To do
+
+## Overloaded dataclass-like decorators
+
+In the case of an overloaded decorator, the `dataclass_transform` decorator can be applied to the
+implementation, or to *one* of the overloads.
+
+### Applying `dataclass_transform` to the implementation
+
+```py
+from typing_extensions import dataclass_transform, TypeVar, Callable, overload
+
+T = TypeVar("T", bound=type)
+
+@overload
+def versioned_class(
+    cls: T,
+    *,
+    version: int = 1,
+) -> T: ...
+@overload
+def versioned_class(
+    *,
+    version: int = 1,
+) -> Callable[[T], T]: ...
+@dataclass_transform()
+def versioned_class(
+    cls: T | None = None,
+    *,
+    version: int = 1,
+) -> T | Callable[[T], T]:
+    raise NotImplementedError
+
+@versioned_class
+class D1:
+    x: str
+
+@versioned_class(version=2)
+class D2:
+    x: str
+
+D1("a")
+D2("a")
+
+D1(1.2)  # error: [invalid-argument-type]
+D2(1.2)  # error: [invalid-argument-type]
+```
+
+### Applying `dataclass_transform` to an overload
+
+```py
+from typing_extensions import dataclass_transform, TypeVar, Callable, overload
+
+T = TypeVar("T", bound=type)
+
+@overload
+@dataclass_transform()
+def versioned_class(
+    cls: T,
+    *,
+    version: int = 1,
+) -> T: ...
+@overload
+def versioned_class(
+    *,
+    version: int = 1,
+) -> Callable[[T], T]: ...
+def versioned_class(
+    cls: T | None = None,
+    *,
+    version: int = 1,
+) -> T | Callable[[T], T]:
+    raise NotImplementedError
+
+@versioned_class
+class D1:
+    x: str
+
+@versioned_class(version=2)
+class D2:
+    x: str
+
+# TODO: these should not be errors
+D1("a")  # error: [too-many-positional-arguments]
+D2("a")  # error: [too-many-positional-arguments]
+
+# TODO: these should be invalid-argument-type errors
+D1(1.2)  # error: [too-many-positional-arguments]
+D2(1.2)  # error: [too-many-positional-arguments]
+```
+
+[`typing.dataclass_transform`]: https://docs.python.org/3/library/typing.html#typing.dataclass_transform

crates/red_knot_python_semantic/resources/mdtest/dataclasses.md

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

crates/red_knot_python_semantic/resources/mdtest/descriptor_protocol.md

@@ -459,11 +459,9 @@ class Descriptor:
 class C:
     d: Descriptor = Descriptor()
 
-# TODO: should be `Literal["called on class object"]
-reveal_type(C.d)  # revealed: LiteralString
+reveal_type(C.d)  # revealed: Literal["called on class object"]
 
-# TODO: should be `Literal["called on instance"]
-reveal_type(C().d)  # revealed: LiteralString
+reveal_type(C().d)  # revealed: Literal["called on instance"]
 ```
 
 ## Descriptor protocol for dunder methods

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

@@ -0,0 +1,165 @@
+# Semantic syntax error diagnostics
+
+## `async` comprehensions in synchronous comprehensions
+
+### Python 3.10
+
+<!-- snapshot-diagnostics -->
+
+Before Python 3.11, `async` comprehensions could not be used within outer sync comprehensions, even
+within an `async` function ([CPython issue](https://github.com/python/cpython/issues/77527)):
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+async def elements(n):
+    yield n
+
+async def f():
+    # error: 19 [invalid-syntax] "cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (syntax was added in 3.11)"
+    return {n: [x async for x in elements(n)] for n in range(3)}
+```
+
+If all of the comprehensions are `async`, on the other hand, the code was still valid:
+
+```py
+async def test():
+    return [[x async for x in elements(n)] async for n in range(3)]
+```
+
+These are a couple of tricky but valid cases to check that nested scope handling is wired up
+correctly in the `SemanticSyntaxContext` trait:
+
+```py
+async def f():
+    [x for x in [1]] and [x async for x in elements(1)]
+
+async def f():
+    def g():
+        pass
+    [x async for x in elements(1)]
+```
+
+### Python 3.11
+
+All of these same examples are valid after Python 3.11:
+
+```toml
+[environment]
+python-version = "3.11"
+```
+
+```py
+async def elements(n):
+    yield n
+
+async def f():
+    return {n: [x async for x in elements(n)] for n in range(3)}
+```
+
+## Late `__future__` import
+
+```py
+from collections import namedtuple
+
+# error: [invalid-syntax] "__future__ imports must be at the top of the file"
+from __future__ import print_function
+```
+
+## Invalid annotation
+
+This one might be a bit redundant with the `invalid-type-form` error.
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+from __future__ import annotations
+
+# error: [invalid-type-form] "Named expressions are not allowed in type expressions"
+# error: [invalid-syntax] "named expression cannot be used within a type annotation"
+def f() -> (y := 3): ...
+```
+
+## Duplicate `match` key
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+match 2:
+    # error: [invalid-syntax] "mapping pattern checks duplicate key `"x"`"
+    case {"x": 1, "x": 2}:
+        ...
+```
+
+## `return`, `yield`, `yield from`, and `await` outside function
+
+```py
+# error: [invalid-syntax] "`return` statement outside of a function"
+return
+
+# error: [invalid-syntax] "`yield` statement outside of a function"
+yield
+
+# error: [invalid-syntax] "`yield from` statement outside of a function"
+yield from []
+
+# error: [invalid-syntax] "`await` statement outside of a function"
+# error: [invalid-syntax] "`await` outside of an asynchronous function"
+await 1
+
+def f():
+    # error: [invalid-syntax] "`await` outside of an asynchronous function"
+    await 1
+```
+
+Generators are evaluated lazily, so `await` is allowed, even outside of a function.
+
+```py
+async def g():
+    yield 1
+
+(x async for x in g())
+```
+
+## `await` outside async function
+
+This error includes `await`, `async for`, `async with`, and `async` comprehensions.
+
+```python
+async def elements(n):
+    yield n
+
+def _():
+    # error: [invalid-syntax] "`await` outside of an asynchronous function"
+    await 1
+    # error: [invalid-syntax] "`async for` outside of an asynchronous function"
+    async for _ in elements(1):
+        ...
+    # error: [invalid-syntax] "`async with` outside of an asynchronous function"
+    async with elements(1) as x:
+        ...
+    # error: [invalid-syntax] "cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.9 (syntax was added in 3.11)"
+    # error: [invalid-syntax] "asynchronous comprehension outside of an asynchronous function"
+    [x async for x in elements(1)]
+```
+
+## Load before `global` declaration
+
+This should be an error, but it's not yet.
+
+TODO implement `SemanticSyntaxContext::global`
+
+```py
+def f():
+    x = 1
+    global x
+```

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

@@ -0,0 +1,19 @@
+# Shadowing
+
+<!-- snapshot-diagnostics -->
+
+## Implicit class shadowing
+
+```py
+class C: ...
+
+C = 1  # error: [invalid-assignment]
+```
+
+## Implicit function shadowing
+
+```py
+def f(): ...
+
+f = 1  # error: [invalid-assignment]
+```

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

@@ -8,14 +8,20 @@
 a, b = 1  # error: [not-iterable]
 ```
 
-## Too many values to unpack
+## Exactly too many values to unpack
 
 ```py
 a, b = (1, 2, 3)  # error: [invalid-assignment]
 ```
 
-## Too few values to unpack
+## Exactly too few values to unpack
 
 ```py
 a, b = (1,)  # error: [invalid-assignment]
 ```
+
+## Too few values to unpack
+
+```py
+[a, *b, c, d] = (1, 2)  # error: [invalid-assignment]
+```

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

@@ -0,0 +1,61 @@
+<!-- snapshot-diagnostics -->
+
+# Different ways that `unsupported-bool-conversion` can occur
+
+## Has a `__bool__` method, but has incorrect parameters
+
+```py
+class NotBoolable:
+    def __bool__(self, foo):
+        return False
+
+a = NotBoolable()
+
+# error: [unsupported-bool-conversion]
+10 and a and True
+```
+
+## Has a `__bool__` method, but has an incorrect return type
+
+```py
+class NotBoolable:
+    def __bool__(self) -> str:
+        return "wat"
+
+a = NotBoolable()
+
+# error: [unsupported-bool-conversion]
+10 and a and True
+```
+
+## Has a `__bool__` attribute, but it's not callable
+
+```py
+class NotBoolable:
+    __bool__: int = 3
+
+a = NotBoolable()
+
+# error: [unsupported-bool-conversion]
+10 and a and True
+```
+
+## Part of a union where at least one member has incorrect `__bool__` method
+
+```py
+class NotBoolable1:
+    def __bool__(self) -> str:
+        return "wat"
+
+class NotBoolable2:
+    pass
+
+class NotBoolable3:
+    __bool__: int = 3
+
+def get() -> NotBoolable1 | NotBoolable2 | NotBoolable3:
+    return NotBoolable2()
+
+# error: [unsupported-bool-conversion]
+10 and get() and True
+```

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

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

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

@@ -26,6 +26,11 @@ 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(generics)
+    reveal_type(a)  # revealed: @Todo(specialized non-generic class)
 
     b = cast(Any, y)
     reveal_type(b)  # revealed: Any

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

@@ -4,6 +4,6 @@
 class NotBoolable:
     __bool__: int = 3
 
-# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`; its `__bool__` method isn't callable"
+# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`"
 assert NotBoolable()
 ```

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

@@ -10,8 +10,8 @@ def _(foo: str):
     reveal_type(False or "z")  # revealed: Literal["z"]
     reveal_type(False or True)  # revealed: Literal[True]
     reveal_type(False or False)  # revealed: Literal[False]
-    reveal_type(foo or False)  # revealed: str & ~AlwaysFalsy | Literal[False]
-    reveal_type(foo or True)  # revealed: str & ~AlwaysFalsy | Literal[True]
+    reveal_type(foo or False)  # revealed: (str & ~AlwaysFalsy) | Literal[False]
+    reveal_type(foo or True)  # revealed: (str & ~AlwaysFalsy) | Literal[True]
 ```
 
 ## AND
@@ -20,8 +20,8 @@ def _(foo: str):
 def _(foo: str):
     reveal_type(True and False)  # revealed: Literal[False]
     reveal_type(False and True)  # revealed: Literal[False]
-    reveal_type(foo and False)  # revealed: str & ~AlwaysTruthy | Literal[False]
-    reveal_type(foo and True)  # revealed: str & ~AlwaysTruthy | Literal[True]
+    reveal_type(foo and False)  # revealed: (str & ~AlwaysTruthy) | Literal[False]
+    reveal_type(foo and True)  # revealed: (str & ~AlwaysTruthy) | Literal[True]
     reveal_type("x" and "y" and "z")  # revealed: Literal["z"]
     reveal_type("x" and "y" and "")  # revealed: Literal[""]
     reveal_type("" and "y")  # revealed: Literal[""]
@@ -123,7 +123,7 @@ if NotBoolable():
 class NotBoolable:
     __bool__: None = None
 
-# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`; its `__bool__` method isn't callable"
+# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`"
 if NotBoolable():
     ...
 ```
@@ -135,7 +135,7 @@ def test(cond: bool):
     class NotBoolable:
         __bool__: int | None = None if cond else 3
 
-    # error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`; its `__bool__` method isn't callable"
+    # error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`"
     if NotBoolable():
         ...
 ```
@@ -149,7 +149,7 @@ def test(cond: bool):
 
     a = 10 if cond else NotBoolable()
 
-    # error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `Literal[10] | NotBoolable`; its `__bool__` method isn't callable"
+    # error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `Literal[10] | NotBoolable`"
     if a:
         ...
 ```

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

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

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

@@ -1,5 +1,10 @@
 # Generic classes
 
+```toml
+[environment]
+python-version = "3.13"
+```
+
 ## PEP 695 syntax
 
 TODO: Add a `red_knot_extension` function that asserts whether a function or class is generic.
@@ -40,8 +45,6 @@ from typing import Generic, TypeVar
 
 T = TypeVar("T")
 
-# TODO: no error
-# error: [invalid-base]
 class C(Generic[T]): ...
 ```
 
@@ -149,23 +152,92 @@ If a typevar does not provide a default, we use `Unknown`:
 reveal_type(C())  # revealed: C[Unknown]
 ```
 
+## Inferring generic class parameters from constructors
+
 If the type of a constructor parameter is a class typevar, we can use that to infer the type
-parameter:
+parameter. The types inferred from a type context and from a constructor parameter must be
+consistent with each other.
+
+## `__new__` only
 
 ```py
-class E[T]:
-    def __init__(self, x: T) -> None: ...
+class C[T]:
+    def __new__(cls, x: T) -> "C[T]":
+        return object.__new__(cls)
 
-# TODO: revealed: E[int] or E[Literal[1]]
-reveal_type(E(1))  # revealed: E[Unknown]
+reveal_type(C(1))  # revealed: C[Literal[1]]
+
+# error: [invalid-assignment] "Object of type `C[Literal["five"]]` is not assignable to `C[int]`"
+wrong_innards: C[int] = C("five")
 ```
 
-The types inferred from a type context and from a constructor parameter must be consistent with each
-other:
+## `__init__` only
 
 ```py
-# TODO: error: [invalid-argument-type]
-wrong_innards: E[int] = E("five")
+class C[T]:
+    def __init__(self, x: T) -> None: ...
+
+reveal_type(C(1))  # revealed: C[Literal[1]]
+
+# error: [invalid-assignment] "Object of type `C[Literal["five"]]` is not assignable to `C[int]`"
+wrong_innards: C[int] = C("five")
+```
+
+## Identical `__new__` and `__init__` signatures
+
+```py
+class C[T]:
+    def __new__(cls, x: T) -> "C[T]":
+        return object.__new__(cls)
+
+    def __init__(self, x: T) -> None: ...
+
+reveal_type(C(1))  # revealed: C[Literal[1]]
+
+# error: [invalid-assignment] "Object of type `C[Literal["five"]]` is not assignable to `C[int]`"
+wrong_innards: C[int] = C("five")
+```
+
+## Compatible `__new__` and `__init__` signatures
+
+```py
+class C[T]:
+    def __new__(cls, *args, **kwargs) -> "C[T]":
+        return object.__new__(cls)
+
+    def __init__(self, x: T) -> None: ...
+
+reveal_type(C(1))  # revealed: C[Literal[1]]
+
+# error: [invalid-assignment] "Object of type `C[Literal["five"]]` is not assignable to `C[int]`"
+wrong_innards: C[int] = C("five")
+
+class D[T]:
+    def __new__(cls, x: T) -> "D[T]":
+        return object.__new__(cls)
+
+    def __init__(self, *args, **kwargs) -> None: ...
+
+reveal_type(D(1))  # revealed: D[Literal[1]]
+
+# error: [invalid-assignment] "Object of type `D[Literal["five"]]` is not assignable to `D[int]`"
+wrong_innards: D[int] = D("five")
+```
+
+## `__init__` is itself generic
+
+TODO: These do not currently work yet, because we don't correctly model the nested generic contexts.
+
+```py
+class C[T]:
+    def __init__[S](self, x: T, y: S) -> None: ...
+
+reveal_type(C(1, 1))  # revealed: C[Literal[1]]
+reveal_type(C(1, "string"))  # revealed: C[Literal[1]]
+reveal_type(C(1, True))  # 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", 1)
 ```
 
 ## Generic subclass
@@ -200,20 +272,19 @@ class C[T]:
     def cannot_shadow_class_typevar[T](self, t: T): ...
 
 c: C[int] = C[int]()
-# TODO: no error
-# TODO: revealed: str or Literal["string"]
-# error: [invalid-argument-type]
-reveal_type(c.method("string"))  # revealed: U
+reveal_type(c.method("string"))  # revealed: Literal["string"]
 ```
 
-## Cyclic class definition
+## Cyclic class definitions
+
+### F-bounded quantification
 
 A class can use itself as the type parameter of one of its superclasses. (This is also known as the
 [curiously recurring template pattern][crtp] or [F-bounded quantification][f-bound].)
 
-Here, `Sub` is not a generic class, since it fills its superclass's type parameter (with itself).
+#### In a stub file
 
-`stub.pyi`:
+Here, `Sub` is not a generic class, since it fills its superclass's type parameter (with itself).
 
 ```pyi
 class Base[T]: ...
@@ -222,9 +293,9 @@ class Sub(Base[Sub]): ...
 reveal_type(Sub)  # revealed: Literal[Sub]
 ```
 
-A similar case can work in a non-stub file, if forward references are stringified:
+#### With string forward references
 
-`string_annotation.py`:
+A similar case can work in a non-stub file, if forward references are stringified:
 
 ```py
 class Base[T]: ...
@@ -233,9 +304,9 @@ class Sub(Base["Sub"]): ...
 reveal_type(Sub)  # revealed: Literal[Sub]
 ```
 
-In a non-stub file, without stringified forward references, this raises a `NameError`:
+#### Without string forward references
 
-`bare_annotation.py`:
+In a non-stub file, without stringified forward references, this raises a `NameError`:
 
 ```py
 class Base[T]: ...
@@ -244,13 +315,23 @@ class Base[T]: ...
 class Sub(Base[Sub]): ...
 ```
 
-## Another cyclic case
+### Cyclic inheritance as a generic parameter
 
 ```pyi
-# TODO no error (generics)
-# error: [invalid-base]
 class Derived[T](list[Derived[T]]): ...
 ```
 
+### Direct cyclic inheritance
+
+Inheritance that would result in a cyclic MRO is detected as an error.
+
+```py
+# error: [cyclic-class-definition]
+class C[T](C): ...
+
+# error: [cyclic-class-definition]
+class D[T](D[int]): ...
+```
+
 [crtp]: https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
 [f-bound]: https://en.wikipedia.org/wiki/Bounded_quantification#F-bounded_quantification

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

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

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

@@ -1,5 +1,10 @@
 # PEP 695 Generics
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 [PEP 695] and Python 3.12 introduced new, more ergonomic syntax for type variables.
 
 ## Type variables
@@ -59,19 +64,19 @@ is.)
 from knot_extensions import is_fully_static, static_assert
 from typing import Any
 
-def unbounded_unconstrained[T](t: list[T]) -> None:
+def unbounded_unconstrained[T](t: T) -> None:
     static_assert(is_fully_static(T))
 
-def bounded[T: int](t: list[T]) -> None:
+def bounded[T: int](t: T) -> None:
     static_assert(is_fully_static(T))
 
-def bounded_by_gradual[T: Any](t: list[T]) -> None:
+def bounded_by_gradual[T: Any](t: T) -> None:
     static_assert(not is_fully_static(T))
 
-def constrained[T: (int, str)](t: list[T]) -> None:
+def constrained[T: (int, str)](t: T) -> None:
     static_assert(is_fully_static(T))
 
-def constrained_by_gradual[T: (int, Any)](t: list[T]) -> None:
+def constrained_by_gradual[T: (int, Any)](t: T) -> None:
     static_assert(not is_fully_static(T))
 ```
 
@@ -94,7 +99,7 @@ class Base(Super): ...
 class Sub(Base): ...
 class Unrelated: ...
 
-def unbounded_unconstrained[T, U](t: list[T], u: list[U]) -> None:
+def unbounded_unconstrained[T, U](t: T, u: U) -> None:
     static_assert(is_assignable_to(T, T))
     static_assert(is_assignable_to(T, object))
     static_assert(not is_assignable_to(T, Super))
@@ -124,7 +129,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: list[T]) -> None:
+def bounded[T: Super](t: T) -> None:
     static_assert(is_assignable_to(T, Super))
     static_assert(not is_assignable_to(T, Sub))
     static_assert(not is_assignable_to(Super, T))
@@ -135,7 +140,7 @@ def bounded[T: Super](t: list[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: list[T]) -> None:
+def bounded_by_gradual[T: Any](t: T) -> None:
     static_assert(is_assignable_to(T, Any))
     static_assert(is_assignable_to(Any, T))
     static_assert(is_assignable_to(T, Super))
@@ -153,7 +158,7 @@ def bounded_by_gradual[T: Any](t: list[T]) -> None:
 @final
 class FinalClass: ...
 
-def bounded_final[T: FinalClass](t: list[T]) -> None:
+def bounded_final[T: FinalClass](t: T) -> None:
     static_assert(is_assignable_to(T, FinalClass))
     static_assert(not is_assignable_to(FinalClass, T))
 
@@ -167,14 +172,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: list[T], u: list[U]) -> None:
+def two_bounded[T: Super, U: Super](t: T, u: U) -> None:
     static_assert(not is_assignable_to(T, U))
     static_assert(not is_assignable_to(U, T))
 
     static_assert(not is_subtype_of(T, U))
     static_assert(not is_subtype_of(U, T))
 
-def two_final_bounded[T: FinalClass, U: FinalClass](t: list[T], u: list[U]) -> None:
+def two_final_bounded[T: FinalClass, U: FinalClass](t: T, u: U) -> None:
     static_assert(not is_assignable_to(T, U))
     static_assert(not is_assignable_to(U, T))
 
@@ -189,7 +194,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: list[T]) -> None:
+def constrained[T: (Base, Unrelated)](t: T) -> None:
     static_assert(not is_assignable_to(T, Super))
     static_assert(not is_assignable_to(T, Base))
     static_assert(not is_assignable_to(T, Sub))
@@ -214,7 +219,7 @@ def constrained[T: (Base, Unrelated)](t: list[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: list[T]) -> None:
+def constrained_by_gradual[T: (Base, Any)](t: T) -> None:
     static_assert(is_assignable_to(T, Super))
     static_assert(is_assignable_to(T, Base))
     static_assert(not is_assignable_to(T, Sub))
@@ -256,7 +261,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: list[T], u: list[U]) -> None:
+def two_constrained[T: (int, str), U: (int, str)](t: T, u: U) -> None:
     static_assert(not is_assignable_to(T, U))
     static_assert(not is_assignable_to(U, T))
 
@@ -266,7 +271,7 @@ def two_constrained[T: (int, str), U: (int, str)](t: list[T], u: list[U]) -> Non
 @final
 class AnotherFinalClass: ...
 
-def two_final_constrained[T: (FinalClass, AnotherFinalClass), U: (FinalClass, AnotherFinalClass)](t: list[T], u: list[U]) -> None:
+def two_final_constrained[T: (FinalClass, AnotherFinalClass), U: (FinalClass, AnotherFinalClass)](t: T, u: U) -> None:
     static_assert(not is_assignable_to(T, U))
     static_assert(not is_assignable_to(U, T))
 
@@ -285,7 +290,7 @@ non-singleton type.
 ```py
 from knot_extensions import is_singleton, is_single_valued, static_assert
 
-def unbounded_unconstrained[T](t: list[T]) -> None:
+def unbounded_unconstrained[T](t: T) -> None:
     static_assert(not is_singleton(T))
     static_assert(not is_single_valued(T))
 ```
@@ -294,7 +299,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: list[T]) -> None:
+def bounded[T: None](t: T) -> None:
     static_assert(not is_singleton(T))
     static_assert(not is_single_valued(T))
 ```
@@ -305,14 +310,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: list[T]) -> None:
+def constrained_non_singletons[T: (int, str)](t: T) -> None:
     static_assert(not is_singleton(T))
     static_assert(not is_single_valued(T))
 
-def constrained_singletons[T: (Literal[True], Literal[False])](t: list[T]) -> None:
+def constrained_singletons[T: (Literal[True], Literal[False])](t: T) -> None:
     static_assert(is_singleton(T))
 
-def constrained_single_valued[T: (Literal[True], tuple[()])](t: list[T]) -> None:
+def constrained_single_valued[T: (Literal[True], tuple[()])](t: T) -> None:
     static_assert(is_single_valued(T))
 ```
 
@@ -507,6 +512,20 @@ 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,5 +1,10 @@
 # Scoping rules for type variables
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 Most of these tests come from the [Scoping rules for type variables][scoping] section of the typing
 spec.
 
@@ -59,14 +64,8 @@ to a different type each time.
 def f[T](x: T) -> T:
     return x
 
-# TODO: no error
-# TODO: revealed: int or Literal[1]
-# error: [invalid-argument-type]
-reveal_type(f(1))  # revealed: T
-# TODO: no error
-# TODO: revealed: str or Literal["a"]
-# error: [invalid-argument-type]
-reveal_type(f("a"))  # revealed: T
+reveal_type(f(1))  # revealed: Literal[1]
+reveal_type(f("a"))  # revealed: Literal["a"]
 ```
 
 ## Methods can mention class typevars
@@ -138,8 +137,6 @@ from typing import TypeVar, Generic
 T = TypeVar("T")
 S = TypeVar("S")
 
-# TODO: no error
-# error: [invalid-base]
 class Legacy(Generic[T]):
     def m(self, x: T, y: S) -> S:
         return y
@@ -157,10 +154,7 @@ class C[T]:
         return y
 
 c: C[int] = C()
-# TODO: no errors
-# TODO: revealed: str
-# error: [invalid-argument-type]
-reveal_type(c.m(1, "string"))  # revealed: S
+reveal_type(c.m(1, "string"))  # revealed: Literal["string"]
 ```
 
 ## Unbound typevars
@@ -178,13 +172,11 @@ S = TypeVar("S")
 
 def f(x: T) -> None:
     x: list[T] = []
-    # TODO: error
+    # TODO: invalid-assignment error
     y: list[S] = []
 
-# TODO: no error
-# error: [invalid-base]
 class C(Generic[T]):
-    # TODO: error
+    # TODO: error: cannot use S if it's not in the current generic context
     x: list[S] = []
 
     # This is not an error, as shown in the previous test
@@ -204,11 +196,11 @@ S = TypeVar("S")
 
 def f[T](x: T) -> None:
     x: list[T] = []
-    # TODO: error
+    # TODO: invalid assignment error
     y: list[S] = []
 
 class C[T]:
-    # TODO: error
+    # TODO: error: cannot use S if it's not in the current generic context
     x: list[S] = []
 
     def m1(self, x: S) -> S:
@@ -263,8 +255,7 @@ def f[T](x: T, y: T) -> None:
     class Ok[S]: ...
     # TODO: error for reuse of typevar
     class Bad1[T]: ...
-    # TODO: no non-subscriptable error, error for reuse of typevar
-    # error: [non-subscriptable]
+    # TODO: error for reuse of typevar
     class Bad2(Iterable[T]): ...
 ```
 
@@ -277,8 +268,7 @@ class C[T]:
     class Ok1[S]: ...
     # TODO: error for reuse of typevar
     class Bad1[T]: ...
-    # TODO: no non-subscriptable error, error for reuse of typevar
-    # error: [non-subscriptable]
+    # TODO: error for reuse of typevar
     class Bad2(Iterable[T]): ...
 ```
 
@@ -292,7 +282,7 @@ class C[T]:
     ok1: list[T] = []
 
     class Bad:
-        # TODO: error
+        # TODO: error: cannot refer to T in nested scope
         bad: list[T] = []
 
     class Inner[S]: ...

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

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

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

@@ -122,6 +122,11 @@ from c import Y  # error: [unresolved-import]
 
 ## Esoteric definitions and redefinintions
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 We understand all public symbols defined in an external module as being imported by a `*` import,
 not just those that are defined in `StmtAssign` nodes and `StmtAnnAssign` nodes. This section
 provides tests for definitions, and redefinitions, that use more esoteric AST nodes.
@@ -184,7 +189,7 @@ match 42:
         ...
     case [O]:
         ...
-    case P | Q:
+    case P | Q:  # error: [invalid-syntax] "name capture `P` makes remaining patterns unreachable"
         ...
     case object(foo=R):
         ...
@@ -284,7 +289,7 @@ match 42:
         ...
     case [D]:
         ...
-    case E | F:
+    case E | F:  # error: [invalid-syntax] "name capture `E` makes remaining patterns unreachable"
         ...
     case object(foo=G):
         ...
@@ -352,7 +357,7 @@ match 42:
         ...
     case [D]:
         ...
-    case E | F:
+    case E | F:  # error: [invalid-syntax] "name capture `E` makes remaining patterns unreachable"
         ...
     case object(foo=G):
         ...
@@ -626,6 +631,30 @@ reveal_type(X)  # revealed: Unknown
 reveal_type(Y)  # revealed: bool
 ```
 
+### An implicit import in a `.pyi` file later overridden by another assignment
+
+`a.pyi`:
+
+```pyi
+X: bool = True
+```
+
+`b.pyi`:
+
+```pyi
+from a import X
+
+X: bool = False
+```
+
+`c.py`:
+
+```py
+from b import *
+
+reveal_type(X)  # revealed: bool
+```
+
 ## Visibility constraints
 
 If an `importer` module contains a `from exporter import *` statement in its global namespace, the
@@ -865,15 +894,10 @@ from exporter import *
 
 reveal_type(X)  # revealed: bool
 
-# TODO none of these should error, should all reveal `bool`
-# error: [unresolved-reference]
-reveal_type(_private)  # revealed: Unknown
-# error: [unresolved-reference]
-reveal_type(__protected)  # revealed: Unknown
-# error: [unresolved-reference]
-reveal_type(__dunder__)  # revealed: Unknown
-# error: [unresolved-reference]
-reveal_type(___thunder___)  # revealed: Unknown
+reveal_type(_private)  # revealed: bool
+reveal_type(__protected)  # revealed: bool
+reveal_type(__dunder__)  # revealed: bool
+reveal_type(___thunder___)  # revealed: bool
 
 # TODO: should emit [unresolved-reference] diagnostic & reveal `Unknown`
 reveal_type(Y)  # revealed: bool
@@ -1072,6 +1096,44 @@ reveal_type(Y)  # revealed: bool
 reveal_type(Z)  # revealed: Unknown
 ```
 
+### `__all__` conditionally defined in a statically known branch (2)
+
+The same example again, but with a different `python-version` set:
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+`exporter.py`:
+
+```py
+import sys
+
+X: bool = True
+
+if sys.version_info >= (3, 11):
+    __all__ = ["X", "Y"]
+    Y: bool = True
+else:
+    __all__ = ("Z",)
+    Z: bool = True
+```
+
+`importer.py`:
+
+```py
+from exporter import *
+
+# TODO: should reveal `Unknown` and emit `[unresolved-reference]`
+reveal_type(X)  # revealed: bool
+
+# error: [unresolved-reference]
+reveal_type(Y)  # revealed: Unknown
+
+reveal_type(Z)  # revealed: bool
+```
+
 ### `__all__` conditionally mutated in a statically known branch
 
 ```toml
@@ -1084,11 +1146,11 @@ python-version = "3.11"
 ```py
 import sys
 
-__all__ = ["X"]
+__all__ = []
 X: bool = True
 
 if sys.version_info >= (3, 11):
-    __all__.append("Y")
+    __all__.extend(["X", "Y"])
     Y: bool = True
 else:
     __all__.append("Z")
@@ -1107,6 +1169,45 @@ reveal_type(Y)  # revealed: bool
 reveal_type(Z)  # revealed: Unknown
 ```
 
+### `__all__` conditionally mutated in a statically known branch (2)
+
+The same example again, but with a different `python-version` set:
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+`exporter.py`:
+
+```py
+import sys
+
+__all__ = []
+X: bool = True
+
+if sys.version_info >= (3, 11):
+    __all__.extend(["X", "Y"])
+    Y: bool = True
+else:
+    __all__.append("Z")
+    Z: bool = True
+```
+
+`importer.py`:
+
+```py
+from exporter import *
+
+# TODO: should reveal `Unknown` & emit `[unresolved-reference]
+reveal_type(X)  # revealed: bool
+
+# error: [unresolved-reference]
+reveal_type(Y)  # revealed: Unknown
+
+reveal_type(Z)  # revealed: bool
+```
+
 ### Empty `__all__`
 
 An empty `__all__` is valid, but a `*` import from a module with an empty `__all__` results in 0
@@ -1166,6 +1267,7 @@ from b import *
 
 # TODO: should not error, should reveal `bool`
 # (`X` is re-exported from `b.pyi` due to presence in `__all__`)
+# See https://github.com/astral-sh/ruff/issues/16159
 #
 # error: [unresolved-reference]
 reveal_type(X)  # revealed: Unknown

crates/red_knot_python_semantic/resources/mdtest/intersection_types.md

@@ -191,9 +191,9 @@ def _(
     i2: Intersection[P | Q | R, S],
     i3: Intersection[P | Q, R | S],
 ) -> None:
-    reveal_type(i1)  # revealed: P & Q | P & R | P & S
-    reveal_type(i2)  # revealed: P & S | Q & S | R & S
-    reveal_type(i3)  # revealed: P & R | Q & R | P & S | Q & S
+    reveal_type(i1)  # revealed: (P & Q) | (P & R) | (P & S)
+    reveal_type(i2)  # revealed: (P & S) | (Q & S) | (R & S)
+    reveal_type(i3)  # revealed: (P & R) | (Q & R) | (P & S) | (Q & S)
 
 def simplifications_for_same_elements(
     i1: Intersection[P, Q | P],
@@ -216,7 +216,7 @@ def simplifications_for_same_elements(
     # = P & Q | P & R | Q | Q & R
     # = Q | P & R
     # (again, because Q is a supertype of P & Q and of Q & R)
-    reveal_type(i3)  # revealed: Q | P & R
+    reveal_type(i3)  # revealed: Q | (P & R)
 
     #   (P | Q) & (P | Q)
     # = P & P | P & Q | Q & P | Q & Q
@@ -842,7 +842,7 @@ def unknown(
 
 ### Mixed dynamic types
 
-We currently do not simplify mixed dynamic types, but might consider doing so in the future:
+Gradually-equivalent types can be simplified out of intersections:
 
 ```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 & Unknown
-    reveal_type(i2)  # revealed: Any & Unknown
-    reveal_type(i3)  # revealed: Any & Unknown
-    reveal_type(i4)  # revealed: Any & Unknown
+    reveal_type(i1)  # revealed: Any
+    reveal_type(i2)  # revealed: Any
+    reveal_type(i3)  # revealed: Any
+    reveal_type(i4)  # revealed: Any
 ```
 
 ## Invalid

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

@@ -123,7 +123,7 @@ def _(flag: bool, flag2: bool):
 class NotBoolable:
     __bool__: int = 3
 
-# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`; its `__bool__` method isn't callable"
+# error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `NotBoolable`"
 while NotBoolable():
     ...
 ```

crates/red_knot_python_semantic/resources/mdtest/mdtest_custom_typeshed.md

@@ -22,6 +22,7 @@ We can then place custom stub files in `/typeshed/stdlib`, for example:
 `/typeshed/stdlib/builtins.pyi`:
 
 ```pyi
+class object: ...
 class BuiltinClass: ...
 
 builtin_symbol: BuiltinClass

crates/red_knot_python_semantic/resources/mdtest/metaclass.md

@@ -53,6 +53,25 @@ class B(A): ...
 reveal_type(B.__class__)  # revealed: Literal[M]
 ```
 
+## Linear inheritance with PEP 695 generic class
+
+The same is true if the base with the metaclass is a generic class.
+
+```toml
+[environment]
+python-version = "3.13"
+```
+
+```py
+class M(type): ...
+class A[T](metaclass=M): ...
+class B(A): ...
+class C(A[int]): ...
+
+reveal_type(B.__class__)  # revealed: Literal[M]
+reveal_type(C.__class__)  # revealed: Literal[M]
+```
+
 ## Conflict (1)
 
 The metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its
@@ -216,6 +235,11 @@ 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

@@ -0,0 +1,53 @@
+# 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[2]
+```
+
+## `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

@@ -10,7 +10,7 @@ def _(x: A | B):
     if isinstance(x, A) and isinstance(x, B):
         reveal_type(x)  # revealed:  A & B
     else:
-        reveal_type(x)  # revealed:  B & ~A | A & ~B
+        reveal_type(x)  # revealed:  (B & ~A) | (A & ~B)
 ```
 
 ## Arms might not add narrowing constraints
@@ -131,8 +131,8 @@ def _(x: A | B | C, y: A | B | C):
         # The same for `y`
         reveal_type(y)  # revealed:  A | B | C
     else:
-        reveal_type(x)  # revealed:  B & ~A | C & ~A
-        reveal_type(y)  # revealed:  B & ~A | C & ~A
+        reveal_type(x)  # revealed:  (B & ~A) | (C & ~A)
+        reveal_type(y)  # revealed:  (B & ~A) | (C & ~A)
 
     if (isinstance(x, A) and isinstance(y, A)) or (isinstance(x, B) and isinstance(y, B)):
         # Here, types of `x` and `y` can be narrowd since all `or` arms constraint them.
@@ -155,7 +155,7 @@ def _(x: A | B | C):
         reveal_type(x)  # revealed:  B & ~C
     else:
         # ~(B & ~C) -> ~B | C -> (A & ~B) | (C & ~B) | C -> (A & ~B) | C
-        reveal_type(x)  # revealed: A & ~B | C
+        reveal_type(x)  # revealed: (A & ~B) | C
 ```
 
 ## mixing `or` and `not`
@@ -167,7 +167,7 @@ class C: ...
 
 def _(x: A | B | C):
     if isinstance(x, B) or not isinstance(x, C):
-        reveal_type(x)  # revealed: B | A & ~C
+        reveal_type(x)  # revealed: B | (A & ~C)
     else:
         reveal_type(x)  # revealed: C & ~B
 ```
@@ -181,7 +181,7 @@ class C: ...
 
 def _(x: A | B | C):
     if isinstance(x, A) or (isinstance(x, B) and not isinstance(x, C)):
-        reveal_type(x)  # revealed:  A | B & ~C
+        reveal_type(x)  # revealed:  A | (B & ~C)
     else:
         # ~(A | (B & ~C)) -> ~A & ~(B & ~C) -> ~A & (~B | C) -> (~A & C) | (~A ~ B)
         reveal_type(x)  # revealed:  C & ~A
@@ -197,7 +197,7 @@ class C: ...
 def _(x: A | B | C):
     if isinstance(x, A) and (isinstance(x, B) or not isinstance(x, C)):
         # A & (B | ~C) -> (A & B) | (A & ~C)
-        reveal_type(x)  # revealed:  A & B | A & ~C
+        reveal_type(x)  # revealed:  (A & B) | (A & ~C)
     else:
         # ~((A & B) | (A & ~C)) ->
         # ~(A & B) & ~(A & ~C) ->
@@ -206,7 +206,7 @@ def _(x: A | B | C):
         # ~A | (~A & C) | (~B & C) ->
         # ~A | (C & ~B) ->
         # ~A | (C & ~B)  The positive side of ~A is  A | B | C ->
-        reveal_type(x)  # revealed:  B & ~A | C & ~A | C & ~B
+        reveal_type(x)  # revealed:  (B & ~A) | (C & ~A) | (C & ~B)
 ```
 
 ## Boolean expression internal narrowing
@@ -223,3 +223,15 @@ 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

@@ -20,11 +20,9 @@ def _(flag1: bool, flag2: bool):
     x = 1 if flag1 else 2 if flag2 else 3
 
     if x == 1:
-        # TODO should be Literal[1]
-        reveal_type(x)  # revealed: Literal[1, 2, 3]
+        reveal_type(x)  # revealed: Literal[1]
     elif x == 2:
-        # TODO should be Literal[2]
-        reveal_type(x)  # revealed: Literal[2, 3]
+        reveal_type(x)  # revealed: Literal[2]
     else:
         reveal_type(x)  # revealed: Literal[3]
 ```
@@ -38,12 +36,22 @@ def _(flag1: bool, flag2: bool):
     if x != 1:
         reveal_type(x)  # revealed: Literal[2, 3]
     elif x != 2:
-        # TODO should be `Literal[1]`
-        reveal_type(x)  # revealed: Literal[1, 3]
+        reveal_type(x)  # revealed: Literal[1]
     elif x == 3:
-        # TODO should be Never
-        reveal_type(x)  # revealed: Literal[1, 2, 3]
+        reveal_type(x)  # revealed: Never
     else:
-        # TODO should be Never
-        reveal_type(x)  # revealed: Literal[1, 2]
+        reveal_type(x)  # revealed: Never
+```
+
+## 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/eq.md

@@ -0,0 +1,157 @@
+# Narrowing for `!=` conditionals
+
+## `x != None`
+
+```py
+def _(flag: bool):
+    x = None if flag else 1
+
+    if x != None:
+        reveal_type(x)  # revealed: Literal[1]
+    else:
+        reveal_type(x)  # revealed: None
+```
+
+## `!=` for other singleton types
+
+```py
+def _(flag: bool):
+    x = True if flag else False
+
+    if x != False:
+        reveal_type(x)  # revealed: Literal[True]
+    else:
+        reveal_type(x)  # revealed: Literal[False]
+```
+
+## `x != y` where `y` is of literal type
+
+```py
+def _(flag: bool):
+    x = 1 if flag else 2
+
+    if x != 1:
+        reveal_type(x)  # revealed: Literal[2]
+```
+
+## `x != y` where `y` is a single-valued type
+
+```py
+def _(flag: bool):
+    class A: ...
+    class B: ...
+    C = A if flag else B
+
+    if C != A:
+        reveal_type(C)  # revealed: Literal[B]
+    else:
+        reveal_type(C)  # revealed: Literal[A]
+```
+
+## `x != y` where `y` has multiple single-valued options
+
+```py
+def _(flag1: bool, flag2: bool):
+    x = 1 if flag1 else 2
+    y = 2 if flag2 else 3
+
+    if x != y:
+        reveal_type(x)  # revealed: Literal[1, 2]
+    else:
+        reveal_type(x)  # revealed: Literal[2]
+```
+
+## `!=` for non-single-valued types
+
+Only single-valued types should narrow the type:
+
+```py
+def _(flag: bool, a: int, y: int):
+    x = a if flag else None
+
+    if x != y:
+        reveal_type(x)  # revealed: int | None
+```
+
+## Mix of single-valued and non-single-valued types
+
+```py
+def _(flag1: bool, flag2: bool, a: int):
+    x = 1 if flag1 else 2
+    y = 2 if flag2 else a
+
+    if x != y:
+        reveal_type(x)  # revealed: Literal[1, 2]
+    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:
+    reveal_type(x)  # revealed: Literal[1]
+```
+
+## Union with `Any`
+
+```py
+from typing import Any
+
+def _(x: Any | None, y: Any | None):
+    if x != 1:
+        reveal_type(x)  # revealed: (Any & ~Literal[1]) | None
+    if y == 1:
+        reveal_type(y)  # revealed: Any & ~None
+```
+
+## Booleans and integers
+
+```py
+from typing import Literal
+
+def _(b: bool, i: Literal[1, 2]):
+    if b == 1:
+        reveal_type(b)  # revealed: Literal[True]
+    else:
+        reveal_type(b)  # revealed: Literal[False]
+
+    if b == 6:
+        reveal_type(b)  # revealed: Never
+    else:
+        reveal_type(b)  # revealed: bool
+
+    if b == 0:
+        reveal_type(b)  # revealed: Literal[False]
+    else:
+        reveal_type(b)  # revealed: Literal[True]
+
+    if i == True:
+        reveal_type(i)  # revealed: Literal[1]
+    else:
+        reveal_type(i)  # revealed: Literal[2]
+```
+
+## Narrowing `LiteralString` in union
+
+```py
+from typing_extensions import Literal, LiteralString, Any
+
+def _(s: LiteralString | None, t: LiteralString | Any):
+    if s == "foo":
+        reveal_type(s)  # revealed: Literal["foo"]
+
+    if s == 1:
+        reveal_type(s)  # revealed: Never
+
+    if t == "foo":
+        # TODO could be `Literal["foo"] | Any`
+        reveal_type(t)  # revealed: LiteralString | Any
+```

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

@@ -78,3 +78,17 @@ 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,3 +100,16 @@ 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,3 +82,14 @@ 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/nested.md

@@ -31,17 +31,14 @@ def _(flag1: bool, flag2: bool):
     if x != 1:
         reveal_type(x)  # revealed: Literal[2, 3]
         if x == 2:
-            # TODO should be `Literal[2]`
-            reveal_type(x)  # revealed: Literal[2, 3]
+            reveal_type(x)  # revealed: Literal[2]
         elif x == 3:
             reveal_type(x)  # revealed: Literal[3]
         else:
             reveal_type(x)  # revealed: Never
 
     elif x != 2:
-        # TODO should be Literal[1]
-        reveal_type(x)  # revealed: Literal[1, 3]
+        reveal_type(x)  # revealed: Literal[1]
     else:
-        # TODO should be Never
-        reveal_type(x)  # revealed: Literal[1, 2, 3]
+        reveal_type(x)  # revealed: Never
 ```

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

@@ -1,91 +0,0 @@
-# Narrowing for `!=` conditionals
-
-## `x != None`
-
-```py
-def _(flag: bool):
-    x = None if flag else 1
-
-    if x != None:
-        reveal_type(x)  # revealed: Literal[1]
-    else:
-        # TODO should be None
-        reveal_type(x)  # revealed: None | Literal[1]
-```
-
-## `!=` for other singleton types
-
-```py
-def _(flag: bool):
-    x = True if flag else False
-
-    if x != False:
-        reveal_type(x)  # revealed: Literal[True]
-    else:
-        # TODO should be Literal[False]
-        reveal_type(x)  # revealed: bool
-```
-
-## `x != y` where `y` is of literal type
-
-```py
-def _(flag: bool):
-    x = 1 if flag else 2
-
-    if x != 1:
-        reveal_type(x)  # revealed: Literal[2]
-```
-
-## `x != y` where `y` is a single-valued type
-
-```py
-def _(flag: bool):
-    class A: ...
-    class B: ...
-    C = A if flag else B
-
-    if C != A:
-        reveal_type(C)  # revealed: Literal[B]
-    else:
-        # TODO should be Literal[A]
-        reveal_type(C)  # revealed: Literal[A, B]
-```
-
-## `x != y` where `y` has multiple single-valued options
-
-```py
-def _(flag1: bool, flag2: bool):
-    x = 1 if flag1 else 2
-    y = 2 if flag2 else 3
-
-    if x != y:
-        reveal_type(x)  # revealed: Literal[1, 2]
-    else:
-        # TODO should be Literal[2]
-        reveal_type(x)  # revealed: Literal[1, 2]
-```
-
-## `!=` for non-single-valued types
-
-Only single-valued types should narrow the type:
-
-```py
-def _(flag: bool, a: int, y: int):
-    x = a if flag else None
-
-    if x != y:
-        reveal_type(x)  # revealed: int | None
-```
-
-## Mix of single-valued and non-single-valued types
-
-```py
-def _(flag1: bool, flag2: bool, a: int):
-    x = 1 if flag1 else 2
-    y = 2 if flag2 else a
-
-    if x != y:
-        reveal_type(x)  # revealed: Literal[1, 2]
-    else:
-        reveal_type(x)  # revealed: Literal[1, 2]
-```

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

@@ -1,5 +1,10 @@
 # Narrowing for `match` statements
 
+```toml
+[environment]
+python-version = "3.10"
+```
+
 ## Single `match` pattern
 
 ```py
@@ -34,8 +39,7 @@ match x:
     case A():
         reveal_type(x)  # revealed: A
     case B():
-        # TODO could be `B & ~A`
-        reveal_type(x)  # revealed: B
+        reveal_type(x)  # revealed: B & ~A
 
 reveal_type(x)  # revealed: object
 ```
@@ -83,7 +87,7 @@ match x:
     case 6.0:
         reveal_type(x)  # revealed: float
     case 1j:
-        reveal_type(x)  # revealed: complex
+        reveal_type(x)  # revealed: complex & ~float
     case b"foo":
         reveal_type(x)  # revealed: Literal[b"foo"]
 
@@ -129,11 +133,11 @@ match x:
     case "foo" | 42 | None:
         reveal_type(x)  # revealed: Literal["foo", 42] | None
     case "foo" | tuple():
-        reveal_type(x)  # revealed: Literal["foo"] | tuple
+        reveal_type(x)  # revealed: tuple
     case True | False:
         reveal_type(x)  # revealed: bool
     case 3.14 | 2.718 | 1.414:
-        reveal_type(x)  # revealed: float
+        reveal_type(x)  # revealed: float & ~tuple
 
 reveal_type(x)  # revealed: object
 ```
@@ -160,3 +164,49 @@ 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

@@ -82,19 +82,19 @@ class B: ...
 
 def f(x: A | B):
     if x:
-        reveal_type(x)  # revealed: A & ~AlwaysFalsy | B & ~AlwaysFalsy
+        reveal_type(x)  # revealed: (A & ~AlwaysFalsy) | (B & ~AlwaysFalsy)
     else:
-        reveal_type(x)  # revealed: A & ~AlwaysTruthy | B & ~AlwaysTruthy
+        reveal_type(x)  # revealed: (A & ~AlwaysTruthy) | (B & ~AlwaysTruthy)
 
     if x and not x:
-        reveal_type(x)  # revealed: A & ~AlwaysFalsy & ~AlwaysTruthy | B & ~AlwaysFalsy & ~AlwaysTruthy
+        reveal_type(x)  # revealed: (A & ~AlwaysFalsy & ~AlwaysTruthy) | (B & ~AlwaysFalsy & ~AlwaysTruthy)
     else:
         reveal_type(x)  # revealed: A | B
 
     if x or not x:
         reveal_type(x)  # revealed: A | B
     else:
-        reveal_type(x)  # revealed: A & ~AlwaysTruthy & ~AlwaysFalsy | B & ~AlwaysTruthy & ~AlwaysFalsy
+        reveal_type(x)  # revealed: (A & ~AlwaysTruthy & ~AlwaysFalsy) | (B & ~AlwaysTruthy & ~AlwaysFalsy)
 ```
 
 ### Truthiness of Types
@@ -111,9 +111,9 @@ x = int if flag() else str
 reveal_type(x)  # revealed: Literal[int, str]
 
 if x:
-    reveal_type(x)  # revealed: Literal[int] & ~AlwaysFalsy | Literal[str] & ~AlwaysFalsy
+    reveal_type(x)  # revealed: (Literal[int] & ~AlwaysFalsy) | (Literal[str] & ~AlwaysFalsy)
 else:
-    reveal_type(x)  # revealed: Literal[int] & ~AlwaysTruthy | Literal[str] & ~AlwaysTruthy
+    reveal_type(x)  # revealed: (Literal[int] & ~AlwaysTruthy) | (Literal[str] & ~AlwaysTruthy)
 ```
 
 ## Determined Truthiness
@@ -176,12 +176,12 @@ if isinstance(x, str) and not isinstance(x, B):
 
     z = x if flag() else y
 
-    reveal_type(z)  # revealed: A & str & ~B | Literal[0, 42, "", "hello"]
+    reveal_type(z)  # revealed: (A & str & ~B) | Literal[0, 42, "", "hello"]
 
     if z:
-        reveal_type(z)  # revealed: A & str & ~B & ~AlwaysFalsy | Literal[42, "hello"]
+        reveal_type(z)  # revealed: (A & str & ~B & ~AlwaysFalsy) | Literal[42, "hello"]
     else:
-        reveal_type(z)  # revealed: A & str & ~B & ~AlwaysTruthy | Literal[0, ""]
+        reveal_type(z)  # revealed: (A & str & ~B & ~AlwaysTruthy) | Literal[0, ""]
 ```
 
 ## Narrowing Multiple Variables
@@ -246,7 +246,7 @@ class MetaTruthy(type):
 
 class MetaDeferred(type):
     def __bool__(self) -> MetaAmbiguous:
-        return MetaAmbiguous()
+        raise NotImplementedError
 
 class AmbiguousClass(metaclass=MetaAmbiguous): ...
 class FalsyClass(metaclass=MetaFalsy): ...
@@ -264,13 +264,13 @@ def _(
 ):
     reveal_type(ta)  # revealed: type[TruthyClass] | type[AmbiguousClass]
     if ta:
-        reveal_type(ta)  # revealed: type[TruthyClass] | type[AmbiguousClass] & ~AlwaysFalsy
+        reveal_type(ta)  # revealed: type[TruthyClass] | (type[AmbiguousClass] & ~AlwaysFalsy)
 
     reveal_type(af)  # revealed: type[AmbiguousClass] | type[FalsyClass]
     if af:
         reveal_type(af)  # revealed: type[AmbiguousClass] & ~AlwaysFalsy
 
-    # error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `MetaDeferred`; the return type of its bool method (`MetaAmbiguous`) isn't assignable to `bool"
+    # error: [unsupported-bool-conversion] "Boolean conversion is unsupported for type `MetaDeferred`"
     if d:
         # TODO: Should be `Unknown`
         reveal_type(d)  # revealed: type[DeferredClass] & ~AlwaysFalsy
@@ -296,12 +296,12 @@ def _(x: Literal[0, 1]):
     reveal_type(x and A())  # revealed: Literal[0] | A
 
 def _(x: str):
-    reveal_type(x or A())  # revealed: str & ~AlwaysFalsy | A
-    reveal_type(x and A())  # revealed: str & ~AlwaysTruthy | A
+    reveal_type(x or A())  # revealed: (str & ~AlwaysFalsy) | A
+    reveal_type(x and A())  # revealed: (str & ~AlwaysTruthy) | A
 
 def _(x: bool | str):
-    reveal_type(x or A())  # revealed: Literal[True] | str & ~AlwaysFalsy | A
-    reveal_type(x and A())  # revealed: Literal[False] | str & ~AlwaysTruthy | A
+    reveal_type(x or A())  # revealed: Literal[True] | (str & ~AlwaysFalsy) | A
+    reveal_type(x and A())  # revealed: Literal[False] | (str & ~AlwaysTruthy) | A
 
 class Falsy:
     def __bool__(self) -> Literal[False]:

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

@@ -111,6 +111,11 @@ def _(x: A | B):
 
 ## 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
@@ -122,7 +127,7 @@ class B: ...
 
 def _[T](x: A | B):
     if type(x) is A[str]:
-        reveal_type(x)  # revealed: A[int] & A[Unknown] | B & A[Unknown]
+        reveal_type(x)  # revealed: (A[int] & A[Unknown]) | (B & A[Unknown])
     else:
         reveal_type(x)  # revealed: A[int] | B
 ```
@@ -139,3 +144,13 @@ 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

@@ -0,0 +1,638 @@
+# 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/scopes/eager.md

@@ -404,7 +404,7 @@ x = int
 class C:
     var: ClassVar[x]
 
-reveal_type(C.var)  # revealed: Unknown | str
+reveal_type(C.var)  # revealed: str
 
 x = str
 ```

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

@@ -0,0 +1,177 @@
+# `global` references
+
+## Implicit global in function
+
+A name reference to a never-defined symbol in a function is implicitly a global lookup.
+
+```py
+x = 1
+
+def f():
+    reveal_type(x)  # revealed: Unknown | Literal[1]
+```
+
+## Explicit global in function
+
+```py
+x = 1
+
+def f():
+    global x
+    reveal_type(x)  # revealed: Unknown | Literal[1]
+```
+
+## Unassignable type in function
+
+```py
+x: int = 1
+
+def f():
+    y: int = 1
+    # error: [invalid-assignment] "Object of type `Literal[""]` is not assignable to `int`"
+    y = ""
+
+    global x
+    # TODO: error: [invalid-assignment] "Object of type `Literal[""]` is not assignable to `int`"
+    x = ""
+```
+
+## Nested intervening scope
+
+A `global` statement causes lookup to skip any bindings in intervening scopes:
+
+```py
+x: int = 1
+
+def outer():
+    x: str = ""
+
+    def inner():
+        global x
+        # TODO: revealed: int
+        reveal_type(x)  # revealed: str
+```
+
+## Narrowing
+
+An assignment following a `global` statement should narrow the type in the local scope after the
+assignment.
+
+```py
+x: int | None
+
+def f():
+    global x
+    x = 1
+    reveal_type(x)  # revealed: Literal[1]
+```
+
+## `nonlocal` and `global`
+
+A binding cannot be both `nonlocal` and `global`. This should emit a semantic syntax error. CPython
+marks the `nonlocal` line, while `mypy`, `pyright`, and `ruff` (`PLE0115`) mark the `global` line.
+
+```py
+x = 1
+
+def f():
+    x = 1
+    def g() -> None:
+        nonlocal x
+        global x  # TODO: error: [invalid-syntax] "name 'x' is nonlocal and global"
+        x = None
+```
+
+## Global declaration after `global` statement
+
+```py
+def f():
+    global x
+    # TODO this should also not be an error
+    y = x  # error: [unresolved-reference] "Name `x` used when not defined"
+    x = 1  # No error.
+
+x = 2
+```
+
+## Semantic syntax errors
+
+Using a name prior to its `global` declaration in the same scope is a syntax error.
+
+```py
+x = 1
+
+def f():
+    print(x)  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x
+    print(x)
+
+def f():
+    global x
+    print(x)  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x
+    print(x)
+
+def f():
+    print(x)  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x, y
+    print(x)
+
+def f():
+    global x, y
+    print(x)  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x, y
+    print(x)
+
+def f():
+    x = 1  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x
+    x = 1
+
+def f():
+    global x
+    x = 1  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x
+    x = 1
+
+def f():
+    del x  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x, y
+    del x
+
+def f():
+    global x, y
+    del x  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x, y
+    del x
+
+def f():
+    del x  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x
+    del x
+
+def f():
+    global x
+    del x  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x
+    del x
+
+def f():
+    del x  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x, y
+    del x
+
+def f():
+    global x, y
+    del x  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x, y
+    del x
+
+def f():
+    print(f"{x=}")  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+    global x
+
+# still an error in module scope
+x = None  # TODO: error: [invalid-syntax] name `x` is used prior to global declaration
+global x
+```

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(generics)
+reveal_type(__path__)  # revealed: @Todo(specialized non-generic class)
 
 class X:
     reveal_type(__name__)  # revealed: str
@@ -59,7 +59,7 @@ reveal_type(typing.__eq__)  # revealed: bound method ModuleType.__eq__(value: ob
 reveal_type(typing.__class__)  # revealed: Literal[ModuleType]
 
 # TODO: needs support generics; should be `dict[str, Any]`:
-reveal_type(typing.__dict__)  # revealed: @Todo(generics)
+reveal_type(typing.__dict__)  # revealed: @Todo(specialized non-generic class)
 ```
 
 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(generics)
-reveal_type(foo_dict)  # revealed: @Todo(generics)
+reveal_type(foo.__dict__)  # revealed: @Todo(specialized non-generic class)
+reveal_type(foo_dict)  # revealed: @Todo(specialized non-generic class)
 ```
 
 ## Conditionally global or `ModuleType` attribute

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

@@ -43,14 +43,3 @@ def f():
         def h():
             reveal_type(x)  # revealed: Unknown | Literal[1]
 ```
-
-## Implicit global in function
-
-A name reference to a never-defined symbol in a function is implicitly a global lookup.
-
-```py
-x = 1
-
-def f():
-    reveal_type(x)  # revealed: Unknown | Literal[1]
-```

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

@@ -5,7 +5,7 @@
 ```py
 class C: ...
 
-C = 1  # error: "Implicit shadowing of class `C`; annotate to make it explicit if this is intentional"
+C = 1  # error: "Implicit shadowing of class `C`"
 ```
 
 ## Explicit

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

@@ -15,7 +15,7 @@ def f(x: str):
 ```py
 def f(): ...
 
-f = 1  # error: "Implicit shadowing of function `f`; annotate to make it explicit if this is intentional"
+f = 1  # error: "Implicit shadowing of function `f`"
 ```
 
 ## Explicit shadowing