Add rule registry and rule selection

Add declare_lint
Introduce DiagnosticId
2024-12-09 14:10:40 +01:00 · 2024-12-09 14:08:19 +01:00 · 2024-12-09 14:05:09 +01:00
445 changed files with 10171 additions and 28608 deletions
--- a/.github/actionlint.yaml
+++ b/.github/actionlint.yaml
@@ -1,9 +0,0 @@
-# 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
--- a/.github/workflows/build-binaries.yml
+++ b/.github/workflows/build-binaries.yml
@@ -53,9 +53,9 @@ jobs:
          args: --out dist
      - name: "Test sdist"
        run: |
-          pip install dist/"${PACKAGE_NAME}"-*.tar.gz --force-reinstall
-          "${MODULE_NAME}" --help
-          python -m "${MODULE_NAME}" --help
+          pip install dist/${{ env.PACKAGE_NAME }}-*.tar.gz --force-reinstall
+          ${{ env.MODULE_NAME }} --help
+          python -m ${{ env.MODULE_NAME }} --help
      - name: "Upload sdist"
        uses: actions/upload-artifact@v4
        with:
@@ -125,7 +125,7 @@ jobs:
          args: --release --locked --out dist
      - name: "Test wheel - aarch64"
        run: |
-          pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
          ruff --help
          python -m ruff --help
      - name: "Upload wheels"
@@ -186,9 +186,9 @@ jobs:
        if: ${{ !startsWith(matrix.platform.target, 'aarch64') }}
        shell: bash
        run: |
-          python -m pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
-          "${MODULE_NAME}" --help
-          python -m "${MODULE_NAME}" --help
+          python -m pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+          ${{ env.MODULE_NAME }} --help
+          python -m ${{ env.MODULE_NAME }} --help
      - name: "Upload wheels"
        uses: actions/upload-artifact@v4
        with:
@@ -236,9 +236,9 @@ jobs:
      - name: "Test wheel"
        if: ${{ startsWith(matrix.target, 'x86_64') }}
        run: |
-          pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
-          "${MODULE_NAME}" --help
-          python -m "${MODULE_NAME}" --help
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+          ${{ env.MODULE_NAME }} --help
+          python -m ${{ env.MODULE_NAME }} --help
      - name: "Upload wheels"
        uses: actions/upload-artifact@v4
        with:
--- a/.github/workflows/build-docker.yml
+++ b/.github/workflows/build-docker.yml
@@ -72,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
@@ -87,10 +87,9 @@ 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
@@ -142,10 +141,9 @@ 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 "${RUFF_BASE_IMG}@sha256:%s " *)
+            $(printf '${{ env.RUFF_BASE_IMG }}@sha256:%s ' *)

  docker-publish-extra:
    name: Publish additional Docker image based on ${{ matrix.image-mapping }}
@@ -184,7 +182,7 @@ jobs:
          # Generate Dockerfile content
          cat <<EOF > Dockerfile
          FROM ${BASE_IMAGE}
-          COPY --from=${RUFF_BASE_IMG}:latest /ruff /usr/local/bin/ruff
+          COPY --from=${{ env.RUFF_BASE_IMG }}:latest /ruff /usr/local/bin/ruff
          ENTRYPOINT []
          CMD ["/usr/local/bin/ruff"]
          EOF
@@ -204,14 +202,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
@@ -287,9 +285,7 @@ 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 "${RUFF_BASE_IMG}@sha256:%s " *)
+            $(printf '${{ env.RUFF_BASE_IMG }}@sha256:%s ' *)
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -290,9 +290,7 @@ jobs:
          file: "Cargo.toml"
          field: "workspace.package.rust-version"
      - name: "Install Rust toolchain"
-        env:
-          MSRV: ${{ steps.msrv.outputs.value }}
-        run: rustup default "${MSRV}"
+        run: rustup default ${{ steps.msrv.outputs.value }}
      - name: "Install mold"
        uses: rui314/setup-mold@v1
      - name: "Install cargo nextest"
@@ -308,14 +306,13 @@ jobs:
        shell: bash
        env:
          NEXTEST_PROFILE: "ci"
-          MSRV: ${{ steps.msrv.outputs.value }}
-        run: cargo "+${MSRV}" insta test --all-features --unreferenced reject --test-runner nextest
+        run: cargo +${{ steps.msrv.outputs.value }} insta test --all-features --unreferenced reject --test-runner nextest

  cargo-fuzz-build:
    name: "cargo fuzz build"
    runs-on: ubuntu-latest
    needs: determine_changes
-    if: ${{ github.ref == 'refs/heads/main' || needs.determine_changes.outputs.fuzz == 'true' || needs.determine_changes.outputs.code == 'true' }}
+    if: ${{ github.ref == 'refs/heads/main' || needs.determine_changes.outputs.fuzz == 'true' }}
    timeout-minutes: 10
    steps:
      - uses: actions/checkout@v4
@@ -349,7 +346,7 @@ jobs:
      - uses: actions/checkout@v4
        with:
          persist-credentials: false
-      - uses: astral-sh/setup-uv@v5
+      - uses: astral-sh/setup-uv@v4
      - uses: actions/download-artifact@v4
        name: Download Ruff binary to test
        id: download-cached-binary
@@ -357,18 +354,16 @@ 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 "${DOWNLOAD_PATH}/ruff"
+          chmod +x ${{ steps.download-cached-binary.outputs.download-path }}/ruff

          (
            uvx \
-            --python="${PYTHON_VERSION}" \
+            --python=${{ env.PYTHON_VERSION }} \
            --from=./python/py-fuzzer \
            fuzz \
-            --test-executable="${DOWNLOAD_PATH}/ruff" \
+            --test-executable=${{ steps.download-cached-binary.outputs.download-path }}/ruff \
            --bin=ruff \
            0-500
          )
@@ -434,72 +429,64 @@ 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 "${DOWNLOAD_PATH}/ruff"
+          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff

          # Set pipefail to avoid hiding errors with tee
          set -eo pipefail

-          ruff-ecosystem check ./ruff "${DOWNLOAD_PATH}/ruff" --cache ./checkouts --output-format markdown | tee ecosystem-result-check-stable
+          ruff-ecosystem check ./ruff ${{ steps.ruff-target.outputs.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 "${DOWNLOAD_PATH}/ruff"
+          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff

          # Set pipefail to avoid hiding errors with tee
          set -eo pipefail

-          ruff-ecosystem check ./ruff "${DOWNLOAD_PATH}/ruff" --cache ./checkouts --output-format markdown --force-preview | tee ecosystem-result-check-preview
+          ruff-ecosystem check ./ruff ${{ steps.ruff-target.outputs.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 "${DOWNLOAD_PATH}/ruff"
+          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff

          # Set pipefail to avoid hiding errors with tee
          set -eo pipefail

-          ruff-ecosystem format ./ruff "${DOWNLOAD_PATH}/ruff" --cache ./checkouts --output-format markdown | tee ecosystem-result-format-stable
+          ruff-ecosystem format ./ruff ${{ steps.ruff-target.outputs.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 "${DOWNLOAD_PATH}/ruff"
+          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff

          # Set pipefail to avoid hiding errors with tee
          set -eo pipefail

-          ruff-ecosystem format ./ruff "${DOWNLOAD_PATH}/ruff" --cache ./checkouts --output-format markdown --force-preview | tee ecosystem-result-format-preview
+          ruff-ecosystem format ./ruff ${{ steps.ruff-target.outputs.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
@@ -554,7 +541,7 @@ jobs:
          args: --out dist
      - name: "Test wheel"
        run: |
-          pip install --force-reinstall --find-links dist "${PACKAGE_NAME}"
+          pip install --force-reinstall --find-links dist ${{ env.PACKAGE_NAME }}
          ruff --help
          python -m ruff --help
      - name: "Remove wheels from cache"
@@ -583,14 +570,13 @@ 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
-          # 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"
+          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

  docs:
    name: "mkdocs"
@@ -613,7 +599,7 @@ jobs:
      - name: "Install Rust toolchain"
        run: rustup show
      - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v4
      - uses: Swatinem/rust-cache@v2
      - name: "Install Insiders dependencies"
        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
@@ -651,7 +637,7 @@ jobs:
      - name: "Run checks"
        run: scripts/formatter_ecosystem_checks.sh
      - name: "Github step summary"
-        run: cat target/formatter-ecosystem/stats.txt > "$GITHUB_STEP_SUMMARY"
+        run: cat target/formatter-ecosystem/stats.txt > $GITHUB_STEP_SUMMARY
      - name: "Remove checkouts from cache"
        run: rm -r target/formatter-ecosystem

@@ -690,13 +676,11 @@ 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 "${DOWNLOAD_PATH}/ruff"
-          export PATH="${DOWNLOAD_PATH}:${PATH}"
+          chmod +x ${{ steps.ruff-target.outputs.download-path }}/ruff
+          export PATH=${{ steps.ruff-target.outputs.download-path }}:$PATH
          ruff version

          just test
--- a/.github/workflows/daily_fuzz.yaml
+++ b/.github/workflows/daily_fuzz.yaml
@@ -34,7 +34,7 @@ jobs:
      - uses: actions/checkout@v4
        with:
          persist-credentials: false
-      - uses: astral-sh/setup-uv@v5
+      - uses: astral-sh/setup-uv@v4
      - name: "Install Rust toolchain"
        run: rustup show
      - name: "Install mold"
@@ -46,7 +46,6 @@ jobs:
        run: cargo build --locked
      - name: Fuzz
        run: |
-          # shellcheck disable=SC2046
          (
            uvx \
            --python=3.12 \
--- a/.github/workflows/pr-comment.yaml
+++ b/.github/workflows/pr-comment.yaml
@@ -10,11 +10,12 @@ 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@v7
        name: Download pull request number
@@ -29,7 +30,7 @@ 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@v7
@@ -65,9 +66,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
--- a/.github/workflows/publish-docs.yml
+++ b/.github/workflows/publish-docs.yml
@@ -44,19 +44,21 @@ 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' }}
@@ -91,7 +93,9 @@ jobs:
        run: mkdocs build --strict -f mkdocs.public.yml

      - name: "Clone docs repo"
-        run: git clone https://${{ secrets.ASTRAL_DOCS_PAT }}@github.com/astral-sh/docs.git astral-docs
+        run: |
+          version="${{ env.version }}"
+          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/
@@ -99,10 +103,12 @@ 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"

@@ -111,8 +117,12 @@ 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
@@ -121,15 +131,13 @@ 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 }}
@@ -137,7 +145,9 @@ 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
--- a/.github/workflows/publish-pypi.yml
+++ b/.github/workflows/publish-pypi.yml
@@ -22,7 +22,7 @@ jobs:
      id-token: write
    steps:
      - name: "Install uv"
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v4
      - uses: actions/download-artifact@v4
        with:
          pattern: wheels-*
--- a/.github/workflows/sync_typeshed.yaml
+++ b/.github/workflows/sync_typeshed.yaml
@@ -31,7 +31,7 @@ jobs:
        with:
          repository: python/typeshed
          path: typeshed
-          persist-credentials: false
+          persist-credentials: true
      - name: Setup git
        run: |
          git config --global user.name typeshedbot
@@ -59,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:
--- a/.github/zizmor.yml
+++ b/.github/zizmor.yml
@@ -1,6 +0,0 @@
-# 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
--- a/.markdownlint.yaml
+++ b/.markdownlint.yaml
@@ -21,11 +21,3 @@ 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
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -2,7 +2,6 @@ fail_fast: false

 exclude: |
  (?x)^(
-    .github/workflows/release.yml|
    crates/red_knot_vendored/vendor/.*|
    crates/red_knot_workspace/resources/.*|
    crates/ruff_linter/resources/.*|
@@ -23,12 +22,13 @@ repos:
      - id: validate-pyproject

  - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.21
+    rev: 0.7.19
    hooks:
      - id: mdformat
        additional_dependencies:
-          - mdformat-mkdocs==4.0.0
-          - mdformat-footnote==0.1.1
+          - mdformat-mkdocs
+          - mdformat-admon
+          - mdformat-footnote
        exclude: |
          (?x)^(
            docs/formatter/black\.md
@@ -59,7 +59,7 @@ repos:
          - black==24.10.0

  - repo: https://github.com/crate-ci/typos
-    rev: v1.28.4
+    rev: v1.28.2
    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.8.4
+    rev: v0.8.2
    hooks:
      - id: ruff-format
      - id: ruff
@@ -88,37 +88,20 @@ repos:
      - 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.10.0
+    rev: v0.8.0
    hooks:
      - id: zizmor
+        # `release.yml` is autogenerated by `dist`; security issues need to be fixed there
+        # (https://opensource.axo.dev/cargo-dist/)
+        exclude: .github/workflows/release.yml
+        # We could consider enabling the low-severity warnings, but they're noisy
+        args: [--min-severity=medium]

  - 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.5
-    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]
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,68 +1,5 @@
 # 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
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -467,7 +467,7 @@ cargo build --release && hyperfine --warmup 10 \
  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache -e --select W505,E501"
 ```

-You can run `uv venv --project ./scripts/benchmarks`, activate the venv and then run `uv sync --project ./scripts/benchmarks` to create a working environment for the
+You can run `poetry install` from `./scripts/benchmarks` to create a working environment for the
 above. All reported benchmarks were computed using the versions specified by
 `./scripts/benchmarks/pyproject.toml` on Python 3.11.

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -117,9 +117,9 @@ dependencies = [

 [[package]]
 name = "anyhow"
-version = "1.0.95"
+version = "1.0.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
+checksum = "c1fd03a028ef38ba2276dce7e33fcd6369c158a1bca17946c4b1b701891c1ff7"

 [[package]]
 name = "append-only-vec"
@@ -220,9 +220,9 @@ checksum = "7f839cdf7e2d3198ac6ca003fd8ebc61715755f41c1cad15ff13df67531e00ed"

 [[package]]
 name = "bstr"
-version = "1.11.1"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "786a307d683a5bf92e6fd5fd69a7eb613751668d1d8d67d802846dfe367c62c8"
+checksum = "1a68f1f47cdf0ec8ee4b941b2eee2a80cb796db73118c0dd09ac63fbe405be22"
 dependencies = [
 "memchr",
 "regex-automata 0.4.8",
@@ -314,9 +314,9 @@ dependencies = [

 [[package]]
 name = "chrono"
-version = "0.4.39"
+version = "0.4.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e36cc9d416881d2e24f9a963be5fb1cd90966419ac844274161d10488b3e825"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
 dependencies = [
 "android-tzdata",
 "iana-time-zone",
@@ -413,7 +413,7 @@ dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -465,9 +465,9 @@ checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"

 [[package]]
 name = "colored"
-version = "2.2.0"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
+checksum = "cbf2150cce219b664a8a70df7a1f933836724b503f8a413af9365b4dcc4d90b8"
 dependencies = [
 "lazy_static",
 "windows-sys 0.48.0",
@@ -475,9 +475,9 @@ dependencies = [

 [[package]]
 name = "compact_str"
-version = "0.8.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b79c4069c6cad78e2e0cdfcbd26275770669fb39fd308a752dc110e83b9af32"
+checksum = "6050c3a16ddab2e412160b31f2c871015704239bca62f72f6e5f0be631d3f644"
 dependencies = [
 "castaway",
 "cfg-if",
@@ -693,7 +693,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "strsim 0.10.0",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -704,7 +704,7 @@ checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f"
 dependencies = [
 "darling_core",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -774,7 +774,7 @@ dependencies = [
 "glob",
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -826,7 +826,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -877,9 +877,9 @@ dependencies = [

 [[package]]
 name = "env_logger"
-version = "0.11.6"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcaee3d8e3cfc3fd92428d477bc97fc29ec8716d180c0d74c643bb26166660e0"
+checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d"
 dependencies = [
 "anstream",
 "anstyle",
@@ -923,9 +923,9 @@ checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"

 [[package]]
 name = "fern"
-version = "0.7.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4316185f709b23713e41e3195f90edef7fb00c3ed4adc79769cf09cc762a3b29"
+checksum = "69ff9c9d5fb3e6da8ac2f77ab76fe7e8087d512ce095200f8f29ac5b656cf6dc"
 dependencies = [
 "log",
 ]
@@ -1019,9 +1019,9 @@ dependencies = [

 [[package]]
 name = "glob"
-version = "0.3.2"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"

 [[package]]
 name = "globset"
@@ -1246,7 +1246,7 @@ checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -1420,7 +1420,7 @@ dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -1521,9 +1521,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.169"
+version = "0.2.167"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
+checksum = "09d6582e104315a817dff97f75133544b2e094ee22447d2acf4a74e189ba06fc"

 [[package]]
 name = "libcst"
@@ -1547,7 +1547,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2ae40017ac09cd2c6a53504cb3c871c7f2b41466eac5bc66ba63f39073b467b"
 dependencies = [
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -1607,14 +1607,13 @@ checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"

 [[package]]
 name = "lsp-server"
-version = "0.7.8"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9462c4dc73e17f971ec1f171d44bfffb72e65a130117233388a0ebc7ec5656f9"
+checksum = "550446e84739dcaf6d48a4a093973850669e13e8a34d8f8d64851041be267cd9"
 dependencies = [
 "crossbeam-channel",
 "log",
 "serde",
- "serde_derive",
 "serde_json",
 ]

@@ -2015,7 +2014,7 @@ dependencies = [
 "pest_meta",
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -2162,7 +2161,7 @@ dependencies = [
 "newtype-uuid",
 "quick-xml",
 "strip-ansi-escapes",
- "thiserror 2.0.9",
+ "thiserror 2.0.6",
 "uuid",
 ]

@@ -2197,9 +2196,9 @@ dependencies = [

 [[package]]
 name = "quote"
-version = "1.0.38"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
 "proc-macro2",
 ]
@@ -2289,7 +2288,6 @@ dependencies = [
 "compact_str",
 "countme",
 "dir-test",
- "drop_bomb",
 "hashbrown 0.15.2",
 "indexmap",
 "insta",
@@ -2307,7 +2305,6 @@ dependencies = [
 "ruff_python_literal",
 "ruff_python_parser",
 "ruff_python_stdlib",
- "ruff_python_trivia",
 "ruff_source_file",
 "ruff_text_size",
 "rustc-hash 2.1.0",
@@ -2317,7 +2314,7 @@ dependencies = [
 "static_assertions",
 "tempfile",
 "test-case",
- "thiserror 2.0.9",
+ "thiserror 2.0.6",
 "tracing",
 ]

@@ -2414,7 +2411,7 @@ dependencies = [
 "rustc-hash 2.1.0",
 "salsa",
 "serde",
- "thiserror 2.0.9",
+ "thiserror 2.0.6",
 "toml",
 "tracing",
 ]
@@ -2520,7 +2517,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.8.4"
+version = "0.8.2"
 dependencies = [
 "anyhow",
 "argfile",
@@ -2567,7 +2564,7 @@ dependencies = [
 "strum",
 "tempfile",
 "test-case",
- "thiserror 2.0.9",
+ "thiserror 2.0.6",
 "tikv-jemallocator",
 "toml",
 "tracing",
@@ -2637,7 +2634,7 @@ dependencies = [
 "salsa",
 "serde",
 "tempfile",
- "thiserror 2.0.9",
+ "thiserror 2.0.6",
 "tracing",
 "tracing-subscriber",
 "tracing-tree",
@@ -2739,7 +2736,7 @@ dependencies = [

 [[package]]
 name = "ruff_linter"
-version = "0.8.4"
+version = "0.8.2"
 dependencies = [
 "aho-corasick",
 "annotate-snippets 0.9.2",
@@ -2789,7 +2786,7 @@ dependencies = [
 "strum",
 "strum_macros",
 "test-case",
- "thiserror 2.0.9",
+ "thiserror 2.0.6",
 "toml",
 "typed-arena",
 "unicode-normalization",
@@ -2806,7 +2803,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "ruff_python_trivia",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -2823,7 +2820,7 @@ dependencies = [
 "serde_json",
 "serde_with",
 "test-case",
- "thiserror 2.0.9",
+ "thiserror 2.0.6",
 "uuid",
 ]

@@ -2895,7 +2892,7 @@ dependencies = [
 "similar",
 "smallvec",
 "static_assertions",
- "thiserror 2.0.9",
+ "thiserror 2.0.6",
 "tracing",
 ]

@@ -3028,7 +3025,7 @@ dependencies = [
 "serde",
 "serde_json",
 "shellexpand",
- "thiserror 2.0.9",
+ "thiserror 2.0.6",
 "tracing",
 "tracing-subscriber",
 ]
@@ -3054,7 +3051,7 @@ dependencies = [

 [[package]]
 name = "ruff_wasm"
-version = "0.8.4"
+version = "0.8.2"
 dependencies = [
 "console_error_panic_hook",
 "console_log",
@@ -3196,7 +3193,7 @@ checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
 [[package]]
 name = "salsa"
 version = "0.18.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=3c7f1694c9efba751dbeeacfbc93b227586e316a#3c7f1694c9efba751dbeeacfbc93b227586e316a"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=254c749b02cde2fd29852a7463a33e800b771758#254c749b02cde2fd29852a7463a33e800b771758"
 dependencies = [
 "append-only-vec",
 "arc-swap",
@@ -3206,7 +3203,6 @@ dependencies = [
 "indexmap",
 "lazy_static",
 "parking_lot",
- "rayon",
 "rustc-hash 2.1.0",
 "salsa-macro-rules",
 "salsa-macros",
@@ -3217,17 +3213,17 @@ dependencies = [
 [[package]]
 name = "salsa-macro-rules"
 version = "0.1.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=3c7f1694c9efba751dbeeacfbc93b227586e316a#3c7f1694c9efba751dbeeacfbc93b227586e316a"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=254c749b02cde2fd29852a7463a33e800b771758#254c749b02cde2fd29852a7463a33e800b771758"

 [[package]]
 name = "salsa-macros"
 version = "0.18.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=3c7f1694c9efba751dbeeacfbc93b227586e316a#3c7f1694c9efba751dbeeacfbc93b227586e316a"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=254c749b02cde2fd29852a7463a33e800b771758#254c749b02cde2fd29852a7463a33e800b771758"
 dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 "synstructure",
 ]

@@ -3261,7 +3257,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "serde_derive_internals",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -3284,9 +3280,9 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"

 [[package]]
 name = "serde"
-version = "1.0.217"
+version = "1.0.215"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
+checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f"
 dependencies = [
 "serde_derive",
 ]
@@ -3304,13 +3300,13 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.217"
+version = "1.0.215"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
+checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -3321,14 +3317,14 @@ checksum = "330f01ce65a3a5fe59a60c82f3c9a024b573b8a6e875bd233fe5f934e71d54e3"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
 name = "serde_json"
-version = "1.0.134"
+version = "1.0.133"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d00f4175c42ee48b15416f6193a959ba3a0d67fc699a0db9ad12df9f83991c7d"
+checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377"
 dependencies = [
 "itoa",
 "memchr",
@@ -3344,7 +3340,7 @@ checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -3367,9 +3363,9 @@ dependencies = [

 [[package]]
 name = "serde_with"
-version = "3.12.0"
+version = "3.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6b6f7f2fcb69f747921f79f3926bd1e203fce4fef62c268dd3abfb6d86029aa"
+checksum = "8e28bdad6db2b8340e449f7108f020b3b092e8583a9e3fb82713e1d4e71fe817"
 dependencies = [
 "serde",
 "serde_derive",
@@ -3378,14 +3374,14 @@ dependencies = [

 [[package]]
 name = "serde_with_macros"
-version = "3.12.0"
+version = "3.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d00caa5193a3c8362ac2b73be6b9e768aa5a4b2f721d8f4b339600c3cb51f8e"
+checksum = "9d846214a9854ef724f3da161b426242d8de7c1fc7de2f89bb1efcb154dca79d"
 dependencies = [
 "darling",
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -3499,7 +3495,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "rustversion",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -3521,9 +3517,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.93"
+version = "2.0.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c786062daee0d6db1132800e623df74274a0a87322d8e183338e01b3d98d058"
+checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -3538,7 +3534,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -3601,7 +3597,7 @@ dependencies = [
 "cfg-if",
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -3612,7 +3608,7 @@ checksum = "5c89e72a01ed4c579669add59014b9a524d609c0c88c6a585ce37485879f6ffb"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 "test-case-core",
 ]

@@ -3627,11 +3623,11 @@ dependencies = [

 [[package]]
 name = "thiserror"
-version = "2.0.9"
+version = "2.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f072643fd0190df67a8bab670c20ef5d8737177d6ac6b2e9a236cb096206b2cc"
+checksum = "8fec2a1820ebd077e2b90c4df007bebf344cd394098a13c563957d0afc83ea47"
 dependencies = [
- "thiserror-impl 2.0.9",
+ "thiserror-impl 2.0.6",
 ]

 [[package]]
@@ -3642,18 +3638,18 @@ checksum = "b607164372e89797d78b8e23a6d67d5d1038c1c65efd52e1389ef8b77caba2a6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "2.0.9"
+version = "2.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b50fa271071aae2e6ee85f842e2e28ba8cd2c5fb67f11fcb1fd70b276f9e7d4"
+checksum = "d65750cab40f4ff1929fb1ba509e9914eb756131cef4210da8d5d700d26f6312"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -3775,7 +3771,7 @@ checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -4045,7 +4041,7 @@ checksum = "6b91f57fe13a38d0ce9e28a03463d8d3c2468ed03d75375110ec71d93b449a08"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -4140,7 +4136,7 @@ dependencies = [
 "once_cell",
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 "wasm-bindgen-shared",
 ]

@@ -4175,7 +4171,7 @@ checksum = "98c9ae5a76e46f4deecd0f0255cc223cfa18dc9b261213b8aa0c7b36f61b3f1d"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 "wasm-bindgen-backend",
 "wasm-bindgen-shared",
 ]
@@ -4209,7 +4205,7 @@ checksum = "222ebde6ea87fbfa6bdd2e9f1fd8a91d60aee5db68792632176c4e16a74fc7d8"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -4512,7 +4508,7 @@ checksum = "28cc31741b18cb6f1d5ff12f5b7523e3d6eb0852bbbad19d73905511d9849b95"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 "synstructure",
 ]

@@ -4533,7 +4529,7 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
@@ -4553,7 +4549,7 @@ checksum = "0ea7b4a3637ea8669cedf0f1fd5c286a17f3de97b8dd5a70a6c167a1730e63a5"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 "synstructure",
 ]

@@ -4582,7 +4578,7 @@ checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.93",
+ "syn 2.0.90",
 ]

 [[package]]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -118,8 +118,7 @@ rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
-# When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "3c7f1694c9efba751dbeeacfbc93b227586e316a" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "254c749b02cde2fd29852a7463a33e800b771758" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
--- a/README.md
+++ b/README.md
@@ -140,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.8.4/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.8.4/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.8.2/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.8.2/install.ps1 | iex"
 ```

 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -174,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.8.4
+  rev: v0.8.2
  hooks:
    # Run the linter.
    - id: ruff
--- a/crates/red_knot/src/main.rs
+++ b/crates/red_knot/src/main.rs
@@ -5,7 +5,6 @@ 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;
@@ -16,11 +15,12 @@ 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 python_version;
+mod target_version;
 mod verbosity;

 #[derive(Debug, Parser)]
@@ -34,39 +34,54 @@ struct Args {
    #[command(subcommand)]
    pub(crate) command: Option<Command>,

-    /// 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 = "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>,

-    /// 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")]
+    #[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"
+    )]
    venv_path: 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 = "DIRECTORY",
+        help = "Custom directory to use for stdlib typeshed stubs"
+    )]
+    custom_typeshed_dir: Option<SystemPathBuf>,

-    /// Additional path to use as a module-resolution source (can be passed multiple times).
-    #[arg(long, value_name = "PATH")]
+    #[arg(
+        long,
+        value_name = "PATH",
+        help = "Additional path to use as a module-resolution source (can be passed multiple times)"
+    )]
    extra_search_path: Option<Vec<SystemPathBuf>>,

-    /// Python version to assume when resolving types.
-    #[arg(long, value_name = "VERSION", alias = "target-version")]
-    python_version: Option<PythonVersion>,
+    #[arg(
+        long,
+        help = "Python version to assume when resolving types",
+        value_name = "VERSION"
+    )]
+    target_version: Option<TargetVersion>,

    #[clap(flatten)]
    verbosity: Verbosity,

-    /// Run in watch mode by re-running whenever files change.
-    #[arg(long, short = 'W')]
+    #[arg(
+        long,
+        help = "Run in watch mode by re-running whenever files change",
+        short = 'W'
+    )]
    watch: bool,
 }

