Bump version to 0.8.4 (#15064)

Co-authored-by: Micha Reiser <micha@reiser.io>

.github/CODEOWNERS

@@ -13,9 +13,10 @@
 # flake8-pyi
 /crates/ruff_linter/src/rules/flake8_pyi/ @AlexWaygood
 
-# Script for fuzzing the parser
-/scripts/fuzz-parser/ @AlexWaygood
+# Script for fuzzing the parser/red-knot etc.
+/python/py-fuzzer/ @AlexWaygood
 
 # red-knot
 /crates/red_knot* @carljm @MichaReiser @AlexWaygood @sharkdp
 /crates/ruff_db/ @carljm @MichaReiser @AlexWaygood @sharkdp
+/scripts/knot_benchmark/ @carljm @MichaReiser @AlexWaygood @sharkdp

.github/actionlint.yaml

@@ -0,0 +1,9 @@
+# Configuration for the actionlint tool, which we run via pre-commit
+# to verify the correctness of the syntax in our GitHub Actions workflows.
+
+self-hosted-runner:
+  # Various runners we use that aren't recognized out-of-the-box by actionlint:
+  labels:
+    - depot-ubuntu-latest-8
+    - depot-ubuntu-22.04-16
+    - windows-latest-xlarge

.github/workflows/build-binaries.yml

@@ -40,6 +40,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -52,9 +53,9 @@ jobs:
           args: --out dist
       - name: "Test sdist"
         run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*.tar.gz --force-reinstall
-          ${{ env.MODULE_NAME }} --help
-          python -m ${{ env.MODULE_NAME }} --help
+          pip install dist/"${PACKAGE_NAME}"-*.tar.gz --force-reinstall
+          "${MODULE_NAME}" --help
+          python -m "${MODULE_NAME}" --help
       - name: "Upload sdist"
         uses: actions/upload-artifact@v4
         with:
@@ -68,6 +69,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -109,6 +111,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -122,7 +125,7 @@ jobs:
           args: --release --locked --out dist
       - name: "Test wheel - aarch64"
         run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+          pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
           ruff --help
           python -m ruff --help
       - name: "Upload wheels"
@@ -164,6 +167,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -182,9 +186,9 @@ jobs:
         if: ${{ !startsWith(matrix.platform.target, 'aarch64') }}
         shell: bash
         run: |
-          python -m pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-          ${{ env.MODULE_NAME }} --help
-          python -m ${{ env.MODULE_NAME }} --help
+          python -m pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
+          "${MODULE_NAME}" --help
+          python -m "${MODULE_NAME}" --help
       - name: "Upload wheels"
         uses: actions/upload-artifact@v4
         with:
@@ -216,6 +220,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -231,9 +236,9 @@ jobs:
       - name: "Test wheel"
         if: ${{ startsWith(matrix.target, 'x86_64') }}
         run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-          ${{ env.MODULE_NAME }} --help
-          python -m ${{ env.MODULE_NAME }} --help
+          pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
+          "${MODULE_NAME}" --help
+          python -m "${MODULE_NAME}" --help
       - name: "Upload wheels"
         uses: actions/upload-artifact@v4
         with:
@@ -290,6 +295,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -354,6 +360,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -419,6 +426,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}

.github/workflows/build-docker.yml

@@ -36,6 +36,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
 
       - uses: docker/setup-buildx-action@v3
 
@@ -71,7 +72,7 @@ jobs:
       - name: Normalize Platform Pair (replace / with -)
         run: |
           platform=${{ matrix.platform }}
-          echo "PLATFORM_TUPLE=${platform//\//-}" >> $GITHUB_ENV
+          echo "PLATFORM_TUPLE=${platform//\//-}" >> "$GITHUB_ENV"
 
       # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
       - name: Build and push by digest
@@ -86,9 +87,10 @@ jobs:
           outputs: type=image,name=${{ env.RUFF_BASE_IMG }},push-by-digest=true,name-canonical=true,push=${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
 
       - name: Export digests
+        env:
+          digest: ${{ steps.build.outputs.digest }}
         run: |
           mkdir -p /tmp/digests
-          digest="${{ steps.build.outputs.digest }}"
           touch "/tmp/digests/${digest#sha256:}"
 
       - name: Upload digests
@@ -140,9 +142,10 @@ jobs:
         # The printf will expand the base image with the `<RUFF_BASE_IMG>@sha256:<sha256> ...` for each sha256 in the directory
         # The final command becomes `docker buildx imagetools create -t tag1 -t tag2 ... <RUFF_BASE_IMG>@sha256:<sha256_1> <RUFF_BASE_IMG>@sha256:<sha256_2> ...`
         run: |
+          # shellcheck disable=SC2046
           docker buildx imagetools create \
             $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf '${{ env.RUFF_BASE_IMG }}@sha256:%s ' *)
+            $(printf "${RUFF_BASE_IMG}@sha256:%s " *)
 
   docker-publish-extra:
     name: Publish additional Docker image based on ${{ matrix.image-mapping }}
@@ -181,7 +184,7 @@ jobs:
           # Generate Dockerfile content
           cat <<EOF > Dockerfile
           FROM ${BASE_IMAGE}
-          COPY --from=${{ env.RUFF_BASE_IMG }}:latest /ruff /usr/local/bin/ruff
+          COPY --from=${RUFF_BASE_IMG}:latest /ruff /usr/local/bin/ruff
           ENTRYPOINT []
           CMD ["/usr/local/bin/ruff"]
           EOF
@@ -201,14 +204,14 @@ jobs:
           TAG_PATTERNS="${TAG_PATTERNS%\\n}"
 
           # Export image cache name
-          echo "IMAGE_REF=${BASE_IMAGE//:/-}" >> $GITHUB_ENV
+          echo "IMAGE_REF=${BASE_IMAGE//:/-}" >> "$GITHUB_ENV"
 
           # Export tag patterns using the multiline env var syntax
           {
             echo "TAG_PATTERNS<<EOF"
             echo -e "${TAG_PATTERNS}"
             echo EOF
-          } >> $GITHUB_ENV
+          } >> "$GITHUB_ENV"
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
@@ -284,7 +287,9 @@ jobs:
         # The final command becomes `docker buildx imagetools create -t tag1 -t tag2 ... <RUFF_BASE_IMG>@sha256:<sha256_1> <RUFF_BASE_IMG>@sha256:<sha256_2> ...`
         run: |
           readarray -t lines <<< "$DOCKER_METADATA_OUTPUT_ANNOTATIONS"; annotations=(); for line in "${lines[@]}"; do annotations+=(--annotation "$line"); done
+
+          # shellcheck disable=SC2046
           docker buildx imagetools create \
             "${annotations[@]}" \
             $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf '${{ env.RUFF_BASE_IMG }}@sha256:%s ' *)
+            $(printf "${RUFF_BASE_IMG}@sha256:%s " *)

.github/workflows/ci.yaml

@@ -32,10 +32,13 @@ jobs:
       # Flag that is raised when any code is changed
       # This is superset of the linter and formatter
       code: ${{ steps.changed.outputs.code_any_changed }}
+      # Flag that is raised when any code that affects the fuzzer is changed
+      fuzz: ${{ steps.changed.outputs.fuzz_any_changed }}
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          persist-credentials: false
 
       - uses: tj-actions/changed-files@v45
         id: changed
@@ -49,7 +52,7 @@ jobs:
               - crates/ruff_text_size/**
               - crates/ruff_python_ast/**
               - crates/ruff_python_parser/**
-              - scripts/fuzz-parser/**
+              - python/py-fuzzer/**
               - .github/workflows/ci.yaml
 
             linter:
@@ -79,9 +82,15 @@ jobs:
               - python/**
               - .github/workflows/ci.yaml
 
+            fuzz:
+              - fuzz/Cargo.toml
+              - fuzz/Cargo.lock
+              - fuzz/fuzz_targets/**
+
             code:
               - "**/*"
               - "!**/*.md"
+              - "crates/red_knot_python_semantic/resources/mdtest/**/*.md"
               - "!docs/**"
               - "!assets/**"
 
@@ -91,6 +100,8 @@ jobs:
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup component add rustfmt
       - run: cargo fmt --all --check
@@ -103,6 +114,8 @@ jobs:
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: |
           rustup component add clippy
@@ -115,12 +128,14 @@ jobs:
 
   cargo-test-linux:
     name: "cargo test (linux)"
-    runs-on: ubuntu-latest
+    runs-on: depot-ubuntu-22.04-16
     needs: determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
@@ -157,14 +172,45 @@ jobs:
           name: ruff
           path: target/debug/ruff
 
-  cargo-test-windows:
-    name: "cargo test (windows)"
-    runs-on: windows-latest
+  cargo-test-linux-release:
+    name: "cargo test (linux, release)"
+    runs-on: depot-ubuntu-22.04-16
     needs: determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - name: "Install mold"
+        uses: rui314/setup-mold@v1
+      - name: "Install cargo nextest"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-nextest
+      - name: "Install cargo insta"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-insta
+      - uses: Swatinem/rust-cache@v2
+      - name: "Run tests"
+        shell: bash
+        env:
+          NEXTEST_PROFILE: "ci"
+        run: cargo insta test --release --all-features --unreferenced reject --test-runner nextest
+
+  cargo-test-windows:
+    name: "cargo test (windows)"
+    runs-on: windows-latest-xlarge
+    needs: determine_changes
+    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install cargo nextest"
@@ -189,6 +235,8 @@ jobs:
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
       - uses: actions/setup-node@v4
@@ -197,6 +245,8 @@ jobs:
           cache: "npm"
           cache-dependency-path: playground/package-lock.json
       - uses: jetli/wasm-pack-action@v0.4.0
+        with:
+          version: v0.13.1
       - uses: Swatinem/rust-cache@v2
       - name: "Test ruff_wasm"
         run: |
@@ -210,11 +260,12 @@ jobs:
   cargo-build-release:
     name: "cargo build (release)"
     runs-on: macos-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
+    if: ${{ github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
@@ -231,13 +282,17 @@ jobs:
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: SebRollen/toml-action@v1.2.0
         id: msrv
         with:
           file: "Cargo.toml"
           field: "workspace.package.rust-version"
       - name: "Install Rust toolchain"
-        run: rustup default ${{ steps.msrv.outputs.value }}
+        env:
+          MSRV: ${{ steps.msrv.outputs.value }}
+        run: rustup default "${MSRV}"
       - name: "Install mold"
         uses: rui314/setup-mold@v1
       - name: "Install cargo nextest"
@@ -253,16 +308,19 @@ jobs:
         shell: bash
         env:
           NEXTEST_PROFILE: "ci"
-        run: cargo +${{ steps.msrv.outputs.value }} insta test --all-features --unreferenced reject --test-runner nextest
+          MSRV: ${{ steps.msrv.outputs.value }}
+        run: cargo "+${MSRV}" insta test --all-features --unreferenced reject --test-runner nextest
 
-  cargo-fuzz:
-    name: "cargo fuzz"
+  cargo-fuzz-build:
+    name: "cargo fuzz build"
     runs-on: ubuntu-latest
     needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
+    if: ${{ github.ref == 'refs/heads/main' || needs.determine_changes.outputs.fuzz == 'true' || needs.determine_changes.outputs.code == 'true' }}
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup show
       - uses: Swatinem/rust-cache@v2
@@ -278,7 +336,7 @@ jobs:
       - run: cargo fuzz build -s none
 
   fuzz-parser:
-    name: "Fuzz the parser"
+    name: "fuzz parser"
     runs-on: ubuntu-latest
     needs:
       - cargo-test-linux
@@ -289,13 +347,9 @@ jobs:
       FORCE_COLOR: 1
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
         with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Install uv
-        run: curl -LsSf https://astral.sh/uv/install.sh | sh
-      - name: Install Python requirements
-        run: uv pip install -r scripts/fuzz-parser/requirements.txt --system
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@v4
       - uses: actions/download-artifact@v4
         name: Download Ruff binary to test
         id: download-cached-binary
@@ -303,11 +357,21 @@ jobs:
           name: ruff
           path: ruff-to-test
       - name: Fuzz
+        env:
+          DOWNLOAD_PATH: ${{ steps.download-cached-binary.outputs.download-path }}
         run: |
           # Make executable, since artifact download doesn't preserve this
-          chmod +x ${{ steps.download-cached-binary.outputs.download-path }}/ruff
+          chmod +x "${DOWNLOAD_PATH}/ruff"
 
-          python scripts/fuzz-parser/fuzz.py 0-500 --test-executable ${{ steps.download-cached-binary.outputs.download-path }}/ruff
+          (
+            uvx \
+            --python="${PYTHON_VERSION}" \
+            --from=./python/py-fuzzer \
+            fuzz \
+            --test-executable="${DOWNLOAD_PATH}/ruff" \
+            --bin=ruff \
+            0-500
+          )
 
   scripts:
     name: "test scripts"
@@ -317,6 +381,8 @@ jobs:
     timeout-minutes: 5
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup component add rustfmt
       - uses: Swatinem/rust-cache@v2
@@ -331,7 +397,7 @@ jobs:
 
   ecosystem:
     name: "ecosystem"
-    runs-on: ubuntu-latest
+    runs-on: depot-ubuntu-latest-8
     needs:
       - cargo-test-linux
       - determine_changes
@@ -341,6 +407,8 @@ jobs:
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -352,7 +420,7 @@ jobs:
           name: ruff
           path: target/debug
 
-      - uses: dawidd6/action-download-artifact@v6
+      - uses: dawidd6/action-download-artifact@v7
         name: Download baseline Ruff binary
         with:
           name: ruff
@@ -366,64 +434,72 @@ jobs:
 
       - name: Run `ruff check` stable ecosystem check
         if: ${{ needs.determine_changes.outputs.linter == 'true' }}
+        env:
+          DOWNLOAD_PATH: ${{ steps.ruff-target.outputs.download-path }}
         run: |
           # Make executable, since artifact download doesn't preserve this
-          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
+          chmod +x ./ruff "${DOWNLOAD_PATH}/ruff"
 
           # Set pipefail to avoid hiding errors with tee
           set -eo pipefail
 
-          ruff-ecosystem check ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff --cache ./checkouts --output-format markdown | tee ecosystem-result-check-stable
+          ruff-ecosystem check ./ruff "${DOWNLOAD_PATH}/ruff" --cache ./checkouts --output-format markdown | tee ecosystem-result-check-stable
 
-          cat ecosystem-result-check-stable > $GITHUB_STEP_SUMMARY
+          cat ecosystem-result-check-stable > "$GITHUB_STEP_SUMMARY"
           echo "### Linter (stable)"  > ecosystem-result
           cat ecosystem-result-check-stable >> ecosystem-result
           echo "" >> ecosystem-result
 
       - name: Run `ruff check` preview ecosystem check
         if: ${{ needs.determine_changes.outputs.linter == 'true' }}
+        env:
+          DOWNLOAD_PATH: ${{ steps.ruff-target.outputs.download-path }}
         run: |
           # Make executable, since artifact download doesn't preserve this
-          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
+          chmod +x ./ruff "${DOWNLOAD_PATH}/ruff"
 
           # Set pipefail to avoid hiding errors with tee
           set -eo pipefail
 
-          ruff-ecosystem check ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff --cache ./checkouts --output-format markdown --force-preview | tee ecosystem-result-check-preview
+          ruff-ecosystem check ./ruff "${DOWNLOAD_PATH}/ruff" --cache ./checkouts --output-format markdown --force-preview | tee ecosystem-result-check-preview
 
-          cat ecosystem-result-check-preview > $GITHUB_STEP_SUMMARY
+          cat ecosystem-result-check-preview > "$GITHUB_STEP_SUMMARY"
           echo "### Linter (preview)" >> ecosystem-result
           cat ecosystem-result-check-preview >> ecosystem-result
           echo "" >> ecosystem-result
 
       - name: Run `ruff format` stable ecosystem check
         if: ${{ needs.determine_changes.outputs.formatter == 'true' }}
+        env:
+          DOWNLOAD_PATH: ${{ steps.ruff-target.outputs.download-path }}
         run: |
           # Make executable, since artifact download doesn't preserve this
-          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
+          chmod +x ./ruff "${DOWNLOAD_PATH}/ruff"
 
           # Set pipefail to avoid hiding errors with tee
           set -eo pipefail
 
-          ruff-ecosystem format ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff --cache ./checkouts --output-format markdown | tee ecosystem-result-format-stable
+          ruff-ecosystem format ./ruff "${DOWNLOAD_PATH}/ruff" --cache ./checkouts --output-format markdown | tee ecosystem-result-format-stable
 
-          cat ecosystem-result-format-stable > $GITHUB_STEP_SUMMARY
+          cat ecosystem-result-format-stable > "$GITHUB_STEP_SUMMARY"
           echo "### Formatter (stable)" >> ecosystem-result
           cat ecosystem-result-format-stable >> ecosystem-result
           echo "" >> ecosystem-result
 
       - name: Run `ruff format` preview ecosystem check
         if: ${{ needs.determine_changes.outputs.formatter == 'true' }}
+        env:
+          DOWNLOAD_PATH: ${{ steps.ruff-target.outputs.download-path }}
         run: |
           # Make executable, since artifact download doesn't preserve this
-          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
+          chmod +x ./ruff "${DOWNLOAD_PATH}/ruff"
 
           # Set pipefail to avoid hiding errors with tee
           set -eo pipefail
 
-          ruff-ecosystem format ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff --cache ./checkouts --output-format markdown --force-preview | tee ecosystem-result-format-preview
+          ruff-ecosystem format ./ruff "${DOWNLOAD_PATH}/ruff" --cache ./checkouts --output-format markdown --force-preview | tee ecosystem-result-format-preview
 
-          cat ecosystem-result-format-preview > $GITHUB_STEP_SUMMARY
+          cat ecosystem-result-format-preview > "$GITHUB_STEP_SUMMARY"
           echo "### Formatter (preview)" >> ecosystem-result
           cat ecosystem-result-format-preview >> ecosystem-result
           echo "" >> ecosystem-result
@@ -451,6 +527,8 @@ jobs:
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: cargo-bins/cargo-binstall@main
       - run: cargo binstall --no-confirm cargo-shear
       - run: cargo shear
@@ -461,6 +539,8 @@ jobs:
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -474,7 +554,7 @@ jobs:
           args: --out dist
       - name: "Test wheel"
         run: |
-          pip install --force-reinstall --find-links dist ${{ env.PACKAGE_NAME }}
+          pip install --force-reinstall --find-links dist "${PACKAGE_NAME}"
           ruff --help
           python -m ruff --help
       - name: "Remove wheels from cache"
@@ -486,6 +566,8 @@ jobs:
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -501,13 +583,14 @@ jobs:
           key: pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
       - name: "Run pre-commit"
         run: |
-          echo '```console' > $GITHUB_STEP_SUMMARY
+          echo '```console' > "$GITHUB_STEP_SUMMARY"
           # Enable color output for pre-commit and remove it for the summary
-          SKIP=cargo-fmt,clippy,dev-generate-all pre-commit run --all-files --show-diff-on-failure --color=always | \
-            tee >(sed -E 's/\x1B\[([0-9]{1,2}(;[0-9]{1,2})*)?[mGK]//g' >> $GITHUB_STEP_SUMMARY) >&1
-          exit_code=${PIPESTATUS[0]}
-          echo '```' >> $GITHUB_STEP_SUMMARY
-          exit $exit_code
+          # Use --hook-stage=manual to enable slower pre-commit hooks that are skipped by default
+          SKIP=cargo-fmt,clippy,dev-generate-all pre-commit run --all-files --show-diff-on-failure --color=always --hook-stage=manual | \
+            tee >(sed -E 's/\x1B\[([0-9]{1,2}(;[0-9]{1,2})*)?[mGK]//g' >> "$GITHUB_STEP_SUMMARY") >&1
+          exit_code="${PIPESTATUS[0]}"
+          echo '```' >> "$GITHUB_STEP_SUMMARY"
+          exit "$exit_code"
 
   docs:
     name: "mkdocs"
@@ -517,6 +600,8 @@ jobs:
       MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: "3.13"
@@ -528,7 +613,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: Install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
       - uses: Swatinem/rust-cache@v2
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
@@ -557,16 +642,18 @@ jobs:
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Cache rust"
         uses: Swatinem/rust-cache@v2
-      - name: "Formatter progress"
+      - name: "Run checks"
         run: scripts/formatter_ecosystem_checks.sh
       - name: "Github step summary"
-        run: cat target/progress_projects_stats.txt > $GITHUB_STEP_SUMMARY
+        run: cat target/formatter-ecosystem/stats.txt > "$GITHUB_STEP_SUMMARY"
       - name: "Remove checkouts from cache"
-        run: rm -r target/progress_projects
+        run: rm -r target/formatter-ecosystem
 
   check-ruff-lsp:
     name: "test ruff-lsp"
@@ -584,6 +671,7 @@ jobs:
       - uses: actions/checkout@v4
         name: "Download ruff-lsp source"
         with:
+          persist-credentials: false
           repository: "astral-sh/ruff-lsp"
 
       - uses: actions/setup-python@v5
@@ -602,11 +690,13 @@ jobs:
           just install
 
       - name: Run ruff-lsp tests
+        env:
+          DOWNLOAD_PATH: ${{ steps.ruff-target.outputs.download-path }}
         run: |
           # Setup development binary
           pip uninstall --yes ruff
-          chmod +x ${{ steps.ruff-target.outputs.download-path }}/ruff
-          export PATH=${{ steps.ruff-target.outputs.download-path }}:$PATH
+          chmod +x "${DOWNLOAD_PATH}/ruff"
+          export PATH="${DOWNLOAD_PATH}:${PATH}"
           ruff version
 
           just test
@@ -619,6 +709,8 @@ jobs:
     steps:
       - name: "Checkout Branch"
         uses: actions/checkout@v4
+        with:
+          persist-credentials: false
 
       - name: "Install Rust toolchain"
         run: rustup show

.github/workflows/daily_fuzz.yaml

@@ -32,13 +32,9 @@ jobs:
     if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
-      - name: Install uv
-        run: curl -LsSf https://astral.sh/uv/install.sh | sh
-      - name: Install Python requirements
-        run: uv pip install -r scripts/fuzz-parser/requirements.txt --system
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@v4
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
@@ -49,7 +45,17 @@ jobs:
         # but this is outweighed by the fact that a release build takes *much* longer to compile in CI
         run: cargo build --locked
       - name: Fuzz
-        run: python scripts/fuzz-parser/fuzz.py $(shuf -i 0-9999999999999999999 -n 1000) --test-executable target/debug/ruff
+        run: |
+          # shellcheck disable=SC2046
+          (
+            uvx \
+            --python=3.12 \
+            --from=./python/py-fuzzer \
+            fuzz \
+            --test-executable=target/debug/ruff \
+            --bin=ruff \
+            $(shuf -i 0-9999999999999999999 -n 1000)
+          )
 
   create-issue-on-failure:
     name: Create an issue if the daily fuzz surfaced any bugs

.github/workflows/pr-comment.yaml

@@ -10,14 +10,13 @@ on:
         description: The ecosystem workflow that triggers the workflow run
         required: true
 
-permissions:
-  pull-requests: write
-
 jobs:
   comment:
     runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
     steps:
-      - uses: dawidd6/action-download-artifact@v6
+      - uses: dawidd6/action-download-artifact@v7
         name: Download pull request number
         with:
           name: pr-number
@@ -30,10 +29,10 @@ jobs:
         run: |
           if [[ -f pr-number ]]
           then
-            echo "pr-number=$(<pr-number)" >> $GITHUB_OUTPUT
+            echo "pr-number=$(<pr-number)" >> "$GITHUB_OUTPUT"
           fi
 
-      - uses: dawidd6/action-download-artifact@v6
+      - uses: dawidd6/action-download-artifact@v7
         name: "Download ecosystem results"
         id: download-ecosystem-result
         if: steps.pr-number.outputs.pr-number
@@ -66,9 +65,9 @@ jobs:
           cat pr/ecosystem/ecosystem-result >> comment.txt
           echo "" >> comment.txt
 
-          echo 'comment<<EOF' >> $GITHUB_OUTPUT
-          cat comment.txt >> $GITHUB_OUTPUT
-          echo 'EOF' >> $GITHUB_OUTPUT
+          echo 'comment<<EOF' >> "$GITHUB_OUTPUT"
+          cat comment.txt >> "$GITHUB_OUTPUT"
+          echo 'EOF' >> "$GITHUB_OUTPUT"
 
       - name: Find existing comment
         uses: peter-evans/find-comment@v3

.github/workflows/publish-docs.yml

@@ -26,6 +26,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           ref: ${{ inputs.ref }}
+          persist-credentials: true
 
       - uses: actions/setup-python@v5
         with:
@@ -43,21 +44,19 @@ jobs:
           # Use version as display name for now
           display_name="$version"
 
-          echo "version=$version" >> $GITHUB_ENV
-          echo "display_name=$display_name" >> $GITHUB_ENV
+          echo "version=$version" >> "$GITHUB_ENV"
+          echo "display_name=$display_name" >> "$GITHUB_ENV"
 
       - name: "Set branch name"
         run: |
-          version="${{ env.version }}"
-          display_name="${{ env.display_name }}"
           timestamp="$(date +%s)"
 
           # create branch_display_name from display_name by replacing all
           # characters disallowed in git branch names with hyphens
-          branch_display_name="$(echo "$display_name" | tr -c '[:alnum:]._' '-' | tr -s '-')"
+          branch_display_name="$(echo "${display_name}" | tr -c '[:alnum:]._' '-' | tr -s '-')"
 
-          echo "branch_name=update-docs-$branch_display_name-$timestamp" >> $GITHUB_ENV
-          echo "timestamp=$timestamp" >> $GITHUB_ENV
+          echo "branch_name=update-docs-$branch_display_name-$timestamp" >> "$GITHUB_ENV"
+          echo "timestamp=$timestamp" >> "$GITHUB_ENV"
 
       - name: "Add SSH key"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
@@ -92,9 +91,7 @@ jobs:
         run: mkdocs build --strict -f mkdocs.public.yml
 
       - name: "Clone docs repo"
-        run: |
-          version="${{ env.version }}"
-          git clone https://${{ secrets.ASTRAL_DOCS_PAT }}@github.com/astral-sh/docs.git astral-docs
+        run: git clone https://${{ secrets.ASTRAL_DOCS_PAT }}@github.com/astral-sh/docs.git astral-docs
 
       - name: "Copy docs"
         run: rm -rf astral-docs/site/ruff && mkdir -p astral-docs/site && cp -r site/ruff astral-docs/site/
@@ -102,12 +99,10 @@ jobs:
       - name: "Commit docs"
         working-directory: astral-docs
         run: |
-          branch_name="${{ env.branch_name }}"
-
           git config user.name "astral-docs-bot"
           git config user.email "176161322+astral-docs-bot@users.noreply.github.com"
 
-          git checkout -b $branch_name
+          git checkout -b "${branch_name}"
           git add site/ruff
           git commit -m "Update ruff documentation for $version"
 
@@ -116,12 +111,8 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.ASTRAL_DOCS_PAT }}
         run: |
-          version="${{ env.version }}"
-          display_name="${{ env.display_name }}"
-          branch_name="${{ env.branch_name }}"
-
           # set the PR title
-          pull_request_title="Update ruff documentation for $display_name"
+          pull_request_title="Update ruff documentation for ${display_name}"
 
           # Delete any existing pull requests that are open for this version
           # by checking against pull_request_title because the new PR will
@@ -130,13 +121,15 @@ jobs:
             xargs -I {} gh pr close {}
 
           # push the branch to GitHub
-          git push origin $branch_name
+          git push origin "${branch_name}"
 
           # create the PR
-          gh pr create --base main --head $branch_name \
-            --title "$pull_request_title" \
-            --body "Automated documentation update for $display_name" \
-            --label "documentation"
+          gh pr create \
+            --base=main \
+            --head="${branch_name}" \
+            --title="${pull_request_title}" \
+            --body="Automated documentation update for ${display_name}" \
+            --label="documentation"
 
       - name: "Merge Pull Request"
         if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
@@ -144,9 +137,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.ASTRAL_DOCS_PAT }}
         run: |
-          branch_name="${{ env.branch_name }}"
-
           # auto-merge the PR if the build was triggered by a release. Manual builds should be reviewed by a human.
           # give the PR a few seconds to be created before trying to auto-merge it
           sleep 10
-          gh pr merge --squash $branch_name
+          gh pr merge --squash "${branch_name}"

.github/workflows/publish-playground.yml

@@ -25,6 +25,8 @@ jobs:
       CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
       - uses: actions/setup-node@v4
@@ -47,7 +49,7 @@ jobs:
         working-directory: playground
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.12.1
+        uses: cloudflare/wrangler-action@v3.13.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/publish-pypi.yml

@@ -22,7 +22,7 @@ jobs:
       id-token: write
     steps:
       - name: "Install uv"
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
       - uses: actions/download-artifact@v4
         with:
           pattern: wheels-*

.github/workflows/publish-wasm.yml

@@ -30,6 +30,8 @@ jobs:
       fail-fast: false
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
       - uses: jetli/wasm-pack-action@v0.4.0

.github/workflows/release.yml

@@ -1,4 +1,4 @@
-# This file was autogenerated by cargo-dist: https://opensource.axo.dev/cargo-dist/
+# This file was autogenerated by dist: https://opensource.axo.dev/cargo-dist/
 #
 # Copyright 2022-2024, axodotdev
 # SPDX-License-Identifier: MIT or Apache-2.0
@@ -6,7 +6,7 @@
 # CI that:
 #
 # * checks for a Git Tag that looks like a release
-# * builds artifacts with cargo-dist (archives, installers, hashes)
+# * builds artifacts with dist (archives, installers, hashes)
 # * uploads those artifacts to temporary workflow zip
 # * on success, uploads the artifacts to a GitHub Release
 #
@@ -24,10 +24,10 @@ permissions:
 # must be a Cargo-style SemVer Version (must have at least major.minor.patch).
 #
 # If PACKAGE_NAME is specified, then the announcement will be for that
-# package (erroring out if it doesn't have the given version or isn't cargo-dist-able).
+# package (erroring out if it doesn't have the given version or isn't dist-able).
 #
 # If PACKAGE_NAME isn't specified, then the announcement will be for all
-# (cargo-dist-able) packages in the workspace with that version (this mode is
+# (dist-able) packages in the workspace with that version (this mode is
 # intended for workspaces with only one dist-able package, or with all dist-able
 # packages versioned/released in lockstep).
 #
@@ -48,7 +48,7 @@ on:
         type: string
 
 jobs:
-  # Run 'cargo dist plan' (or host) to determine what tasks we need to do
+  # Run 'dist plan' (or host) to determine what tasks we need to do
   plan:
     runs-on: "ubuntu-20.04"
     outputs:
@@ -62,16 +62,16 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      - name: Install cargo-dist
+      - name: Install dist
         # we specify bash to get pipefail; it guards against the `curl` command
         # failing. otherwise `sh` won't catch that `curl` returned non-0
         shell: bash
-        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.22.1/cargo-dist-installer.sh | sh"
-      - name: Cache cargo-dist
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.25.2-prerelease.3/cargo-dist-installer.sh | sh"
+      - name: Cache dist
         uses: actions/upload-artifact@v4
         with:
           name: cargo-dist-cache
-          path: ~/.cargo/bin/cargo-dist
+          path: ~/.cargo/bin/dist
       # sure would be cool if github gave us proper conditionals...
       # so here's a doubly-nested ternary-via-truthiness to try to provide the best possible
       # functionality based on whether this is a pull_request, and whether it's from a fork.
@@ -79,8 +79,8 @@ jobs:
       # but also really annoying to build CI around when it needs secrets to work right.)
       - id: plan
         run: |
-          cargo dist ${{ (inputs.tag && inputs.tag != 'dry-run' && format('host --steps=create --tag={0}', inputs.tag)) || 'plan' }} --output-format=json > plan-dist-manifest.json
-          echo "cargo dist ran successfully"
+          dist ${{ (inputs.tag && inputs.tag != 'dry-run' && format('host --steps=create --tag={0}', inputs.tag)) || 'plan' }} --output-format=json > plan-dist-manifest.json
+          echo "dist ran successfully"
           cat plan-dist-manifest.json
           echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
       - name: "Upload dist-manifest.json"
@@ -124,12 +124,12 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      - name: Install cached cargo-dist
+      - name: Install cached dist
         uses: actions/download-artifact@v4
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/cargo-dist
+      - 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@v4
@@ -140,8 +140,8 @@ jobs:
       - id: cargo-dist
         shell: bash
         run: |
-          cargo dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
-          echo "cargo dist ran successfully"
+          dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
+          echo "dist ran successfully"
 
           # Parse out what we just built and upload it to scratch storage
           echo "paths<<EOF" >> "$GITHUB_OUTPUT"
@@ -174,12 +174,12 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      - name: Install cached cargo-dist
+      - name: Install cached dist
         uses: actions/download-artifact@v4
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/cargo-dist
+      - run: chmod +x ~/.cargo/bin/dist
       # Fetch artifacts from scratch-storage
       - name: Fetch artifacts
         uses: actions/download-artifact@v4
@@ -191,7 +191,7 @@ jobs:
       - id: host
         shell: bash
         run: |
-          cargo dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
+          dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
           echo "artifacts uploaded and released successfully"
           cat dist-manifest.json
           echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"

.github/workflows/sync_typeshed.yaml

@@ -25,11 +25,13 @@ jobs:
         name: Checkout Ruff
         with:
           path: ruff
+          persist-credentials: true
       - uses: actions/checkout@v4
         name: Checkout typeshed
         with:
           repository: python/typeshed
           path: typeshed
+          persist-credentials: false
       - name: Setup git
         run: |
           git config --global user.name typeshedbot
@@ -57,7 +59,7 @@ jobs:
         run: |
           cd ruff
           git push --force origin typeshedbot/sync-typeshed
-          gh pr list --repo $GITHUB_REPOSITORY --head typeshedbot/sync-typeshed --json id --jq length | grep 1 && exit 0 # exit if there is existing pr
+          gh pr list --repo "$GITHUB_REPOSITORY" --head typeshedbot/sync-typeshed --json id --jq length | grep 1 && exit 0 # exit if there is existing pr
           gh pr create --title "Sync vendored typeshed stubs" --body "Close and reopen this PR to trigger CI" --label "internal"
 
   create-issue-on-failure:

.github/zizmor.yml

@@ -0,0 +1,6 @@
+# Configuration for the zizmor static analysis tool, run via pre-commit in CI
+# https://woodruffw.github.io/zizmor/configuration/
+rules:
+  dangerous-triggers:
+    ignore:
+      - pr-comment.yaml

.markdownlint.yaml

@@ -21,3 +21,11 @@ MD014: false
 MD024:
   # Allow when nested under different parents e.g. CHANGELOG.md
   siblings_only: true
+
+# MD046/code-block-style
+#
+# Ignore this because it conflicts with the code block style used in content
+# tabs of mkdocs-material which is to add a blank line after the content title.
+#
+# Ref: https://github.com/astral-sh/ruff/pull/15011#issuecomment-2544790854
+MD046: false

.pre-commit-config.yaml

