TypeVarInstance and intersection of callables

[airflow] Apply auto fixes to cases where the names have changed in Airflow 3 (AIR302) (#17553 )
## Summary  Apply auto fixes to cases where the names have changed in Airflow 3 in AIR302 and split the huge test cases into different test cases based on proivder ## Test Plan  the test cases has been split into multiple for easier checking
2025-04-28 16:27:17 -05:00 · 2025-04-28 16:35:17 -04:00 · 2025-04-28 21:21:53 +02:00 · 2025-04-28 14:57:36 -04:00 · 2025-04-28 14:32:34 -04:00 · 2025-04-28 16:13:07 +00:00
516 changed files with 27264 additions and 10774 deletions
--- a/.gitattributes
+++ b/.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
--- a/.github/actionlint.yaml
+++ b/.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
--- a/.github/workflows/build-binaries.yml
+++ b/.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
--- a/.github/workflows/build-docker.yml
+++ b/.github/workflows/build-docker.yml
@@ -79,7 +79,7 @@ jobs:
      # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
      - name: Build and push by digest
        id: build
-        uses: docker/build-push-action@471d1dc4e07e5cdedd4c2171150001c434f0b7a4 # v6
+        uses: docker/build-push-action@14487ce63c7a62a4a324b0bfb37086795e31c6c1 # v6
        with:
          context: .
          platforms: ${{ matrix.platform }}
@@ -231,7 +231,7 @@ jobs:
            ${{ env.TAG_PATTERNS }}

      - name: Build and push
-        uses: docker/build-push-action@471d1dc4e07e5cdedd4c2171150001c434f0b7a4 # v6
+        uses: docker/build-push-action@14487ce63c7a62a4a324b0bfb37086795e31c6c1 # v6
        with:
          context: .
          platforms: linux/amd64,linux/arm64
--- a/.github/workflows/ci.yaml
+++ b/.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@ab3728c7ba6948b9b429627f4d55a68842b27f18 # v2
        with:
          tool: cargo-nextest
      - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@ab3728c7ba6948b9b429627f4d55a68842b27f18 # 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@ab3728c7ba6948b9b429627f4d55a68842b27f18 # v2
        with:
          tool: cargo-nextest
      - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@ab3728c7ba6948b9b429627f4d55a68842b27f18 # 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@ab3728c7ba6948b9b429627f4d55a68842b27f18 # 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@ab3728c7ba6948b9b429627f4d55a68842b27f18 # v2
        with:
          tool: cargo-nextest
      - name: "Install cargo insta"
-        uses: taiki-e/install-action@d4635f2de61c8b8104d59cd4aede2060638378cc # v2
+        uses: taiki-e/install-action@ab3728c7ba6948b9b429627f4d55a68842b27f18 # 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@ab3728c7ba6948b9b429627f4d55a68842b27f18 # v2
        with:
          tool: cargo-codspeed

--- a/.github/workflows/daily_fuzz.yaml
+++ b/.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,
--- a/.github/workflows/daily_property_tests.yaml
+++ b/.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
--- a/.github/workflows/mypy_primer.yaml
+++ b/.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,23 +36,22 @@ 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:
          workspaces: "ruff"
+
      - name: Install Rust toolchain
        run: rustup show

-      - name: Install mypy_primer
-        run: |
-          uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support-v5"
-
      - name: Run mypy_primer
        shell: bash
        run: |
          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 +62,16 @@ 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 \
+          uvx \
+            --from="git+https://github.com/hauntsaninja/mypy_primer@b83b9eade0b7ed2f4b9b129b163acac1ecb48f71" \
+            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 ]

--- a/.github/workflows/publish-knot-playground.yml
+++ b/.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
--- a/.github/workflows/publish-playground.yml
+++ b/.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"
--- a/.github/workflows/publish-pypi.yml
+++ b/.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-*
--- a/.github/workflows/publish-wasm.yml
+++ b/.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"
--- a/.github/workflows/release.yml
+++ b/.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,19 +124,19 @@ 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
      - name: Install cached dist
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
        with:
          name: cargo-dist-cache
          path: ~/.cargo/bin/
      - run: chmod +x ~/.cargo/bin/dist
      # Get all the local artifacts for the global tasks to use (for e.g. checksums)
      - name: Fetch local artifacts
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
        with:
          pattern: artifacts-*
          path: target/distrib/
@@ -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,19 +175,19 @@ jobs:
    outputs:
      val: ${{ steps.host.outputs.manifest }}
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
        with:
          persist-credentials: false
          submodules: recursive
      - name: Install cached dist
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
        with:
          name: cargo-dist-cache
          path: ~/.cargo/bin/
      - run: chmod +x ~/.cargo/bin/dist
      # Fetch artifacts from scratch-storage
      - name: Fetch artifacts
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
        with:
          pattern: artifacts-*
          path: target/distrib/
@@ -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,13 +251,13 @@ jobs:
    env:
      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
        with:
          persist-credentials: false
          submodules: recursive
      # Create a GitHub Release while uploading all files to it
      - name: "Download GitHub Artifacts"
-        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
        with:
          pattern: artifacts-*
          path: artifacts
--- a/.pre-commit-config.yaml
+++ b/.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.7
    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