@@ -74,8 +89,8 @@ impl Args {
    fn to_configuration(&self, cli_cwd: &SystemPath) -> Configuration {
        let mut configuration = Configuration::default();

-        if let Some(python_version) = self.python_version {
-            configuration.python_version = Some(python_version.into());
+        if let Some(target_version) = self.target_version {
+            configuration.target_version = Some(target_version.into());
        }

        if let Some(venv_path) = &self.venv_path {
@@ -84,8 +99,9 @@ impl Args {
            });
        }

-        if let Some(typeshed) = &self.typeshed {
-            configuration.search_paths.typeshed = Some(SystemPath::absolute(typeshed, cli_cwd));
+        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(extra_search_paths) = &self.extra_search_path {
@@ -151,13 +167,15 @@ fn run() -> anyhow::Result<ExitStatus> {
    };

    let cwd = args
-        .project
+        .current_directory
        .as_ref()
        .map(|cwd| {
            if cwd.as_std_path().is_dir() {
                Ok(SystemPath::absolute(cwd, &cli_base_path))
            } else {
-                Err(anyhow!("Provided project path `{cwd}` is not a directory"))
+                Err(anyhow!(
+                    "Provided current-directory path `{cwd}` is not a directory"
+                ))
            }
        })
        .transpose()?
@@ -279,7 +297,7 @@ impl MainLoop {
        while let Ok(message) = self.receiver.recv() {
            match message {
                MainLoopMessage::CheckWorkspace => {
-                    let db = db.clone();
+                    let db = db.snapshot();
                    let sender = self.sender.clone();

                    // Spawn a new task that checks the workspace. This needs to be done in a separate thread
--- a/crates/red_knot/src/python_version.rs
+++ b/crates/red_knot/src/python_version.rs
@@ -1,68 +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 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()
-        );
-    }
-}
--- a/crates/red_knot/src/target_version.rs
+++ b/crates/red_knot/src/target_version.rs
@@ -0,0 +1,62 @@
+/// 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()
+        );
+    }
+}
--- a/crates/red_knot/tests/file_watching.rs
+++ b/crates/red_knot/tests/file_watching.rs
@@ -282,7 +282,7 @@ where
        .extra_paths
        .iter()
        .flatten()
-        .chain(search_paths.typeshed.iter())
+        .chain(search_paths.custom_typeshed.iter())
        .chain(search_paths.site_packages.iter().flat_map(|site_packages| {
            if let SitePackages::Known(path) = site_packages {
                path.as_slice()
@@ -296,7 +296,7 @@ where
    }

    let configuration = Configuration {
-        python_version: Some(PythonVersion::PY312),
+        target_version: Some(PythonVersion::PY312),
        search_paths,
    };

@@ -888,7 +888,7 @@ fn changed_versions_file() -> anyhow::Result<()> {
            Ok(())
        },
        |root_path, _workspace_path| SearchPathConfiguration {
-            typeshed: Some(root_path.join("typeshed")),
+            custom_typeshed: Some(root_path.join("typeshed")),
            ..SearchPathConfiguration::default()
        },
    )?;
--- a/crates/red_knot_python_semantic/Cargo.toml
+++ b/crates/red_knot_python_semantic/Cargo.toml
@@ -20,14 +20,12 @@ ruff_python_stdlib = { workspace = true }
 ruff_source_file = { workspace = true }
 ruff_text_size = { workspace = true }
 ruff_python_literal = { workspace = true }
-ruff_python_trivia = { workspace = true }

 anyhow = { workspace = true }
 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 }
@@ -55,8 +53,5 @@ 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
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/annotated.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/annotated.md
@@ -1,94 +0,0 @@
-# `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]]
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/any.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/any.md
@@ -34,7 +34,8 @@ If you define your own class named `Any`, using that in a type expression refers
 isn't a spelling of the Any type.

 ```py
-class Any: ...
+class Any:
+    pass

 x: Any

@@ -58,7 +59,8 @@ assignable to `int`.
 ```py
 from typing import Any

-class Subclass(Any): ...
+class Subclass(Any):
+    pass

 reveal_type(Subclass.__mro__)  # revealed: tuple[Literal[Subclass], Any, Literal[object]]

@@ -66,18 +68,8 @@ 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
+def f() -> Subclass:
+    pass
+
+reveal_type(f())  # revealed: Subclass
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/literal_string.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/literal_string.md
@@ -27,19 +27,19 @@ def f():
 ```py
 from typing_extensions import Literal, LiteralString

-bad_union: Literal["hello", LiteralString]  # error: [invalid-type-form]
-bad_nesting: Literal[LiteralString]  # error: [invalid-type-form]
+bad_union: Literal["hello", LiteralString]  # error: [invalid-literal-parameter]
+bad_nesting: Literal[LiteralString]  # error: [invalid-literal-parameter]
 ```

-### Parameterized
+### Parametrized

-`LiteralString` cannot be parameterized.
+`LiteralString` cannot be parametrized.

 ```py
 from typing_extensions import LiteralString

-a: LiteralString[str]  # error: [invalid-type-form]
-b: LiteralString["foo"]  # error: [invalid-type-form]
+a: LiteralString[str]  # error: [invalid-type-parameter]
+b: LiteralString["foo"]  # error: [invalid-type-parameter]
 ```

 ### As a base class
@@ -73,12 +73,12 @@ 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)
+reveal_type(foo.join(qux))  # revealed: @Todo(call todo)

 template: LiteralString = "{}, {}"
 reveal_type(template)  # revealed: Literal["{}, {}"]
 # TODO: Infer `LiteralString`
-reveal_type(template.format(foo, bar))  # revealed: @Todo(Attribute access on `StringLiteral` types)
+reveal_type(template.format(foo, bar))  # revealed: @Todo(call todo)
 ```

 ### Assignability
@@ -89,26 +89,28 @@ vice versa.
 ```py
 from typing_extensions import Literal, LiteralString

-def _(flag: bool):
-    foo_1: Literal["foo"] = "foo"
-    bar_1: LiteralString = foo_1  # fine
+def coinflip() -> bool:
+    return True

-    foo_2 = "foo" if flag else "bar"
-    reveal_type(foo_2)  # revealed: Literal["foo", "bar"]
-    bar_2: LiteralString = foo_2  # fine
+foo_1: Literal["foo"] = "foo"
+bar_1: LiteralString = foo_1  # fine

-    foo_3: LiteralString = "foo" * 1_000_000_000
-    bar_3: str = foo_2  # fine
+foo_2 = "foo" if coinflip() else "bar"
+reveal_type(foo_2)  # revealed: Literal["foo", "bar"]
+bar_2: LiteralString = foo_2  # fine

-    baz_1: str = str()
-    qux_1: LiteralString = baz_1  # error: [invalid-assignment]
+foo_3: LiteralString = "foo" * 1_000_000_000
+bar_3: str = foo_2  # fine

-    baz_2: LiteralString = "baz" * 1_000_000_000
-    qux_2: Literal["qux"] = baz_2  # error: [invalid-assignment]
+baz_1: str = str()
+qux_1: LiteralString = baz_1  # 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]
+baz_2: LiteralString = "baz" * 1_000_000_000
+qux_2: Literal["qux"] = baz_2  # error: [invalid-assignment]
+
+baz_3 = "foo" if coinflip() else 1
+reveal_type(baz_3)  # revealed: Literal["foo"] | Literal[1]
+qux_3: LiteralString = baz_3  # error: [invalid-assignment]
 ```

 ### Narrowing
@@ -135,7 +137,7 @@ if "" < lorem == "ipsum":

 ```toml
 [environment]
-python-version = "3.11"
+target-version = "3.11"
 ```

 ```py
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/never.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/never.md
@@ -21,7 +21,7 @@ reveal_type(stop())
 ```py
 from typing_extensions import NoReturn, Never, Any

-# error: [invalid-type-form] "Type `typing.Never` expected no type parameter"
+# error: [invalid-type-parameter] "Type `typing.Never` expected no type parameter"
 x: Never[int]
 a1: NoReturn
 a2: Never
@@ -47,29 +47,18 @@ def f():

 ## `typing.Never`

-`typing.Never` is only available in Python 3.11 and later.
-
-### Python 3.11
+`typing.Never` is only available in Python 3.11 and later:

 ```toml
 [environment]
-python-version = "3.11"
+target-version = "3.11"
 ```

 ```py
 from typing import Never

-reveal_type(Never)  # revealed: typing.Never
-```
+x: Never

-### Python 3.10
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-# error: [unresolved-import]
-from typing import Never
+def f():
+    reveal_type(x)  # revealed: Never
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/stdlib_typing_aliases.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/stdlib_typing_aliases.md
@@ -1,127 +0,0 @@
-# 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__)
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/string.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/string.md
@@ -3,56 +3,75 @@
 ## Simple

 ```py
-def f(v: "int"):
-    reveal_type(v)  # revealed: int
+def f() -> "int":
+    return 1
+
+reveal_type(f())  # revealed: int
 ```

 ## Nested

 ```py
-def f(v: "'int'"):
-    reveal_type(v)  # revealed: int
+def f() -> "'int'":
+    return 1
+
+reveal_type(f())  # revealed: int
 ```

 ## Type expression

 ```py
-def f1(v: "int | str", w: "tuple[int, str]"):
-    reveal_type(v)  # revealed: int | str
-    reveal_type(w)  # revealed: tuple[int, str]
+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]
 ```

 ## Partial

 ```py
-def f(v: tuple[int, "str"]):
-    reveal_type(v)  # revealed: tuple[int, str]
+def f() -> tuple[int, "str"]:
+    return 1
+
+reveal_type(f())  # revealed: tuple[int, str]
 ```

 ## Deferred

 ```py
-def f(v: "Foo"):
-    reveal_type(v)  # revealed: Foo
+def f() -> "Foo":
+    return Foo()

-class Foo: ...
+class Foo:
+    pass
+
+reveal_type(f())  # revealed: Foo
 ```

 ## Deferred (undefined)

 ```py
 # error: [unresolved-reference]
-def f(v: "Foo"):
-    reveal_type(v)  # revealed: Unknown
+def f() -> "Foo":
+    pass
+
+reveal_type(f())  # revealed: Unknown
 ```

 ## Partial deferred

 ```py
-def f(v: int | "Foo"):
-    reveal_type(v)  # revealed: int | Foo
+def f() -> int | "Foo":
+    return 1

-class Foo: ...
+class Foo:
+    pass
+
+reveal_type(f())  # revealed: int | Foo
 ```

 ## `typing.Literal`
@@ -60,43 +79,65 @@ class Foo: ...
 ```py
 from typing import Literal

-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 f1() -> Literal["Foo", "Bar"]:
+    return "Foo"

-class Foo: ...
+def f2() -> 'Literal["Foo", "Bar"]':
+    return "Foo"
+
+class Foo:
+    pass
+
+reveal_type(f1())  # revealed: Literal["Foo", "Bar"]
+reveal_type(f2())  # revealed: Literal["Foo", "Bar"]
 ```

 ## Various string kinds

 ```py
-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
+# error: [raw-string-type-annotation] "Type expressions cannot use raw string literal"
+def f1() -> r"int":
+    return 1
+
+# error: [fstring-type-annotation] "Type expressions cannot use f-strings"
+def f2() -> f"int":
+    return 1
+
+# error: [byte-string-type-annotation] "Type expressions cannot use bytes literal"
+def f3() -> b"int":
+    return 1
+
+def f4() -> "int":
+    return 1
+
+# error: [implicit-concatenated-string-type-annotation] "Type expressions cannot span multiple string literals"
+def f5() -> "in" "t":
+    return 1
+
+# error: [escape-character-in-forward-annotation] "Type expressions cannot contain escape characters"
+def f6() -> "\N{LATIN SMALL LETTER I}nt":
+    return 1
+
+# error: [escape-character-in-forward-annotation] "Type expressions cannot contain escape characters"
+def f7() -> "\x69nt":
+    return 1
+
+def f8() -> """int""":
+    return 1
+
+# error: [byte-string-type-annotation] "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
 ```

 ## Various string kinds in `typing.Literal`
@@ -104,8 +145,10 @@ def f1(
 ```py
 from typing import Literal

-def f(v: Literal["a", r"b", b"c", "d" "e", "\N{LATIN SMALL LETTER F}", "\x67", """h"""]):
-    reveal_type(v)  # revealed: Literal["a", "b", "de", "f", "g", "h"] | Literal[b"c"]
+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"]
 ```

 ## Class variables
@@ -132,7 +175,8 @@ c: "Foo"
 # error: [invalid-assignment] "Object of type `Literal[1]` is not assignable to `Foo`"
 d: "Foo" = 1

-class Foo: ...
+class Foo:
+    pass

 c = Foo()

--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md
@@ -1,71 +0,0 @@
-# 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
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_type_qualifiers.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_type_qualifiers.md
@@ -1,37 +0,0 @@
-# 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]
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/assignment/annotations.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/assignment/annotations.md
@@ -33,6 +33,8 @@ b: tuple[int] = (42,)
 c: tuple[str, int] = ("42", 42)
 d: tuple[tuple[str, str], tuple[int, int]] = (("foo", "foo"), (42, 42))
 e: tuple[str, ...] = ()
+# TODO: we should not emit this error
+# error: [call-possibly-unbound-method] "Method `__class_getitem__` of type `Literal[tuple]` is possibly unbound"
 f: tuple[str, *tuple[int, ...], bytes] = ("42", b"42")
 g: tuple[str, Unpack[tuple[int, ...]], bytes] = ("42", b"42")
 h: tuple[list[int], list[int]] = ([], [])
@@ -76,10 +78,20 @@ c: tuple[str | int, str] = ([], "foo")
 ## PEP-604 annotations are supported

 ```py
-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
+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
 ```

 ## Attribute expressions in type annotations are understood
@@ -106,7 +118,8 @@ from __future__ import annotations

 x: Foo

-class Foo: ...
+class Foo:
+    pass

 x = Foo()
 reveal_type(x)  # revealed: Foo
@@ -117,7 +130,8 @@ reveal_type(x)  # revealed: Foo
 ```pyi path=main.pyi
 x: Foo

-class Foo: ...
+class Foo:
+    pass

 x = Foo()
 reveal_type(x)  # revealed: Foo
--- a/crates/red_knot_python_semantic/resources/mdtest/assignment/augmented.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/assignment/augmented.md
@@ -49,116 +49,134 @@ reveal_type(x)  # revealed: int
 ## Method union

 ```py
-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
+def bool_instance() -> bool:
+    return True

-    f = Foo()
-    f += 12
+flag = bool_instance()

-    reveal_type(f)  # revealed: str | int
+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
 ```

 ## Partially bound `__iadd__`

 ```py
-def _(flag: bool):
-    class Foo:
-        if flag:
-            def __iadd__(self, other: str) -> int:
-                return 42
+def bool_instance() -> bool:
+    return True

-    f = Foo()
+class Foo:
+    if bool_instance():
+        def __iadd__(self, other: str) -> int:
+            return 42

-    # 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!"
+f = Foo()

-    reveal_type(f)  # revealed: int | Unknown
+# 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
 ```

 ## Partially bound with `__add__`

 ```py
-def _(flag: bool):
-    class Foo:
-        def __add__(self, other: str) -> str:
-            return "Hello, world!"
-        if flag:
-            def __iadd__(self, other: str) -> int:
-                return 42
+def bool_instance() -> bool:
+    return True

-    f = Foo()
-    f += "Hello, world!"
+class Foo:
+    def __add__(self, other: str) -> str:
+        return "Hello, world!"
+    if bool_instance():
+        def __iadd__(self, other: str) -> int:
+            return 42

-    reveal_type(f)  # revealed: int | str
+f = Foo()
+f += "Hello, world!"
+
+reveal_type(f)  # revealed: int | str
 ```

 ## Partially bound target union

 ```py
-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
+def bool_instance() -> bool:
+    return True

-    if flag2:
-        f = Foo()
-    else:
-        f = 42.0
-    f += 12
+class Foo:
+    def __add__(self, other: int) -> str:
+        return "Hello, world!"
+    if bool_instance():
+        def __iadd__(self, other: int) -> int:
+            return 42

-    reveal_type(f)  # revealed: int | str | float
+if bool_instance():
+    f = Foo()
+else:
+    f = 42.0
+f += 12
+
+reveal_type(f)  # revealed: int | str | float
 ```

 ## Target union

 ```py
-def _(flag: bool):
-    class Foo:
-        def __iadd__(self, other: int) -> str:
-            return "Hello, world!"
+def bool_instance() -> bool:
+    return True

-    if flag:
-        f = Foo()
-    else:
-        f = 42.0
-    f += 12
+flag = bool_instance()

-    reveal_type(f)  # revealed: str | float
+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
 ```

 ## Partially bound target union with `__add__`

 ```py
-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
+def bool_instance() -> bool:
+    return True

-    class Bar:
-        def __add__(self, other: int) -> bytes:
-            return b"Hello, world!"
+flag = bool_instance()

-        def __iadd__(self, other: int) -> float:
-            return 42.0
+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 = Bar()
-    f += 12
+class Bar:
+    def __add__(self, other: int) -> bytes:
+        return b"Hello, world!"

-    reveal_type(f)  # revealed: int | str | float
+    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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/attributes.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/attributes.md
@@ -1,27 +1,29 @@
-# Attributes
-
-Tests for attribute access on various kinds of types.
+# Class attributes

 ## Union of attributes

 ```py
-def _(flag: bool):
+def bool_instance() -> bool:
+    return True
+
+flag = bool_instance()
+
+if flag:
+    class C1:
+        x = 1
+
+else:
+    class C1:
+        x = 2
+
+class C2:
    if flag:
-        class C1:
-            x = 1
-
+        x = 3
    else:
-        class C1:
-            x = 2
+        x = 4

-    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]
+reveal_type(C1.x)  # revealed: Literal[1, 2]
+reveal_type(C2.x)  # revealed: Literal[3, 4]
 ```

 ## Inherited attributes
@@ -66,19 +68,24 @@ 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 _(flag1: bool, flag2: bool):
-    class C1:
-        x = 1
+def bool_instance() -> bool:
+    return True

-    class C2: ...
+class C1:
+    x = 1

-    class C3:
-        x = 3
+class C2: ...

-    C = C1 if flag1 else C2 if flag2 else C3
+class C3:
+    x = 3

-    # error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C1, C2, C3]` is possibly unbound"
-    reveal_type(C.x)  # revealed: Literal[1, 3]
+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]
 ```

 ### Possibly-unbound within a class
@@ -87,21 +94,26 @@ We raise the same diagnostic if the attribute is possibly-unbound in at least on
 union:

 ```py