@@ -2,6 +2,7 @@ fail_fast: false
 
 exclude: |
   (?x)^(
+    .github/workflows/release.yml|
     crates/red_knot_vendored/vendor/.*|
     crates/red_knot_workspace/resources/.*|
     crates/ruff_linter/resources/.*|
@@ -22,13 +23,12 @@ repos:
       - id: validate-pyproject
 
   - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.18
+    rev: 0.7.19
     hooks:
       - id: mdformat
         additional_dependencies:
-          - mdformat-mkdocs
-          - mdformat-admon
-          - mdformat-footnote
+          - mdformat-mkdocs==4.0.0
+          - mdformat-footnote==0.1.1
         exclude: |
           (?x)^(
             docs/formatter/black\.md
@@ -36,7 +36,7 @@ repos:
           )$
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.42.0
+    rev: v0.43.0
     hooks:
       - id: markdownlint-fix
         exclude: |
@@ -59,7 +59,7 @@ repos:
           - black==24.10.0
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.27.3
+    rev: v1.28.3
     hooks:
       - id: typos
 
@@ -73,7 +73,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.4
+    rev: v0.8.3
     hooks:
       - id: ruff-format
       - id: ruff
@@ -83,10 +83,42 @@ repos:
 
   # Prettier
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.3.3
+    rev: v3.4.2
     hooks:
       - id: prettier
         types: [yaml]
 
+  # 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: v0.9.2
+    hooks:
+      - id: zizmor
+
+  - repo: https://github.com/python-jsonschema/check-jsonschema
+    rev: 0.30.0
+    hooks:
+      - id: check-github-workflows
+
+  # `actionlint` hook, for verifying correct syntax in GitHub Actions workflows.
+  # Some additional configuration for `actionlint` can be found in `.github/actionlint.yaml`.
+  - repo: https://github.com/rhysd/actionlint
+    rev: v1.7.4
+    hooks:
+      - id: actionlint
+        stages:
+          # This hook is disabled by default, since it's quite slow.
+          # To run all hooks *including* this hook, use `uvx pre-commit run -a --hook-stage=manual`.
+          # To run *just* this hook, use `uvx pre-commit run -a actionlint --hook-stage=manual`.
+          - manual
+        args:
+          - "-ignore=SC2129" # ignorable stylistic lint from shellcheck
+          - "-ignore=SC2016" # another shellcheck lint: seems to have false positives?
+        additional_dependencies:
+          # actionlint has a shellcheck integration which extracts shell scripts in `run:` steps from GitHub Actions
+          # and checks these with shellcheck. This is arguably its most useful feature,
+          # but the integration only works if shellcheck is installed
+          - "github.com/wasilibs/go-shellcheck/cmd/shellcheck@v0.10.0"
+
 ci:
   skip: [cargo-fmt, dev-generate-all]

BREAKING_CHANGES.md

@@ -1,5 +1,30 @@
 # Breaking Changes
 
+## 0.8.0
+
+- **Default to Python 3.9**
+
+    Ruff now defaults to Python 3.9 instead of 3.8 if no explicit Python version is configured using [`ruff.target-version`](https://docs.astral.sh/ruff/settings/#target-version) or [`project.requires-python`](https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#python-requires) ([#13896](https://github.com/astral-sh/ruff/pull/13896))
+
+- **Changed location of `pydoclint` diagnostics**
+
+    [`pydoclint`](https://docs.astral.sh/ruff/rules/#pydoclint-doc) diagnostics now point to the first-line of the problematic docstring. Previously, this was not the case.
+
+    If you've opted into these preview rules but have them suppressed using
+    [`noqa`](https://docs.astral.sh/ruff/linter/#error-suppression) comments in
+    some places, this change may mean that you need to move the `noqa` suppression
+    comments. Most users should be unaffected by this change.
+
+- **Use XDG (i.e. `~/.local/bin`) instead of the Cargo home directory in the standalone installer**
+
+    Previously, Ruff's installer used `$CARGO_HOME` or `~/.cargo/bin` for its target install directory. Now, Ruff will be installed into `$XDG_BIN_HOME`, `$XDG_DATA_HOME/../bin`, or `~/.local/bin` (in that order).
+
+    This change is only relevant to users of the standalone Ruff installer (using the shell or PowerShell script). If you installed Ruff using uv or pip, you should be unaffected.
+
+- **Changes to the line width calculation**
+
+    Ruff now uses a new version of the [unicode-width](https://github.com/unicode-rs/unicode-width) Rust crate to calculate the line width. In very rare cases, this may lead to lines containing Unicode characters being reformatted, or being considered too long when they were not before ([`E501`](https://docs.astral.sh/ruff/rules/line-too-long/)).
+
 ## 0.7.0
 
 - The pytest rules `PT001` and `PT023` now default to omitting the decorator parentheses when there are no arguments
@@ -167,7 +192,7 @@ flag or `unsafe-fixes` configuration option can be used to enable unsafe fixes.
 
 See the [docs](https://docs.astral.sh/ruff/configuration/#fix-safety) for details.
 
-### Remove formatter-conflicting rules from the default rule set  ([#7900](https://github.com/astral-sh/ruff/pull/7900))
+### Remove formatter-conflicting rules from the default rule set ([#7900](https://github.com/astral-sh/ruff/pull/7900))
 
 Previously, Ruff enabled all implemented rules in Pycodestyle (`E`) by default. Ruff now only includes the
 Pycodestyle prefixes `E4`, `E7`, and `E9` to exclude rules that conflict with automatic formatters. Consequently,

CHANGELOG.md

@@ -1,5 +1,245 @@
 # Changelog
 
+## 0.8.4
+
+### Preview features
+
+- \[`airflow`\] Extend `AIR302` with additional functions and classes ([#15015](https://github.com/astral-sh/ruff/pull/15015))
+- \[`airflow`\] Implement `moved-to-provider-in-3` for modules that has been moved to Airflow providers (`AIR303`) ([#14764](https://github.com/astral-sh/ruff/pull/14764))
+- \[`flake8-use-pathlib`\] Extend check for invalid path suffix to include the case `"."` (`PTH210`) ([#14902](https://github.com/astral-sh/ruff/pull/14902))
+- \[`perflint`\] Fix panic in `PERF401` when list variable is after the `for` loop ([#14971](https://github.com/astral-sh/ruff/pull/14971))
+- \[`perflint`\] Simplify finding the loop target in `PERF401` ([#15025](https://github.com/astral-sh/ruff/pull/15025))
+- \[`pylint`\] Preserve original value format (`PLR6104`) ([#14978](https://github.com/astral-sh/ruff/pull/14978))
+- \[`ruff`\] Avoid false positives for `RUF027` for typing context bindings ([#15037](https://github.com/astral-sh/ruff/pull/15037))
+- \[`ruff`\] Check for ambiguous pattern passed to `pytest.raises()` (`RUF043`) ([#14966](https://github.com/astral-sh/ruff/pull/14966))
+
+### Rule changes
+
+- \[`flake8-bandit`\] Check `S105` for annotated assignment ([#15059](https://github.com/astral-sh/ruff/pull/15059))
+- \[`flake8-pyi`\] More autofixes for `redundant-none-literal` (`PYI061`) ([#14872](https://github.com/astral-sh/ruff/pull/14872))
+- \[`pydocstyle`\] Skip leading whitespace for `D403` ([#14963](https://github.com/astral-sh/ruff/pull/14963))
+- \[`ruff`\] Skip `SQLModel` base classes for `mutable-class-default` (`RUF012`) ([#14949](https://github.com/astral-sh/ruff/pull/14949))
+
+### Bug
+
+- \[`perflint`\] Parenthesize walrus expressions in autofix for `manual-list-comprehension` (`PERF401`) ([#15050](https://github.com/astral-sh/ruff/pull/15050))
+
+### Server
+
+- Check diagnostic refresh support from client capability which enables dynamic configuration for various editors ([#15014](https://github.com/astral-sh/ruff/pull/15014))
+
+## 0.8.3
+
+### Preview features
+
+- Fix fstring formatting removing overlong implicit concatenated string in expression part ([#14811](https://github.com/astral-sh/ruff/pull/14811))
+- \[`airflow`\] Add fix to remove deprecated keyword arguments (`AIR302`) ([#14887](https://github.com/astral-sh/ruff/pull/14887))
+- \[`airflow`\]: Extend rule to include deprecated names for Airflow 3.0 (`AIR302`) ([#14765](https://github.com/astral-sh/ruff/pull/14765) and [#14804](https://github.com/astral-sh/ruff/pull/14804))
+- \[`flake8-bugbear`\] Improve error messages for `except*` (`B025`, `B029`, `B030`, `B904`) ([#14815](https://github.com/astral-sh/ruff/pull/14815))
+- \[`flake8-bugbear`\] `itertools.batched()` without explicit `strict` (`B911`) ([#14408](https://github.com/astral-sh/ruff/pull/14408))
+- \[`flake8-use-pathlib`\] Dotless suffix passed to `Path.with_suffix()` (`PTH210`) ([#14779](https://github.com/astral-sh/ruff/pull/14779))
+- \[`pylint`\] Include parentheses and multiple comparators in check for `boolean-chained-comparison` (`PLR1716`) ([#14781](https://github.com/astral-sh/ruff/pull/14781))
+- \[`ruff`\] Do not simplify `round()` calls (`RUF046`) ([#14832](https://github.com/astral-sh/ruff/pull/14832))
+- \[`ruff`\] Don't emit `used-dummy-variable` on function parameters (`RUF052`) ([#14818](https://github.com/astral-sh/ruff/pull/14818))
+- \[`ruff`\] Implement `if-key-in-dict-del` (`RUF051`) ([#14553](https://github.com/astral-sh/ruff/pull/14553))
+- \[`ruff`\] Mark autofix for `RUF052` as always unsafe ([#14824](https://github.com/astral-sh/ruff/pull/14824))
+- \[`ruff`\] Teach autofix for `used-dummy-variable` about TypeVars etc. (`RUF052`) ([#14819](https://github.com/astral-sh/ruff/pull/14819))
+
+### Rule changes
+
+- \[`flake8-bugbear`\] Offer unsafe autofix for `no-explicit-stacklevel` (`B028`) ([#14829](https://github.com/astral-sh/ruff/pull/14829))
+- \[`flake8-pyi`\] Skip all type definitions in `string-or-bytes-too-long` (`PYI053`) ([#14797](https://github.com/astral-sh/ruff/pull/14797))
+- \[`pyupgrade`\] Do not report when a UTF-8 comment is followed by a non-UTF-8 one (`UP009`) ([#14728](https://github.com/astral-sh/ruff/pull/14728))
+- \[`pyupgrade`\] Mark fixes for `convert-typed-dict-functional-to-class` and `convert-named-tuple-functional-to-class` as unsafe if they will remove comments (`UP013`, `UP014`) ([#14842](https://github.com/astral-sh/ruff/pull/14842))
+
+### Bug fixes
+
+- Raise syntax error for mixing `except` and `except*` ([#14895](https://github.com/astral-sh/ruff/pull/14895))
+- \[`flake8-bugbear`\] Fix `B028` to allow `stacklevel` to be explicitly assigned as a positional argument ([#14868](https://github.com/astral-sh/ruff/pull/14868))
+- \[`flake8-bugbear`\] Skip `B028` if `warnings.warn` is called with `*args` or `**kwargs` ([#14870](https://github.com/astral-sh/ruff/pull/14870))
+- \[`flake8-comprehensions`\] Skip iterables with named expressions in `unnecessary-map` (`C417`) ([#14827](https://github.com/astral-sh/ruff/pull/14827))
+- \[`flake8-pyi`\] Also remove `self` and `cls`'s annotation (`PYI034`) ([#14801](https://github.com/astral-sh/ruff/pull/14801))
+- \[`flake8-pytest-style`\] Fix `pytest-parametrize-names-wrong-type` (`PT006`) to edit both `argnames` and `argvalues` if both of them are single-element tuples/lists ([#14699](https://github.com/astral-sh/ruff/pull/14699))
+- \[`perflint`\] Improve autofix for `PERF401` ([#14369](https://github.com/astral-sh/ruff/pull/14369))
+- \[`pylint`\] Fix `PLW1508` false positive for default string created via a mult operation ([#14841](https://github.com/astral-sh/ruff/pull/14841))
+
+## 0.8.2
+
+### Preview features
+
+- \[`airflow`\] Avoid deprecated values (`AIR302`) ([#14582](https://github.com/astral-sh/ruff/pull/14582))
+- \[`airflow`\] Extend removed names for `AIR302` ([#14734](https://github.com/astral-sh/ruff/pull/14734))
+- \[`ruff`\] Extend `unnecessary-regular-expression` to non-literal strings (`RUF055`) ([#14679](https://github.com/astral-sh/ruff/pull/14679))
+- \[`ruff`\] Implement `used-dummy-variable` (`RUF052`) ([#14611](https://github.com/astral-sh/ruff/pull/14611))
+- \[`ruff`\] Implement `unnecessary-cast-to-int` (`RUF046`) ([#14697](https://github.com/astral-sh/ruff/pull/14697))
+
+### Rule changes
+
+- \[`airflow`\] Check `AIR001` from builtin or providers `operators` module ([#14631](https://github.com/astral-sh/ruff/pull/14631))
+- \[`flake8-pytest-style`\] Remove `@` in `pytest.mark.parametrize` rule messages ([#14770](https://github.com/astral-sh/ruff/pull/14770))
+- \[`pandas-vet`\] Skip rules if the `panda` module hasn't been seen ([#14671](https://github.com/astral-sh/ruff/pull/14671))
+- \[`pylint`\] Fix false negatives for `ascii` and `sorted` in `len-as-condition` (`PLC1802`) ([#14692](https://github.com/astral-sh/ruff/pull/14692))
+- \[`refurb`\] Guard `hashlib` imports and mark `hashlib-digest-hex` fix as safe (`FURB181`) ([#14694](https://github.com/astral-sh/ruff/pull/14694))
+
+### Configuration
+
+- \[`flake8-import-conventions`\] Improve syntax check for aliases supplied in configuration for `unconventional-import-alias` (`ICN001`) ([#14745](https://github.com/astral-sh/ruff/pull/14745))
+
+### Bug fixes
+
+- Revert: [pyflakes] Avoid false positives in `@no_type_check` contexts (`F821`, `F722`) (#14615) ([#14726](https://github.com/astral-sh/ruff/pull/14726))
+- \[`pep8-naming`\] Avoid false positive for `class Bar(type(foo))` (`N804`) ([#14683](https://github.com/astral-sh/ruff/pull/14683))
+- \[`pycodestyle`\] Handle f-strings properly for `invalid-escape-sequence` (`W605`) ([#14748](https://github.com/astral-sh/ruff/pull/14748))
+- \[`pylint`\] Ignore `@overload` in `PLR0904` ([#14730](https://github.com/astral-sh/ruff/pull/14730))
+- \[`refurb`\] Handle non-finite decimals in `verbose-decimal-constructor` (`FURB157`) ([#14596](https://github.com/astral-sh/ruff/pull/14596))
+- \[`ruff`\] Avoid emitting `assignment-in-assert` when all references to the assigned variable are themselves inside `assert`s (`RUF018`) ([#14661](https://github.com/astral-sh/ruff/pull/14661))
+
+### Documentation
+
+- Improve docs for `flake8-use-pathlib` rules ([#14741](https://github.com/astral-sh/ruff/pull/14741))
+- Improve error messages and docs for `flake8-comprehensions` rules ([#14729](https://github.com/astral-sh/ruff/pull/14729))
+- \[`flake8-type-checking`\] Expands `TC006` docs to better explain itself ([#14749](https://github.com/astral-sh/ruff/pull/14749))
+
+## 0.8.1
+
+### Preview features
+
+- Formatter: Avoid invalid syntax for format-spec with quotes for all Python versions ([#14625](https://github.com/astral-sh/ruff/pull/14625))
+- Formatter: Consider quotes inside format-specs when choosing the quotes for an f-string ([#14493](https://github.com/astral-sh/ruff/pull/14493))
+- Formatter: Do not consider f-strings with escaped newlines as multiline ([#14624](https://github.com/astral-sh/ruff/pull/14624))
+- Formatter: Fix f-string formatting in assignment statement ([#14454](https://github.com/astral-sh/ruff/pull/14454))
+- Formatter: Fix unnecessary space around power operator (`**`) in overlong f-string expressions ([#14489](https://github.com/astral-sh/ruff/pull/14489))
+- \[`airflow`\] Avoid implicit `schedule` argument to `DAG` and `@dag` (`AIR301`) ([#14581](https://github.com/astral-sh/ruff/pull/14581))
+- \[`flake8-builtins`\] Exempt private built-in modules (`A005`) ([#14505](https://github.com/astral-sh/ruff/pull/14505))
+- \[`flake8-pytest-style`\] Fix `pytest.mark.parametrize` rules to check calls instead of decorators ([#14515](https://github.com/astral-sh/ruff/pull/14515))
+- \[`flake8-type-checking`\] Implement `runtime-cast-value` (`TC006`) ([#14511](https://github.com/astral-sh/ruff/pull/14511))
+- \[`flake8-type-checking`\] Implement `unquoted-type-alias` (`TC007`) and `quoted-type-alias` (`TC008`) ([#12927](https://github.com/astral-sh/ruff/pull/12927))
+- \[`flake8-use-pathlib`\] Recommend `Path.iterdir()` over `os.listdir()` (`PTH208`) ([#14509](https://github.com/astral-sh/ruff/pull/14509))
+- \[`pylint`\] Extend `invalid-envvar-default` to detect `os.environ.get` (`PLW1508`) ([#14512](https://github.com/astral-sh/ruff/pull/14512))
+- \[`pylint`\] Implement `len-test` (`PLC1802`) ([#14309](https://github.com/astral-sh/ruff/pull/14309))
+- \[`refurb`\] Fix bug where methods defined using lambdas were flagged by `FURB118` ([#14639](https://github.com/astral-sh/ruff/pull/14639))
+- \[`ruff`\] Auto-add `r` prefix when string has no backslashes for `unraw-re-pattern` (`RUF039`) ([#14536](https://github.com/astral-sh/ruff/pull/14536))
+- \[`ruff`\] Implement `invalid-assert-message-literal-argument` (`RUF040`) ([#14488](https://github.com/astral-sh/ruff/pull/14488))
+- \[`ruff`\] Implement `unnecessary-nested-literal` (`RUF041`) ([#14323](https://github.com/astral-sh/ruff/pull/14323))
+- \[`ruff`\] Implement `unnecessary-regular-expression` (`RUF055`) ([#14659](https://github.com/astral-sh/ruff/pull/14659))
+
+### Rule changes
+
+- Ignore more rules for stub files ([#14541](https://github.com/astral-sh/ruff/pull/14541))
+- \[`pep8-naming`\] Eliminate false positives for single-letter names (`N811`, `N814`) ([#14584](https://github.com/astral-sh/ruff/pull/14584))
+- \[`pyflakes`\] Avoid false positives in `@no_type_check` contexts (`F821`, `F722`) ([#14615](https://github.com/astral-sh/ruff/pull/14615))
+- \[`ruff`\] Detect redirected-noqa in file-level comments (`RUF101`) ([#14635](https://github.com/astral-sh/ruff/pull/14635))
+- \[`ruff`\] Mark fixes for `unsorted-dunder-all` and `unsorted-dunder-slots` as unsafe when there are complex comments in the sequence (`RUF022`, `RUF023`) ([#14560](https://github.com/astral-sh/ruff/pull/14560))
+
+### Bug fixes
+
+- Avoid fixing code to `None | None` for `redundant-none-literal` (`PYI061`) and `never-union` (`RUF020`) ([#14583](https://github.com/astral-sh/ruff/pull/14583), [#14589](https://github.com/astral-sh/ruff/pull/14589))
+- \[`flake8-bugbear`\] Fix `mutable-contextvar-default` to resolve annotated function calls properly (`B039`) ([#14532](https://github.com/astral-sh/ruff/pull/14532))
+- \[`flake8-pyi`, `ruff`\] Fix traversal of nested literals and unions (`PYI016`, `PYI051`, `PYI055`, `PYI062`, `RUF041`) ([#14641](https://github.com/astral-sh/ruff/pull/14641))
+- \[`flake8-pyi`\] Avoid rewriting invalid type expressions in `unnecessary-type-union` (`PYI055`) ([#14660](https://github.com/astral-sh/ruff/pull/14660))
+- \[`flake8-type-checking`\] Avoid syntax errors and type checking problem for quoted annotations autofix (`TC003`, `TC006`) ([#14634](https://github.com/astral-sh/ruff/pull/14634))
+- \[`pylint`\] Do not wrap function calls in parentheses in the fix for unnecessary-dunder-call (`PLC2801`) ([#14601](https://github.com/astral-sh/ruff/pull/14601))
+- \[`ruff`\] Handle `attrs`'s `auto_attribs` correctly (`RUF009`) ([#14520](https://github.com/astral-sh/ruff/pull/14520))
+
+## 0.8.0
+
+Check out the [blog post](https://astral.sh/blog/ruff-v0.8.0) for a migration guide and overview of the changes!
+
+### Breaking changes
+
+See also, the "Remapped rules" section which may result in disabled rules.
+
+- **Default to Python 3.9**
+
+    Ruff now defaults to Python 3.9 instead of 3.8 if no explicit Python version is configured using [`ruff.target-version`](https://docs.astral.sh/ruff/settings/#target-version) or [`project.requires-python`](https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#python-requires) ([#13896](https://github.com/astral-sh/ruff/pull/13896))
+
+- **Changed location of `pydoclint` diagnostics**
+
+    [`pydoclint`](https://docs.astral.sh/ruff/rules/#pydoclint-doc) diagnostics now point to the first-line of the problematic docstring. Previously, this was not the case.
+
+    If you've opted into these preview rules but have them suppressed using
+    [`noqa`](https://docs.astral.sh/ruff/linter/#error-suppression) comments in
+    some places, this change may mean that you need to move the `noqa` suppression
+    comments. Most users should be unaffected by this change.
+
+- **Use XDG (i.e. `~/.local/bin`) instead of the Cargo home directory in the standalone installer**
+
+    Previously, Ruff's installer used `$CARGO_HOME` or `~/.cargo/bin` for its target install directory. Now, Ruff will be installed into `$XDG_BIN_HOME`, `$XDG_DATA_HOME/../bin`, or `~/.local/bin` (in that order).
+
+    This change is only relevant to users of the standalone Ruff installer (using the shell or PowerShell script). If you installed Ruff using uv or pip, you should be unaffected.
+
+- **Changes to the line width calculation**
+
+    Ruff now uses a new version of the [unicode-width](https://github.com/unicode-rs/unicode-width) Rust crate to calculate the line width. In very rare cases, this may lead to lines containing Unicode characters being reformatted, or being considered too long when they were not before ([`E501`](https://docs.astral.sh/ruff/rules/line-too-long/)).
+
+### Removed Rules
+
+The following deprecated rules have been removed:
+
+- [`missing-type-self`](https://docs.astral.sh/ruff/rules/missing-type-self/) (`ANN101`)
+- [`missing-type-cls`](https://docs.astral.sh/ruff/rules/missing-type-cls/) (`ANN102`)
+- [`syntax-error`](https://docs.astral.sh/ruff/rules/syntax-error/) (`E999`)
+- [`pytest-missing-fixture-name-underscore`](https://docs.astral.sh/ruff/rules/pytest-missing-fixture-name-underscore/) (`PT004`)
+- [`pytest-incorrect-fixture-name-underscore`](https://docs.astral.sh/ruff/rules/pytest-incorrect-fixture-name-underscore/) (`PT005`)
+- [`unpacked-list-comprehension`](https://docs.astral.sh/ruff/rules/unpacked-list-comprehension/) (`UP027`)
+
+### Remapped rules
+
+The following rules have been remapped to new rule codes:
+
+- [`flake8-type-checking`](https://docs.astral.sh/ruff/rules/#flake8-type-checking-tc): `TCH` to `TC`
+
+### Stabilization
+
+The following rules have been stabilized and are no longer in preview:
+
+- [`builtin-import-shadowing`](https://docs.astral.sh/ruff/rules/builtin-import-shadowing/) (`A004`)
+- [`mutable-contextvar-default`](https://docs.astral.sh/ruff/rules/mutable-contextvar-default/) (`B039`)
+- [`fast-api-redundant-response-model`](https://docs.astral.sh/ruff/rules/fast-api-redundant-response-model/) (`FAST001`)
+- [`fast-api-non-annotated-dependency`](https://docs.astral.sh/ruff/rules/fast-api-non-annotated-dependency/) (`FAST002`)
+- [`dict-index-missing-items`](https://docs.astral.sh/ruff/rules/dict-index-missing-items/) (`PLC0206`)
+- [`pep484-style-positional-only-parameter`](https://docs.astral.sh/ruff/rules/pep484-style-positional-only-parameter/) (`PYI063`)
+- [`redundant-final-literal`](https://docs.astral.sh/ruff/rules/redundant-final-literal/) (`PYI064`)
+- [`bad-version-info-order`](https://docs.astral.sh/ruff/rules/bad-version-info-order/) (`PYI066`)
+- [`parenthesize-chained-operators`](https://docs.astral.sh/ruff/rules/parenthesize-chained-operators/) (`RUF021`)
+- [`unsorted-dunder-all`](https://docs.astral.sh/ruff/rules/unsorted-dunder-all/) (`RUF022`)
+- [`unsorted-dunder-slots`](https://docs.astral.sh/ruff/rules/unsorted-dunder-slots/) (`RUF023`)
+- [`assert-with-print-message`](https://docs.astral.sh/ruff/rules/assert-with-print-message/) (`RUF030`)
+- [`unnecessary-default-type-args`](https://docs.astral.sh/ruff/rules/unnecessary-default-type-args/) (`UP043`)
+
+The following behaviors have been stabilized:
+
+- [`ambiguous-variable-name`](https://docs.astral.sh/ruff/rules/ambiguous-variable-name/) (`E741`): Violations in stub files are now ignored. Stub authors typically don't control variable names.
+- [`printf-string-formatting`](https://docs.astral.sh/ruff/rules/printf-string-formatting/) (`UP031`): Report all `printf`-like usages even if no autofix is available
+
+The following fixes have been stabilized:
+
+- [`zip-instead-of-pairwise`](https://docs.astral.sh/ruff/rules/zip-instead-of-pairwise/) (`RUF007`)
+
+### Preview features
+
+- \[`flake8-datetimez`\] Exempt `min.time()` and `max.time()` (`DTZ901`) ([#14394](https://github.com/astral-sh/ruff/pull/14394))
+- \[`flake8-pie`\] Mark fix as unsafe if the following statement is a string literal (`PIE790`) ([#14393](https://github.com/astral-sh/ruff/pull/14393))
+- \[`flake8-pyi`\] New rule `redundant-none-literal` (`PYI061`) ([#14316](https://github.com/astral-sh/ruff/pull/14316))
+- \[`flake8-pyi`\] Add autofix for `redundant-numeric-union` (`PYI041`) ([#14273](https://github.com/astral-sh/ruff/pull/14273))
+- \[`ruff`\] New rule `map-int-version-parsing` (`RUF048`) ([#14373](https://github.com/astral-sh/ruff/pull/14373))
+- \[`ruff`\] New rule `redundant-bool-literal` (`RUF038`) ([#14319](https://github.com/astral-sh/ruff/pull/14319))
+- \[`ruff`\] New rule `unraw-re-pattern` (`RUF039`) ([#14446](https://github.com/astral-sh/ruff/pull/14446))
+- \[`pycodestyle`\] Exempt `pytest.importorskip()` calls (`E402`) ([#14474](https://github.com/astral-sh/ruff/pull/14474))
+- \[`pylint`\] Autofix suggests using sets when possible (`PLR1714`) ([#14372](https://github.com/astral-sh/ruff/pull/14372))
+
+### Rule changes
+
+- [`invalid-pyproject-toml`](https://docs.astral.sh/ruff/rules/invalid-pyproject-toml/) (`RUF200`): Updated to reflect the provisionally accepted [PEP 639](https://peps.python.org/pep-0639/).
+- \[`flake8-pyi`\] Avoid panic in unfixable case (`PYI041`) ([#14402](https://github.com/astral-sh/ruff/pull/14402))
+- \[`flake8-type-checking`\] Correctly handle quotes in subscript expression when generating an autofix ([#14371](https://github.com/astral-sh/ruff/pull/14371))
+- \[`pylint`\] Suggest correct autofix for `__contains__` (`PLC2801`) ([#14424](https://github.com/astral-sh/ruff/pull/14424))
+
+### Configuration
+
+- Ruff now emits a warning instead of an error when a configuration [`ignore`](https://docs.astral.sh/ruff/settings/#lint_ignore)s a rule that has been removed ([#14435](https://github.com/astral-sh/ruff/pull/14435))
+- Ruff now validates that `lint.flake8-import-conventions.aliases` only uses valid module names and aliases ([#14477](https://github.com/astral-sh/ruff/pull/14477))
+
 ## 0.7.4
 
 ### Preview features
@@ -117,7 +357,7 @@
 ### Preview features
 
 - Fix `E221` and `E222` to flag missing or extra whitespace around `==` operator ([#13890](https://github.com/astral-sh/ruff/pull/13890))
-- Formatter: Alternate quotes for strings inside f-strings in preview  ([#13860](https://github.com/astral-sh/ruff/pull/13860))
+- Formatter: Alternate quotes for strings inside f-strings in preview ([#13860](https://github.com/astral-sh/ruff/pull/13860))
 - Formatter: Join implicit concatenated strings when they fit on a line ([#13663](https://github.com/astral-sh/ruff/pull/13663))
 - \[`pylint`\] Restrict `iteration-over-set` to only work on sets of literals (`PLC0208`) ([#13731](https://github.com/astral-sh/ruff/pull/13731))
 
@@ -978,7 +1218,7 @@ The following deprecated CLI commands have been removed:
 ### Preview features
 
 - \[`flake8-bugbear`\] Implement `return-in-generator` (`B901`) ([#11644](https://github.com/astral-sh/ruff/pull/11644))
-- \[`flake8-pyi`\] Implement `PYI063` ([#11699](https://github.com/astral-sh/ruff/pull/11699))
+- \[`flake8-pyi`\] Implement `pep484-style-positional-only-parameter` (`PYI063`) ([#11699](https://github.com/astral-sh/ruff/pull/11699))
 - \[`pygrep_hooks`\] Check blanket ignores via file-level pragmas (`PGH004`) ([#11540](https://github.com/astral-sh/ruff/pull/11540))
 
 ### Rule changes
@@ -1132,7 +1372,7 @@ To read more about this exciting milestone, check out our [blog post](https://as
 ### Preview features
 
 - \[`pycodestyle`\] Ignore end-of-line comments when determining blank line rules ([#11342](https://github.com/astral-sh/ruff/pull/11342))
-- \[`pylint`\] Detect `pathlib.Path.open` calls in `unspecified-encoding` (`PLW1514`)  ([#11288](https://github.com/astral-sh/ruff/pull/11288))
+- \[`pylint`\] Detect `pathlib.Path.open` calls in `unspecified-encoding` (`PLW1514`) ([#11288](https://github.com/astral-sh/ruff/pull/11288))
 - \[`flake8-pyi`\] Implement `PYI059` (`generic-not-last-base-class`) ([#11233](https://github.com/astral-sh/ruff/pull/11233))
 - \[`flake8-pyi`\] Implement `PYI062` (`duplicate-literal-member`) ([#11269](https://github.com/astral-sh/ruff/pull/11269))
 
@@ -1507,7 +1747,7 @@ To setup `ruff server` with your editor, refer to the [README.md](https://github
 - \[`pycodestyle`\] Do not ignore lines before the first logical line in blank lines rules. ([#10382](https://github.com/astral-sh/ruff/pull/10382))
 - \[`pycodestyle`\] Do not trigger `E225` and `E275` when the next token is a ')' ([#10315](https://github.com/astral-sh/ruff/pull/10315))
 - \[`pylint`\] Avoid false-positive slot non-assignment for `__dict__` (`PLE0237`) ([#10348](https://github.com/astral-sh/ruff/pull/10348))
-- Gate f-string struct size test for Rustc \< 1.76 ([#10371](https://github.com/astral-sh/ruff/pull/10371))
+- Gate f-string struct size test for Rustc < 1.76 ([#10371](https://github.com/astral-sh/ruff/pull/10371))
 
 ### Documentation
 

CONTRIBUTING.md

@@ -139,7 +139,7 @@ At a high level, the steps involved in adding a new lint rule are as follows:
 1. Create a file for your rule (e.g., `crates/ruff_linter/src/rules/flake8_bugbear/rules/assert_false.rs`).
 
 1. In that file, define a violation struct (e.g., `pub struct AssertFalse`). You can grep for
-    `#[violation]` to see examples.
+    `#[derive(ViolationMetadata)]` to see examples.
 
 1. In that file, define a function that adds the violation to the diagnostic list as appropriate
     (e.g., `pub(crate) fn assert_false`) based on whatever inputs are required for the rule (e.g.,
@@ -863,7 +863,7 @@ each configuration file.
 
 The package root is used to determine a file's "module path". Consider, again, `baz.py`. In that
 case, `./my_project/src/foo` was identified as the package root, so the module path for `baz.py`
-would resolve to  `foo.bar.baz` — as computed by taking the relative path from the package root
+would resolve to `foo.bar.baz` — as computed by taking the relative path from the package root
 (inclusive of the root itself). The module path can be thought of as "the path you would use to
 import the module" (e.g., `import foo.bar.baz`).
 

Cargo.toml

@@ -65,7 +65,7 @@ compact_str = "0.8.0"
 criterion = { version = "0.5.1", default-features = false }
 crossbeam = { version = "0.8.4" }
 dashmap = { version = "6.0.1" }
-dir-test = { version = "0.3.0" }
+dir-test = { version = "0.4.0" }
 dunce = { version = "1.0.5" }
 drop_bomb = { version = "0.1.5" }
 env_logger = { version = "0.11.0" }
@@ -111,14 +111,15 @@ pathdiff = { version = "0.2.1" }
 pep440_rs = { version = "0.7.1" }
 pretty_assertions = "1.3.0"
 proc-macro2 = { version = "1.0.79" }
-pyproject-toml = { version = "0.9.0" }
+pyproject-toml = { version = "0.13.4" }
 quick-junit = { version = "0.5.0" }
 quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "254c749b02cde2fd29852a7463a33e800b771758" }
+# When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "3c7f1694c9efba751dbeeacfbc93b227586e316a" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -151,7 +152,7 @@ tracing-tree = { version = "0.4.0" }
 typed-arena = { version = "2.0.2" }
 unic-ucd-category = { version = "0.9" }
 unicode-ident = { version = "1.0.12" }
-unicode-width = { version = "0.1.11" }
+unicode-width = { version = "0.2.0" }
 unicode_names2 = { version = "1.2.2" }
 unicode-normalization = { version = "0.1.23" }
 ureq = { version = "2.9.6" }
@@ -248,10 +249,10 @@ debug = 1
 [profile.dist]
 inherits = "release"
 
-# Config for 'cargo dist'
+# Config for 'dist'
 [workspace.metadata.dist]
-# The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax)
-cargo-dist-version = "0.22.1"
+# The preferred dist version to use in CI (Cargo.toml SemVer syntax)
+cargo-dist-version = "0.25.2-prerelease.3"
 # CI backends to support
 ci = "github"
 # The installers to generate for each app
@@ -282,13 +283,13 @@ targets = [
 ]
 # Whether to auto-include files like READMEs, LICENSEs, and CHANGELOGs (default true)
 auto-includes = false
-# Whether cargo-dist should create a GitHub Release or use an existing draft
+# 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"
 # Whether CI should trigger releases with dispatches instead of tag pushes
 dispatch-releases = true
-# Which phase cargo-dist should use to create the GitHub release
+# Which phase dist should use to create the GitHub release
 github-release = "announce"
 # Whether CI should include auto-generated code to build local artifacts
 build-local-artifacts = false
@@ -297,14 +298,10 @@ local-artifacts-jobs = ["./build-binaries", "./build-docker"]
 # Publish jobs to run in CI
 publish-jobs = ["./publish-pypi", "./publish-wasm"]
 # Post-announce jobs to run in CI
-post-announce-jobs = [
-    "./notify-dependents",
-    "./publish-docs",
-    "./publish-playground",
-]
+post-announce-jobs = ["./notify-dependents", "./publish-docs", "./publish-playground"]
 # Custom permissions for GitHub Jobs
 github-custom-job-permissions = { "build-docker" = { packages = "write", contents = "read" }, "publish-wasm" = { contents = "read", id-token = "write", packages = "write" } }
 # Whether to install an updater program
 install-updater = false
 # Path that installers should place binaries in
-install-path = "CARGO_HOME"
+install-path = ["$XDG_BIN_HOME/", "$XDG_DATA_HOME/../bin", "~/.local/bin"]

README.md

@@ -119,6 +119,10 @@ For more, see the [documentation](https://docs.astral.sh/ruff/).
 Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 
 ```shell
+# With uv.
+uv add --dev ruff     # to add ruff to your project
+uv tool install ruff  # to install ruff globally
+
 # With pip.
 pip install ruff
 
@@ -136,8 +140,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.7.4/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.7.4/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.8.4/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.8.4/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -170,7 +174,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.7.4
+  rev: v0.8.4
   hooks:
     # Run the linter.
     - id: ruff
@@ -238,8 +242,8 @@ exclude = [
 line-length = 88
 indent-width = 4
 
-# Assume Python 3.8
-target-version = "py38"
+# Assume Python 3.9
+target-version = "py39"
 
 [lint]
 # Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.

clippy.toml

@@ -1,21 +1,25 @@
 doc-valid-idents = [
-  "..",
-  "CodeQL",
-  "FastAPI",
-  "IPython",
-  "LangChain",
-  "LibCST",
-  "McCabe",
-  "NumPy",
-  "SCREAMING_SNAKE_CASE",
-  "SQLAlchemy",
-  "StackOverflow",
-  "PyCharm",
+    "..",
+    "CodeQL",
+    "FastAPI",
+    "IPython",
+    "LangChain",
+    "LibCST",
+    "McCabe",
+    "NumPy",
+    "SCREAMING_SNAKE_CASE",
+    "SQLAlchemy",
+    "StackOverflow",
+    "PyCharm",
+    "SNMPv1",
+    "SNMPv2",
+    "SNMPv3",
+    "PyFlakes"
 ]
 
 ignore-interior-mutability = [
-  # Interned is read-only. The wrapped `Rc` never gets updated.
-  "ruff_formatter::format_element::Interned",
-  # The expression is read-only.
-  "ruff_python_ast::hashable::HashableExpr",
+    # Interned is read-only. The wrapped `Rc` never gets updated.
+    "ruff_formatter::format_element::Interned",
+    # The expression is read-only.
+    "ruff_python_ast::hashable::HashableExpr",
 ]

crates/red_knot/docs/tracing.md

@@ -103,7 +103,7 @@ called **once**.
 
 ## Profiling
 
-Red Knot generates a folded stack trace  to the current directory named `tracing.folded` when setting the environment variable `RED_KNOT_LOG_PROFILE` to `1` or `true`.
+Red Knot generates a folded stack trace to the current directory named `tracing.folded` when setting the environment variable `RED_KNOT_LOG_PROFILE` to `1` or `true`.
 
 ```bash
 RED_KNOT_LOG_PROFILE=1 red_knot -- --current-directory=../test -vvv

crates/red_knot/src/main.rs

@@ -5,6 +5,7 @@ use anyhow::{anyhow, Context};
 use clap::Parser;
 use colored::Colorize;
 use crossbeam::channel as crossbeam_channel;
+use python_version::PythonVersion;
 use red_knot_python_semantic::SitePackages;
 use red_knot_server::run_server;
 use red_knot_workspace::db::RootDatabase;
@@ -15,12 +16,11 @@ use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::diagnostic::Diagnostic;
 use ruff_db::system::{OsSystem, System, SystemPath, SystemPathBuf};
 use salsa::plumbing::ZalsaDatabase;
-use target_version::TargetVersion;
 
 use crate::logging::{setup_tracing, Verbosity};
 
 mod logging;
-mod target_version;
+mod python_version;
 mod verbosity;
 
 #[derive(Debug, Parser)]
@@ -34,54 +34,39 @@ struct Args {
     #[command(subcommand)]
     pub(crate) command: Option<Command>,
 
-    #[arg(
-        long,
-        help = "Changes the current working directory.",
-        long_help = "Changes the current working directory before any specified operations. This affects the workspace and configuration discovery.",
-        value_name = "PATH"
-    )]
-    current_directory: Option<SystemPathBuf>,
+    /// Run the command within the given project directory.
+    ///
+    /// All `pyproject.toml` files will be discovered by walking up the directory tree from the given project directory,
+    /// as will the project's virtual environment (`.venv`) unless the `venv-path` option is set.
+    ///
+    /// Other command-line arguments (such as relative paths) will be resolved relative to the current working directory.
+    #[arg(long, value_name = "PROJECT")]
+    project: Option<SystemPathBuf>,
 
-    #[arg(
-        long,
-        help = "Path to the virtual environment the project uses",
-        long_help = "\
-Path to the virtual environment the project uses. \
-If provided, red-knot will use the `site-packages` directory of this virtual environment \
-to resolve type information for the project's third-party dependencies.",
-        value_name = "PATH"
-    )]
+    /// Path to the virtual environment the project uses.
+    ///
+    /// If provided, red-knot will use the `site-packages` directory of this virtual environment
+    /// to resolve type information for the project's third-party dependencies.
+    #[arg(long, value_name = "PATH")]
     venv_path: Option<SystemPathBuf>,
 
-    #[arg(
-        long,
-        value_name = "DIRECTORY",
-        help = "Custom directory to use for stdlib typeshed stubs"
-    )]
-    custom_typeshed_dir: Option<SystemPathBuf>,
+    /// Custom directory to use for stdlib typeshed stubs.
+    #[arg(long, value_name = "PATH", alias = "custom-typeshed-dir")]
+    typeshed: Option<SystemPathBuf>,
 
-    #[arg(
-        long,
-        value_name = "PATH",
-        help = "Additional path to use as a module-resolution source (can be passed multiple times)"
-    )]
+    /// Additional path to use as a module-resolution source (can be passed multiple times).
+    #[arg(long, value_name = "PATH")]
     extra_search_path: Option<Vec<SystemPathBuf>>,
 
-    #[arg(
-        long,
-        help = "Python version to assume when resolving types",
-        value_name = "VERSION"
-    )]
-    target_version: Option<TargetVersion>,
+    /// Python version to assume when resolving types.
+    #[arg(long, value_name = "VERSION", alias = "target-version")]
+    python_version: Option<PythonVersion>,
 
     #[clap(flatten)]
     verbosity: Verbosity,
 
-    #[arg(
-        long,
-        help = "Run in watch mode by re-running whenever files change",
-        short = 'W'
-    )]
+    /// Run in watch mode by re-running whenever files change.
+    #[arg(long, short = 'W')]
     watch: bool,
 }
 
@@ -89,8 +74,8 @@ impl Args {
     fn to_configuration(&self, cli_cwd: &SystemPath) -> Configuration {
         let mut configuration = Configuration::default();
 
-        if let Some(target_version) = self.target_version {
-            configuration.target_version = Some(target_version.into());
+        if let Some(python_version) = self.python_version {
+            configuration.python_version = Some(python_version.into());
         }
 
         if let Some(venv_path) = &self.venv_path {
@@ -99,9 +84,8 @@ impl Args {
             });
         }
 
-        if let Some(custom_typeshed_dir) = &self.custom_typeshed_dir {
-            configuration.search_paths.custom_typeshed =
-                Some(SystemPath::absolute(custom_typeshed_dir, cli_cwd));
+        if let Some(typeshed) = &self.typeshed {
+            configuration.search_paths.typeshed = Some(SystemPath::absolute(typeshed, cli_cwd));
         }
 
         if let Some(extra_search_paths) = &self.extra_search_path {
@@ -167,15 +151,13 @@ fn run() -> anyhow::Result<ExitStatus> {
     };
 
     let cwd = args
-        .current_directory
+        .project
         .as_ref()
         .map(|cwd| {
             if cwd.as_std_path().is_dir() {
                 Ok(SystemPath::absolute(cwd, &cli_base_path))
             } else {
-                Err(anyhow!(
-                    "Provided current-directory path `{cwd}` is not a directory"
-                ))
+                Err(anyhow!("Provided project path `{cwd}` is not a directory"))
             }
         })
         .transpose()?
@@ -297,7 +279,7 @@ impl MainLoop {
         while let Ok(message) = self.receiver.recv() {
             match message {
                 MainLoopMessage::CheckWorkspace => {
-                    let db = db.snapshot();
+                    let db = db.clone();
                     let sender = self.sender.clone();
 
                     // Spawn a new task that checks the workspace. This needs to be done in a separate thread

crates/red_knot/src/python_version.rs

@@ -0,0 +1,68 @@
+/// Enumeration of all supported Python versions
+///
+/// TODO: unify with the `PythonVersion` enum in the linter/formatter crates?
+#[derive(Copy, Clone, Hash, Debug, PartialEq, Eq, PartialOrd, Ord, Default, clap::ValueEnum)]
+pub enum PythonVersion {
+    #[value(name = "3.7")]
+    Py37,
+    #[value(name = "3.8")]
+    Py38,
+    #[default]
+    #[value(name = "3.9")]
+    Py39,
+    #[value(name = "3.10")]
+    Py310,
+    #[value(name = "3.11")]
+    Py311,
+    #[value(name = "3.12")]
+    Py312,
+    #[value(name = "3.13")]
+    Py313,
+}
+
+impl PythonVersion {
+    const fn as_str(self) -> &'static str {
+        match self {
+            Self::Py37 => "3.7",
+            Self::Py38 => "3.8",
+            Self::Py39 => "3.9",
+            Self::Py310 => "3.10",
+            Self::Py311 => "3.11",
+            Self::Py312 => "3.12",
+            Self::Py313 => "3.13",
+        }
+    }
+}
+
+impl std::fmt::Display for PythonVersion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+impl From<PythonVersion> for red_knot_python_semantic::PythonVersion {
+    fn from(value: PythonVersion) -> Self {
+        match value {
+            PythonVersion::Py37 => Self::PY37,
+            PythonVersion::Py38 => Self::PY38,
+            PythonVersion::Py39 => Self::PY39,
+            PythonVersion::Py310 => Self::PY310,
+            PythonVersion::Py311 => Self::PY311,
+            PythonVersion::Py312 => Self::PY312,
+            PythonVersion::Py313 => Self::PY313,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::python_version::PythonVersion;
+
+    #[test]
+    fn same_default_as_python_version() {
+        assert_eq!(
+            red_knot_python_semantic::PythonVersion::from(PythonVersion::default()),
+            red_knot_python_semantic::PythonVersion::default()
+        );
+    }
+}

crates/red_knot/src/target_version.rs

@@ -1,62 +0,0 @@
-/// Enumeration of all supported Python versions
-///
-/// TODO: unify with the `PythonVersion` enum in the linter/formatter crates?
-#[derive(Copy, Clone, Hash, Debug, PartialEq, Eq, PartialOrd, Ord, Default, clap::ValueEnum)]
-pub enum TargetVersion {
-    Py37,
-    Py38,
-    #[default]
-    Py39,
-    Py310,
-    Py311,
-    Py312,
-    Py313,
-}
-
-impl TargetVersion {
-    const fn as_str(self) -> &'static str {
-        match self {
-            Self::Py37 => "py37",
-            Self::Py38 => "py38",
-            Self::Py39 => "py39",
-            Self::Py310 => "py310",
-            Self::Py311 => "py311",
-            Self::Py312 => "py312",
-            Self::Py313 => "py313",
-        }
-    }
-}
-
-impl std::fmt::Display for TargetVersion {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.as_str())
-    }
-}
-
-impl From<TargetVersion> for red_knot_python_semantic::PythonVersion {
-    fn from(value: TargetVersion) -> Self {
-        match value {
-            TargetVersion::Py37 => Self::PY37,
-            TargetVersion::Py38 => Self::PY38,
-            TargetVersion::Py39 => Self::PY39,
-            TargetVersion::Py310 => Self::PY310,
-            TargetVersion::Py311 => Self::PY311,
-            TargetVersion::Py312 => Self::PY312,
-            TargetVersion::Py313 => Self::PY313,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::target_version::TargetVersion;
-    use red_knot_python_semantic::PythonVersion;
-
-    #[test]
-    fn same_default_as_python_version() {
-        assert_eq!(
-            PythonVersion::from(TargetVersion::default()),
-            PythonVersion::default()
-        );
-    }
-}

crates/red_knot/tests/file_watching.rs

@@ -1,26 +1,23 @@
 #![allow(clippy::disallowed_names)]
 
 use std::io::Write;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use anyhow::{anyhow, Context};
-
 use red_knot_python_semantic::{resolve_module, ModuleName, Program, PythonVersion, SitePackages};
 use red_knot_workspace::db::{Db, RootDatabase};
-use red_knot_workspace::watch;
-use red_knot_workspace::watch::{directory_watcher, WorkspaceWatcher};
+use red_knot_workspace::watch::{directory_watcher, ChangeEvent, WorkspaceWatcher};
 use red_knot_workspace::workspace::settings::{Configuration, SearchPathConfiguration};
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::files::{system_path_to_file, File, FileError};
 use ruff_db::source::source_text;
 use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
-use ruff_db::testing::setup_logging;
 use ruff_db::Upcast;
 
 struct TestCase {
     db: RootDatabase,
     watcher: Option<WorkspaceWatcher>,
-    changes_receiver: crossbeam::channel::Receiver<Vec<watch::ChangeEvent>>,
+    changes_receiver: crossbeam::channel::Receiver<Vec<ChangeEvent>>,
     /// The temporary directory that contains the test files.
     /// We need to hold on to it in the test case or the temp files get deleted.
     _temp_dir: tempfile::TempDir,
@@ -41,44 +38,87 @@ impl TestCase {
         &self.db
     }
 
-    fn stop_watch(&mut self) -> Vec<watch::ChangeEvent> {
-        self.try_stop_watch(Duration::from_secs(10))
-            .expect("Expected watch changes but observed none")
+    #[track_caller]
+    fn stop_watch<M>(&mut self, matcher: M) -> Vec<ChangeEvent>
+    where
+        M: MatchEvent,
+    {
+        // track_caller is unstable for lambdas -> That's why this is a fn
+        #[track_caller]
+        fn panic_with_formatted_events(events: Vec<ChangeEvent>) -> Vec<ChangeEvent> {
+            panic!(
+                "Didn't observe expected change:\n{}",
+                events
+                    .into_iter()
+                    .map(|event| format!("  - {event:?}"))
+                    .collect::<Vec<_>>()
+                    .join("\n")
+            )
+        }
+
+        self.try_stop_watch(matcher, Duration::from_secs(10))
+            .unwrap_or_else(panic_with_formatted_events)
     }
 
-    fn try_stop_watch(&mut self, timeout: Duration) -> Option<Vec<watch::ChangeEvent>> {
+    fn try_stop_watch<M>(
+        &mut self,
+        mut matcher: M,
+        timeout: Duration,
+    ) -> Result<Vec<ChangeEvent>, Vec<ChangeEvent>>
+    where
+        M: MatchEvent,
+    {
+        tracing::debug!("Try stopping watch with timeout {:?}", timeout);
+
         let watcher = self
             .watcher
             .take()
             .expect("Cannot call `stop_watch` more than once");
 
-        let mut all_events = self
-            .changes_receiver
-            .recv_timeout(timeout)
-            .unwrap_or_default();
-        watcher.flush();
-        watcher.stop();
+        let start = Instant::now();
+        let mut all_events = Vec::new();
 
+        loop {
+            let events = self
+                .changes_receiver
+                .recv_timeout(Duration::from_millis(100))
+                .unwrap_or_default();
+
+            if events
+                .iter()
+                .any(|event| matcher.match_event(event) || event.is_rescan())
+            {
+                all_events.extend(events);
+                break;
+            }
+
+            all_events.extend(events);
+
+            if start.elapsed() > timeout {
+                return Err(all_events);
+            }
+        }
+
+        watcher.flush();
+        tracing::debug!("Flushed file watcher");
+        watcher.stop();
+        tracing::debug!("Stopping file watcher");
+
+        // Consume remaining events
         for event in &self.changes_receiver {
             all_events.extend(event);
         }
 
-        if all_events.is_empty() {
-            return None;
-        }
-
-        Some(all_events)
+        Ok(all_events)
     }
 
-    fn take_watch_changes(&self) -> Vec<watch::ChangeEvent> {
+    fn take_watch_changes(&self) -> Vec<ChangeEvent> {
         self.try_take_watch_changes(Duration::from_secs(10))
             .expect("Expected watch changes but observed none")
     }
 
-    fn try_take_watch_changes(&self, timeout: Duration) -> Option<Vec<watch::ChangeEvent>> {
-        let Some(watcher) = &self.watcher else {
-            return None;
-        };
+    fn try_take_watch_changes(&self, timeout: Duration) -> Option<Vec<ChangeEvent>> {
+        let watcher = self.watcher.as_ref()?;
 
         let mut all_events = self
             .changes_receiver
@@ -100,7 +140,7 @@ impl TestCase {
         Some(all_events)
     }
 
-    fn apply_changes(&mut self, changes: Vec<watch::ChangeEvent>) {
+    fn apply_changes(&mut self, changes: Vec<ChangeEvent>) {
         self.db.apply_changes(changes, Some(&self.configuration));
     }
 
@@ -136,6 +176,23 @@ impl TestCase {
     }
 }
 
+trait MatchEvent {
+    fn match_event(&mut self, event: &ChangeEvent) -> bool;
+}
+
+fn event_for_file(name: &str) -> impl MatchEvent + '_ {
+    |event: &ChangeEvent| event.file_name() == Some(name)
+}
+
+impl<F> MatchEvent for F
+where
+    F: FnMut(&ChangeEvent) -> bool,
+{
+    fn match_event(&mut self, event: &ChangeEvent) -> bool {
+        (*self)(event)
+    }
+}
+
 trait SetupFiles {
     fn setup(self, root_path: &SystemPath, workspace_path: &SystemPath) -> anyhow::Result<()>;
 }
@@ -225,7 +282,7 @@ where
         .extra_paths
         .iter()
         .flatten()
-        .chain(search_paths.custom_typeshed.iter())
+        .chain(search_paths.typeshed.iter())
         .chain(search_paths.site_packages.iter().flat_map(|site_packages| {
             if let SitePackages::Known(path) = site_packages {
                 path.as_slice()
@@ -239,7 +296,7 @@ where
     }
 
     let configuration = Configuration {
-        target_version: Some(PythonVersion::PY312),
+        python_version: Some(PythonVersion::PY312),
         search_paths,
     };
 
@@ -311,7 +368,7 @@ fn new_file() -> anyhow::Result<()> {
 
     std::fs::write(foo_path.as_std_path(), "print('Hello')")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -334,7 +391,7 @@ fn new_ignored_file() -> anyhow::Result<()> {
 
     std::fs::write(foo_path.as_std_path(), "print('Hello')")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -356,7 +413,7 @@ fn changed_file() -> anyhow::Result<()> {
 
     update_file(&foo_path, "print('Version 2')")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     assert!(!changes.is_empty());
 
@@ -381,7 +438,7 @@ fn deleted_file() -> anyhow::Result<()> {
 
     std::fs::remove_file(foo_path.as_std_path())?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -413,7 +470,7 @@ fn move_file_to_trash() -> anyhow::Result<()> {
         trash_path.join("foo.py").as_std_path(),
     )?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -445,7 +502,7 @@ fn move_file_to_workspace() -> anyhow::Result<()> {
 
     std::fs::rename(foo_path.as_std_path(), foo_in_workspace_path.as_std_path())?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -473,7 +530,7 @@ fn rename_file() -> anyhow::Result<()> {
 
     std::fs::rename(foo_path.as_std_path(), bar_path.as_std_path())?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("bar.py"));
 
     case.apply_changes(changes);
 
@@ -517,7 +574,7 @@ fn directory_moved_to_workspace() -> anyhow::Result<()> {
     std::fs::rename(sub_original_path.as_std_path(), sub_new_path.as_std_path())
         .with_context(|| "Failed to move sub directory")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("sub"));
 
     case.apply_changes(changes);
 
@@ -576,7 +633,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
     std::fs::rename(sub_path.as_std_path(), trashed_sub.as_std_path())
         .with_context(|| "Failed to move the sub directory to the trash")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("sub"));
 
     case.apply_changes(changes);
 
@@ -638,7 +695,8 @@ fn directory_renamed() -> anyhow::Result<()> {
     std::fs::rename(sub_path.as_std_path(), foo_baz.as_std_path())
         .with_context(|| "Failed to move the sub directory")?;
 
-    let changes = case.stop_watch();
+    // Linux and windows only emit an event for the newly created root directory, but not for every new component.
+    let changes = case.stop_watch(event_for_file("sub"));
 
     case.apply_changes(changes);
 
@@ -711,7 +769,7 @@ fn directory_deleted() -> anyhow::Result<()> {
     std::fs::remove_dir_all(sub_path.as_std_path())
         .with_context(|| "Failed to remove the sub directory")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("sub"));
 
     case.apply_changes(changes);
 
@@ -748,7 +806,7 @@ fn search_path() -> anyhow::Result<()> {
 
     std::fs::write(site_packages.join("a.py").as_std_path(), "class A: ...")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("a.py"));
 
     case.apply_changes(changes);
 
@@ -779,7 +837,7 @@ fn add_search_path() -> anyhow::Result<()> {
 
     std::fs::write(site_packages.join("a.py").as_std_path(), "class A: ...")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("a.py"));
 
     case.apply_changes(changes);
 
@@ -808,9 +866,9 @@ fn remove_search_path() -> anyhow::Result<()> {
 
     std::fs::write(site_packages.join("a.py").as_std_path(), "class A: ...")?;
 
-    let changes = case.try_stop_watch(Duration::from_millis(100));
+    let changes = case.try_stop_watch(|_: &ChangeEvent| true, Duration::from_millis(100));
 
-    assert_eq!(changes, None);
+    assert_eq!(changes, Err(vec![]));
 
     Ok(())
 }
@@ -830,7 +888,7 @@ fn changed_versions_file() -> anyhow::Result<()> {
             Ok(())
         },
         |root_path, _workspace_path| SearchPathConfiguration {
-            custom_typeshed: Some(root_path.join("typeshed")),
+            typeshed: Some(root_path.join("typeshed")),
             ..SearchPathConfiguration::default()
         },
     )?;
@@ -848,7 +906,7 @@ fn changed_versions_file() -> anyhow::Result<()> {
         "os: 3.0-",
     )?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("VERSIONS"));
 
     case.apply_changes(changes);
 
@@ -901,7 +959,7 @@ fn hard_links_in_workspace() -> anyhow::Result<()> {
     // Write to the hard link target.
     update_file(foo_path, "print('Version 2')").context("Failed to update foo.py")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -972,7 +1030,7 @@ fn hard_links_to_target_outside_workspace() -> anyhow::Result<()> {
     // Write to the hard link target.
     update_file(foo_path, "print('Version 2')").context("Failed to update foo.py")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(ChangeEvent::is_changed);
 
     case.apply_changes(changes);
 
@@ -1011,7 +1069,7 @@ mod unix {
         )
         .with_context(|| "Failed to set file permissions.")?;
 
-        let changes = case.stop_watch();
+        let changes = case.stop_watch(event_for_file("foo.py"));
 
         case.apply_changes(changes);
 
@@ -1109,7 +1167,7 @@ mod unix {
         update_file(baz_workspace, "def baz(): print('Version 3')")
             .context("Failed to update bar/baz.py")?;
 
-        let changes = case.stop_watch();
+        let changes = case.stop_watch(event_for_file("baz.py"));
 
         case.apply_changes(changes);
 
@@ -1180,7 +1238,7 @@ mod unix {
         update_file(&patched_bar_baz, "def baz(): print('Version 2')")
             .context("Failed to update bar/baz.py")?;
 
-        let changes = case.stop_watch();
+        let changes = case.stop_watch(event_for_file("baz.py"));
 
         case.apply_changes(changes);
 
@@ -1288,7 +1346,7 @@ mod unix {
         update_file(&baz_original, "def baz(): print('Version 2')")
             .context("Failed to update bar/baz.py")?;
 
-        let changes = case.stop_watch();
+        let changes = case.stop_watch(event_for_file("baz.py"));
 
         case.apply_changes(changes);
 
@@ -1342,7 +1400,7 @@ fn nested_packages_delete_root() -> anyhow::Result<()> {
 
     std::fs::remove_file(case.workspace_path("pyproject.toml").as_std_path())?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(ChangeEvent::is_deleted);
 
     case.apply_changes(changes);
 
@@ -1354,7 +1412,6 @@ fn nested_packages_delete_root() -> anyhow::Result<()> {
 
 #[test]
 fn added_package() -> anyhow::Result<()> {
-    let _ = setup_logging();
     let mut case = setup([
         (
             "pyproject.toml",
@@ -1396,7 +1453,7 @@ fn added_package() -> anyhow::Result<()> {
     )
     .context("failed to write pyproject.toml for package b")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("pyproject.toml"));
 
     case.apply_changes(changes);
 
@@ -1439,7 +1496,7 @@ fn removed_package() -> anyhow::Result<()> {
     std::fs::remove_dir_all(case.workspace_path("packages/b").as_std_path())
         .context("failed to remove package 'b'")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(ChangeEvent::is_deleted);
 
     case.apply_changes(changes);
 

crates/red_knot_python_semantic/Cargo.toml

@@ -13,6 +13,7 @@ license = { workspace = true }
 [dependencies]
 ruff_db = { workspace = true }
 ruff_index = { workspace = true }
+ruff_macros = { workspace = true }
 ruff_python_ast = { workspace = true }
 ruff_python_parser = { workspace = true }
 ruff_python_stdlib = { workspace = true }
@@ -25,6 +26,7 @@ bitflags = { workspace = true }
 camino = { workspace = true }
 compact_str = { workspace = true }
 countme = { workspace = true }
+drop_bomb = { workspace = true }
 indexmap = { workspace = true }
 itertools = { workspace = true }
 ordermap = { workspace = true }
@@ -49,6 +51,11 @@ anyhow = { workspace = true }
 dir-test = { workspace = true }
 insta = { workspace = true }
 tempfile = { workspace = true }
+quickcheck = { version = "1.0.3", default-features = false }
+quickcheck_macros = { version = "1.0.0" }
+
+[features]
+serde = ["ruff_db/serde", "dep:serde"]
 
 [lints]
 workspace = true

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

@@ -0,0 +1,94 @@
+# `Annotated`
+
+`Annotated` attaches arbitrary metadata to a given type.
+
+## Usages
+
+`Annotated[T, ...]` is equivalent to `T`: All metadata arguments are simply ignored.
+
+```py
+from typing_extensions import Annotated
+
+def _(x: Annotated[int, "foo"]):
+    reveal_type(x)  # revealed: int
+
+def _(x: Annotated[int, lambda: 0 + 1 * 2 // 3, _(4)]):
+    reveal_type(x)  # revealed: int
+
+def _(x: Annotated[int, "arbitrary", "metadata", "elements", "are", "fine"]):
+    reveal_type(x)  # revealed: int
+
+def _(x: Annotated[tuple[str, int], bytes]):
+    reveal_type(x)  # revealed: tuple[str, int]
+```
+
+## Parameterization
+
+It is invalid to parameterize `Annotated` with less than two arguments.
+
+```py
+from typing_extensions import Annotated
+
+# error: [invalid-type-form] "`Annotated` requires at least two arguments when used in an annotation or type expression"
+def _(x: Annotated):
+    reveal_type(x)  # revealed: Unknown
+
+def _(flag: bool):
+    if flag:
+        X = Annotated
+    else:
+        X = bool
+
+    # error: [invalid-type-form] "`Annotated` requires at least two arguments when used in an annotation or type expression"
+    def f(y: X):
+        reveal_type(y)  # revealed: Unknown | bool
+
+# error: [invalid-type-form] "`Annotated` requires at least two arguments when used in an annotation or type expression"
+def _(x: Annotated | bool):
+    reveal_type(x)  # revealed: Unknown | bool
+
+# error: [invalid-type-form]
+def _(x: Annotated[()]):
+    reveal_type(x)  # revealed: Unknown
+
+# error: [invalid-type-form]
+def _(x: Annotated[int]):
+    # `Annotated[T]` is invalid and will raise an error at runtime,
+    # but we treat it the same as `T` to provide better diagnostics later on.
+    # The subscription itself is still reported, regardless.
+    # Same for the `(int,)` form below.
+    reveal_type(x)  # revealed: int
+
+# error: [invalid-type-form]
+def _(x: Annotated[(int,)]):
+    reveal_type(x)  # revealed: int
+```
+
+## Inheritance
+
+### Correctly parameterized
+
+Inheriting from `Annotated[T, ...]` is equivalent to inheriting from `T` itself.
+
+```py
+from typing_extensions import Annotated
+
+# TODO: False positive
+# error: [invalid-base]
+class C(Annotated[int, "foo"]): ...
+
+# TODO: Should be `tuple[Literal[C], Literal[int], Literal[object]]`
+reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Unknown, Literal[object]]
+```
+
+### Not parameterized
+
+```py
+from typing_extensions import Annotated
+
+# At runtime, this is an error.
+# error: [invalid-base]
+class C(Annotated): ...
+
+reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Unknown, Literal[object]]
+```

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

@@ -0,0 +1,83 @@
+# Any
+
+## Annotation
+
+`typing.Any` is a way to name the Any type.
+
+```py
+from typing import Any
+
+x: Any = 1
+x = "foo"
+
+def f():
+    reveal_type(x)  # revealed: Any
+```
+
+## Aliased to a different name
+
+If you alias `typing.Any` to another name, we still recognize that as a spelling of the Any type.
+
+```py
+from typing import Any as RenamedAny
+
+x: RenamedAny = 1
+x = "foo"
+
+def f():
+    reveal_type(x)  # revealed: Any
+```
+
+## Shadowed class
+
+If you define your own class named `Any`, using that in a type expression refers to your class, and
+isn't a spelling of the Any type.
+
+```py
+class Any: ...
+
+x: Any
+
+def f():
+    reveal_type(x)  # revealed: Any
+
+# This verifies that we're not accidentally seeing typing.Any, since str is assignable
+# to that but not to our locally defined class.
+y: Any = "not an Any"  # error: [invalid-assignment]
+```
+
+## Subclass
+
+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`.
+
+```py
+from typing import Any
+
+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]
+
+def _(s: Subclass):
+    reveal_type(s)  # revealed: Subclass
+```
+
+## Invalid
+
+`Any` cannot be parameterized:
+
+```py
+from typing import Any
+
+# error: [invalid-type-form] "Type `typing.Any` expected no type parameter"
+def f(x: Any[int]):
+    reveal_type(x)  # revealed: Unknown
+```

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

@@ -45,19 +45,19 @@ def f():
     # TODO: This should be Color.RED
     reveal_type(b1)  # revealed: Literal[0]
 
-# error: [invalid-literal-parameter]
+# error: [invalid-type-form]
 invalid1: Literal[3 + 4]
-# error: [invalid-literal-parameter]
+# error: [invalid-type-form]
 invalid2: Literal[4 + 3j]
-# error: [invalid-literal-parameter]
+# error: [invalid-type-form]
 invalid3: Literal[(3, 4)]
 
 hello = "hello"
 invalid4: Literal[
-    1 + 2,  # error: [invalid-literal-parameter]
+    1 + 2,  # error: [invalid-type-form]
     "foo",
-    hello,  # error: [invalid-literal-parameter]
-    (1, 2, 3),  # error: [invalid-literal-parameter]
+    hello,  # error: [invalid-type-form]
+    (1, 2, 3),  # error: [invalid-type-form]
 ]
 ```
 
@@ -78,7 +78,7 @@ from other import Literal
 a1: Literal[26]
 
 def f():
-    reveal_type(a1)  # revealed: @Todo
+    reveal_type(a1)  # revealed: @Todo(generics)
 ```
 
 ## Detecting typing_extensions.Literal
@@ -91,3 +91,13 @@ a1: Literal[26]
 def f():
     reveal_type(a1)  # revealed: Literal[26]
 ```
+
+## Invalid
+
+```py
+from typing import Literal
+
+# error: [invalid-type-form] "`Literal` requires at least one argument when used in a type expression"
+def _(x: Literal):
+    reveal_type(x)  # revealed: Unknown
+```

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

@@ -0,0 +1,150 @@
+# `LiteralString`
+
+`LiteralString` represents a string that is either defined directly within the source code or is
+made up of such components.
+
+Parts of the testcases defined here were adapted from [the specification's examples][1].
+
+## Usages
+
+### Valid places
+
+It can be used anywhere a type is accepted:
+
+```py
+from typing_extensions import LiteralString
+
+x: LiteralString
+
+def f():
+    reveal_type(x)  # revealed: LiteralString
+```
+
+### Within `Literal`
+
+`LiteralString` cannot be used within `Literal`:
+
+```py
+from typing_extensions import Literal, LiteralString
+
+bad_union: Literal["hello", LiteralString]  # error: [invalid-type-form]
+bad_nesting: Literal[LiteralString]  # error: [invalid-type-form]
+```
+
+### Parameterized
+
+`LiteralString` cannot be parameterized.
+
+```py
+from typing_extensions import LiteralString
+
+a: LiteralString[str]  # error: [invalid-type-form]
+b: LiteralString["foo"]  # error: [invalid-type-form]
+```
+
+### As a base class
+
+Subclassing `LiteralString` leads to a runtime error.
+
+```py
+from typing_extensions import LiteralString
+
+class C(LiteralString): ...  # error: [invalid-base]
+```
+
+## Inference
+
+### Common operations
+
+```py
+from typing_extensions import LiteralString
+
+foo: LiteralString = "foo"
+reveal_type(foo)  # revealed: Literal["foo"]
+
+bar: LiteralString = "bar"
+reveal_type(foo + bar)  # revealed: Literal["foobar"]
+
+baz: LiteralString = "baz"
+baz += foo
+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(Attribute access on `StringLiteral` types)
+
+template: LiteralString = "{}, {}"
+reveal_type(template)  # revealed: Literal["{}, {}"]
+# TODO: Infer `LiteralString`
+reveal_type(template.format(foo, bar))  # revealed: @Todo(Attribute access on `StringLiteral` types)
+```
+
+### Assignability
+
+`Literal[""]` is assignable to `LiteralString`, and `LiteralString` is assignable to `str`, but not
+vice versa.
+
+```py
+from typing_extensions import Literal, LiteralString
+
+def _(flag: bool):
+    foo_1: Literal["foo"] = "foo"
+    bar_1: LiteralString = foo_1  # fine
+
+    foo_2 = "foo" if flag else "bar"
+    reveal_type(foo_2)  # revealed: Literal["foo", "bar"]
+    bar_2: LiteralString = foo_2  # fine
+
+    foo_3: LiteralString = "foo" * 1_000_000_000
+    bar_3: str = foo_2  # fine
+
+    baz_1: str = str()
+    qux_1: LiteralString = baz_1  # error: [invalid-assignment]
+
+    baz_2: LiteralString = "baz" * 1_000_000_000
+    qux_2: Literal["qux"] = baz_2  # error: [invalid-assignment]
+
+    baz_3 = "foo" if flag else 1
+    reveal_type(baz_3)  # revealed: Literal["foo"] | Literal[1]
+    qux_3: LiteralString = baz_3  # error: [invalid-assignment]
+```
+
+### Narrowing
+
+```py
+from typing_extensions import LiteralString
+
+lorem: LiteralString = "lorem" * 1_000_000_000
+
+reveal_type(lorem)  # revealed: LiteralString
+
+if lorem == "ipsum":
+    reveal_type(lorem)  # revealed: Literal["ipsum"]
+
+reveal_type(lorem)  # revealed: LiteralString
+
+if "" < lorem == "ipsum":
+    reveal_type(lorem)  # revealed: Literal["ipsum"]
+```
+
+## `typing.LiteralString`
+
+`typing.LiteralString` is only available in Python 3.11 and later:
+
+```toml
+[environment]
+python-version = "3.11"
+```
+
+```py
+from typing import LiteralString
+
+x: LiteralString = "foo"
+
+def f():
+    reveal_type(x)  # revealed: LiteralString
+```
+
+[1]: https://typing.readthedocs.io/en/latest/spec/literal.html#literalstring

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

@@ -0,0 +1,64 @@
+# NoReturn & Never
+
+`NoReturn` is used to annotate the return type for functions that never return. `Never` is the
+bottom type, representing the empty set of Python objects. These two annotations can be used
+interchangeably.
+
+## Function Return Type Annotation
+
+```py
+from typing import NoReturn
+
+def stop() -> NoReturn:
+    raise RuntimeError("no way")
+
+# revealed: Never
+reveal_type(stop())
+```
+
+## Assignment
+
+```py
+from typing_extensions import NoReturn, Never, Any
+
+# error: [invalid-type-form] "Type `typing.Never` expected no type parameter"
+x: Never[int]
+a1: NoReturn
+a2: Never
+b1: Any
+b2: int
+
+def f():
+    # revealed: Never
+    reveal_type(a1)
+    # revealed: Never
+    reveal_type(a2)
+
+    # Never is assignable to all types.
+    v1: int = a1
+    v2: str = a1
+    # Other types are not assignable to Never except for Never (and Any).
+    v3: Never = b1
+    v4: Never = a2
+    v5: Any = b2
+    # error: [invalid-assignment] "Object of type `Literal[1]` is not assignable to `Never`"
+    v6: Never = 1
+```
+
+## `typing.Never`
+
+`typing.Never` is only available in Python 3.11 and later:
+
+```toml
+[environment]
+python-version = "3.11"
+```
+
+```py
+from typing import Never
+
+x: Never
+
+def f():
+    reveal_type(x)  # revealed: Never
+```

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

@@ -8,11 +8,11 @@ from typing_extensions import TypeVarTuple
 Ts = TypeVarTuple("Ts")
 
 def append_int(*args: *Ts) -> tuple[*Ts, int]:
-    # TODO: should show some representation of the variadic generic type
-    reveal_type(args)  # revealed: @Todo
+    # TODO: tuple[*Ts]
+    reveal_type(args)  # revealed: tuple
 
     return (*args, 1)
 
 # TODO should be tuple[Literal[True], Literal["a"], int]
-reveal_type(append_int(True, "a"))  # revealed: @Todo
+reveal_type(append_int(True, "a"))  # revealed: @Todo(full tuple[...] support)
 ```

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

@@ -0,0 +1,127 @@
+# Typing-module aliases to other stdlib classes
+
+The `typing` module has various aliases to other stdlib classes. These are a legacy feature, but
+still need to be supported by a type checker.
+
+## Correspondence
+
+All of the following symbols can be mapped one-to-one with the actual type:
+
+```py
+import typing
+
+def f(
+    list_bare: typing.List,
+    list_parametrized: typing.List[int],
+    dict_bare: typing.Dict,
+    dict_parametrized: typing.Dict[int, str],
+    set_bare: typing.Set,
+    set_parametrized: typing.Set[int],
+    frozen_set_bare: typing.FrozenSet,
+    frozen_set_parametrized: typing.FrozenSet[str],
+    chain_map_bare: typing.ChainMap,
+    chain_map_parametrized: typing.ChainMap[int],
+    counter_bare: typing.Counter,
+    counter_parametrized: typing.Counter[int],
+    default_dict_bare: typing.DefaultDict,
+    default_dict_parametrized: typing.DefaultDict[str, int],
+    deque_bare: typing.Deque,
+    deque_parametrized: typing.Deque[str],
+    ordered_dict_bare: typing.OrderedDict,
+    ordered_dict_parametrized: typing.OrderedDict[int, str],
+):
+    reveal_type(list_bare)  # revealed: list
+    reveal_type(list_parametrized)  # revealed: list
+
+    reveal_type(dict_bare)  # revealed: dict
+    reveal_type(dict_parametrized)  # revealed: dict
+
+    reveal_type(set_bare)  # revealed: set
+    reveal_type(set_parametrized)  # revealed: set
+
+    reveal_type(frozen_set_bare)  # revealed: frozenset
+    reveal_type(frozen_set_parametrized)  # revealed: frozenset
+
+    reveal_type(chain_map_bare)  # revealed: ChainMap
+    reveal_type(chain_map_parametrized)  # revealed: ChainMap
+
+    reveal_type(counter_bare)  # revealed: Counter
+    reveal_type(counter_parametrized)  # revealed: Counter
+
+    reveal_type(default_dict_bare)  # revealed: defaultdict
+    reveal_type(default_dict_parametrized)  # revealed: defaultdict
+
+    reveal_type(deque_bare)  # revealed: deque
+    reveal_type(deque_parametrized)  # revealed: deque
+
+    reveal_type(ordered_dict_bare)  # revealed: OrderedDict
+    reveal_type(ordered_dict_parametrized)  # revealed: OrderedDict
+```
+
+## Inheritance
+
+The aliases can be inherited from. Some of these are still partially or wholly TODOs.
+
+```py
+import typing
+
+####################
+### Built-ins
+
+class ListSubclass(typing.List): ...
+
+# TODO: should have `Generic`, should not have `Unknown`
+# revealed: tuple[Literal[ListSubclass], Literal[list], Unknown, 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]]
+reveal_type(DictSubclass.__mro__)
+
+class SetSubclass(typing.Set): ...
+
+# TODO: should have `Generic`, should not have `Unknown`
+# revealed: tuple[Literal[SetSubclass], Literal[set], Unknown, Literal[object]]
+reveal_type(SetSubclass.__mro__)
+
+class FrozenSetSubclass(typing.FrozenSet): ...
+
+# TODO: should have `Generic`, should not have `Unknown`
+# revealed: tuple[Literal[FrozenSetSubclass], Literal[frozenset], Unknown, Literal[object]]
+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]]
+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]]
+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]]
+reveal_type(DefaultDictSubclass.__mro__)
+
+class DequeSubclass(typing.Deque): ...
+
+# TODO: Should be (DequeSubclass, deque, MutableSequence, Sequence, Reversible, Collection, Sized, Iterable, Container, Generic, object)
+# revealed: tuple[Literal[DequeSubclass], Literal[deque], Unknown, Literal[object]]
+reveal_type(DequeSubclass.__mro__)
+
+class OrderedDictSubclass(typing.OrderedDict): ...
+
+# TODO: Should be (OrderedDictSubclass, OrderedDict, dict, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
+# revealed: tuple[Literal[OrderedDictSubclass], Literal[OrderedDict], Unknown, Literal[object]]
+reveal_type(OrderedDictSubclass.__mro__)
+```

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

@@ -3,75 +3,56 @@
 ## Simple
 
 ```py
-def f() -> "int":
-    return 1
-
-reveal_type(f())  # revealed: int
+def f(v: "int"):
+    reveal_type(v)  # revealed: int
 ```
 
 ## Nested
 
 ```py
-def f() -> "'int'":
-    return 1
-
-reveal_type(f())  # revealed: int
+def f(v: "'int'"):
+    reveal_type(v)  # revealed: int
 ```
 
 ## Type expression
 
 ```py
-def f1() -> "int | str":
-    return 1
-
-def f2() -> "tuple[int, str]":
-    return 1
-
-reveal_type(f1())  # revealed: int | str
-reveal_type(f2())  # revealed: tuple[int, str]
+def f1(v: "int | str", w: "tuple[int, str]"):
+    reveal_type(v)  # revealed: int | str
+    reveal_type(w)  # revealed: tuple[int, str]
 ```
 
 ## Partial
 
 ```py
-def f() -> tuple[int, "str"]:
-    return 1
-
-reveal_type(f())  # revealed: tuple[int, str]
+def f(v: tuple[int, "str"]):
+    reveal_type(v)  # revealed: tuple[int, str]
 ```
 
 ## Deferred
 
 ```py
-def f() -> "Foo":
-    return Foo()
+def f(v: "Foo"):
+    reveal_type(v)  # revealed: Foo
 
-class Foo:
-    pass
-
-reveal_type(f())  # revealed: Foo
+class Foo: ...
 ```
 
 ## Deferred (undefined)
 
 ```py
 # error: [unresolved-reference]
-def f() -> "Foo":
-    pass
-
-reveal_type(f())  # revealed: Unknown
+def f(v: "Foo"):
+    reveal_type(v)  # revealed: Unknown
 ```
 
 ## Partial deferred
 
 ```py
-def f() -> int | "Foo":
-    return 1
+def f(v: int | "Foo"):
+    reveal_type(v)  # revealed: int | Foo
 
-class Foo:
-    pass
-
-reveal_type(f())  # revealed: int | Foo
+class Foo: ...
 ```
 
 ## `typing.Literal`
@@ -79,65 +60,43 @@ reveal_type(f())  # revealed: int | Foo
 ```py
 from typing import Literal
 
-def f1() -> Literal["Foo", "Bar"]:
-    return "Foo"
+def f1(v: Literal["Foo", "Bar"], w: 'Literal["Foo", "Bar"]'):
+    reveal_type(v)  # revealed: Literal["Foo", "Bar"]
+    reveal_type(w)  # revealed: Literal["Foo", "Bar"]
 
-def f2() -> 'Literal["Foo", "Bar"]':
-    return "Foo"
-
-class Foo:
-    pass
-
-reveal_type(f1())  # revealed: Literal["Foo", "Bar"]
-reveal_type(f2())  # revealed: Literal["Foo", "Bar"]
+class Foo: ...
 ```
 
 ## Various string kinds
 
 ```py
-# error: [annotation-raw-string] "Type expressions cannot use raw string literal"
-def f1() -> r"int":
-    return 1
-
-# error: [annotation-f-string] "Type expressions cannot use f-strings"
-def f2() -> f"int":
-    return 1
-
-# error: [annotation-byte-string] "Type expressions cannot use bytes literal"
-def f3() -> b"int":
-    return 1
-
-def f4() -> "int":
-    return 1
-
-# error: [annotation-implicit-concat] "Type expressions cannot span multiple string literals"
-def f5() -> "in" "t":
-    return 1
-
-# error: [annotation-escape-character] "Type expressions cannot contain escape characters"
-def f6() -> "\N{LATIN SMALL LETTER I}nt":
-    return 1
-
-# error: [annotation-escape-character] "Type expressions cannot contain escape characters"
-def f7() -> "\x69nt":
-    return 1
-
-def f8() -> """int""":
-    return 1
-
-# error: [annotation-byte-string] "Type expressions cannot use bytes literal"
-def f9() -> "b'int'":
-    return 1
-
-reveal_type(f1())  # revealed: Unknown
-reveal_type(f2())  # revealed: Unknown
-reveal_type(f3())  # revealed: Unknown
-reveal_type(f4())  # revealed: int
-reveal_type(f5())  # revealed: Unknown
-reveal_type(f6())  # revealed: Unknown
-reveal_type(f7())  # revealed: Unknown
-reveal_type(f8())  # revealed: int
-reveal_type(f9())  # revealed: Unknown
+def f1(
+    # error: [raw-string-type-annotation] "Type expressions cannot use raw string literal"
+    a: r"int",
+    # error: [fstring-type-annotation] "Type expressions cannot use f-strings"
+    b: f"int",
+    # error: [byte-string-type-annotation] "Type expressions cannot use bytes literal"
+    c: b"int",
+    d: "int",
+    # error: [implicit-concatenated-string-type-annotation] "Type expressions cannot span multiple string literals"
+    e: "in" "t",
+    # error: [escape-character-in-forward-annotation] "Type expressions cannot contain escape characters"
+    f: "\N{LATIN SMALL LETTER I}nt",
+    # error: [escape-character-in-forward-annotation] "Type expressions cannot contain escape characters"
+    g: "\x69nt",
+    h: """int""",
+    # error: [byte-string-type-annotation] "Type expressions cannot use bytes literal"
+    i: "b'int'",
+):
+    reveal_type(a)  # revealed: Unknown
+    reveal_type(b)  # revealed: Unknown
+    reveal_type(c)  # revealed: Unknown
+    reveal_type(d)  # revealed: int
+    reveal_type(e)  # revealed: Unknown
+    reveal_type(f)  # revealed: Unknown
+    reveal_type(g)  # revealed: Unknown
+    reveal_type(h)  # revealed: int
+    reveal_type(i)  # revealed: Unknown
 ```
 
 ## Various string kinds in `typing.Literal`
@@ -145,10 +104,8 @@ reveal_type(f9())  # revealed: Unknown
 ```py
 from typing import Literal
 
-def f() -> Literal["a", r"b", b"c", "d" "e", "\N{LATIN SMALL LETTER F}", "\x67", """h"""]:
-    return "normal"
-
-reveal_type(f())  # revealed: Literal["a", "b", "de", "f", "g", "h"] | Literal[b"c"]
+def f(v: Literal["a", r"b", b"c", "d" "e", "\N{LATIN SMALL LETTER F}", "\x67", """h"""]):
+    reveal_type(v)  # revealed: Literal["a", "b", "de", "f", "g", "h"] | Literal[b"c"]
 ```
 
 ## Class variables
@@ -175,8 +132,7 @@ c: "Foo"
 # error: [invalid-assignment] "Object of type `Literal[1]` is not assignable to `Foo`"
 d: "Foo" = 1
 
-class Foo:
-    pass
+class Foo: ...
 
 c = Foo()
 
@@ -189,3 +145,31 @@ reveal_type(d)  # revealed: Foo
 ## Parameter
 
 TODO: Add tests once parameter inference is supported
+
+## Invalid expressions
+
+The expressions in these string annotations aren't valid expressions in this context but we
+shouldn't panic.
+
+```py
+a: "1 or 2"
+b: "(x := 1)"
+c: "1 + 2"
+d: "lambda x: x"
+e: "x if True else y"
+f: "{'a': 1, 'b': 2}"
+g: "{1, 2}"
+h: "[i for i in range(5)]"
+i: "{i for i in range(5)}"
+j: "{i: i for i in range(5)}"
+k: "(i for i in range(5))"
+l: "await 1"
+# error: [invalid-syntax-in-forward-annotation]
+m: "yield 1"
+# error: [invalid-syntax-in-forward-annotation]
+n: "yield from 1"
+o: "1 < 2"
+p: "call()"
+r: "[1, 2]"
+s: "(1, 2)"
+```

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

@@ -0,0 +1,61 @@
+# Union
+
+## Annotation
+
+`typing.Union` can be used to construct union types same as `|` operator.
+
+```py
+from typing import Union
+
+a: Union[int, str]
+a1: Union[int, bool]
+a2: Union[int, Union[float, str]]
+a3: Union[int, None]
+a4: Union[Union[float, str]]
+a5: Union[int]
+a6: Union[()]
+
+def f():
+    # revealed: int | str
+    reveal_type(a)
+    # Since bool is a subtype of int we simplify to int here. But we do allow assigning boolean values (see below).
+    # revealed: int
+    reveal_type(a1)
+    # revealed: int | float | str
+    reveal_type(a2)
+    # revealed: int | None
+    reveal_type(a3)
+    # revealed: float | str
+    reveal_type(a4)
+    # revealed: int
+    reveal_type(a5)
+    # revealed: Never
+    reveal_type(a6)
+```
+
+## Assignment
+
+```py
+from typing import Union
+
+a: Union[int, str]
+a = 1
+a = ""
+a1: Union[int, bool]
+a1 = 1
+a1 = True
+# error: [invalid-assignment] "Object of type `Literal[b""]` is not assignable to `int | str`"
+a = b""
+```
+
+## Typing Extensions
+
+```py
+from typing_extensions import Union
+
+a: Union[int, str]
+
+def f():
+    # revealed: int | str
+    reveal_type(a)
+```

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

@@ -0,0 +1,71 @@
+# Unsupported special forms
+
+## Not yet supported
+
+Several special forms are unsupported by red-knot currently. However, we also don't emit
+false-positive errors if you use one in an annotation:
+
+```py
+from typing_extensions import Self, TypeVarTuple, Unpack, TypeGuard, TypeIs, Concatenate, ParamSpec, TypeAlias, Callable, TypeVar
+
+P = ParamSpec("P")
+Ts = TypeVarTuple("Ts")
+R_co = TypeVar("R_co", covariant=True)
+
+Alias: TypeAlias = int
+
+def f(*args: Unpack[Ts]) -> tuple[Unpack[Ts]]:
+    # TODO: should understand the annotation
+    reveal_type(args)  # revealed: tuple
+
+    reveal_type(Alias)  # revealed: @Todo(Unsupported or invalid type in a type expression)
+
+def g() -> TypeGuard[int]: ...
+def h() -> TypeIs[int]: ...
+def i(callback: Callable[Concatenate[int, P], R_co], *args: P.args, **kwargs: P.kwargs) -> R_co:
+    # TODO: should understand the annotation
+    reveal_type(args)  # revealed: tuple
+
+    # TODO: should understand the annotation
+    reveal_type(kwargs)  # revealed: dict
+
+    return callback(42, *args, **kwargs)
+
+class Foo:
+    def method(self, x: Self):
+        reveal_type(x)  # revealed: @Todo(Unsupported or invalid type in a type expression)
+```
+
+## Inheritance
+
+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
+
+class A(Self): ...  # error: [invalid-base]
+class B(Unpack): ...  # error: [invalid-base]
+class C(TypeGuard): ...  # error: [invalid-base]
+class D(TypeIs): ...  # error: [invalid-base]
+class E(Concatenate): ...  # error: [invalid-base]
+class F(Callable): ...
+
+reveal_type(F.__mro__)  # revealed: tuple[Literal[F], @Todo(Support for Callable as a base class), Literal[object]]
+```
+
+## Subscriptability
+
+Some of these are not subscriptable:
+
+```py
+from typing_extensions import Self, TypeAlias
+
+X: TypeAlias[T] = int  # error: [invalid-type-form]
+
+class Foo[T]:
+    # error: [invalid-type-form] "Special form `typing.Self` expected no type parameter"
+    # error: [invalid-type-form] "Special form `typing.Self` expected no type parameter"
+    def method(self: Self[int]) -> Self[int]:
+        reveal_type(self)  # revealed: Unknown
+```

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

@@ -0,0 +1,37 @@
+# Unsupported type qualifiers
+
+## Not yet supported
+
+Several type qualifiers are unsupported by red-knot currently. However, we also don't emit
+false-positive errors if you use one in an annotation:
+
+```py
+from typing_extensions import Final, ClassVar, Required, NotRequired, ReadOnly, TypedDict
+
+X: Final = 42
+Y: Final[int] = 42
+
+class Foo:
+    A: ClassVar[int] = 42
+
+# TODO: `TypedDict` is actually valid as a base
+# error: [invalid-base]
+class Bar(TypedDict):
+    x: Required[int]
+    y: NotRequired[str]
+    z: ReadOnly[bytes]
+```
+
+## Inheritance
+
+You can't inherit from a type qualifier.
+
+```py
+from typing_extensions import Final, ClassVar, Required, NotRequired, ReadOnly
+
+class A(Final): ...  # error: [invalid-base]
+class B(ClassVar): ...  # error: [invalid-base]
+class C(Required): ...  # error: [invalid-base]
+class D(NotRequired): ...  # error: [invalid-base]
+class E(ReadOnly): ...  # error: [invalid-base]
+```

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

@@ -50,13 +50,13 @@ reveal_type(b)  # revealed: tuple[int]
 reveal_type(c)  # revealed: tuple[str, int]
 reveal_type(d)  # revealed: tuple[tuple[str, str], tuple[int, int]]
 
-# TODO: homogenous tuples, PEP-646 tuples
-reveal_type(e)  # revealed: @Todo
-reveal_type(f)  # revealed: @Todo
-reveal_type(g)  # revealed: @Todo
+# TODO: homogeneous tuples, PEP-646 tuples
+reveal_type(e)  # revealed: @Todo(full tuple[...] support)
+reveal_type(f)  # revealed: @Todo(full tuple[...] support)
+reveal_type(g)  # revealed: @Todo(full tuple[...] support)
 
 # TODO: support more kinds of type expressions in annotations
-reveal_type(h)  # revealed: @Todo
+reveal_type(h)  # revealed: @Todo(full tuple[...] support)
 
 reveal_type(i)  # revealed: tuple[str | int, str | int]
 reveal_type(j)  # revealed: tuple[str | int]
@@ -78,20 +78,10 @@ c: tuple[str | int, str] = ([], "foo")
 ## PEP-604 annotations are supported
 
 ```py
-def foo() -> str | int | None:
-    return None
-
-reveal_type(foo())  # revealed: str | int | None
-
-def bar() -> str | str | None:
-    return None
-
-reveal_type(bar())  # revealed: str | None
-
-def baz() -> str | str:
-    return "Hello, world!"
-
-reveal_type(baz())  # revealed: str
+def foo(v: str | int | None, w: str | str | None, x: str | str):
+    reveal_type(v)  # revealed: str | int | None
+    reveal_type(w)  # revealed: str | None
+    reveal_type(x)  # revealed: str
 ```
 
 ## Attribute expressions in type annotations are understood
@@ -118,8 +108,7 @@ from __future__ import annotations
 
 x: Foo
 
-class Foo:
-    pass
+class Foo: ...
 
 x = Foo()
 reveal_type(x)  # revealed: Foo
@@ -130,8 +119,7 @@ reveal_type(x)  # revealed: Foo
 ```pyi path=main.pyi
 x: Foo
 
-class Foo:
-    pass
+class Foo: ...
 
 x = Foo()
 reveal_type(x)  # revealed: Foo

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

@@ -49,134 +49,116 @@ reveal_type(x)  # revealed: int
 ## Method union
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    class Foo:
+        if flag:
+            def __iadd__(self, other: int) -> str:
+                return "Hello, world!"
+        else:
+            def __iadd__(self, other: int) -> int:
+                return 42
 
-flag = bool_instance()
+    f = Foo()
+    f += 12
 
-class Foo:
-    if bool_instance():
-        def __iadd__(self, other: int) -> str:
-            return "Hello, world!"
-    else:
-        def __iadd__(self, other: int) -> int:
-            return 42
-
-f = Foo()
-f += 12
-
-reveal_type(f)  # revealed: str | int
+    reveal_type(f)  # revealed: str | int
 ```
 
 ## Partially bound `__iadd__`
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    class Foo:
+        if flag:
+            def __iadd__(self, other: str) -> int:
+                return 42
 
-class Foo:
-    if bool_instance():
-        def __iadd__(self, other: str) -> int:
-            return 42
+    f = Foo()
 
-f = Foo()
+    # TODO: We should emit an `unsupported-operator` error here, possibly with the information
+    # that `Foo.__iadd__` may be unbound as additional context.
+    f += "Hello, world!"
 
-# TODO: We should emit an `unsupported-operator` error here, possibly with the information
-# that `Foo.__iadd__` may be unbound as additional context.
-f += "Hello, world!"
-
-reveal_type(f)  # revealed: int | Unknown
+    reveal_type(f)  # revealed: int | Unknown
 ```
 
 ## Partially bound with `__add__`
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    class Foo:
+        def __add__(self, other: str) -> str:
+            return "Hello, world!"
+        if flag:
+            def __iadd__(self, other: str) -> int:
+                return 42
 
-class Foo:
-    def __add__(self, other: str) -> str:
-        return "Hello, world!"
-    if bool_instance():
-        def __iadd__(self, other: str) -> int:
-            return 42
+    f = Foo()
+    f += "Hello, world!"
 
-f = Foo()
-f += "Hello, world!"
-
-reveal_type(f)  # revealed: int | str
+    reveal_type(f)  # revealed: int | str
 ```
 
 ## Partially bound target union
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool):
+    class Foo:
+        def __add__(self, other: int) -> str:
+            return "Hello, world!"
+        if flag1:
+            def __iadd__(self, other: int) -> int:
+                return 42
 
-class Foo:
-    def __add__(self, other: int) -> str:
-        return "Hello, world!"
-    if bool_instance():
-        def __iadd__(self, other: int) -> int:
-            return 42
+    if flag2:
+        f = Foo()
+    else:
+        f = 42.0
+    f += 12
 
-if bool_instance():
-    f = Foo()
-else:
-    f = 42.0
-f += 12
-
-reveal_type(f)  # revealed: int | str | float
+    reveal_type(f)  # revealed: int | str | float
 ```
 
 ## Target union
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    class Foo:
+        def __iadd__(self, other: int) -> str:
+            return "Hello, world!"
 
-flag = bool_instance()
+    if flag:
+        f = Foo()
+    else:
+        f = 42.0
+    f += 12
 
-class Foo:
-    def __iadd__(self, other: int) -> str:
-        return "Hello, world!"
-
-if flag:
-    f = Foo()
-else:
-    f = 42.0
-f += 12
-
-reveal_type(f)  # revealed: str | float
+    reveal_type(f)  # revealed: str | float
 ```
 
 ## Partially bound target union with `__add__`
 
 ```py
-def bool_instance() -> bool:
-    return True
+def f(flag: bool, flag2: bool):
+    class Foo:
+        def __add__(self, other: int) -> str:
+            return "Hello, world!"
+        if flag:
+            def __iadd__(self, other: int) -> int:
+                return 42
 
-flag = bool_instance()
+    class Bar:
+        def __add__(self, other: int) -> bytes:
+            return b"Hello, world!"
 
-class Foo:
-    def __add__(self, other: int) -> str:
-        return "Hello, world!"
-    if bool_instance():
-        def __iadd__(self, other: int) -> int:
-            return 42
+        def __iadd__(self, other: int) -> float:
+            return 42.0
 
-class Bar:
-    def __add__(self, other: int) -> bytes:
-        return b"Hello, world!"
+    if flag2:
+        f = Foo()
+    else:
+        f = Bar()
+    f += 12
 
-    def __iadd__(self, other: int) -> float:
-        return 42.0
-
-if flag:
-    f = Foo()
-else:
-    f = Bar()
-f += 12
-
-reveal_type(f)  # revealed: int | str | float
+    reveal_type(f)  # revealed: int | str | float
 ```

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

@@ -18,43 +18,3 @@ Note: in this particular example, one could argue that the most likely error wou
 of the `x`/`foo` definitions, and so it could be desirable to infer `Literal[1]` for the type of
 `x`. On the other hand, there might be a variable `fob` a little higher up in this file, and the
 actual error might have been just a typo. Inferring `Unknown` thus seems like the safest option.
-
-## Unbound class variable
-
-Name lookups within a class scope fall back to globals, but lookups of class attributes don't.
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-x = 1
-
-class C:
-    y = x
-    if flag:
-        x = 2
-
-# error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C]` is possibly unbound"
-reveal_type(C.x)  # revealed: Literal[2]
-reveal_type(C.y)  # revealed: Literal[1]
-```
-
-## Possibly unbound in class and global scope
-
-```py
-def bool_instance() -> bool:
-    return True
-
-if bool_instance():
-    x = "abc"
-
-class C:
-    if bool_instance():
-        x = 1
-
-    # error: [possibly-unresolved-reference]
-    y = x
-
-reveal_type(C.y)  # revealed: Literal[1] | Literal["abc"]
-```

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -3,27 +3,23 @@
 ## Union of attributes
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-if flag:
-    class C1:
-        x = 1
-
-else:
-    class C1:
-        x = 2
-
-class C2:
+def _(flag: bool):
     if flag:
-        x = 3
-    else:
-        x = 4
+        class C1:
+            x = 1
 
-reveal_type(C1.x)  # revealed: Literal[1, 2]
-reveal_type(C2.x)  # revealed: Literal[3, 4]
+    else:
+        class C1:
+            x = 2
+
+    class C2:
+        if flag:
+            x = 3
+        else:
+            x = 4
+
+    reveal_type(C1.x)  # revealed: Literal[1, 2]
+    reveal_type(C2.x)  # revealed: Literal[3, 4]
 ```
 
 ## Inherited attributes
@@ -68,24 +64,19 @@ reveal_type(A.X)  # revealed: Literal[42]
 In this example, the `x` attribute is not defined in the `C2` element of the union:
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool):
+    class C1:
+        x = 1
 
-class C1:
-    x = 1
+    class C2: ...
 
-class C2: ...
+    class C3:
+        x = 3
 
-class C3:
-    x = 3
+    C = C1 if flag1 else C2 if flag2 else C3
 
-flag1 = bool_instance()
-flag2 = bool_instance()
-
-C = C1 if flag1 else C2 if flag2 else C3
-
-# error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C1, C2, C3]` is possibly unbound"
-reveal_type(C.x)  # revealed: Literal[1, 3]
+    # error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C1, C2, C3]` is possibly unbound"
+    reveal_type(C.x)  # revealed: Literal[1, 3]
 ```
 
 ### Possibly-unbound within a class
@@ -94,26 +85,21 @@ We raise the same diagnostic if the attribute is possibly-unbound in at least on
 union:
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool, flag1: bool, flag2: bool):
+    class C1:
+        x = 1
 
-class C1:
-    x = 1
+    class C2:
+        if flag:
+            x = 2
 
-class C2:
-    if bool_instance():
-        x = 2
+    class C3:
+        x = 3
 
-class C3:
-    x = 3
+    C = C1 if flag1 else C2 if flag2 else C3
 
-flag1 = bool_instance()
-flag2 = bool_instance()
-
-C = C1 if flag1 else C2 if flag2 else C3
-
-# error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C1, C2, C3]` is possibly unbound"
-reveal_type(C.x)  # revealed: Literal[1, 2, 3]
+    # error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C1, C2, C3]` is possibly unbound"
+    reveal_type(C.x)  # revealed: Literal[1, 2, 3]
 ```
 
 ## Unions with all paths unbound
@@ -121,16 +107,51 @@ reveal_type(C.x)  # revealed: Literal[1, 2, 3]
 If the symbol is unbound in all elements of the union, we detect that:
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    class C1: ...
+    class C2: ...
+    C = C1 if flag else C2
 
-class C1: ...
-class C2: ...
-
-flag = bool_instance()
-
-C = C1 if flag else C2
-
-# error: [unresolved-attribute] "Type `Literal[C1, C2]` has no attribute `x`"
-reveal_type(C.x)  # revealed: Unknown
+    # error: [unresolved-attribute] "Type `Literal[C1, C2]` has no attribute `x`"
+    reveal_type(C.x)  # revealed: Unknown
+```
+
+## Objects of all types have a `__class__` method
+
+```py
+import typing_extensions
+
+reveal_type(typing_extensions.__class__)  # revealed: Literal[ModuleType]
+
+a = 42
+reveal_type(a.__class__)  # revealed: Literal[int]
+
+b = "42"
+reveal_type(b.__class__)  # revealed: Literal[str]
+
+c = b"42"
+reveal_type(c.__class__)  # revealed: Literal[bytes]
+
+d = True
+reveal_type(d.__class__)  # revealed: Literal[bool]
+
+e = (42, 42)
+reveal_type(e.__class__)  # revealed: Literal[tuple]
+
+def f(a: int, b: typing_extensions.LiteralString, c: int | str, d: type[str]):
+    reveal_type(a.__class__)  # revealed: type[int]
+    reveal_type(b.__class__)  # revealed: Literal[str]
+    reveal_type(c.__class__)  # revealed: type[int] | type[str]
+
+    # `type[type]`, a.k.a., either the class `type` or some subclass of `type`.
+    # It would be incorrect to infer `Literal[type]` here,
+    # as `c` could be some subclass of `str` with a custom metaclass.
+    # All we know is that the metaclass must be a (non-strict) subclass of `type`.
+    reveal_type(d.__class__)  # revealed: type[type]
+
+reveal_type(f.__class__)  # revealed: Literal[FunctionType]
+
+class Foo: ...
+
+reveal_type(Foo.__class__)  # revealed: Literal[type]
 ```

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

@@ -281,20 +281,12 @@ reveal_type(42 + 4.2)  # revealed: int
 # TODO should be complex, need to check arg type and fall back to `rhs.__radd__`
 reveal_type(3 + 3j)  # revealed: int
 
-def returns_int() -> int:
-    return 42
+def _(x: bool, y: int):
+    reveal_type(x + y)  # revealed: int
+    reveal_type(4.2 + x)  # revealed: float
 
-def returns_bool() -> bool:
-    return True
-
-x = returns_bool()
-y = returns_int()
-
-reveal_type(x + y)  # revealed: int
-reveal_type(4.2 + x)  # revealed: float
-
-# TODO should be float, need to check arg type and fall back to `rhs.__radd__`
-reveal_type(y + 4.12)  # revealed: int
+    # TODO should be float, need to check arg type and fall back to `rhs.__radd__`
+    reveal_type(y + 4.12)  # revealed: int
 ```
 
 ## With literal types
@@ -317,7 +309,7 @@ reveal_type(1 + A())  # revealed: int
 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
+reveal_type("foo" + A())  # revealed: @Todo(return type)
 
 reveal_type(A() + b"foo")  # revealed: A
 # TODO should be `A` since `bytes.__add__` doesn't support `A` instances
@@ -325,7 +317,7 @@ reveal_type(b"foo" + A())  # revealed: bytes
 
 reveal_type(A() + ())  # revealed: A
 # TODO this should be `A`, since `tuple.__add__` doesn't support `A` instances
-reveal_type(() + A())  # revealed: @Todo
+reveal_type(() + A())  # revealed: @Todo(return type)
 
 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`:
@@ -334,7 +326,7 @@ reveal_type(literal_string_instance)  # revealed: LiteralString
 reveal_type(A() + literal_string_instance)  # revealed: A
 # TODO should be `A` since `str.__add__` doesn't support `A` instances
 # TODO overloads
-reveal_type(literal_string_instance + A())  # revealed: @Todo
+reveal_type(literal_string_instance + A())  # revealed: @Todo(return type)
 ```
 
 ## Operations involving instances of classes inheriting from `Any`

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

@@ -7,29 +7,25 @@ Similarly, in `and` expressions, if the left-hand side is falsy, the right-hand
 evaluated.
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    if flag or (x := 1):
+        # error: [possibly-unresolved-reference]
+        reveal_type(x)  # revealed: Literal[1]
 
-if bool_instance() or (x := 1):
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-
-if bool_instance() and (x := 1):
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
+    if flag and (x := 1):
+        # error: [possibly-unresolved-reference]
+        reveal_type(x)  # revealed: Literal[1]
 ```
 
 ## First expression is always evaluated
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    if (x := 1) or flag:
+        reveal_type(x)  # revealed: Literal[1]
 
-if (x := 1) or bool_instance():
-    reveal_type(x)  # revealed: Literal[1]
-
-if (x := 1) and bool_instance():
-    reveal_type(x)  # revealed: Literal[1]
+    if (x := 1) and flag:
+        reveal_type(x)  # revealed: Literal[1]
 ```
 
 ## Statically known truthiness
@@ -49,30 +45,26 @@ if True and (x := 1):
 ## Later expressions can always use variables from earlier expressions
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    flag or (x := 1) or reveal_type(x)  # revealed: Literal[1]
 
-bool_instance() or (x := 1) or reveal_type(x)  # revealed: Literal[1]
-
-# error: [unresolved-reference]
-bool_instance() or reveal_type(y) or (y := 1)  # revealed: Unknown
+    # error: [unresolved-reference]
+    flag or reveal_type(y) or (y := 1)  # revealed: Unknown
 ```
 
 ## Nested expressions
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool):
+    if flag1 or ((x := 1) and flag2):
+        # error: [possibly-unresolved-reference]
+        reveal_type(x)  # revealed: Literal[1]
+
+    if ((y := 1) and flag1) or flag2:
+        reveal_type(y)  # revealed: Literal[1]
 
-if bool_instance() or ((x := 1) and bool_instance()):
     # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-
-if ((y := 1) and bool_instance()) or bool_instance():
-    reveal_type(y)  # revealed: Literal[1]
-
-# error: [possibly-unresolved-reference]
-if (bool_instance() and (z := 1)) or reveal_type(z):  # revealed: Literal[1]
-    # error: [possibly-unresolved-reference]
-    reveal_type(z)  # revealed: Literal[1]
+    if (flag1 and (z := 1)) or reveal_type(z):  # revealed: Literal[1]
+        # error: [possibly-unresolved-reference]
+        reveal_type(z)  # revealed: Literal[1]
 ```

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

@@ -22,29 +22,27 @@ reveal_type(b)  # revealed: Unknown
 ## Possibly unbound `__call__` method
 
 ```py
-def flag() -> bool: ...
+def _(flag: bool):
+    class PossiblyNotCallable:
+        if flag:
+            def __call__(self) -> int: ...
 
-class PossiblyNotCallable:
-    if flag():
-        def __call__(self) -> int: ...
-
-a = PossiblyNotCallable()
-result = a()  # error: "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
-reveal_type(result)  # revealed: int
+    a = PossiblyNotCallable()
+    result = a()  # error: "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
+    reveal_type(result)  # revealed: int
 ```
 
 ## Possibly unbound callable
 
 ```py
-def flag() -> bool: ...
+def _(flag: bool):
+    if flag:
+        class PossiblyUnbound:
+            def __call__(self) -> int: ...
 
-if flag():
-    class PossiblyUnbound:
-        def __call__(self) -> int: ...
-
-# error: [possibly-unresolved-reference]
-a = PossiblyUnbound()
-reveal_type(a())  # revealed: int
+    # error: [possibly-unresolved-reference]
+    a = PossiblyUnbound()
+    reveal_type(a())  # revealed: int
 ```
 
 ## Non-callable `__call__`
@@ -61,15 +59,14 @@ reveal_type(a())  # revealed: Unknown
 ## Possibly non-callable `__call__`
 
 ```py
-def flag() -> bool: ...
+def _(flag: bool):
+    class NonCallable:
+        if flag:
+            __call__ = 1
+        else:
+            def __call__(self) -> int: ...
 
-class NonCallable:
-    if flag():
-        __call__ = 1
-    else:
-        def __call__(self) -> int: ...
-
-a = NonCallable()
-# error: "Object of type `Literal[1] | Literal[__call__]` is not callable (due to union element `Literal[1]`)"
-reveal_type(a())  # revealed: Unknown | int
+    a = NonCallable()
+    # error: "Object of type `Literal[__call__] | Literal[1]` is not callable (due to union element `Literal[1]`)"
+    reveal_type(a())  # revealed: int | Unknown
 ```

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

@@ -16,7 +16,7 @@ async def get_int_async() -> int:
     return 42
 
 # TODO: we don't yet support `types.CoroutineType`, should be generic `Coroutine[Any, Any, int]`
-reveal_type(get_int_async())  # revealed: @Todo
+reveal_type(get_int_async())  # revealed: @Todo(generic types.CoroutineType)
 ```
 
 ## Generic
@@ -44,7 +44,7 @@ def bar() -> str:
     return "bar"
 
 # TODO: should reveal `int`, as the decorator replaces `bar` with `foo`
-reveal_type(bar())  # revealed: @Todo
+reveal_type(bar())  # revealed: @Todo(return type)
 ```
 
 ## Invalid callable
@@ -57,12 +57,10 @@ x = nonsense()  # error: "Object of type `Literal[123]` is not callable"
 ## Potentially unbound function
 
 ```py
-def flag() -> bool: ...
-
-if flag():
-    def foo() -> int:
-        return 42
-
-# error: [possibly-unresolved-reference]
-reveal_type(foo())  # revealed: int
+def _(flag: bool):
+    if flag:
+        def foo() -> int:
+            return 42
+    # error: [possibly-unresolved-reference]
+    reveal_type(foo())  # revealed: int
 ```

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

@@ -3,22 +3,14 @@
 ## Union of return types
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-if flag:
-
-    def f() -> int:
-        return 1
-
-else:
-
-    def f() -> str:
-        return "foo"
-
-reveal_type(f())  # revealed: int | str
+def _(flag: bool):
+    if flag:
+        def f() -> int:
+            return 1
+    else:
+        def f() -> str:
+            return "foo"
+    reveal_type(f())  # revealed: int | str
 ```
 
 ## Calling with an unknown union
@@ -26,13 +18,10 @@ reveal_type(f())  # revealed: int | str
 ```py
 from nonexistent import f  # error: [unresolved-import] "Cannot resolve import `nonexistent`"
 
-def bool_instance() -> bool:
+def coinflip() -> bool:
     return True
 
-flag = bool_instance()
-
-if flag:
-
+if coinflip():
     def f() -> int:
         return 1
 
@@ -44,20 +33,14 @@ reveal_type(f())  # revealed: Unknown | int
 Calling a union with a non-callable element should emit a diagnostic.
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-if flag:
-    f = 1
-else:
-
-    def f() -> int:
-        return 1
-
-x = f()  # error: "Object of type `Literal[1] | Literal[f]` is not callable (due to union element `Literal[1]`)"
-reveal_type(x)  # revealed: Unknown | int
+def _(flag: bool):
+    if flag:
+        f = 1
+    else:
+        def f() -> int:
+            return 1
+    x = f()  # error: "Object of type `Literal[1] | Literal[f]` is not callable (due to union element `Literal[1]`)"
+    reveal_type(x)  # revealed: Unknown | int
 ```
 
 ## Multiple non-callable elements in a union
@@ -65,23 +48,17 @@ reveal_type(x)  # revealed: Unknown | int
 Calling a union with multiple non-callable elements should mention all of them in the diagnostic.
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-
-if flag:
-    f = 1
-elif flag2:
-    f = "foo"
-else:
-
-    def f() -> int:
-        return 1
-
-# error: "Object of type `Literal[1] | Literal["foo"] | Literal[f]` is not callable (due to union elements Literal[1], Literal["foo"])"
-# revealed: Unknown | int
-reveal_type(f())
+def _(flag: bool, flag2: bool):
+    if flag:
+        f = 1
+    elif flag2:
+        f = "foo"
+    else:
+        def f() -> int:
+            return 1
+    # error: "Object of type `Literal[1] | Literal["foo"] | Literal[f]` is not callable (due to union elements Literal[1], Literal["foo"])"
+    # revealed: Unknown | int
+    reveal_type(f())
 ```
 
 ## All non-callable union elements
@@ -89,16 +66,12 @@ reveal_type(f())
 Calling a union with no callable elements can emit a simpler diagnostic.
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    if flag:
+        f = 1
+    else:
+        f = "foo"
 
-flag = bool_instance()
-
-if flag:
-    f = 1
-else:
-    f = "foo"
-
-x = f()  # error: "Object of type `Literal[1] | Literal["foo"]` is not callable"
-reveal_type(x)  # revealed: Unknown
+    x = f()  # error: "Object of type `Literal[1] | Literal["foo"]` is not callable"
+    reveal_type(x)  # revealed: Unknown
 ```

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

@@ -3,38 +3,31 @@
 ```py
 class A: ...
 
-def get_a() -> A: ...
-def get_object() -> object: ...
+def _(a1: A, a2: A, o: object):
+    n1 = None
+    n2 = None
 
-a1 = get_a()
-a2 = get_a()
+    reveal_type(a1 is a1)  # revealed: bool
+    reveal_type(a1 is a2)  # revealed: bool
 
-n1 = None
-n2 = None
+    reveal_type(n1 is n1)  # revealed: Literal[True]
+    reveal_type(n1 is n2)  # revealed: Literal[True]
 
-o = get_object()
+    reveal_type(a1 is n1)  # revealed: Literal[False]
+    reveal_type(n1 is a1)  # revealed: Literal[False]
 
-reveal_type(a1 is a1)  # revealed: bool
-reveal_type(a1 is a2)  # revealed: bool
+    reveal_type(a1 is o)  # revealed: bool
+    reveal_type(n1 is o)  # revealed: bool
 
-reveal_type(n1 is n1)  # revealed: Literal[True]
-reveal_type(n1 is n2)  # revealed: Literal[True]
+    reveal_type(a1 is not a1)  # revealed: bool
+    reveal_type(a1 is not a2)  # revealed: bool
 
-reveal_type(a1 is n1)  # revealed: Literal[False]
-reveal_type(n1 is a1)  # revealed: Literal[False]
+    reveal_type(n1 is not n1)  # revealed: Literal[False]
+    reveal_type(n1 is not n2)  # revealed: Literal[False]
 
-reveal_type(a1 is o)  # revealed: bool
-reveal_type(n1 is o)  # revealed: bool
+    reveal_type(a1 is not n1)  # revealed: Literal[True]
+    reveal_type(n1 is not a1)  # revealed: Literal[True]
 
-reveal_type(a1 is not a1)  # revealed: bool
-reveal_type(a1 is not a2)  # revealed: bool
-
-reveal_type(n1 is not n1)  # revealed: Literal[False]
-reveal_type(n1 is not n2)  # revealed: Literal[False]
-
-reveal_type(a1 is not n1)  # revealed: Literal[True]
-reveal_type(n1 is not a1)  # revealed: Literal[True]
-
-reveal_type(a1 is not o)  # revealed: bool
-reveal_type(n1 is not o)  # revealed: bool
+    reveal_type(a1 is not o)  # revealed: bool
+    reveal_type(n1 is not o)  # revealed: bool
 ```

crates/red_knot_python_semantic/resources/mdtest/comparison/instances/rich_comparison.md

@@ -312,17 +312,9 @@ reveal_type(1 <= 2j)  # revealed: bool
 reveal_type(1 > 2j)  # revealed: bool
 reveal_type(1 >= 2j)  # revealed: bool
 
-def bool_instance() -> bool:
-    return True
-
-def int_instance() -> int:
-    return 42
-
-x = bool_instance()
-y = int_instance()
-
-reveal_type(x < y)  # revealed: bool
-reveal_type(y < x)  # revealed: bool
-reveal_type(4.2 < x)  # revealed: bool
-reveal_type(x < 4.2)  # revealed: bool
+def f(x: bool, y: int):
+    reveal_type(x < y)  # revealed: bool
+    reveal_type(y < x)  # revealed: bool
+    reveal_type(4.2 < x)  # revealed: bool
+    reveal_type(x < 4.2)  # revealed: bool
 ```

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

@@ -20,10 +20,8 @@ reveal_type(1 <= "" and 0 < 1)  # revealed: bool
 
 ```py
 # TODO: implement lookup of `__eq__` on typeshed `int` stub.
-def int_instance() -> int:
-    return 42
-
-reveal_type(1 == int_instance())  # revealed: bool
-reveal_type(9 < int_instance())  # revealed: bool
-reveal_type(int_instance() < int_instance())  # revealed: bool
+def _(a: int, b: int):
+    reveal_type(1 == a)  # revealed: bool
+    reveal_type(9 < a)  # revealed: bool
+    reveal_type(a < b)  # revealed: bool
 ```

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

@@ -14,21 +14,19 @@ class Child1(Base):
 
 class Child2(Base): ...
 
-def get_base() -> Base: ...
+def _(x: Base):
+    c1 = Child1()
 
-x = get_base()
-c1 = Child1()
+    # Create an intersection type through narrowing:
+    if isinstance(x, Child1):
+        if isinstance(x, Child2):
+            reveal_type(x)  # revealed: Child1 & Child2
 
-# Create an intersection type through narrowing:
-if isinstance(x, Child1):
-    if isinstance(x, Child2):
-        reveal_type(x)  # revealed: Child1 & Child2
+            reveal_type(x == 1)  # revealed: Literal[True]
 
-        reveal_type(x == 1)  # revealed: Literal[True]
-
-        # Other comparison operators fall back to the base type:
-        reveal_type(x > 1)  # revealed: bool
-        reveal_type(x is c1)  # revealed: bool
+            # Other comparison operators fall back to the base type:
+            reveal_type(x > 1)  # revealed: bool
+            reveal_type(x is c1)  # revealed: bool
 ```
 
 ## Negative contributions
@@ -73,18 +71,15 @@ if x != "abc":
 #### Integers
 
 ```py
-def get_int() -> int: ...
+def _(x: int):
+    if x != 1:
+        reveal_type(x)  # revealed: int & ~Literal[1]
 
-x = get_int()
+        reveal_type(x != 1)  # revealed: Literal[True]
+        reveal_type(x != 2)  # revealed: bool
 
-if x != 1:
-    reveal_type(x)  # revealed: int & ~Literal[1]
-
-    reveal_type(x != 1)  # revealed: Literal[True]
-    reveal_type(x != 2)  # revealed: bool
-
-    reveal_type(x == 1)  # revealed: Literal[False]
-    reveal_type(x == 2)  # revealed: bool
+        reveal_type(x == 1)  # revealed: Literal[False]
+        reveal_type(x == 2)  # revealed: bool
 ```
 
 ### Identity comparisons
@@ -92,18 +87,15 @@ if x != 1:
 ```py
 class A: ...
 
-def get_object() -> object: ...
+def _(o: object):
+    a = A()
+    n = None
 
-o = object()
+    if o is not None:
+        reveal_type(o)  # revealed: object & ~None
 
-a = A()
-n = None
-
-if o is not None:
-    reveal_type(o)  # revealed: object & ~None
-
-    reveal_type(o is n)  # revealed: Literal[False]
-    reveal_type(o is not n)  # revealed: Literal[True]
+        reveal_type(o is n)  # revealed: Literal[False]
+        reveal_type(o is not n)  # revealed: Literal[True]
 ```
 
 ## Diagnostics
@@ -119,16 +111,13 @@ class Container:
 
 class NonContainer: ...
 
-def get_object() -> object: ...
+def _(x: object):
+    if isinstance(x, Container):
+        if isinstance(x, NonContainer):
+            reveal_type(x)  # revealed: Container & NonContainer
 
-x = get_object()
-
-if isinstance(x, Container):
-    if isinstance(x, NonContainer):
-        reveal_type(x)  # revealed: Container & NonContainer
-
-        # error: [unsupported-operator] "Operator `in` is not supported for types `int` and `NonContainer`"
-        reveal_type(2 in x)  # revealed: bool
+            # error: [unsupported-operator] "Operator `in` is not supported for types `int` and `NonContainer`"
+            reveal_type(2 in x)  # revealed: bool
 ```
 
 ### Unsupported operators for negative contributions
@@ -142,14 +131,11 @@ class Container:
 
 class NonContainer: ...
 
-def get_object() -> object: ...
+def _(x: object):
+    if isinstance(x, Container):
+        if not isinstance(x, NonContainer):
+            reveal_type(x)  # revealed: Container & ~NonContainer
 
-x = get_object()
-
-if isinstance(x, Container):
-    if not isinstance(x, NonContainer):
-        reveal_type(x)  # revealed: Container & ~NonContainer
-
-        # No error here!
-        reveal_type(2 in x)  # revealed: bool
+            # No error here!
+            reveal_type(2 in x)  # revealed: bool
 ```

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

@@ -3,18 +3,17 @@
 ## String literals
 
 ```py
-def str_instance() -> str: ...
+def _(x: str):
+    reveal_type("abc" == "abc")  # revealed: Literal[True]
+    reveal_type("ab_cd" <= "ab_ce")  # revealed: Literal[True]
+    reveal_type("abc" in "ab cd")  # revealed: Literal[False]
+    reveal_type("" not in "hello")  # revealed: Literal[False]
+    reveal_type("--" is "--")  # revealed: bool
+    reveal_type("A" is "B")  # revealed: Literal[False]
+    reveal_type("--" is not "--")  # revealed: bool
+    reveal_type("A" is not "B")  # revealed: Literal[True]
+    reveal_type(x < "...")  # revealed: bool
 
-reveal_type("abc" == "abc")  # revealed: Literal[True]
-reveal_type("ab_cd" <= "ab_ce")  # revealed: Literal[True]
-reveal_type("abc" in "ab cd")  # revealed: Literal[False]
-reveal_type("" not in "hello")  # revealed: Literal[False]
-reveal_type("--" is "--")  # revealed: bool
-reveal_type("A" is "B")  # revealed: Literal[False]
-reveal_type("--" is not "--")  # revealed: bool
-reveal_type("A" is not "B")  # revealed: Literal[True]
-reveal_type(str_instance() < "...")  # revealed: bool
-
-# ensure we're not comparing the interned salsa symbols, which compare by order of declaration.
-reveal_type("ab" < "ab_cd")  # revealed: Literal[True]
+    # ensure we're not comparing the interned salsa symbols, which compare by order of declaration.
+    reveal_type("ab" < "ab_cd")  # revealed: Literal[True]
 ```

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

@@ -58,26 +58,23 @@ reveal_type(c >= d)  # revealed: Literal[True]
 #### Results with Ambiguity
 
 ```py
-def bool_instance() -> bool: ...
-def int_instance() -> int:
-    return 42
+def _(x: bool, y: int):
+    a = (x,)
+    b = (y,)
 
-a = (bool_instance(),)
-b = (int_instance(),)
+    reveal_type(a == a)  # revealed: bool
+    reveal_type(a != a)  # revealed: bool
+    reveal_type(a < a)  # revealed: bool
+    reveal_type(a <= a)  # revealed: bool
+    reveal_type(a > a)  # revealed: bool
+    reveal_type(a >= a)  # revealed: bool
 
-reveal_type(a == a)  # revealed: bool
-reveal_type(a != a)  # revealed: bool
-reveal_type(a < a)  # revealed: bool
-reveal_type(a <= a)  # revealed: bool
-reveal_type(a > a)  # revealed: bool
-reveal_type(a >= a)  # revealed: bool
-
-reveal_type(a == b)  # revealed: bool
-reveal_type(a != b)  # revealed: bool
-reveal_type(a < b)  # revealed: bool
-reveal_type(a <= b)  # revealed: bool
-reveal_type(a > b)  # revealed: bool
-reveal_type(a >= b)  # revealed: bool
+    reveal_type(a == b)  # revealed: bool
+    reveal_type(a != b)  # revealed: bool
+    reveal_type(a < b)  # revealed: bool
+    reveal_type(a <= b)  # revealed: bool
+    reveal_type(a > b)  # revealed: bool
+    reveal_type(a >= b)  # revealed: bool
 ```
 
 #### Comparison Unsupported
@@ -134,23 +131,148 @@ reveal_type(c >= c)  # revealed: Literal[True]
 
 #### Non Boolean Rich Comparisons
 
+Rich comparison methods defined in a class affect tuple comparisons as well. Proper type inference
+should be possible even in cases where these methods return non-boolean types.
+
+Note: Tuples use lexicographic comparisons. If the `==` result for all paired elements in the tuple
+is True, the comparison then considers the tuple’s length. Regardless of the return type of the
+dunder methods, the final result can still be a boolean value.
+
+(+cpython: For tuples, `==` and `!=` always produce boolean results, regardless of the return type
+of the dunder methods.)
+
 ```py
+from __future__ import annotations
+
 class A:
-    def __eq__(self, o) -> str: ...
-    def __ne__(self, o) -> int: ...
-    def __lt__(self, o) -> float: ...
-    def __le__(self, o) -> object: ...
-    def __gt__(self, o) -> tuple: ...
-    def __ge__(self, o) -> list: ...
+    def __eq__(self, o: object) -> str:
+        return "hello"
+
+    def __ne__(self, o: object) -> bytes:
+        return b"world"
+
+    def __lt__(self, o: A) -> float:
+        return 3.14
+
+    def __le__(self, o: A) -> complex:
+        return complex(0.5, -0.5)
+
+    def __gt__(self, o: A) -> tuple:
+        return (1, 2, 3)
+
+    def __ge__(self, o: A) -> list:
+        return [1, 2, 3]
 
 a = (A(), A())
 
 reveal_type(a == a)  # revealed: bool
 reveal_type(a != a)  # revealed: bool
-reveal_type(a < a)  # revealed: bool
-reveal_type(a <= a)  # revealed: bool
-reveal_type(a > a)  # revealed: bool
-reveal_type(a >= a)  # revealed: bool
+reveal_type(a < a)  # revealed: float | Literal[False]
+reveal_type(a <= a)  # revealed: complex | Literal[True]
+reveal_type(a > a)  # revealed: tuple | Literal[False]
+reveal_type(a >= a)  # revealed: list | Literal[True]
+
+# If lexicographic comparison is finished before comparing A()
+b = ("1_foo", A())
+c = ("2_bar", A())
+
+reveal_type(b == c)  # revealed: Literal[False]
+reveal_type(b != c)  # revealed: Literal[True]
+reveal_type(b < c)  # revealed: Literal[True]
+reveal_type(b <= c)  # revealed: Literal[True]
+reveal_type(b > c)  # revealed: Literal[False]
+reveal_type(b >= c)  # revealed: Literal[False]
+
+class B:
+    def __lt__(self, o: B) -> set:
+        return set()
+
+reveal_type((A(), B()) < (A(), B()))  # revealed: float | set | Literal[False]
+```
+
+#### Special Handling of Eq and NotEq in Lexicographic Comparisons
+
+> Example: `(<int instance>, "foo") == (<int instance>, "bar")`
+
+`Eq` and `NotEq` have unique behavior compared to other operators in lexicographic comparisons.
+Specifically, for `Eq`, if any non-equal pair exists within the tuples being compared, we can
+immediately conclude that the tuples are not equal. Conversely, for `NotEq`, if any non-equal pair
+exists, we can determine that the tuples are unequal.
+
+In contrast, with operators like `<` and `>`, the comparison must consider each pair of elements
+sequentially, and the final outcome might remain ambiguous until all pairs are compared.
+
+```py
+def _(x: str, y: int):
+    reveal_type("foo" == "bar")  # revealed: Literal[False]
+    reveal_type(("foo",) == ("bar",))  # revealed: Literal[False]
+    reveal_type((4, "foo") == (4, "bar"))  # revealed: Literal[False]
+    reveal_type((y, "foo") == (y, "bar"))  # revealed: Literal[False]
+
+    a = (x, y, "foo")
+
+    reveal_type(a == a)  # revealed: bool
+    reveal_type(a != a)  # revealed: bool
+    reveal_type(a < a)  # revealed: bool
+    reveal_type(a <= a)  # revealed: bool
+    reveal_type(a > a)  # revealed: bool
+    reveal_type(a >= a)  # revealed: bool
+
+    b = (x, y, "bar")
+
+    reveal_type(a == b)  # revealed: Literal[False]
+    reveal_type(a != b)  # revealed: Literal[True]
+    reveal_type(a < b)  # revealed: bool
+    reveal_type(a <= b)  # revealed: bool
+    reveal_type(a > b)  # revealed: bool
+    reveal_type(a >= b)  # revealed: bool
+
+    c = (x, y, "foo", "different_length")
+
+    reveal_type(a == c)  # revealed: Literal[False]
+    reveal_type(a != c)  # revealed: Literal[True]
+    reveal_type(a < c)  # revealed: bool
+    reveal_type(a <= c)  # revealed: bool
+    reveal_type(a > c)  # revealed: bool
+    reveal_type(a >= c)  # revealed: bool
+```
+
+#### Error Propagation
+
+Errors occurring within a tuple comparison should propagate outward. However, if the tuple
+comparison can clearly conclude before encountering an error, the error should not be raised.
+
+```py
+def _(n: int, s: str):
+    class A: ...
+    # error: [unsupported-operator] "Operator `<` is not supported for types `A` and `A`"
+    A() < A()
+    # error: [unsupported-operator] "Operator `<=` is not supported for types `A` and `A`"
+    A() <= A()
+    # error: [unsupported-operator] "Operator `>` is not supported for types `A` and `A`"
+    A() > A()
+    # error: [unsupported-operator] "Operator `>=` is not supported for types `A` and `A`"
+    A() >= A()
+
+    a = (0, n, A())
+
+    # error: [unsupported-operator] "Operator `<` is not supported for types `A` and `A`, in comparing `tuple[Literal[0], int, A]` with `tuple[Literal[0], int, A]`"
+    reveal_type(a < a)  # revealed: Unknown
+    # error: [unsupported-operator] "Operator `<=` is not supported for types `A` and `A`, in comparing `tuple[Literal[0], int, A]` with `tuple[Literal[0], int, A]`"
+    reveal_type(a <= a)  # revealed: Unknown
+    # error: [unsupported-operator] "Operator `>` is not supported for types `A` and `A`, in comparing `tuple[Literal[0], int, A]` with `tuple[Literal[0], int, A]`"
+    reveal_type(a > a)  # revealed: Unknown
+    # error: [unsupported-operator] "Operator `>=` is not supported for types `A` and `A`, in comparing `tuple[Literal[0], int, A]` with `tuple[Literal[0], int, A]`"
+    reveal_type(a >= a)  # revealed: Unknown
+
+    # Comparison between `a` and `b` should only involve the first elements, `Literal[0]` and `Literal[99999]`,
+    # and should terminate immediately.
+    b = (99999, n, A())
+
+    reveal_type(a < b)  # revealed: Literal[True]
+    reveal_type(a <= b)  # revealed: Literal[True]
+    reveal_type(a > b)  # revealed: Literal[False]
+    reveal_type(a >= b)  # revealed: Literal[False]
 ```
 
 ### Membership Test Comparisons
@@ -158,22 +280,20 @@ reveal_type(a >= a)  # revealed: bool
 "Membership Test Comparisons" refers to the operators `in` and `not in`.
 
 ```py
-def int_instance() -> int:
-    return 42
+def _(n: int):
+    a = (1, 2)
+    b = ((3, 4), (1, 2))
+    c = ((1, 2, 3), (4, 5, 6))
+    d = ((n, n), (n, n))
 
-a = (1, 2)
-b = ((3, 4), (1, 2))
-c = ((1, 2, 3), (4, 5, 6))
-d = ((int_instance(), int_instance()), (int_instance(), int_instance()))
+    reveal_type(a in b)  # revealed: Literal[True]
+    reveal_type(a not in b)  # revealed: Literal[False]
 
-reveal_type(a in b)  # revealed: Literal[True]
-reveal_type(a not in b)  # revealed: Literal[False]
+    reveal_type(a in c)  # revealed: Literal[False]
+    reveal_type(a not in c)  # revealed: Literal[True]
 
-reveal_type(a in c)  # revealed: Literal[False]
-reveal_type(a not in c)  # revealed: Literal[True]
-
-reveal_type(a in d)  # revealed: bool
-reveal_type(a not in d)  # revealed: bool
+    reveal_type(a in d)  # revealed: bool
+    reveal_type(a not in d)  # revealed: bool
 ```
 
 ### Identity Comparisons

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

@@ -5,49 +5,46 @@
 Comparisons on union types need to consider all possible cases:
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    one_or_two = 1 if flag else 2
 
-flag = bool_instance()
-one_or_two = 1 if flag else 2
+    reveal_type(one_or_two <= 2)  # revealed: Literal[True]
+    reveal_type(one_or_two <= 1)  # revealed: bool
+    reveal_type(one_or_two <= 0)  # revealed: Literal[False]
 
-reveal_type(one_or_two <= 2)  # revealed: Literal[True]
-reveal_type(one_or_two <= 1)  # revealed: bool
-reveal_type(one_or_two <= 0)  # revealed: Literal[False]
+    reveal_type(2 >= one_or_two)  # revealed: Literal[True]
+    reveal_type(1 >= one_or_two)  # revealed: bool
+    reveal_type(0 >= one_or_two)  # revealed: Literal[False]
 
-reveal_type(2 >= one_or_two)  # revealed: Literal[True]
-reveal_type(1 >= one_or_two)  # revealed: bool
-reveal_type(0 >= one_or_two)  # revealed: Literal[False]
+    reveal_type(one_or_two < 1)  # revealed: Literal[False]
+    reveal_type(one_or_two < 2)  # revealed: bool
+    reveal_type(one_or_two < 3)  # revealed: Literal[True]
 
-reveal_type(one_or_two < 1)  # revealed: Literal[False]
-reveal_type(one_or_two < 2)  # revealed: bool
-reveal_type(one_or_two < 3)  # revealed: Literal[True]
+    reveal_type(one_or_two > 0)  # revealed: Literal[True]
+    reveal_type(one_or_two > 1)  # revealed: bool
+    reveal_type(one_or_two > 2)  # revealed: Literal[False]
 
-reveal_type(one_or_two > 0)  # revealed: Literal[True]
-reveal_type(one_or_two > 1)  # revealed: bool
-reveal_type(one_or_two > 2)  # revealed: Literal[False]
+    reveal_type(one_or_two == 3)  # revealed: Literal[False]
+    reveal_type(one_or_two == 1)  # revealed: bool
 
-reveal_type(one_or_two == 3)  # revealed: Literal[False]
-reveal_type(one_or_two == 1)  # revealed: bool
+    reveal_type(one_or_two != 3)  # revealed: Literal[True]
+    reveal_type(one_or_two != 1)  # revealed: bool
 
-reveal_type(one_or_two != 3)  # revealed: Literal[True]
-reveal_type(one_or_two != 1)  # revealed: bool
+    a_or_ab = "a" if flag else "ab"
 
-a_or_ab = "a" if flag else "ab"
+    reveal_type(a_or_ab in "ab")  # revealed: Literal[True]
+    reveal_type("a" in a_or_ab)  # revealed: Literal[True]
 
-reveal_type(a_or_ab in "ab")  # revealed: Literal[True]
-reveal_type("a" in a_or_ab)  # revealed: Literal[True]
+    reveal_type("c" not in a_or_ab)  # revealed: Literal[True]
+    reveal_type("a" not in a_or_ab)  # revealed: Literal[False]
 
-reveal_type("c" not in a_or_ab)  # revealed: Literal[True]
-reveal_type("a" not in a_or_ab)  # revealed: Literal[False]
+    reveal_type("b" in a_or_ab)  # revealed: bool
+    reveal_type("b" not in a_or_ab)  # revealed: bool
 
-reveal_type("b" in a_or_ab)  # revealed: bool
-reveal_type("b" not in a_or_ab)  # revealed: bool
+    one_or_none = 1 if flag else None
 
-one_or_none = 1 if flag else None
-
-reveal_type(one_or_none is None)  # revealed: bool
-reveal_type(one_or_none is not None)  # revealed: bool
+    reveal_type(one_or_none is None)  # revealed: bool
+    reveal_type(one_or_none is not None)  # revealed: bool
 ```
 
 ## Union on both sides of the comparison
@@ -56,18 +53,15 @@ With unions on both sides, we need to consider the full cross product of options
 resulting (union) type:
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag_s: bool, flag_l: bool):
+    small = 1 if flag_s else 2
+    large = 2 if flag_l else 3
 
-flag_s, flag_l = bool_instance(), bool_instance()
-small = 1 if flag_s else 2
-large = 2 if flag_l else 3
+    reveal_type(small <= large)  # revealed: Literal[True]
+    reveal_type(small >= large)  # revealed: bool
 
-reveal_type(small <= large)  # revealed: Literal[True]
-reveal_type(small >= large)  # revealed: bool
-
-reveal_type(small < large)  # revealed: bool
-reveal_type(small > large)  # revealed: Literal[False]
+    reveal_type(small < large)  # revealed: bool
+    reveal_type(small > large)  # revealed: Literal[False]
 ```
 
 ## Unsupported operations
@@ -77,12 +71,9 @@ back to `bool` for the result type instead of trying to infer something more pre
 (supported) variants:
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = [1, 2] if flag else 1
 
-flag = bool_instance()
-x = [1, 2] if flag else 1
-
-result = 1 in x  # error: "Operator `in` is not supported"
-reveal_type(result)  # revealed: bool
+    result = 1 in x  # error: "Operator `in` is not supported"
+    reveal_type(result)  # revealed: bool
 ```

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

@@ -1,36 +1,38 @@
 # Comparison: Unsupported operators
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool, flag1: bool, flag2: bool):
+    class A: ...
+    a = 1 in 7  # error: "Operator `in` is not supported for types `Literal[1]` and `Literal[7]`"
+    reveal_type(a)  # revealed: bool
 
-a = 1 in 7  # error: "Operator `in` is not supported for types `Literal[1]` and `Literal[7]`"
-reveal_type(a)  # revealed: bool
+    b = 0 not in 10  # error: "Operator `not in` is not supported for types `Literal[0]` and `Literal[10]`"
+    reveal_type(b)  # revealed: bool
 
-b = 0 not in 10  # error: "Operator `not in` is not supported for types `Literal[0]` and `Literal[10]`"
-reveal_type(b)  # revealed: bool
+    # TODO: should error, once operand type check is implemented
+    # ("Operator `<` is not supported for types `object` and `int`")
+    c = object() < 5
+    # TODO: should be Unknown, once operand type check is implemented
+    reveal_type(c)  # revealed: bool
 
-# TODO: should error, once operand type check is implemented
-# ("Operator `<` is not supported for types `object` and `int`")
-c = object() < 5
-# TODO: should be Unknown, once operand type check is implemented
-reveal_type(c)  # revealed: bool
+    # TODO: should error, once operand type check is implemented
+    # ("Operator `<` is not supported for types `int` and `object`")
+    d = 5 < object()
+    # TODO: should be Unknown, once operand type check is implemented
+    reveal_type(d)  # revealed: bool
 
-# TODO: should error, once operand type check is implemented
-# ("Operator `<` is not supported for types `int` and `object`")
-d = 5 < object()
-# TODO: should be Unknown, once operand type check is implemented
-reveal_type(d)  # revealed: bool
+    int_literal_or_str_literal = 1 if flag else "foo"
+    # error: "Operator `in` is not supported for types `Literal[42]` and `Literal[1]`, in comparing `Literal[42]` with `Literal[1] | Literal["foo"]`"
+    e = 42 in int_literal_or_str_literal
+    reveal_type(e)  # revealed: bool
 
-flag = bool_instance()
-int_literal_or_str_literal = 1 if flag else "foo"
-# error: "Operator `in` is not supported for types `Literal[42]` and `Literal[1]`, in comparing `Literal[42]` with `Literal[1] | Literal["foo"]`"
-e = 42 in int_literal_or_str_literal
-reveal_type(e)  # revealed: bool
+    # TODO: should error, need to check if __lt__ signature is valid for right operand
+    # error may be "Operator `<` is not supported for types `int` and `str`, in comparing `tuple[Literal[1], Literal[2]]` with `tuple[Literal[1], Literal["hello"]]`
+    f = (1, 2) < (1, "hello")
+    # TODO: should be Unknown, once operand type check is implemented
+    reveal_type(f)  # revealed: bool
 
-# TODO: should error, need to check if __lt__ signature is valid for right operand
-# error may be "Operator `<` is not supported for types `int` and `str`, in comparing `tuple[Literal[1], Literal[2]]` with `tuple[Literal[1], Literal["hello"]]`
-f = (1, 2) < (1, "hello")
-# TODO: should be Unknown, once operand type check is implemented
-reveal_type(f)  # revealed: bool
+    # error: [unsupported-operator] "Operator `<` is not supported for types `A` and `A`, in comparing `tuple[bool, A]` with `tuple[bool, A]`"
+    g = (flag1, A()) < (flag2, A())
+    reveal_type(g)  # revealed: Unknown
 ```

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

@@ -3,47 +3,35 @@
 ## Simple if-expression
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-x = 1 if flag else 2
-reveal_type(x)  # revealed: Literal[1, 2]
+def _(flag: bool):
+    x = 1 if flag else 2
+    reveal_type(x)  # revealed: Literal[1, 2]
 ```
 
 ## If-expression with walrus operator
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-y = 0
-z = 0
-x = (y := 1) if flag else (z := 2)
-reveal_type(x)  # revealed: Literal[1, 2]
-reveal_type(y)  # revealed: Literal[0, 1]
-reveal_type(z)  # revealed: Literal[0, 2]
+def _(flag: bool):
+    y = 0
+    z = 0
+    x = (y := 1) if flag else (z := 2)
+    reveal_type(x)  # revealed: Literal[1, 2]
+    reveal_type(y)  # revealed: Literal[0, 1]
+    reveal_type(z)  # revealed: Literal[0, 2]
 ```
 
 ## Nested if-expression
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-x = 1 if flag else 2 if flag2 else 3
-reveal_type(x)  # revealed: Literal[1, 2, 3]
+def _(flag: bool, flag2: bool):
+    x = 1 if flag else 2 if flag2 else 3
+    reveal_type(x)  # revealed: Literal[1, 2, 3]
 ```
 
 ## None
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-x = 1 if flag else None
-reveal_type(x)  # revealed: Literal[1] | None
+def _(flag: bool):
+    x = 1 if flag else None
+    reveal_type(x)  # revealed: Literal[1] | None
 ```

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

@@ -3,128 +3,115 @@
 ## Simple if
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    y = 1
+    y = 2
 
-flag = bool_instance()
-y = 1
-y = 2
+    if flag:
+        y = 3
 
-if flag:
-    y = 3
-
-reveal_type(y)  # revealed: Literal[2, 3]
+    reveal_type(y)  # revealed: Literal[2, 3]
 ```
 
 ## Simple if-elif-else
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool, flag2: bool):
+    y = 1
+    y = 2
 
-flag, flag2 = bool_instance(), bool_instance()
-y = 1
-y = 2
-if flag:
-    y = 3
-elif flag2:
-    y = 4
-else:
-    r = y
-    y = 5
-    s = y
-x = y
+    if flag:
+        y = 3
+    elif flag2:
+        y = 4
+    else:
+        r = y
+        y = 5
+        s = y
+    x = y
 
-reveal_type(x)  # revealed: Literal[3, 4, 5]
+    reveal_type(x)  # revealed: Literal[3, 4, 5]
 
-# revealed: Literal[2]
-# error: [possibly-unresolved-reference]
-reveal_type(r)
+    # revealed: Literal[2]
+    # error: [possibly-unresolved-reference]
+    reveal_type(r)
 
-# revealed: Literal[5]
-# error: [possibly-unresolved-reference]
-reveal_type(s)
+    # revealed: Literal[5]
+    # error: [possibly-unresolved-reference]
+    reveal_type(s)
 ```
 
 ## Single symbol across if-elif-else
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool, flag2: bool):
+    if flag:
+        y = 1
+    elif flag2:
+        y = 2
+    else:
+        y = 3
 
-flag, flag2 = bool_instance(), bool_instance()
-
-if flag:
-    y = 1
-elif flag2:
-    y = 2
-else:
-    y = 3
-reveal_type(y)  # revealed: Literal[1, 2, 3]
+    reveal_type(y)  # revealed: Literal[1, 2, 3]
 ```
 
 ## if-elif-else without else assignment
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool, flag2: bool):
+    y = 0
 
-flag, flag2 = bool_instance(), bool_instance()
-y = 0
-if flag:
-    y = 1
-elif flag2:
-    y = 2
-else:
-    pass
-reveal_type(y)  # revealed: Literal[0, 1, 2]
+    if flag:
+        y = 1
+    elif flag2:
+        y = 2
+    else:
+        pass
+
+    reveal_type(y)  # revealed: Literal[0, 1, 2]
 ```
 
 ## if-elif-else with intervening assignment
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool, flag2: bool):
+    y = 0
 
-flag, flag2 = bool_instance(), bool_instance()
-y = 0
-if flag:
-    y = 1
-    z = 3
-elif flag2:
-    y = 2
-else:
-    pass
-reveal_type(y)  # revealed: Literal[0, 1, 2]
+    if flag:
+        y = 1
+        z = 3
+    elif flag2:
+        y = 2
+    else:
+        pass
+
+    reveal_type(y)  # revealed: Literal[0, 1, 2]
 ```
 
 ## Nested if statement
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool, flag2: bool):
+    y = 0
 
-flag, flag2 = bool_instance(), bool_instance()
-y = 0
-if flag:
-    if flag2:
-        y = 1
-reveal_type(y)  # revealed: Literal[0, 1]
+    if flag:
+        if flag2:
+            y = 1
+
+    reveal_type(y)  # revealed: Literal[0, 1]
 ```
 
 ## if-elif without else
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool, flag2: bool):
+    y = 1
+    y = 2
 
-flag, flag2 = bool_instance(), bool_instance()
-y = 1
-y = 2
-if flag:
-    y = 3
-elif flag2:
-    y = 4
+    if flag:
+        y = 3
+    elif flag2:
+        y = 4
 
-reveal_type(y)  # revealed: Literal[2, 3, 4]
+    reveal_type(y)  # revealed: Literal[2, 3, 4]
 ```

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

@@ -3,39 +3,43 @@
 ## With wildcard
 
 ```py
-match 0:
-    case 1:
-        y = 2
-    case _:
-        y = 3
+def _(target: int):
+    match target:
+        case 1:
+            y = 2
+        case _:
+            y = 3
 
-reveal_type(y)  # revealed: Literal[2, 3]
+    reveal_type(y)  # revealed: Literal[2, 3]
 ```
 
 ## Without wildcard
 
 ```py
-match 0:
-    case 1:
-        y = 2
-    case 2:
-        y = 3
+def _(target: int):
+    match target:
+        case 1:
+            y = 2
+        case 2:
+            y = 3
 
-# revealed: Literal[2, 3]
-# error: [possibly-unresolved-reference]
-reveal_type(y)
+    # revealed: Literal[2, 3]
+    # error: [possibly-unresolved-reference]
+    reveal_type(y)
 ```
 
 ## Basic match
 
 ```py
-y = 1
-y = 2
-match 0:
-    case 1:
-        y = 3
-    case 2:
-        y = 4
+def _(target: int):
+    y = 1
+    y = 2
 
-reveal_type(y)  # revealed: Literal[2, 3, 4]
+    match target:
+        case 1:
+            y = 3
+        case 2:
+            y = 4
+
+    reveal_type(y)  # revealed: Literal[2, 3, 4]
 ```

crates/red_knot_python_semantic/resources/mdtest/declaration/error.md

@@ -10,42 +10,66 @@ x: str  # error: [invalid-declaration] "Cannot declare type `str` for inferred t
 ## Incompatible declarations
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    if flag:
+        x: str
+    else:
+        x: int
 
-flag = bool_instance()
-if flag:
-    x: str
-else:
-    x: int
-x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: str, int"
+    x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: str, int"
 ```
 
-## Partial declarations
+## Incompatible declarations for 2 (out of 3) types
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool):
+    if flag1:
+        x: str
+    elif flag2:
+        x: int
 
-flag = bool_instance()
-if flag:
-    x: int
-x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: Unknown, int"
+    # Here, the declared type for `x` is `int | str | Unknown`.
+    x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: str, int"
 ```
 
 ## Incompatible declarations with bad assignment
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    if flag:
+        x: str
+    else:
+        x: int
 
-flag = bool_instance()
-if flag:
-    x: str
-else:
-    x: int
-
-# error: [conflicting-declarations]
-# error: [invalid-assignment]
-x = b"foo"
+    # error: [conflicting-declarations]
+    # error: [invalid-assignment]
+    x = b"foo"
+```
+
+## No errors
+
+Currently, we avoid raising the conflicting-declarations for the following cases:
+
+### Partial declarations
+
+```py
+def _(flag: bool):
+    if flag:
+        x: int
+
+    x = 1
+```
+
+### Partial declarations in try-except
+
+Refer to <https://github.com/astral-sh/ruff/issues/13966>
+
+```py
+def _():
+    try:
+        x: int = 1
+    except:
+        x = 2
+
+    x = 3
 ```

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

@@ -49,12 +49,124 @@ def foo(
     try:
         help()
     except x as e:
-        # TODO: should be `AttributeError`
-        reveal_type(e)  # revealed: @Todo
+        reveal_type(e)  # revealed: AttributeError
     except y as f:
-        # TODO: should be `OSError | RuntimeError`
-        reveal_type(f)  # revealed: @Todo
+        reveal_type(f)  # revealed: OSError | RuntimeError
     except z as g:
         # TODO: should be `BaseException`
-        reveal_type(g)  # revealed: @Todo
+        reveal_type(g)  # revealed: @Todo(full tuple[...] support)
+```
+
+## Invalid exception handlers
+
+```py
+try:
+    pass
+# error: [invalid-exception-caught] "Cannot catch object of type `Literal[3]` in an exception handler (must be a `BaseException` subclass or a tuple of `BaseException` subclasses)"
+except 3 as e:
+    reveal_type(e)  # revealed: Unknown
+
+try:
+    pass
+# error: [invalid-exception-caught] "Cannot catch object of type `Literal["foo"]` in an exception handler (must be a `BaseException` subclass or a tuple of `BaseException` subclasses)"
+# error: [invalid-exception-caught] "Cannot catch object of type `Literal[b"bar"]` in an exception handler (must be a `BaseException` subclass or a tuple of `BaseException` subclasses)"
+except (ValueError, OSError, "foo", b"bar") as e:
+    reveal_type(e)  # revealed: ValueError | OSError | Unknown
+
+def foo(
+    x: type[str],
+    y: tuple[type[OSError], type[RuntimeError], int],
+    z: tuple[type[str], ...],
+):
+    try:
+        help()
+    # error: [invalid-exception-caught]
+    except x as e:
+        reveal_type(e)  # revealed: Unknown
+    # error: [invalid-exception-caught]
+    except y as f:
+        reveal_type(f)  # revealed: OSError | RuntimeError | Unknown
+    except z as g:
+        # TODO: should emit a diagnostic here:
+        reveal_type(g)  # revealed: @Todo(full tuple[...] support)
+```
+
+## Object raised is not an exception
+
+```py
+try:
+    raise AttributeError()  # fine
+except:
+    ...
+
+try:
+    raise FloatingPointError  # fine
+except:
+    ...
+
+try:
+    raise 1  # error: [invalid-raise]
+except:
+    ...
+
+try:
+    raise int  # error: [invalid-raise]
+except:
+    ...
+
+def _(e: Exception | type[Exception]):
+    raise e  # fine
+
+def _(e: Exception | type[Exception] | None):
+    raise e  # error: [invalid-raise]
+```
+
+## Exception cause is not an exception
+
+```py
+try:
+    raise EOFError() from GeneratorExit  # fine
+except:
+    ...
+
+try:
+    raise StopIteration from MemoryError()  # fine
+except:
+    ...
+
+try:
+    raise BufferError() from None  # fine
+except:
+    ...
+
+try:
+    raise ZeroDivisionError from False  # error: [invalid-raise]
+except:
+    ...
+
+try:
+    raise SystemExit from bool()  # error: [invalid-raise]
+except:
+    ...
+
+try:
+    raise
+except KeyboardInterrupt as e:  # fine
+    reveal_type(e)  # revealed: KeyboardInterrupt
+    raise LookupError from e  # fine
+
+try:
+    raise
+except int as e:  # error: [invalid-exception-caught]
+    reveal_type(e)  # revealed: Unknown
+    raise KeyError from e
+
+def _(e: Exception | type[Exception]):
+    raise ModuleNotFoundError from e  # fine
+
+def _(e: Exception | type[Exception] | None):
+    raise IndexError from e  # fine
+
+def _(e: int | None):
+    raise IndexError from e  # error: [invalid-raise]
 ```

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

@@ -1,30 +1,66 @@
-# Except star
+# `except*`
 
-## Except\* with BaseException
+`except*` is only available in Python 3.11 and later:
+
+```toml
+[environment]
+python-version = "3.11"
+```
+
+## `except*` with `BaseException`
 
 ```py
 try:
     help()
 except* BaseException as e:
+    # TODO: should be `BaseExceptionGroup[BaseException]` --Alex
     reveal_type(e)  # revealed: BaseExceptionGroup
 ```
 
-## Except\* with specific exception
+## `except*` with specific exception
 
 ```py
 try:
     help()
 except* OSError as e:
-    # TODO(Alex): more precise would be `ExceptionGroup[OSError]`
+    # TODO: more precise would be `ExceptionGroup[OSError]` --Alex
+    # (needs homogenous tuples + generics)
     reveal_type(e)  # revealed: BaseExceptionGroup
 ```
 
-## Except\* with multiple exceptions
+## `except*` with multiple exceptions
 
 ```py
 try:
     help()
 except* (TypeError, AttributeError) as e:
-    # TODO(Alex): more precise would be `ExceptionGroup[TypeError | AttributeError]`.
+    # TODO: more precise would be `ExceptionGroup[TypeError | AttributeError]` --Alex
+    # (needs homogenous tuples + generics)
+    reveal_type(e)  # revealed: BaseExceptionGroup
+```
+
+## `except*` with mix of `Exception`s and `BaseException`s
+
+```py
+try:
+    help()
+except* (KeyboardInterrupt, AttributeError) as e:
+    # TODO: more precise would be `BaseExceptionGroup[KeyboardInterrupt | AttributeError]` --Alex
+    reveal_type(e)  # revealed: BaseExceptionGroup
+```
+
+## Invalid `except*` handlers
+
+```py
+try:
+    help()
+except* 3 as e:  # error: [invalid-exception-caught]
+    # TODO: Should be `BaseExceptionGroup[Unknown]` --Alex
+    reveal_type(e)  # revealed: BaseExceptionGroup
+
+try:
+    help()
+except* (AttributeError, 42) as e:  # error: [invalid-exception-caught]
+    # TODO: Should be `BaseExceptionGroup[AttributeError | Unknown]` --Alex
     reveal_type(e)  # revealed: BaseExceptionGroup
 ```

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

@@ -9,5 +9,4 @@ try:
     print
 except as e:  # error: [invalid-syntax]
     reveal_type(e)  # revealed: Unknown
-
 ```

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

@@ -3,26 +3,25 @@
 ## Boundness
 
 ```py
-def flag() -> bool: ...
+def _(flag: bool):
+    class A:
+        always_bound = 1
 
-class A:
-    always_bound = 1
+        if flag:
+            union = 1
+        else:
+            union = "abc"
 
-    if flag():
-        union = 1
-    else:
-        union = "abc"
+        if flag:
+            possibly_unbound = "abc"
 
-    if flag():
-        possibly_unbound = "abc"
+    reveal_type(A.always_bound)  # revealed: Literal[1]
 
-reveal_type(A.always_bound)  # revealed: Literal[1]
+    reveal_type(A.union)  # revealed: Literal[1] | Literal["abc"]
 
-reveal_type(A.union)  # revealed: Literal[1] | Literal["abc"]
+    # error: [possibly-unbound-attribute] "Attribute `possibly_unbound` on type `Literal[A]` is possibly unbound"
+    reveal_type(A.possibly_unbound)  # revealed: Literal["abc"]
 
-# error: [possibly-unbound-attribute] "Attribute `possibly_unbound` on type `Literal[A]` is possibly unbound"
-reveal_type(A.possibly_unbound)  # revealed: Literal["abc"]
-
-# error: [unresolved-attribute] "Type `Literal[A]` has no attribute `non_existent`"
-reveal_type(A.non_existent)  # revealed: Unknown
+    # error: [unresolved-attribute] "Type `Literal[A]` has no attribute `non_existent`"
+    reveal_type(A.non_existent)  # revealed: Unknown
 ```

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

@@ -3,54 +3,45 @@
 ## OR
 
 ```py
-def foo() -> str:
-    pass
-
-reveal_type(True or False)  # revealed: Literal[True]
-reveal_type("x" or "y" or "z")  # revealed: Literal["x"]
-reveal_type("" or "y" or "z")  # revealed: Literal["y"]
-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 | Literal[False]
-reveal_type(foo() or True)  # revealed: str | Literal[True]
+def _(foo: str):
+    reveal_type(True or False)  # revealed: Literal[True]
+    reveal_type("x" or "y" or "z")  # revealed: Literal["x"]
+    reveal_type("" or "y" or "z")  # revealed: Literal["y"]
+    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 | Literal[False]
+    reveal_type(foo or True)  # revealed: str | Literal[True]
 ```
 
 ## AND
 
 ```py
-def foo() -> str:
-    pass
-
-reveal_type(True and False)  # revealed: Literal[False]
-reveal_type(False and True)  # revealed: Literal[False]
-reveal_type(foo() and False)  # revealed: str | Literal[False]
-reveal_type(foo() and True)  # revealed: str | 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[""]
+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 | Literal[False]
+    reveal_type(foo and True)  # revealed: str | 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[""]
 ```
 
 ## Simple function calls to bool
 
 ```py
-def returns_bool() -> bool:
-    return True
+def _(flag: bool):
+    if flag:
+        x = True
+    else:
+        x = False
 
-if returns_bool():
-    x = True
-else:
-    x = False
-
-reveal_type(x)  # revealed: bool
+    reveal_type(x)  # revealed: bool
 ```
 
 ## Complex
 
 ```py
-def foo() -> str:
-    pass
-
 reveal_type("x" and "y" or "z")  # revealed: Literal["y"]
 reveal_type("x" or "y" and "z")  # revealed: Literal["x"]
 reveal_type("" and "y" or "z")  # revealed: Literal["z"]

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

@@ -3,10 +3,8 @@
 ## Union
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-reveal_type(1 if bool_instance() else 2)  # revealed: Literal[1, 2]
+def _(flag: bool):
+    reveal_type(1 if flag else 2)  # revealed: Literal[1, 2]
 ```
 
 ## Statically known branches
@@ -22,3 +20,20 @@ reveal_type(1 if None else 2)  # revealed: Literal[2]
 reveal_type(1 if "" else 2)  # revealed: Literal[2]
 reveal_type(1 if 0 else 2)  # revealed: Literal[2]
 ```
+
+## Leaked Narrowing Constraint
+
+(issue #14588)
+
+The test inside an if expression should not affect code outside of the expression.
+
+```py
+def _(flag: bool):
+    x: Literal[42, "hello"] = 42 if flag else "hello"
+
+    reveal_type(x)  # revealed: Literal[42] | Literal["hello"]
+
+    _ = ... if isinstance(x, str) else ...
+
+    reveal_type(x)  # revealed: Literal[42] | Literal["hello"]
+```

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

@@ -0,0 +1,218 @@
+# Length (`len()`)
+
+## Literal and constructed iterables
+
+### Strings and bytes literals
+
+```py
+reveal_type(len("no\rmal"))  # revealed: Literal[6]
+reveal_type(len(r"aw stri\ng"))  # revealed: Literal[10]
+reveal_type(len(r"conca\t" "ena\tion"))  # revealed: Literal[14]
+reveal_type(len(b"ytes lite" rb"al"))  # revealed: Literal[11]
+reveal_type(len("𝒰𝕹🄸©🕲𝕕ℇ"))  # revealed: Literal[7]
+
+reveal_type(  # revealed: Literal[7]
+    len(
+        """foo
+bar"""
+    )
+)
+reveal_type(  # revealed: Literal[9]
+    len(
+        r"""foo\r
+bar"""
+    )
+)
+reveal_type(  # revealed: Literal[7]
+    len(
+        b"""foo
+bar"""
+    )
+)
+reveal_type(  # revealed: Literal[9]
+    len(
+        rb"""foo\r
+bar"""
+    )
+)
+```
+
+### Tuples
+
+```py
+reveal_type(len(()))  # revealed: Literal[0]
+reveal_type(len((1,)))  # revealed: Literal[1]
+reveal_type(len((1, 2)))  # revealed: Literal[2]
+
+# TODO: Handle constructor calls
+reveal_type(len(tuple()))  # revealed: int
+
+# TODO: Handle star unpacks; Should be: Literal[0]
+reveal_type(len((*[],)))  # revealed: Literal[1]
+
+# TODO: Handle star unpacks; Should be: Literal[1]
+reveal_type(  # revealed: Literal[2]
+    len(
+        (
+            *[],
+            1,
+        )
+    )
+)
+
+# TODO: Handle star unpacks; Should be: Literal[2]
+reveal_type(len((*[], 1, 2)))  # revealed: Literal[3]
+
+# TODO: Handle star unpacks; Should be: Literal[0]
+reveal_type(len((*[], *{})))  # revealed: Literal[2]
+```
+
+### Lists, sets and dictionaries
+
+```py
+reveal_type(len([]))  # revealed: int
+reveal_type(len([1]))  # revealed: int
+reveal_type(len([1, 2]))  # revealed: int
+reveal_type(len([*{}, *dict()]))  # revealed: int
+
+reveal_type(len({}))  # revealed: int
+reveal_type(len({**{}}))  # revealed: int
+reveal_type(len({**{}, **{}}))  # revealed: int
+
+reveal_type(len({1}))  # revealed: int
+reveal_type(len({1, 2}))  # revealed: int
+reveal_type(len({*[], 2}))  # revealed: int
+
+reveal_type(len(list()))  # revealed: int
+reveal_type(len(set()))  # revealed: int
+reveal_type(len(dict()))  # revealed: int
+reveal_type(len(frozenset()))  # revealed: int
+```
+
+## `__len__`
+
+The returned value of `__len__` is implicitly and recursively converted to `int`.
+
+### Literal integers
+
+```py
+from typing import Literal
+
+class Zero:
+    def __len__(self) -> Literal[0]: ...
+
+class ZeroOrOne:
+    def __len__(self) -> Literal[0, 1]: ...
+
+class ZeroOrTrue:
+    def __len__(self) -> Literal[0, True]: ...
+
+class OneOrFalse:
+    def __len__(self) -> Literal[1] | Literal[False]: ...
+
+class OneOrFoo:
+    def __len__(self) -> Literal[1, "foo"]: ...
+
+class ZeroOrStr:
+    def __len__(self) -> Literal[0] | str: ...
+
+reveal_type(len(Zero()))  # revealed: Literal[0]
+reveal_type(len(ZeroOrOne()))  # revealed: Literal[0, 1]
+reveal_type(len(ZeroOrTrue()))  # revealed: Literal[0, 1]
+reveal_type(len(OneOrFalse()))  # revealed: Literal[0, 1]
+
+# TODO: Emit a diagnostic
+reveal_type(len(OneOrFoo()))  # revealed: int
+
+# TODO: Emit a diagnostic
+reveal_type(len(ZeroOrStr()))  # revealed: int
+```
+
+### Literal booleans
+
+```py
+from typing import Literal
+
+class LiteralTrue:
+    def __len__(self) -> Literal[True]: ...
+
+class LiteralFalse:
+    def __len__(self) -> Literal[False]: ...
+
+reveal_type(len(LiteralTrue()))  # revealed: Literal[1]
+reveal_type(len(LiteralFalse()))  # revealed: Literal[0]
+```
+
+### Enums
+
+```py
+from enum import Enum, auto
+from typing import Literal
+
+class SomeEnum(Enum):
+    AUTO = auto()
+    INT = 2
+    STR = "4"
+    TUPLE = (8, "16")
+    INT_2 = 3_2
+
+class Auto:
+    def __len__(self) -> Literal[SomeEnum.AUTO]: ...
+
+class Int:
+    def __len__(self) -> Literal[SomeEnum.INT]: ...
+
+class Str:
+    def __len__(self) -> Literal[SomeEnum.STR]: ...
+
+class Tuple:
+    def __len__(self) -> Literal[SomeEnum.TUPLE]: ...
+
+class IntUnion:
+    def __len__(self) -> Literal[SomeEnum.INT, SomeEnum.INT_2]: ...
+
+reveal_type(len(Auto()))  # revealed: int
+reveal_type(len(Int()))  # revealed: Literal[2]
+reveal_type(len(Str()))  # revealed: int
+reveal_type(len(Tuple()))  # revealed: int
+reveal_type(len(IntUnion()))  # revealed: Literal[2, 32]
+```
+
+### Negative integers
+
+```py
+from typing import Literal
+
+class Negative:
+    def __len__(self) -> Literal[-1]: ...
+
+# TODO: Emit a diagnostic
+reveal_type(len(Negative()))  # revealed: int
+```
+
+### Wrong signature
+
+```py
+from typing import Literal
+
+class SecondOptionalArgument:
+    def __len__(self, v: int = 0) -> Literal[0]: ...
+
+class SecondRequiredArgument:
+    def __len__(self, v: int) -> Literal[1]: ...
+
+# TODO: Emit a diagnostic
+reveal_type(len(SecondOptionalArgument()))  # revealed: Literal[0]
+
+# TODO: Emit a diagnostic
+reveal_type(len(SecondRequiredArgument()))  # revealed: Literal[1]
+```
+
+### No `__len__`
+
+```py
+class NoDunderLen: ...
+
+# TODO: Emit a diagnostic
+reveal_type(len(NoDunderLen()))  # revealed: int
+```

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

@@ -0,0 +1,75 @@
+# Function parameter types
+
+Within a function scope, the declared type of each parameter is its annotated type (or Unknown if
+not annotated). The initial inferred type is the union of the declared type with the type of the
+default value expression (if any). If both are fully static types, this union should simplify to the
+annotated type (since the default value type must be assignable to the annotated type, and for fully
+static types this means subtype-of, which simplifies in unions). But if the annotated type is
+Unknown or another non-fully-static type, the default value type may still be relevant as lower
+bound.
+
+The variadic parameter is a variadic tuple of its annotated type; the variadic-keywords parameter is
+a dictionary from strings to its annotated type.
+
+## Parameter kinds
+
+```py
+from typing import Literal
+
+def f(a, b: int, c=1, d: int = 2, /, e=3, f: Literal[4] = 4, *args: object, g=5, h: Literal[6] = 6, **kwargs: str):
+    reveal_type(a)  # revealed: Unknown
+    reveal_type(b)  # revealed: int
+    reveal_type(c)  # revealed: Unknown | Literal[1]
+    reveal_type(d)  # revealed: int
+    reveal_type(e)  # revealed: Unknown | Literal[3]
+    reveal_type(f)  # revealed: Literal[4]
+    reveal_type(g)  # revealed: Unknown | Literal[5]
+    reveal_type(h)  # revealed: Literal[6]
+
+    # TODO: should be `tuple[object, ...]` (needs generics)
+    reveal_type(args)  # revealed: tuple
+
+    # TODO: should be `dict[str, str]` (needs generics)
+    reveal_type(kwargs)  # revealed: dict
+```
+
+## Unannotated variadic parameters
+
+...are inferred as tuple of Unknown or dict from string to Unknown.
+
+```py
+def g(*args, **kwargs):
+    # TODO: should be `tuple[Unknown, ...]` (needs generics)
+    reveal_type(args)  # revealed: tuple
+
+    # TODO: should be `dict[str, Unknown]` (needs generics)
+    reveal_type(kwargs)  # revealed: dict
+```
+
+## Annotation is present but not a fully static type
+
+The default value type should be a lower bound on the inferred type.
+
+```py
+from typing import Any
+
+def f(x: Any = 1):
+    reveal_type(x)  # revealed: Any | Literal[1]
+```
+
+## Default value type must be assignable to annotated type
+
+The default value type must be assignable to the annotated type. If not, we emit a diagnostic, and
+fall back to inferring the annotated type, ignoring the default value type.
+
+```py
+# error: [invalid-parameter-default]
+def f(x: int = "foo"):
+    reveal_type(x)  # revealed: int
+
+# The check is assignable-to, not subtype-of, so this is fine:
+from typing import Any
+
+def g(x: Any = "foo"):
+    reveal_type(x)  # revealed: Any | Literal["foo"]
+```

crates/red_knot_python_semantic/resources/mdtest/generics.md

@@ -18,7 +18,7 @@ box: MyBox[int] = MyBox(5)
 wrong_innards: MyBox[int] = MyBox("five")
 
 # TODO reveal int
-reveal_type(box.data)  # revealed: @Todo
+reveal_type(box.data)  # revealed: @Todo(instance attributes)
 
 reveal_type(MyBox.box_model_number)  # revealed: Literal[695]
 ```
@@ -39,7 +39,7 @@ class MySecureBox[T](MyBox[T]): ...
 secure_box: MySecureBox[int] = MySecureBox(5)
 reveal_type(secure_box)  # revealed: MySecureBox
 # TODO reveal int
-reveal_type(secure_box.data)  # revealed: @Todo
+reveal_type(secure_box.data)  # revealed: @Todo(instance attributes)
 ```
 
 ## Cyclical class definition
@@ -60,52 +60,20 @@ reveal_type(S)  # revealed: Literal[S]
 
 ## Type params
 
-A PEP695 type variable defines a value of type `typing.TypeVar` with attributes `__name__`,
-`__bounds__`, `__constraints__`, and `__default__` (the latter three all lazily evaluated):
+A PEP695 type variable defines a value of type `typing.TypeVar`.
 
 ```py
-def f[T, U: A, V: (A, B), W = A, X: A = A1]():
+def f[T]():
     reveal_type(T)  # revealed: T
     reveal_type(T.__name__)  # revealed: Literal["T"]
-    reveal_type(T.__bound__)  # revealed: None
-    reveal_type(T.__constraints__)  # revealed: tuple[()]
-    reveal_type(T.__default__)  # revealed: NoDefault
-
-    reveal_type(U)  # revealed: U
-    reveal_type(U.__name__)  # revealed: Literal["U"]
-    reveal_type(U.__bound__)  # revealed: type[A]
-    reveal_type(U.__constraints__)  # revealed: tuple[()]
-    reveal_type(U.__default__)  # revealed: NoDefault
-
-    reveal_type(V)  # revealed: V
-    reveal_type(V.__name__)  # revealed: Literal["V"]
-    reveal_type(V.__bound__)  # revealed: None
-    reveal_type(V.__constraints__)  # revealed: tuple[type[A], type[B]]
-    reveal_type(V.__default__)  # revealed: NoDefault
-
-    reveal_type(W)  # revealed: W
-    reveal_type(W.__name__)  # revealed: Literal["W"]
-    reveal_type(W.__bound__)  # revealed: None
-    reveal_type(W.__constraints__)  # revealed: tuple[()]
-    reveal_type(W.__default__)  # revealed: type[A]
-
-    reveal_type(X)  # revealed: X
-    reveal_type(X.__name__)  # revealed: Literal["X"]
-    reveal_type(X.__bound__)  # revealed: type[A]
-    reveal_type(X.__constraints__)  # revealed: tuple[()]
-    reveal_type(X.__default__)  # revealed: type[A1]
-
-class A: ...
-class B: ...
-class A1(A): ...
 ```
 
 ## Minimum two constraints
 
-A typevar with less than two constraints emits a diagnostic and is treated as unconstrained:
+A typevar with less than two constraints emits a diagnostic:
 
 ```py
-# error: [invalid-typevar-constraints] "TypeVar must have at least two constrained types"
+# error: [invalid-type-variable-constraints] "TypeVar must have at least two constrained types"
 def f[T: (int,)]():
-    reveal_type(T.__constraints__)  # revealed: tuple[()]
+    pass
 ```

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

@@ -25,3 +25,82 @@ reveal_type(D)  # revealed: Literal[C]
 ```py path=b.py
 class C: ...
 ```
+
+## Nested
+
+```py
+import a.b
+
+reveal_type(a.b.C)  # revealed: Literal[C]
+```
+
+```py path=a/__init__.py
+```
+
+```py path=a/b.py
+class C: ...
+```
+
+## Deeply nested
+
+```py
+import a.b.c
+
+reveal_type(a.b.c.C)  # revealed: Literal[C]
+```
+
+```py path=a/__init__.py
+```
+
+```py path=a/b/__init__.py
+```
+
+```py path=a/b/c.py
+class C: ...
+```
+
+## Nested with rename
+
+```py
+import a.b as b
+
+reveal_type(b.C)  # revealed: Literal[C]
+```
+
+```py path=a/__init__.py
+```
+
+```py path=a/b.py
+class C: ...
+```
+
+## Deeply nested with rename
+
+```py
+import a.b.c as c
+
+reveal_type(c.C)  # revealed: Literal[C]
+```
+
+```py path=a/__init__.py
+```
+
+```py path=a/b/__init__.py
+```
+
+```py path=a/b/c.py
+class C: ...
+```
+
+## Unresolvable submodule imports
+
+```py
+# Topmost component resolvable, submodule not resolvable:
+import a.foo  # error: [unresolved-import] "Cannot resolve import `a.foo`"
+
+# Topmost component unresolvable:
+import b.foo  # error: [unresolved-import] "Cannot resolve import `b.foo`"
+```
+
+```py path=a/__init__.py
+```

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

@@ -3,6 +3,6 @@
 ```py
 import builtins
 
-x = builtins.copyright
-reveal_type(x)  # revealed: Literal[copyright]
+x = builtins.chr
+reveal_type(x)  # revealed: Literal[chr]
 ```

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

@@ -3,11 +3,10 @@
 ## Maybe unbound
 
 ```py path=maybe_unbound.py
-def bool_instance() -> bool:
+def coinflip() -> bool:
     return True
 
-flag = bool_instance()
-if flag:
+if coinflip():
     y = 3
 
 x = y  # error: [possibly-unresolved-reference]
@@ -31,13 +30,12 @@ reveal_type(y)  # revealed: Literal[3]
 ## Maybe unbound annotated
 
 ```py path=maybe_unbound_annotated.py
-def bool_instance() -> bool:
+def coinflip() -> bool:
     return True
 
-flag = bool_instance()
-
-if flag:
+if coinflip():
     y: int = 3
+
 x = y  # error: [possibly-unresolved-reference]
 
 # revealed: Literal[3]
@@ -63,10 +61,10 @@ reveal_type(y)  # revealed: int
 Importing a possibly undeclared name still gives us its declared type:
 
 ```py path=maybe_undeclared.py
-def bool_instance() -> bool:
+def coinflip() -> bool:
     return True
 
-if bool_instance():
+if coinflip():
     x: int
 ```
 
@@ -83,14 +81,12 @@ def f(): ...
 ```
 
 ```py path=b.py
-def bool_instance() -> bool:
+def coinflip() -> bool:
     return True
 
-flag = bool_instance()
-if flag:
+if coinflip():
     from c import f
 else:
-
     def f(): ...
 ```
 
@@ -111,11 +107,10 @@ x: int
 ```
 
 ```py path=b.py
-def bool_instance() -> bool:
+def coinflip() -> bool:
     return True
 
-flag = bool_instance()
-if flag:
+if coinflip():
     from c import x
 else:
     x = 1

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

@@ -0,0 +1,75 @@
+# Conflicting attributes and submodules
+
+## Via import
+
+```py
+import a.b
+
+reveal_type(a.b)  # revealed: <module 'a.b'>
+```
+
+```py path=a/__init__.py
+b = 42
+```
+
+```py path=a/b.py
+```
+
+## Via from/import
+
+```py
+from a import b
+
+reveal_type(b)  # revealed: Literal[42]
+```
+
+```py path=a/__init__.py
+b = 42
+```
+
+```py path=a/b.py
+```
+
+## Via both
+
+```py
+import a.b
+from a import b
+
+reveal_type(b)  # revealed: <module 'a.b'>
+reveal_type(a.b)  # revealed: <module 'a.b'>
+```
+
+```py path=a/__init__.py
+b = 42
+```
+
+```py path=a/b.py
+```
+
+## Via both (backwards)
+
+In this test, we infer a different type for `b` than the runtime behavior of the Python interpreter.
+The interpreter will not load the submodule `a.b` during the `from a import b` statement, since `a`
+contains a non-module attribute named `b`. (See the [definition][from-import] of a `from...import`
+statement for details.) However, because our import tracking is flow-insensitive, we will see that
+`a.b` is imported somewhere in the file, and therefore assume that the `from...import` statement
+sees the submodule as the value of `b` instead of the integer.
+
+```py
+from a import b
+import a.b
+
+# Python would say `Literal[42]` for `b`
+reveal_type(b)  # revealed: <module 'a.b'>
+reveal_type(a.b)  # revealed: <module 'a.b'>
+```
+
+```py path=a/__init__.py
+b = 42
+```
+
+```py path=a/b.py
+```
+
+[from-import]: https://docs.python.org/3/reference/simple_stmts.html#the-import-statement

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

@@ -55,3 +55,24 @@ from b import x
 
 x = "foo"  # error: [invalid-assignment] "Object of type `Literal["foo"]"
 ```
+
+## Import cycle
+
+```py path=a.py
+class A: ...
+
+reveal_type(A.__mro__)  # revealed: tuple[Literal[A], Literal[object]]
+import b
+
+class C(b.B): ...
+
+reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[B], Literal[A], Literal[object]]
+```
+
+```py path=b.py
+from a import A
+
+class B(A): ...
+
+reveal_type(B.__mro__)  # revealed: tuple[Literal[B], Literal[A], Literal[object]]
+```

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

@@ -0,0 +1,31 @@
+# Invalid syntax
+
+## Missing module name
+
+```py
+from import bar  # error: [invalid-syntax]
+
+reveal_type(bar)  # revealed: Unknown
+```
+
+## Invalid nested module import
+
+TODO: This is correctly flagged as an error, but we could clean up the diagnostics that we report.
+
+```py
+# TODO: No second diagnostic
+# error: [invalid-syntax] "Expected ',', found '.'"
+# error: [unresolved-import] "Module `a` has no member `c`"
+from a import b.c
+
+# TODO: Should these be inferred as Unknown?
+reveal_type(b)  # revealed: <module 'a.b'>
+reveal_type(b.c)  # revealed: Literal[1]
+```
+
+```py path=a/__init__.py
+```
+
+```py path=a/b.py
+c = 1
+```

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

@@ -121,23 +121,44 @@ X = 42
 ```
 
 ```py path=package/bar.py
-# TODO: support submodule imports
-from . import foo  # error: [unresolved-import]
+from . import foo
 
-y = foo.X
-
-# TODO: should be `Literal[42]`
-reveal_type(y)  # revealed: Unknown
+reveal_type(foo.X)  # revealed: Literal[42]
 ```
 
 ## Non-existent + bare to module
 
+This test verifies that we emit an error when we try to import a symbol that is neither a submodule
+nor an attribute of `package`.
+
 ```py path=package/__init__.py
 ```
 
 ```py path=package/bar.py
-# TODO: support submodule imports
 from . import foo  # error: [unresolved-import]
 
 reveal_type(foo)  # revealed: Unknown
 ```
+
+## Import submodule from self
+
+We don't currently consider `from...import` statements when building up the `imported_modules` set
+in the semantic index. When accessing an attribute of a module, we only consider it a potential
+submodule when that submodule name appears in the `imported_modules` set. That means that submodules
+that are imported via `from...import` are not visible to our type inference if you also access that
+submodule via the attribute on its parent package.
+
+```py path=package/__init__.py
+```
+
+```py path=package/foo.py
+X = 42
+```
+
+```py path=package/bar.py
+from . import foo
+import package
+
+# error: [unresolved-attribute] "Type `<module 'package'>` has no attribute `foo`"
+reveal_type(package.foo.X)  # revealed: Unknown
+```

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

@@ -0,0 +1,100 @@
+# Tracking imported modules
+
+These tests depend on how we track which modules have been imported. There are currently two
+characteristics of our module tracking that can lead to inaccuracies:
+
+- Imports are tracked on a per-file basis. At runtime, importing a submodule in one file makes that
+    submodule globally available via any reference to the containing package. We will flag an error
+    if a file tries to access a submodule without there being an import of that submodule _in that
+    same file_.
+
+    This is a purposeful decision, and not one we plan to change. If a module wants to re-export some
+    other module that it imports, there are ways to do that (tested below) that are blessed by the
+    typing spec and that are visible to our file-scoped import tracking.
+
+- Imports are tracked flow-insensitively: submodule accesses are allowed and resolved if that
+    submodule is imported _anywhere in the file_. This handles the common case where all imports are
+    grouped at the top of the file, and is easiest to implement. We might revisit this decision and
+    track submodule imports flow-sensitively, in which case we will have to update the assertions in
+    some of these tests.
+
+## Import submodule later in file
+
+This test highlights our flow-insensitive analysis, since we access the `a.b` submodule before it
+has been imported.
+
+```py
+import a
+
+# Would be an error with flow-sensitive tracking
+reveal_type(a.b.C)  # revealed: Literal[C]
+
+import a.b
+```
+
+```py path=a/__init__.py
+```
+
+```py path=a/b.py
+class C: ...
+```
+
+## Rename a re-export
+
+This test highlights how import tracking is local to each file, but specifically to the file where a
+containing module is first referenced. This allows the main module to see that `q.a` contains a
+submodule `b`, even though `a.b` is never imported in the main module.
+
+```py
+from q import a, b
+
+reveal_type(b)  # revealed: <module 'a.b'>
+reveal_type(b.C)  # revealed: Literal[C]
+
+reveal_type(a.b)  # revealed: <module 'a.b'>
+reveal_type(a.b.C)  # revealed: Literal[C]
+```
+
+```py path=a/__init__.py
+```
+
+```py path=a/b.py
+class C: ...
+```
+
+```py path=q.py
+import a as a
+import a.b as b
+```
+
+## Attribute overrides submodule
+
+Technically, either a submodule or a non-module attribute could shadow the other, depending on the
+ordering of when the submodule is loaded relative to the parent module's `__init__.py` file being
+evaluated. We have chosen to always have the submodule take priority. (This matches pyright's
+current behavior, and opposite of mypy's current behavior.)
+
+```py
+import sub.b
+import attr.b
+
+# In the Python interpreter, `attr.b` is Literal[1]
+reveal_type(sub.b)  # revealed: <module 'sub.b'>
+reveal_type(attr.b)  # revealed: <module 'attr.b'>
+```
+
+```py path=sub/__init__.py
+b = 1
+```
+
+```py path=sub/b.py
+```
+
+```py path=attr/__init__.py
+from . import b as _
+
+b = 1
+```
+
+```py path=attr/b.py
+```

crates/red_knot_python_semantic/resources/mdtest/invalid_syntax.md

@@ -0,0 +1,93 @@
+# Syntax errors
+
+Test cases to ensure that red knot does not panic if there are syntax errors in the source code.
+
+The parser cannot recover from certain syntax errors completely which is why the number of syntax
+errors could be more than expected in the following examples. For instance, if there's a keyword
+(like `for`) in the middle of another statement (like function definition), then it's more likely
+that the rest of the tokens are going to be part of the `for` statement and not the function
+definition. But, it's not necessary that the remaining tokens are valid in the context of a `for`
+statement.
+
+## Keyword as identifiers
+
+When keywords are used as identifiers, the parser recovers from this syntax error by emitting an
+error and including the text value of the keyword to create the `Identifier` node.
+
+### Name expression
+
+#### Assignment
+
+```py
+# error: [invalid-syntax]
+pass = 1
+```
+
+#### Type alias
+
+```py
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+type pass = 1
+```
+
+#### Function definition
+
+```py
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+def True(for):
+    # error: [invalid-syntax]
+    # error: [invalid-syntax]
+    pass
+```
+
+#### For
+
+```py
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+# error: [unresolved-reference] "Name `pass` used when not defined"
+for while in pass:
+    pass
+```
+
+#### While
+
+```py
+# error: [invalid-syntax]
+# error: [unresolved-reference] "Name `in` used when not defined"
+while in:
+    pass
+```
+
+#### Match
+
+```py
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+# error: [unresolved-reference] "Name `match` used when not defined"
+match while:
+    # error: [invalid-syntax]
+    # error: [invalid-syntax]
+    # error: [invalid-syntax]
+    # error: [unresolved-reference] "Name `case` used when not defined"
+    case in:
+        # error: [invalid-syntax]
+        # error: [invalid-syntax]
+        pass
+```
+
+### Attribute expression
+
+```py
+# TODO: Check when support for attribute expressions is added
+
+# error: [invalid-syntax]
+# error: [unresolved-reference] "Name `foo` used when not defined"
+for x in foo.pass:
+    pass
+```

crates/red_knot_python_semantic/resources/mdtest/known_constants.md

@@ -0,0 +1,52 @@
+# Known constants
+
+## `typing.TYPE_CHECKING`
+
+This constant is `True` when in type-checking mode, `False` otherwise. The symbol is defined to be
+`False` at runtime. In typeshed, it is annotated as `bool`. This test makes sure that we infer
+`Literal[True]` for it anyways.
+
+### Basic
+
+```py
+from typing import TYPE_CHECKING
+import typing
+
+reveal_type(TYPE_CHECKING)  # revealed: Literal[True]
+reveal_type(typing.TYPE_CHECKING)  # revealed: Literal[True]
+```
+
+### Aliased
+
+Make sure that we still infer the correct type if the constant has been given a different name:
+
+```py
+from typing import TYPE_CHECKING as TC
+
+reveal_type(TC)  # revealed: Literal[True]
+```
+
+### Must originate from `typing`
+
+Make sure we only use our special handling for `typing.TYPE_CHECKING` and not for other constants
+with the same name:
+
+```py path=constants.py
+TYPE_CHECKING: bool = False
+```
+
+```py
+from constants import TYPE_CHECKING
+
+reveal_type(TYPE_CHECKING)  # revealed: bool
+```
+
+### `typing_extensions` re-export
+
+This should behave in the same way as `typing.TYPE_CHECKING`:
+
+```py
+from typing_extensions import TYPE_CHECKING
+
+reveal_type(TYPE_CHECKING)  # revealed: Literal[True]
+```

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

@@ -0,0 +1,7 @@
+# Ellipsis literals
+
+## Simple
+
+```py
+reveal_type(...)  # revealed: EllipsisType | ellipsis
+```

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

@@ -18,7 +18,7 @@ async def foo():
         pass
 
     # TODO: should reveal `Unknown` because `__aiter__` is not defined
-    # revealed: @Todo
+    # revealed: @Todo(async iterables/iterators)
     # error: [possibly-unresolved-reference]
     reveal_type(x)
 ```
@@ -40,6 +40,6 @@ async def foo():
         pass
 
     # error: [possibly-unresolved-reference]
-    # revealed: @Todo
+    # revealed: @Todo(async iterables/iterators)
     reveal_type(x)
 ```

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

@@ -106,23 +106,19 @@ reveal_type(x)
 ## With non-callable iterator
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    class NotIterable:
+        if flag:
+            __iter__ = 1
+        else:
+            __iter__ = None
 
-flag = bool_instance()
+    for x in NotIterable():  # error: "Object of type `NotIterable` is not iterable"
+        pass
 
-class NotIterable:
-    if flag:
-        __iter__ = 1
-    else:
-        __iter__ = None
-
-for x in NotIterable():  # error: "Object of type `NotIterable` is not iterable"
-    pass
-
-# revealed: Unknown
-# error: [possibly-unresolved-reference]
-reveal_type(x)
+    # revealed: Unknown
+    # error: [possibly-unresolved-reference]
+    reveal_type(x)
 ```
 
 ## Invalid iterable
@@ -160,13 +156,9 @@ class Test2:
     def __iter__(self) -> TestIter:
         return TestIter()
 
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-for x in Test() if flag else Test2():
-    reveal_type(x)  # revealed: int
+def _(flag: bool):
+    for x in Test() if flag else Test2():
+        reveal_type(x)  # revealed: int
 ```
 
 ## Union type as iterator
@@ -215,13 +207,9 @@ class Test2:
     def __iter__(self) -> TestIter3 | TestIter4:
         return TestIter3()
 
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-for x in Test() if flag else Test2():
-    reveal_type(x)  # revealed: int | Exception | str | tuple[int, int] | bytes | memoryview
+def _(flag: bool):
+    for x in Test() if flag else Test2():
+        reveal_type(x)  # revealed: int | Exception | str | tuple[int, int] | bytes | memoryview
 ```
 
 ## Union type as iterable where one union element has no `__iter__` method
@@ -235,12 +223,10 @@ class Test:
     def __iter__(self) -> TestIter:
         return TestIter()
 
-def coinflip() -> bool:
-    return True
-
-# error: [not-iterable] "Object of type `Test | Literal[42]` is not iterable because its `__iter__` method is possibly unbound"
-for x in Test() if coinflip() else 42:
-    reveal_type(x)  # revealed: int
+def _(flag: bool):
+    # error: [not-iterable] "Object of type `Test | Literal[42]` is not iterable because its `__iter__` method is possibly unbound"
+    for x in Test() if flag else 42:
+        reveal_type(x)  # revealed: int
 ```
 
 ## Union type as iterable where one union element has invalid `__iter__` method
@@ -258,12 +244,10 @@ class Test2:
     def __iter__(self) -> int:
         return 42
 
-def coinflip() -> bool:
-    return True
-
-# error: "Object of type `Test | Test2` is not iterable"
-for x in Test() if coinflip() else Test2():
-    reveal_type(x)  # revealed: Unknown
+def _(flag: bool):
+    # error: "Object of type `Test | Test2` is not iterable"
+    for x in Test() if flag else Test2():
+        reveal_type(x)  # revealed: Unknown
 ```
 
 ## Union type as iterator where one union element has no `__next__` method

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

@@ -1,54 +1,118 @@
 # While loops
 
-## Basic While Loop
+## Basic `while` loop
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = 1
+    while flag:
+        x = 2
 
-flag = bool_instance()
-x = 1
-while flag:
-    x = 2
-
-reveal_type(x)  # revealed: Literal[1, 2]
-```
-
-## While with else (no break)
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-x = 1
-while flag:
-    x = 2
-else:
     reveal_type(x)  # revealed: Literal[1, 2]
-    x = 3
-
-reveal_type(x)  # revealed: Literal[3]
 ```
 
-## While with Else (may break)
+## `while` with `else` (no `break`)
 
 ```py
-def bool_instance() -> bool:
+def _(flag: bool):
+    x = 1
+    while flag:
+        x = 2
+    else:
+        reveal_type(x)  # revealed: Literal[1, 2]
+        x = 3
+
+    reveal_type(x)  # revealed: Literal[3]
+```
+
+## `while` with `else` (may `break`)
+
+```py
+def _(flag: bool, flag2: bool):
+    x = 1
+    y = 0
+    while flag:
+        x = 2
+        if flag2:
+            y = 4
+            break
+    else:
+        y = x
+        x = 3
+
+    reveal_type(x)  # revealed: Literal[2, 3]
+    reveal_type(y)  # revealed: Literal[1, 2, 4]
+```
+
+## Nested `while` loops
+
+```py
+def flag() -> bool:
     return True
 
-flag, flag2 = bool_instance(), bool_instance()
 x = 1
-y = 0
-while flag:
+
+while flag():
     x = 2
-    if flag2:
-        y = 4
+
+    while flag():
+        x = 3
+        if flag():
+            break
+    else:
+        x = 4
+
+    if flag():
         break
 else:
-    y = x
-    x = 3
+    x = 5
 
-reveal_type(x)  # revealed: Literal[2, 3]
-reveal_type(y)  # revealed: Literal[1, 2, 4]
+reveal_type(x)  # revealed: Literal[3, 4, 5]
+```
+
+## Boundness
+
+Make sure that the boundness information is correctly tracked in `while` loop control flow.
+
+### Basic `while` loop
+
+```py
+def _(flag: bool):
+    while flag:
+        x = 1
+
+    # error: [possibly-unresolved-reference]
+    x
+```
+
+### `while` with `else` (no `break`)
+
+```py
+def _(flag: bool):
+    while flag:
+        y = 1
+    else:
+        x = 1
+
+    # no error, `x` is always bound
+    x
+    # error: [possibly-unresolved-reference]
+    y
+```
+
+### `while` with `else` (may `break`)
+
+```py
+def _(flag: bool, flag2: bool):
+    while flag:
+        x = 1
+        if flag2:
+            break
+    else:
+        y = 1
+
+    # error: [possibly-unresolved-reference]
+    x
+    # error: [possibly-unresolved-reference]
+    y
 ```

crates/red_knot_python_semantic/resources/mdtest/mdtest_config.md

@@ -0,0 +1,67 @@
+This test makes sure that `red_knot_test` correctly parses the TOML configuration blocks and applies
+the correct settings hierarchically.
+
+The following configuration will be attached to the *root* section (without any heading):
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+# Basic
+
+Here, we simply make sure that we pick up the global configuration from the root section:
+
+```py
+reveal_type(sys.version_info[:2] == (3, 10))  # revealed: Literal[True]
+```
+
+# Inheritance
+
+## Child
+
+### Grandchild
+
+The same should work for arbitrarily nested sections:
+
+```py
+reveal_type(sys.version_info[:2] == (3, 10))  # revealed: Literal[True]
+```
+
+# Overwriting
+
+Here, we make sure that we can overwrite the global configuration in a child section:
+
+```toml
+[environment]
+python-version = "3.11"
+```
+
+```py
+reveal_type(sys.version_info[:2] == (3, 11))  # revealed: Literal[True]
+```
+
+# No global state
+
+There is no global state. This section should again use the root configuration:
+
+```py
+reveal_type(sys.version_info[:2] == (3, 10))  # revealed: Literal[True]
+```
+
+# Overwriting affects children
+
+Children in this section should all use the section configuration:
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+## Child
+
+### Grandchild
+
+```py
+reveal_type(sys.version_info[:2] == (3, 12))  # revealed: Literal[True]
+```

crates/red_knot_python_semantic/resources/mdtest/metaclass.md

@@ -68,7 +68,7 @@ class B(metaclass=M2): ...
 # error: [conflicting-metaclass] "The metaclass of a derived class (`C`) must be a subclass of the metaclasses of all its bases, but `M1` (metaclass of base class `A`) and `M2` (metaclass of base class `B`) have no subclass relationship"
 class C(A, B): ...
 
-reveal_type(C.__class__)  # revealed: Unknown
+reveal_type(C.__class__)  # revealed: type[Unknown]
 ```
 
 ## Conflict (2)
@@ -85,7 +85,7 @@ class A(metaclass=M1): ...
 # error: [conflicting-metaclass] "The metaclass of a derived class (`B`) must be a subclass of the metaclasses of all its bases, but `M2` (metaclass of `B`) and `M1` (metaclass of base class `A`) have no subclass relationship"
 class B(A, metaclass=M2): ...
 
-reveal_type(B.__class__)  # revealed: Unknown
+reveal_type(B.__class__)  # revealed: type[Unknown]
 ```
 
 ## Common metaclass
@@ -129,7 +129,7 @@ class C(metaclass=M12): ...
 # error: [conflicting-metaclass] "The metaclass of a derived class (`D`) must be a subclass of the metaclasses of all its bases, but `M1` (metaclass of base class `A`) and `M2` (metaclass of base class `B`) have no subclass relationship"
 class D(A, B, C): ...
 
-reveal_type(D.__class__)  # revealed: Unknown
+reveal_type(D.__class__)  # revealed: type[Unknown]
 ```
 
 ## Unknown
@@ -171,7 +171,7 @@ def f(*args, **kwargs) -> int: ...
 class A(metaclass=f): ...
 
 # TODO should be `type[int]`
-reveal_type(A.__class__)  # revealed: @Todo
+reveal_type(A.__class__)  # revealed: @Todo(metaclass not a class)
 ```
 
 ## Cyclic
@@ -179,11 +179,11 @@ reveal_type(A.__class__)  # revealed: @Todo
 Retrieving the metaclass of a cyclically defined class should not cause an infinite loop.
 
 ```py path=a.pyi
-class A(B): ...  # error: [cyclic-class-def]
-class B(C): ...  # error: [cyclic-class-def]
-class C(A): ...  # error: [cyclic-class-def]
+class A(B): ...  # error: [cyclic-class-definition]
+class B(C): ...  # error: [cyclic-class-definition]
+class C(A): ...  # error: [cyclic-class-definition]
 
-reveal_type(A.__class__)  # revealed: Unknown
+reveal_type(A.__class__)  # revealed: type[Unknown]
 ```
 
 ## PEP 695 generic
@@ -194,3 +194,26 @@ class A[T: str](metaclass=M): ...
 
 reveal_type(A.__class__)  # revealed: Literal[M]
 ```
+
+## Metaclasses of metaclasses
+
+```py
+class Foo(type): ...
+class Bar(type, metaclass=Foo): ...
+class Baz(type, metaclass=Bar): ...
+class Spam(metaclass=Baz): ...
+
+reveal_type(Spam.__class__)  # revealed: Literal[Baz]
+reveal_type(Spam.__class__.__class__)  # revealed: Literal[Bar]
+reveal_type(Spam.__class__.__class__.__class__)  # revealed: Literal[Foo]
+
+def test(x: Spam):
+    reveal_type(x.__class__)  # revealed: type[Spam]
+    reveal_type(x.__class__.__class__)  # revealed: type[Baz]
+    reveal_type(x.__class__.__class__.__class__)  # revealed: type[Bar]
+    reveal_type(x.__class__.__class__.__class__.__class__)  # revealed: type[Foo]
+    reveal_type(x.__class__.__class__.__class__.__class__.__class__)  # revealed: type[type]
+
+    # revealed: type[type]
+    reveal_type(x.__class__.__class__.__class__.__class__.__class__.__class__.__class__.__class__)
+```

crates/red_knot_python_semantic/resources/mdtest/mro.md

@@ -256,7 +256,7 @@ class O: ...
 class X(O): ...
 class Y(O): ...
 
-if bool():
+if returns_bool():
     foo = Y
 else:
     foo = object
@@ -348,14 +348,14 @@ reveal_type(unknown_object.__mro__)  # revealed: Unknown
 These are invalid, but we need to be able to handle them gracefully without panicking.
 
 ```py path=a.pyi
-class Foo(Foo): ...  # error: [cyclic-class-def]
+class Foo(Foo): ...  # error: [cyclic-class-definition]
 
 reveal_type(Foo)  # revealed: Literal[Foo]
 reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
 
 class Bar: ...
 class Baz: ...
-class Boz(Bar, Baz, Boz): ...  # error: [cyclic-class-def]
+class Boz(Bar, Baz, Boz): ...  # error: [cyclic-class-definition]
 
 reveal_type(Boz)  # revealed: Literal[Boz]
 reveal_type(Boz.__mro__)  # revealed: tuple[Literal[Boz], Unknown, Literal[object]]
@@ -366,9 +366,9 @@ reveal_type(Boz.__mro__)  # revealed: tuple[Literal[Boz], Unknown, Literal[objec
 These are similarly unlikely, but we still shouldn't crash:
 
 ```py path=a.pyi
-class Foo(Bar): ...  # error: [cyclic-class-def]
-class Bar(Baz): ...  # error: [cyclic-class-def]
-class Baz(Foo): ...  # error: [cyclic-class-def]
+class Foo(Bar): ...  # error: [cyclic-class-definition]
+class Bar(Baz): ...  # error: [cyclic-class-definition]
+class Baz(Foo): ...  # error: [cyclic-class-definition]
 
 reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
 reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Unknown, Literal[object]]
@@ -379,9 +379,9 @@ reveal_type(Baz.__mro__)  # revealed: tuple[Literal[Baz], Unknown, Literal[objec
 
 ```py path=a.pyi
 class Spam: ...
-class Foo(Bar): ...  # error: [cyclic-class-def]
-class Bar(Baz): ...  # error: [cyclic-class-def]
-class Baz(Foo, Spam): ...  # error: [cyclic-class-def]
+class Foo(Bar): ...  # error: [cyclic-class-definition]
+class Bar(Baz): ...  # error: [cyclic-class-definition]
+class Baz(Foo, Spam): ...  # error: [cyclic-class-definition]
 
 reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
 reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Unknown, Literal[object]]
@@ -391,16 +391,16 @@ reveal_type(Baz.__mro__)  # revealed: tuple[Literal[Baz], Unknown, Literal[objec
 ## Classes with cycles in their MRO, and a sub-graph
 
 ```py path=a.pyi
-class FooCycle(BarCycle): ...  # error: [cyclic-class-def]
+class FooCycle(BarCycle): ...  # error: [cyclic-class-definition]
 class Foo: ...
-class BarCycle(FooCycle): ...  # error: [cyclic-class-def]
+class BarCycle(FooCycle): ...  # error: [cyclic-class-definition]
 class Bar(Foo): ...
 
 # TODO: can we avoid emitting the errors for these?
 # The classes have cyclic superclasses,
 # but are not themselves cyclic...
-class Baz(Bar, BarCycle): ...  # error: [cyclic-class-def]
-class Spam(Baz): ...  # error: [cyclic-class-def]
+class Baz(Bar, BarCycle): ...  # error: [cyclic-class-definition]
+class Spam(Baz): ...  # error: [cyclic-class-definition]
 
 reveal_type(FooCycle.__mro__)  # revealed: tuple[Literal[FooCycle], Unknown, Literal[object]]
 reveal_type(BarCycle.__mro__)  # revealed: tuple[Literal[BarCycle], Unknown, Literal[object]]

crates/red_knot_python_semantic/resources/mdtest/narrow/bool-call.md

@@ -0,0 +1,32 @@
+## Narrowing for `bool(..)` checks
+
+```py
+def _(flag: bool):
+
+    x = 1 if flag else None
+
+    # valid invocation, positive
+    reveal_type(x)  # revealed: Literal[1] | None
+    if bool(x is not None):
+        reveal_type(x)  # revealed: Literal[1]
+
+    # valid invocation, negative
+    reveal_type(x)  # revealed: Literal[1] | None
+    if not bool(x is not None):
+        reveal_type(x)  # revealed: None
+
+    # no args/narrowing
+    reveal_type(x)  # revealed: Literal[1] | None
+    if not bool():
+        reveal_type(x)  # revealed: Literal[1] | None
+
+    # invalid invocation, too many positional args
+    reveal_type(x)  # revealed: Literal[1] | None
+    if bool(x is not None, 5):  # TODO diagnostic
+        reveal_type(x)  # revealed: Literal[1] | None
+
+    # invalid invocation, too many kwargs
+    reveal_type(x)  # revealed: Literal[1] | None
+    if bool(x is not None, y=5):  # TODO diagnostic
+        reveal_type(x)  # revealed: Literal[1] | None
+```

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

@@ -9,85 +9,67 @@ Similarly, in `and` expressions, the right-hand side is evaluated only if the le
 ## Narrowing in `or`
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    class A: ...
+    x: A | None = A() if flag else None
 
-class A: ...
-
-x: A | None = A() if bool_instance() else None
-
-isinstance(x, A) or reveal_type(x)  # revealed: None
-x is None or reveal_type(x)  # revealed: A
-reveal_type(x)  # revealed: A | None
+    isinstance(x, A) or reveal_type(x)  # revealed: None
+    x is None or reveal_type(x)  # revealed: A
+    reveal_type(x)  # revealed: A | None
 ```
 
 ## Narrowing in `and`
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    class A: ...
+    x: A | None = A() if flag else None
 
-class A: ...
-
-x: A | None = A() if bool_instance() else None
-
-isinstance(x, A) and reveal_type(x)  # revealed: A
-x is None and reveal_type(x)  # revealed: None
-reveal_type(x)  # revealed: A | None
+    isinstance(x, A) and reveal_type(x)  # revealed: A
+    x is None and reveal_type(x)  # revealed: None
+    reveal_type(x)  # revealed: A | None
 ```
 
 ## Multiple `and` arms
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool, flag3: bool, flag4: bool):
+    class A: ...
+    x: A | None = A() if flag1 else None
 
-class A: ...
-
-x: A | None = A() if bool_instance() else None
-
-bool_instance() and isinstance(x, A) and reveal_type(x)  # revealed: A
-isinstance(x, A) and bool_instance() and reveal_type(x)  # revealed: A
-reveal_type(x) and isinstance(x, A) and bool_instance()  # revealed: A | None
+    flag2 and isinstance(x, A) and reveal_type(x)  # revealed: A
+    isinstance(x, A) and flag2 and reveal_type(x)  # revealed: A
+    reveal_type(x) and isinstance(x, A) and flag3  # revealed: A | None
 ```
 
 ## Multiple `or` arms
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool, flag3: bool, flag4: bool):
+    class A: ...
+    x: A | None = A() if flag1 else None
 
-class A: ...
-
-x: A | None = A() if bool_instance() else None
-
-bool_instance() or isinstance(x, A) or reveal_type(x)  # revealed: None
-isinstance(x, A) or bool_instance() or reveal_type(x)  # revealed: None
-reveal_type(x) or isinstance(x, A) or bool_instance()  # revealed: A | None
+    flag2 or isinstance(x, A) or reveal_type(x)  # revealed: None
+    isinstance(x, A) or flag3 or reveal_type(x)  # revealed: None
+    reveal_type(x) or isinstance(x, A) or flag4  # revealed: A | None
 ```
 
 ## Multiple predicates
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool):
+    class A: ...
+    x: A | None | Literal[1] = A() if flag1 else None if flag2 else 1
 
-class A: ...
-
-x: A | None | Literal[1] = A() if bool_instance() else None if bool_instance() else 1
-
-x is None or isinstance(x, A) or reveal_type(x)  # revealed: Literal[1]
+    x is None or isinstance(x, A) or reveal_type(x)  # revealed: Literal[1]
 ```
 
 ## Mix of `and` and `or`
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool):
+    class A: ...
+    x: A | None | Literal[1] = A() if flag1 else None if flag2 else 1
 
-class A: ...
-
-x: A | None | Literal[1] = A() if bool_instance() else None if bool_instance() else 1
-
-isinstance(x, A) or x is not None and reveal_type(x)  # revealed: Literal[1]
+    isinstance(x, A) or x is not None and reveal_type(x)  # revealed: Literal[1]
 ```

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

@@ -6,15 +6,11 @@
 class A: ...
 class B: ...
 
-def instance() -> A | B:
-    return A()
-
-x = instance()
-
-if isinstance(x, A) and isinstance(x, B):
-    reveal_type(x)  # revealed:  A & B
-else:
-    reveal_type(x)  # revealed:  B & ~A | A & ~B
+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
 ```
 
 ## Arms might not add narrowing constraints
@@ -23,25 +19,18 @@ else:
 class A: ...
 class B: ...
 
-def bool_instance() -> bool:
-    return True
+def _(flag: bool, x: A | B):
+    if isinstance(x, A) and flag:
+        reveal_type(x)  # revealed: A
+    else:
+        reveal_type(x)  # revealed: A | B
 
-def instance() -> A | B:
-    return A()
+    if flag and isinstance(x, A):
+        reveal_type(x)  # revealed: A
+    else:
+        reveal_type(x)  # revealed: A | B
 
-x = instance()
-
-if isinstance(x, A) and bool_instance():
-    reveal_type(x)  # revealed: A
-else:
     reveal_type(x)  # revealed: A | B
-
-if bool_instance() and isinstance(x, A):
-    reveal_type(x)  # revealed: A
-else:
-    reveal_type(x)  # revealed: A | B
-
-reveal_type(x)  # revealed: A | B
 ```
 
 ## Statically known arms
@@ -50,39 +39,35 @@ reveal_type(x)  # revealed: A | B
 class A: ...
 class B: ...
 
-def instance() -> A | B:
-    return A()
+def _(x: A | B):
+    if isinstance(x, A) and True:
+        reveal_type(x)  # revealed: A
+    else:
+        reveal_type(x)  # revealed: B & ~A
 
-x = instance()
+    if True and isinstance(x, A):
+        reveal_type(x)  # revealed: A
+    else:
+        reveal_type(x)  # revealed: B & ~A
 
-if isinstance(x, A) and True:
-    reveal_type(x)  # revealed: A
-else:
-    reveal_type(x)  # revealed: B & ~A
+    if False and isinstance(x, A):
+        # TODO: should emit an `unreachable code` diagnostic
+        reveal_type(x)  # revealed: A
+    else:
+        reveal_type(x)  # revealed: A | B
 
-if True and isinstance(x, A):
-    reveal_type(x)  # revealed: A
-else:
-    reveal_type(x)  # revealed: B & ~A
+    if False or isinstance(x, A):
+        reveal_type(x)  # revealed: A
+    else:
+        reveal_type(x)  # revealed: B & ~A
+
+    if True or isinstance(x, A):
+        reveal_type(x)  # revealed: A | B
+    else:
+        # TODO: should emit an `unreachable code` diagnostic
+        reveal_type(x)  # revealed: B & ~A
 
-if False and isinstance(x, A):
-    # TODO: should emit an `unreachable code` diagnostic
-    reveal_type(x)  # revealed: A
-else:
     reveal_type(x)  # revealed: A | B
-
-if False or isinstance(x, A):
-    reveal_type(x)  # revealed: A
-else:
-    reveal_type(x)  # revealed: B & ~A
-
-if True or isinstance(x, A):
-    reveal_type(x)  # revealed: A | B
-else:
-    # TODO: should emit an `unreachable code` diagnostic
-    reveal_type(x)  # revealed: B & ~A
-
-reveal_type(x)  # revealed: A | B
 ```
 
 ## The type of multiple symbols can be narrowed down
@@ -91,22 +76,17 @@ reveal_type(x)  # revealed: A | B
 class A: ...
 class B: ...
 
-def instance() -> A | B:
-    return A()
+def _(x: A | B, y: A | B):
+    if isinstance(x, A) and isinstance(y, B):
+        reveal_type(x)  # revealed: A
+        reveal_type(y)  # revealed: B
+    else:
+        # No narrowing: Only-one or both checks might have failed
+        reveal_type(x)  # revealed: A | B
+        reveal_type(y)  # revealed: A | B
 
-x = instance()
-y = instance()
-
-if isinstance(x, A) and isinstance(y, B):
-    reveal_type(x)  # revealed: A
-    reveal_type(y)  # revealed: B
-else:
-    # No narrowing: Only-one or both checks might have failed
     reveal_type(x)  # revealed: A | B
     reveal_type(y)  # revealed: A | B
-
-reveal_type(x)  # revealed: A | B
-reveal_type(y)  # revealed: A | B
 ```
 
 ## Narrowing in `or` conditional
@@ -116,15 +96,11 @@ class A: ...
 class B: ...
 class C: ...
 
-def instance() -> A | B | C:
-    return A()
-
-x = instance()
-
-if isinstance(x, A) or isinstance(x, B):
-    reveal_type(x)  # revealed:  A | B
-else:
-    reveal_type(x)  # revealed:  C & ~A & ~B
+def _(x: A | B | C):
+    if isinstance(x, A) or isinstance(x, B):
+        reveal_type(x)  # revealed:  A | B
+    else:
+        reveal_type(x)  # revealed:  C & ~A & ~B
 ```
 
 ## In `or`, all arms should add constraint in order to narrow
@@ -134,18 +110,11 @@ class A: ...
 class B: ...
 class C: ...
 
-def instance() -> A | B | C:
-    return A()
-
-def bool_instance() -> bool:
-    return True
-
-x = instance()
-
-if isinstance(x, A) or isinstance(x, B) or bool_instance():
-    reveal_type(x)  # revealed:  A | B | C
-else:
-    reveal_type(x)  # revealed:  C & ~A & ~B
+def _(flag: bool, x: A | B | C):
+    if isinstance(x, A) or isinstance(x, B) or flag:
+        reveal_type(x)  # revealed:  A | B | C
+    else:
+        reveal_type(x)  # revealed:  C & ~A & ~B
 ```
 
 ## in `or`, all arms should narrow the same set of symbols
@@ -155,28 +124,23 @@ class A: ...
 class B: ...
 class C: ...
 
-def instance() -> A | B | C:
-    return A()
+def _(x: A | B | C, y: A | B | C):
+    if isinstance(x, A) or isinstance(y, A):
+        # The predicate might be satisfied by the right side, so the type of `x` can’t be narrowed down here.
+        reveal_type(x)  # revealed:  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
 
-x = instance()
-y = instance()
-
-if isinstance(x, A) or isinstance(y, A):
-    # The predicate might be satisfied by the right side, so the type of `x` can’t be narrowed down here.
-    reveal_type(x)  # revealed:  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
-
-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.
-    reveal_type(x)  # revealed:  A | B
-    reveal_type(y)  # revealed:  A | B
-else:
-    reveal_type(x)  # revealed:  A | B | C
-    reveal_type(y)  # revealed:  A | B | C
+    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.
+        reveal_type(x)  # revealed:  A | B
+        reveal_type(y)  # revealed:  A | B
+    else:
+        reveal_type(x)  # revealed:  A | B | C
+        reveal_type(y)  # revealed:  A | B | C
 ```
 
 ## mixing `and` and `not`
@@ -186,16 +150,12 @@ class A: ...
 class B: ...
 class C: ...
 
-def instance() -> A | B | C:
-    return A()
-
-x = instance()
-
-if isinstance(x, B) and not isinstance(x, 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
+def _(x: A | B | C):
+    if isinstance(x, B) and not isinstance(x, 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
 ```
 
 ## mixing `or` and `not`
@@ -205,15 +165,11 @@ class A: ...
 class B: ...
 class C: ...
 
-def instance() -> A | B | C:
-    return A()
-
-x = instance()
-
-if isinstance(x, B) or not isinstance(x, C):
-    reveal_type(x)  # revealed: B | A & ~C
-else:
-    reveal_type(x)  # revealed: C & ~B
+def _(x: A | B | C):
+    if isinstance(x, B) or not isinstance(x, C):
+        reveal_type(x)  # revealed: B | A & ~C
+    else:
+        reveal_type(x)  # revealed: C & ~B
 ```
 
 ## `or` with nested `and`
@@ -223,16 +179,12 @@ class A: ...
 class B: ...
 class C: ...
 
-def instance() -> A | B | C:
-    return A()
-
-x = instance()
-
-if isinstance(x, A) or (isinstance(x, B) and not isinstance(x, 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
+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
+    else:
+        # ~(A | (B & ~C)) -> ~A & ~(B & ~C) -> ~A & (~B | C) -> (~A & C) | (~A ~ B)
+        reveal_type(x)  # revealed:  C & ~A
 ```
 
 ## `and` with nested `or`
@@ -242,41 +194,32 @@ class A: ...
 class B: ...
 class C: ...
 
-def instance() -> A | B | C:
-    return A()
-
-x = instance()
-
-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
-else:
-    # ~((A & B) | (A & ~C)) ->
-    # ~(A & B) & ~(A & ~C) ->
-    # (~A | ~B) & (~A | C) ->
-    # [(~A | ~B) & ~A] | [(~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
+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
+    else:
+        # ~((A & B) | (A & ~C)) ->
+        # ~(A & B) & ~(A & ~C) ->
+        # (~A | ~B) & (~A | C) ->
+        # [(~A | ~B) & ~A] | [(~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
 ```
 
 ## Boolean expression internal narrowing
 
 ```py
-def optional_string() -> str | None:
-    return None
+def _(x: str | None, y: str | None):
+    if x is None and y is not x:
+        reveal_type(y)  # revealed: str
 
-x = optional_string()
-y = optional_string()
+    # Neither of the conditions alone is sufficient for narrowing y's type:
+    if x is None:
+        reveal_type(y)  # revealed: str | None
 
-if x is None and y is not x:
-    reveal_type(y)  # revealed: str
-
-# Neither of the conditions alone is sufficient for narrowing y's type:
-if x is None:
-    reveal_type(y)  # revealed: str | None
-
-if y is not x:
-    reveal_type(y)  # revealed: str | None
+    if y is not x:
+        reveal_type(y)  # revealed: str | None
 ```

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

@@ -3,55 +3,47 @@
 ## Positive contributions become negative in elif-else blocks
 
 ```py
-def int_instance() -> int:
-    return 42
-
-x = int_instance()
-
-if x == 1:
-    # cannot narrow; could be a subclass of `int`
-    reveal_type(x)  # revealed: int
-elif x == 2:
-    reveal_type(x)  # revealed: int & ~Literal[1]
-elif x != 3:
-    reveal_type(x)  # revealed: int & ~Literal[1] & ~Literal[2] & ~Literal[3]
+def _(x: int):
+    if x == 1:
+        # cannot narrow; could be a subclass of `int`
+        reveal_type(x)  # revealed: int
+    elif x == 2:
+        reveal_type(x)  # revealed: int & ~Literal[1]
+    elif x != 3:
+        reveal_type(x)  # revealed: int & ~Literal[1] & ~Literal[2] & ~Literal[3]
 ```
 
 ## Positive contributions become negative in elif-else blocks, with simplification
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool):
+    x = 1 if flag1 else 2 if flag2 else 3
 
-x = 1 if bool_instance() else 2 if bool_instance() else 3
-
-if x == 1:
-    # TODO should be Literal[1]
-    reveal_type(x)  # revealed: Literal[1, 2, 3]
-elif x == 2:
-    # TODO should be Literal[2]
-    reveal_type(x)  # revealed: Literal[2, 3]
-else:
-    reveal_type(x)  # revealed: Literal[3]
+    if x == 1:
+        # TODO should be Literal[1]
+        reveal_type(x)  # revealed: Literal[1, 2, 3]
+    elif x == 2:
+        # TODO should be Literal[2]
+        reveal_type(x)  # revealed: Literal[2, 3]
+    else:
+        reveal_type(x)  # revealed: Literal[3]
 ```
 
 ## Multiple negative contributions using elif, with simplification
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool):
+    x = 1 if flag1 else 2 if flag2 else 3
 
-x = 1 if bool_instance() else 2 if bool_instance() else 3
-
-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]
-elif x == 3:
-    # TODO should be Never
-    reveal_type(x)  # revealed: Literal[1, 2, 3]
-else:
-    # TODO should be Never
-    reveal_type(x)  # revealed: Literal[1, 2]
+    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]
+    elif x == 3:
+        # TODO should be Never
+        reveal_type(x)  # revealed: Literal[1, 2, 3]
+    else:
+        # TODO should be Never
+        reveal_type(x)  # revealed: Literal[1, 2]
 ```

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

@@ -3,77 +3,64 @@
 ## `is None`
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = None if flag else 1
 
-flag = bool_instance()
-x = None if flag else 1
+    if x is None:
+        reveal_type(x)  # revealed: None
+    else:
+        reveal_type(x)  # revealed: Literal[1]
 
-if x is None:
-    reveal_type(x)  # revealed: None
-else:
-    reveal_type(x)  # revealed: Literal[1]
-
-reveal_type(x)  # revealed: None | Literal[1]
+    reveal_type(x)  # revealed: None | Literal[1]
 ```
 
 ## `is` for other types
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    class A: ...
+    x = A()
+    y = x if flag else None
 
-flag = bool_instance()
+    if y is x:
+        reveal_type(y)  # revealed: A
+    else:
+        reveal_type(y)  # revealed: A | None
 
-class A: ...
-
-x = A()
-y = x if flag else None
-
-if y is x:
-    reveal_type(y)  # revealed: A
-else:
     reveal_type(y)  # revealed: A | None
-
-reveal_type(y)  # revealed: A | None
 ```
 
 ## `is` in chained comparisons
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(x_flag: bool, y_flag: bool):
+    x = True if x_flag else False
+    y = True if y_flag else False
 
-x_flag, y_flag = bool_instance(), bool_instance()
-x = True if x_flag else False
-y = True if y_flag else False
-
-reveal_type(x)  # revealed: bool
-reveal_type(y)  # revealed: bool
-
-if y is x is False:  # Interpreted as `(y is x) and (x is False)`
-    reveal_type(x)  # revealed: Literal[False]
-    reveal_type(y)  # revealed: bool
-else:
-    # The negation of the clause above is (y is not x) or (x is not False)
-    # So we can't narrow the type of x or y here, because each arm of the `or` could be true
     reveal_type(x)  # revealed: bool
     reveal_type(y)  # revealed: bool
+
+    if y is x is False:  # Interpreted as `(y is x) and (x is False)`
+        reveal_type(x)  # revealed: Literal[False]
+        reveal_type(y)  # revealed: bool
+    else:
+        # The negation of the clause above is (y is not x) or (x is not False)
+        # So we can't narrow the type of x or y here, because each arm of the `or` could be true
+        reveal_type(x)  # revealed: bool
+        reveal_type(y)  # revealed: bool
 ```
 
 ## `is` in elif clause
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool):
+    x = None if flag1 else (1 if flag2 else True)
 
-x = None if bool_instance() else (1 if bool_instance() else True)
-
-reveal_type(x)  # revealed: None | Literal[1] | Literal[True]
-if x is None:
-    reveal_type(x)  # revealed: None
-elif x is True:
-    reveal_type(x)  # revealed: Literal[True]
-else:
-    reveal_type(x)  # revealed: Literal[1]
+    reveal_type(x)  # revealed: None | Literal[1] | Literal[True]
+    if x is None:
+        reveal_type(x)  # revealed: None
+    elif x is True:
+        reveal_type(x)  # revealed: Literal[True]
+    else:
+        reveal_type(x)  # revealed: Literal[1]
 ```

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

@@ -5,34 +5,28 @@
 The type guard removes `None` from the union type:
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = None if flag else 1
 
-flag = bool_instance()
-x = None if flag else 1
+    if x is not None:
+        reveal_type(x)  # revealed: Literal[1]
+    else:
+        reveal_type(x)  # revealed: None
 
-if x is not None:
-    reveal_type(x)  # revealed: Literal[1]
-else:
-    reveal_type(x)  # revealed: None
-
-reveal_type(x)  # revealed: None | Literal[1]
+    reveal_type(x)  # revealed: None | Literal[1]
 ```
 
 ## `is not` for other singleton types
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = True if flag else False
+    reveal_type(x)  # revealed: bool
 
-flag = bool_instance()
-x = True if flag else False
-reveal_type(x)  # revealed: bool
-
-if x is not False:
-    reveal_type(x)  # revealed: Literal[True]
-else:
-    reveal_type(x)  # revealed: Literal[False]
+    if x is not False:
+        reveal_type(x)  # revealed: Literal[True]
+    else:
+        reveal_type(x)  # revealed: Literal[False]
 ```
 
 ## `is not` for non-singleton types
@@ -53,20 +47,17 @@ else:
 ## `is not` for other types
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    class A: ...
+    x = A()
+    y = x if flag else None
 
-class A: ...
+    if y is not x:
+        reveal_type(y)  # revealed: A | None
+    else:
+        reveal_type(y)  # revealed: A
 
-x = A()
-y = x if bool_instance() else None
-
-if y is not x:
     reveal_type(y)  # revealed: A | None
-else:
-    reveal_type(y)  # revealed: A
-
-reveal_type(y)  # revealed: A | None
 ```
 
 ## `is not` in chained comparisons
@@ -74,23 +65,20 @@ reveal_type(y)  # revealed: A | None
 The type guard removes `False` from the union type of the tested value only.
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-x_flag, y_flag = bool_instance(), bool_instance()
-x = True if x_flag else False
-y = True if y_flag else False
-
-reveal_type(x)  # revealed: bool
-reveal_type(y)  # revealed: bool
-
-if y is not x is not False:  # Interpreted as `(y is not x) and (x is not False)`
-    reveal_type(x)  # revealed: Literal[True]
-    reveal_type(y)  # revealed: bool
-else:
-    # The negation of the clause above is (y is x) or (x is False)
-    # So we can't narrow the type of x or y here, because each arm of the `or` could be true
+def _(x_flag: bool, y_flag: bool):
+    x = True if x_flag else False
+    y = True if y_flag else False
 
     reveal_type(x)  # revealed: bool
     reveal_type(y)  # revealed: bool
+
+    if y is not x is not False:  # Interpreted as `(y is not x) and (x is not False)`
+        reveal_type(x)  # revealed: Literal[True]
+        reveal_type(y)  # revealed: bool
+    else:
+        # The negation of the clause above is (y is x) or (x is False)
+        # So we can't narrow the type of x or y here, because each arm of the `or` could be true
+
+        reveal_type(x)  # revealed: bool
+        reveal_type(y)  # revealed: bool
 ```

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

@@ -3,54 +3,45 @@
 ## Multiple negative contributions
 
 ```py
-def int_instance() -> int:
-    return 42
-
-x = int_instance()
-
-if x != 1:
-    if x != 2:
-        if x != 3:
-            reveal_type(x)  # revealed: int & ~Literal[1] & ~Literal[2] & ~Literal[3]
+def _(x: int):
+    if x != 1:
+        if x != 2:
+            if x != 3:
+                reveal_type(x)  # revealed: int & ~Literal[1] & ~Literal[2] & ~Literal[3]
 ```
 
 ## Multiple negative contributions with simplification
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool):
+    x = 1 if flag1 else 2 if flag2 else 3
 
-flag1, flag2 = bool_instance(), bool_instance()
-x = 1 if flag1 else 2 if flag2 else 3
-
-if x != 1:
-    reveal_type(x)  # revealed: Literal[2, 3]
-    if x != 2:
-        reveal_type(x)  # revealed: Literal[3]
+    if x != 1:
+        reveal_type(x)  # revealed: Literal[2, 3]
+        if x != 2:
+            reveal_type(x)  # revealed: Literal[3]
 ```
 
 ## elif-else blocks
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag1: bool, flag2: bool):
+    x = 1 if flag1 else 2 if flag2 else 3
 
-x = 1 if bool_instance() else 2 if bool_instance() else 3
-
-if x != 1:
-    reveal_type(x)  # revealed: Literal[2, 3]
-    if x == 2:
-        # TODO should be `Literal[2]`
+    if x != 1:
         reveal_type(x)  # revealed: Literal[2, 3]
-    elif x == 3:
-        reveal_type(x)  # revealed: Literal[3]
-    else:
-        reveal_type(x)  # revealed: Never
+        if x == 2:
+            # TODO should be `Literal[2]`
+            reveal_type(x)  # revealed: Literal[2, 3]
+        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]
-else:
-    # TODO should be Never
-    reveal_type(x)  # revealed: Literal[1, 2, 3]
+    elif x != 2:
+        # TODO should be Literal[1]
+        reveal_type(x)  # revealed: Literal[1, 3]
+    else:
+        # TODO should be Never
+        reveal_type(x)  # revealed: Literal[1, 2, 3]
 ```

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

@@ -5,29 +5,25 @@ The `not` operator negates a constraint.
 ## `not is None`
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = None if flag else 1
 
-x = None if bool_instance() else 1
+    if not x is None:
+        reveal_type(x)  # revealed: Literal[1]
+    else:
+        reveal_type(x)  # revealed: None
 
-if not x is None:
-    reveal_type(x)  # revealed: Literal[1]
-else:
-    reveal_type(x)  # revealed: None
-
-reveal_type(x)  # revealed: None | Literal[1]
+    reveal_type(x)  # revealed: None | Literal[1]
 ```
 
 ## `not isinstance`
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = 1 if flag else "a"
 
-x = 1 if bool_instance() else "a"
-
-if not isinstance(x, (int)):
-    reveal_type(x)  # revealed: Literal["a"]
-else:
-    reveal_type(x)  # revealed: Literal[1]
+    if not isinstance(x, (int)):
+        reveal_type(x)  # revealed: Literal["a"]
+    else:
+        reveal_type(x)  # revealed: Literal[1]
 ```

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

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

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

@@ -5,23 +5,19 @@ Narrowing for `isinstance(object, classinfo)` expressions.
 ## `classinfo` is a single type
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = 1 if flag else "a"
 
-flag = bool_instance()
-
-x = 1 if flag else "a"
-
-if isinstance(x, int):
-    reveal_type(x)  # revealed: Literal[1]
-
-if isinstance(x, str):
-    reveal_type(x)  # revealed: Literal["a"]
     if isinstance(x, int):
-        reveal_type(x)  # revealed: Never
+        reveal_type(x)  # revealed: Literal[1]
 
-if isinstance(x, (int, object)):
-    reveal_type(x)  # revealed: Literal[1] | Literal["a"]
+    if isinstance(x, str):
+        reveal_type(x)  # revealed: Literal["a"]
+        if isinstance(x, int):
+            reveal_type(x)  # revealed: Never
+
+    if isinstance(x, (int, object)):
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```
 
 ## `classinfo` is a tuple of types
@@ -30,56 +26,48 @@ Note: `isinstance(x, (int, str))` should not be confused with `isinstance(x, tup
 The former is equivalent to `isinstance(x, int | str)`:
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool, flag1: bool, flag2: bool):
+    x = 1 if flag else "a"
 
-flag, flag1, flag2 = bool_instance(), bool_instance(), bool_instance()
+    if isinstance(x, (int, str)):
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
+    else:
+        reveal_type(x)  # revealed: Never
 
-x = 1 if flag else "a"
+    if isinstance(x, (int, bytes)):
+        reveal_type(x)  # revealed: Literal[1]
 
-if isinstance(x, (int, str)):
-    reveal_type(x)  # revealed: Literal[1] | Literal["a"]
-else:
-    reveal_type(x)  # revealed: Never
+    if isinstance(x, (bytes, str)):
+        reveal_type(x)  # revealed: Literal["a"]
 
-if isinstance(x, (int, bytes)):
-    reveal_type(x)  # revealed: Literal[1]
+    # No narrowing should occur if a larger type is also
+    # one of the possibilities:
+    if isinstance(x, (int, object)):
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
+    else:
+        reveal_type(x)  # revealed: Never
 
-if isinstance(x, (bytes, str)):
-    reveal_type(x)  # revealed: Literal["a"]
+    y = 1 if flag1 else "a" if flag2 else b"b"
+    if isinstance(y, (int, str)):
+        reveal_type(y)  # revealed: Literal[1] | Literal["a"]
 
-# No narrowing should occur if a larger type is also
-# one of the possibilities:
-if isinstance(x, (int, object)):
-    reveal_type(x)  # revealed: Literal[1] | Literal["a"]
-else:
-    reveal_type(x)  # revealed: Never
+    if isinstance(y, (int, bytes)):
+        reveal_type(y)  # revealed: Literal[1] | Literal[b"b"]
 
-y = 1 if flag1 else "a" if flag2 else b"b"
-if isinstance(y, (int, str)):
-    reveal_type(y)  # revealed: Literal[1] | Literal["a"]
-
-if isinstance(y, (int, bytes)):
-    reveal_type(y)  # revealed: Literal[1] | Literal[b"b"]
-
-if isinstance(y, (str, bytes)):
-    reveal_type(y)  # revealed: Literal["a"] | Literal[b"b"]
+    if isinstance(y, (str, bytes)):
+        reveal_type(y)  # revealed: Literal["a"] | Literal[b"b"]
 ```
 
 ## `classinfo` is a nested tuple of types
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = 1 if flag else "a"
 
-flag = bool_instance()
-
-x = 1 if flag else "a"
-
-if isinstance(x, (bool, (bytes, int))):
-    reveal_type(x)  # revealed: Literal[1]
-else:
-    reveal_type(x)  # revealed: Literal["a"]
+    if isinstance(x, (bool, (bytes, int))):
+        reveal_type(x)  # revealed: Literal[1]
+    else:
+        reveal_type(x)  # revealed: Literal["a"]
 ```
 
 ## Class types
@@ -89,9 +77,7 @@ class A: ...
 class B: ...
 class C: ...
 
-def get_object() -> object: ...
-
-x = get_object()
+x = object()
 
 if isinstance(x, A):
     reveal_type(x)  # revealed: A
@@ -112,50 +98,40 @@ else:
 ## No narrowing for instances of `builtins.type`
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    t = type("t", (), {})
 
-flag = bool_instance()
+    # This isn't testing what we want it to test if we infer anything more precise here:
+    reveal_type(t)  # revealed: type
 
-t = type("t", (), {})
+    x = 1 if flag else "foo"
 
-# This isn't testing what we want it to test if we infer anything more precise here:
-reveal_type(t)  # revealed: type
-x = 1 if flag else "foo"
-
-if isinstance(x, t):
-    reveal_type(x)  # revealed: Literal[1] | Literal["foo"]
+    if isinstance(x, t):
+        reveal_type(x)  # revealed: Literal[1] | Literal["foo"]
 ```
 
 ## Do not use custom `isinstance` for narrowing
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    def isinstance(x, t):
+        return True
+    x = 1 if flag else "a"
 
-flag = bool_instance()
-
-def isinstance(x, t):
-    return True
-
-x = 1 if flag else "a"
-if isinstance(x, int):
-    reveal_type(x)  # revealed: Literal[1] | Literal["a"]
+    if isinstance(x, int):
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```
 
 ## Do support narrowing if `isinstance` is aliased
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    isinstance_alias = isinstance
 
-flag = bool_instance()
+    x = 1 if flag else "a"
 
-isinstance_alias = isinstance
-
-x = 1 if flag else "a"
-if isinstance_alias(x, int):
-    reveal_type(x)  # revealed: Literal[1]
+    if isinstance_alias(x, int):
+        reveal_type(x)  # revealed: Literal[1]
 ```
 
 ## Do support narrowing if `isinstance` is imported
@@ -163,46 +139,38 @@ if isinstance_alias(x, int):
 ```py
 from builtins import isinstance as imported_isinstance
 
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = 1 if flag else "a"
 
-flag = bool_instance()
-x = 1 if flag else "a"
-if imported_isinstance(x, int):
-    reveal_type(x)  # revealed: Literal[1]
+    if imported_isinstance(x, int):
+        reveal_type(x)  # revealed: Literal[1]
 ```
 
 ## Do not narrow if second argument is not a type
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = 1 if flag else "a"
 
-flag = bool_instance()
-x = 1 if flag else "a"
+    # TODO: this should cause us to emit a diagnostic during
+    # type checking
+    if isinstance(x, "a"):
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 
-# TODO: this should cause us to emit a diagnostic during
-# type checking
-if isinstance(x, "a"):
-    reveal_type(x)  # revealed: Literal[1] | Literal["a"]
-
-# TODO: this should cause us to emit a diagnostic during
-# type checking
-if isinstance(x, "int"):
-    reveal_type(x)  # revealed: Literal[1] | Literal["a"]
+    # TODO: this should cause us to emit a diagnostic during
+    # type checking
+    if isinstance(x, "int"):
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```
 
 ## Do not narrow if there are keyword arguments
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = 1 if flag else "a"
 
-flag = bool_instance()
-x = 1 if flag else "a"
-
-# TODO: this should cause us to emit a diagnostic
-# (`isinstance` has no `foo` parameter)
-if isinstance(x, int, foo="bar"):
-    reveal_type(x)  # revealed: Literal[1] | Literal["a"]
+    # TODO: this should cause us to emit a diagnostic
+    # (`isinstance` has no `foo` parameter)
+    if isinstance(x, int, foo="bar"):
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```

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

@@ -7,45 +7,43 @@ Narrowing for `issubclass(class, classinfo)` expressions.
 ### Basic example
 
 ```py
-def flag() -> bool: ...
+def _(flag: bool):
+    t = int if flag else str
 
-t = int if flag() else str
-
-if issubclass(t, bytes):
-    reveal_type(t)  # revealed: Never
-
-if issubclass(t, object):
-    reveal_type(t)  # revealed: Literal[int, str]
-
-if issubclass(t, int):
-    reveal_type(t)  # revealed: Literal[int]
-else:
-    reveal_type(t)  # revealed: Literal[str]
-
-if issubclass(t, str):
-    reveal_type(t)  # revealed: Literal[str]
-    if issubclass(t, int):
+    if issubclass(t, bytes):
         reveal_type(t)  # revealed: Never
+
+    if issubclass(t, object):
+        reveal_type(t)  # revealed: Literal[int, str]
+
+    if issubclass(t, int):
+        reveal_type(t)  # revealed: Literal[int]
+    else:
+        reveal_type(t)  # revealed: Literal[str]
+
+    if issubclass(t, str):
+        reveal_type(t)  # revealed: Literal[str]
+        if issubclass(t, int):
+            reveal_type(t)  # revealed: Never
 ```
 
 ### Proper narrowing in `elif` and `else` branches
 
 ```py
-def flag() -> bool: ...
+def _(flag1: bool, flag2: bool):
+    t = int if flag1 else str if flag2 else bytes
 
-t = int if flag() else str if flag() else bytes
+    if issubclass(t, int):
+        reveal_type(t)  # revealed: Literal[int]
+    else:
+        reveal_type(t)  # revealed: Literal[str, bytes]
 
-if issubclass(t, int):
-    reveal_type(t)  # revealed: Literal[int]
-else:
-    reveal_type(t)  # revealed: Literal[str, bytes]
-
-if issubclass(t, int):
-    reveal_type(t)  # revealed: Literal[int]
-elif issubclass(t, str):
-    reveal_type(t)  # revealed: Literal[str]
-else:
-    reveal_type(t)  # revealed: Literal[bytes]
+    if issubclass(t, int):
+        reveal_type(t)  # revealed: Literal[int]
+    elif issubclass(t, str):
+        reveal_type(t)  # revealed: Literal[str]
+    else:
+        reveal_type(t)  # revealed: Literal[bytes]
 ```
 
 ### Multiple derived classes
@@ -56,29 +54,28 @@ class Derived1(Base): ...
 class Derived2(Base): ...
 class Unrelated: ...
 
-def flag() -> bool: ...
+def _(flag1: bool, flag2: bool, flag3: bool):
+    t1 = Derived1 if flag1 else Derived2
 
-t1 = Derived1 if flag() else Derived2
+    if issubclass(t1, Base):
+        reveal_type(t1)  # revealed: Literal[Derived1, Derived2]
 
-if issubclass(t1, Base):
-    reveal_type(t1)  # revealed: Literal[Derived1, Derived2]
+    if issubclass(t1, Derived1):
+        reveal_type(t1)  # revealed: Literal[Derived1]
+    else:
+        reveal_type(t1)  # revealed: Literal[Derived2]
 
-if issubclass(t1, Derived1):
-    reveal_type(t1)  # revealed: Literal[Derived1]
-else:
-    reveal_type(t1)  # revealed: Literal[Derived2]
+    t2 = Derived1 if flag2 else Base
 
-t2 = Derived1 if flag() else Base
+    if issubclass(t2, Base):
+        reveal_type(t2)  # revealed: Literal[Derived1, Base]
 
-if issubclass(t2, Base):
-    reveal_type(t2)  # revealed: Literal[Derived1, Base]
+    t3 = Derived1 if flag3 else Unrelated
 
-t3 = Derived1 if flag() else Unrelated
-
-if issubclass(t3, Base):
-    reveal_type(t3)  # revealed: Literal[Derived1]
-else:
-    reveal_type(t3)  # revealed: Literal[Unrelated]
+    if issubclass(t3, Base):
+        reveal_type(t3)  # revealed: Literal[Derived1]
+    else:
+        reveal_type(t3)  # revealed: Literal[Unrelated]
 ```
 
 ### Narrowing for non-literals
@@ -87,16 +84,13 @@ else:
 class A: ...
 class B: ...
 
-def get_class() -> type[object]: ...
-
-t = get_class()
-
-if issubclass(t, A):
-    reveal_type(t)  # revealed: type[A]
-    if issubclass(t, B):
-        reveal_type(t)  # revealed: type[A] & type[B]
-else:
-    reveal_type(t)  # revealed: type[object] & ~type[A]
+def _(t: type[object]):
+    if issubclass(t, A):
+        reveal_type(t)  # revealed: type[A]
+        if issubclass(t, B):
+            reveal_type(t)  # revealed: type[A] & type[B]
+    else:
+        reveal_type(t)  # revealed: type[object] & ~type[A]
 ```
 
 ### Handling of `None`
@@ -107,16 +101,15 @@ else:
 # error: [possibly-unbound-import] "Member `NoneType` of module `types` is possibly unbound"
 from types import NoneType
 
-def flag() -> bool: ...
+def _(flag: bool):
+    t = int if flag else NoneType
 
-t = int if flag() else NoneType
+    if issubclass(t, NoneType):
+        reveal_type(t)  # revealed: Literal[NoneType]
 
-if issubclass(t, NoneType):
-    reveal_type(t)  # revealed: Literal[NoneType]
-
-if issubclass(t, type(None)):
-    # TODO: this should be just `Literal[NoneType]`
-    reveal_type(t)  # revealed: Literal[int, NoneType]
+    if issubclass(t, type(None)):
+        # TODO: this should be just `Literal[NoneType]`
+        reveal_type(t)  # revealed: Literal[int, NoneType]
 ```
 
 ## `classinfo` contains multiple types
@@ -126,14 +119,13 @@ if issubclass(t, type(None)):
 ```py
 class Unrelated: ...
 
-def flag() -> bool: ...
+def _(flag1: bool, flag2: bool):
+    t = int if flag1 else str if flag2 else bytes
 
-t = int if flag() else str if flag() else bytes
-
-if issubclass(t, (int, (Unrelated, (bytes,)))):
-    reveal_type(t)  # revealed: Literal[int, bytes]
-else:
-    reveal_type(t)  # revealed: Literal[str]
+    if issubclass(t, (int, (Unrelated, (bytes,)))):
+        reveal_type(t)  # revealed: Literal[int, bytes]
+    else:
+        reveal_type(t)  # revealed: Literal[str]
 ```
 
 ## Special cases
@@ -148,9 +140,7 @@ to `issubclass`:
 ```py
 class A: ...
 
-def get_object() -> object: ...
-
-t = get_object()
+t = object()
 
 # TODO: we should emit a diagnostic here
 if issubclass(t, A):

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

@@ -3,19 +3,16 @@
 ## Single `match` pattern
 
 ```py
-def bool_instance() -> bool:
-    return True
+def _(flag: bool):
+    x = None if flag else 1
 
-flag = bool_instance()
+    reveal_type(x)  # revealed: None | Literal[1]
 
-x = None if flag else 1
-reveal_type(x)  # revealed: None | Literal[1]
+    y = 0
 
-y = 0
+    match x:
+        case None:
+            y = x
 
-match x:
-    case None:
-        y = x
-
-reveal_type(y)  # revealed: Literal[0] | None
+    reveal_type(y)  # revealed: Literal[0] | None
 ```

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

@@ -0,0 +1,51 @@
+# Consolidating narrowed types after if statement
+
+## After if-else statements, narrowing has no effect if the variable is not mutated in any branch
+
+```py
+def _(x: int | None):
+    if x is None:
+        pass
+    else:
+        pass
+
+    reveal_type(x)  # revealed: int | None
+```
+
+## Narrowing can have a persistent effect if the variable is mutated in one branch
+
+```py
+def _(x: int | None):
+    if x is None:
+        x = 10
+    else:
+        pass
+
+    reveal_type(x)  # revealed: int
+```
+
+## An if statement without an explicit `else` branch is equivalent to one with a no-op `else` branch
+
+```py
+def _(x: int | None, y: int | None):
+    if x is None:
+        x = 0
+
+    if y is None:
+        pass
+
+    reveal_type(x)  # revealed: int
+    reveal_type(y)  # revealed: int | None
+```
+
+## An if-elif without an explicit else branch is equivalent to one with an empty else branch
+
+```py
+def _(x: int | None):
+    if x is None:
+        x = 0
+    elif x > 50:
+        x = 50
+
+    reveal_type(x)  # revealed: int
+```