--- a/CHANGELOG.md
+++ b/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
--- a/Cargo.lock
+++ b/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",
@@ -394,7 +394,7 @@ dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -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,21 +487,7 @@ version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fde0e0ec90c9dfb3b4b1a0891a7dcd0e2bffde2f7efed5fe7c9bb00e5bfb915e"
 dependencies = [
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "compact_str"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b79c4069c6cad78e2e0cdfcbd26275770669fb39fd308a752dc110e83b9af32"
-dependencies = [
- "castaway",
- "cfg-if",
- "itoa",
- "rustversion",
- "ryu",
- "static_assertions",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -724,7 +710,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "strsim",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -735,7 +721,7 @@ checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
 "darling_core",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -805,7 +791,7 @@ dependencies = [
 "glob",
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -837,7 +823,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -1323,7 +1309,7 @@ checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -1488,7 +1474,7 @@ dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -1553,26 +1539,43 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"

 [[package]]
 name = "jiff"
-version = "0.2.4"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d699bc6dfc879fb1bf9bdff0d4c56f0884fc6f0d0eb0fba397a6d00cd9a6b85e"
+checksum = "5a064218214dc6a10fbae5ec5fa888d80c45d611aba169222fc272072bf7aef6"
 dependencies = [
 "jiff-static",
+ "jiff-tzdb-platform",
 "log",
 "portable-atomic",
 "portable-atomic-util",
 "serde",
+ "windows-sys 0.52.0",
 ]

 [[package]]
 name = "jiff-static"
-version = "0.2.4"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d16e75759ee0aa64c57a56acbf43916987b20c77373cb7e808979e02b93c9f9"
+checksum = "199b7932d97e325aff3a7030e141eafe7f2c6268e1d1b24859b753a627f45254"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
+]
+
+[[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]]
@@ -1628,9 +1631,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"
@@ -1654,14 +1657,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bfa96ed35d0dccc67cf7ba49350cb86de3dcb1d072a7ab28f99117f19d874953"
 dependencies = [
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[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 +1800,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",
 ]
@@ -2163,7 +2166,7 @@ dependencies = [
 "pest_meta",
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -2232,7 +2235,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -2310,9 +2313,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 +2406,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 +2478,6 @@ version = "0.0.0"
 dependencies = [
 "anyhow",
 "argfile",
- "chrono",
 "clap",
 "colored 3.0.0",
 "countme",
@@ -2485,6 +2486,7 @@ dependencies = [
 "filetime",
 "insta",
 "insta-cmd",
+ "jiff",
 "rayon",
 "red_knot_project",
 "red_knot_python_semantic",
@@ -2556,7 +2558,7 @@ dependencies = [
 "anyhow",
 "bitflags 2.9.0",
 "camino",
- "compact_str 0.9.0",
+ "compact_str",
 "countme",
 "dir-test",
 "drop_bomb",
@@ -2756,7 +2758,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.11.5"
+version = "0.11.7"
 dependencies = [
 "anyhow",
 "argfile",
@@ -2764,7 +2766,6 @@ dependencies = [
 "bincode",
 "bitflags 2.9.0",
 "cachedir",
- "chrono",
 "clap",
 "clap_complete_command",
 "clearscreen",
@@ -2777,6 +2778,7 @@ dependencies = [
 "insta-cmd",
 "is-macro",
 "itertools 0.14.0",
+ "jiff",
 "log",
 "mimalloc",
 "notify",
@@ -2991,12 +2993,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 +3008,7 @@ dependencies = [
 "is-macro",
 "is-wsl",
 "itertools 0.14.0",
+ "jiff",
 "libcst",
 "log",
 "memchr",
@@ -3058,7 +3060,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "ruff_python_trivia",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -3067,7 +3069,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",
@@ -3085,7 +3087,7 @@ version = "0.0.0"
 dependencies = [
 "aho-corasick",
 "bitflags 2.9.0",
- "compact_str 0.9.0",
+ "compact_str",
 "is-macro",
 "itertools 0.14.0",
 "memchr",
@@ -3183,7 +3185,7 @@ dependencies = [
 "anyhow",
 "bitflags 2.9.0",
 "bstr",
- "compact_str 0.9.0",
+ "compact_str",
 "insta",
 "memchr",
 "ruff_annotate_snippets",
@@ -3317,7 +3319,7 @@ dependencies = [

 [[package]]
 name = "ruff_wasm"
-version = "0.11.5"
+version = "0.11.7"
 dependencies = [
 "console_error_panic_hook",
 "console_log",
@@ -3441,11 +3443,11 @@ checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"

 [[package]]
 name = "salsa"
-version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
+version = "0.20.0"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=c75b0161aba55965ab6ad8cc9aaee7dc177967f1#c75b0161aba55965ab6ad8cc9aaee7dc177967f1"
 dependencies = [
 "boxcar",
- "compact_str 0.8.1",
+ "compact_str",
 "crossbeam-queue",
 "dashmap 6.1.0",
 "hashbrown 0.15.2",
@@ -3464,18 +3466,18 @@ dependencies = [

 [[package]]
 name = "salsa-macro-rules"
-version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
+version = "0.20.0"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=c75b0161aba55965ab6ad8cc9aaee7dc177967f1#c75b0161aba55965ab6ad8cc9aaee7dc177967f1"

 [[package]]
 name = "salsa-macros"
-version = "0.19.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=87bf6b6c2d5f6479741271da73bd9d30c2580c26#87bf6b6c2d5f6479741271da73bd9d30c2580c26"
+version = "0.20.0"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=c75b0161aba55965ab6ad8cc9aaee7dc177967f1#c75b0161aba55965ab6ad8cc9aaee7dc177967f1"
 dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 "synstructure",
 ]

@@ -3509,7 +3511,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "serde_derive_internals",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -3558,7 +3560,7 @@ checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -3569,7 +3571,7 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -3592,7 +3594,7 @@ checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -3633,7 +3635,7 @@ dependencies = [
 "darling",
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -3658,9 +3660,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",
 ]
@@ -3764,7 +3766,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "rustversion",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -3780,9 +3782,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.100"
+version = "2.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
+checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -3797,7 +3799,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -3868,7 +3870,7 @@ dependencies = [
 "cfg-if",
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -3879,7 +3881,7 @@ checksum = "5c89e72a01ed4c579669add59014b9a524d609c0c88c6a585ce37485879f6ffb"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 "test-case-core",
 ]

@@ -3915,7 +3917,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -3926,7 +3928,7 @@ checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -4057,7 +4059,7 @@ checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -4311,7 +4313,7 @@ checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
 dependencies = [
 "getrandom 0.3.2",
 "js-sys",
- "rand 0.9.0",
+ "rand 0.9.1",
 "uuid-macro-internal",
 "wasm-bindgen",
 ]
@@ -4324,7 +4326,7 @@ checksum = "72dcd78c4f979627a754f5522cea6e6a25e55139056535fe6e69c506cd64a862"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -4446,7 +4448,7 @@ dependencies = [
 "log",
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 "wasm-bindgen-shared",
 ]

@@ -4481,7 +4483,7 @@ checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 "wasm-bindgen-backend",
 "wasm-bindgen-shared",
 ]
@@ -4516,7 +4518,7 @@ checksum = "17d5042cc5fa009658f9a7333ef24291b1291a25b6382dd68862a7f3b969f69b"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -4582,7 +4584,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]]
@@ -4631,7 +4633,7 @@ checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -4642,7 +4644,7 @@ checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -4880,7 +4882,7 @@ checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 "synstructure",
 ]

@@ -4901,7 +4903,7 @@ checksum = "6352c01d0edd5db859a63e2605f4ea3183ddbd15e2c4a9e7d32184df75e4f154"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
@@ -4921,7 +4923,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 "synstructure",
 ]

@@ -4944,7 +4946,7 @@ checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]

 [[package]]
--- a/Cargo.toml
+++ b/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" }
@@ -124,7 +124,7 @@ rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
 # When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "87bf6b6c2d5f6479741271da73bd9d30c2580c26" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "c75b0161aba55965ab6ad8cc9aaee7dc177967f1" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -272,7 +272,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 +308,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 +336,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/download-artifact" = "95815c38cf2ff2164869cbab79da8d1f422bc89e" # v4.2.1
+"actions/checkout" = "85e6279cec87321a52edac9c87bce653a07cf6c2" # v4
+"actions/upload-artifact" = "6027e3dd177782cd8ab9af838c04fd81a07f1d47" # v4.6.2
+"actions/download-artifact" = "d3f86a106a0bac45b974a628896c90dbdf5c8093" # v4.3.0
 "actions/attest-build-provenance" = "c074443f1aee8d4aeeae555aebba3282517141b2" #v2.2.3
--- a/README.md
+++ b/README.md
@@ -149,8 +149,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"

 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.11.5/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.11.5/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.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
--- a/crates/red_knot/Cargo.toml
+++ b/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"] }
--- a/crates/red_knot/docs/mypy_primer.md
+++ b/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
--- a/crates/red_knot/src/args.rs
+++ b/crates/red_knot/src/args.rs
@@ -105,6 +105,19 @@ pub(crate) struct CheckCommand {
    /// Watch files for changes and recheck files related to the changed files.
    #[arg(long, short = 'W')]
    pub(crate) watch: bool,
+
+    /// Respect file exclusions via `.gitignore` and other standard ignore files.
+    /// Use `--no-respect-gitignore` to disable.
+    #[arg(
+        long,
+        overrides_with("no_respect_ignore_files"),
+        help_heading = "File selection",
+        default_missing_value = "true",
+        num_args = 0..1
+    )]
+    respect_ignore_files: Option<bool>,
+    #[clap(long, overrides_with("respect_ignore_files"), hide = true)]
+    no_respect_ignore_files: bool,
 }

 impl CheckCommand {
@@ -120,6 +133,13 @@ impl CheckCommand {
            )
        };

+        // --no-respect-gitignore defaults to false and is set true by CLI flag. If passed, override config file
+        // Otherwise, only pass this through if explicitly set (don't default to anything here to
+        // make sure that doesn't take precedence over an explicitly-set config file value)
+        let respect_ignore_files = self
+            .no_respect_ignore_files
+            .then_some(false)
+            .or(self.respect_ignore_files);
        Options {
            environment: Some(EnvironmentOptions {
                python_version: self
@@ -144,6 +164,7 @@ impl CheckCommand {
                error_on_warning: self.error_on_warning,
            }),
            rules,
+            respect_ignore_files,
            ..Default::default()
        }
    }
--- a/crates/red_knot/src/logging.rs
+++ b/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")
                )?;
            }
        }
--- a/crates/red_knot/src/main.rs
+++ b/crates/red_knot/src/main.rs
@@ -169,8 +169,12 @@ pub enum ExitStatus {
    /// Checking was successful but there were errors.
    Failure = 1,

-    /// Checking failed.
+    /// Checking failed due to an invocation error (e.g. the current directory no longer exists, incorrect CLI arguments, ...)
    Error = 2,
+
+    /// Internal Red Knot error (panic, or any other error that isn't due to the user using the
+    /// program incorrectly or transient environment errors).
+    InternalError = 101,
 }

 impl Termination for ExitStatus {
@@ -246,11 +250,16 @@ impl MainLoop {
                    // Spawn a new task that checks the project. This needs to be done in a separate thread
                    // to prevent blocking the main loop here.
                    rayon::spawn(move || {
-                        if let Ok(result) = db.check() {
-                            // Send the result back to the main loop for printing.
-                            sender
-                                .send(MainLoopMessage::CheckCompleted { result, revision })
-                                .unwrap();
+                        match db.check() {
+                            Ok(result) => {
+                                // Send the result back to the main loop for printing.
+                                sender
+                                    .send(MainLoopMessage::CheckCompleted { result, revision })
+                                    .unwrap();
+                            }
+                            Err(cancelled) => {
+                                tracing::debug!("Check has been cancelled: {cancelled:?}");
+                            }
                        }
                    });
                }
@@ -264,12 +273,6 @@ impl MainLoop {
                        .format(terminal_settings.output_format)
                        .color(colored::control::SHOULD_COLORIZE.should_colorize());

-                    let min_error_severity = if terminal_settings.error_on_warning {
-                        Severity::Warning
-                    } else {
-                        Severity::Error
-                    };
-
                    if check_revision == revision {
                        if db.project().files(db).is_empty() {
                            tracing::warn!("No python files found under the given path(s)");
@@ -284,13 +287,13 @@ impl MainLoop {
                                return Ok(ExitStatus::Success);
                            }
                        } else {
-                            let mut failed = false;
+                            let mut max_severity = Severity::Info;
                            let diagnostics_count = result.len();

                            for diagnostic in result {
                                write!(stdout, "{}", diagnostic.display(db, &display_config))?;

-                                failed |= diagnostic.severity() >= min_error_severity;
+                                max_severity = max_severity.max(diagnostic.severity());
                            }

                            writeln!(
@@ -301,10 +304,17 @@ impl MainLoop {
                            )?;

                            if self.watcher.is_none() {
-                                return Ok(if failed {
-                                    ExitStatus::Failure
-                                } else {
-                                    ExitStatus::Success
+                                return Ok(match max_severity {
+                                    Severity::Info => ExitStatus::Success,
+                                    Severity::Warning => {
+                                        if terminal_settings.error_on_warning {
+                                            ExitStatus::Failure
+                                        } else {
+                                            ExitStatus::Success
+                                        }
+                                    }
+                                    Severity::Error => ExitStatus::Failure,
+                                    Severity::Fatal => ExitStatus::InternalError,
                                });
                            }
                        }
--- a/crates/red_knot/tests/cli.rs
+++ b/crates/red_knot/tests/cli.rs
@@ -5,6 +5,116 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 use tempfile::TempDir;

+#[test]
+fn test_run_in_sub_directory() -> anyhow::Result<()> {
+    let case = TestCase::with_files([("test.py", "~"), ("subdir/nothing", "")])?;
+    assert_cmd_snapshot!(case.command().current_dir(case.root().join("subdir")).arg(".."), @r"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    error: invalid-syntax
+     --> <temp_dir>/test.py:1:2
+      |
+    1 | ~
+      |  ^ Expected an expression
+      |
+
+    Found 1 diagnostic
+
+    ----- stderr -----
+    ");
+    Ok(())
+}
+
+#[test]
+fn test_include_hidden_files_by_default() -> anyhow::Result<()> {
+    let case = TestCase::with_files([(".test.py", "~")])?;
+    assert_cmd_snapshot!(case.command(), @r"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    error: invalid-syntax
+     --> .test.py:1:2
+      |
+    1 | ~
+      |  ^ Expected an expression
+      |
+
+    Found 1 diagnostic
+
+    ----- stderr -----
+    ");
+    Ok(())
+}
+
+#[test]
+fn test_respect_ignore_files() -> anyhow::Result<()> {
+    // First test that the default option works correctly (the file is skipped)
+    let case = TestCase::with_files([(".ignore", "test.py"), ("test.py", "~")])?;
+    assert_cmd_snapshot!(case.command(), @r"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    All checks passed!
+
+    ----- stderr -----
+    WARN No python files found under the given path(s)
+    ");
+
+    // Test that we can set to false via CLI
+    assert_cmd_snapshot!(case.command().arg("--no-respect-ignore-files"), @r"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    error: invalid-syntax
+     --> test.py:1:2
+      |
+    1 | ~
+      |  ^ Expected an expression
+      |
+
+    Found 1 diagnostic
+
+    ----- stderr -----
+    ");
+
+    // Test that we can set to false via config file
+    case.write_file("knot.toml", "respect-ignore-files = false")?;
+    assert_cmd_snapshot!(case.command(), @r"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    error: invalid-syntax
+     --> test.py:1:2
+      |
+    1 | ~
+      |  ^ Expected an expression
+      |
+
+    Found 1 diagnostic
+
+    ----- stderr -----
+    ");
+
+    // Ensure CLI takes precedence
+    case.write_file("knot.toml", "respect-ignore-files = true")?;
+    assert_cmd_snapshot!(case.command().arg("--no-respect-ignore-files"), @r"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    error: invalid-syntax
+     --> test.py:1:2
+      |
+    1 | ~
+      |  ^ Expected an expression
+      |
+
+    Found 1 diagnostic
+
+    ----- stderr -----
+    ");
+    Ok(())
+}
 /// Specifying an option on the CLI should take precedence over the same setting in the
 /// project's configuration. Here, this is tested for the Python version.
 #[test]
@@ -32,12 +142,12 @@ fn config_override_python_version() -> anyhow::Result<()> {
    success: false
    exit_code: 1
    ----- stdout -----
-    error: lint:unresolved-attribute
-     --> <temp_dir>/test.py:5:7
+    error: lint:unresolved-attribute: Type `<module 'sys'>` has no attribute `last_exc`
+     --> 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
@@ -84,7 +194,7 @@ fn config_override_python_platform() -> anyhow::Result<()> {
    exit_code: 0
    ----- stdout -----
    info: revealed-type: Revealed type
-     --> <temp_dir>/test.py:5:1
+     --> test.py:5:1
      |
    3 | from typing_extensions import reveal_type
    4 |
@@ -102,7 +212,7 @@ fn config_override_python_platform() -> anyhow::Result<()> {
    exit_code: 0
    ----- stdout -----
    info: revealed-type: Revealed type
-     --> <temp_dir>/test.py:5:1
+     --> test.py:5:1
      |
    3 | from typing_extensions import reveal_type
    4 |
@@ -165,11 +275,11 @@ fn cli_arguments_are_relative_to_the_current_directory() -> anyhow::Result<()> {
    success: false
    exit_code: 1
    ----- stdout -----
-    error: lint:unresolved-import
-     --> <temp_dir>/child/test.py:2:6
+    error: lint:unresolved-import: Cannot resolve import `utils`
+     --> test.py:2:6
      |
    2 | from utils import add
-      |      ^^^^^ Cannot resolve import `utils`
+      |      ^^^^^
    3 |
    4 | stat = add(10, 15)
      |
@@ -252,7 +362,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 +375,22 @@ fn configuration_rule_severity() -> anyhow::Result<()> {
    success: false
    exit_code: 1
    ----- stdout -----
-    error: lint:division-by-zero
-     --> <temp_dir>/test.py:2:5
+    error: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
+     --> 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
-     --> <temp_dir>/test.py:7:7
+    warning: lint:possibly-unresolved-reference: Name `x` used when possibly not defined
+     --> 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 +411,13 @@ fn configuration_rule_severity() -> anyhow::Result<()> {
    success: true
    exit_code: 0
    ----- stdout -----
-    warning: lint:division-by-zero
-     --> <temp_dir>/test.py:2:5
+    warning: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
+     --> 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 +438,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 +451,33 @@ fn cli_rule_severity() -> anyhow::Result<()> {
    success: false
    exit_code: 1
    ----- stdout -----
-    error: lint:unresolved-import
-     --> <temp_dir>/test.py:2:8
+    error: lint:unresolved-import: Cannot resolve import `does_not_exit`
+     --> 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
-     --> <temp_dir>/test.py:4:5
+    error: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
+     --> 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
-     --> <temp_dir>/test.py:9:7
+    warning: lint:possibly-unresolved-reference: Name `x` used when possibly not defined
+     --> 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 +498,24 @@ fn cli_rule_severity() -> anyhow::Result<()> {
    success: true
    exit_code: 0
    ----- stdout -----
-    warning: lint:unresolved-import
-     --> <temp_dir>/test.py:2:8
+    warning: lint:unresolved-import: Cannot resolve import `does_not_exit`
+     --> 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
-     --> <temp_dir>/test.py:4:5
+    warning: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
+     --> 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 +536,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 +549,22 @@ fn cli_rule_severity_precedence() -> anyhow::Result<()> {
    success: false
    exit_code: 1
    ----- stdout -----
-    error: lint:division-by-zero
-     --> <temp_dir>/test.py:2:5
+    error: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
+     --> 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
-     --> <temp_dir>/test.py:7:7
+    warning: lint:possibly-unresolved-reference: Name `x` used when possibly not defined
+     --> 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 +586,13 @@ fn cli_rule_severity_precedence() -> anyhow::Result<()> {
    success: true
    exit_code: 0
    ----- stdout -----
-    warning: lint:division-by-zero
-     --> <temp_dir>/test.py:2:5
+    warning: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
+     --> 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
@@ -513,7 +623,7 @@ fn configuration_unknown_rules() -> anyhow::Result<()> {
    exit_code: 0
    ----- stdout -----
    warning: unknown-rule
-     --> <temp_dir>/pyproject.toml:3:1
+     --> pyproject.toml:3:1
      |
    2 | [tool.knot.rules]
    3 | division-by-zer = "warn" # incorrect rule name
@@ -555,11 +665,11 @@ fn exit_code_only_warnings() -> anyhow::Result<()> {
    success: true
    exit_code: 0
    ----- stdout -----
-    warning: lint:unresolved-reference
-     --> <temp_dir>/test.py:1:7
+    warning: lint:unresolved-reference: Name `x` used when not defined
+     --> test.py:1:7
      |
    1 | print(x)  # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       ^
      |

    Found 1 diagnostic
@@ -585,7 +695,7 @@ fn exit_code_only_info() -> anyhow::Result<()> {
    exit_code: 0
    ----- stdout -----
    info: revealed-type: Revealed type
-     --> <temp_dir>/test.py:3:1
+     --> test.py:3:1
      |
    2 | from typing_extensions import reveal_type
    3 | reveal_type(1)
@@ -615,7 +725,7 @@ fn exit_code_only_info_and_error_on_warning_is_true() -> anyhow::Result<()> {
    exit_code: 0
    ----- stdout -----
    info: revealed-type: Revealed type
-     --> <temp_dir>/test.py:3:1
+     --> test.py:3:1
      |
    2 | from typing_extensions import reveal_type
    3 | reveal_type(1)
@@ -638,11 +748,11 @@ fn exit_code_no_errors_but_error_on_warning_is_true() -> anyhow::Result<()> {
    success: false
    exit_code: 1
    ----- stdout -----
-    warning: lint:unresolved-reference
-     --> <temp_dir>/test.py:1:7
+    warning: lint:unresolved-reference: Name `x` used when not defined
+     --> test.py:1:7
      |
    1 | print(x)  # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       ^
      |

    Found 1 diagnostic
@@ -670,11 +780,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
-     --> <temp_dir>/test.py:1:7
+    warning: lint:unresolved-reference: Name `x` used when not defined
+     --> test.py:1:7
      |
    1 | print(x)  # [unresolved-reference]
-      |       ^ Name `x` used when not defined
+      |       ^
      |

    Found 1 diagnostic
@@ -699,20 +809,20 @@ fn exit_code_both_warnings_and_errors() -> anyhow::Result<()> {
    success: false
    exit_code: 1
    ----- stdout -----
-    warning: lint:unresolved-reference
-     --> <temp_dir>/test.py:2:7
+    warning: lint:unresolved-reference: Name `x` used when not defined
+     --> 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
-     --> <temp_dir>/test.py:3:7
+    error: lint:non-subscriptable: Cannot subscript object of type `Literal[4]` with no `__getitem__` method
+     --> 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 +847,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
-     --> <temp_dir>/test.py:2:7
+    warning: lint:unresolved-reference: Name `x` used when not defined
+     --> 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
-     --> <temp_dir>/test.py:3:7
+    error: lint:non-subscriptable: Cannot subscript object of type `Literal[4]` with no `__getitem__` method
+     --> 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 +885,20 @@ fn exit_code_exit_zero_is_true() -> anyhow::Result<()> {
    success: true
    exit_code: 0
    ----- stdout -----
-    warning: lint:unresolved-reference
-     --> <temp_dir>/test.py:2:7
+    warning: lint:unresolved-reference: Name `x` used when not defined
+     --> 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
-     --> <temp_dir>/test.py:3:7
+    error: lint:non-subscriptable: Cannot subscript object of type `Literal[4]` with no `__getitem__` method
+     --> 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 +924,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 +945,22 @@ fn user_configuration() -> anyhow::Result<()> {
    success: true
    exit_code: 0
    ----- stdout -----
-    warning: lint:division-by-zero
-     --> <temp_dir>/project/main.py:2:5
+    warning: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
+     --> 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
-     --> <temp_dir>/project/main.py:7:7
+    warning: lint:possibly-unresolved-reference: Name `x` used when possibly not defined
+     --> main.py:7:7
      |
    5 |     x = a
    6 |
    7 | print(x)
-      |       ^ Name `x` used when possibly not defined
+      |       ^
      |

    Found 2 diagnostics
@@ -877,22 +987,22 @@ fn user_configuration() -> anyhow::Result<()> {
    success: false
    exit_code: 1
    ----- stdout -----
-    warning: lint:division-by-zero
-     --> <temp_dir>/project/main.py:2:5
+    warning: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
+     --> 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
-     --> <temp_dir>/project/main.py:7:7
+    error: lint:possibly-unresolved-reference: Name `x` used when possibly not defined
+     --> main.py:7:7
      |
    5 |     x = a
    6 |
    7 | print(x)
-      |       ^ Name `x` used when possibly not defined
+      |       ^
      |

    Found 2 diagnostics
@@ -935,29 +1045,29 @@ fn check_specific_paths() -> anyhow::Result<()> {
    success: false
    exit_code: 1
    ----- stdout -----
-    error: lint:unresolved-import
-     --> <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
-     --> <temp_dir>/project/main.py:2:5
+    error: lint:division-by-zero: Cannot divide object of type `Literal[4]` by zero
+     --> 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
-     --> <temp_dir>/project/other.py:2:6
+    error: lint:unresolved-import: Cannot resolve import `main2`
+     --> project/other.py:2:6
      |
    2 | from main2 import z  # error: unresolved-import
-      |      ^^^^^ Cannot resolve import `main2`
+      |      ^^^^^
    3 |
    4 | print(z)
      |

+    error: lint:unresolved-import: Cannot resolve import `does_not_exist`
+     --> project/tests/test_main.py:2:8
+      |
+    2 | import does_not_exist  # error: unresolved-import
+      |        ^^^^^^^^^^^^^^
+      |
+
    Found 3 diagnostics

    ----- stderr -----
@@ -972,22 +1082,22 @@ fn check_specific_paths() -> anyhow::Result<()> {
    success: false
    exit_code: 1
    ----- stdout -----
-    error: lint:unresolved-import
-     --> <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
-     --> <temp_dir>/project/other.py:2:6
+    error: lint:unresolved-import: Cannot resolve import `main2`
+     --> project/other.py:2:6
      |
    2 | from main2 import z  # error: unresolved-import
-      |      ^^^^^ Cannot resolve import `main2`
+      |      ^^^^^
    3 |
    4 | print(z)
      |

+    error: lint:unresolved-import: Cannot resolve import `does_not_exist`
+     --> project/tests/test_main.py:2:8
+      |
+    2 | import does_not_exist  # error: unresolved-import
+      |        ^^^^^^^^^^^^^^
+      |
+
    Found 2 diagnostics

    ----- stderr -----
@@ -1042,8 +1152,8 @@ fn concise_diagnostics() -> anyhow::Result<()> {
    success: false
    exit_code: 1
    ----- stdout -----
-    warning[lint:unresolved-reference] <temp_dir>/test.py:2:7: Name `x` used when not defined
-    error[lint:non-subscriptable] <temp_dir>/test.py:3:7: Cannot subscript object of type `Literal[4]` with no `__getitem__` method
+    warning[lint:unresolved-reference] test.py:2:7: Name `x` used when not defined
+    error[lint:non-subscriptable] test.py:3:7: Cannot subscript object of type `Literal[4]` with no `__getitem__` method
    Found 2 diagnostics

    ----- stderr -----
@@ -1076,7 +1186,7 @@ fn concise_revealed_type() -> anyhow::Result<()> {
    success: true
    exit_code: 0
    ----- stdout -----
-    info[revealed-type] <temp_dir>/test.py:5:1: Revealed type: `Literal["hello"]`
+    info[revealed-type] test.py:5:1: Revealed type: `Literal["hello"]`
    Found 1 diagnostic

    ----- stderr -----
--- a/crates/red_knot_ide/src/db.rs
+++ b/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 {
--- a/crates/red_knot_ide/src/goto.rs
+++ b/crates/red_knot_ide/src/goto.rs
@@ -272,9 +272,9 @@ mod tests {
            "#,
        );

-        assert_snapshot!(test.goto_type_definition(), @r###"
+        assert_snapshot!(test.goto_type_definition(), @r"
        info: lint:goto-type-definition: Type definition
-         --> /main.py:2:19
+         --> main.py:2:19
          |
        2 |             class Test: ...
          |                   ^^^^
@@ -282,14 +282,14 @@ mod tests {
        4 |             ab = Test()
          |
        info: Source
-         --> /main.py:4:13
+         --> main.py:4:13
          |
        2 |             class Test: ...
        3 |
        4 |             ab = Test()
          |             ^^
          |
-        "###);
+        ");
    }

    #[test]
@@ -304,9 +304,9 @@ mod tests {
        "#,
        );

-        assert_snapshot!(test.goto_type_definition(), @r###"
+        assert_snapshot!(test.goto_type_definition(), @r"
        info: lint:goto-type-definition: Type definition
-         --> /main.py:2:17
+         --> main.py:2:17
          |
        2 |             def foo(a, b): ...
          |                 ^^^
@@ -314,14 +314,14 @@ mod tests {
        4 |             ab = foo
          |
        info: Source
-         --> /main.py:6:13
+         --> main.py:6:13
          |
        4 |             ab = foo
        5 |
        6 |             ab
          |             ^^
          |
-        "###);
+        ");
    }

    #[test]
@@ -344,7 +344,7 @@ mod tests {

        assert_snapshot!(test.goto_type_definition(), @r"
        info: lint:goto-type-definition: Type definition
-         --> /main.py:3:17
+         --> main.py:3:17
          |
        3 |             def foo(a, b): ...
          |                 ^^^
@@ -352,7 +352,7 @@ mod tests {
        5 |             def bar(a, b): ...
          |
        info: Source
-          --> /main.py:12:13
+          --> main.py:12:13
           |
        10 |                 a = bar
        11 |
@@ -361,7 +361,7 @@ mod tests {
           |

        info: lint:goto-type-definition: Type definition
-         --> /main.py:5:17
+         --> main.py:5:17
          |
        3 |             def foo(a, b): ...
        4 |
@@ -371,7 +371,7 @@ mod tests {
        7 |             if random.choice():
          |
        info: Source
-          --> /main.py:12:13
+          --> main.py:12:13
           |
        10 |                 a = bar
        11 |
@@ -395,13 +395,13 @@ mod tests {

        assert_snapshot!(test.goto_type_definition(), @r"
        info: lint:goto-type-definition: Type definition
-         --> /lib.py:1:1
+         --> lib.py:1:1
          |
        1 | a = 10
          | ^^^^^^
          |
        info: Source
-         --> /main.py:4:13
+         --> main.py:4:13
          |
        2 |             import lib
        3 |
@@ -433,7 +433,7 @@ mod tests {
        440 |     def __new__(cls, object: object = ...) -> Self: ...
            |
        info: Source
-         --> /main.py:4:13
+         --> main.py:4:13
          |
        2 |             a: str = "test"
        3 |
@@ -462,7 +462,7 @@ mod tests {
        440 |     def __new__(cls, object: object = ...) -> Self: ...
            |
        info: Source
-         --> /main.py:2:22
+         --> main.py:2:22
          |
        2 |             a: str = "test"
          |                      ^^^^^^
@@ -478,20 +478,20 @@ mod tests {
            "#,
        );

-        assert_snapshot!(test.goto_type_definition(), @r###"
+        assert_snapshot!(test.goto_type_definition(), @r"
        info: lint:goto-type-definition: Type definition
-         --> /main.py:2:24
+         --> main.py:2:24
          |
        2 |             type Alias[T: int = bool] = list[T]
          |                        ^
          |
        info: Source
-         --> /main.py:2:46
+         --> main.py:2:46
          |
        2 |             type Alias[T: int = bool] = list[T]
          |                                              ^
          |
-        "###);
+        ");
    }

    #[test]
@@ -544,7 +544,7 @@ mod tests {
        440 |     def __new__(cls, object: object = ...) -> Self: ...
            |
        info: Source
-         --> /main.py:4:18
+         --> main.py:4:18
          |
        2 |             def test(a: str): ...
        3 |
@@ -579,7 +579,7 @@ mod tests {
        233 |     def __new__(cls, x: ConvertibleToInt = ..., /) -> Self: ...
            |
        info: Source
-         --> /main.py:4:18
+         --> main.py:4:18
          |
        2 |             def test(a: str): ...
        3 |
@@ -613,7 +613,7 @@ f(**kwargs<CURSOR>)
        1088 |     # Also multiprocessing.managers.SyncManager.dict()
             |
        info: Source
-         --> /main.py:6:5
+         --> main.py:6:5
          |
        4 | kwargs = { "name": "test"}
        5 |
@@ -644,7 +644,7 @@ f(**kwargs<CURSOR>)
        440 |     def __new__(cls, object: object = ...) -> Self: ...
            |
        info: Source
-         --> /main.py:3:17
+         --> main.py:3:17
          |
        2 |             def foo(a: str):
        3 |                 a
@@ -666,23 +666,23 @@ f(**kwargs<CURSOR>)
            "#,
        );

-        assert_snapshot!(test.goto_type_definition(), @r###"
+        assert_snapshot!(test.goto_type_definition(), @r"
        info: lint:goto-type-definition: Type definition
-         --> /main.py:2:19
+         --> main.py:2:19
          |
        2 |             class X:
          |                   ^
        3 |                 def foo(a, b): ...
          |
        info: Source
-         --> /main.py:7:13
+         --> main.py:7:13
          |
        5 |             x = X()
        6 |
        7 |             x.foo()
          |             ^
          |
-        "###);
+        ");
    }

    #[test]
@@ -695,9 +695,9 @@ f(**kwargs<CURSOR>)
            "#,
        );

-        assert_snapshot!(test.goto_type_definition(), @r###"
+        assert_snapshot!(test.goto_type_definition(), @r"
        info: lint:goto-type-definition: Type definition
-         --> /main.py:2:17
+         --> main.py:2:17
          |
        2 |             def foo(a, b): ...
          |                 ^^^
@@ -705,14 +705,14 @@ f(**kwargs<CURSOR>)
        4 |             foo()
          |
        info: Source
-         --> /main.py:4:13
+         --> main.py:4:13
          |
        2 |             def foo(a, b): ...
        3 |
        4 |             foo()
          |             ^^^
          |
-        "###);
+        ");
    }

    #[test]
@@ -737,7 +737,7 @@ f(**kwargs<CURSOR>)
        440 |     def __new__(cls, object: object = ...) -> Self: ...
            |
        info: Source
-         --> /main.py:4:27
+         --> main.py:4:27
          |
        2 |             def foo(a: str | None, b):
        3 |                 if a is not None:
@@ -767,7 +767,7 @@ f(**kwargs<CURSOR>)
        672 |         def __bool__(self) -> Literal[False]: ...
            |
        info: Source
-         --> /main.py:3:17
+         --> main.py:3:17
          |
        2 |             def foo(a: str | None, b):
        3 |                 a
@@ -785,7 +785,7 @@ f(**kwargs<CURSOR>)
        440 |     def __new__(cls, object: object = ...) -> Self: ...
            |
        info: Source
-         --> /main.py:3:17
+         --> main.py:3:17
          |
        2 |             def foo(a: str | None, b):
        3 |                 a
--- a/crates/red_knot_ide/src/hover.rs
+++ b/crates/red_knot_ide/src/hover.rs
@@ -156,7 +156,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-         --> /main.py:4:9
+         --> main.py:4:9
          |
        2 |         a = 10
        3 |
@@ -192,7 +192,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-          --> /main.py:10:9
+          --> main.py:10:9
           |
         9 |         foo = Foo()
        10 |         foo.a
@@ -214,7 +214,7 @@ mod tests {
        "#,
        );

-        assert_snapshot!(test.hover(), @r###"
+        assert_snapshot!(test.hover(), @r"
        def foo(a, b) -> Unknown
        ---------------------------------------------
        ```text
@@ -222,7 +222,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-         --> /main.py:4:13
+         --> main.py:4:13
          |
        2 |             def foo(a, b): ...
        3 |
@@ -231,7 +231,7 @@ mod tests {
          |             |
          |             source
          |
-        "###);
+        ");
    }

    #[test]
@@ -251,7 +251,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-         --> /main.py:3:17
+         --> main.py:3:17
          |
        2 |             def foo(a: int, b: int, c: int):
        3 |                 a + b == c
@@ -282,7 +282,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-         --> /main.py:4:18
+         --> main.py:4:18
          |
        2 |             def test(a: int): ...
        3 |
@@ -312,7 +312,7 @@ mod tests {
            "#,
        );

-        assert_snapshot!(test.hover(), @r###"
+        assert_snapshot!(test.hover(), @r"
        (def foo(a, b) -> Unknown) | (def bar(a, b) -> Unknown)
        ---------------------------------------------
        ```text
@@ -320,7 +320,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-          --> /main.py:12:13
+          --> main.py:12:13
           |
        10 |                 a = bar
        11 |
@@ -329,7 +329,7 @@ mod tests {
           |             |
           |             source
           |
-        "###);
+        ");
    }

    #[test]
@@ -352,7 +352,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-         --> /main.py:4:13
+         --> main.py:4:13
          |
        2 |             import lib
        3 |
@@ -381,7 +381,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-         --> /main.py:2:46
+         --> main.py:2:46
          |
        2 |             type Alias[T: int = bool] = list[T]
          |                                              ^- Cursor offset
@@ -407,7 +407,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-         --> /main.py:2:53
+         --> main.py:2:53
          |
        2 |             type Alias[**P = [int, str]] = Callable[P, int]
          |                                                     ^- Cursor offset
@@ -433,7 +433,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-         --> /main.py:2:43
+         --> main.py:2:43
          |
        2 |             type Alias[*Ts = ()] = tuple[*Ts]
          |                                           ^^- Cursor offset
@@ -461,7 +461,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-         --> /main.py:3:13
+         --> main.py:3:13
          |
        2 |         class Foo:
        3 |             a: int
@@ -490,7 +490,7 @@ mod tests {
        ```
        ---------------------------------------------
        info: lint:hover: Hovered content is
-         --> /main.py:4:27
+         --> main.py:4:27
          |
        2 |             def foo(a: str | None, b):
        3 |                 if a is not None:
--- a/crates/red_knot_project/resources/test/corpus/cycle_narrowing_constraints.py
+++ b/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
--- a/crates/red_knot_project/resources/test/corpus/cycle_negative_narrowing_constraints.py
+++ b/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
--- a/crates/red_knot_project/resources/test/corpus/self_referential_function_annotation.py
+++ b/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
--- a/crates/red_knot_project/src/db.rs
+++ b/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 {
--- a/crates/red_knot_project/src/lib.rs
+++ b/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, SubDiagnostic,
 };
 use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
@@ -19,8 +20,10 @@ use ruff_db::system::{SystemPath, SystemPathBuf};
 use rustc_hash::FxHashSet;
 use salsa::Durability;
 use salsa::Setter;
+use std::panic::{catch_unwind, AssertUnwindSafe, UnwindSafe};
 use std::sync::Arc;
 use thiserror::Error;
+use tracing::error;

 pub mod combine;

@@ -186,30 +189,66 @@ impl Project {
                .map(IOErrorDiagnostic::to_diagnostic),
        );

-        let result = Arc::new(std::sync::Mutex::new(diagnostics));
-        let inner_result = Arc::clone(&result);
+        let file_diagnostics = Arc::new(std::sync::Mutex::new(vec![]));

-        let db = db.clone();
-        let project_span = project_span.clone();
+        {
+            let file_diagnostics = Arc::clone(&file_diagnostics);
+            let db = db.clone();
+            let project_span = project_span.clone();

-        rayon::scope(move |scope| {
-            for file in &files {
-                let result = inner_result.clone();
-                let db = db.clone();
-                let project_span = project_span.clone();
+            rayon::scope(move |scope| {
+                for file in &files {
+                    let result = Arc::clone(&file_diagnostics);
+                    let db = db.clone();
+                    let project_span = project_span.clone();

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

-                    let file_diagnostics = check_file_impl(&db, file);
-                    result.lock().unwrap().extend(file_diagnostics);
-                });
+                        let file_diagnostics = check_file_impl(&db, file);
+                        result.lock().unwrap().extend(file_diagnostics);
+                    });
+                }
+            });
+        }
+
+        let mut file_diagnostics = Arc::into_inner(file_diagnostics)
+            .unwrap()
+            .into_inner()
+            .unwrap();
+        // We sort diagnostics in a way that keeps them in source order
+        // and grouped by file. After that, we fall back to severity
+        // (with fatal messages sorting before info messages) and then
+        // finally the diagnostic ID.
+        file_diagnostics.sort_by(|d1, d2| {
+            if let (Some(span1), Some(span2)) = (d1.primary_span(), d2.primary_span()) {
+                let order = span1
+                    .file()
+                    .path(db)
+                    .as_str()
+                    .cmp(span2.file().path(db).as_str());
+                if order.is_ne() {
+                    return order;
+                }
+
+                if let (Some(range1), Some(range2)) = (span1.range(), span2.range()) {
+                    let order = range1.start().cmp(&range2.start());
+                    if order.is_ne() {
+                        return order;
+                    }
+                }
            }
+            // Reverse so that, e.g., Fatal sorts before Info.
+            let order = d1.severity().cmp(&d2.severity()).reverse();
+            if order.is_ne() {
+                return order;
+            }
+            d1.id().cmp(&d2.id())
        });
-
-        Arc::into_inner(result).unwrap().into_inner().unwrap()
+        diagnostics.extend(file_diagnostics);
+        diagnostics
    }

    pub(crate) fn check_file(self, db: &dyn Db, file: File) -> Vec<Diagnostic> {
@@ -313,20 +352,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,7 +466,23 @@ fn check_file_impl(db: &dyn Db, file: File) -> Vec<Diagnostic> {
            .map(|error| create_parse_diagnostic(file, error)),
    );

-    diagnostics.extend(check_types(db.upcast(), file).into_iter().cloned());
+    diagnostics.extend(
+        parsed
+            .unsupported_syntax_errors()
+            .iter()
+            .map(|error| create_unsupported_syntax_diagnostic(file, error)),
+    );
+
+    {
+        let db = AssertUnwindSafe(db);
+        match catch(&**db, file, || check_types(db.upcast(), file)) {
+            Ok(Some(type_check_diagnostics)) => {
+                diagnostics.extend(type_check_diagnostics.into_iter().cloned());
+            }
+            Ok(None) => {}
+            Err(diagnostic) => diagnostics.push(diagnostic),
+        }
+    }

    diagnostics.sort_unstable_by_key(|diagnostic| {
        diagnostic
@@ -515,16 +573,57 @@ enum IOErrorKind {
    SourceText(#[from] SourceTextError),
 }

+fn catch<F, R>(db: &dyn Db, file: File, f: F) -> Result<Option<R>, Diagnostic>
+where
+    F: FnOnce() -> R + UnwindSafe,
+{
+    match catch_unwind(|| {
+        // Ignore salsa errors
+        salsa::Cancelled::catch(f).ok()
+    }) {
+        Ok(result) => Ok(result),
+        Err(error) => {
+            let payload = if let Some(s) = error.downcast_ref::<&str>() {
+                Some((*s).to_string())
+            } else {
+                error.downcast_ref::<String>().cloned()
+            };
+
+            let message = if let Some(payload) = payload {
+                format!(
+                    "Panicked while checking `{file}`: `{payload}`",
+                    file = file.path(db)
+                )
+            } else {
+                format!("Panicked while checking `{file}`", file = { file.path(db) })
+            };
+
+            let mut diagnostic = Diagnostic::new(DiagnosticId::Panic, Severity::Fatal, message);
+            diagnostic.sub(SubDiagnostic::new(
+                Severity::Info,
+                "This indicates a bug in Red Knot.",
+            ));
+
+            let report_message = "If you could open an issue at https://github.com/astral-sh/ruff/issues/new?title=%5Bred-knot%5D:%20panic we'd be very appreciative!";
+            diagnostic.sub(SubDiagnostic::new(Severity::Info, report_message));
+
+            Err(diagnostic)
+        }
+    }
+}
+
 #[cfg(test)]
 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 +631,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();

--- a/crates/red_knot_project/src/metadata/options.rs
+++ b/crates/red_knot_project/src/metadata/options.rs
@@ -32,6 +32,9 @@ pub struct Options {

    #[serde(skip_serializing_if = "Option::is_none")]
    pub terminal: Option<TerminalOptions>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub respect_ignore_files: Option<bool>,
 }

 impl Options {
@@ -133,7 +136,7 @@ impl Options {
    pub(crate) fn to_settings(&self, db: &dyn Db) -> (Settings, Vec<OptionDiagnostic>) {
        let (rules, diagnostics) = self.to_rule_selection(db);

-        let mut settings = Settings::new(rules);
+        let mut settings = Settings::new(rules, self.respect_ignore_files);

        if let Some(terminal) = self.terminal.as_ref() {
            settings.set_terminal(TerminalSettings {
--- a/crates/red_knot_project/src/metadata/settings.rs
+++ b/crates/red_knot_project/src/metadata/settings.rs
@@ -21,13 +21,16 @@ pub struct Settings {
    rules: Arc<RuleSelection>,

    terminal: TerminalSettings,
+
+    respect_ignore_files: bool,
 }

 impl Settings {
-    pub fn new(rules: RuleSelection) -> Self {
+    pub fn new(rules: RuleSelection, respect_ignore_files: Option<bool>) -> Self {
        Self {
            rules: Arc::new(rules),
            terminal: TerminalSettings::default(),
+            respect_ignore_files: respect_ignore_files.unwrap_or(true),
        }
    }

@@ -35,6 +38,10 @@ impl Settings {
        &self.rules
    }

+    pub fn respect_ignore_files(&self) -> bool {
+        self.respect_ignore_files
+    }
+
    pub fn to_rules(&self) -> Arc<RuleSelection> {
        self.rules.clone()
    }
--- a/crates/red_knot_project/src/walk.rs
+++ b/crates/red_knot_project/src/walk.rs
@@ -129,7 +129,11 @@ impl<'a> ProjectFilesWalker<'a> {
    {
        let mut paths = paths.into_iter();

-        let mut walker = db.system().walk_directory(paths.next()?.as_ref());
+        let mut walker = db
+            .system()
+            .walk_directory(paths.next()?.as_ref())
+            .standard_filters(db.project().settings(db).respect_ignore_files())
+            .ignore_hidden(false);

        for path in paths {
            walker = walker.add(path);
--- a/crates/red_knot_project/tests/check.rs
+++ b/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);

--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/any.md
+++ b/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:
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/callable.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/callable.md
@@ -225,18 +225,25 @@ Using `Concatenate` as the first argument to `Callable`:
 from typing_extensions import Callable, Concatenate

 def _(c: Callable[Concatenate[int, str, ...], int]):
-    reveal_type(c)  # revealed: (*args: @Todo(todo signature *args), **kwargs: @Todo(todo signature **kwargs)) -> int
+    # TODO: Should reveal the correct signature
+    reveal_type(c)  # revealed: (...) -> int
 ```

 And, as one of the parameter types:

 ```py
 def _(c: Callable[[Concatenate[int, str, ...], int], int]):
-    reveal_type(c)  # revealed: (*args: @Todo(todo signature *args), **kwargs: @Todo(todo signature **kwargs)) -> int
+    # TODO: Should reveal the correct signature
+    reveal_type(c)  # revealed: (...) -> int
 ```

 ## Using `typing.ParamSpec`

+```toml
+[environment]
+python-version = "3.12"
+```
+
 Using a `ParamSpec` in a `Callable` annotation:

 ```py
@@ -271,7 +278,8 @@ from typing_extensions import Callable, TypeVarTuple
 Ts = TypeVarTuple("Ts")

 def _(c: Callable[[int, *Ts], int]):
-    reveal_type(c)  # revealed: (*args: @Todo(todo signature *args), **kwargs: @Todo(todo signature **kwargs)) -> int
+    # TODO: Should reveal the correct signature
+    reveal_type(c)  # revealed: (...) -> int
 ```

 And, using the legacy syntax using `Unpack`:
@@ -280,7 +288,8 @@ And, using the legacy syntax using `Unpack`:
 from typing_extensions import Unpack

 def _(c: Callable[[int, Unpack[Ts]], int]):
-    reveal_type(c)  # revealed: (*args: @Todo(todo signature *args), **kwargs: @Todo(todo signature **kwargs)) -> int
+    # TODO: Should reveal the correct signature
+    reveal_type(c)  # revealed: (...) -> int
 ```

 ## Member lookup
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/deferred.md
+++ b/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: ...
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/invalid.md
+++ 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
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/literal.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/literal_string.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/literal_string.md
@@ -38,8 +38,12 @@ bad_nesting: Literal[LiteralString]  # error: [invalid-type-form]
 ```py
 from typing_extensions import LiteralString

-a: LiteralString[str]  # error: [invalid-type-form]
-b: LiteralString["foo"]  # error: [invalid-type-form]
+# error: [invalid-type-form]
+a: LiteralString[str]
+
+# error: [invalid-type-form]
+# error: [unresolved-reference] "Name `foo` used when not defined"
+b: LiteralString["foo"]
 ```

 ### As a base class
@@ -72,13 +76,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
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/starred.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/stdlib_typing_aliases.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/stdlib_typing_aliases.md
@@ -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__)
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/string.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md
@@ -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,18 +74,27 @@ 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
-from typing_extensions import Self, TypeAlias
+from typing_extensions import Self, TypeAlias, TypeVar

-X: TypeAlias[T] = int  # error: [invalid-type-form]
+T = TypeVar("T")
+
+# error: [invalid-type-form] "Special form `typing.TypeAlias` expected no type parameter"
+X: TypeAlias[T] = int

 class Foo[T]:
    # error: [invalid-type-form] "Special form `typing.Self` expected no type parameter"
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_type_qualifiers.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_type_qualifiers.md
@@ -11,8 +11,6 @@ from typing_extensions import Final, Required, NotRequired, ReadOnly, TypedDict
 X: Final = 42
 Y: Final[int] = 42

-# TODO: `TypedDict` is actually valid as a base
-# error: [invalid-base]
 class Bar(TypedDict):
    x: Required[int]
    y: NotRequired[str]
--- a/crates/red_knot_python_semantic/resources/mdtest/assignment/annotations.md
+++ b/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]
--- a/crates/red_knot_python_semantic/resources/mdtest/attributes.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/binary/instances.md
+++ b/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`
--- a/crates/red_knot_python_semantic/resources/mdtest/binary/integers.md
+++ b/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 & Any) | (int & float & Any)
+    # TODO: should be `Any` (overload 5 on `__pow__`), requires correct overload matching
+    reveal_type(2**x)  # revealed: (int & Any) | (int & float & Any)
+    # TODO: should be `Any` (overload 5 on `__pow__`), requires correct overload matching
+    reveal_type(x**x)  # revealed: (int & Any) | (int & float & Any)
 ```

 If the second argument is \<0, a `float` is returned at runtime. If the first argument is \<0 but
--- a/crates/red_knot_python_semantic/resources/mdtest/boolean/short_circuit.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/boundness_declaredness/public.md
+++ b/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
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/call/function.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/call/methods.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/call/union.md
+++ b/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
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/class/super.md
+++ b/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]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/integers.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/intersections.md
+++ b/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
 ```

--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/non_bool_returns.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/non_bool_returns.md
@@ -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
--- a/crates/red_knot_python_semantic/resources/mdtest/comprehensions/basic.md
+++ b/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()]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/conditional/if_expression.md
+++ b/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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/conditional/if_statement.md
+++ b/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():
    ...
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/conditional/match.md
+++ b/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:
--- a/crates/red_knot_python_semantic/resources/mdtest/dataclass_transform.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/dataclasses.md
+++ b/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 = Never) -> 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
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/decorators.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/descriptor_protocol.md
+++ b/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: Never

-# 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
--- a/crates/red_knot_python_semantic/resources/mdtest/diagnostics/semantic_syntax_errors.md
+++ b/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
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/diagnostics/shadowing.md
+++ b/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]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/diagnostics/unpacking.md
+++ b/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]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/diagnostics/unsupported_bool_conversion.md
+++ b/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
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/diagnostics/version_related_syntax_errors.md
+++ b/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")
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/directives/assert_never.md
+++ b/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.

--- a/crates/red_knot_python_semantic/resources/mdtest/directives/cast.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/expression/assert.md
+++ b/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()
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/expression/boolean.md
+++ b/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:
        ...
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/function/parameters.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/function/return_type.md
+++ b/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

@@ -195,7 +203,7 @@ from typing import TypeVar

 T = TypeVar("T")

-# TODO: `invalid-return-type` error should be emitted
+# error: [invalid-return-type]
 def m(x: T) -> T: ...
 ```

--- a/crates/red_knot_python_semantic/resources/mdtest/generics/classes.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/generics/functions.md
+++ b/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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/generics/legacy.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/generics/legacy.md
@@ -19,6 +19,9 @@ in newer Python releases.
 from typing import TypeVar

 T = TypeVar("T")
+reveal_type(type(T))  # revealed: Literal[TypeVar]
+reveal_type(T)  # revealed: typing.TypeVar
+reveal_type(T.__name__)  # revealed: Literal["T"]
 ```

 ### Directly assigned to a variable
@@ -29,7 +32,12 @@ T = TypeVar("T")
 ```py
 from typing import TypeVar

-# TODO: error
+T = TypeVar("T")
+# TODO: no error
+# error: [invalid-legacy-type-variable]
+U: TypeVar = TypeVar("U")
+
+# error: [invalid-legacy-type-variable] "A legacy `typing.TypeVar` must be immediately assigned to a variable"
 TestList = list[TypeVar("W")]
 ```

@@ -40,7 +48,7 @@ TestList = list[TypeVar("W")]
 ```py
 from typing import TypeVar

-# TODO: error
+# error: [invalid-legacy-type-variable] "The name of a legacy `typing.TypeVar` (`Q`) must match the name of the variable it is assigned to (`T`)"
 T = TypeVar("Q")
 ```

@@ -57,6 +65,52 @@ T = TypeVar("T")
 T = TypeVar("T")
 ```

+### Type variables with a default
+
+Note that the `__default__` property is only available in Python ≥3.13.
+
+```toml
+[environment]
+python-version = "3.13"
+```
+
+```py
+from typing import TypeVar
+
+T = TypeVar("T", default=int)
+reveal_type(T.__default__)  # revealed: int
+reveal_type(T.__bound__)  # revealed: None
+reveal_type(T.__constraints__)  # revealed: tuple[()]
+
+S = TypeVar("S")
+reveal_type(S.__default__)  # revealed: NoDefault
+```
+
+### Type variables with an upper bound
+
+```py
+from typing import TypeVar
+
+T = TypeVar("T", bound=int)
+reveal_type(T.__bound__)  # revealed: int
+reveal_type(T.__constraints__)  # revealed: tuple[()]
+
+S = TypeVar("S")
+reveal_type(S.__bound__)  # revealed: None
+```
+
+### Type variables with constraints
+
+```py
+from typing import TypeVar
+
+T = TypeVar("T", int, str)
+reveal_type(T.__constraints__)  # revealed: tuple[int, str]
+
+S = TypeVar("S")
+reveal_type(S.__constraints__)  # revealed: tuple[()]
+```
+
 ### Cannot have only one constraint

 > `TypeVar` supports constraining parametric types to a fixed set of possible types...There should
--- a/crates/red_knot_python_semantic/resources/mdtest/generics/pep695.md
+++ b/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
@@ -12,10 +17,51 @@ instances of `typing.TypeVar`, just like legacy type variables.
 ```py
 def f[T]():
    reveal_type(type(T))  # revealed: Literal[TypeVar]
-    reveal_type(T)  # revealed: T
+    reveal_type(T)  # revealed: typing.TypeVar
    reveal_type(T.__name__)  # revealed: Literal["T"]
 ```

+### Type variables with a default
+
+Note that the `__default__` property is only available in Python ≥3.13.
+
+```toml
+[environment]
+python-version = "3.13"
+```
+
+```py
+def f[T = int]():
+    reveal_type(T.__default__)  # revealed: int
+    reveal_type(T.__bound__)  # revealed: None
+    reveal_type(T.__constraints__)  # revealed: tuple[()]
+
+def g[S]():
+    reveal_type(S.__default__)  # revealed: NoDefault
+```
+
+### Type variables with an upper bound
+
+```py
+def f[T: int]():
+    reveal_type(T.__bound__)  # revealed: int
+    reveal_type(T.__constraints__)  # revealed: tuple[()]
+
+def g[S]():
+    reveal_type(S.__bound__)  # revealed: None
+```
+
+### Type variables with constraints
+
+```py
+def f[T: (int, str)]():
+    reveal_type(T.__constraints__)  # revealed: tuple[int, str]
+    reveal_type(T.__bound__)  # revealed: None
+
+def g[S]():
+    reveal_type(S.__constraints__)  # revealed: tuple[()]
+```
+
 ### Cannot have only one constraint

 > `TypeVar` supports constraining parametric types to a fixed set of possible types...There should
@@ -59,19 +105,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 +140,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 +170,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 +181,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 +199,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 +213,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 +235,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 +260,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 +302,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 +312,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 +331,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 +340,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 +351,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 +553,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:
--- a/crates/red_knot_python_semantic/resources/mdtest/generics/scoping.md
+++ b/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,15 +137,12 @@ 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

 legacy: Legacy[int] = Legacy()
-# TODO: revealed: str
-reveal_type(legacy.m(1, "string"))  # revealed: @Todo(Support for `typing.TypeVar` instances in type expressions)
+reveal_type(legacy.m(1, "string"))  # revealed: Literal["string"]
 ```

 With PEP 695 syntax, it is clearer that the method uses a separate typevar:
@@ -157,10 +153,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 +171,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 +195,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 +254,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 +267,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 +281,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]: ...
--- a/crates/red_knot_python_semantic/resources/mdtest/generics/variance.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/import/star.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/intersection_types.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/loops/for.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/loops/for.md
@@ -286,7 +286,7 @@ class Test:
    def __iter__(self) -> TestIter | int:
        return TestIter()

-# error: [not-iterable] "Object of type `Test` may not be iterable because its `__iter__` method returns an object of type `TestIter | int`, which may not have a `__next__` method"
+# error: [not-iterable] "Object of type `Test` may not be iterable"
 for x in Test():
    reveal_type(x)  # revealed: int
 ```
@@ -316,12 +316,12 @@ def _(flag: bool):
        else:
            __iter__: None = None

-    # error: [not-iterable] "Object of type `Iterable1` may not be iterable because its `__iter__` attribute (with type `CustomCallable`) may not be callable"
+    # error: [not-iterable] "Object of type `Iterable1` may not be iterable"
    for x in Iterable1():
        # TODO... `int` might be ideal here?
        reveal_type(x)  # revealed: int | Unknown

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

-    # error: [not-iterable] "Object of type `Iterable` may not be iterable because its `__iter__` method returns an object of type `Iterator`, which may not have a `__next__` method"
+    # error: [not-iterable] "Object of type `Iterable` may not be iterable"
    for x in Iterable():
        reveal_type(x)  # revealed: int
 ```
@@ -461,7 +461,7 @@ def _(flag: bool):
                return Iterator()
        __getitem__: None = None

-    # error: [not-iterable] "Object of type `Iterable` may not be iterable because it may not have an `__iter__` method and its `__getitem__` attribute has type `None`, which is not callable"
+    # error: [not-iterable] "Object of type `Iterable` may not be iterable"
    for x in Iterable():
        reveal_type(x)  # revealed: int
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/loops/while_loop.md
+++ b/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():
    ...
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/mdtest_custom_typeshed.md
+++ b/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
--- a/crates/red_knot_python_semantic/resources/mdtest/metaclass.md
+++ b/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): ...
--- a/crates/red_knot_python_semantic/resources/mdtest/mro.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/mro.md
@@ -191,8 +191,8 @@ reveal_type(AA.__mro__)  # revealed: tuple[Literal[AA], Literal[Z], Unknown, Lit

 ## `__bases__` includes a `Union`

-We don't support union types in a class's bases; a base must resolve to a single `ClassLiteralType`.
-If we find a union type in a class's bases, we infer the class's `__mro__` as being
+We don't support union types in a class's bases; a base must resolve to a single `ClassType`. If we
+find a union type in a class's bases, we infer the class's `__mro__` as being
 `[<class>, Unknown, object]`, the same as for MROs that cause errors at runtime.

 ```py
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/assert.md
+++ b/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]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/boolean.md
+++ b/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]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/elif_else.md
+++ b/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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/eq.md
+++ b/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
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/in.md
+++ b/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]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/is.md
+++ b/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]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/is_not.md
+++ b/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
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/nested.md
+++ b/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
 ```
--- a/Show More
+++ b/Show More