-def _(flag: bool, flag1: bool, flag2: bool):
-    class C1:
-        x = 1
+def bool_instance() -> bool:
+    return True

-    class C2:
-        if flag:
-            x = 2
+class C1:
+    x = 1

-    class C3:
-        x = 3
+class C2:
+    if bool_instance():
+        x = 2

-    C = C1 if flag1 else C2 if flag2 else C3
+class C3:
+    x = 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]
+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]
 ```

 ## Unions with all paths unbound
@@ -109,115 +121,16 @@ def _(flag: bool, flag1: bool, flag2: bool):
 If the symbol is unbound in all elements of the union, we detect that:

 ```py
-def _(flag: bool):
-    class C1: ...
-    class C2: ...
-    C = C1 if flag else C2
+def bool_instance() -> bool:
+    return True

-    # 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]
-```
-
-## Function-literal attributes
-
-Most attribute accesses on function-literal types are delegated to `types.FunctionType`, since all
-functions are instances of that class:
-
-```py path=a.py
-def f(): ...
-
-reveal_type(f.__defaults__)  # revealed: @Todo(instance attributes)
-reveal_type(f.__kwdefaults__)  # revealed: @Todo(instance attributes)
-```
-
-Some attributes are special-cased, however:
-
-```py path=b.py
-def f(): ...
-
-reveal_type(f.__get__)  # revealed: @Todo(`__get__` method on functions)
-reveal_type(f.__call__)  # revealed: @Todo(`__call__` method on functions)
-```
-
-## Int-literal attributes
-
-Most attribute accesses on int-literal types are delegated to `builtins.int`, since all literal
-integers are instances of that class:
-
-```py path=a.py
-reveal_type((2).bit_length)  # revealed: @Todo(instance attributes)
-reveal_type((2).denominator)  # revealed: @Todo(instance attributes)
-```
-
-Some attributes are special-cased, however:
-
-```py path=b.py
-reveal_type((2).numerator)  # revealed: Literal[2]
-reveal_type((2).real)  # revealed: Literal[2]
-```
-
-## Literal `bool` attributes
-
-Most attribute accesses on bool-literal types are delegated to `builtins.bool`, since all literal
-bols are instances of that class:
-
-```py path=a.py
-reveal_type(True.__and__)  # revealed: @Todo(instance attributes)
-reveal_type(False.__or__)  # revealed: @Todo(instance attributes)
-```
-
-Some attributes are special-cased, however:
-
-```py path=b.py
-reveal_type(True.numerator)  # revealed: Literal[1]
-reveal_type(False.real)  # revealed: Literal[0]
-```
-
-## Bytes-literal attributes
-
-All attribute access on literal `bytes` types is currently delegated to `buitins.bytes`:
-
-```py
-reveal_type(b"foo".join)  # revealed: @Todo(instance attributes)
-reveal_type(b"foo".endswith)  # revealed: @Todo(instance attributes)
+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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/binary/instances.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/binary/instances.md
@@ -281,12 +281,20 @@ 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 _(x: bool, y: int):
-    reveal_type(x + y)  # revealed: int
-    reveal_type(4.2 + x)  # revealed: float
+def returns_int() -> int:
+    return 42

-    # TODO should be float, need to check arg type and fall back to `rhs.__radd__`
-    reveal_type(y + 4.12)  # revealed: int
+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
 ```

 ## With literal types
--- a/crates/red_knot_python_semantic/resources/mdtest/boolean/short_circuit.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/boolean/short_circuit.md
@@ -7,61 +7,72 @@ Similarly, in `and` expressions, if the left-hand side is falsy, the right-hand
 evaluated.

 ```py
-def _(flag: bool):
-    if flag or (x := 1):
-        # error: [possibly-unresolved-reference]
-        reveal_type(x)  # revealed: Literal[1]
+def bool_instance() -> bool:
+    return True

-    if flag and (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]
 ```

 ## First expression is always evaluated

 ```py
-def _(flag: bool):
-    if (x := 1) or flag:
-        reveal_type(x)  # revealed: Literal[1]
+def bool_instance() -> bool:
+    return True

-    if (x := 1) and 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]
 ```

 ## Statically known truthiness

 ```py
 if True or (x := 1):
-    # error: [unresolved-reference]
-    reveal_type(x)  # revealed: Unknown
+    # TODO: infer that the second arm is never executed, and raise `unresolved-reference`.
+    # error: [possibly-unresolved-reference]
+    reveal_type(x)  # revealed: Literal[1]

 if True and (x := 1):
+    # TODO: infer that the second arm is always executed, do not raise a diagnostic
+    # error: [possibly-unresolved-reference]
    reveal_type(x)  # revealed: Literal[1]
 ```

 ## Later expressions can always use variables from earlier expressions

 ```py
-def _(flag: bool):
-    flag or (x := 1) or reveal_type(x)  # revealed: Literal[1]
+def bool_instance() -> bool:
+    return True

-    # error: [unresolved-reference]
-    flag or reveal_type(y) or (y := 1)  # revealed: Unknown
+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
 ```

 ## Nested expressions

 ```py
-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]
+def bool_instance() -> bool:
+    return True

+if bool_instance() or ((x := 1) and bool_instance()):
    # error: [possibly-unresolved-reference]
-    if (flag1 and (z := 1)) or reveal_type(z):  # revealed: Literal[1]
-        # error: [possibly-unresolved-reference]
-        reveal_type(z)  # revealed: Literal[1]
+    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]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/call/callable_instance.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/callable_instance.md
@@ -22,27 +22,29 @@ reveal_type(b)  # revealed: Unknown
 ## Possibly unbound `__call__` method

 ```py
-def _(flag: bool):
-    class PossiblyNotCallable:
-        if flag:
-            def __call__(self) -> int: ...
+def flag() -> bool: ...

-    a = PossiblyNotCallable()
-    result = a()  # error: "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
-    reveal_type(result)  # revealed: 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
 ```

 ## Possibly unbound callable

 ```py
-def _(flag: bool):
-    if flag:
-        class PossiblyUnbound:
-            def __call__(self) -> int: ...
+def flag() -> bool: ...

-    # error: [possibly-unresolved-reference]
-    a = PossiblyUnbound()
-    reveal_type(a())  # revealed: int
+if flag():
+    class PossiblyUnbound:
+        def __call__(self) -> int: ...
+
+# error: [possibly-unresolved-reference]
+a = PossiblyUnbound()
+reveal_type(a())  # revealed: int
 ```

 ## Non-callable `__call__`
@@ -59,14 +61,15 @@ reveal_type(a())  # revealed: Unknown
 ## Possibly non-callable `__call__`

 ```py
-def _(flag: bool):
-    class NonCallable:
-        if flag:
-            __call__ = 1
-        else:
-            def __call__(self) -> int: ...
+def flag() -> bool: ...

-    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
+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/crates/red_knot_python_semantic/resources/mdtest/call/function.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/function.md
@@ -57,10 +57,12 @@ 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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/call/union.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/union.md
@@ -3,14 +3,22 @@
 ## Union of return types

 ```py
-def _(flag: bool):
-    if flag:
-        def f() -> int:
-            return 1
-    else:
-        def f() -> str:
-            return "foo"
-    reveal_type(f())  # revealed: int | str
+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
 ```

 ## Calling with an unknown union
@@ -18,10 +26,13 @@ def _(flag: bool):
 ```py
 from nonexistent import f  # error: [unresolved-import] "Cannot resolve import `nonexistent`"

-def coinflip() -> bool:
+def bool_instance() -> bool:
    return True

-if coinflip():
+flag = bool_instance()
+
+if flag:
+
    def f() -> int:
        return 1

@@ -33,14 +44,20 @@ reveal_type(f())  # revealed: Unknown | int
 Calling a union with a non-callable element should emit a diagnostic.

 ```py
-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
+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
 ```

 ## Multiple non-callable elements in a union
@@ -48,17 +65,23 @@ def _(flag: bool):
 Calling a union with multiple non-callable elements should mention all of them in the diagnostic.

 ```py
-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())
+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())
 ```

 ## All non-callable union elements
@@ -66,12 +89,16 @@ def _(flag: bool, flag2: bool):
 Calling a union with no callable elements can emit a simpler diagnostic.

 ```py
-def _(flag: bool):
-    if flag:
-        f = 1
-    else:
-        f = "foo"
+def bool_instance() -> bool:
+    return True

-    x = f()  # error: "Object of type `Literal[1] | Literal["foo"]` is not callable"
-    reveal_type(x)  # revealed: Unknown
+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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/identity.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/identity.md
@@ -3,31 +3,38 @@
 ```py
 class A: ...

-def _(a1: A, a2: A, o: object):
-    n1 = None
-    n2 = None
+def get_a() -> A: ...
+def get_object() -> object: ...

-    reveal_type(a1 is a1)  # revealed: bool
-    reveal_type(a1 is a2)  # revealed: bool
+a1 = get_a()
+a2 = get_a()

-    reveal_type(n1 is n1)  # revealed: Literal[True]
-    reveal_type(n1 is n2)  # revealed: Literal[True]
+n1 = None
+n2 = None

-    reveal_type(a1 is n1)  # revealed: Literal[False]
-    reveal_type(n1 is a1)  # revealed: Literal[False]
+o = get_object()

-    reveal_type(a1 is o)  # revealed: bool
-    reveal_type(n1 is o)  # revealed: bool
+reveal_type(a1 is a1)  # revealed: bool
+reveal_type(a1 is a2)  # revealed: bool

-    reveal_type(a1 is not a1)  # revealed: bool
-    reveal_type(a1 is not a2)  # revealed: bool
+reveal_type(n1 is n1)  # revealed: Literal[True]
+reveal_type(n1 is n2)  # revealed: Literal[True]

-    reveal_type(n1 is not n1)  # revealed: Literal[False]
-    reveal_type(n1 is not n2)  # revealed: Literal[False]
+reveal_type(a1 is n1)  # revealed: Literal[False]
+reveal_type(n1 is a1)  # 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 o)  # revealed: bool
+reveal_type(n1 is o)  # revealed: bool

-    reveal_type(a1 is not o)  # revealed: bool
-    reveal_type(n1 is not o)  # revealed: bool
+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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/instances/rich_comparison.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/instances/rich_comparison.md
@@ -312,9 +312,17 @@ reveal_type(1 <= 2j)  # revealed: bool
 reveal_type(1 > 2j)  # revealed: bool
 reveal_type(1 >= 2j)  # 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
+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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/integers.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/integers.md
@@ -20,8 +20,10 @@ reveal_type(1 <= "" and 0 < 1)  # revealed: bool

 ```py
 # TODO: implement lookup of `__eq__` on typeshed `int` stub.
-def _(a: int, b: int):
-    reveal_type(1 == a)  # revealed: bool
-    reveal_type(9 < a)  # revealed: bool
-    reveal_type(a < b)  # revealed: bool
+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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/intersections.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/intersections.md
@@ -14,19 +14,21 @@ class Child1(Base):

 class Child2(Base): ...

-def _(x: Base):
-    c1 = Child1()
+def get_base() -> Base: ...

-    # Create an intersection type through narrowing:
-    if isinstance(x, Child1):
-        if isinstance(x, Child2):
-            reveal_type(x)  # revealed: Child1 & Child2
+x = get_base()
+c1 = Child1()

-            reveal_type(x == 1)  # revealed: Literal[True]
+# Create an intersection type through narrowing:
+if isinstance(x, Child1):
+    if isinstance(x, Child2):
+        reveal_type(x)  # revealed: Child1 & Child2

-            # Other comparison operators fall back to the base type:
-            reveal_type(x > 1)  # revealed: bool
-            reveal_type(x is c1)  # revealed: bool
+        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
 ```

 ## Negative contributions
@@ -71,15 +73,18 @@ if x != "abc":
 #### Integers

 ```py
-def _(x: int):
-    if x != 1:
-        reveal_type(x)  # revealed: int & ~Literal[1]
+def get_int() -> int: ...

-        reveal_type(x != 1)  # revealed: Literal[True]
-        reveal_type(x != 2)  # revealed: bool
+x = get_int()

-        reveal_type(x == 1)  # revealed: Literal[False]
-        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
 ```

 ### Identity comparisons
@@ -87,15 +92,18 @@ def _(x: int):
 ```py
 class A: ...

-def _(o: object):
-    a = A()
-    n = None
+def get_object() -> object: ...

-    if o is not None:
-        reveal_type(o)  # revealed: object & ~None
+o = object()

-        reveal_type(o is n)  # revealed: Literal[False]
-        reveal_type(o is not n)  # revealed: Literal[True]
+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]
 ```

 ## Diagnostics
@@ -111,13 +119,16 @@ class Container:

 class NonContainer: ...

-def _(x: object):
-    if isinstance(x, Container):
-        if isinstance(x, NonContainer):
-            reveal_type(x)  # revealed: Container & NonContainer
+def get_object() -> object: ...

-            # error: [unsupported-operator] "Operator `in` is not supported for types `int` and `NonContainer`"
-            reveal_type(2 in x)  # revealed: bool
+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
 ```

 ### Unsupported operators for negative contributions
@@ -131,11 +142,14 @@ class Container:

 class NonContainer: ...

-def _(x: object):
-    if isinstance(x, Container):
-        if not isinstance(x, NonContainer):
-            reveal_type(x)  # revealed: Container & ~NonContainer
+def get_object() -> object: ...

-            # No error here!
-            reveal_type(2 in x)  # revealed: bool
+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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/non_bool_returns.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/non_bool_returns.md
@@ -31,10 +31,10 @@ class C:
    def __lt__(self, other) -> C: ...

 x = A() < B() < C()
-reveal_type(x)  # revealed: A & ~AlwaysTruthy | B
+reveal_type(x)  # revealed: A | B

 y = 0 < 1 < A() < 3
-reveal_type(y)  # revealed: Literal[False] | A
+reveal_type(y)  # revealed: bool | A

 z = 10 < 0 < A() < B() < C()
 reveal_type(z)  # revealed: Literal[False]
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/strings.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/strings.md
@@ -3,17 +3,18 @@
 ## String literals

 ```py
-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
+def str_instance() -> str: ...

-    # ensure we're not comparing the interned salsa symbols, which compare by order of declaration.
-    reveal_type("ab" < "ab_cd")  # revealed: Literal[True]
+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]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/tuples.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/tuples.md
@@ -58,23 +58,28 @@ reveal_type(c >= d)  # revealed: Literal[True]
 #### Results with Ambiguity

 ```py
-def _(x: bool, y: int):
-    a = (x,)
-    b = (y,)
+def bool_instance() -> bool:
+    return True

-    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
+def int_instance() -> int:
+    return 42

-    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
+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 == 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
@@ -192,7 +197,7 @@ 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")`
+> 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
@@ -203,38 +208,42 @@ In contrast, with operators like `<` and `>`, the comparison must consider each
 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]
+def str_instance() -> str:
+    return "hello"

-    a = (x, y, "foo")
+def int_instance() -> int:
+    return 42

-    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("foo" == "bar")  # revealed: Literal[False]
+reveal_type(("foo",) == ("bar",))  # revealed: Literal[False]
+reveal_type((4, "foo") == (4, "bar"))  # revealed: Literal[False]
+reveal_type((int_instance(), "foo") == (int_instance(), "bar"))  # revealed: Literal[False]

-    b = (x, y, "bar")
+a = (str_instance(), int_instance(), "foo")

-    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
+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

-    c = (x, y, "foo", "different_length")
+b = (str_instance(), int_instance(), "bar")

-    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
+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 = (str_instance(), int_instance(), "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
@@ -243,36 +252,42 @@ Errors occurring within a tuple comparison should propagate outward. However, if
 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()
+def int_instance() -> int:
+    return 42

-    a = (0, n, A())
+def str_instance() -> str:
+    return "hello"

-    # 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
+class A: ...

-    # Comparison between `a` and `b` should only involve the first elements, `Literal[0]` and `Literal[99999]`,
-    # and should terminate immediately.
-    b = (99999, n, 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()

-    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]
+a = (0, int_instance(), 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, int_instance(), 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
@@ -280,20 +295,22 @@ def _(n: int, s: str):
 "Membership Test Comparisons" refers to the operators `in` and `not in`.

 ```py
-def _(n: int):
-    a = (1, 2)
-    b = ((3, 4), (1, 2))
-    c = ((1, 2, 3), (4, 5, 6))
-    d = ((n, n), (n, n))
+def int_instance() -> int:
+    return 42

-    reveal_type(a in b)  # revealed: Literal[True]
-    reveal_type(a not in b)  # revealed: Literal[False]
+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 c)  # revealed: Literal[False]
-    reveal_type(a not in c)  # revealed: Literal[True]
+reveal_type(a in b)  # revealed: Literal[True]
+reveal_type(a not in b)  # revealed: Literal[False]

-    reveal_type(a in d)  # revealed: bool
-    reveal_type(a not in d)  # revealed: bool
+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
 ```

 ### Identity Comparisons
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/unions.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/unions.md
@@ -5,46 +5,49 @@
 Comparisons on union types need to consider all possible cases:

 ```py
-def _(flag: bool):
-    one_or_two = 1 if flag else 2
+def bool_instance() -> bool:
+    return True

-    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]
+flag = bool_instance()
+one_or_two = 1 if flag else 2

-    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 <= 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 < 1)  # revealed: Literal[False]
-    reveal_type(one_or_two < 2)  # revealed: bool
-    reveal_type(one_or_two < 3)  # revealed: Literal[True]
+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 > 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 < 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 == 3)  # revealed: Literal[False]
-    reveal_type(one_or_two == 1)  # revealed: bool
+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[True]
-    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

-    a_or_ab = "a" if flag else "ab"
+reveal_type(one_or_two != 3)  # revealed: Literal[True]
+reveal_type(one_or_two != 1)  # revealed: bool

-    reveal_type(a_or_ab in "ab")  # revealed: Literal[True]
-    reveal_type("a" in a_or_ab)  # revealed: Literal[True]
+a_or_ab = "a" if flag else "ab"

-    reveal_type("c" not in a_or_ab)  # revealed: Literal[True]
-    reveal_type("a" not in a_or_ab)  # revealed: Literal[False]
+reveal_type(a_or_ab in "ab")  # revealed: Literal[True]
+reveal_type("a" in a_or_ab)  # revealed: Literal[True]

-    reveal_type("b" in a_or_ab)  # revealed: bool
-    reveal_type("b" not in a_or_ab)  # revealed: bool
+reveal_type("c" not in a_or_ab)  # revealed: Literal[True]
+reveal_type("a" not in a_or_ab)  # revealed: Literal[False]

-    one_or_none = 1 if flag else None
+reveal_type("b" in a_or_ab)  # revealed: bool
+reveal_type("b" not in a_or_ab)  # revealed: bool

-    reveal_type(one_or_none is None)  # revealed: bool
-    reveal_type(one_or_none is not None)  # revealed: bool
+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
 ```

 ## Union on both sides of the comparison
@@ -53,15 +56,18 @@ With unions on both sides, we need to consider the full cross product of options
 resulting (union) type:

 ```py
-def _(flag_s: bool, flag_l: bool):
-    small = 1 if flag_s else 2
-    large = 2 if flag_l else 3
+def bool_instance() -> bool:
+    return True

-    reveal_type(small <= large)  # revealed: Literal[True]
-    reveal_type(small >= large)  # revealed: bool
+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: bool
-    reveal_type(small > large)  # revealed: Literal[False]
+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]
 ```

 ## Unsupported operations
@@ -71,9 +77,12 @@ back to `bool` for the result type instead of trying to infer something more pre
 (supported) variants:

 ```py
-def _(flag: bool):
-    x = [1, 2] if flag else 1
+def bool_instance() -> bool:
+    return True

-    result = 1 in x  # error: "Operator `in` is not supported"
-    reveal_type(result)  # revealed: bool
+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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/unsupported.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/unsupported.md
@@ -1,38 +1,42 @@
 # Comparison: Unsupported operators

 ```py
-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
+def bool_instance() -> bool:
+    return True

-    b = 0 not in 10  # error: "Operator `not in` is not supported for types `Literal[0]` and `Literal[10]`"
-    reveal_type(b)  # revealed: bool
+class A: ...

-    # 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
+a = 1 in 7  # error: "Operator `in` is not supported for types `Literal[1]` and `Literal[7]`"
+reveal_type(a)  # 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
+b = 0 not in 10  # error: "Operator `not in` is not supported for types `Literal[0]` and `Literal[10]`"
+reveal_type(b)  # 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
+# 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, 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, 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

-    # 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
+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
+
+# error: [unsupported-operator] "Operator `<` is not supported for types `A` and `A`, in comparing `tuple[bool, A]` with `tuple[bool, A]`"
+g = (bool_instance(), A()) < (bool_instance(), A())
+reveal_type(g)  # revealed: Unknown
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/conditional/if_expression.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/conditional/if_expression.md
@@ -3,35 +3,47 @@
 ## Simple if-expression

 ```py
-def _(flag: bool):
-    x = 1 if flag else 2
-    reveal_type(x)  # revealed: Literal[1, 2]
+def bool_instance() -> bool:
+    return True
+
+flag = bool_instance()
+x = 1 if flag else 2
+reveal_type(x)  # revealed: Literal[1, 2]
 ```

 ## If-expression with walrus operator

 ```py
-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]
+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]
 ```

 ## Nested if-expression

 ```py
-def _(flag: bool, flag2: bool):
-    x = 1 if flag else 2 if flag2 else 3
-    reveal_type(x)  # revealed: Literal[1, 2, 3]
+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]
 ```

 ## None

 ```py
-def _(flag: bool):
-    x = 1 if flag else None
-    reveal_type(x)  # revealed: Literal[1] | None
+def bool_instance() -> bool:
+    return True
+
+flag = bool_instance()
+x = 1 if flag else None
+reveal_type(x)  # revealed: Literal[1] | None
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/conditional/if_statement.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/conditional/if_statement.md
@@ -3,115 +3,128 @@
 ## Simple if

 ```py
-def _(flag: bool):
-    y = 1
-    y = 2
+def bool_instance() -> bool:
+    return True

-    if flag:
-        y = 3
+flag = bool_instance()
+y = 1
+y = 2

-    reveal_type(y)  # revealed: Literal[2, 3]
+if flag:
+    y = 3
+
+reveal_type(y)  # revealed: Literal[2, 3]
 ```

 ## Simple if-elif-else

 ```py
-def _(flag: bool, flag2: bool):
-    y = 1
-    y = 2
+def bool_instance() -> bool:
+    return True

-    if flag:
-        y = 3
-    elif flag2:
-        y = 4
-    else:
-        r = y
-        y = 5
-        s = y
-    x = y
+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

-    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 _(flag: bool, flag2: bool):
-    if flag:
-        y = 1
-    elif flag2:
-        y = 2
-    else:
-        y = 3
+def bool_instance() -> bool:
+    return True

-    reveal_type(y)  # revealed: Literal[1, 2, 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]
 ```

 ## if-elif-else without else assignment

 ```py
-def _(flag: bool, flag2: bool):
-    y = 0
+def bool_instance() -> bool:
+    return True

-    if flag:
-        y = 1
-    elif flag2:
-        y = 2
-    else:
-        pass
-
-    reveal_type(y)  # revealed: Literal[0, 1, 2]
+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-elif-else with intervening assignment

 ```py
-def _(flag: bool, flag2: bool):
-    y = 0
+def bool_instance() -> bool:
+    return True

-    if flag:
-        y = 1
-        z = 3
-    elif flag2:
-        y = 2
-    else:
-        pass
-
-    reveal_type(y)  # revealed: Literal[0, 1, 2]
+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]
 ```

 ## Nested if statement

 ```py
-def _(flag: bool, flag2: bool):
-    y = 0
+def bool_instance() -> bool:
+    return True

-    if flag:
-        if flag2:
-            y = 1
-
-    reveal_type(y)  # revealed: Literal[0, 1]
+flag, flag2 = bool_instance(), bool_instance()
+y = 0
+if flag:
+    if flag2:
+        y = 1
+reveal_type(y)  # revealed: Literal[0, 1]
 ```

 ## if-elif without else

 ```py
-def _(flag: bool, flag2: bool):
-    y = 1
-    y = 2
+def bool_instance() -> bool:
+    return True

-    if flag:
-        y = 3
-    elif flag2:
-        y = 4
+flag, flag2 = bool_instance(), bool_instance()
+y = 1
+y = 2
+if flag:
+    y = 3
+elif flag2:
+    y = 4

-    reveal_type(y)  # revealed: Literal[2, 3, 4]
+reveal_type(y)  # revealed: Literal[2, 3, 4]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/conditional/match.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/conditional/match.md
@@ -3,43 +3,39 @@
 ## With wildcard

 ```py
-def _(target: int):
-    match target:
-        case 1:
-            y = 2
-        case _:
-            y = 3
+match 0:
+    case 1:
+        y = 2
+    case _:
+        y = 3

-    reveal_type(y)  # revealed: Literal[2, 3]
+reveal_type(y)  # revealed: Literal[2, 3]
 ```

 ## Without wildcard

 ```py
-def _(target: int):
-    match target:
-        case 1:
-            y = 2
-        case 2:
-            y = 3
+match 0:
+    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
-def _(target: int):
-    y = 1
-    y = 2
+y = 1
+y = 2
+match 0:
+    case 1:
+        y = 3
+    case 2:
+        y = 4

-    match target:
-        case 1:
-            y = 3
-        case 2:
-            y = 4
-
-    reveal_type(y)  # revealed: Literal[2, 3, 4]
+reveal_type(y)  # revealed: Literal[2, 3, 4]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/declaration/error.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/declaration/error.md
@@ -10,66 +10,42 @@ x: str  # error: [invalid-declaration] "Cannot declare type `str` for inferred t
 ## Incompatible declarations

 ```py
-def _(flag: bool):
-    if flag:
-        x: str
-    else:
-        x: int
+def bool_instance() -> bool:
+    return True

-    x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: str, int"
+flag = bool_instance()
+if flag:
+    x: str
+else:
+    x: int
+x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: str, int"
 ```

-## Incompatible declarations for 2 (out of 3) types
+## Partial declarations

 ```py
-def _(flag1: bool, flag2: bool):
-    if flag1:
-        x: str
-    elif flag2:
-        x: int
+def bool_instance() -> bool:
+    return True

-    # Here, the declared type for `x` is `int | str | Unknown`.
-    x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: str, int"
+flag = bool_instance()
+if flag:
+    x: int
+x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: Unknown, int"
 ```

 ## Incompatible declarations with bad assignment

 ```py
-def _(flag: bool):
-    if flag:
-        x: str
-    else:
-        x: int
+def bool_instance() -> bool:
+    return True

-    # 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
+flag = bool_instance()
+if flag:
+    x: str
+else:
+    x: int
+
+# error: [conflicting-declarations]
+# error: [invalid-assignment]
+x = b"foo"
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/exception/basic.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/exception/basic.md
@@ -49,124 +49,12 @@ def foo(
    try:
        help()
    except x as e:
-        reveal_type(e)  # revealed: AttributeError
+        # TODO: should be `AttributeError`
+        reveal_type(e)  # revealed: @Todo(exception type)
    except y as f:
-        reveal_type(f)  # revealed: OSError | RuntimeError
+        # TODO: should be `OSError | RuntimeError`
+        reveal_type(f)  # revealed: @Todo(exception type)
    except z as g:
        # TODO: should be `BaseException`
-        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]
+        reveal_type(g)  # revealed: @Todo(exception type)
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/exception/except_star.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/exception/except_star.md
@@ -1,66 +1,30 @@
-# `except*`
+# Except star

-`except*` is only available in Python 3.11 and later:
-
-```toml
-[environment]
-python-version = "3.11"
-```
-
-## `except*` with `BaseException`
+## 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: more precise would be `ExceptionGroup[OSError]` --Alex
-    # (needs homogenous tuples + generics)
+    # TODO(Alex): more precise would be `ExceptionGroup[OSError]`
    reveal_type(e)  # revealed: BaseExceptionGroup
 ```

-## `except*` with multiple exceptions
+## Except\* with multiple exceptions

 ```py
 try:
    help()
 except* (TypeError, AttributeError) as e:
-    # 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
+    # TODO(Alex): more precise would be `ExceptionGroup[TypeError | AttributeError]`.
    reveal_type(e)  # revealed: BaseExceptionGroup
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/exception/invalid_syntax.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/exception/invalid_syntax.md
@@ -9,4 +9,5 @@ try:
    print
 except as e:  # error: [invalid-syntax]
    reveal_type(e)  # revealed: Unknown
+
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/expression/attribute.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/expression/attribute.md
@@ -3,25 +3,26 @@
 ## Boundness

 ```py
-def _(flag: bool):
-    class A:
-        always_bound = 1
+def flag() -> bool: ...

-        if flag:
-            union = 1
-        else:
-            union = "abc"
+class A:
+    always_bound = 1

-        if flag:
-            possibly_unbound = "abc"
+    if flag():
+        union = 1
+    else:
+        union = "abc"

-    reveal_type(A.always_bound)  # revealed: Literal[1]
+    if flag():
+        possibly_unbound = "abc"

-    reveal_type(A.union)  # revealed: Literal[1] | Literal["abc"]
+reveal_type(A.always_bound)  # revealed: Literal[1]

-    # error: [possibly-unbound-attribute] "Attribute `possibly_unbound` on type `Literal[A]` is possibly unbound"
-    reveal_type(A.possibly_unbound)  # revealed: Literal["abc"]
+reveal_type(A.union)  # revealed: Literal[1] | Literal["abc"]

-    # error: [unresolved-attribute] "Type `Literal[A]` has no attribute `non_existent`"
-    reveal_type(A.non_existent)  # revealed: Unknown
+# 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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/expression/boolean.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/expression/boolean.md
@@ -3,45 +3,54 @@
 ## OR

 ```py
-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 & ~AlwaysFalsy | Literal[False]
-    reveal_type(foo or True)  # revealed: str & ~AlwaysFalsy | Literal[True]
+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]
 ```

 ## AND

 ```py
-def _(foo: str):
-    reveal_type(True and False)  # revealed: Literal[False]
-    reveal_type(False and True)  # revealed: Literal[False]
-    reveal_type(foo and False)  # revealed: str & ~AlwaysTruthy | Literal[False]
-    reveal_type(foo and True)  # revealed: str & ~AlwaysTruthy | Literal[True]
-    reveal_type("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:
+    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[""]
 ```

 ## Simple function calls to bool

 ```py
-def _(flag: bool):
-    if flag:
-        x = True
-    else:
-        x = False
+def returns_bool() -> bool:
+    return True

-    reveal_type(x)  # revealed: bool
+if returns_bool():
+    x = True
+else:
+    x = False
+
+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"]
--- a/crates/red_knot_python_semantic/resources/mdtest/expression/if.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/expression/if.md
@@ -3,11 +3,13 @@
 ## Union

 ```py
-def _(flag: bool):
-    reveal_type(1 if flag else 2)  # revealed: Literal[1, 2]
+def bool_instance() -> bool:
+    return True
+
+reveal_type(1 if bool_instance() else 2)  # revealed: Literal[1, 2]
 ```

-## Statically known conditions in if-expressions
+## Statically known branches

 ```py
 reveal_type(1 if True else 2)  # revealed: Literal[1]
@@ -28,12 +30,14 @@ reveal_type(1 if 0 else 2)  # revealed: Literal[2]
 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"
+def bool_instance() -> bool:
+    return True

-    reveal_type(x)  # revealed: Literal[42] | Literal["hello"]
+x: Literal[42, "hello"] = 42 if bool_instance() else "hello"

-    _ = ... if isinstance(x, str) else ...
+reveal_type(x)  # revealed: Literal[42] | Literal["hello"]

-    reveal_type(x)  # revealed: Literal[42] | Literal["hello"]
+_ = ... if isinstance(x, str) else ...
+
+reveal_type(x)  # revealed: Literal[42] | Literal["hello"]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/expression/len.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/expression/len.md
@@ -211,7 +211,8 @@ reveal_type(len(SecondRequiredArgument()))  # revealed: Literal[1]
 ### No `__len__`

 ```py
-class NoDunderLen: ...
+class NoDunderLen:
+    pass

 # TODO: Emit a diagnostic
 reveal_type(len(NoDunderLen()))  # revealed: int
--- a/crates/red_knot_python_semantic/resources/mdtest/final.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/final.md
@@ -1,31 +0,0 @@
-# Tests for the `@typing(_extensions).final` decorator
-
-## Cannot subclass
-
-Don't do this:
-
-```py
-import typing_extensions
-from typing import final
-
-@final
-class A: ...
-
-class B(A): ...  # error: 9 [subclass-of-final-class] "Class `B` cannot inherit from final class `A`"
-
-@typing_extensions.final
-class C: ...
-
-class D(C): ...  # error: [subclass-of-final-class]
-class E: ...
-class F: ...
-class G: ...
-
-# fmt: off
-class H(
-    E,
-    F,
-    A,  # error: [subclass-of-final-class]
-    G,
-): ...
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/import/basic.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/import/basic.md
@@ -25,82 +25,3 @@ 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
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/import/builtins.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/import/builtins.md
@@ -3,6 +3,6 @@
 ```py
 import builtins

-x = builtins.chr
-reveal_type(x)  # revealed: Literal[chr]
+x = builtins.copyright
+reveal_type(x)  # revealed: Literal[copyright]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/import/conditional.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/import/conditional.md
@@ -3,10 +3,11 @@
 ## Maybe unbound

 ```py path=maybe_unbound.py
-def coinflip() -> bool:
+def bool_instance() -> bool:
    return True

-if coinflip():
+flag = bool_instance()
+if flag:
    y = 3

 x = y  # error: [possibly-unresolved-reference]
@@ -30,12 +31,13 @@ reveal_type(y)  # revealed: Literal[3]
 ## Maybe unbound annotated

 ```py path=maybe_unbound_annotated.py
-def coinflip() -> bool:
+def bool_instance() -> bool:
    return True

-if coinflip():
-    y: int = 3
+flag = bool_instance()

+if flag:
+    y: int = 3
 x = y  # error: [possibly-unresolved-reference]

 # revealed: Literal[3]
@@ -61,10 +63,10 @@ reveal_type(y)  # revealed: int
 Importing a possibly undeclared name still gives us its declared type:

 ```py path=maybe_undeclared.py
-def coinflip() -> bool:
+def bool_instance() -> bool:
    return True

-if coinflip():
+if bool_instance():
    x: int
 ```

@@ -81,12 +83,14 @@ def f(): ...
 ```

 ```py path=b.py
-def coinflip() -> bool:
+def bool_instance() -> bool:
    return True

-if coinflip():
+flag = bool_instance()
+if flag:
    from c import f
 else:
+
    def f(): ...
 ```

@@ -107,10 +111,11 @@ x: int
 ```

 ```py path=b.py
-def coinflip() -> bool:
+def bool_instance() -> bool:
    return True

-if coinflip():
+flag = bool_instance()
+if flag:
    from c import x
 else:
    x = 1
--- a/crates/red_knot_python_semantic/resources/mdtest/import/conflicts.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/import/conflicts.md
@@ -1,75 +0,0 @@
-# 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
--- a/crates/red_knot_python_semantic/resources/mdtest/import/invalid_syntax.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/import/invalid_syntax.md
@@ -7,25 +7,3 @@ 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
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/import/relative.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/import/relative.md
@@ -121,44 +121,23 @@ X = 42
 ```

 ```py path=package/bar.py
-from . import foo
+# TODO: support submodule imports
+from . import foo  # error: [unresolved-import]

-reveal_type(foo.X)  # revealed: Literal[42]
+y = foo.X
+
+# TODO: should be `Literal[42]`
+reveal_type(y)  # revealed: Unknown
 ```

 ## 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
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/import/tracking.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/import/tracking.md
@@ -1,100 +0,0 @@
-# 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
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/known_constants.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/known_constants.md
@@ -1,52 +0,0 @@
-# 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]
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/literal/ellipsis.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/literal/ellipsis.md
@@ -1,23 +1,7 @@
 # Ellipsis literals

-## Python 3.9
-
-```toml
-[environment]
-python-version = "3.9"
-```
+## Simple

 ```py
-reveal_type(...)  # revealed: ellipsis
-```
-
-## Python 3.10
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-reveal_type(...)  # revealed: EllipsisType
+reveal_type(...)  # revealed: EllipsisType | ellipsis
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/literal.md
+++ b/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-type-form]
+# error: [invalid-literal-parameter]
 invalid1: Literal[3 + 4]
-# error: [invalid-type-form]
+# error: [invalid-literal-parameter]
 invalid2: Literal[4 + 3j]
-# error: [invalid-type-form]
+# error: [invalid-literal-parameter]
 invalid3: Literal[(3, 4)]

 hello = "hello"
 invalid4: Literal[
-    1 + 2,  # error: [invalid-type-form]
+    1 + 2,  # error: [invalid-literal-parameter]
    "foo",
-    hello,  # error: [invalid-type-form]
-    (1, 2, 3),  # error: [invalid-type-form]
+    hello,  # error: [invalid-literal-parameter]
+    (1, 2, 3),  # error: [invalid-literal-parameter]
 ]
 ```

@@ -91,13 +91,3 @@ 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
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/loops/for.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/loops/for.md
@@ -106,19 +106,23 @@ reveal_type(x)
 ## With non-callable iterator

 ```py
-def _(flag: bool):
-    class NotIterable:
-        if flag:
-            __iter__ = 1
-        else:
-            __iter__ = None
+def bool_instance() -> bool:
+    return True

-    for x in NotIterable():  # error: "Object of type `NotIterable` is not iterable"
-        pass
+flag = bool_instance()

-    # revealed: Unknown
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)
+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)
 ```

 ## Invalid iterable
@@ -156,9 +160,13 @@ class Test2:
    def __iter__(self) -> TestIter:
        return TestIter()

-def _(flag: bool):
-    for x in Test() if flag else Test2():
-        reveal_type(x)  # revealed: int
+def bool_instance() -> bool:
+    return True
+
+flag = bool_instance()
+
+for x in Test() if flag else Test2():
+    reveal_type(x)  # revealed: int
 ```

 ## Union type as iterator
@@ -207,9 +215,13 @@ class Test2:
    def __iter__(self) -> TestIter3 | TestIter4:
        return TestIter3()

-def _(flag: bool):
-    for x in Test() if flag else Test2():
-        reveal_type(x)  # revealed: int | Exception | str | tuple[int, int] | bytes | memoryview
+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
 ```

 ## Union type as iterable where one union element has no `__iter__` method
@@ -223,10 +235,12 @@ class Test:
    def __iter__(self) -> TestIter:
        return TestIter()

-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
+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
 ```

 ## Union type as iterable where one union element has invalid `__iter__` method
@@ -244,10 +258,12 @@ class Test2:
    def __iter__(self) -> int:
        return 42

-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
+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
 ```

 ## Union type as iterator where one union element has no `__next__` method
--- a/crates/red_knot_python_semantic/resources/mdtest/loops/while_loop.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/loops/while_loop.md
@@ -1,50 +1,59 @@
 # While loops

-## Basic `while` loop
+## Basic While Loop

 ```py
-def _(flag: bool):
-    x = 1
-    while flag:
-        x = 2
+def bool_instance() -> bool:
+    return True

+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` (no `break`)
+## While with Else (may break)

 ```py
-def _(flag: bool):
-    x = 1
-    while flag:
-        x = 2
-    else:
-        reveal_type(x)  # revealed: Literal[1, 2]
-        x = 3
+def bool_instance() -> bool:
+    return True

-    reveal_type(x)  # revealed: Literal[3]
+flag, flag2 = bool_instance(), bool_instance()
+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]
 ```

-## `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
+## Nested while loops

 ```py
 def flag() -> bool:
@@ -69,50 +78,3 @@ else:

 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
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/mdtest_config.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/mdtest_config.md
@@ -5,7 +5,7 @@ The following configuration will be attached to the *root* section (without any

 ```toml
 [environment]
-python-version = "3.10"
+target-version = "3.10"
 ```

 # Basic
@@ -34,7 +34,7 @@ Here, we make sure that we can overwrite the global configuration in a child sec

 ```toml
 [environment]
-python-version = "3.11"
+target-version = "3.11"
 ```

 ```py
@@ -55,7 +55,7 @@ Children in this section should all use the section configuration:

 ```toml
 [environment]
-python-version = "3.12"
+target-version = "3.12"
 ```

 ## Child
--- a/crates/red_knot_python_semantic/resources/mdtest/metaclass.md
+++ b/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: type[Unknown]
+reveal_type(C.__class__)  # revealed: 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: type[Unknown]
+reveal_type(B.__class__)  # revealed: 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: type[Unknown]
+reveal_type(D.__class__)  # revealed: Unknown
 ```

 ## Unknown
@@ -183,7 +183,7 @@ 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: type[Unknown]
+reveal_type(A.__class__)  # revealed: Unknown
 ```

 ## PEP 695 generic
@@ -194,26 +194,3 @@ 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__)
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/bool-call.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/bool-call.md
@@ -1,32 +1,32 @@
 ## Narrowing for `bool(..)` checks

 ```py
-def _(flag: bool):
+def flag() -> bool: ...

-    x = 1 if flag else None
+x = 1 if flag() else None

-    # valid invocation, positive
+# 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
-    if bool(x is not None):
-        reveal_type(x)  # revealed: Literal[1]

-    # valid invocation, negative
+# 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
-    if not bool(x is not None):
-        reveal_type(x)  # revealed: None

-    # no args/narrowing
+# 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
-    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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/boolean.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/boolean.md
@@ -9,67 +9,85 @@ Similarly, in `and` expressions, the right-hand side is evaluated only if the le
 ## Narrowing in `or`

 ```py
-def _(flag: bool):
-    class A: ...
-    x: A | None = A() if flag else None
+def bool_instance() -> bool:
+    return True

-    isinstance(x, A) or reveal_type(x)  # revealed: None
-    x is None or reveal_type(x)  # revealed: A
-    reveal_type(x)  # revealed: A | 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
 ```

 ## Narrowing in `and`

 ```py
-def _(flag: bool):
-    class A: ...
-    x: A | None = A() if flag else None
+def bool_instance() -> bool:
+    return True

-    isinstance(x, A) and reveal_type(x)  # revealed: A
-    x is None and reveal_type(x)  # revealed: None
-    reveal_type(x)  # revealed: A | 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
 ```

 ## Multiple `and` arms

 ```py
-def _(flag1: bool, flag2: bool, flag3: bool, flag4: bool):
-    class A: ...
-    x: A | None = A() if flag1 else None
+def bool_instance() -> bool:
+    return True

-    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
+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
 ```

 ## Multiple `or` arms

 ```py
-def _(flag1: bool, flag2: bool, flag3: bool, flag4: bool):
-    class A: ...
-    x: A | None = A() if flag1 else None
+def bool_instance() -> bool:
+    return True

-    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
+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
 ```

 ## Multiple predicates

 ```py
-def _(flag1: bool, flag2: bool):
-    class A: ...
-    x: A | None | Literal[1] = A() if flag1 else None if flag2 else 1
+def bool_instance() -> bool:
+    return True

-    x is None or isinstance(x, A) or reveal_type(x)  # revealed: Literal[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]
 ```

 ## Mix of `and` and `or`

 ```py
-def _(flag1: bool, flag2: bool):
-    class A: ...
-    x: A | None | Literal[1] = A() if flag1 else None if flag2 else 1
+def bool_instance() -> bool:
+    return True

-    isinstance(x, A) or x is not None and reveal_type(x)  # revealed: Literal[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]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/boolean.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/boolean.md
@@ -6,11 +6,15 @@
 class A: ...
 class 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
+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
 ```

 ## Arms might not add narrowing constraints
@@ -19,18 +23,25 @@ def _(x: A | B):
 class A: ...
 class B: ...

-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 bool_instance() -> bool:
+    return True

-    if flag and isinstance(x, A):
-        reveal_type(x)  # revealed: A
-    else:
-        reveal_type(x)  # revealed: A | B
+def instance() -> A | B:
+    return A()

+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
@@ -39,35 +50,39 @@ def _(flag: bool, x: A | B):
 class A: ...
 class B: ...

-def _(x: A | B):
-    if isinstance(x, A) and True:
-        reveal_type(x)  # revealed: A
-    else:
-        reveal_type(x)  # revealed: B & ~A
+def instance() -> A | B:
+    return A()

-    if True and isinstance(x, A):
-        reveal_type(x)  # revealed: A
-    else:
-        reveal_type(x)  # revealed: B & ~A
+x = instance()

-    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 isinstance(x, A) and True:
+    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 True and isinstance(x, A):
+    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 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
@@ -76,17 +91,22 @@ def _(x: A | B):
 class A: ...
 class B: ...

-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
+def instance() -> A | B:
+    return A()

+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
@@ -96,11 +116,15 @@ class A: ...
 class B: ...
 class C: ...

-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
+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
 ```

 ## In `or`, all arms should add constraint in order to narrow
@@ -110,11 +134,18 @@ class A: ...
 class B: ...
 class C: ...

-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
+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
 ```

 ## in `or`, all arms should narrow the same set of symbols
@@ -124,23 +155,28 @@ class A: ...
 class B: ...
 class C: ...

-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
+def instance() -> A | B | C:
+    return 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
+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
 ```

 ## mixing `and` and `not`
@@ -150,12 +186,16 @@ class A: ...
 class B: ...
 class 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
+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
 ```

 ## mixing `or` and `not`
@@ -165,11 +205,15 @@ class A: ...
 class B: ...
 class C: ...

-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
+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
 ```

 ## `or` with nested `and`
@@ -179,12 +223,16 @@ class A: ...
 class B: ...
 class C: ...

-def _(x: A | B | C):
-    if isinstance(x, A) or (isinstance(x, B) and not isinstance(x, C)):
-        reveal_type(x)  # revealed:  A | B & ~C
-    else:
-        # ~(A | (B & ~C)) -> ~A & ~(B & ~C) -> ~A & (~B | C) -> (~A & C) | (~A ~ B)
-        reveal_type(x)  # revealed:  C & ~A
+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
 ```

 ## `and` with nested `or`
@@ -194,32 +242,41 @@ class A: ...
 class B: ...
 class C: ...

-def _(x: A | B | C):
-    if isinstance(x, A) and (isinstance(x, B) or not isinstance(x, C)):
-        # A & (B | ~C) -> (A & B) | (A & ~C)
-        reveal_type(x)  # revealed:  A & B | A & ~C
-    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 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
 ```

 ## Boolean expression internal narrowing

 ```py
-def _(x: str | None, y: str | None):
-    if x is None and y is not x:
-        reveal_type(y)  # revealed: str
+def optional_string() -> str | None:
+    return None

-    # Neither of the conditions alone is sufficient for narrowing y's type:
-    if x is None:
-        reveal_type(y)  # revealed: str | None
+x = optional_string()
+y = optional_string()

-    if y is not x:
-        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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/elif_else.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/elif_else.md
@@ -3,47 +3,55 @@
 ## Positive contributions become negative in elif-else blocks

 ```py
-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]
+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]
 ```

 ## Positive contributions become negative in elif-else blocks, with simplification

 ```py
-def _(flag1: bool, flag2: bool):
-    x = 1 if flag1 else 2 if flag2 else 3
+def bool_instance() -> bool:
+    return True

-    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]
+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]
 ```

 ## Multiple negative contributions using elif, with simplification

 ```py
-def _(flag1: bool, flag2: bool):
-    x = 1 if flag1 else 2 if flag2 else 3
+def bool_instance() -> bool:
+    return True

-    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]
+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]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/is.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/is.md
@@ -3,64 +3,77 @@
 ## `is None`

 ```py
-def _(flag: bool):
-    x = None if flag else 1
+def bool_instance() -> bool:
+    return True

-    if x is None:
-        reveal_type(x)  # revealed: None
-    else:
-        reveal_type(x)  # revealed: Literal[1]
+flag = bool_instance()
+x = None if flag else 1

-    reveal_type(x)  # revealed: None | 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]
 ```

 ## `is` for other types

 ```py
-def _(flag: bool):
-    class A: ...
-    x = A()
-    y = x if flag else None
+def bool_instance() -> bool:
+    return True

-    if y is x:
-        reveal_type(y)  # revealed: A
-    else:
-        reveal_type(y)  # revealed: A | None
+flag = bool_instance()

+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 _(x_flag: bool, y_flag: bool):
-    x = True if x_flag else False
-    y = True if y_flag else False
+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 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 _(flag1: bool, flag2: bool):
-    x = None if flag1 else (1 if flag2 else True)
+def bool_instance() -> bool:
+    return 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]
+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]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/is_not.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/is_not.md
@@ -5,28 +5,34 @@
 The type guard removes `None` from the union type:

 ```py
-def _(flag: bool):
-    x = None if flag else 1
+def bool_instance() -> bool:
+    return True

-    if x is not None:
-        reveal_type(x)  # revealed: Literal[1]
-    else:
-        reveal_type(x)  # revealed: None
+flag = bool_instance()
+x = None if flag else 1

-    reveal_type(x)  # revealed: None | Literal[1]
+if x is not None:
+    reveal_type(x)  # revealed: Literal[1]
+else:
+    reveal_type(x)  # revealed: None
+
+reveal_type(x)  # revealed: None | Literal[1]
 ```

 ## `is not` for other singleton types

 ```py
-def _(flag: bool):
-    x = True if flag else False
-    reveal_type(x)  # revealed: bool
+def bool_instance() -> bool:
+    return True

-    if x is not False:
-        reveal_type(x)  # revealed: Literal[True]
-    else:
-        reveal_type(x)  # revealed: Literal[False]
+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]
 ```

 ## `is not` for non-singleton types
@@ -47,17 +53,20 @@ else:
 ## `is not` for other types

 ```py
-def _(flag: bool):
-    class A: ...
-    x = A()
-    y = x if flag else None
+def bool_instance() -> bool:
+    return True

-    if y is not x:
-        reveal_type(y)  # revealed: A | None
-    else:
-        reveal_type(y)  # revealed: A
+class 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
@@ -65,20 +74,23 @@ def _(flag: bool):
 The type guard removes `False` from the union type of the tested value only.

 ```py
-def _(x_flag: bool, y_flag: bool):
-    x = True if x_flag else False
-    y = True if y_flag else False
+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

    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
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/nested.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/nested.md
@@ -3,45 +3,54 @@
 ## Multiple negative contributions

 ```py
-def _(x: int):
-    if x != 1:
-        if x != 2:
-            if x != 3:
-                reveal_type(x)  # revealed: int & ~Literal[1] & ~Literal[2] & ~Literal[3]
+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]
 ```

 ## Multiple negative contributions with simplification

 ```py
-def _(flag1: bool, flag2: bool):
-    x = 1 if flag1 else 2 if flag2 else 3
+def bool_instance() -> bool:
+    return True

-    if x != 1:
-        reveal_type(x)  # revealed: Literal[2, 3]
-        if x != 2:
-            reveal_type(x)  # revealed: Literal[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]
 ```

 ## elif-else blocks

 ```py
-def _(flag1: bool, flag2: bool):
-    x = 1 if flag1 else 2 if flag2 else 3
+def bool_instance() -> bool:
+    return True

-    if x != 1:
+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]`
        reveal_type(x)  # revealed: Literal[2, 3]
-        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]
+    elif x == 3:
+        reveal_type(x)  # revealed: Literal[3]
    else:
-        # TODO should be Never
-        reveal_type(x)  # revealed: Literal[1, 2, 3]
+        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]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/not.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/not.md
@@ -5,25 +5,29 @@ The `not` operator negates a constraint.
 ## `not is None`

 ```py
-def _(flag: bool):
-    x = None if flag else 1
+def bool_instance() -> bool:
+    return True

-    if not x is None:
-        reveal_type(x)  # revealed: Literal[1]
-    else:
-        reveal_type(x)  # revealed: None
+x = None if bool_instance() else 1

-    reveal_type(x)  # revealed: None | Literal[1]
+if not x is None:
+    reveal_type(x)  # revealed: Literal[1]
+else:
+    reveal_type(x)  # revealed: None
+
+reveal_type(x)  # revealed: None | Literal[1]
 ```

 ## `not isinstance`

 ```py
-def _(flag: bool):
-    x = 1 if flag else "a"
+def bool_instance() -> bool:
+    return True

-    if not isinstance(x, (int)):
-        reveal_type(x)  # revealed: Literal["a"]
-    else:
-        reveal_type(x)  # revealed: Literal[1]
+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]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/not_eq.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/not_eq.md
@@ -3,66 +3,82 @@
 ## `x != None`

 ```py
-def _(flag: bool):
-    x = None if flag else 1
+def bool_instance() -> bool:
+    return True

-    if x != None:
-        reveal_type(x)  # revealed: Literal[1]
-    else:
-        # TODO should be None
-        reveal_type(x)  # revealed: None | Literal[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]
 ```

 ## `!=` for other singleton types

 ```py
-def _(flag: bool):
-    x = True if flag else False
+def bool_instance() -> bool:
+    return True

-    if x != False:
-        reveal_type(x)  # revealed: Literal[True]
-    else:
-        # TODO should be Literal[False]
-        reveal_type(x)  # revealed: bool
+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
 ```

 ## `x != y` where `y` is of literal type

 ```py
-def _(flag: bool):
-    x = 1 if flag else 2
+def bool_instance() -> bool:
+    return True

-    if x != 1:
-        reveal_type(x)  # revealed: Literal[2]
+flag = bool_instance()
+x = 1 if flag else 2
+
+if x != 1:
+    reveal_type(x)  # revealed: Literal[2]
 ```

 ## `x != y` where `y` is a single-valued type

 ```py
-def _(flag: bool):
-    class A: ...
-    class B: ...
-    C = A if flag else B
+def bool_instance() -> bool:
+    return True

-    if C != A:
-        reveal_type(C)  # revealed: Literal[B]
-    else:
-        # TODO should be Literal[A]
-        reveal_type(C)  # revealed: Literal[A, 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]
 ```

 ## `x != y` where `y` has multiple single-valued options

 ```py
-def _(flag1: bool, flag2: bool):
-    x = 1 if flag1 else 2
-    y = 2 if flag2 else 3
+def bool_instance() -> bool:
+    return True

-    if x != y:
-        reveal_type(x)  # revealed: Literal[1, 2]
-    else:
-        # TODO should be Literal[2]
-        reveal_type(x)  # revealed: Literal[1, 2]
+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]
 ```

 ## `!=` for non-single-valued types
@@ -70,22 +86,34 @@ def _(flag1: bool, flag2: bool):
 Only single-valued types should narrow the type:

 ```py
-def _(flag: bool, a: int, y: int):
-    x = a if flag else None
+def bool_instance() -> bool:
+    return True

-    if x != y:
-        reveal_type(x)  # revealed: int | 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
 ```

 ## Mix of single-valued and non-single-valued types

 ```py
-def _(flag1: bool, flag2: bool, a: int):
-    x = 1 if flag1 else 2
-    y = 2 if flag2 else a
+def int_instance() -> int:
+    return 42

-    if x != y:
-        reveal_type(x)  # revealed: Literal[1, 2]
-    else:
-        reveal_type(x)  # revealed: Literal[1, 2]
+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]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/isinstance.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/isinstance.md
@@ -5,19 +5,23 @@ Narrowing for `isinstance(object, classinfo)` expressions.
 ## `classinfo` is a single type

 ```py
-def _(flag: bool):
-    x = 1 if flag else "a"
+def bool_instance() -> bool:
+    return True

+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: Literal[1]
+        reveal_type(x)  # revealed: Never

-    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"]
+if isinstance(x, (int, object)):
+    reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```

 ## `classinfo` is a tuple of types
@@ -26,48 +30,56 @@ Note: `isinstance(x, (int, str))` should not be confused with `isinstance(x, tup
 The former is equivalent to `isinstance(x, int | str)`:

 ```py
-def _(flag: bool, flag1: bool, flag2: bool):
-    x = 1 if flag else "a"
+def bool_instance() -> bool:
+    return True

-    if isinstance(x, (int, str)):
-        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
-    else:
-        reveal_type(x)  # revealed: Never
+flag, flag1, flag2 = bool_instance(), bool_instance(), bool_instance()

-    if isinstance(x, (int, bytes)):
-        reveal_type(x)  # revealed: Literal[1]
+x = 1 if flag else "a"

-    if isinstance(x, (bytes, str)):
-        reveal_type(x)  # revealed: Literal["a"]
+if isinstance(x, (int, str)):
+    reveal_type(x)  # revealed: Literal[1] | Literal["a"]
+else:
+    reveal_type(x)  # revealed: Never

-    # 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, (int, bytes)):
+    reveal_type(x)  # revealed: Literal[1]

-    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(x, (bytes, str)):
+    reveal_type(x)  # revealed: Literal["a"]

-    if isinstance(y, (int, bytes)):
-        reveal_type(y)  # revealed: Literal[1] | Literal[b"b"]
+# 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, (str, bytes)):
-        reveal_type(y)  # revealed: Literal["a"] | 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"]
 ```

 ## `classinfo` is a nested tuple of types

 ```py
-def _(flag: bool):
-    x = 1 if flag else "a"
+def bool_instance() -> bool:
+    return True

-    if isinstance(x, (bool, (bytes, int))):
-        reveal_type(x)  # revealed: Literal[1]
-    else:
-        reveal_type(x)  # revealed: Literal["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"]
 ```

 ## Class types
@@ -77,7 +89,9 @@ class A: ...
 class B: ...
 class C: ...

-x = object()
+def get_object() -> object: ...
+
+x = get_object()

 if isinstance(x, A):
    reveal_type(x)  # revealed: A
@@ -98,40 +112,50 @@ else:
 ## No narrowing for instances of `builtins.type`

 ```py
-def _(flag: bool):
-    t = type("t", (), {})
+def bool_instance() -> bool:
+    return True

-    # This isn't testing what we want it to test if we infer anything more precise here:
-    reveal_type(t)  # revealed: type
+flag = bool_instance()

-    x = 1 if flag else "foo"
+t = type("t", (), {})

-    if isinstance(x, t):
-        reveal_type(x)  # revealed: Literal[1] | Literal["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"]
 ```

 ## Do not use custom `isinstance` for narrowing

 ```py
-def _(flag: bool):
-    def isinstance(x, t):
-        return True
-    x = 1 if flag else "a"
+def bool_instance() -> bool:
+    return True

-    if isinstance(x, int):
-        reveal_type(x)  # revealed: Literal[1] | Literal["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"]
 ```

 ## Do support narrowing if `isinstance` is aliased

 ```py
-def _(flag: bool):
-    isinstance_alias = isinstance
+def bool_instance() -> bool:
+    return True

-    x = 1 if flag else "a"
+flag = bool_instance()

-    if isinstance_alias(x, int):
-        reveal_type(x)  # revealed: Literal[1]
+isinstance_alias = isinstance
+
+x = 1 if flag else "a"
+if isinstance_alias(x, int):
+    reveal_type(x)  # revealed: Literal[1]
 ```

 ## Do support narrowing if `isinstance` is imported
@@ -139,38 +163,46 @@ def _(flag: bool):
 ```py
 from builtins import isinstance as imported_isinstance

-def _(flag: bool):
-    x = 1 if flag else "a"
+def bool_instance() -> bool:
+    return True

-    if imported_isinstance(x, int):
-        reveal_type(x)  # revealed: Literal[1]
+flag = bool_instance()
+x = 1 if flag else "a"
+if imported_isinstance(x, int):
+    reveal_type(x)  # revealed: Literal[1]
 ```

 ## Do not narrow if second argument is not a type

 ```py
-def _(flag: bool):
-    x = 1 if flag else "a"
+def bool_instance() -> bool:
+    return True

-    # TODO: this should cause us to emit a diagnostic during
-    # type checking
-    if isinstance(x, "a"):
-        reveal_type(x)  # revealed: Literal[1] | Literal["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, "int"):
-        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"]
 ```

 ## Do not narrow if there are keyword arguments

 ```py
-def _(flag: bool):
-    x = 1 if flag else "a"
+def bool_instance() -> bool:
+    return True

-    # 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"]
+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"]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/issubclass.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/issubclass.md
@@ -7,43 +7,45 @@ Narrowing for `issubclass(class, classinfo)` expressions.
 ### Basic example

 ```py
-def _(flag: bool):
-    t = int if flag else str
+def flag() -> bool: ...

-    if issubclass(t, bytes):
-        reveal_type(t)  # revealed: Never
+t = int if flag() else str

-    if issubclass(t, object):
-        reveal_type(t)  # revealed: Literal[int, 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):
-        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
+        reveal_type(t)  # revealed: Never
 ```

 ### Proper narrowing in `elif` and `else` branches

 ```py
-def _(flag1: bool, flag2: bool):
-    t = int if flag1 else str if flag2 else bytes
+def flag() -> bool: ...

-    if issubclass(t, int):
-        reveal_type(t)  # revealed: Literal[int]
-    else:
-        reveal_type(t)  # revealed: Literal[str, bytes]
+t = int if flag() else str if flag() else 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]
+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]
 ```

 ### Multiple derived classes
@@ -54,28 +56,29 @@ class Derived1(Base): ...
 class Derived2(Base): ...
 class Unrelated: ...

-def _(flag1: bool, flag2: bool, flag3: bool):
-    t1 = Derived1 if flag1 else Derived2
+def flag() -> bool: ...

-    if issubclass(t1, Base):
-        reveal_type(t1)  # revealed: Literal[Derived1, Derived2]
+t1 = Derived1 if flag() else Derived2

-    if issubclass(t1, Derived1):
-        reveal_type(t1)  # revealed: Literal[Derived1]
-    else:
-        reveal_type(t1)  # revealed: Literal[Derived2]
+if issubclass(t1, Base):
+    reveal_type(t1)  # revealed: Literal[Derived1, Derived2]

-    t2 = Derived1 if flag2 else Base
+if issubclass(t1, Derived1):
+    reveal_type(t1)  # revealed: Literal[Derived1]
+else:
+    reveal_type(t1)  # revealed: Literal[Derived2]

-    if issubclass(t2, Base):
-        reveal_type(t2)  # revealed: Literal[Derived1, Base]
+t2 = Derived1 if flag() else Base

-    t3 = Derived1 if flag3 else Unrelated
+if issubclass(t2, Base):
+    reveal_type(t2)  # revealed: Literal[Derived1, Base]

-    if issubclass(t3, Base):
-        reveal_type(t3)  # revealed: Literal[Derived1]
-    else:
-        reveal_type(t3)  # revealed: Literal[Unrelated]
+t3 = Derived1 if flag() else Unrelated
+
+if issubclass(t3, Base):
+    reveal_type(t3)  # revealed: Literal[Derived1]
+else:
+    reveal_type(t3)  # revealed: Literal[Unrelated]
 ```

 ### Narrowing for non-literals
@@ -84,36 +87,36 @@ def _(flag1: bool, flag2: bool, flag3: bool):
 class A: ...
 class B: ...

-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]
+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]
 ```

 ### Handling of `None`

-`types.NoneType` is only available in Python 3.10 and later:
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
 ```py
+# TODO: this error should ideally go away once we (1) understand `sys.version_info` branches,
+# and (2) set the target Python version for this test to 3.10.
+# error: [possibly-unbound-import] "Member `NoneType` of module `types` is possibly unbound"
 from types import NoneType

-def _(flag: bool):
-    t = int if flag else NoneType
+def flag() -> bool: ...

-    if issubclass(t, NoneType):
-        reveal_type(t)  # revealed: Literal[NoneType]
+t = int if flag() else NoneType

-    if issubclass(t, type(None)):
-        # TODO: this should be just `Literal[NoneType]`
-        reveal_type(t)  # revealed: Literal[int, 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]
 ```

 ## `classinfo` contains multiple types
@@ -123,13 +126,14 @@ def _(flag: bool):
 ```py
 class Unrelated: ...

-def _(flag1: bool, flag2: bool):
-    t = int if flag1 else str if flag2 else bytes
+def flag() -> bool: ...

-    if issubclass(t, (int, (Unrelated, (bytes,)))):
-        reveal_type(t)  # revealed: Literal[int, bytes]
-    else:
-        reveal_type(t)  # revealed: Literal[str]
+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]
 ```

 ## Special cases
@@ -144,7 +148,9 @@ to `issubclass`:
 ```py
 class A: ...

-t = object()
+def get_object() -> object: ...
+
+t = get_object()

 # TODO: we should emit a diagnostic here
 if issubclass(t, A):
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/match.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/match.md
@@ -3,16 +3,19 @@
 ## Single `match` pattern

 ```py
-def _(flag: bool):
-    x = None if flag else 1
+def bool_instance() -> bool:
+    return True

-    reveal_type(x)  # revealed: None | Literal[1]
+flag = bool_instance()

-    y = 0
+x = None if flag else 1
+reveal_type(x)  # revealed: None | Literal[1]

-    match x:
-        case None:
-            y = x
+y = 0

-    reveal_type(y)  # revealed: Literal[0] | None
+match x:
+    case None:
+        y = x
+
+reveal_type(y)  # revealed: Literal[0] | None
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/post_if_statement.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/post_if_statement.md
@@ -3,49 +3,62 @@
 ## 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
+def optional_int() -> int | None: ...

-    reveal_type(x)  # revealed: int | None
+x = optional_int()
+
+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
+def optional_int() -> int | None: ...

-    reveal_type(x)  # revealed: int
+x = optional_int()
+
+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
+def optional_int() -> int | None: ...

-    if y is None:
-        pass
+x = optional_int()
+y = optional_int()

-    reveal_type(x)  # revealed: int
-    reveal_type(y)  # revealed: 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
+def optional_int() -> int | None: ...

-    reveal_type(x)  # revealed: int
+x = optional_int()
+
+if x is None:
+    x = 0
+elif x > 50:
+    x = 50
+
+reveal_type(x)  # revealed: int
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/truthiness.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/truthiness.md
@@ -1,315 +0,0 @@
-# Narrowing For Truthiness Checks (`if x` or `if not x`)
-
-## Value Literals
-
-```py
-def foo() -> Literal[0, -1, True, False, "", "foo", b"", b"bar", None] | tuple[()]:
-    return 0
-
-x = foo()
-
-if x:
-    reveal_type(x)  # revealed: Literal[-1] | Literal[True] | Literal["foo"] | Literal[b"bar"]
-else:
-    reveal_type(x)  # revealed: Literal[0] | Literal[False] | Literal[""] | Literal[b""] | None | tuple[()]
-
-if not x:
-    reveal_type(x)  # revealed: Literal[0] | Literal[False] | Literal[""] | Literal[b""] | None | tuple[()]
-else:
-    reveal_type(x)  # revealed: Literal[-1] | Literal[True] | Literal["foo"] | Literal[b"bar"]
-
-if x and not x:
-    reveal_type(x)  # revealed: Never
-else:
-    reveal_type(x)  # revealed: Literal[-1, 0] | bool | Literal["", "foo"] | Literal[b"", b"bar"] | None | tuple[()]
-
-if not (x and not x):
-    reveal_type(x)  # revealed: Literal[-1, 0] | bool | Literal["", "foo"] | Literal[b"", b"bar"] | None | tuple[()]
-else:
-    reveal_type(x)  # revealed: Never
-
-if x or not x:
-    reveal_type(x)  # revealed: Literal[-1, 0] | bool | Literal["foo", ""] | Literal[b"bar", b""] | None | tuple[()]
-else:
-    reveal_type(x)  # revealed: Never
-
-if not (x or not x):
-    reveal_type(x)  # revealed: Never
-else:
-    reveal_type(x)  # revealed: Literal[-1, 0] | bool | Literal["foo", ""] | Literal[b"bar", b""] | None | tuple[()]
-
-if (isinstance(x, int) or isinstance(x, str)) and x:
-    reveal_type(x)  # revealed: Literal[-1] | Literal[True] | Literal["foo"]
-else:
-    reveal_type(x)  # revealed: Literal[b"", b"bar"] | None | tuple[()] | Literal[0] | Literal[False] | Literal[""]
-```
-
-## Function Literals
-
-Basically functions are always truthy.
-
-```py
-def flag() -> bool:
-    return True
-
-def foo(hello: int) -> bytes:
-    return b""
-
-def bar(world: str, *args, **kwargs) -> float:
-    return 0.0
-
-x = foo if flag() else bar
-
-if x:
-    reveal_type(x)  # revealed: Literal[foo, bar]
-else:
-    reveal_type(x)  # revealed: Never
-```
-
-## Mutable Truthiness
-
-### Truthiness of Instances
-
-The boolean value of an instance is not always consistent. For example, `__bool__` can be customized
-to return random values, or in the case of a `list()`, the result depends on the number of elements
-in the list. Therefore, these types should not be narrowed by `if x` or `if not x`.
-
-```py
-class A: ...
-class B: ...
-
-def f(x: A | B):
-    if x:
-        reveal_type(x)  # revealed: A & ~AlwaysFalsy | B & ~AlwaysFalsy
-    else:
-        reveal_type(x)  # revealed: A & ~AlwaysTruthy | B & ~AlwaysTruthy
-
-    if x and not x:
-        reveal_type(x)  # revealed: A & ~AlwaysFalsy & ~AlwaysTruthy | B & ~AlwaysFalsy & ~AlwaysTruthy
-    else:
-        reveal_type(x)  # revealed: A & ~AlwaysTruthy | B & ~AlwaysTruthy | A & ~AlwaysFalsy | B & ~AlwaysFalsy
-
-    if x or not x:
-        reveal_type(x)  # revealed: A & ~AlwaysFalsy | B & ~AlwaysFalsy | A & ~AlwaysTruthy | B & ~AlwaysTruthy
-    else:
-        reveal_type(x)  # revealed: A & ~AlwaysTruthy & ~AlwaysFalsy | B & ~AlwaysTruthy & ~AlwaysFalsy
-```
-
-### Truthiness of Types
-
-Also, types may not be Truthy. This is because `__bool__` can be customized via a metaclass.
-Although this is a very rare case, we may consider metaclass checks in the future to handle this
-more accurately.
-
-```py
-def flag() -> bool:
-    return True
-
-x = int if flag() else str
-reveal_type(x)  # revealed: Literal[int, str]
-
-if x:
-    reveal_type(x)  # revealed: Literal[int] & ~AlwaysFalsy | Literal[str] & ~AlwaysFalsy
-else:
-    reveal_type(x)  # revealed: Literal[int] & ~AlwaysTruthy | Literal[str] & ~AlwaysTruthy
-```
-
-## Determined Truthiness
-
-Some custom classes can have a boolean value that is consistently determined as either `True` or
-`False`, regardless of the instance's state. This is achieved by defining a `__bool__` method that
-always returns a fixed value.
-
-These types can always be fully narrowed in boolean contexts, as shown below:
-
-```py
-class T:
-    def __bool__(self) -> Literal[True]:
-        return True
-
-class F:
-    def __bool__(self) -> Literal[False]:
-        return False
-
-t = T()
-
-if t:
-    reveal_type(t)  # revealed: T
-else:
-    reveal_type(t)  # revealed: Never
-
-f = F()
-
-if f:
-    reveal_type(f)  # revealed: Never
-else:
-    reveal_type(f)  # revealed: F
-```
-
-## Narrowing Complex Intersection and Union
-
-```py
-class A: ...
-class B: ...
-
-def flag() -> bool:
-    return True
-
-def instance() -> A | B:
-    return A()
-
-def literals() -> Literal[0, 42, "", "hello"]:
-    return 42
-
-x = instance()
-y = literals()
-
-if isinstance(x, str) and not isinstance(x, B):
-    reveal_type(x)  # revealed: A & str & ~B
-    reveal_type(y)  # revealed: Literal[0, 42] | Literal["", "hello"]
-
-    z = x if flag() else y
-
-    reveal_type(z)  # revealed: A & str & ~B | Literal[0, 42] | Literal["", "hello"]
-
-    if z:
-        reveal_type(z)  # revealed: A & str & ~B & ~AlwaysFalsy | Literal[42] | Literal["hello"]
-    else:
-        reveal_type(z)  # revealed: A & str & ~B & ~AlwaysTruthy | Literal[0] | Literal[""]
-```
-
-## Narrowing Multiple Variables
-
-```py
-def f(x: Literal[0, 1], y: Literal["", "hello"]):
-    if x and y and not x and not y:
-        reveal_type(x)  # revealed: Never
-        reveal_type(y)  # revealed: Never
-    else:
-        # ~(x or not x) and ~(y or not y)
-        reveal_type(x)  # revealed: Literal[0, 1]
-        reveal_type(y)  # revealed: Literal["", "hello"]
-
-    if (x or not x) and (y and not y):
-        reveal_type(x)  # revealed: Literal[0, 1]
-        reveal_type(y)  # revealed: Never
-    else:
-        # ~(x or not x) or ~(y and not y)
-        reveal_type(x)  # revealed: Literal[0, 1]
-        reveal_type(y)  # revealed: Literal["", "hello"]
-```
-
-## ControlFlow Merging
-
-After merging control flows, when we take the union of all constraints applied in each branch, we
-should return to the original state.
-
-```py
-class A: ...
-
-x = A()
-
-if x and not x:
-    y = x
-    reveal_type(y)  # revealed: A & ~AlwaysFalsy & ~AlwaysTruthy
-else:
-    y = x
-    reveal_type(y)  # revealed: A & ~AlwaysTruthy | A & ~AlwaysFalsy
-
-# TODO: It should be A. We should improve UnionBuilder or IntersectionBuilder. (issue #15023)
-reveal_type(y)  # revealed: A & ~AlwaysTruthy | A & ~AlwaysFalsy
-```
-
-## Truthiness of classes
-
-```py
-class MetaAmbiguous(type):
-    def __bool__(self) -> bool: ...
-
-class MetaFalsy(type):
-    def __bool__(self) -> Literal[False]: ...
-
-class MetaTruthy(type):
-    def __bool__(self) -> Literal[True]: ...
-
-class MetaDeferred(type):
-    def __bool__(self) -> MetaAmbiguous: ...
-
-class AmbiguousClass(metaclass=MetaAmbiguous): ...
-class FalsyClass(metaclass=MetaFalsy): ...
-class TruthyClass(metaclass=MetaTruthy): ...
-class DeferredClass(metaclass=MetaDeferred): ...
-
-def _(
-    a: type[AmbiguousClass],
-    t: type[TruthyClass],
-    f: type[FalsyClass],
-    d: type[DeferredClass],
-    ta: type[TruthyClass | AmbiguousClass],
-    af: type[AmbiguousClass] | type[FalsyClass],
-    flag: bool,
-):
-    reveal_type(ta)  # revealed: type[TruthyClass] | type[AmbiguousClass]
-    if ta:
-        reveal_type(ta)  # revealed: type[TruthyClass] | type[AmbiguousClass] & ~AlwaysFalsy
-
-    reveal_type(af)  # revealed: type[AmbiguousClass] | type[FalsyClass]
-    if af:
-        reveal_type(af)  # revealed: type[AmbiguousClass] & ~AlwaysFalsy
-
-    # TODO: Emit a diagnostic (`d` is not valid in boolean context)
-    if d:
-        # TODO: Should be `Unknown`
-        reveal_type(d)  # revealed: type[DeferredClass] & ~AlwaysFalsy
-
-    tf = TruthyClass if flag else FalsyClass
-    reveal_type(tf)  # revealed: Literal[TruthyClass, FalsyClass]
-
-    if tf:
-        reveal_type(tf)  # revealed: Literal[TruthyClass]
-    else:
-        reveal_type(tf)  # revealed: Literal[FalsyClass]
-```
-
-## Narrowing in chained boolean expressions
-
-```py
-from typing import Literal
-
-class A: ...
-
-def _(x: Literal[0, 1]):
-    reveal_type(x or A())  # revealed: Literal[1] | A
-    reveal_type(x and A())  # revealed: Literal[0] | A
-
-def _(x: str):
-    reveal_type(x or A())  # revealed: str & ~AlwaysFalsy | A
-    reveal_type(x and A())  # revealed: str & ~AlwaysTruthy | A
-
-def _(x: bool | str):
-    reveal_type(x or A())  # revealed: Literal[True] | str & ~AlwaysFalsy | A
-    reveal_type(x and A())  # revealed: Literal[False] | str & ~AlwaysTruthy | A
-
-class Falsy:
-    def __bool__(self) -> Literal[False]: ...
-
-class Truthy:
-    def __bool__(self) -> Literal[True]: ...
-
-def _(x: Falsy | Truthy):
-    reveal_type(x or A())  # revealed: Truthy | A
-    reveal_type(x and A())  # revealed: Falsy | A
-
-class MetaFalsy(type):
-    def __bool__(self) -> Literal[False]: ...
-
-class MetaTruthy(type):
-    def __bool__(self) -> Literal[True]: ...
-
-class FalsyClass(metaclass=MetaFalsy): ...
-class TruthyClass(metaclass=MetaTruthy): ...
-
-def _(x: type[FalsyClass] | type[TruthyClass]):
-    reveal_type(x or A())  # revealed: type[TruthyClass] | A
-    reveal_type(x and A())  # revealed: type[FalsyClass] | A
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/type.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/type.md
@@ -6,14 +6,18 @@
 class A: ...
 class B: ...

-def _(x: A | B):
-    if type(x) is A:
-        reveal_type(x)  # revealed: A
-    else:
-        # It would be wrong to infer `B` here. The type
-        # of `x` could be a subclass of `A`, so we need
-        # to infer the full union type:
-        reveal_type(x)  # revealed: A | B
+def get_a_or_b() -> A | B:
+    return A()
+
+x = get_a_or_b()
+
+if type(x) is A:
+    reveal_type(x)  # revealed: A
+else:
+    # It would be wrong to infer `B` here. The type
+    # of `x` could be a subclass of `A`, so we need
+    # to infer the full union type:
+    reveal_type(x)  # revealed: A | B
 ```

 ## `type(x) is not C`
@@ -22,12 +26,16 @@ def _(x: A | B):
 class A: ...
 class B: ...

-def _(x: A | B):
-    if type(x) is not A:
-        # Same reasoning as above: no narrowing should occur here.
-        reveal_type(x)  # revealed: A | B
-    else:
-        reveal_type(x)  # revealed: A
+def get_a_or_b() -> A | B:
+    return A()
+
+x = get_a_or_b()
+
+if type(x) is not A:
+    # Same reasoning as above: no narrowing should occur here.
+    reveal_type(x)  # revealed: A | B
+else:
+    reveal_type(x)  # revealed: A
 ```

 ## `type(x) == C`, `type(x) != C`
@@ -46,12 +54,16 @@ class IsEqualToEverything(type):
 class A(metaclass=IsEqualToEverything): ...
 class B(metaclass=IsEqualToEverything): ...

-def _(x: A | B):
-    if type(x) == A:
-        reveal_type(x)  # revealed: A | B
+def get_a_or_b() -> A | B:
+    return B()

-    if type(x) != A:
-        reveal_type(x)  # revealed: A | B
+x = get_a_or_b()
+
+if type(x) == A:
+    reveal_type(x)  # revealed: A | B
+
+if type(x) != A:
+    reveal_type(x)  # revealed: A | B
 ```

 ## No narrowing for custom `type` callable
@@ -63,11 +75,15 @@ class B: ...
 def type(x):
    return int

-def _(x: A | B):
-    if type(x) is A:
-        reveal_type(x)  # revealed: A | B
-    else:
-        reveal_type(x)  # revealed: A | B
+def get_a_or_b() -> A | B:
+    return A()
+
+x = get_a_or_b()
+
+if type(x) is A:
+    reveal_type(x)  # revealed: A | B
+else:
+    reveal_type(x)  # revealed: A | B
 ```

 ## No narrowing for multiple arguments
@@ -75,11 +91,15 @@ def _(x: A | B):
 No narrowing should occur if `type` is used to dynamically create a class:

 ```py
-def _(x: str | int):
-    if type(x, (), {}) is str:
-        reveal_type(x)  # revealed: str | int
-    else:
-        reveal_type(x)  # revealed: str | int
+def get_str_or_int() -> str | int:
+    return "test"
+
+x = get_str_or_int()
+
+if type(x, (), {}) is str:
+    reveal_type(x)  # revealed: str | int
+else:
+    reveal_type(x)  # revealed: str | int
 ```

 ## No narrowing for keyword arguments
@@ -87,10 +107,14 @@ def _(x: str | int):
 `type` can't be used with a keyword argument:

 ```py
-def _(x: str | int):
-    # TODO: we could issue a diagnostic here
-    if type(object=x) is str:
-        reveal_type(x)  # revealed: str | int
+def get_str_or_int() -> str | int:
+    return "test"
+
+x = get_str_or_int()
+
+# TODO: we could issue a diagnostic here
+if type(object=x) is str:
+    reveal_type(x)  # revealed: str | int
 ```

 ## Narrowing if `type` is aliased
@@ -101,9 +125,13 @@ class B: ...

 alias_for_type = type

-def _(x: A | B):
-    if alias_for_type(x) is A:
-        reveal_type(x)  # revealed: A
+def get_a_or_b() -> A | B:
+    return A()
+
+x = get_a_or_b()
+
+if alias_for_type(x) is A:
+    reveal_type(x)  # revealed: A
 ```

 ## Limitations
@@ -112,9 +140,13 @@ def _(x: A | B):
 class Base: ...
 class Derived(Base): ...

-def _(x: Base):
-    if type(x) is Base:
-        # Ideally, this could be narrower, but there is now way to
-        # express a constraint like `Base & ~ProperSubtypeOf[Base]`.
-        reveal_type(x)  # revealed: Base
+def get_base() -> Base:
+    return Base()
+
+x = get_base()
+
+if type(x) is Base:
+    # Ideally, this could be narrower, but there is now way to
+    # express a constraint like `Base & ~ProperSubtypeOf[Base]`.
+    reveal_type(x)  # revealed: Base
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/while.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/while.md
@@ -1,58 +0,0 @@
-# Narrowing in `while` loops
-
-We only make sure that narrowing works for `while` loops in general, we do not exhaustively test all
-narrowing forms here, as they are covered in other tests.
-
-Note how type narrowing works subtly different from `if` ... `else`, because the negated constraint
-is retained after the loop.
-
-## Basic `while` loop
-
-```py
-def next_item() -> int | None: ...
-
-x = next_item()
-
-while x is not None:
-    reveal_type(x)  # revealed: int
-    x = next_item()
-
-reveal_type(x)  # revealed: None
-```
-
-## `while` loop with `else`
-
-```py
-def next_item() -> int | None: ...
-
-x = next_item()
-
-while x is not None:
-    reveal_type(x)  # revealed: int
-    x = next_item()
-else:
-    reveal_type(x)  # revealed: None
-
-reveal_type(x)  # revealed: None
-```
-
-## Nested `while` loops
-
-```py
-from typing import Literal
-
-def next_item() -> Literal[1, 2, 3]: ...
-
-x = next_item()
-
-while x != 1:
-    reveal_type(x)  # revealed: Literal[2, 3]
-
-    while x != 2:
-        # TODO: this should be Literal[1, 3]; Literal[3] is only correct
-        # in the first loop iteration
-        reveal_type(x)  # revealed: Literal[3]
-        x = next_item()
-
-    x = next_item()
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/scopes/builtin.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/scopes/builtin.md
@@ -10,10 +10,10 @@ def returns_bool() -> bool:
    return True

 if returns_bool():
-    chr = 1
+    copyright = 1

 def f():
-    reveal_type(chr)  # revealed: Literal[chr] | Literal[1]
+    reveal_type(copyright)  # revealed: Literal[copyright] | Literal[1]
 ```

 ## Conditionally global or builtin, with annotation
@@ -25,8 +25,8 @@ def returns_bool() -> bool:
    return True

 if returns_bool():
-    chr: int = 1
+    copyright: int = 1

 def f():
-    reveal_type(chr)  # revealed: Literal[chr] | int
+    reveal_type(copyright)  # revealed: Literal[copyright] | int
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/scopes/moduletype_attrs.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/scopes/moduletype_attrs.md
@@ -59,7 +59,7 @@ reveal_type(typing.__init__)  # revealed: Literal[__init__]
 # These come from `builtins.object`, not `types.ModuleType`:
 reveal_type(typing.__eq__)  # revealed: Literal[__eq__]

-reveal_type(typing.__class__)  # revealed: Literal[ModuleType]
+reveal_type(typing.__class__)  # revealed: Literal[type]

 # TODO: needs support for attribute access on instances, properties and generics;
 # should be `dict[str, Any]`
--- a/crates/red_knot_python_semantic/resources/mdtest/scopes/unbound.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/scopes/unbound.md
@@ -5,10 +5,10 @@
 Name lookups within a class scope fall back to globals, but lookups of class attributes don't.

 ```py
-def coinflip() -> bool:
+def bool_instance() -> bool:
    return True

-flag = coinflip()
+flag = bool_instance()
 x = 1

 class C:
@@ -24,14 +24,14 @@ reveal_type(C.y)  # revealed: Literal[1]
 ## Possibly unbound in class and global scope

 ```py
-def coinflip() -> bool:
+def bool_instance() -> bool:
    return True

-if coinflip():
+if bool_instance():
    x = "abc"

 class C:
-    if coinflip():
+    if bool_instance():
        x = 1

    # error: [possibly-unresolved-reference]
--- a/crates/red_knot_python_semantic/resources/mdtest/shadowing/function.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/shadowing/function.md
@@ -25,29 +25,3 @@ def f(): ...

 f: int = 1
 ```
-
-## Explicit shadowing involving `def` statements
-
-Since a `def` statement is a declaration, one `def` can shadow another `def`, or shadow a previous
-non-`def` declaration, without error.
-
-```py
-f = 1
-reveal_type(f)  # revealed: Literal[1]
-
-def f(): ...
-
-reveal_type(f)  # revealed: Literal[f]
-
-def f(x: int) -> int:
-    raise NotImplementedError
-
-reveal_type(f)  # revealed: Literal[f]
-
-f: int = 1
-reveal_type(f)  # revealed: Literal[1]
-
-def f(): ...
-
-reveal_type(f)  # revealed: Literal[f]
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/shadowing/variable_declaration.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/shadowing/variable_declaration.md
@@ -3,11 +3,14 @@
 ## Shadow after incompatible declarations is OK

 ```py
-def _(flag: bool):
-    if flag:
-        x: str
-    else:
-        x: int
+def bool_instance() -> bool:
+    return True

-    x: bytes = b"foo"
+flag = bool_instance()
+
+if flag:
+    x: str
+else:
+    x: int
+x: bytes = b"foo"
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/slots.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/slots.md
@@ -1,184 +0,0 @@
-# `__slots__`
-
-## Not specified and empty
-
-```py
-class A: ...
-
-class B:
-    __slots__ = ()
-
-class C:
-    __slots__ = ("lorem", "ipsum")
-
-class AB(A, B): ...  # fine
-class AC(A, C): ...  # fine
-class BC(B, C): ...  # fine
-class ABC(A, B, C): ...  # fine
-```
-
-## Incompatible tuples
-
-```py
-class A:
-    __slots__ = ("a", "b")
-
-class B:
-    __slots__ = ("c", "d")
-
-class C(
-    A,  # error: [incompatible-slots]
-    B,  # error: [incompatible-slots]
-): ...
-```
-
-## Same value
-
-```py
-class A:
-    __slots__ = ("a", "b")
-
-class B:
-    __slots__ = ("a", "b")
-
-class C(
-    A,  # error: [incompatible-slots]
-    B,  # error: [incompatible-slots]
-): ...
-```
-
-## Strings
-
-```py
-class A:
-    __slots__ = "abc"
-
-class B:
-    __slots__ = ("abc",)
-
-class AB(
-    A,  # error: [incompatible-slots]
-    B,  # error: [incompatible-slots]
-): ...
-```
-
-## Invalid
-
-TODO: Emit diagnostics
-
-```py
-class NonString1:
-    __slots__ = 42
-
-class NonString2:
-    __slots__ = b"ar"
-
-class NonIdentifier1:
-    __slots__ = "42"
-
-class NonIdentifier2:
-    __slots__ = ("lorem", "42")
-
-class NonIdentifier3:
-    __slots__ = (e for e in ("lorem", "42"))
-```
-
-## Inheritance
-
-```py
-class A:
-    __slots__ = ("a", "b")
-
-class B(A): ...
-
-class C:
-    __slots__ = ("c", "d")
-
-class D(C): ...
-class E(
-    B,  # error: [incompatible-slots]
-    D,  # error: [incompatible-slots]
-): ...
-```
-
-## Single solid base
-
-```py
-class A:
-    __slots__ = ("a", "b")
-
-class B(A): ...
-class C(A): ...
-class D(B, A): ...  # fine
-class E(B, C, A): ...  # fine
-```
-
-## False negatives
-
-### Possibly unbound
-
-```py
-def _(flag: bool):
-    class A:
-        if flag:
-            __slots__ = ("a", "b")
-
-    class B:
-        __slots__ = ("c", "d")
-
-    # Might or might not be fine at runtime
-    class C(A, B): ...
-```
-
-### Bound but with different types
-
-```py
-def _(flag: bool):
-    class A:
-        if flag:
-            __slots__ = ("a", "b")
-        else:
-            __slots__ = ()
-
-    class B:
-        __slots__ = ("c", "d")
-
-    # Might or might not be fine at runtime
-    class C(A, B): ...
-```
-
-### Non-tuples
-
-```py
-class A:
-    __slots__ = ["a", "b"]  # This is treated as "dynamic"
-
-class B:
-    __slots__ = ("c", "d")
-
-# False negative: [incompatible-slots]
-class C(A, B): ...
-```
-
-### Post-hoc modifications
-
-```py
-class A:
-    __slots__ = ()
-    __slots__ += ("a", "b")
-
-reveal_type(A.__slots__)  # revealed: @Todo(Support for more binary expressions)
-
-class B:
-    __slots__ = ("c", "d")
-
-# False negative: [incompatible-slots]
-class C(A, B): ...
-```
-
-### Built-ins with implicit layouts
-
-```py
-# False negative: [incompatible-slots]
-class A(int, str): ...
-```
--- a/crates/red_knot_python_semantic/resources/mdtest/statically_known_branches.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/statically_known_branches.md
--- a/crates/red_knot_python_semantic/resources/mdtest/subscript/bytes.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/subscript/bytes.md
@@ -22,10 +22,12 @@ reveal_type(x)  # revealed: Unknown
 y = b[-6]  # error: [index-out-of-bounds] "Index -6 is out of bounds for bytes literal `Literal[b"\x00abc\xff"]` with length 5"
 reveal_type(y)  # revealed: Unknown

-def _(n: int):
-    a = b"abcde"[n]
-    # TODO: Support overloads... Should be `bytes`
-    reveal_type(a)  # revealed: @Todo(return type)
+def int_instance() -> int:
+    return 42
+
+a = b"abcde"[int_instance()]
+# TODO: Support overloads... Should be `bytes`
+reveal_type(a)  # revealed: @Todo(return type)
 ```

 ## Slices
@@ -41,13 +43,15 @@ b[:4:0]  # error: [zero-stepsize-in-slice]
 b[0::0]  # error: [zero-stepsize-in-slice]
 b[::0]  # error: [zero-stepsize-in-slice]

-def _(m: int, n: int):
-    byte_slice1 = b[m:n]
-    # TODO: Support overloads... Should be `bytes`
-    reveal_type(byte_slice1)  # revealed: @Todo(return type)
+def int_instance() -> int: ...

-def _(s: bytes) -> bytes:
-    byte_slice2 = s[0:5]
-    # TODO: Support overloads... Should be `bytes`
-    reveal_type(byte_slice2)  # revealed: @Todo(return type)
+byte_slice1 = b[int_instance() : int_instance()]
+# TODO: Support overloads... Should be `bytes`
+reveal_type(byte_slice1)  # revealed: @Todo(return type)
+
+def bytes_instance() -> bytes: ...
+
+byte_slice2 = bytes_instance()[0:5]
+# TODO: Support overloads... Should be `bytes`
+reveal_type(byte_slice2)  # revealed: @Todo(return type)
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/subscript/class.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/subscript/class.md
@@ -21,66 +21,77 @@ reveal_type(Identity[0])  # revealed: str
 ## Class getitem union

 ```py
-def _(flag: bool):
-    class UnionClassGetItem:
-        if flag:
-            def __class_getitem__(cls, item: int) -> str:
-                return item
-        else:
-            def __class_getitem__(cls, item: int) -> int:
-                return item
+def bool_instance() -> bool:
+    return True

-    reveal_type(UnionClassGetItem[0])  # revealed: str | int
+class UnionClassGetItem:
+    if bool_instance():
+
+        def __class_getitem__(cls, item: int) -> str:
+            return item
+    else:
+
+        def __class_getitem__(cls, item: int) -> int:
+            return item
+
+reveal_type(UnionClassGetItem[0])  # revealed: str | int
 ```

 ## Class getitem with class union

 ```py
-def _(flag: bool):
-    class A:
-        def __class_getitem__(cls, item: int) -> str:
-            return item
+def bool_instance() -> bool:
+    return True

-    class B:
-        def __class_getitem__(cls, item: int) -> int:
-            return item
+class A:
+    def __class_getitem__(cls, item: int) -> str:
+        return item

-    x = A if flag else B
+class B:
+    def __class_getitem__(cls, item: int) -> int:
+        return item

-    reveal_type(x)  # revealed: Literal[A, B]
-    reveal_type(x[0])  # revealed: str | int
+x = A if bool_instance() else B
+
+reveal_type(x)  # revealed: Literal[A, B]
+reveal_type(x[0])  # revealed: str | int
 ```

 ## Class getitem with unbound method union

 ```py
-def _(flag: bool):
-    if flag:
-        class Spam:
-            def __class_getitem__(self, x: int) -> str:
-                return "foo"
+def bool_instance() -> bool:
+    return True

-    else:
-        class Spam: ...
-    # error: [call-possibly-unbound-method] "Method `__class_getitem__` of type `Literal[Spam, Spam]` is possibly unbound"
-    # revealed: str
-    reveal_type(Spam[42])
+if bool_instance():
+    class Spam:
+        def __class_getitem__(self, x: int) -> str:
+            return "foo"
+
+else:
+    class Spam: ...
+
+# error: [call-possibly-unbound-method] "Method `__class_getitem__` of type `Literal[Spam, Spam]` is possibly unbound"
+# revealed: str
+reveal_type(Spam[42])
 ```

 ## TODO: Class getitem non-class union

 ```py
-def _(flag: bool):
-    if flag:
-        class Eggs:
-            def __class_getitem__(self, x: int) -> str:
-                return "foo"
+def bool_instance() -> bool:
+    return True

-    else:
-        Eggs = 1
+if bool_instance():
+    class Eggs:
+        def __class_getitem__(self, x: int) -> str:
+            return "foo"

-    a = Eggs[42]  # error: "Cannot subscript object of type `Literal[Eggs] | Literal[1]` with no `__getitem__` method"
+else:
+    Eggs = 1

-    # TODO: should _probably_ emit `str | Unknown`
-    reveal_type(a)  # revealed: Unknown
+a = Eggs[42]  # error: "Cannot subscript object of type `Literal[Eggs] | Literal[1]` with no `__getitem__` method"
+
+# TODO: should _probably_ emit `str | Unknown`
+reveal_type(a)  # revealed: Unknown
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/subscript/instance.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/subscript/instance.md
@@ -30,14 +30,18 @@ reveal_type(Identity()[0])  # revealed: int
 ## Getitem union

 ```py
-def _(flag: bool):
-    class Identity:
-        if flag:
-            def __getitem__(self, index: int) -> int:
-                return index
-        else:
-            def __getitem__(self, index: int) -> str:
-                return str(index)
+def bool_instance() -> bool:
+    return True

-    reveal_type(Identity()[0])  # revealed: int | str
+class Identity:
+    if bool_instance():
+
+        def __getitem__(self, index: int) -> int:
+            return index
+    else:
+
+        def __getitem__(self, index: int) -> str:
+            return str(index)
+
+reveal_type(Identity()[0])  # revealed: int | str
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/subscript/string.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/subscript/string.md
@@ -19,10 +19,11 @@ reveal_type(a)  # revealed: Unknown
 b = s[-8]  # error: [index-out-of-bounds] "Index -8 is out of bounds for string `Literal["abcde"]` with length 5"
 reveal_type(b)  # revealed: Unknown

-def _(n: int):
-    a = "abcde"[n]
-    # TODO: Support overloads... Should be `str`
-    reveal_type(a)  # revealed: @Todo(return type)
+def int_instance() -> int: ...
+
+a = "abcde"[int_instance()]
+# TODO: Support overloads... Should be `str`
+reveal_type(a)  # revealed: @Todo(return type)
 ```

 ## Slices
@@ -73,14 +74,17 @@ s[:4:0]  # error: [zero-stepsize-in-slice]
 s[0::0]  # error: [zero-stepsize-in-slice]
 s[::0]  # error: [zero-stepsize-in-slice]

-def _(m: int, n: int, s2: str):
-    substring1 = s[m:n]
-    # TODO: Support overloads... Should be `LiteralString`
-    reveal_type(substring1)  # revealed: @Todo(return type)
+def int_instance() -> int: ...

-    substring2 = s2[0:5]
-    # TODO: Support overloads... Should be `str`
-    reveal_type(substring2)  # revealed: @Todo(return type)
+substring1 = s[int_instance() : int_instance()]
+# TODO: Support overloads... Should be `LiteralString`
+reveal_type(substring1)  # revealed: @Todo(return type)
+
+def str_instance() -> str: ...
+
+substring2 = str_instance()[0:5]
+# TODO: Support overloads... Should be `str`
+reveal_type(substring2)  # revealed: @Todo(return type)
 ```

 ## Unsupported slice types
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Micha Reiser	f6b2544993	Add rule registry and rule selection	2024-12-09 14:10:40 +01:00
Micha Reiser	fe78d50560	Add `declare_lint`	2024-12-09 14:08:19 +01:00
Micha Reiser	b39def2915	Introduce `DiagnosticId`	2024-12-09 14:05:09 +01:00