Add DisplayType trait

.github/CODEOWNERS

@@ -9,7 +9,6 @@
 /crates/ruff_formatter/ @MichaReiser
 /crates/ruff_python_formatter/ @MichaReiser
 /crates/ruff_python_parser/ @MichaReiser @dhruvmanila
-/crates/ruff_annotate_snippets/ @BurntSushi
 
 # flake8-pyi
 /crates/ruff_linter/src/rules/flake8_pyi/ @AlexWaygood

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,12 @@
+<!--
+Thank you for taking the time to report an issue! We're glad to have you involved with Ruff.
+
+If you're filing a bug report, please consider including the following information:
+
+* List of keywords you searched for before creating this issue. Write them down here so that others can find this issue more easily and help provide feedback.
+  e.g. "RUF001", "unused variable", "Jupyter notebook"
+* A minimal code snippet that reproduces the bug.
+* The command you invoked (e.g., `ruff /path/to/file.py --fix`), ideally including the `--isolated` flag.
+* The current Ruff settings (any relevant sections from your `pyproject.toml`).
+* The current Ruff version (`ruff --version`).
+-->

.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

.github/renovate.json5

@@ -45,7 +45,7 @@
       groupName: "Artifact GitHub Actions dependencies",
       matchManagers: ["github-actions"],
       matchDatasources: ["gitea-tags", "github-tags"],
-      matchPackageNames: ["actions/.*-artifact"],
+      matchPackagePatterns: ["actions/.*-artifact"],
       description: "Weekly update of artifact-related GitHub Actions dependencies",
     },
     {
@@ -61,7 +61,7 @@
     {
       // Disable updates of `zip-rs`; intentionally pinned for now due to ownership change
       // See: https://github.com/astral-sh/uv/issues/3642
-      matchPackageNames: ["zip"],
+      matchPackagePatterns: ["zip"],
       matchManagers: ["cargo"],
       enabled: false,
     },
@@ -70,7 +70,7 @@
       // with `mkdocs-material-insider`.
       // See: https://squidfunk.github.io/mkdocs-material/insiders/upgrade/
       matchManagers: ["pip_requirements"],
-      matchPackageNames: ["mkdocs-material"],
+      matchPackagePatterns: ["mkdocs-material"],
       enabled: false,
     },
     {
@@ -87,13 +87,13 @@
     {
       groupName: "Monaco",
       matchManagers: ["npm"],
-      matchPackageNames: ["monaco"],
+      matchPackagePatterns: ["monaco"],
       description: "Weekly update of the Monaco editor",
     },
     {
       groupName: "strum",
       matchManagers: ["cargo"],
-      matchPackageNames: ["strum"],
+      matchPackagePatterns: ["strum"],
       description: "Weekly update of strum dependencies",
     },
     {

.github/workflows/build-binaries.yml

@@ -53,7 +53,7 @@ jobs:
           args: --out dist
       - name: "Test sdist"
         run: |
-          pip install dist/"${PACKAGE_NAME}"-*.tar.gz --force-reinstall
+          pip install dist/${PACKAGE_NAME}-*.tar.gz --force-reinstall
           "${MODULE_NAME}" --help
           python -m "${MODULE_NAME}" --help
       - name: "Upload sdist"
@@ -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/${PACKAGE_NAME}-*.whl --force-reinstall
           ruff --help
           python -m ruff --help
       - name: "Upload wheels"
@@ -186,7 +186,7 @@ jobs:
         if: ${{ !startsWith(matrix.platform.target, 'aarch64') }}
         shell: bash
         run: |
-          python -m pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
+          python -m pip install dist/${PACKAGE_NAME}-*.whl --force-reinstall
           "${MODULE_NAME}" --help
           python -m "${MODULE_NAME}" --help
       - name: "Upload wheels"
@@ -236,7 +236,7 @@ jobs:
       - name: "Test wheel"
         if: ${{ startsWith(matrix.target, 'x86_64') }}
         run: |
-          pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
+          pip install dist/${PACKAGE_NAME}-*.whl --force-reinstall
           "${MODULE_NAME}" --help
           python -m "${MODULE_NAME}" --help
       - name: "Upload wheels"

.github/workflows/build-docker.yml

@@ -48,13 +48,11 @@ jobs:
 
       - name: Check tag consistency
         if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-        env:
-          TAG: ${{ inputs.plan != '' && fromJson(inputs.plan).announcement_tag || 'dry-run' }}
         run: |
           version=$(grep "version = " pyproject.toml | sed -e 's/version = "\(.*\)"/\1/g')
-          if [ "${TAG}" != "${version}" ]; then
+          if [ "${{ fromJson(inputs.plan).announcement_tag }}" != "${version}" ]; then
             echo "The input tag does not match the version from pyproject.toml:" >&2
-            echo "${TAG}" >&2
+            echo "${{ fromJson(inputs.plan).announcement_tag }}" >&2
             echo "${version}" >&2
             exit 1
           else
@@ -74,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
@@ -144,10 +142,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 '${RUFF_BASE_IMG}@sha256:%s ' *)
 
   docker-publish-extra:
     name: Publish additional Docker image based on ${{ matrix.image-mapping }}
@@ -177,8 +174,6 @@ jobs:
 
       - name: Generate Dynamic Dockerfile Tags
         shell: bash
-        env:
-          TAG_VALUE: ${{ fromJson(inputs.plan).announcement_tag }}
         run: |
           set -euo pipefail
 
@@ -199,8 +194,8 @@ jobs:
           # Loop through all base tags and append its docker metadata pattern to the list
           # Order is on purpose such that the label org.opencontainers.image.version has the first pattern with the full version
           IFS=','; for TAG in ${BASE_TAGS}; do
-            TAG_PATTERNS="${TAG_PATTERNS}type=pep440,pattern={{ version }},suffix=-${TAG},value=${TAG_VALUE}\n"
-            TAG_PATTERNS="${TAG_PATTERNS}type=pep440,pattern={{ major }}.{{ minor }},suffix=-${TAG},value=${TAG_VALUE}\n"
+            TAG_PATTERNS="${TAG_PATTERNS}type=pep440,pattern={{ version }},suffix=-${TAG},value=${{ fromJson(inputs.plan).announcement_tag }}\n"
+            TAG_PATTERNS="${TAG_PATTERNS}type=pep440,pattern={{ major }}.{{ minor }},suffix=-${TAG},value=${{ fromJson(inputs.plan).announcement_tag }}\n"
             TAG_PATTERNS="${TAG_PATTERNS}type=raw,value=${TAG}\n"
           done
 
@@ -208,14 +203,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
@@ -291,9 +286,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 '${RUFF_BASE_IMG}@sha256:%s ' *)

.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
           )
@@ -386,7 +381,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup component add rustfmt
       - uses: Swatinem/rust-cache@v2
-      - run: ./scripts/add_rule.py --name DoTheThing --prefix F --code 999 --linter pyflakes
+      - run: ./scripts/add_rule.py --name DoTheThing --prefix PL --code C0999 --linter pylint
       - run: cargo check
       - run: cargo fmt --all --check
       - run: |
@@ -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

.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 \
@@ -73,6 +72,6 @@ jobs:
               owner: "astral-sh",
               repo: "ruff",
               title: `Daily parser fuzz failed on ${new Date().toDateString()}`,
-              body: "Run listed here: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}",
+              body: "Runs listed here: https://github.com/astral-sh/ruff/actions/workflows/daily_fuzz.yml",
               labels: ["bug", "parser", "fuzzer"],
             })

.github/workflows/daily_property_tests.yaml

@@ -1,71 +0,0 @@
-name: Daily property test run
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 12 * * *"
-  pull_request:
-    paths:
-      - ".github/workflows/daily_property_tests.yaml"
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-  FORCE_COLOR: 1
-
-jobs:
-  property_tests:
-    name: Property tests
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    # Don't run the cron job on forks:
-    if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - name: "Install mold"
-        uses: rui314/setup-mold@v1
-      - uses: Swatinem/rust-cache@v2
-      - name: Build Red Knot
-        # A release build takes longer (2 min vs 1 min), but the property tests run much faster in release
-        # mode (1.5 min vs 14 min), so the overall time is shorter with a release build.
-        run: cargo build --locked --release --package red_knot_python_semantic --tests
-      - name: Run property tests
-        shell: bash
-        run: |
-          export QUICKCHECK_TESTS=100000
-          for _ in {1..5}; do
-            cargo test --locked --release --package red_knot_python_semantic -- --ignored types::property_tests::stable
-          done
-
-  create-issue-on-failure:
-    name: Create an issue if the daily property test run surfaced any bugs
-    runs-on: ubuntu-latest
-    needs: property_tests
-    if: ${{ github.repository == 'astral-sh/ruff' && always() && github.event_name == 'schedule' && needs.property_tests.result == 'failure' }}
-    permissions:
-      issues: write
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            await github.rest.issues.create({
-              owner: "astral-sh",
-              repo: "ruff",
-              title: `Daily property test run failed on ${new Date().toDateString()}`,
-              body: "Run listed here: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}",
-              labels: ["bug", "red-knot", "testing"],
-            })

.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

.github/workflows/publish-docs.yml

@@ -33,9 +33,8 @@ jobs:
           python-version: 3.12
 
       - name: "Set docs version"
-        env:
-          version: ${{ (inputs.plan != '' && fromJson(inputs.plan).announcement_tag) || inputs.ref }}
         run: |
+          version="${{ (inputs.plan != '' && fromJson(inputs.plan).announcement_tag) || inputs.ref }}"
           # if version is missing, use 'latest'
           if [ -z "$version" ]; then
             echo "Using 'latest' as version"
@@ -45,8 +44,8 @@ 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: |
@@ -56,8 +55,8 @@ jobs:
           # characters disallowed in git branch names with hyphens
           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' }}
@@ -113,7 +112,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.ASTRAL_DOCS_PAT }}
         run: |
           # 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
@@ -125,12 +124,10 @@ jobs:
           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 }}

.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-*

.github/workflows/sync_typeshed.yaml

@@ -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:
@@ -78,6 +78,5 @@ jobs:
               owner: "astral-sh",
               repo: "ruff",
               title: `Automated typeshed sync failed on ${new Date().toDateString()}`,
-              body: "Run listed here: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}",
-              labels: ["bug", "red-knot"],
+              body: "Runs are listed here: https://github.com/astral-sh/ruff/actions/workflows/sync_typeshed.yaml",
             })

.github/zizmor.yml

@@ -1,12 +0,0 @@
-# Configuration for the zizmor static analysis tool, run via pre-commit in CI
-# https://woodruffw.github.io/zizmor/configuration/
-#
-# TODO: can we remove the ignores here so that our workflows are more secure?
-rules:
-  dangerous-triggers:
-    ignore:
-      - pr-comment.yaml
-  cache-poisoning:
-    ignore:
-      - build-docker.yml
-      - publish-playground.yml

.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

.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.29.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.9.1
+    rev: v0.8.2
     hooks:
       - id: ruff-format
       - id: ruff
@@ -88,37 +88,18 @@ 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: v1.0.1
+    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
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.31.0
+    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.6
-    hooks:
-      - id: actionlint
-        stages:
-          # This hook is disabled by default, since it's quite slow.
-          # To run all hooks *including* this hook, use `uvx pre-commit run -a --hook-stage=manual`.
-          # To run *just* this hook, use `uvx pre-commit run -a actionlint --hook-stage=manual`.
-          - manual
-        args:
-          - "-ignore=SC2129" # ignorable stylistic lint from shellcheck
-          - "-ignore=SC2016" # another shellcheck lint: seems to have false positives?
-        additional_dependencies:
-          # actionlint has a shellcheck integration which extracts shell scripts in `run:` steps from GitHub Actions
-          # and checks these with shellcheck. This is arguably its most useful feature,
-          # but the integration only works if shellcheck is installed
-          - "github.com/wasilibs/go-shellcheck/cmd/shellcheck@v0.10.0"
-
 ci:
   skip: [cargo-fmt, dev-generate-all]

BREAKING_CHANGES.md

@@ -1,9 +1,5 @@
 # Breaking Changes
 
-## 0.9.0
-
-Ruff now formats your code according to the 2025 style guide. As a result, your code might now get formatted differently. See the [changelog](./CHANGELOG.md#090) for a detailed list of changes.
-
 ## 0.8.0
 
 - **Default to Python 3.9**

CHANGELOG.md

@@ -1,243 +1,5 @@
 # Changelog
 
-## 0.9.1
-
-### Preview features
-
-- \[`pycodestyle`\] Run `too-many-newlines-at-end-of-file` on each cell in notebooks (`W391`) ([#15308](https://github.com/astral-sh/ruff/pull/15308))
-- \[`ruff`\] Omit diagnostic for shadowed private function parameters in `used-dummy-variable` (`RUF052`) ([#15376](https://github.com/astral-sh/ruff/pull/15376))
-
-### Rule changes
-
-- \[`flake8-bugbear`\] Improve `assert-raises-exception` message (`B017`) ([#15389](https://github.com/astral-sh/ruff/pull/15389))
-
-### Formatter
-
-- Preserve trailing end-of line comments for the last string literal in implicitly concatenated strings ([#15378](https://github.com/astral-sh/ruff/pull/15378))
-
-### Server
-
-- Fix a bug where the server and client notebooks were out of sync after reordering cells ([#15398](https://github.com/astral-sh/ruff/pull/15398))
-
-### Bug fixes
-
-- \[`flake8-pie`\] Correctly remove wrapping parentheses (`PIE800`) ([#15394](https://github.com/astral-sh/ruff/pull/15394))
-- \[`pyupgrade`\] Handle comments and multiline expressions correctly (`UP037`) ([#15337](https://github.com/astral-sh/ruff/pull/15337))
-
-## 0.9.0
-
-Check out the [blog post](https://astral.sh/blog/ruff-v0.9.0) for a migration guide and overview of the changes!
-
-### Breaking changes
-
-Ruff now formats your code according to the 2025 style guide. As a result, your code might now get formatted differently. See the formatter section for a detailed list of changes.
-
-This release doesn’t remove or remap any existing stable rules.
-
-### Stabilization
-
-The following rules have been stabilized and are no longer in preview:
-
-- [`stdlib-module-shadowing`](https://docs.astral.sh/ruff/rules/stdlib-module-shadowing/) (`A005`).
-    This rule has also been renamed: previously, it was called `builtin-module-shadowing`.
-- [`builtin-lambda-argument-shadowing`](https://docs.astral.sh/ruff/rules/builtin-lambda-argument-shadowing/) (`A006`)
-- [`slice-to-remove-prefix-or-suffix`](https://docs.astral.sh/ruff/rules/slice-to-remove-prefix-or-suffix/) (`FURB188`)
-- [`boolean-chained-comparison`](https://docs.astral.sh/ruff/rules/boolean-chained-comparison/) (`PLR1716`)
-- [`decimal-from-float-literal`](https://docs.astral.sh/ruff/rules/decimal-from-float-literal/) (`RUF032`)
-- [`post-init-default`](https://docs.astral.sh/ruff/rules/post-init-default/) (`RUF033`)
-- [`useless-if-else`](https://docs.astral.sh/ruff/rules/useless-if-else/) (`RUF034`)
-
-The following behaviors have been stabilized:
-
-- [`pytest-parametrize-names-wrong-type`](https://docs.astral.sh/ruff/rules/pytest-parametrize-names-wrong-type/) (`PT006`): Detect [`pytest.parametrize`](https://docs.pytest.org/en/7.1.x/how-to/parametrize.html#parametrize) calls outside decorators and calls with keyword arguments.
-- [`module-import-not-at-top-of-file`](https://docs.astral.sh/ruff/rules/module-import-not-at-top-of-file/) (`E402`): Ignore [`pytest.importorskip`](https://docs.pytest.org/en/7.1.x/reference/reference.html#pytest-importorskip) calls between import statements.
-- [`mutable-dataclass-default`](https://docs.astral.sh/ruff/rules/mutable-dataclass-default/) (`RUF008`) and [`function-call-in-dataclass-default-argument`](https://docs.astral.sh/ruff/rules/function-call-in-dataclass-default-argument/) (`RUF009`): Add support for [`attrs`](https://www.attrs.org/en/stable/).
-- [`bad-version-info-comparison`](https://docs.astral.sh/ruff/rules/bad-version-info-comparison/) (`PYI006`): Extend the rule to check non-stub files.
-
-The following fixes or improvements to fixes have been stabilized:
-
-- [`redundant-numeric-union`](https://docs.astral.sh/ruff/rules/redundant-numeric-union/) (`PYI041`)
-- [`duplicate-union-members`](https://docs.astral.sh/ruff/rules/duplicate-union-member/) (`PYI016`)
-
-### Formatter
-
-This release introduces the new 2025 stable style ([#13371](https://github.com/astral-sh/ruff/issues/13371)), stabilizing the following changes:
-
-- Format expressions in f-string elements ([#7594](https://github.com/astral-sh/ruff/issues/7594))
-- Alternate quotes for strings inside f-strings ([#13860](https://github.com/astral-sh/ruff/pull/13860))
-- Preserve the casing of hex codes in f-string debug expressions ([#14766](https://github.com/astral-sh/ruff/issues/14766))
-- Choose the quote style for each string literal in an implicitly concatenated f-string rather than for the entire string ([#13539](https://github.com/astral-sh/ruff/pull/13539))
-- Automatically join an implicitly concatenated string into a single string literal if it fits on a single line ([#9457](https://github.com/astral-sh/ruff/issues/9457))
-- Remove the [`ISC001`](https://docs.astral.sh/ruff/rules/single-line-implicit-string-concatenation/) incompatibility warning ([#15123](https://github.com/astral-sh/ruff/pull/15123))
-- Prefer parenthesizing the `assert` message over breaking the assertion expression ([#9457](https://github.com/astral-sh/ruff/issues/9457))
-- Automatically parenthesize over-long `if` guards in `match` `case` clauses ([#13513](https://github.com/astral-sh/ruff/pull/13513))
-- More consistent formatting for `match` `case` patterns ([#6933](https://github.com/astral-sh/ruff/issues/6933))
-- Avoid unnecessary parentheses around return type annotations ([#13381](https://github.com/astral-sh/ruff/pull/13381))
-- Keep the opening parentheses on the same line as the `if` keyword for comprehensions where the condition has a leading comment ([#12282](https://github.com/astral-sh/ruff/pull/12282))
-- More consistent formatting for `with` statements with a single context manager for Python 3.8 or older ([#10276](https://github.com/astral-sh/ruff/pull/10276))
-- Correctly calculate the line-width for code blocks in docstrings when using `max-doc-code-line-length = "dynamic"` ([#13523](https://github.com/astral-sh/ruff/pull/13523))
-
-### Preview features
-
-- \[`flake8-bugbear`\] Implement `class-as-data-structure` (`B903`) ([#9601](https://github.com/astral-sh/ruff/pull/9601))
-- \[`flake8-type-checking`\] Apply `quoted-type-alias` more eagerly in `TYPE_CHECKING` blocks and ignore it in stubs (`TC008`) ([#15180](https://github.com/astral-sh/ruff/pull/15180))
-- \[`pylint`\] Ignore `eq-without-hash` in stub files (`PLW1641`) ([#15310](https://github.com/astral-sh/ruff/pull/15310))
-- \[`pyupgrade`\] Split `UP007` into two individual rules: `UP007` for `Union` and `UP045` for `Optional` (`UP007`, `UP045`) ([#15313](https://github.com/astral-sh/ruff/pull/15313))
-- \[`ruff`\] New rule that detects classes that are both an enum and a `dataclass` (`RUF049`) ([#15299](https://github.com/astral-sh/ruff/pull/15299))
-- \[`ruff`\] Recode `RUF025` to `RUF037` (`RUF037`) ([#15258](https://github.com/astral-sh/ruff/pull/15258))
-
-### Rule changes
-
-- \[`flake8-builtins`\] Ignore [`stdlib-module-shadowing`](https://docs.astral.sh/ruff/rules/stdlib-module-shadowing/) in stub files(`A005`) ([#15350](https://github.com/astral-sh/ruff/pull/15350))
-- \[`flake8-return`\] Add support for functions returning `typing.Never` (`RET503`) ([#15298](https://github.com/astral-sh/ruff/pull/15298))
-
-### Server
-
-- Improve the observability by removing the need for the ["trace" value](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#traceValue) to turn on or off logging. The server logging is solely controlled using the [`logLevel` server setting](https://docs.astral.sh/ruff/editors/settings/#loglevel)
-    which defaults to `info`. This addresses the issue where users were notified about an error and told to consult the log, but it didn’t contain any messages. ([#15232](https://github.com/astral-sh/ruff/pull/15232))
-- Ignore diagnostics from other sources for code action requests ([#15373](https://github.com/astral-sh/ruff/pull/15373))
-
-### CLI
-
-- Improve the error message for `--config key=value` when the `key` is for a table and it’s a simple `value`
-
-### Bug fixes
-
-- \[`eradicate`\] Ignore metadata blocks directly followed by normal blocks (`ERA001`) ([#15330](https://github.com/astral-sh/ruff/pull/15330))
-- \[`flake8-django`\] Recognize other magic methods (`DJ012`) ([#15365](https://github.com/astral-sh/ruff/pull/15365))
-- \[`pycodestyle`\] Avoid false positives related to type aliases (`E252`) ([#15356](https://github.com/astral-sh/ruff/pull/15356))
-- \[`pydocstyle`\] Avoid treating newline-separated sections as sub-sections (`D405`) ([#15311](https://github.com/astral-sh/ruff/pull/15311))
-- \[`pyflakes`\] Remove call when removing final argument from `format` (`F523`) ([#15309](https://github.com/astral-sh/ruff/pull/15309))
-- \[`refurb`\] Mark fix as unsafe when the right-hand side is a string (`FURB171`) ([#15273](https://github.com/astral-sh/ruff/pull/15273))
-- \[`ruff`\] Treat `)` as a regex metacharacter (`RUF043`, `RUF055`) ([#15318](https://github.com/astral-sh/ruff/pull/15318))
-- \[`ruff`\] Parenthesize the `int`-call argument when removing the `int` call would change semantics (`RUF046`) ([#15277](https://github.com/astral-sh/ruff/pull/15277))
-
-## 0.8.6
-
-### Preview features
-
-- \[`format`\]: Preserve multiline implicit concatenated strings in docstring positions ([#15126](https://github.com/astral-sh/ruff/pull/15126))
-- \[`ruff`\] Add rule to detect empty literal in deque call (`RUF025`) ([#15104](https://github.com/astral-sh/ruff/pull/15104))
-- \[`ruff`\] Avoid reporting when `ndigits` is possibly negative (`RUF057`) ([#15234](https://github.com/astral-sh/ruff/pull/15234))
-
-### Rule changes
-
-- \[`flake8-todos`\] remove issue code length restriction (`TD003`) ([#15175](https://github.com/astral-sh/ruff/pull/15175))
-- \[`pyflakes`\] Ignore errors in `@no_type_check` string annotations (`F722`, `F821`) ([#15215](https://github.com/astral-sh/ruff/pull/15215))
-
-### CLI
-
-- Show errors for attempted fixes only when passed `--verbose` ([#15237](https://github.com/astral-sh/ruff/pull/15237))
-
-### Bug fixes
-
-- \[`ruff`\] Avoid syntax error when removing int over multiple lines (`RUF046`) ([#15230](https://github.com/astral-sh/ruff/pull/15230))
-- \[`pyupgrade`\] Revert "Add all PEP-585 names to `UP006` rule" ([#15250](https://github.com/astral-sh/ruff/pull/15250))
-
-## 0.8.5
-
-### Preview features
-
-- \[`airflow`\] Extend names moved from core to provider (`AIR303`) ([#15145](https://github.com/astral-sh/ruff/pull/15145), [#15159](https://github.com/astral-sh/ruff/pull/15159), [#15196](https://github.com/astral-sh/ruff/pull/15196), [#15216](https://github.com/astral-sh/ruff/pull/15216))
-- \[`airflow`\] Extend rule to check class attributes, methods, arguments (`AIR302`) ([#15054](https://github.com/astral-sh/ruff/pull/15054), [#15083](https://github.com/astral-sh/ruff/pull/15083))
-- \[`fastapi`\] Update `FAST002` to check keyword-only arguments ([#15119](https://github.com/astral-sh/ruff/pull/15119))
-- \[`flake8-type-checking`\] Disable `TC006` and `TC007` in stub files ([#15179](https://github.com/astral-sh/ruff/pull/15179))
-- \[`pylint`\] Detect nested methods correctly (`PLW1641`) ([#15032](https://github.com/astral-sh/ruff/pull/15032))
-- \[`ruff`\] Detect more strict-integer expressions (`RUF046`) ([#14833](https://github.com/astral-sh/ruff/pull/14833))
-- \[`ruff`\] Implement `falsy-dict-get-fallback` (`RUF056`) ([#15160](https://github.com/astral-sh/ruff/pull/15160))
-- \[`ruff`\] Implement `unnecessary-round` (`RUF057`) ([#14828](https://github.com/astral-sh/ruff/pull/14828))
-
-### Rule changes
-
-- Visit PEP 764 inline `TypedDict` keys as non-type-expressions ([#15073](https://github.com/astral-sh/ruff/pull/15073))
-- \[`flake8-comprehensions`\] Skip `C416` if comprehension contains unpacking ([#14909](https://github.com/astral-sh/ruff/pull/14909))
-- \[`flake8-pie`\] Allow `cast(SomeType, ...)` (`PIE796`) ([#15141](https://github.com/astral-sh/ruff/pull/15141))
-- \[`flake8-simplify`\] More precise inference for dictionaries (`SIM300`) ([#15164](https://github.com/astral-sh/ruff/pull/15164))
-- \[`flake8-use-pathlib`\] Catch redundant joins in `PTH201` and avoid syntax errors ([#15177](https://github.com/astral-sh/ruff/pull/15177))
-- \[`pycodestyle`\] Preserve original value format (`E731`) ([#15097](https://github.com/astral-sh/ruff/pull/15097))
-- \[`pydocstyle`\] Split on first whitespace character (`D403`) ([#15082](https://github.com/astral-sh/ruff/pull/15082))
-- \[`pyupgrade`\] Add all PEP-585 names to `UP006` rule ([#5454](https://github.com/astral-sh/ruff/pull/5454))
-
-### Configuration
-
-- \[`flake8-type-checking`\] Improve flexibility of `runtime-evaluated-decorators` ([#15204](https://github.com/astral-sh/ruff/pull/15204))
-- \[`pydocstyle`\] Add setting to ignore missing documentation for `*args` and `**kwargs` parameters (`D417`) ([#15210](https://github.com/astral-sh/ruff/pull/15210))
-- \[`ruff`\] Add an allowlist for `unsafe-markup-use` (`RUF035`) ([#15076](https://github.com/astral-sh/ruff/pull/15076))
-
-### Bug fixes
-
-- Fix type subscript on older python versions ([#15090](https://github.com/astral-sh/ruff/pull/15090))
-- Use `TypeChecker` for detecting `fastapi` routes ([#15093](https://github.com/astral-sh/ruff/pull/15093))
-- \[`pycodestyle`\] Avoid false positives and negatives related to type parameter default syntax (`E225`, `E251`) ([#15214](https://github.com/astral-sh/ruff/pull/15214))
-
-### Documentation
-
-- Fix incorrect doc in `shebang-not-executable` (`EXE001`) and add git+windows solution to executable bit ([#15208](https://github.com/astral-sh/ruff/pull/15208))
-- Rename rules currently not conforming to naming convention ([#15102](https://github.com/astral-sh/ruff/pull/15102))
-
-## 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

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.
 

Cargo.toml

@@ -13,7 +13,6 @@ license = "MIT"
 
 [workspace.dependencies]
 ruff = { path = "crates/ruff" }
-ruff_annotate_snippets = { path = "crates/ruff_annotate_snippets" }
 ruff_cache = { path = "crates/ruff_cache" }
 ruff_db = { path = "crates/ruff_db", default-features = false }
 ruff_diagnostics = { path = "crates/ruff_diagnostics" }
@@ -44,8 +43,7 @@ red_knot_test = { path = "crates/red_knot_test" }
 red_knot_workspace = { path = "crates/red_knot_workspace", default-features = false }
 
 aho-corasick = { version = "1.1.3" }
-anstream = { version = "0.6.18" }
-anstyle = { version = "1.0.10" }
+annotate-snippets = { version = "0.9.2", features = ["color"] }
 anyhow = { version = "1.0.80" }
 assert_fs = { version = "1.1.0" }
 argfile = { version = "0.2.0" }
@@ -57,9 +55,9 @@ camino = { version = "1.1.7" }
 chrono = { version = "0.4.35", default-features = false, features = ["clock"] }
 clap = { version = "4.5.3", features = ["derive"] }
 clap_complete_command = { version = "0.6.0" }
-clearscreen = { version = "4.0.0" }
+clearscreen = { version = "3.0.0" }
 codspeed-criterion-compat = { version = "2.6.0", default-features = false }
-colored = { version = "3.0.0" }
+colored = { version = "2.1.0" }
 console_error_panic_hook = { version = "0.1.7" }
 console_log = { version = "1.0.0" }
 countme = { version = "3.0.1" }
@@ -91,7 +89,7 @@ insta = { version = "1.35.1" }
 insta-cmd = { version = "0.6.0" }
 is-macro = { version = "0.3.5" }
 is-wsl = { version = "0.4.0" }
-itertools = { version = "0.14.0" }
+itertools = { version = "0.13.0" }
 js-sys = { version = "0.3.69" }
 jod-thread = { version = "0.1.2" }
 libc = { version = "0.2.153" }
@@ -120,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 = "88a1d7774d78f048fbd77d40abca9ebd729fd1f0" }
+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"] }
@@ -134,7 +131,6 @@ serde_with = { version = "3.6.0", default-features = false, features = [
 shellexpand = { version = "3.0.0" }
 similar = { version = "2.4.0", features = ["inline"] }
 smallvec = { version = "1.13.2" }
-snapbox = { version = "0.6.0", features = ["diff", "term-svg", "cmd", "examples"] }
 static_assertions = "1.1.0"
 strum = { version = "0.26.0", features = ["strum_macros"] }
 strum_macros = { version = "0.26.0" }
@@ -152,7 +148,6 @@ tracing-subscriber = { version = "0.3.18", default-features = false, features =
     "fmt",
 ] }
 tracing-tree = { version = "0.4.0" }
-tryfn = { version = "0.2.1" }
 typed-arena = { version = "2.0.2" }
 unic-ucd-category = { version = "0.9" }
 unicode-ident = { version = "1.0.12" }
@@ -215,9 +210,6 @@ redundant_clone = "warn"
 debug_assert_with_mut_call = "warn"
 unused_peekable = "warn"
 
-# Diagnostics are not actionable: Enable once https://github.com/rust-lang/rust-clippy/issues/13774 is resolved.
-large_stack_arrays = "allow"
-
 [profile.release]
 # Note that we set these explicitly, and these values
 # were chosen based on a trade-off between compile times

README.md

@@ -116,21 +116,12 @@ For more, see the [documentation](https://docs.astral.sh/ruff/).
 
 ### Installation
 
-Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI.
-
-Invoke Ruff directly with [`uvx`](https://docs.astral.sh/uv/):
-
-```shell
-uvx ruff check   # Lint all files in the current directory.
-uvx ruff format  # Format all files in the current directory.
-```
-
-Or install Ruff with `uv` (recommended), `pip`, or `pipx`:
+Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 
 ```shell
 # With uv.
-uv tool install ruff@latest  # Install Ruff globally.
-uv add --dev ruff            # Or add Ruff to your project.
+uv add --dev ruff     # to add ruff to your project
+uv tool install ruff  # to install ruff globally
 
 # With pip.
 pip install ruff
@@ -149,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.9.1/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.9.1/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),
@@ -183,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.9.1
+  rev: v0.8.2
   hooks:
     # Run the linter.
     - id: ruff
@@ -205,7 +196,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: astral-sh/ruff-action@v3
+      - uses: astral-sh/ruff-action@v1
 ```
 
 ### Configuration<a id="configuration"></a>

_typos.toml

@@ -1,9 +1,10 @@
 [files]
 # https://github.com/crate-ci/typos/issues/868
 extend-exclude = [
-    "crates/red_knot_vendored/vendor/**/*",
-    "**/resources/**/*",
-    "**/snapshots/**/*",
+  "crates/red_knot_vendored/vendor/**/*",
+  "**/resources/**/*",
+  "**/snapshots/**/*",
+  "crates/red_knot_workspace/src/workspace/pyproject/package_name.rs"
 ]
 
 [default.extend-words]
@@ -20,10 +21,7 @@ Numer = "Numer" # Library name 'NumerBlox' in "Who's Using Ruff?"
 
 [default]
 extend-ignore-re = [
-    # Line ignore with trailing "spellchecker:disable-line"
-    "(?Rm)^.*#\\s*spellchecker:disable-line$",
-    "LICENSEs",
+  # Line ignore with trailing "spellchecker:disable-line"
+  "(?Rm)^.*#\\s*spellchecker:disable-line$",
+  "LICENSEs",
 ]
-
-[default.extend-identifiers]
-"FrIeNdLy" = "FrIeNdLy"

crates/red_knot/src/main.rs

@@ -5,22 +5,22 @@ 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::ProjectDatabase;
-use red_knot_workspace::project::settings::Configuration;
-use red_knot_workspace::project::ProjectMetadata;
+use red_knot_workspace::db::RootDatabase;
 use red_knot_workspace::watch;
-use red_knot_workspace::watch::ProjectWatcher;
+use red_knot_workspace::watch::WorkspaceWatcher;
+use red_knot_workspace::workspace::settings::Configuration;
+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()?
@@ -165,7 +183,7 @@ fn run() -> anyhow::Result<ExitStatus> {
 
     let system = OsSystem::new(cwd.clone());
     let cli_configuration = args.to_configuration(&cwd);
-    let workspace_metadata = ProjectMetadata::discover(
+    let workspace_metadata = WorkspaceMetadata::discover(
         system.current_directory(),
         &system,
         Some(&cli_configuration),
@@ -173,7 +191,7 @@ fn run() -> anyhow::Result<ExitStatus> {
 
     // TODO: Use the `program_settings` to compute the key for the database's persistent
     //   cache and load the cache if it exists.
-    let mut db = ProjectDatabase::new(workspace_metadata, system)?;
+    let mut db = RootDatabase::new(workspace_metadata, system)?;
 
     let (main_loop, main_loop_cancellation_token) = MainLoop::new(cli_configuration);
 
@@ -226,7 +244,7 @@ struct MainLoop {
     receiver: crossbeam_channel::Receiver<MainLoopMessage>,
 
     /// The file system watcher, if running in watch mode.
-    watcher: Option<ProjectWatcher>,
+    watcher: Option<WorkspaceWatcher>,
 
     cli_configuration: Configuration,
 }
@@ -246,21 +264,21 @@ impl MainLoop {
         )
     }
 
-    fn watch(mut self, db: &mut ProjectDatabase) -> anyhow::Result<ExitStatus> {
+    fn watch(mut self, db: &mut RootDatabase) -> anyhow::Result<ExitStatus> {
         tracing::debug!("Starting watch mode");
         let sender = self.sender.clone();
         let watcher = watch::directory_watcher(move |event| {
             sender.send(MainLoopMessage::ApplyChanges(event)).unwrap();
         })?;
 
-        self.watcher = Some(ProjectWatcher::new(watcher, db));
+        self.watcher = Some(WorkspaceWatcher::new(watcher, db));
 
         self.run(db);
 
         Ok(ExitStatus::Success)
     }
 
-    fn run(mut self, db: &mut ProjectDatabase) -> ExitStatus {
+    fn run(mut self, db: &mut RootDatabase) -> ExitStatus {
         self.sender.send(MainLoopMessage::CheckWorkspace).unwrap();
 
         let result = self.main_loop(db);
@@ -270,7 +288,7 @@ impl MainLoop {
         result
     }
 
-    fn main_loop(&mut self, db: &mut ProjectDatabase) -> ExitStatus {
+    fn main_loop(&mut self, db: &mut RootDatabase) -> ExitStatus {
         // Schedule the first check.
         tracing::debug!("Starting main loop");
 
@@ -279,10 +297,10 @@ 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 project. This needs to be done in a separate thread
+                    // Spawn a new task that checks the workspace. This needs to be done in a separate thread
                     // to prevent blocking the main loop here.
                     rayon::spawn(move || {
                         if let Ok(result) = db.check() {

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()
-        );
-    }
-}

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()
+        );
+    }
+}

crates/red_knot/tests/file_watching.rs

@@ -5,18 +5,18 @@ use std::time::{Duration, Instant};
 
 use anyhow::{anyhow, Context};
 use red_knot_python_semantic::{resolve_module, ModuleName, Program, PythonVersion, SitePackages};
-use red_knot_workspace::db::{Db, ProjectDatabase};
-use red_knot_workspace::project::settings::{Configuration, SearchPathConfiguration};
-use red_knot_workspace::project::ProjectMetadata;
-use red_knot_workspace::watch::{directory_watcher, ChangeEvent, ProjectWatcher};
+use red_knot_workspace::db::{Db, RootDatabase};
+use red_knot_workspace::watch::{directory_watcher, ChangeEvent, WorkspaceWatcher};
+use red_knot_workspace::workspace::settings::{Configuration, SearchPathConfiguration};
+use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::files::{system_path_to_file, File, FileError};
 use ruff_db::source::source_text;
 use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
 use ruff_db::Upcast;
 
 struct TestCase {
-    db: ProjectDatabase,
-    watcher: Option<ProjectWatcher>,
+    db: RootDatabase,
+    watcher: Option<WorkspaceWatcher>,
     changes_receiver: crossbeam::channel::Receiver<Vec<ChangeEvent>>,
     /// The temporary directory that contains the test files.
     /// We need to hold on to it in the test case or the temp files get deleted.
@@ -26,15 +26,15 @@ struct TestCase {
 }
 
 impl TestCase {
-    fn project_path(&self, relative: impl AsRef<SystemPath>) -> SystemPathBuf {
-        SystemPath::absolute(relative, self.db.project().root(&self.db))
+    fn workspace_path(&self, relative: impl AsRef<SystemPath>) -> SystemPathBuf {
+        SystemPath::absolute(relative, self.db.workspace().root(&self.db))
     }
 
     fn root_path(&self) -> &SystemPath {
         &self.root_dir
     }
 
-    fn db(&self) -> &ProjectDatabase {
+    fn db(&self) -> &RootDatabase {
         &self.db
     }
 
@@ -150,7 +150,7 @@ impl TestCase {
     ) -> anyhow::Result<()> {
         let program = Program::get(self.db());
 
-        let new_settings = configuration.to_settings(self.db.project().root(&self.db));
+        let new_settings = configuration.to_settings(self.db.workspace().root(&self.db));
         self.configuration.search_paths = configuration;
 
         program.update_search_paths(&mut self.db, &new_settings)?;
@@ -163,8 +163,9 @@ impl TestCase {
         Ok(())
     }
 
-    fn collect_project_files(&self) -> Vec<File> {
-        let files = self.db().project().files(self.db());
+    fn collect_package_files(&self, path: &SystemPath) -> Vec<File> {
+        let package = self.db().workspace().package(self.db(), path).unwrap();
+        let files = package.files(self.db());
         let mut collected: Vec<_> = files.into_iter().collect();
         collected.sort_unstable_by_key(|file| file.path(self.db()).as_system_path().unwrap());
         collected
@@ -193,17 +194,17 @@ where
 }
 
 trait SetupFiles {
-    fn setup(self, root_path: &SystemPath, project_path: &SystemPath) -> anyhow::Result<()>;
+    fn setup(self, root_path: &SystemPath, workspace_path: &SystemPath) -> anyhow::Result<()>;
 }
 
 impl<const N: usize, P> SetupFiles for [(P, &'static str); N]
 where
     P: AsRef<SystemPath>,
 {
-    fn setup(self, _root_path: &SystemPath, project_path: &SystemPath) -> anyhow::Result<()> {
+    fn setup(self, _root_path: &SystemPath, workspace_path: &SystemPath) -> anyhow::Result<()> {
         for (relative_path, content) in self {
             let relative_path = relative_path.as_ref();
-            let absolute_path = project_path.join(relative_path);
+            let absolute_path = workspace_path.join(relative_path);
             if let Some(parent) = absolute_path.parent() {
                 std::fs::create_dir_all(parent).with_context(|| {
                     format!("Failed to create parent directory for file `{relative_path}`")
@@ -225,8 +226,8 @@ impl<F> SetupFiles for F
 where
     F: FnOnce(&SystemPath, &SystemPath) -> anyhow::Result<()>,
 {
-    fn setup(self, root_path: &SystemPath, project_path: &SystemPath) -> anyhow::Result<()> {
-        self(root_path, project_path)
+    fn setup(self, root_path: &SystemPath, workspace_path: &SystemPath) -> anyhow::Result<()> {
+        self(root_path, workspace_path)
     }
 }
 
@@ -234,7 +235,7 @@ fn setup<F>(setup_files: F) -> anyhow::Result<TestCase>
 where
     F: SetupFiles,
 {
-    setup_with_search_paths(setup_files, |_root, _project_path| {
+    setup_with_search_paths(setup_files, |_root, _workspace_path| {
         SearchPathConfiguration::default()
     })
 }
@@ -264,24 +265,24 @@ where
     .simplified()
     .to_path_buf();
 
-    let project_path = root_path.join("project");
+    let workspace_path = root_path.join("workspace");
 
-    std::fs::create_dir_all(project_path.as_std_path())
-        .with_context(|| format!("Failed to create project directory `{project_path}`"))?;
+    std::fs::create_dir_all(workspace_path.as_std_path())
+        .with_context(|| format!("Failed to create workspace directory `{workspace_path}`"))?;
 
     setup_files
-        .setup(&root_path, &project_path)
+        .setup(&root_path, &workspace_path)
         .context("Failed to setup test files")?;
 
-    let system = OsSystem::new(&project_path);
+    let system = OsSystem::new(&workspace_path);
 
-    let search_paths = create_search_paths(&root_path, &project_path);
+    let search_paths = create_search_paths(&root_path, &workspace_path);
 
     for path in search_paths
         .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()
@@ -295,19 +296,19 @@ where
     }
 
     let configuration = Configuration {
-        python_version: Some(PythonVersion::PY312),
+        target_version: Some(PythonVersion::PY312),
         search_paths,
     };
 
-    let project = ProjectMetadata::discover(&project_path, &system, Some(&configuration))?;
+    let workspace = WorkspaceMetadata::discover(&workspace_path, &system, Some(&configuration))?;
 
-    let db = ProjectDatabase::new(project, system)?;
+    let db = RootDatabase::new(workspace, system)?;
 
     let (sender, receiver) = crossbeam::channel::unbounded();
     let watcher = directory_watcher(move |events| sender.send(events).unwrap())
         .with_context(|| "Failed to create directory watcher")?;
 
-    let watcher = ProjectWatcher::new(watcher, &db);
+    let watcher = WorkspaceWatcher::new(watcher, &db);
     assert!(!watcher.has_errored_paths());
 
     let test_case = TestCase {
@@ -358,12 +359,12 @@ fn update_file(path: impl AsRef<SystemPath>, content: &str) -> anyhow::Result<()
 #[test]
 fn new_file() -> anyhow::Result<()> {
     let mut case = setup([("bar.py", "")])?;
-    let bar_path = case.project_path("bar.py");
+    let bar_path = case.workspace_path("bar.py");
     let bar_file = case.system_file(&bar_path).unwrap();
-    let foo_path = case.project_path("foo.py");
+    let foo_path = case.workspace_path("foo.py");
 
     assert_eq!(case.system_file(&foo_path), Err(FileError::NotFound));
-    assert_eq!(&case.collect_project_files(), &[bar_file]);
+    assert_eq!(&case.collect_package_files(&bar_path), &[bar_file]);
 
     std::fs::write(foo_path.as_std_path(), "print('Hello')")?;
 
@@ -373,7 +374,7 @@ fn new_file() -> anyhow::Result<()> {
 
     let foo = case.system_file(&foo_path).expect("foo.py to exist.");
 
-    assert_eq!(&case.collect_project_files(), &[bar_file, foo]);
+    assert_eq!(&case.collect_package_files(&bar_path), &[bar_file, foo]);
 
     Ok(())
 }
@@ -381,12 +382,12 @@ fn new_file() -> anyhow::Result<()> {
 #[test]
 fn new_ignored_file() -> anyhow::Result<()> {
     let mut case = setup([("bar.py", ""), (".ignore", "foo.py")])?;
-    let bar_path = case.project_path("bar.py");
+    let bar_path = case.workspace_path("bar.py");
     let bar_file = case.system_file(&bar_path).unwrap();
-    let foo_path = case.project_path("foo.py");
+    let foo_path = case.workspace_path("foo.py");
 
     assert_eq!(case.system_file(&foo_path), Err(FileError::NotFound));
-    assert_eq!(&case.collect_project_files(), &[bar_file]);
+    assert_eq!(&case.collect_package_files(&bar_path), &[bar_file]);
 
     std::fs::write(foo_path.as_std_path(), "print('Hello')")?;
 
@@ -395,7 +396,7 @@ fn new_ignored_file() -> anyhow::Result<()> {
     case.apply_changes(changes);
 
     assert!(case.system_file(&foo_path).is_ok());
-    assert_eq!(&case.collect_project_files(), &[bar_file]);
+    assert_eq!(&case.collect_package_files(&bar_path), &[bar_file]);
 
     Ok(())
 }
@@ -404,11 +405,11 @@ fn new_ignored_file() -> anyhow::Result<()> {
 fn changed_file() -> anyhow::Result<()> {
     let foo_source = "print('Hello, world!')";
     let mut case = setup([("foo.py", foo_source)])?;
-    let foo_path = case.project_path("foo.py");
+    let foo_path = case.workspace_path("foo.py");
 
     let foo = case.system_file(&foo_path)?;
     assert_eq!(source_text(case.db(), foo).as_str(), foo_source);
-    assert_eq!(&case.collect_project_files(), &[foo]);
+    assert_eq!(&case.collect_package_files(&foo_path), &[foo]);
 
     update_file(&foo_path, "print('Version 2')")?;
 
@@ -419,7 +420,7 @@ fn changed_file() -> anyhow::Result<()> {
     case.apply_changes(changes);
 
     assert_eq!(source_text(case.db(), foo).as_str(), "print('Version 2')");
-    assert_eq!(&case.collect_project_files(), &[foo]);
+    assert_eq!(&case.collect_package_files(&foo_path), &[foo]);
 
     Ok(())
 }
@@ -428,12 +429,12 @@ fn changed_file() -> anyhow::Result<()> {
 fn deleted_file() -> anyhow::Result<()> {
     let foo_source = "print('Hello, world!')";
     let mut case = setup([("foo.py", foo_source)])?;
-    let foo_path = case.project_path("foo.py");
+    let foo_path = case.workspace_path("foo.py");
 
     let foo = case.system_file(&foo_path)?;
 
     assert!(foo.exists(case.db()));
-    assert_eq!(&case.collect_project_files(), &[foo]);
+    assert_eq!(&case.collect_package_files(&foo_path), &[foo]);
 
     std::fs::remove_file(foo_path.as_std_path())?;
 
@@ -442,7 +443,7 @@ fn deleted_file() -> anyhow::Result<()> {
     case.apply_changes(changes);
 
     assert!(!foo.exists(case.db()));
-    assert_eq!(&case.collect_project_files(), &[] as &[File]);
+    assert_eq!(&case.collect_package_files(&foo_path), &[] as &[File]);
 
     Ok(())
 }
@@ -454,7 +455,7 @@ fn deleted_file() -> anyhow::Result<()> {
 fn move_file_to_trash() -> anyhow::Result<()> {
     let foo_source = "print('Hello, world!')";
     let mut case = setup([("foo.py", foo_source)])?;
-    let foo_path = case.project_path("foo.py");
+    let foo_path = case.workspace_path("foo.py");
 
     let trash_path = case.root_path().join(".trash");
     std::fs::create_dir_all(trash_path.as_std_path())?;
@@ -462,7 +463,7 @@ fn move_file_to_trash() -> anyhow::Result<()> {
     let foo = case.system_file(&foo_path)?;
 
     assert!(foo.exists(case.db()));
-    assert_eq!(&case.collect_project_files(), &[foo]);
+    assert_eq!(&case.collect_package_files(&foo_path), &[foo]);
 
     std::fs::rename(
         foo_path.as_std_path(),
@@ -474,50 +475,58 @@ fn move_file_to_trash() -> anyhow::Result<()> {
     case.apply_changes(changes);
 
     assert!(!foo.exists(case.db()));
-    assert_eq!(&case.collect_project_files(), &[] as &[File]);
+    assert_eq!(&case.collect_package_files(&foo_path), &[] as &[File]);
 
     Ok(())
 }
 
-/// Move a file from a non-project (non-watched) location into the project.
+/// Move a file from a non-workspace (non-watched) location into the workspace.
 #[test]
-fn move_file_to_project() -> anyhow::Result<()> {
+fn move_file_to_workspace() -> anyhow::Result<()> {
     let mut case = setup([("bar.py", "")])?;
-    let bar_path = case.project_path("bar.py");
+    let bar_path = case.workspace_path("bar.py");
     let bar = case.system_file(&bar_path).unwrap();
 
     let foo_path = case.root_path().join("foo.py");
     std::fs::write(foo_path.as_std_path(), "")?;
 
-    let foo_in_project = case.project_path("foo.py");
+    let foo_in_workspace_path = case.workspace_path("foo.py");
 
     assert!(case.system_file(&foo_path).is_ok());
-    assert_eq!(&case.collect_project_files(), &[bar]);
+    assert_eq!(&case.collect_package_files(&bar_path), &[bar]);
+    assert!(case
+        .db()
+        .workspace()
+        .package(case.db(), &foo_path)
+        .is_none());
 
-    std::fs::rename(foo_path.as_std_path(), foo_in_project.as_std_path())?;
+    std::fs::rename(foo_path.as_std_path(), foo_in_workspace_path.as_std_path())?;
 
     let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
-    let foo_in_project = case.system_file(&foo_in_project)?;
+    let foo_in_workspace = case.system_file(&foo_in_workspace_path)?;
 
-    assert!(foo_in_project.exists(case.db()));
-    assert_eq!(&case.collect_project_files(), &[bar, foo_in_project]);
+    assert!(foo_in_workspace.exists(case.db()));
+    assert_eq!(
+        &case.collect_package_files(&foo_in_workspace_path),
+        &[bar, foo_in_workspace]
+    );
 
     Ok(())
 }
 
-/// Rename a project file.
+/// Rename a workspace file.
 #[test]
 fn rename_file() -> anyhow::Result<()> {
     let mut case = setup([("foo.py", "")])?;
-    let foo_path = case.project_path("foo.py");
-    let bar_path = case.project_path("bar.py");
+    let foo_path = case.workspace_path("foo.py");
+    let bar_path = case.workspace_path("bar.py");
 
     let foo = case.system_file(&foo_path)?;
 
-    assert_eq!(case.collect_project_files(), [foo]);
+    assert_eq!(case.collect_package_files(&foo_path), [foo]);
 
     std::fs::rename(foo_path.as_std_path(), bar_path.as_std_path())?;
 
@@ -530,15 +539,15 @@ fn rename_file() -> anyhow::Result<()> {
     let bar = case.system_file(&bar_path)?;
 
     assert!(bar.exists(case.db()));
-    assert_eq!(case.collect_project_files(), [bar]);
+    assert_eq!(case.collect_package_files(&foo_path), [bar]);
 
     Ok(())
 }
 
 #[test]
-fn directory_moved_to_project() -> anyhow::Result<()> {
+fn directory_moved_to_workspace() -> anyhow::Result<()> {
     let mut case = setup([("bar.py", "import sub.a")])?;
-    let bar = case.system_file(case.project_path("bar.py")).unwrap();
+    let bar = case.system_file(case.workspace_path("bar.py")).unwrap();
 
     let sub_original_path = case.root_path().join("sub");
     let init_original_path = sub_original_path.join("__init__.py");
@@ -556,9 +565,12 @@ fn directory_moved_to_project() -> anyhow::Result<()> {
     );
 
     assert_eq!(sub_a_module, None);
-    assert_eq!(case.collect_project_files(), &[bar]);
+    assert_eq!(
+        case.collect_package_files(&case.workspace_path("bar.py")),
+        &[bar]
+    );
 
-    let sub_new_path = case.project_path("sub");
+    let sub_new_path = case.workspace_path("sub");
     std::fs::rename(sub_original_path.as_std_path(), sub_new_path.as_std_path())
         .with_context(|| "Failed to move sub directory")?;
 
@@ -580,7 +592,10 @@ fn directory_moved_to_project() -> anyhow::Result<()> {
     )
     .is_some());
 
-    assert_eq!(case.collect_project_files(), &[bar, init_file, a_file]);
+    assert_eq!(
+        case.collect_package_files(&case.workspace_path("bar.py")),
+        &[bar, init_file, a_file]
+    );
 
     Ok(())
 }
@@ -592,7 +607,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
         ("sub/__init__.py", ""),
         ("sub/a.py", ""),
     ])?;
-    let bar = case.system_file(case.project_path("bar.py")).unwrap();
+    let bar = case.system_file(case.workspace_path("bar.py")).unwrap();
 
     assert!(resolve_module(
         case.db().upcast(),
@@ -600,7 +615,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
     )
     .is_some());
 
-    let sub_path = case.project_path("sub");
+    let sub_path = case.workspace_path("sub");
     let init_file = case
         .system_file(sub_path.join("__init__.py"))
         .expect("__init__.py to exist");
@@ -608,7 +623,10 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
         .system_file(sub_path.join("a.py"))
         .expect("a.py to exist");
 
-    assert_eq!(case.collect_project_files(), &[bar, init_file, a_file]);
+    assert_eq!(
+        case.collect_package_files(&case.workspace_path("bar.py")),
+        &[bar, init_file, a_file]
+    );
 
     std::fs::create_dir(case.root_path().join(".trash").as_std_path())?;
     let trashed_sub = case.root_path().join(".trash/sub");
@@ -629,7 +647,10 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
     assert!(!init_file.exists(case.db()));
     assert!(!a_file.exists(case.db()));
 
-    assert_eq!(case.collect_project_files(), &[bar]);
+    assert_eq!(
+        case.collect_package_files(&case.workspace_path("bar.py")),
+        &[bar]
+    );
 
     Ok(())
 }
@@ -642,7 +663,7 @@ fn directory_renamed() -> anyhow::Result<()> {
         ("sub/a.py", ""),
     ])?;
 
-    let bar = case.system_file(case.project_path("bar.py")).unwrap();
+    let bar = case.system_file(case.workspace_path("bar.py")).unwrap();
 
     assert!(resolve_module(
         case.db().upcast(),
@@ -655,7 +676,7 @@ fn directory_renamed() -> anyhow::Result<()> {
     )
     .is_none());
 
-    let sub_path = case.project_path("sub");
+    let sub_path = case.workspace_path("sub");
     let sub_init = case
         .system_file(sub_path.join("__init__.py"))
         .expect("__init__.py to exist");
@@ -663,11 +684,14 @@ fn directory_renamed() -> anyhow::Result<()> {
         .system_file(sub_path.join("a.py"))
         .expect("a.py to exist");
 
-    assert_eq!(case.collect_project_files(), &[bar, sub_init, sub_a]);
+    assert_eq!(
+        case.collect_package_files(&sub_path),
+        &[bar, sub_init, sub_a]
+    );
 
-    let foo_baz = case.project_path("foo/baz");
+    let foo_baz = case.workspace_path("foo/baz");
 
-    std::fs::create_dir(case.project_path("foo").as_std_path())?;
+    std::fs::create_dir(case.workspace_path("foo").as_std_path())?;
     std::fs::rename(sub_path.as_std_path(), foo_baz.as_std_path())
         .with_context(|| "Failed to move the sub directory")?;
 
@@ -706,7 +730,7 @@ fn directory_renamed() -> anyhow::Result<()> {
     assert!(foo_baz_a.exists(case.db()));
 
     assert_eq!(
-        case.collect_project_files(),
+        case.collect_package_files(&sub_path),
         &[bar, foo_baz_init, foo_baz_a]
     );
 
@@ -721,7 +745,7 @@ fn directory_deleted() -> anyhow::Result<()> {
         ("sub/a.py", ""),
     ])?;
 
-    let bar = case.system_file(case.project_path("bar.py")).unwrap();
+    let bar = case.system_file(case.workspace_path("bar.py")).unwrap();
 
     assert!(resolve_module(
         case.db().upcast(),
@@ -729,7 +753,7 @@ fn directory_deleted() -> anyhow::Result<()> {
     )
     .is_some());
 
-    let sub_path = case.project_path("sub");
+    let sub_path = case.workspace_path("sub");
 
     let init_file = case
         .system_file(sub_path.join("__init__.py"))
@@ -737,7 +761,10 @@ fn directory_deleted() -> anyhow::Result<()> {
     let a_file = case
         .system_file(sub_path.join("a.py"))
         .expect("a.py to exist");
-    assert_eq!(case.collect_project_files(), &[bar, init_file, a_file]);
+    assert_eq!(
+        case.collect_package_files(&sub_path),
+        &[bar, init_file, a_file]
+    );
 
     std::fs::remove_dir_all(sub_path.as_std_path())
         .with_context(|| "Failed to remove the sub directory")?;
@@ -755,20 +782,20 @@ fn directory_deleted() -> anyhow::Result<()> {
 
     assert!(!init_file.exists(case.db()));
     assert!(!a_file.exists(case.db()));
-    assert_eq!(case.collect_project_files(), &[bar]);
+    assert_eq!(case.collect_package_files(&sub_path), &[bar]);
 
     Ok(())
 }
 
 #[test]
 fn search_path() -> anyhow::Result<()> {
-    let mut case =
-        setup_with_search_paths([("bar.py", "import sub.a")], |root_path, _project_path| {
-            SearchPathConfiguration {
-                site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
-                ..SearchPathConfiguration::default()
-            }
-        })?;
+    let mut case = setup_with_search_paths(
+        [("bar.py", "import sub.a")],
+        |root_path, _workspace_path| SearchPathConfiguration {
+            site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
+            ..SearchPathConfiguration::default()
+        },
+    )?;
 
     let site_packages = case.root_path().join("site_packages");
 
@@ -785,8 +812,8 @@ fn search_path() -> anyhow::Result<()> {
 
     assert!(resolve_module(case.db().upcast(), &ModuleName::new_static("a").unwrap()).is_some());
     assert_eq!(
-        case.collect_project_files(),
-        &[case.system_file(case.project_path("bar.py")).unwrap()]
+        case.collect_package_files(&case.workspace_path("bar.py")),
+        &[case.system_file(case.workspace_path("bar.py")).unwrap()]
     );
 
     Ok(())
@@ -796,7 +823,7 @@ fn search_path() -> anyhow::Result<()> {
 fn add_search_path() -> anyhow::Result<()> {
     let mut case = setup([("bar.py", "import sub.a")])?;
 
-    let site_packages = case.project_path("site_packages");
+    let site_packages = case.workspace_path("site_packages");
     std::fs::create_dir_all(site_packages.as_std_path())?;
 
     assert!(resolve_module(case.db().upcast(), &ModuleName::new_static("a").unwrap()).is_none());
@@ -821,13 +848,13 @@ fn add_search_path() -> anyhow::Result<()> {
 
 #[test]
 fn remove_search_path() -> anyhow::Result<()> {
-    let mut case =
-        setup_with_search_paths([("bar.py", "import sub.a")], |root_path, _project_path| {
-            SearchPathConfiguration {
-                site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
-                ..SearchPathConfiguration::default()
-            }
-        })?;
+    let mut case = setup_with_search_paths(
+        [("bar.py", "import sub.a")],
+        |root_path, _workspace_path| SearchPathConfiguration {
+            site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
+            ..SearchPathConfiguration::default()
+        },
+    )?;
 
     // Remove site packages from the search path settings.
     let site_packages = case.root_path().join("site_packages");
@@ -849,8 +876,8 @@ fn remove_search_path() -> anyhow::Result<()> {
 #[test]
 fn changed_versions_file() -> anyhow::Result<()> {
     let mut case = setup_with_search_paths(
-        |root_path: &SystemPath, project_path: &SystemPath| {
-            std::fs::write(project_path.join("bar.py").as_std_path(), "import sub.a")?;
+        |root_path: &SystemPath, workspace_path: &SystemPath| {
+            std::fs::write(workspace_path.join("bar.py").as_std_path(), "import sub.a")?;
             std::fs::create_dir_all(root_path.join("typeshed/stdlib").as_std_path())?;
             std::fs::write(root_path.join("typeshed/stdlib/VERSIONS").as_std_path(), "")?;
             std::fs::write(
@@ -860,8 +887,8 @@ fn changed_versions_file() -> anyhow::Result<()> {
 
             Ok(())
         },
-        |root_path, _project_path| SearchPathConfiguration {
-            typeshed: Some(root_path.join("typeshed")),
+        |root_path, _workspace_path| SearchPathConfiguration {
+            custom_typeshed: Some(root_path.join("typeshed")),
             ..SearchPathConfiguration::default()
         },
     )?;
@@ -888,11 +915,11 @@ fn changed_versions_file() -> anyhow::Result<()> {
     Ok(())
 }
 
-/// Watch a project that contains two files where one file is a hardlink to another.
+/// Watch a workspace that contains two files where one file is a hardlink to another.
 ///
 /// Setup:
 /// ```text
-/// - project
+/// - workspace
 ///   |- foo.py
 ///   |- bar.py (hard link to foo.py)
 /// ```
@@ -908,22 +935,22 @@ fn changed_versions_file() -> anyhow::Result<()> {
 /// I haven't found any documentation that states the notification behavior on Windows but what
 /// we're seeing is that Windows only emits a single event, similar to Linux.
 #[test]
-fn hard_links_in_project() -> anyhow::Result<()> {
-    let mut case = setup(|_root: &SystemPath, project: &SystemPath| {
-        let foo_path = project.join("foo.py");
+fn hard_links_in_workspace() -> anyhow::Result<()> {
+    let mut case = setup(|_root: &SystemPath, workspace: &SystemPath| {
+        let foo_path = workspace.join("foo.py");
         std::fs::write(foo_path.as_std_path(), "print('Version 1')")?;
 
         // Create a hardlink to `foo`
-        let bar_path = project.join("bar.py");
+        let bar_path = workspace.join("bar.py");
         std::fs::hard_link(foo_path.as_std_path(), bar_path.as_std_path())
             .context("Failed to create hard link from foo.py -> bar.py")?;
 
         Ok(())
     })?;
 
-    let foo_path = case.project_path("foo.py");
+    let foo_path = case.workspace_path("foo.py");
     let foo = case.system_file(&foo_path).unwrap();
-    let bar_path = case.project_path("bar.py");
+    let bar_path = case.workspace_path("bar.py");
     let bar = case.system_file(&bar_path).unwrap();
 
     assert_eq!(source_text(case.db(), foo).as_str(), "print('Version 1')");
@@ -946,12 +973,12 @@ fn hard_links_in_project() -> anyhow::Result<()> {
     Ok(())
 }
 
-/// Watch a project that contains one file that is a hardlink to a file outside the project.
+/// Watch a workspace that contains one file that is a hardlink to a file outside the workspace.
 ///
 /// Setup:
 /// ```text
 /// - foo.py
-/// - project
+/// - workspace
 ///   |- bar.py (hard link to /foo.py)
 /// ```
 ///
@@ -969,7 +996,7 @@ fn hard_links_in_project() -> anyhow::Result<()> {
 /// [source](https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-readdirectorychangesw)
 ///
 /// My interpretation of this is that Windows doesn't support observing changes made to
-/// hard linked files outside the project.
+/// hard linked files outside the workspace.
 #[test]
 #[cfg_attr(
     target_os = "linux",
@@ -979,13 +1006,13 @@ fn hard_links_in_project() -> anyhow::Result<()> {
     target_os = "windows",
     ignore = "windows doesn't support observing changes to hard linked files."
 )]
-fn hard_links_to_target_outside_project() -> anyhow::Result<()> {
-    let mut case = setup(|root: &SystemPath, project: &SystemPath| {
+fn hard_links_to_target_outside_workspace() -> anyhow::Result<()> {
+    let mut case = setup(|root: &SystemPath, workspace: &SystemPath| {
         let foo_path = root.join("foo.py");
         std::fs::write(foo_path.as_std_path(), "print('Version 1')")?;
 
         // Create a hardlink to `foo`
-        let bar_path = project.join("bar.py");
+        let bar_path = workspace.join("bar.py");
         std::fs::hard_link(foo_path.as_std_path(), bar_path.as_std_path())
             .context("Failed to create hard link from foo.py -> bar.py")?;
 
@@ -994,7 +1021,7 @@ fn hard_links_to_target_outside_project() -> anyhow::Result<()> {
 
     let foo_path = case.root_path().join("foo.py");
     let foo = case.system_file(&foo_path).unwrap();
-    let bar_path = case.project_path("bar.py");
+    let bar_path = case.workspace_path("bar.py");
     let bar = case.system_file(&bar_path).unwrap();
 
     assert_eq!(source_text(case.db(), foo).as_str(), "print('Version 1')");
@@ -1017,13 +1044,13 @@ mod unix {
     //! Tests that make use of unix specific file-system features.
     use super::*;
 
-    /// Changes the metadata of the only file in the project.
+    /// Changes the metadata of the only file in the workspace.
     #[test]
     fn changed_metadata() -> anyhow::Result<()> {
         use std::os::unix::fs::PermissionsExt;
 
         let mut case = setup([("foo.py", "")])?;
-        let foo_path = case.project_path("foo.py");
+        let foo_path = case.workspace_path("foo.py");
 
         let foo = case.system_file(&foo_path)?;
         assert_eq!(
@@ -1059,14 +1086,14 @@ mod unix {
         Ok(())
     }
 
-    /// A project path is a symlink to a file outside the project.
+    /// A workspace path is a symlink to a file outside the workspace.
     ///
     /// Setup:
     /// ```text
     /// - bar
     ///   |- baz.py
     ///
-    /// - project
+    /// - workspace
     ///   |- bar -> /bar
     /// ```
     ///
@@ -1088,7 +1115,7 @@ mod unix {
         ignore = "FSEvents doesn't emit change events for symlinked directories outside of the watched paths."
     )]
     fn symlink_target_outside_watched_paths() -> anyhow::Result<()> {
-        let mut case = setup(|root: &SystemPath, project: &SystemPath| {
+        let mut case = setup(|root: &SystemPath, workspace: &SystemPath| {
             // Set up the symlink target.
             let link_target = root.join("bar");
             std::fs::create_dir_all(link_target.as_std_path())
@@ -1097,8 +1124,8 @@ mod unix {
             std::fs::write(baz_original.as_std_path(), "def baz(): ...")
                 .context("Failed to write link target file")?;
 
-            // Create a symlink inside the project
-            let bar = project.join("bar");
+            // Create a symlink inside the workspace
+            let bar = workspace.join("bar");
             std::os::unix::fs::symlink(link_target.as_std_path(), bar.as_std_path())
                 .context("Failed to create symlink to bar package")?;
 
@@ -1110,7 +1137,7 @@ mod unix {
             &ModuleName::new_static("bar.baz").unwrap(),
         )
         .expect("Expected bar.baz to exist in site-packages.");
-        let baz_project = case.project_path("bar/baz.py");
+        let baz_workspace = case.workspace_path("bar/baz.py");
 
         assert_eq!(
             source_text(case.db(), baz.file()).as_str(),
@@ -1118,7 +1145,7 @@ mod unix {
         );
         assert_eq!(
             baz.file().path(case.db()).as_system_path(),
-            Some(&*baz_project)
+            Some(&*baz_workspace)
         );
 
         let baz_original = case.root_path().join("bar/baz.py");
@@ -1137,7 +1164,7 @@ mod unix {
         );
 
         // Write to the symlink source.
-        update_file(baz_project, "def baz(): print('Version 3')")
+        update_file(baz_workspace, "def baz(): print('Version 3')")
             .context("Failed to update bar/baz.py")?;
 
         let changes = case.stop_watch(event_for_file("baz.py"));
@@ -1152,14 +1179,14 @@ mod unix {
         Ok(())
     }
 
-    /// Project contains a symlink to another directory inside the project.
+    /// Workspace contains a symlink to another directory inside the workspace.
     /// Changes to files in the symlinked directory should be reflected
     /// to all files.
     ///
     /// Setup:
     /// ```text
-    /// - project
-    ///   | - bar -> /project/patched/bar
+    /// - workspace
+    ///   | - bar -> /workspace/patched/bar
     ///   |
     ///   | - patched
     ///   |   |-- bar
@@ -1168,10 +1195,10 @@ mod unix {
     ///   |-- foo.py
     /// ```
     #[test]
-    fn symlink_inside_project() -> anyhow::Result<()> {
-        let mut case = setup(|_root: &SystemPath, project: &SystemPath| {
+    fn symlink_inside_workspace() -> anyhow::Result<()> {
+        let mut case = setup(|_root: &SystemPath, workspace: &SystemPath| {
             // Set up the symlink target.
-            let link_target = project.join("patched/bar");
+            let link_target = workspace.join("patched/bar");
             std::fs::create_dir_all(link_target.as_std_path())
                 .context("Failed to create link target directory")?;
             let baz_original = link_target.join("baz.py");
@@ -1179,8 +1206,8 @@ mod unix {
                 .context("Failed to write link target file")?;
 
             // Create a symlink inside site-packages
-            let bar_in_project = project.join("bar");
-            std::os::unix::fs::symlink(link_target.as_std_path(), bar_in_project.as_std_path())
+            let bar_in_workspace = workspace.join("bar");
+            std::os::unix::fs::symlink(link_target.as_std_path(), bar_in_workspace.as_std_path())
                 .context("Failed to create symlink to bar package")?;
 
             Ok(())
@@ -1191,9 +1218,9 @@ mod unix {
             &ModuleName::new_static("bar.baz").unwrap(),
         )
         .expect("Expected bar.baz to exist in site-packages.");
-        let bar_baz = case.project_path("bar/baz.py");
+        let bar_baz = case.workspace_path("bar/baz.py");
 
-        let patched_bar_baz = case.project_path("patched/bar/baz.py");
+        let patched_bar_baz = case.workspace_path("patched/bar/baz.py");
         let patched_bar_baz_file = case.system_file(&patched_bar_baz).unwrap();
 
         assert_eq!(
@@ -1252,7 +1279,7 @@ mod unix {
     /// - site-packages
     ///   | - bar/baz.py
     ///
-    /// - project
+    /// - workspace
     ///   |-- .venv/lib/python3.12/site-packages -> /site-packages
     ///   |
     ///   |-- foo.py
@@ -1260,7 +1287,7 @@ mod unix {
     #[test]
     fn symlinked_module_search_path() -> anyhow::Result<()> {
         let mut case = setup_with_search_paths(
-            |root: &SystemPath, project: &SystemPath| {
+            |root: &SystemPath, workspace: &SystemPath| {
                 // Set up the symlink target.
                 let site_packages = root.join("site-packages");
                 let bar = site_packages.join("bar");
@@ -1271,7 +1298,7 @@ mod unix {
                     .context("Failed to write baz.py")?;
 
                 // Symlink the site packages in the venv to the global site packages
-                let venv_site_packages = project.join(".venv/lib/python3.12/site-packages");
+                let venv_site_packages = workspace.join(".venv/lib/python3.12/site-packages");
                 std::fs::create_dir_all(venv_site_packages.parent().unwrap())
                     .context("Failed to create .venv directory")?;
                 std::os::unix::fs::symlink(
@@ -1282,9 +1309,9 @@ mod unix {
 
                 Ok(())
             },
-            |_root, project| SearchPathConfiguration {
+            |_root, workspace| SearchPathConfiguration {
                 site_packages: Some(SitePackages::Known(vec![
-                    project.join(".venv/lib/python3.12/site-packages")
+                    workspace.join(".venv/lib/python3.12/site-packages")
                 ])),
                 ..SearchPathConfiguration::default()
             },
@@ -1296,7 +1323,7 @@ mod unix {
         )
         .expect("Expected bar.baz to exist in site-packages.");
         let baz_site_packages_path =
-            case.project_path(".venv/lib/python3.12/site-packages/bar/baz.py");
+            case.workspace_path(".venv/lib/python3.12/site-packages/bar/baz.py");
         let baz_site_packages = case.system_file(&baz_site_packages_path).unwrap();
         let baz_original = case.root_path().join("site-packages/bar/baz.py");
         let baz_original_file = case.system_file(&baz_original).unwrap();
@@ -1345,15 +1372,13 @@ mod unix {
 }
 
 #[test]
-fn nested_projects_delete_root() -> anyhow::Result<()> {
-    let mut case = setup(|root: &SystemPath, project_root: &SystemPath| {
+fn nested_packages_delete_root() -> anyhow::Result<()> {
+    let mut case = setup(|root: &SystemPath, workspace_root: &SystemPath| {
         std::fs::write(
-            project_root.join("pyproject.toml").as_std_path(),
+            workspace_root.join("pyproject.toml").as_std_path(),
             r#"
             [project]
             name = "inner"
-
-            [tool.knot]
             "#,
         )?;
 
@@ -1362,24 +1387,120 @@ fn nested_projects_delete_root() -> anyhow::Result<()> {
             r#"
             [project]
             name = "outer"
-
-            [tool.knot]
             "#,
         )?;
 
         Ok(())
     })?;
 
-    assert_eq!(case.db().project().root(case.db()), &*case.project_path(""));
+    assert_eq!(
+        case.db().workspace().root(case.db()),
+        &*case.workspace_path("")
+    );
 
-    std::fs::remove_file(case.project_path("pyproject.toml").as_std_path())?;
+    std::fs::remove_file(case.workspace_path("pyproject.toml").as_std_path())?;
 
     let changes = case.stop_watch(ChangeEvent::is_deleted);
 
     case.apply_changes(changes);
 
-    // It should now pick up the outer project.
-    assert_eq!(case.db().project().root(case.db()), case.root_path());
+    // It should now pick up the outer workspace.
+    assert_eq!(case.db().workspace().root(case.db()), case.root_path());
+
+    Ok(())
+}
+
+#[test]
+fn added_package() -> anyhow::Result<()> {
+    let mut case = setup([
+        (
+            "pyproject.toml",
+            r#"
+            [project]
+            name = "inner"
+
+            [tool.knot.workspace]
+            members = ["packages/*"]
+            "#,
+        ),
+        (
+            "packages/a/pyproject.toml",
+            r#"
+            [project]
+            name = "a"
+            "#,
+        ),
+    ])?;
+
+    assert_eq!(case.db().workspace().packages(case.db()).len(), 2);
+
+    std::fs::create_dir(case.workspace_path("packages/b").as_std_path())
+        .context("failed to create folder for package 'b'")?;
+
+    // It seems that the file watcher won't pick up on file changes shortly after the folder
+    // was created... I suspect this is because most file watchers don't support recursive
+    // file watching. Instead, file-watching libraries manually implement recursive file watching
+    // by setting a watcher for each directory. But doing this obviously "lags" behind.
+    case.take_watch_changes();
+
+    std::fs::write(
+        case.workspace_path("packages/b/pyproject.toml")
+            .as_std_path(),
+        r#"
+            [project]
+            name = "b"
+            "#,
+    )
+    .context("failed to write pyproject.toml for package b")?;
+
+    let changes = case.stop_watch(event_for_file("pyproject.toml"));
+
+    case.apply_changes(changes);
+
+    assert_eq!(case.db().workspace().packages(case.db()).len(), 3);
+
+    Ok(())
+}
+
+#[test]
+fn removed_package() -> anyhow::Result<()> {
+    let mut case = setup([
+        (
+            "pyproject.toml",
+            r#"
+            [project]
+            name = "inner"
+
+            [tool.knot.workspace]
+            members = ["packages/*"]
+            "#,
+        ),
+        (
+            "packages/a/pyproject.toml",
+            r#"
+            [project]
+            name = "a"
+            "#,
+        ),
+        (
+            "packages/b/pyproject.toml",
+            r#"
+            [project]
+            name = "b"
+            "#,
+        ),
+    ])?;
+
+    assert_eq!(case.db().workspace().packages(case.db()).len(), 3);
+
+    std::fs::remove_dir_all(case.workspace_path("packages/b").as_std_path())
+        .context("failed to remove package 'b'")?;
+
+    let changes = case.stop_watch(ChangeEvent::is_deleted);
+
+    case.apply_changes(changes);
+
+    assert_eq!(case.db().workspace().packages(case.db()).len(), 2);
 
     Ok(())
 }

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

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

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

@@ -77,7 +77,7 @@ def _(s: Subclass):
 ```py
 from typing import Any
 
-# error: [invalid-type-form] "Type `typing.Any` expected no type parameter"
+# error: [invalid-type-parameter] "Type `typing.Any` expected no type parameter"
 def f(x: Any[int]):
     reveal_type(x)  # revealed: Unknown
 ```

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

@@ -1,153 +0,0 @@
-# Literal
-
-<https://typing.readthedocs.io/en/latest/spec/literal.html#literals>
-
-## Parameterization
-
-```py
-from typing import Literal
-from enum import Enum
-
-mode: Literal["w", "r"]
-a1: Literal[26]
-a2: Literal[0x1A]
-a3: Literal[-4]
-a4: Literal["hello world"]
-a5: Literal[b"hello world"]
-a6: Literal[True]
-a7: Literal[None]
-a8: Literal[Literal[1]]
-
-class Color(Enum):
-    RED = 0
-    GREEN = 1
-    BLUE = 2
-
-b1: Literal[Color.RED]
-
-def f():
-    reveal_type(mode)  # revealed: Literal["w", "r"]
-    reveal_type(a1)  # revealed: Literal[26]
-    reveal_type(a2)  # revealed: Literal[26]
-    reveal_type(a3)  # revealed: Literal[-4]
-    reveal_type(a4)  # revealed: Literal["hello world"]
-    reveal_type(a5)  # revealed: Literal[b"hello world"]
-    reveal_type(a6)  # revealed: Literal[True]
-    reveal_type(a7)  # revealed: None
-    reveal_type(a8)  # revealed: Literal[1]
-    # TODO: This should be Color.RED
-    reveal_type(b1)  # revealed: Literal[0]
-
-# error: [invalid-type-form]
-invalid1: Literal[3 + 4]
-# error: [invalid-type-form]
-invalid2: Literal[4 + 3j]
-# error: [invalid-type-form]
-invalid3: Literal[(3, 4)]
-
-hello = "hello"
-invalid4: Literal[
-    1 + 2,  # error: [invalid-type-form]
-    "foo",
-    hello,  # error: [invalid-type-form]
-    (1, 2, 3),  # error: [invalid-type-form]
-]
-```
-
-## Shortening unions of literals
-
-When a Literal is parameterized with more than one value, it’s treated as exactly to equivalent to
-the union of those types.
-
-```py
-from typing import Literal
-
-def x(
-    a1: Literal[Literal[Literal[1, 2, 3], "foo"], 5, None],
-    a2: Literal["w"] | Literal["r"],
-    a3: Literal[Literal["w"], Literal["r"], Literal[Literal["w+"]]],
-    a4: Literal[True] | Literal[1, 2] | Literal["foo"],
-):
-    reveal_type(a1)  # revealed: Literal[1, 2, 3, "foo", 5] | None
-    reveal_type(a2)  # revealed: Literal["w", "r"]
-    reveal_type(a3)  # revealed: Literal["w", "r", "w+"]
-    reveal_type(a4)  # revealed: Literal[True, 1, 2, "foo"]
-```
-
-## Display of heterogeneous unions of literals
-
-```py
-from typing import Literal, Union
-
-def foo(x: int) -> int:
-    return x + 1
-
-def bar(s: str) -> str:
-    return s
-
-class A: ...
-class B: ...
-
-def union_example(
-    x: Union[
-        # unknown type
-        # error: [unresolved-reference]
-        y,
-        Literal[-1],
-        Literal["A"],
-        Literal[b"A"],
-        Literal[b"\x00"],
-        Literal[b"\x07"],
-        Literal[0],
-        Literal[1],
-        Literal["B"],
-        Literal["foo"],
-        Literal["bar"],
-        Literal["B"],
-        Literal[True],
-        None,
-    ]
-):
-    reveal_type(x)  # revealed: Unknown | Literal[-1, "A", b"A", b"\x00", b"\x07", 0, 1, "B", "foo", "bar", True] | None
-```
-
-## Detecting Literal outside typing and typing_extensions
-
-Only Literal that is defined in typing and typing_extension modules is detected as the special
-Literal.
-
-```pyi path=other.pyi
-from typing import _SpecialForm
-
-Literal: _SpecialForm
-```
-
-```py
-from other import Literal
-
-a1: Literal[26]
-
-def f():
-    reveal_type(a1)  # revealed: @Todo(generics)
-```
-
-## Detecting typing_extensions.Literal
-
-```py
-from typing_extensions import Literal
-
-a1: Literal[26]
-
-def f():
-    reveal_type(a1)  # revealed: Literal[26]
-```
-
-## Invalid
-
-```py
-from typing import Literal
-
-# error: [invalid-type-form] "`Literal` requires at least one argument when used in a type expression"
-def _(x: Literal):
-    reveal_type(x)  # revealed: Unknown
-```

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

@@ -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
@@ -107,7 +107,7 @@ def _(flag: bool):
     qux_2: Literal["qux"] = baz_2  # error: [invalid-assignment]
 
     baz_3 = "foo" if flag else 1
-    reveal_type(baz_3)  # revealed: Literal["foo", 1]
+    reveal_type(baz_3)  # revealed: Literal["foo"] | Literal[1]
     qux_3: LiteralString = baz_3  # error: [invalid-assignment]
 ```
 
@@ -135,7 +135,7 @@ if "" < lorem == "ipsum":
 
 ```toml
 [environment]
-python-version = "3.11"
+target-version = "3.11"
 ```
 
 ```py

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

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__)
-```

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

@@ -105,7 +105,7 @@ def f1(
 from typing import Literal
 
 def f(v: Literal["a", r"b", b"c", "d" "e", "\N{LATIN SMALL LETTER F}", "\x67", """h"""]):
-    reveal_type(v)  # revealed: Literal["a", "b", b"c", "de", "f", "g", "h"]
+    reveal_type(v)  # revealed: Literal["a", "b", "de", "f", "g", "h"] | Literal[b"c"]
 ```
 
 ## Class variables
@@ -173,40 +173,3 @@ p: "call()"
 r: "[1, 2]"
 s: "(1, 2)"
 ```
-
-## Multi line annotation
-
-Quoted type annotations should be parsed as if surrounded by parentheses.
-
-```py
-def valid(
-    a1: """(
-      int |
-      str
-  )
-  """,
-    a2: """
-     int |
-       str
-  """,
-):
-    reveal_type(a1)  # revealed: int | str
-    reveal_type(a2)  # revealed: int | str
-
-def invalid(
-    # error: [invalid-syntax-in-forward-annotation]
-    a1: """
-  int |
-str)
-""",
-    # error: [invalid-syntax-in-forward-annotation]
-    a2: """
-  int) |
-str
-""",
-    # error: [invalid-syntax-in-forward-annotation]
-    a3: """
-      (int)) """,
-):
-    pass
-```

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

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

@@ -1,34 +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, Required, NotRequired, ReadOnly, TypedDict
-
-X: Final = 42
-Y: Final[int] = 42
-
-# TODO: `TypedDict` is actually valid as a base
-# error: [invalid-base]
-class Bar(TypedDict):
-    x: Required[int]
-    y: NotRequired[str]
-    z: ReadOnly[bytes]
-```
-
-## Inheritance
-
-You can't inherit from a type qualifier.
-
-```py
-from typing_extensions import Final, ClassVar, Required, NotRequired, ReadOnly
-
-class A(Final): ...  # error: [invalid-base]
-class B(ClassVar): ...  # error: [invalid-base]
-class C(Required): ...  # error: [invalid-base]
-class D(NotRequired): ...  # error: [invalid-base]
-class E(ReadOnly): ...  # error: [invalid-base]
-```

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

@@ -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]] = ([], [])
@@ -122,10 +124,3 @@ class Foo: ...
 x = Foo()
 reveal_type(x)  # revealed: Foo
 ```
-
-## Annotated assignments in stub files are inferred correctly
-
-```pyi path=main.pyi
-x: int = 1
-reveal_type(x) # revealed: Literal[1]
-```

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

@@ -40,9 +40,9 @@ class C:
         return 42
 
 x = C()
-# error: [invalid-argument-type]
 x -= 1
 
+# TODO: should error, once operand type check is implemented
 reveal_type(x)  # revealed: int
 ```
 

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -1,273 +1,4 @@
-# Attributes
-
-Tests for attribute access on various kinds of types.
-
-## Class and instance variables
-
-### Pure instance variables
-
-#### Variable only declared/bound in `__init__`
-
-Variables only declared and/or bound in `__init__` are pure instance variables. They cannot be
-accessed on the class itself.
-
-```py
-class C:
-    def __init__(self, value2: int, flag: bool = False) -> None:
-        # bound but not declared
-        self.pure_instance_variable1 = "value set in __init__"
-
-        # bound but not declared - with type inferred from parameter
-        self.pure_instance_variable2 = value2
-
-        # declared but not bound
-        self.pure_instance_variable3: bytes
-
-        # declared and bound
-        self.pure_instance_variable4: bool = True
-
-        # possibly undeclared/unbound
-        if flag:
-            self.pure_instance_variable5: str = "possibly set in __init__"
-
-c_instance = C(1)
-
-# TODO: should be `Literal["value set in __init__"]`, or `Unknown | Literal[…]` to allow
-# assignments to this unannotated attribute from other scopes.
-reveal_type(c_instance.pure_instance_variable1)  # revealed: @Todo(instance attributes)
-
-# TODO: should be `int`
-reveal_type(c_instance.pure_instance_variable2)  # revealed: @Todo(instance attributes)
-
-# TODO: should be `bytes`
-reveal_type(c_instance.pure_instance_variable3)  # revealed: @Todo(instance attributes)
-
-# TODO: should be `bool`
-reveal_type(c_instance.pure_instance_variable4)  # revealed: @Todo(instance attributes)
-
-# TODO: should be `str`
-# We probably don't want to emit a diagnostic for this being possibly undeclared/unbound.
-# mypy and pyright do not show an error here.
-reveal_type(c_instance.pure_instance_variable5)  # revealed: @Todo(instance attributes)
-
-# TODO: If we choose to infer a precise `Literal[…]` type for the instance attribute (see
-# above), this should be an error: incompatible types in assignment. If we choose to infer
-# a gradual `Unknown | Literal[…]` type, this assignment is fine.
-c_instance.pure_instance_variable1 = "value set on instance"
-
-# TODO: this should be an error (incompatible types in assignment)
-c_instance.pure_instance_variable2 = "incompatible"
-
-# TODO: we already show an error here but the message might be improved?
-# mypy shows no error here, but pyright raises "reportAttributeAccessIssue"
-# error: [unresolved-attribute] "Type `Literal[C]` has no attribute `pure_instance_variable1`"
-reveal_type(C.pure_instance_variable1)  # revealed: Unknown
-
-# TODO: this should be an error (pure instance variables cannot be accessed on the class)
-# mypy shows no error here, but pyright raises "reportAttributeAccessIssue"
-C.pure_instance_variable1 = "overwritten on class"
-
-c_instance.pure_instance_variable4 = False
-
-# TODO: After this assignment to the attribute within this scope, we may eventually want to narrow
-# the `bool` type (see above) for this instance variable to `Literal[False]` here. This is unsound
-# in general (we don't know what else happened to `c_instance` between the assignment and the use
-# here), but mypy and pyright support this. In conclusion, this could be `bool` but should probably
-# be `Literal[False]`.
-reveal_type(c_instance.pure_instance_variable4)  # revealed: @Todo(instance attributes)
-```
-
-#### Variable declared in class body and declared/bound in `__init__`
-
-The same rule applies even if the variable is *declared* (not bound!) in the class body: it is still
-a pure instance variable.
-
-```py
-class C:
-    pure_instance_variable: str
-
-    def __init__(self) -> None:
-        self.pure_instance_variable = "value set in __init__"
-
-c_instance = C()
-
-# TODO: should be `str`
-reveal_type(c_instance.pure_instance_variable)  # revealed: @Todo(instance attributes)
-
-# TODO: we currently plan to emit a diagnostic here. Note that both mypy
-# and pyright show no error in this case! So we may reconsider this in
-# the future, if it turns out to produce too many false positives.
-reveal_type(C.pure_instance_variable)  # revealed: str
-
-# TODO: same as above. We plan to emit a diagnostic here, even if both mypy
-# and pyright allow this.
-C.pure_instance_variable = "overwritten on class"
-
-# TODO: this should be an error (incompatible types in assignment)
-c_instance.pure_instance_variable = 1
-```
-
-#### Variable only defined in unrelated method
-
-We also recognize pure instance variables if they are defined in a method that is not `__init__`.
-
-```py
-class C:
-    def set_instance_variable(self) -> None:
-        self.pure_instance_variable = "value set in method"
-
-c_instance = C()
-
-# Not that we would use this in static analysis, but for a more realistic example, let's actually
-# call the method, so that the attribute is bound if this example is actually run.
-c_instance.set_instance_variable()
-
-# TODO: should be `Literal["value set in method"]` or `Unknown | Literal[…]` (see above).
-reveal_type(c_instance.pure_instance_variable)  # revealed: @Todo(instance attributes)
-
-# TODO: We already show an error here, but the message might be improved?
-# error: [unresolved-attribute]
-reveal_type(C.pure_instance_variable)  # revealed: Unknown
-
-# TODO: this should be an error
-C.pure_instance_variable = "overwritten on class"
-```
-
-#### Variable declared in class body and not bound anywhere
-
-If a variable is declared in the class body but not bound anywhere, we still consider it a pure
-instance variable and allow access to it via instances.
-
-```py
-class C:
-    pure_instance_variable: str
-
-c_instance = C()
-
-# TODO: should be 'str'
-reveal_type(c_instance.pure_instance_variable)  # revealed: @Todo(instance attributes)
-
-# TODO: mypy and pyright do not show an error here, but we plan to emit a diagnostic.
-# The type could be changed to 'Unknown' if we decide to emit an error?
-reveal_type(C.pure_instance_variable)  # revealed: str
-
-# TODO: mypy and pyright do not show an error here, but we plan to emit one.
-C.pure_instance_variable = "overwritten on class"
-```
-
-### Pure class variables (`ClassVar`)
-
-#### Annotated with `ClassVar` type qualifier
-
-Class variables annotated with the [`typing.ClassVar`] type qualifier are pure class variables. They
-cannot be overwritten on instances, but they can be accessed on instances.
-
-For more details, see the [typing spec on `ClassVar`].
-
-```py
-from typing import ClassVar
-
-class C:
-    pure_class_variable1: ClassVar[str] = "value in class body"
-    pure_class_variable2: ClassVar = 1
-
-reveal_type(C.pure_class_variable1)  # revealed: str
-
-# TODO: this should be `Literal[1]`, or `Unknown | Literal[1]`.
-reveal_type(C.pure_class_variable2)  # revealed: @Todo(Unsupported or invalid type in a type expression)
-
-c_instance = C()
-
-# TODO: This should be `str`. It is okay to access a pure class variable on an instance.
-reveal_type(c_instance.pure_class_variable1)  # revealed: @Todo(instance attributes)
-
-# TODO: should raise an error. It is not allowed to reassign a pure class variable on an instance.
-c_instance.pure_class_variable1 = "value set on instance"
-
-C.pure_class_variable1 = "overwritten on class"
-
-# TODO: should raise an error (incompatible types in assignment)
-C.pure_class_variable1 = 1
-
-class Subclass(C):
-    pure_class_variable1: ClassVar[str] = "overwritten on subclass"
-
-reveal_type(Subclass.pure_class_variable1)  # revealed: str
-```
-
-#### Variable only mentioned in a class method
-
-We also consider a class variable to be a pure class variable if it is only mentioned in a class
-method.
-
-```py
-class C:
-    @classmethod
-    def class_method(cls):
-        cls.pure_class_variable = "value set in class method"
-
-# for a more realistic example, let's actually call the method
-C.class_method()
-
-# TODO: We currently plan to support this and show no error here.
-# mypy shows an error here, pyright does not.
-# error: [unresolved-attribute]
-reveal_type(C.pure_class_variable)  # revealed: Unknown
-
-C.pure_class_variable = "overwritten on class"
-
-# TODO: should be `Literal["overwritten on class"]`
-# error: [unresolved-attribute]
-reveal_type(C.pure_class_variable)  # revealed: Unknown
-
-c_instance = C()
-# TODO: should be `Literal["overwritten on class"]`
-reveal_type(c_instance.pure_class_variable)  # revealed: @Todo(instance attributes)
-
-# TODO: should raise an error.
-c_instance.pure_class_variable = "value set on instance"
-```
-
-### Instance variables with class-level default values
-
-These are instance attributes, but the fact that we can see that they have a binding (not a
-declaration) in the class body means that reading the value from the class directly is also
-permitted. This is the only difference for these attributes as opposed to "pure" instance
-attributes.
-
-#### Basic
-
-```py
-class C:
-    variable_with_class_default: str = "value in class body"
-
-    def instance_method(self):
-        self.variable_with_class_default = "value set in instance method"
-
-reveal_type(C.variable_with_class_default)  # revealed: str
-
-c_instance = C()
-
-# TODO: should be `str`
-reveal_type(c_instance.variable_with_class_default)  # revealed: @Todo(instance attributes)
-
-c_instance.variable_with_class_default = "value set on instance"
-
-reveal_type(C.variable_with_class_default)  # revealed: str
-
-# TODO: Could be Literal["value set on instance"], or still `str` if we choose not to
-# narrow the type.
-reveal_type(c_instance.variable_with_class_default)  # revealed: @Todo(instance attributes)
-
-C.variable_with_class_default = "overwritten on class"
-
-# TODO: Could be `Literal["overwritten on class"]`, or still `str` if we choose not to
-# narrow the type.
-reveal_type(C.variable_with_class_default)  # revealed: str
-
-# TODO: should still be `Literal["value set on instance"]`, or `str`.
-reveal_type(c_instance.variable_with_class_default)  # revealed: @Todo(instance attributes)
-```
+# Class attributes
 
 ## Union of attributes
 
@@ -291,9 +22,7 @@ def _(flag: bool):
     reveal_type(C2.x)  # revealed: Literal[3, 4]
 ```
 
-## Inherited class attributes
-
-### Basic
+## Inherited attributes
 
 ```py
 class A:
@@ -305,7 +34,7 @@ class C(B): ...
 reveal_type(C.X)  # revealed: Literal["foo"]
 ```
 
-### Multiple inheritance
+## Inherited attributes (multiple inheritance)
 
 ```py
 class O: ...
@@ -373,7 +102,7 @@ def _(flag: bool, flag1: bool, flag2: bool):
     reveal_type(C.x)  # revealed: Literal[1, 2, 3]
 ```
 
-### Unions with all paths unbound
+## Unions with all paths unbound
 
 If the symbol is unbound in all elements of the union, we detect that:
 
@@ -426,78 +155,3 @@ class Foo: ...
 
 reveal_type(Foo.__class__)  # revealed: Literal[type]
 ```
-
-## Literal types
-
-### 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]
-```
-
-### Bool-literal 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)
-```
-
-## References
-
-Some of the tests in the *Class and instance variables* section draw inspiration from
-[pyright's documentation] on this topic.
-
-[pyright's documentation]: https://microsoft.github.io/pyright/#/type-concepts-advanced?id=class-and-instance-variables
-[typing spec on `classvar`]: https://typing.readthedocs.io/en/latest/spec/class-compat.html#classvar
-[`typing.classvar`]: https://docs.python.org/3/library/typing.html#typing.ClassVar

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

@@ -46,50 +46,3 @@ reveal_type(a | b)  # revealed: Literal[True]
 reveal_type(b | a)  # revealed: Literal[True]
 reveal_type(b | b)  # revealed: Literal[False]
 ```
-
-## Arithmetic with a variable
-
-```py
-a = True
-b = False
-
-def lhs_is_int(x: int):
-    reveal_type(x + a)  # revealed: int
-    reveal_type(x - a)  # revealed: int
-    reveal_type(x * a)  # revealed: int
-    reveal_type(x // a)  # revealed: int
-    reveal_type(x / a)  # revealed: float
-    reveal_type(x % a)  # revealed: int
-
-def rhs_is_int(x: int):
-    reveal_type(a + x)  # revealed: int
-    reveal_type(a - x)  # revealed: int
-    reveal_type(a * x)  # revealed: int
-    reveal_type(a // x)  # revealed: int
-    reveal_type(a / x)  # revealed: float
-    reveal_type(a % x)  # revealed: int
-
-def lhs_is_bool(x: bool):
-    reveal_type(x + a)  # revealed: int
-    reveal_type(x - a)  # revealed: int
-    reveal_type(x * a)  # revealed: int
-    reveal_type(x // a)  # revealed: int
-    reveal_type(x / a)  # revealed: float
-    reveal_type(x % a)  # revealed: int
-
-def rhs_is_bool(x: bool):
-    reveal_type(a + x)  # revealed: int
-    reveal_type(a - x)  # revealed: int
-    reveal_type(a * x)  # revealed: int
-    reveal_type(a // x)  # revealed: int
-    reveal_type(a / x)  # revealed: float
-    reveal_type(a % x)  # revealed: int
-
-def both_are_bool(x: bool, y: bool):
-    reveal_type(x + y)  # revealed: int
-    reveal_type(x - y)  # revealed: int
-    reveal_type(x * y)  # revealed: int
-    reveal_type(x // y)  # revealed: int
-    reveal_type(x / y)  # revealed: float
-    reveal_type(x % y)  # revealed: int
-```

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

@@ -1,27 +0,0 @@
-# Binary operations on classes
-
-## Union of two classes
-
-Unioning two classes via the `|` operator is only available in Python 3.10 and later.
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-class A: ...
-class B: ...
-
-reveal_type(A | B)  # revealed: UnionType
-```
-
-## Union of two classes (prior to 3.10)
-
-```py
-class A: ...
-class B: ...
-
-# error: "Operator `|` is unsupported between objects of type `Literal[A]` and `Literal[B]`"
-reveal_type(A | B)  # revealed: Unknown
-```

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

@@ -1,371 +0,0 @@
-# Custom binary operations
-
-## Class instances
-
-```py
-class Yes:
-    def __add__(self, other) -> Literal["+"]:
-        return "+"
-
-    def __sub__(self, other) -> Literal["-"]:
-        return "-"
-
-    def __mul__(self, other) -> Literal["*"]:
-        return "*"
-
-    def __matmul__(self, other) -> Literal["@"]:
-        return "@"
-
-    def __truediv__(self, other) -> Literal["/"]:
-        return "/"
-
-    def __mod__(self, other) -> Literal["%"]:
-        return "%"
-
-    def __pow__(self, other) -> Literal["**"]:
-        return "**"
-
-    def __lshift__(self, other) -> Literal["<<"]:
-        return "<<"
-
-    def __rshift__(self, other) -> Literal[">>"]:
-        return ">>"
-
-    def __or__(self, other) -> Literal["|"]:
-        return "|"
-
-    def __xor__(self, other) -> Literal["^"]:
-        return "^"
-
-    def __and__(self, other) -> Literal["&"]:
-        return "&"
-
-    def __floordiv__(self, other) -> Literal["//"]:
-        return "//"
-
-class Sub(Yes): ...
-class No: ...
-
-# Yes implements all of the dunder methods.
-reveal_type(Yes() + Yes())  # revealed: Literal["+"]
-reveal_type(Yes() - Yes())  # revealed: Literal["-"]
-reveal_type(Yes() * Yes())  # revealed: Literal["*"]
-reveal_type(Yes() @ Yes())  # revealed: Literal["@"]
-reveal_type(Yes() / Yes())  # revealed: Literal["/"]
-reveal_type(Yes() % Yes())  # revealed: Literal["%"]
-reveal_type(Yes() ** Yes())  # revealed: Literal["**"]
-reveal_type(Yes() << Yes())  # revealed: Literal["<<"]
-reveal_type(Yes() >> Yes())  # revealed: Literal[">>"]
-reveal_type(Yes() | Yes())  # revealed: Literal["|"]
-reveal_type(Yes() ^ Yes())  # revealed: Literal["^"]
-reveal_type(Yes() & Yes())  # revealed: Literal["&"]
-reveal_type(Yes() // Yes())  # revealed: Literal["//"]
-
-# Sub inherits Yes's implementation of the dunder methods.
-reveal_type(Sub() + Sub())  # revealed: Literal["+"]
-reveal_type(Sub() - Sub())  # revealed: Literal["-"]
-reveal_type(Sub() * Sub())  # revealed: Literal["*"]
-reveal_type(Sub() @ Sub())  # revealed: Literal["@"]
-reveal_type(Sub() / Sub())  # revealed: Literal["/"]
-reveal_type(Sub() % Sub())  # revealed: Literal["%"]
-reveal_type(Sub() ** Sub())  # revealed: Literal["**"]
-reveal_type(Sub() << Sub())  # revealed: Literal["<<"]
-reveal_type(Sub() >> Sub())  # revealed: Literal[">>"]
-reveal_type(Sub() | Sub())  # revealed: Literal["|"]
-reveal_type(Sub() ^ Sub())  # revealed: Literal["^"]
-reveal_type(Sub() & Sub())  # revealed: Literal["&"]
-reveal_type(Sub() // Sub())  # revealed: Literal["//"]
-
-# No does not implement any of the dunder methods.
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `No` and `No`"
-reveal_type(No() + No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `-` is unsupported between objects of type `No` and `No`"
-reveal_type(No() - No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `*` is unsupported between objects of type `No` and `No`"
-reveal_type(No() * No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `@` is unsupported between objects of type `No` and `No`"
-reveal_type(No() @ No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `/` is unsupported between objects of type `No` and `No`"
-reveal_type(No() / No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `%` is unsupported between objects of type `No` and `No`"
-reveal_type(No() % No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `**` is unsupported between objects of type `No` and `No`"
-reveal_type(No() ** No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `<<` is unsupported between objects of type `No` and `No`"
-reveal_type(No() << No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `>>` is unsupported between objects of type `No` and `No`"
-reveal_type(No() >> No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `|` is unsupported between objects of type `No` and `No`"
-reveal_type(No() | No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `^` is unsupported between objects of type `No` and `No`"
-reveal_type(No() ^ No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `&` is unsupported between objects of type `No` and `No`"
-reveal_type(No() & No())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `//` is unsupported between objects of type `No` and `No`"
-reveal_type(No() // No())  # revealed: Unknown
-
-# Yes does not implement any of the reflected dunder methods.
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() + Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `-` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() - Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `*` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() * Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `@` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() @ Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `/` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() / Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `%` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() % Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `**` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() ** Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `<<` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() << Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `>>` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() >> Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `|` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() | Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `^` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() ^ Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `&` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() & Yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `//` is unsupported between objects of type `No` and `Yes`"
-reveal_type(No() // Yes())  # revealed: Unknown
-```
-
-## Subclass reflections override superclass dunders
-
-```py
-class Yes:
-    def __add__(self, other) -> Literal["+"]:
-        return "+"
-
-    def __sub__(self, other) -> Literal["-"]:
-        return "-"
-
-    def __mul__(self, other) -> Literal["*"]:
-        return "*"
-
-    def __matmul__(self, other) -> Literal["@"]:
-        return "@"
-
-    def __truediv__(self, other) -> Literal["/"]:
-        return "/"
-
-    def __mod__(self, other) -> Literal["%"]:
-        return "%"
-
-    def __pow__(self, other) -> Literal["**"]:
-        return "**"
-
-    def __lshift__(self, other) -> Literal["<<"]:
-        return "<<"
-
-    def __rshift__(self, other) -> Literal[">>"]:
-        return ">>"
-
-    def __or__(self, other) -> Literal["|"]:
-        return "|"
-
-    def __xor__(self, other) -> Literal["^"]:
-        return "^"
-
-    def __and__(self, other) -> Literal["&"]:
-        return "&"
-
-    def __floordiv__(self, other) -> Literal["//"]:
-        return "//"
-
-class Sub(Yes):
-    def __radd__(self, other) -> Literal["r+"]:
-        return "r+"
-
-    def __rsub__(self, other) -> Literal["r-"]:
-        return "r-"
-
-    def __rmul__(self, other) -> Literal["r*"]:
-        return "r*"
-
-    def __rmatmul__(self, other) -> Literal["r@"]:
-        return "r@"
-
-    def __rtruediv__(self, other) -> Literal["r/"]:
-        return "r/"
-
-    def __rmod__(self, other) -> Literal["r%"]:
-        return "r%"
-
-    def __rpow__(self, other) -> Literal["r**"]:
-        return "r**"
-
-    def __rlshift__(self, other) -> Literal["r<<"]:
-        return "r<<"
-
-    def __rrshift__(self, other) -> Literal["r>>"]:
-        return "r>>"
-
-    def __ror__(self, other) -> Literal["r|"]:
-        return "r|"
-
-    def __rxor__(self, other) -> Literal["r^"]:
-        return "r^"
-
-    def __rand__(self, other) -> Literal["r&"]:
-        return "r&"
-
-    def __rfloordiv__(self, other) -> Literal["r//"]:
-        return "r//"
-
-class No:
-    def __radd__(self, other) -> Literal["r+"]:
-        return "r+"
-
-    def __rsub__(self, other) -> Literal["r-"]:
-        return "r-"
-
-    def __rmul__(self, other) -> Literal["r*"]:
-        return "r*"
-
-    def __rmatmul__(self, other) -> Literal["r@"]:
-        return "r@"
-
-    def __rtruediv__(self, other) -> Literal["r/"]:
-        return "r/"
-
-    def __rmod__(self, other) -> Literal["r%"]:
-        return "r%"
-
-    def __rpow__(self, other) -> Literal["r**"]:
-        return "r**"
-
-    def __rlshift__(self, other) -> Literal["r<<"]:
-        return "r<<"
-
-    def __rrshift__(self, other) -> Literal["r>>"]:
-        return "r>>"
-
-    def __ror__(self, other) -> Literal["r|"]:
-        return "r|"
-
-    def __rxor__(self, other) -> Literal["r^"]:
-        return "r^"
-
-    def __rand__(self, other) -> Literal["r&"]:
-        return "r&"
-
-    def __rfloordiv__(self, other) -> Literal["r//"]:
-        return "r//"
-
-# Subclass reflected dunder methods take precedence over the superclass's regular dunders.
-reveal_type(Yes() + Sub())  # revealed: Literal["r+"]
-reveal_type(Yes() - Sub())  # revealed: Literal["r-"]
-reveal_type(Yes() * Sub())  # revealed: Literal["r*"]
-reveal_type(Yes() @ Sub())  # revealed: Literal["r@"]
-reveal_type(Yes() / Sub())  # revealed: Literal["r/"]
-reveal_type(Yes() % Sub())  # revealed: Literal["r%"]
-reveal_type(Yes() ** Sub())  # revealed: Literal["r**"]
-reveal_type(Yes() << Sub())  # revealed: Literal["r<<"]
-reveal_type(Yes() >> Sub())  # revealed: Literal["r>>"]
-reveal_type(Yes() | Sub())  # revealed: Literal["r|"]
-reveal_type(Yes() ^ Sub())  # revealed: Literal["r^"]
-reveal_type(Yes() & Sub())  # revealed: Literal["r&"]
-reveal_type(Yes() // Sub())  # revealed: Literal["r//"]
-
-# But for an unrelated class, the superclass regular dunders are used.
-reveal_type(Yes() + No())  # revealed: Literal["+"]
-reveal_type(Yes() - No())  # revealed: Literal["-"]
-reveal_type(Yes() * No())  # revealed: Literal["*"]
-reveal_type(Yes() @ No())  # revealed: Literal["@"]
-reveal_type(Yes() / No())  # revealed: Literal["/"]
-reveal_type(Yes() % No())  # revealed: Literal["%"]
-reveal_type(Yes() ** No())  # revealed: Literal["**"]
-reveal_type(Yes() << No())  # revealed: Literal["<<"]
-reveal_type(Yes() >> No())  # revealed: Literal[">>"]
-reveal_type(Yes() | No())  # revealed: Literal["|"]
-reveal_type(Yes() ^ No())  # revealed: Literal["^"]
-reveal_type(Yes() & No())  # revealed: Literal["&"]
-reveal_type(Yes() // No())  # revealed: Literal["//"]
-```
-
-## Classes
-
-Dunder methods defined in a class are available to instances of that class, but not to the class
-itself. (For these operators to work on the class itself, they would have to be defined on the
-class's type, i.e. `type`.)
-
-```py
-class Yes:
-    def __add__(self, other) -> Literal["+"]:
-        return "+"
-
-class Sub(Yes): ...
-class No: ...
-
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `Literal[Yes]` and `Literal[Yes]`"
-reveal_type(Yes + Yes)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `Literal[Sub]` and `Literal[Sub]`"
-reveal_type(Sub + Sub)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `Literal[No]` and `Literal[No]`"
-reveal_type(No + No)  # revealed: Unknown
-```
-
-## Subclass
-
-```py
-class Yes:
-    def __add__(self, other) -> Literal["+"]:
-        return "+"
-
-class Sub(Yes): ...
-class No: ...
-
-def yes() -> type[Yes]:
-    return Yes
-
-def sub() -> type[Sub]:
-    return Sub
-
-def no() -> type[No]:
-    return No
-
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `type[Yes]` and `type[Yes]`"
-reveal_type(yes() + yes())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `type[Sub]` and `type[Sub]`"
-reveal_type(sub() + sub())  # revealed: Unknown
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `type[No]` and `type[No]`"
-reveal_type(no() + no())  # revealed: Unknown
-```
-
-## Function literals
-
-```py
-def f():
-    pass
-
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f + f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `-` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f - f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `*` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f * f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `@` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f @ f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `/` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f / f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `%` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f % f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `**` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f**f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `<<` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f << f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `>>` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f >> f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `|` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f | f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `^` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f ^ f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `&` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f & f)  # revealed: Unknown
-# error: [unsupported-operator] "Operator `//` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
-reveal_type(f // f)  # revealed: Unknown
-```

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

@@ -9,34 +9,6 @@ reveal_type(3 * -1)  # revealed: Literal[-3]
 reveal_type(-3 // 3)  # revealed: Literal[-1]
 reveal_type(-3 / 3)  # revealed: float
 reveal_type(5 % 3)  # revealed: Literal[2]
-
-# TODO: We don't currently verify that the actual parameter to int.__add__ matches the declared
-# formal parameter type.
-reveal_type(2 + "f")  # revealed: int
-
-def lhs(x: int):
-    reveal_type(x + 1)  # revealed: int
-    reveal_type(x - 4)  # revealed: int
-    reveal_type(x * -1)  # revealed: int
-    reveal_type(x // 3)  # revealed: int
-    reveal_type(x / 3)  # revealed: float
-    reveal_type(x % 3)  # revealed: int
-
-def rhs(x: int):
-    reveal_type(2 + x)  # revealed: int
-    reveal_type(3 - x)  # revealed: int
-    reveal_type(3 * x)  # revealed: int
-    reveal_type(-3 // x)  # revealed: int
-    reveal_type(-3 / x)  # revealed: float
-    reveal_type(5 % x)  # revealed: int
-
-def both(x: int):
-    reveal_type(x + x)  # revealed: int
-    reveal_type(x - x)  # revealed: int
-    reveal_type(x * x)  # revealed: int
-    reveal_type(x // x)  # revealed: int
-    reveal_type(x / x)  # revealed: float
-    reveal_type(x % x)  # revealed: int
 ```
 
 ## Power
@@ -49,11 +21,6 @@ largest_u32 = 4_294_967_295
 reveal_type(2**2)  # revealed: Literal[4]
 reveal_type(1 ** (largest_u32 + 1))  # revealed: int
 reveal_type(2**largest_u32)  # revealed: int
-
-def variable(x: int):
-    reveal_type(x**2)  # revealed: @Todo(return type)
-    reveal_type(2**x)  # revealed: @Todo(return type)
-    reveal_type(x**x)  # revealed: @Todo(return type)
 ```
 
 ## Division by Zero

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

@@ -32,10 +32,13 @@ def _(flag: bool):
 
 ```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]
 ```
 

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

@@ -1,209 +0,0 @@
-# Boundness and declaredness: public uses
-
-This document demonstrates how type-inference and diagnostics works for *public* uses of a symbol,
-that is, a use of a symbol from another scope. If a symbol has a declared type in its local scope
-(e.g. `int`), we use that as the symbol's "public type" (the type of the symbol from the perspective
-of other scopes) even if there is a more precise local inferred type for the symbol (`Literal[1]`).
-
-We test the whole matrix of possible boundness and declaredness states. The current behavior is
-summarized in the following table, while the tests below demonstrate each case. Note that some of
-this behavior is questionable and might change in the future. See the TODOs in `symbol_by_id`
-(`types.rs`) and [this issue](https://github.com/astral-sh/ruff/issues/14297) for more information.
-In particular, we should raise errors in the "possibly-undeclared-and-unbound" as well as the
-"undeclared-and-possibly-unbound" cases (marked with a "?").
-
-| **Public type**  | declared     | possibly-undeclared        | undeclared   |
-| ---------------- | ------------ | -------------------------- | ------------ |
-| bound            | `T_declared` | `T_declared \| T_inferred` | `T_inferred` |
-| possibly-unbound | `T_declared` | `T_declared \| T_inferred` | `T_inferred` |
-| unbound          | `T_declared` | `T_declared`               | `Unknown`    |
-
-| **Diagnostic**   | declared | possibly-undeclared       | undeclared          |
-| ---------------- | -------- | ------------------------- | ------------------- |
-| bound            |          |                           |                     |
-| possibly-unbound |          | `possibly-unbound-import` | ?                   |
-| unbound          |          | ?                         | `unresolved-import` |
-
-## Declared
-
-### Declared and bound
-
-If a symbol has a declared type (`int`), we use that even if there is a more precise inferred type
-(`Literal[1]`), or a conflicting inferred type (`Literal[2]`):
-
-```py path=mod.py
-x: int = 1
-
-# error: [invalid-assignment]
-y: str = 2
-```
-
-```py
-from mod import x, y
-
-reveal_type(x)  # revealed: int
-reveal_type(y)  # revealed: str
-```
-
-### Declared and possibly unbound
-
-If a symbol is declared and *possibly* unbound, we trust that other module and use the declared type
-without raising an error.
-
-```py path=mod.py
-def flag() -> bool: ...
-
-x: int
-y: str
-if flag:
-    x = 1
-    # error: [invalid-assignment]
-    y = 2
-```
-
-```py
-from mod import x, y
-
-reveal_type(x)  # revealed: int
-reveal_type(y)  # revealed: str
-```
-
-### Declared and unbound
-
-Similarly, if a symbol is declared but unbound, we do not raise an error. We trust that this symbol
-is available somehow and simply use the declared type.
-
-```py path=mod.py
-x: int
-```
-
-```py
-from mod import x
-
-reveal_type(x)  # revealed: int
-```
-
-## Possibly undeclared
-
-### Possibly undeclared and bound
-
-If a symbol is possibly undeclared but definitely bound, we use the union of the declared and
-inferred types:
-
-```py path=mod.py
-from typing import Any
-
-def flag() -> bool: ...
-
-x = 1
-y = 2
-if flag():
-    x: Any
-    # error: [invalid-declaration]
-    y: str
-```
-
-```py
-from mod import x, y
-
-reveal_type(x)  # revealed: Literal[1] | Any
-reveal_type(y)  # revealed: Literal[2] | Unknown
-```
-
-### Possibly undeclared and possibly unbound
-
-If a symbol is possibly undeclared and possibly unbound, we also use the union of the declared and
-inferred types. This case is interesting because the "possibly declared" definition might not be the
-same as the "possibly bound" definition (symbol `y`). Note that we raise a `possibly-unbound-import`
-error for both `x` and `y`:
-
-```py path=mod.py
-def flag() -> bool: ...
-
-if flag():
-    x: Any = 1
-    y = 2
-else:
-    y: str
-```
-
-```py
-# error: [possibly-unbound-import]
-# error: [possibly-unbound-import]
-from mod import x, y
-
-reveal_type(x)  # revealed: Literal[1] | Any
-reveal_type(y)  # revealed: Literal[2] | str
-```
-
-### Possibly undeclared and unbound
-
-If a symbol is possibly undeclared and definitely unbound, we currently do not raise an error. This
-seems inconsistent when compared to the case just above.
-
-```py path=mod.py
-def flag() -> bool: ...
-
-if flag():
-    x: int
-```
-
-```py
-# TODO: this should raise an error. Once we fix this, update the section description and the table
-# on top of this document.
-from mod import x
-
-reveal_type(x)  # revealed: int
-```
-
-## Undeclared
-
-### Undeclared but bound
-
-We use the inferred type as the public type, if a symbol has no declared type.
-
-```py path=mod.py
-x = 1
-```
-
-```py
-from mod import x
-
-reveal_type(x)  # revealed: Literal[1]
-```
-
-### Undeclared and possibly unbound
-
-If a symbol is undeclared and *possibly* unbound, we currently do not raise an error. This seems
-inconsistent when compared to the "possibly-undeclared-and-possibly-unbound" case.
-
-```py path=mod.py
-def flag() -> bool: ...
-
-if flag:
-    x = 1
-```
-
-```py
-# TODO: this should raise an error. Once we fix this, update the section description and the table
-# on top of this document.
-from mod import x
-
-reveal_type(x)  # revealed: Literal[1]
-```
-
-### Undeclared and unbound
-
-If a symbol is undeclared *and* unbound, we infer `Unknown` and raise an error.
-
-```py path=mod.py
-if False:
-    x: int = 1
-```
-
-```py
-# error: [unresolved-import]
-from mod import x
-
-reveal_type(x)  # revealed: Unknown
-```

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

@@ -70,32 +70,3 @@ def _(flag: bool):
     # error: "Object of type `Literal[1] | Literal[__call__]` is not callable (due to union element `Literal[1]`)"
     reveal_type(a())  # revealed: Unknown | int
 ```
-
-## Call binding errors
-
-### Wrong argument type
-
-```py
-class C:
-    def __call__(self, x: int) -> int:
-        return 1
-
-c = C()
-
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 2 (`x`) of function `__call__`; expected type `int`"
-reveal_type(c("foo"))  # revealed: int
-```
-
-### Wrong argument type on `self`
-
-```py
-class C:
-    # TODO this definition should also be an error; `C` must be assignable to type of `self`
-    def __call__(self: int) -> int:
-        return 1
-
-c = C()
-
-# error: 13 [invalid-argument-type] "Object of type `C` cannot be assigned to parameter 1 (`self`) of function `__call__`; expected type `int`"
-reveal_type(c())  # revealed: int
-```

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

@@ -64,269 +64,3 @@ def _(flag: bool):
     # error: [possibly-unresolved-reference]
     reveal_type(foo())  # revealed: int
 ```
-
-## Wrong argument type
-
-### Positional argument, positional-or-keyword parameter
-
-```py
-def f(x: int) -> int:
-    return 1
-
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
-reveal_type(f("foo"))  # revealed: int
-```
-
-### Positional argument, positional-only parameter
-
-```py
-def f(x: int, /) -> int:
-    return 1
-
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
-reveal_type(f("foo"))  # revealed: int
-```
-
-### Positional argument, variadic parameter
-
-```py
-def f(*args: int) -> int:
-    return 1
-
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `*args` of function `f`; expected type `int`"
-reveal_type(f("foo"))  # revealed: int
-```
-
-### Keyword argument, positional-or-keyword parameter
-
-```py
-def f(x: int) -> int:
-    return 1
-
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `x` of function `f`; expected type `int`"
-reveal_type(f(x="foo"))  # revealed: int
-```
-
-### Keyword argument, keyword-only parameter
-
-```py
-def f(*, x: int) -> int:
-    return 1
-
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `x` of function `f`; expected type `int`"
-reveal_type(f(x="foo"))  # revealed: int
-```
-
-### Keyword argument, keywords parameter
-
-```py
-def f(**kwargs: int) -> int:
-    return 1
-
-# error: 15 [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter `**kwargs` of function `f`; expected type `int`"
-reveal_type(f(x="foo"))  # revealed: int
-```
-
-### Correctly match keyword out-of-order
-
-```py
-def f(x: int = 1, y: str = "foo") -> int:
-    return 1
-
-# error: 15 [invalid-argument-type] "Object of type `Literal[2]` cannot be assigned to parameter `y` of function `f`; expected type `str`"
-# error: 20 [invalid-argument-type] "Object of type `Literal["bar"]` cannot be assigned to parameter `x` of function `f`; expected type `int`"
-reveal_type(f(y=2, x="bar"))  # revealed: int
-```
-
-## Too many positional arguments
-
-### One too many
-
-```py
-def f() -> int:
-    return 1
-
-# error: 15 [too-many-positional-arguments] "Too many positional arguments to function `f`: expected 0, got 1"
-reveal_type(f("foo"))  # revealed: int
-```
-
-### Two too many
-
-```py
-def f() -> int:
-    return 1
-
-# error: 15 [too-many-positional-arguments] "Too many positional arguments to function `f`: expected 0, got 2"
-reveal_type(f("foo", "bar"))  # revealed: int
-```
-
-### No too-many-positional if variadic is taken
-
-```py
-def f(*args: int) -> int:
-    return 1
-
-reveal_type(f(1, 2, 3))  # revealed: int
-```
-
-### Multiple keyword arguments map to keyword variadic parameter
-
-```py
-def f(**kwargs: int) -> int:
-    return 1
-
-reveal_type(f(foo=1, bar=2))  # revealed: int
-```
-
-## Missing arguments
-
-### No defaults or variadic
-
-```py
-def f(x: int) -> int:
-    return 1
-
-# error: 13 [missing-argument] "No argument provided for required parameter `x` of function `f`"
-reveal_type(f())  # revealed: int
-```
-
-### With default
-
-```py
-def f(x: int, y: str = "foo") -> int:
-    return 1
-
-# error: 13 [missing-argument] "No argument provided for required parameter `x` of function `f`"
-reveal_type(f())  # revealed: int
-```
-
-### Defaulted argument is not required
-
-```py
-def f(x: int = 1) -> int:
-    return 1
-
-reveal_type(f())  # revealed: int
-```
-
-### With variadic
-
-```py
-def f(x: int, *y: str) -> int:
-    return 1
-
-# error: 13 [missing-argument] "No argument provided for required parameter `x` of function `f`"
-reveal_type(f())  # revealed: int
-```
-
-### Variadic argument is not required
-
-```py
-def f(*args: int) -> int:
-    return 1
-
-reveal_type(f())  # revealed: int
-```
-
-### Keywords argument is not required
-
-```py
-def f(**kwargs: int) -> int:
-    return 1
-
-reveal_type(f())  # revealed: int
-```
-
-### Multiple
-
-```py
-def f(x: int, y: int) -> int:
-    return 1
-
-# error: 13 [missing-argument] "No arguments provided for required parameters `x`, `y` of function `f`"
-reveal_type(f())  # revealed: int
-```
-
-## Unknown argument
-
-```py
-def f(x: int) -> int:
-    return 1
-
-# error: 20 [unknown-argument] "Argument `y` does not match any known parameter of function `f`"
-reveal_type(f(x=1, y=2))  # revealed: int
-```
-
-## Parameter already assigned
-
-```py
-def f(x: int) -> int:
-    return 1
-
-# error: 18 [parameter-already-assigned] "Multiple values provided for parameter `x` of function `f`"
-reveal_type(f(1, x=2))  # revealed: int
-```
-
-## Special functions
-
-Some functions require special handling in type inference. Here, we make sure that we still emit
-proper diagnostics in case of missing or superfluous arguments.
-
-### `reveal_type`
-
-```py
-from typing_extensions import reveal_type
-
-# error: [missing-argument] "No argument provided for required parameter `obj` of function `reveal_type`"
-reveal_type()  # revealed: Unknown
-
-# error: [too-many-positional-arguments] "Too many positional arguments to function `reveal_type`: expected 1, got 2"
-reveal_type(1, 2)  # revealed: Literal[1]
-```
-
-### `static_assert`
-
-```py
-from knot_extensions import static_assert
-
-# error: [missing-argument] "No argument provided for required parameter `condition` of function `static_assert`"
-# error: [static-assert-error]
-static_assert()
-
-# error: [too-many-positional-arguments] "Too many positional arguments to function `static_assert`: expected 2, got 3"
-static_assert(True, 2, 3)
-```
-
-### `len`
-
-```py
-# error: [missing-argument] "No argument provided for required parameter `obj` of function `len`"
-len()
-
-# error: [too-many-positional-arguments] "Too many positional arguments to function `len`: expected 1, got 2"
-len([], 1)
-```
-
-### Type API predicates
-
-```py
-from knot_extensions import is_subtype_of, is_fully_static
-
-# error: [missing-argument]
-is_subtype_of()
-
-# error: [missing-argument]
-is_subtype_of(int)
-
-# error: [too-many-positional-arguments]
-is_subtype_of(int, int, int)
-
-# error: [too-many-positional-arguments]
-is_subtype_of(int, int, int, int)
-
-# error: [missing-argument]
-is_fully_static()
-
-# error: [too-many-positional-arguments]
-is_fully_static(int, int)
-```

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

@@ -1,44 +0,0 @@
-# Invalid signatures
-
-## Multiple arguments with the same name
-
-We always map a keyword argument to the first parameter of that name.
-
-```py
-# error: [invalid-syntax] "Duplicate parameter "x""
-def f(x: int, x: str) -> int:
-    return 1
-
-# error: 13 [missing-argument] "No argument provided for required parameter `x` of function `f`"
-# error: 18 [parameter-already-assigned] "Multiple values provided for parameter `x` of function `f`"
-reveal_type(f(1, x=2))  # revealed: int
-```
-
-## Positional after non-positional
-
-When parameter kinds are given in an invalid order, we emit a diagnostic and implicitly reorder them
-to the valid order:
-
-```py
-# error: [invalid-syntax] "Parameter cannot follow var-keyword parameter"
-def f(**kw: int, x: str) -> int:
-    return 1
-
-# error: 15 [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `str`"
-reveal_type(f(1))  # revealed: int
-```
-
-## Non-defaulted after defaulted
-
-We emit a syntax diagnostic for this, but it doesn't cause any problems for binding.
-
-```py
-# error: [invalid-syntax] "Parameter without a default cannot follow a parameter with a default"
-def f(x: int = 1, y: str) -> int:
-    return 1
-
-reveal_type(f(y="foo"))  # revealed: int
-# error: [invalid-argument-type] "Object of type `Literal["foo"]` cannot be assigned to parameter 1 (`x`) of function `f`; expected type `int`"
-# error: [missing-argument] "No argument provided for required parameter `y` of function `f`"
-reveal_type(f("foo"))  # revealed: int
-```

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

@@ -56,7 +56,7 @@ def _(flag: bool, flag2: bool):
     else:
         def f() -> int:
             return 1
-    # error: "Object of type `Literal[1, "foo"] | Literal[f]` is not callable (due to union elements Literal[1], Literal["foo"])"
+    # 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())
 ```
@@ -72,6 +72,6 @@ def _(flag: bool):
     else:
         f = "foo"
 
-    x = f()  # error: "Object of type `Literal[1, "foo"]` is not callable"
+    x = f()  # error: "Object of type `Literal[1] | Literal["foo"]` is not callable"
     reveal_type(x)  # revealed: Unknown
 ```

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

@@ -92,7 +92,8 @@ def _(o: object):
     n = None
 
     if o is not None:
-        reveal_type(o)  # revealed:  ~None
+        reveal_type(o)  # revealed: object & ~None
+
         reveal_type(o is n)  # revealed: Literal[False]
         reveal_type(o is not n)  # revealed: Literal[True]
 ```

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]

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

@@ -22,7 +22,7 @@ def _(flag: bool, flag1: bool, flag2: bool):
     reveal_type(d)  # revealed: bool
 
     int_literal_or_str_literal = 1 if flag else "foo"
-    # error: "Operator `in` is not supported for types `Literal[42]` and `Literal[1]`, in comparing `Literal[42]` with `Literal[1, "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
 

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

@@ -115,35 +115,3 @@ def _(flag: bool, flag2: bool):
 
     reveal_type(y)  # revealed: Literal[2, 3, 4]
 ```
-
-## if-elif with assignment expressions in tests
-
-```py
-def check(x: int) -> bool:
-    return bool(x)
-
-if check(x := 1):
-    x = 2
-elif check(x := 3):
-    x = 4
-
-reveal_type(x)  # revealed: Literal[2, 3, 4]
-```
-
-## constraints apply to later test expressions
-
-```py
-def check(x) -> bool:
-    return bool(x)
-
-def _(flag: bool):
-    x = 1 if flag else None
-    y = 0
-
-    if x is None:
-        pass
-    elif check(y := x):
-        pass
-
-    reveal_type(y)  # revealed: Literal[0, 1]
-```

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

@@ -3,43 +3,40 @@
 ## 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 target:
-        case 1:
-            y = 3
-        case 2:
-            y = 4
+match 0:
+    case 1:
+        y = 3
+    case 2:
+        y = 4
 
-    reveal_type(y)  # revealed: Literal[2, 3, 4]
+reveal_type(y)  # revealed: Literal[2, 3, 4]
 ```

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

@@ -19,17 +19,14 @@ def _(flag: bool):
     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:
+def _(flag: bool):
+    if flag:
         x: int
 
-    # Here, the declared type for `x` is `int | str | Unknown`.
-    x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: str, int"
+    x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: Unknown, int"
 ```
 
 ## Incompatible declarations with bad assignment
@@ -45,31 +42,3 @@ def _(flag: bool):
     # error: [invalid-assignment]
     x = b"foo"
 ```
-
-## No errors
-
-Currently, we avoid raising the conflicting-declarations for the following cases:
-
-### Partial declarations
-
-```py
-def _(flag: bool):
-    if flag:
-        x: int
-
-    x = 1
-```
-
-### Partial declarations in try-except
-
-Refer to <https://github.com/astral-sh/ruff/issues/13966>
-
-```py
-def _():
-    try:
-        x: int = 1
-    except:
-        x = 2
-
-    x = 3
-```

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

@@ -1,142 +0,0 @@
-# `assert_type`
-
-## Basic
-
-```py
-from typing_extensions import assert_type
-
-def _(x: int):
-    assert_type(x, int)  # fine
-    assert_type(x, str)  # error: [type-assertion-failure]
-```
-
-## Narrowing
-
-The asserted type is checked against the inferred type, not the declared type.
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-from typing_extensions import assert_type
-
-def _(x: int | str):
-    if isinstance(x, int):
-        reveal_type(x)  # revealed: int
-        assert_type(x, int)  # fine
-```
-
-## Equivalence
-
-The actual type must match the asserted type precisely.
-
-```py
-from typing import Any, Type, Union
-from typing_extensions import assert_type
-
-# Subtype does not count
-def _(x: bool):
-    assert_type(x, int)  # error: [type-assertion-failure]
-
-def _(a: type[int], b: type[Any]):
-    assert_type(a, type[Any])  # error: [type-assertion-failure]
-    assert_type(b, type[int])  # error: [type-assertion-failure]
-
-# The expression constructing the type is not taken into account
-def _(a: type[int]):
-    assert_type(a, Type[int])  # fine
-```
-
-## Gradual types
-
-```py
-from typing import Any
-from typing_extensions import Literal, assert_type
-
-from knot_extensions import Unknown
-
-# Any and Unknown are considered equivalent
-def _(a: Unknown, b: Any):
-    reveal_type(a)  # revealed: Unknown
-    assert_type(a, Any)  # fine
-
-    reveal_type(b)  # revealed: Any
-    assert_type(b, Unknown)  # fine
-
-def _(a: type[Unknown], b: type[Any]):
-    reveal_type(a)  # revealed: type[Unknown]
-    assert_type(a, type[Any])  # fine
-
-    reveal_type(b)  # revealed: type[Any]
-    assert_type(b, type[Unknown])  # fine
-```
-
-## Tuples
-
-Tuple types with the same elements are the same.
-
-```py
-from typing_extensions import assert_type
-
-from knot_extensions import Unknown
-
-def _(a: tuple[int, str, bytes]):
-    assert_type(a, tuple[int, str, bytes])  # fine
-
-    assert_type(a, tuple[int, str])  # error: [type-assertion-failure]
-    assert_type(a, tuple[int, str, bytes, None])  # error: [type-assertion-failure]
-    assert_type(a, tuple[int, bytes, str])  # error: [type-assertion-failure]
-
-def _(a: tuple[Any, ...], b: tuple[Unknown, ...]):
-    assert_type(a, tuple[Any, ...])  # fine
-    assert_type(a, tuple[Unknown, ...])  # fine
-
-    assert_type(b, tuple[Unknown, ...])  # fine
-    assert_type(b, tuple[Any, ...])  # fine
-```
-
-## Unions
-
-Unions with the same elements are the same, regardless of order.
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-from typing_extensions import assert_type
-
-def _(a: str | int):
-    assert_type(a, str | int)  # fine
-
-    # TODO: Order-independent union handling in type equivalence
-    assert_type(a, int | str)  # error: [type-assertion-failure]
-```
-
-## Intersections
-
-Intersections are the same when their positive and negative parts are respectively the same,
-regardless of order.
-
-```py
-from typing_extensions import assert_type
-
-from knot_extensions import Intersection, Not
-
-class A: ...
-class B: ...
-class C: ...
-class D: ...
-
-def _(a: A):
-    if isinstance(a, B) and not isinstance(a, C) and not isinstance(a, D):
-        reveal_type(a)  # revealed: A & B & ~C & ~D
-
-        assert_type(a, Intersection[A, B, Not[C], Not[D]])  # fine
-
-        # TODO: Order-independent intersection handling in type equivalence
-        assert_type(a, Intersection[B, A, Not[D], Not[C]])  # error: [type-assertion-failure]
-```

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

@@ -1,27 +0,0 @@
-# `cast`
-
-`cast()` takes two arguments, one type and one value, and returns a value of the given type.
-
-The (inferred) type of the value and the given type do not need to have any correlation.
-
-```py
-from typing import Literal, cast
-
-reveal_type(True)  # revealed: Literal[True]
-reveal_type(cast(str, True))  # revealed: str
-reveal_type(cast("str", True))  # revealed: str
-
-reveal_type(cast(int | str, 1))  # revealed: int | str
-
-# error: [invalid-type-form]
-reveal_type(cast(Literal, True))  # revealed: Unknown
-
-# TODO: These should be errors
-cast(1)
-cast(str)
-cast(str, b"ar", "foo")
-
-# TODO: Either support keyword arguments properly,
-# or give a comprehensible error message saying they're unsupported
-cast(val="foo", typ=int)  # error: [unresolved-reference] "Name `foo` used when not defined"
-```

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

@@ -90,83 +90,3 @@ def foo(
         # TODO: should emit a diagnostic here:
         reveal_type(g)  # revealed: @Todo(full tuple[...] support)
 ```
-
-## Object raised is not an exception
-
-```py
-try:
-    raise AttributeError()  # fine
-except:
-    ...
-
-try:
-    raise FloatingPointError  # fine
-except:
-    ...
-
-try:
-    raise 1  # error: [invalid-raise]
-except:
-    ...
-
-try:
-    raise int  # error: [invalid-raise]
-except:
-    ...
-
-def _(e: Exception | type[Exception]):
-    raise e  # fine
-
-def _(e: Exception | type[Exception] | None):
-    raise e  # error: [invalid-raise]
-```
-
-## Exception cause is not an exception
-
-```py
-try:
-    raise EOFError() from GeneratorExit  # fine
-except:
-    ...
-
-try:
-    raise StopIteration from MemoryError()  # fine
-except:
-    ...
-
-try:
-    raise BufferError() from None  # fine
-except:
-    ...
-
-try:
-    raise ZeroDivisionError from False  # error: [invalid-raise]
-except:
-    ...
-
-try:
-    raise SystemExit from bool()  # error: [invalid-raise]
-except:
-    ...
-
-try:
-    raise
-except KeyboardInterrupt as e:  # fine
-    reveal_type(e)  # revealed: KeyboardInterrupt
-    raise LookupError from e  # fine
-
-try:
-    raise
-except int as e:  # error: [invalid-exception-caught]
-    reveal_type(e)  # revealed: Unknown
-    raise KeyError from e
-
-def _(e: Exception | type[Exception]):
-    raise ModuleNotFoundError from e  # fine
-
-def _(e: Exception | type[Exception] | None):
-    raise IndexError from e  # fine
-
-def _(e: int | None):
-    raise IndexError from e  # error: [invalid-raise]
-```

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

@@ -1,12 +1,5 @@
 # `except*`
 
-`except*` is only available in Python 3.11 and later:
-
-```toml
-[environment]
-python-version = "3.11"
-```
-
 ## `except*` with `BaseException`
 
 ```py

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

@@ -17,7 +17,7 @@ def _(flag: bool):
 
     reveal_type(A.always_bound)  # revealed: Literal[1]
 
-    reveal_type(A.union)  # revealed: Literal[1, "abc"]
+    reveal_type(A.union)  # revealed: Literal[1] | Literal["abc"]
 
     # error: [possibly-unbound-attribute] "Attribute `possibly_unbound` on type `Literal[A]` is possibly unbound"
     reveal_type(A.possibly_unbound)  # revealed: Literal["abc"]

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

@@ -10,8 +10,8 @@ def _(foo: str):
     reveal_type(False or "z")  # revealed: Literal["z"]
     reveal_type(False or True)  # revealed: Literal[True]
     reveal_type(False or False)  # revealed: Literal[False]
-    reveal_type(foo or False)  # revealed: str & ~AlwaysFalsy | Literal[False]
-    reveal_type(foo or True)  # revealed: str & ~AlwaysFalsy | Literal[True]
+    reveal_type(foo or False)  # revealed: str | Literal[False]
+    reveal_type(foo or True)  # revealed: str | Literal[True]
 ```
 
 ## AND
@@ -20,8 +20,8 @@ def _(foo: str):
 def _(foo: str):
     reveal_type(True and False)  # revealed: Literal[False]
     reveal_type(False and True)  # revealed: Literal[False]
-    reveal_type(foo and False)  # revealed: str & ~AlwaysTruthy | Literal[False]
-    reveal_type(foo and True)  # revealed: str & ~AlwaysTruthy | Literal[True]
+    reveal_type(foo and False)  # revealed: str | 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[""]

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

@@ -7,7 +7,7 @@ def _(flag: bool):
     reveal_type(1 if flag 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]
@@ -31,9 +31,9 @@ The test inside an if expression should not affect code outside of the expressio
 def _(flag: bool):
     x: Literal[42, "hello"] = 42 if flag else "hello"
 
-    reveal_type(x)  # revealed: Literal[42, "hello"]
+    reveal_type(x)  # revealed: Literal[42] | Literal["hello"]
 
     _ = ... if isinstance(x, str) else ...
 
-    reveal_type(x)  # revealed: Literal[42, "hello"]
+    reveal_type(x)  # revealed: Literal[42] | Literal["hello"]
 ```

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

@@ -119,7 +119,7 @@ class ZeroOrStr:
 reveal_type(len(Zero()))  # revealed: Literal[0]
 reveal_type(len(ZeroOrOne()))  # revealed: Literal[0, 1]
 reveal_type(len(ZeroOrTrue()))  # revealed: Literal[0, 1]
-reveal_type(len(OneOrFalse()))  # revealed: Literal[1, 0]
+reveal_type(len(OneOrFalse()))  # revealed: Literal[0, 1]
 
 # TODO: Emit a diagnostic
 reveal_type(len(OneOrFoo()))  # revealed: int

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,
-): ...
-```

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

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

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

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

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

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

crates/red_knot_python_semantic/resources/mdtest/intersection_types.md

@@ -1,848 +0,0 @@
-# Intersection types
-
-## Introduction
-
-This test suite covers certain properties of intersection types and makes sure that we can apply
-various simplification strategies. We use `Intersection` (`&`) and `Not` (`~`) to construct
-intersection types (note that we display negative contributions at the end; the order does not
-matter):
-
-```py
-from knot_extensions import Intersection, Not
-
-class P: ...
-class Q: ...
-
-def _(
-    i1: Intersection[P, Q],
-    i2: Intersection[P, Not[Q]],
-    i3: Intersection[Not[P], Q],
-    i4: Intersection[Not[P], Not[Q]],
-) -> None:
-    reveal_type(i1)  # revealed: P & Q
-    reveal_type(i2)  # revealed: P & ~Q
-    reveal_type(i3)  # revealed: Q & ~P
-    reveal_type(i4)  # revealed: ~P & ~Q
-```
-
-## Notation
-
-Throughout this document, we use the following types as representatives for certain equivalence
-classes.
-
-### Non-disjoint types
-
-We use `P`, `Q`, `R`, … to denote types that are non-disjoint:
-
-```py
-from knot_extensions import static_assert, is_disjoint_from
-
-class P: ...
-class Q: ...
-class R: ...
-
-static_assert(not is_disjoint_from(P, Q))
-static_assert(not is_disjoint_from(P, R))
-static_assert(not is_disjoint_from(Q, R))
-```
-
-Although `P` is not a subtype of `Q` and `Q` is not a subtype of `P`, the two types are not disjoint
-because it would be possible to create a class `S` that inherits from both `P` and `Q` using
-multiple inheritance. An instance of `S` would be a member of the `P` type _and_ the `Q` type.
-
-### Disjoint types
-
-We use `Literal[1]`, `Literal[2]`, … as examples of pairwise-disjoint types, and `int` as a joint
-supertype of these:
-
-```py
-from knot_extensions import static_assert, is_disjoint_from, is_subtype_of
-from typing import Literal
-
-static_assert(is_disjoint_from(Literal[1], Literal[2]))
-static_assert(is_disjoint_from(Literal[1], Literal[3]))
-static_assert(is_disjoint_from(Literal[2], Literal[3]))
-
-static_assert(is_subtype_of(Literal[1], int))
-static_assert(is_subtype_of(Literal[2], int))
-static_assert(is_subtype_of(Literal[3], int))
-```
-
-### Subtypes
-
-Finally, we use `A <: B <: C` and `A <: B1`, `A <: B2` to denote hierarchies of (proper) subtypes:
-
-```py
-from knot_extensions import static_assert, is_subtype_of, is_disjoint_from
-
-class A: ...
-class B(A): ...
-class C(B): ...
-
-static_assert(is_subtype_of(B, A))
-static_assert(is_subtype_of(C, B))
-static_assert(is_subtype_of(C, A))
-
-static_assert(not is_subtype_of(A, B))
-static_assert(not is_subtype_of(B, C))
-static_assert(not is_subtype_of(A, C))
-
-class B1(A): ...
-class B2(A): ...
-
-static_assert(is_subtype_of(B1, A))
-static_assert(is_subtype_of(B2, A))
-
-static_assert(not is_subtype_of(A, B1))
-static_assert(not is_subtype_of(A, B2))
-
-static_assert(not is_subtype_of(B1, B2))
-static_assert(not is_subtype_of(B2, B1))
-```
-
-## Structural properties
-
-This section covers structural properties of intersection types and documents some decisions on how
-to represent mixtures of intersections and unions.
-
-### Single-element intersections
-
-If we have an intersection with a single element, we can simplify to that element. Similarly, we
-show an intersection with a single negative contribution as just the negation of that element.
-
-```py
-from knot_extensions import Intersection, Not
-
-class P: ...
-
-def _(
-    i1: Intersection[P],
-    i2: Intersection[Not[P]],
-) -> None:
-    reveal_type(i1)  # revealed: P
-    reveal_type(i2)  # revealed: ~P
-```
-
-### Flattening of nested intersections
-
-We eagerly flatten nested intersections types.
-
-```py
-from knot_extensions import Intersection, Not
-
-class P: ...
-class Q: ...
-class R: ...
-class S: ...
-
-def positive_contributions(
-    i1: Intersection[P, Intersection[Q, R]],
-    i2: Intersection[Intersection[P, Q], R],
-) -> None:
-    reveal_type(i1)  # revealed: P & Q & R
-    reveal_type(i2)  # revealed: P & Q & R
-
-def negative_contributions(
-    i1: Intersection[Not[P], Intersection[Not[Q], Not[R]]],
-    i2: Intersection[Intersection[Not[P], Not[Q]], Not[R]],
-) -> None:
-    reveal_type(i1)  # revealed: ~P & ~Q & ~R
-    reveal_type(i2)  # revealed: ~P & ~Q & ~R
-
-def mixed(
-    i1: Intersection[P, Intersection[Not[Q], R]],
-    i2: Intersection[Intersection[P, Not[Q]], R],
-    i3: Intersection[Not[P], Intersection[Q, Not[R]]],
-    i4: Intersection[Intersection[Q, Not[R]], Not[P]],
-) -> None:
-    reveal_type(i1)  # revealed: P & R & ~Q
-    reveal_type(i2)  # revealed: P & R & ~Q
-    reveal_type(i3)  # revealed: Q & ~P & ~R
-    reveal_type(i4)  # revealed: Q & ~R & ~P
-
-def multiple(
-    i1: Intersection[Intersection[P, Q], Intersection[R, S]],
-):
-    reveal_type(i1)  # revealed: P & Q & R & S
-
-def nested(
-    i1: Intersection[Intersection[Intersection[P, Q], R], S],
-    i2: Intersection[P, Intersection[Q, Intersection[R, S]]],
-):
-    reveal_type(i1)  # revealed: P & Q & R & S
-    reveal_type(i2)  # revealed: P & Q & R & S
-```
-
-### Union of intersections
-
-We always normalize our representation to a _union of intersections_, so when we add a _union to an
-intersection_, we distribute the union over the respective elements:
-
-```py
-from knot_extensions import Intersection, Not
-
-class P: ...
-class Q: ...
-class R: ...
-class S: ...
-
-def _(
-    i1: Intersection[P, Q | R | S],
-    i2: Intersection[P | Q | R, S],
-    i3: Intersection[P | Q, R | S],
-) -> None:
-    reveal_type(i1)  # revealed: P & Q | P & R | P & S
-    reveal_type(i2)  # revealed: P & S | Q & S | R & S
-    reveal_type(i3)  # revealed: P & R | Q & R | P & S | Q & S
-
-def simplifications_for_same_elements(
-    i1: Intersection[P, Q | P],
-    i2: Intersection[Q, P | Q],
-    i3: Intersection[P | Q, Q | R],
-    i4: Intersection[P | Q, P | Q],
-    i5: Intersection[P | Q, Q | P],
-) -> None:
-    #   P & (Q | P)
-    # = P & Q | P & P
-    # = P & Q | P
-    # = P
-    # (because P is a supertype of P & Q)
-    reveal_type(i1)  # revealed: P
-    # similar here:
-    reveal_type(i2)  # revealed: Q
-
-    #   (P | Q) & (Q | R)
-    # = P & Q | P & R | Q & Q | Q & R
-    # = P & Q | P & R | Q | Q & R
-    # = Q | P & R
-    # (again, because Q is a supertype of P & Q and of Q & R)
-    reveal_type(i3)  # revealed: Q | P & R
-
-    #   (P | Q) & (P | Q)
-    # = P & P | P & Q | Q & P | Q & Q
-    # = P | P & Q | Q
-    # = P | Q
-    reveal_type(i4)  # revealed: P | Q
-```
-
-### Negation distributes over union
-
-Distribution also applies to a negation operation. This is a manifestation of one of
-[De Morgan's laws], namely `~(P | Q) = ~P & ~Q`:
-
-```py
-from knot_extensions import Not
-from typing import Literal
-
-class P: ...
-class Q: ...
-class R: ...
-
-def _(i1: Not[P | Q], i2: Not[P | Q | R]) -> None:
-    reveal_type(i1)  # revealed: ~P & ~Q
-    reveal_type(i2)  # revealed: ~P & ~Q & ~R
-
-def example_literals(i: Not[Literal[1, 2]]) -> None:
-    reveal_type(i)  # revealed: ~Literal[1] & ~Literal[2]
-```
-
-### Negation of intersections
-
-The other of [De Morgan's laws], `~(P & Q) = ~P | ~Q`, also holds:
-
-```py
-from knot_extensions import Intersection, Not
-
-class P: ...
-class Q: ...
-class R: ...
-
-def _(
-    i1: Not[Intersection[P, Q]],
-    i2: Not[Intersection[P, Q, R]],
-) -> None:
-    reveal_type(i1)  # revealed: ~P | ~Q
-    reveal_type(i2)  # revealed: ~P | ~Q | ~R
-```
-
-### `Never` is dual to `object`
-
-`Never` represents the empty set of values, while `object` represents the set of all values, so
-`~Never` is equivalent to `object`, and `~object` is equivalent to `Never`. This is a manifestation
-of the [complement laws] of set theory.
-
-```py
-from knot_extensions import Intersection, Not
-from typing_extensions import Never
-
-def _(
-    not_never: Not[Never],
-    not_object: Not[object],
-) -> None:
-    reveal_type(not_never)  # revealed: object
-    reveal_type(not_object)  # revealed: Never
-```
-
-### `object & ~T` is equivalent to `~T`
-
-A second consequence of the fact that `object` is the top type is that `object` is always redundant
-in intersections, and can be eagerly simplified out. `object & P` is equivalent to `P`;
-`object & ~P` is equivalent to `~P` for any type `P`.
-
-```py
-from knot_extensions import Intersection, Not, is_equivalent_to, static_assert
-
-class P: ...
-
-static_assert(is_equivalent_to(Intersection[object, P], P))
-static_assert(is_equivalent_to(Intersection[object, Not[P]], Not[P]))
-```
-
-### Intersection of a type and its negation
-
-Continuing with more [complement laws], if we see both `P` and `~P` in an intersection, we can
-simplify to `Never`, even in the presence of other types:
-
-```py
-from knot_extensions import Intersection, Not
-from typing import Any
-
-class P: ...
-class Q: ...
-
-def _(
-    i1: Intersection[P, Not[P]],
-    i2: Intersection[Not[P], P],
-    i3: Intersection[P, Q, Not[P]],
-    i4: Intersection[Not[P], Q, P],
-    i5: Intersection[P, Any, Not[P]],
-    i6: Intersection[Not[P], Any, P],
-) -> None:
-    reveal_type(i1)  # revealed: Never
-    reveal_type(i2)  # revealed: Never
-    reveal_type(i3)  # revealed: Never
-    reveal_type(i4)  # revealed: Never
-    reveal_type(i5)  # revealed: Never
-    reveal_type(i6)  # revealed: Never
-```
-
-### Union of a type and its negation
-
-Similarly, if we have both `P` and `~P` in a _union_, we can simplify that to `object`.
-
-```py
-from knot_extensions import Intersection, Not
-
-class P: ...
-class Q: ...
-
-def _(
-    i1: P | Not[P],
-    i2: Not[P] | P,
-    i3: P | Q | Not[P],
-    i4: Not[P] | Q | P,
-) -> None:
-    reveal_type(i1)  # revealed: object
-    reveal_type(i2)  # revealed: object
-    reveal_type(i3)  # revealed: object
-    reveal_type(i4)  # revealed: object
-```
-
-### Negation is an involution
-
-The final of the [complement laws] states that negating twice is equivalent to not negating at all:
-
-```py
-from knot_extensions import Not
-
-class P: ...
-
-def _(
-    i1: Not[P],
-    i2: Not[Not[P]],
-    i3: Not[Not[Not[P]]],
-    i4: Not[Not[Not[Not[P]]]],
-) -> None:
-    reveal_type(i1)  # revealed: ~P
-    reveal_type(i2)  # revealed: P
-    reveal_type(i3)  # revealed: ~P
-    reveal_type(i4)  # revealed: P
-```
-
-## Simplification strategies
-
-In this section, we present various simplification strategies that go beyond the structure of the
-representation.
-
-### `Never` in intersections
-
-If we intersect with `Never`, we can simplify the whole intersection to `Never`, even if there are
-dynamic types involved:
-
-```py
-from knot_extensions import Intersection, Not
-from typing_extensions import Never, Any
-
-class P: ...
-class Q: ...
-
-def _(
-    i1: Intersection[P, Never],
-    i2: Intersection[Never, P],
-    i3: Intersection[Any, Never],
-    i4: Intersection[Never, Not[Any]],
-) -> None:
-    reveal_type(i1)  # revealed: Never
-    reveal_type(i2)  # revealed: Never
-    reveal_type(i3)  # revealed: Never
-    reveal_type(i4)  # revealed: Never
-```
-
-### Simplifications using disjointness
-
-#### Positive contributions
-
-If we intersect disjoint types, we can simplify to `Never`, even in the presence of other types:
-
-```py
-from knot_extensions import Intersection, Not
-from typing import Literal, Any
-
-class P: ...
-
-def _(
-    i01: Intersection[Literal[1], Literal[2]],
-    i02: Intersection[Literal[2], Literal[1]],
-    i03: Intersection[Literal[1], Literal[2], P],
-    i04: Intersection[Literal[1], P, Literal[2]],
-    i05: Intersection[P, Literal[1], Literal[2]],
-    i06: Intersection[Literal[1], Literal[2], Any],
-    i07: Intersection[Literal[1], Any, Literal[2]],
-    i08: Intersection[Any, Literal[1], Literal[2]],
-) -> None:
-    reveal_type(i01)  # revealed: Never
-    reveal_type(i02)  # revealed: Never
-    reveal_type(i03)  # revealed: Never
-    reveal_type(i04)  # revealed: Never
-    reveal_type(i05)  # revealed: Never
-    reveal_type(i06)  # revealed: Never
-    reveal_type(i07)  # revealed: Never
-    reveal_type(i08)  # revealed: Never
-
-# `bool` is final and can not be subclassed, so `type[bool]` is equivalent to `Literal[bool]`, which
-# is disjoint from `type[str]`:
-def example_type_bool_type_str(
-    i: Intersection[type[bool], type[str]],
-) -> None:
-    reveal_type(i)  # revealed: Never
-```
-
-#### Positive and negative contributions
-
-If we intersect a type `X` with the negation `~Y` of a disjoint type `Y`, we can remove the negative
-contribution `~Y`, as `~Y` must fully contain the positive contribution `X` as a subtype:
-
-```py
-from knot_extensions import Intersection, Not
-from typing import Literal
-
-def _(
-    i1: Intersection[Literal[1], Not[Literal[2]]],
-    i2: Intersection[Not[Literal[2]], Literal[1]],
-    i3: Intersection[Literal[1], Not[Literal[2]], int],
-    i4: Intersection[Literal[1], int, Not[Literal[2]]],
-    i5: Intersection[int, Literal[1], Not[Literal[2]]],
-) -> None:
-    reveal_type(i1)  # revealed: Literal[1]
-    reveal_type(i2)  # revealed: Literal[1]
-    reveal_type(i3)  # revealed: Literal[1]
-    reveal_type(i4)  # revealed: Literal[1]
-    reveal_type(i5)  # revealed: Literal[1]
-
-# None is disjoint from int, so this simplification applies here
-def example_none(
-    i1: Intersection[int, Not[None]],
-    i2: Intersection[Not[None], int],
-) -> None:
-    reveal_type(i1)  # revealed: int
-    reveal_type(i2)  # revealed: int
-```
-
-### Simplifications using subtype relationships
-
-#### Positive type and positive subtype
-
-Subtypes are contained within their supertypes, so we can simplify intersections by removing
-superfluous supertypes:
-
-```py
-from knot_extensions import Intersection, Not
-from typing import Any
-
-class A: ...
-class B(A): ...
-class C(B): ...
-class Unrelated: ...
-
-def _(
-    i01: Intersection[A, B],
-    i02: Intersection[B, A],
-    i03: Intersection[A, C],
-    i04: Intersection[C, A],
-    i05: Intersection[B, C],
-    i06: Intersection[C, B],
-    i07: Intersection[A, B, C],
-    i08: Intersection[C, B, A],
-    i09: Intersection[B, C, A],
-    i10: Intersection[A, B, Unrelated],
-    i11: Intersection[B, A, Unrelated],
-    i12: Intersection[B, Unrelated, A],
-    i13: Intersection[A, Unrelated, B],
-    i14: Intersection[Unrelated, A, B],
-    i15: Intersection[Unrelated, B, A],
-    i16: Intersection[A, B, Any],
-    i17: Intersection[B, A, Any],
-    i18: Intersection[B, Any, A],
-    i19: Intersection[A, Any, B],
-    i20: Intersection[Any, A, B],
-    i21: Intersection[Any, B, A],
-) -> None:
-    reveal_type(i01)  # revealed: B
-    reveal_type(i02)  # revealed: B
-    reveal_type(i03)  # revealed: C
-    reveal_type(i04)  # revealed: C
-    reveal_type(i05)  # revealed: C
-    reveal_type(i06)  # revealed: C
-    reveal_type(i07)  # revealed: C
-    reveal_type(i08)  # revealed: C
-    reveal_type(i09)  # revealed: C
-    reveal_type(i10)  # revealed: B & Unrelated
-    reveal_type(i11)  # revealed: B & Unrelated
-    reveal_type(i12)  # revealed: B & Unrelated
-    reveal_type(i13)  # revealed: Unrelated & B
-    reveal_type(i14)  # revealed: Unrelated & B
-    reveal_type(i15)  # revealed: Unrelated & B
-    reveal_type(i16)  # revealed: B & Any
-    reveal_type(i17)  # revealed: B & Any
-    reveal_type(i18)  # revealed: B & Any
-    reveal_type(i19)  # revealed: Any & B
-    reveal_type(i20)  # revealed: Any & B
-    reveal_type(i21)  # revealed: Any & B
-```
-
-#### Negative type and negative subtype
-
-For negative contributions, this property is reversed. Here we can remove superfluous _subtypes_:
-
-```py
-from knot_extensions import Intersection, Not
-from typing import Any
-
-class A: ...
-class B(A): ...
-class C(B): ...
-class Unrelated: ...
-
-def _(
-    i01: Intersection[Not[B], Not[A]],
-    i02: Intersection[Not[A], Not[B]],
-    i03: Intersection[Not[A], Not[C]],
-    i04: Intersection[Not[C], Not[A]],
-    i05: Intersection[Not[B], Not[C]],
-    i06: Intersection[Not[C], Not[B]],
-    i07: Intersection[Not[A], Not[B], Not[C]],
-    i08: Intersection[Not[C], Not[B], Not[A]],
-    i09: Intersection[Not[B], Not[C], Not[A]],
-    i10: Intersection[Not[B], Not[A], Unrelated],
-    i11: Intersection[Not[A], Not[B], Unrelated],
-    i12: Intersection[Not[A], Unrelated, Not[B]],
-    i13: Intersection[Not[B], Unrelated, Not[A]],
-    i14: Intersection[Unrelated, Not[A], Not[B]],
-    i15: Intersection[Unrelated, Not[B], Not[A]],
-    i16: Intersection[Not[B], Not[A], Any],
-    i17: Intersection[Not[A], Not[B], Any],
-    i18: Intersection[Not[A], Any, Not[B]],
-    i19: Intersection[Not[B], Any, Not[A]],
-    i20: Intersection[Any, Not[A], Not[B]],
-    i21: Intersection[Any, Not[B], Not[A]],
-) -> None:
-    reveal_type(i01)  # revealed: ~A
-    reveal_type(i02)  # revealed: ~A
-    reveal_type(i03)  # revealed: ~A
-    reveal_type(i04)  # revealed: ~A
-    reveal_type(i05)  # revealed: ~B
-    reveal_type(i06)  # revealed: ~B
-    reveal_type(i07)  # revealed: ~A
-    reveal_type(i08)  # revealed: ~A
-    reveal_type(i09)  # revealed: ~A
-    reveal_type(i10)  # revealed: Unrelated & ~A
-    reveal_type(i11)  # revealed: Unrelated & ~A
-    reveal_type(i12)  # revealed: Unrelated & ~A
-    reveal_type(i13)  # revealed: Unrelated & ~A
-    reveal_type(i14)  # revealed: Unrelated & ~A
-    reveal_type(i15)  # revealed: Unrelated & ~A
-    reveal_type(i16)  # revealed: Any & ~A
-    reveal_type(i17)  # revealed: Any & ~A
-    reveal_type(i18)  # revealed: Any & ~A
-    reveal_type(i19)  # revealed: Any & ~A
-    reveal_type(i20)  # revealed: Any & ~A
-    reveal_type(i21)  # revealed: Any & ~A
-```
-
-#### Negative type and multiple negative subtypes
-
-If there are multiple negative subtypes, all of them can be removed:
-
-```py
-from knot_extensions import Intersection, Not
-
-class A: ...
-class B1(A): ...
-class B2(A): ...
-
-def _(
-    i1: Intersection[Not[A], Not[B1], Not[B2]],
-    i2: Intersection[Not[A], Not[B2], Not[B1]],
-    i3: Intersection[Not[B1], Not[A], Not[B2]],
-    i4: Intersection[Not[B1], Not[B2], Not[A]],
-    i5: Intersection[Not[B2], Not[A], Not[B1]],
-    i6: Intersection[Not[B2], Not[B1], Not[A]],
-) -> None:
-    reveal_type(i1)  # revealed: ~A
-    reveal_type(i2)  # revealed: ~A
-    reveal_type(i3)  # revealed: ~A
-    reveal_type(i4)  # revealed: ~A
-    reveal_type(i5)  # revealed: ~A
-    reveal_type(i6)  # revealed: ~A
-```
-
-#### Negative type and positive subtype
-
-When `A` is a supertype of `B`, its negation `~A` is disjoint from `B`, so we can simplify the
-intersection to `Never`:
-
-```py
-from knot_extensions import Intersection, Not
-from typing import Any
-
-class A: ...
-class B(A): ...
-class C(B): ...
-class Unrelated: ...
-
-def _(
-    i1: Intersection[Not[A], B],
-    i2: Intersection[B, Not[A]],
-    i3: Intersection[Not[A], C],
-    i4: Intersection[C, Not[A]],
-    i5: Intersection[Unrelated, Not[A], B],
-    i6: Intersection[B, Not[A], Not[Unrelated]],
-    i7: Intersection[Any, Not[A], B],
-    i8: Intersection[B, Not[A], Not[Any]],
-) -> None:
-    reveal_type(i1)  # revealed: Never
-    reveal_type(i2)  # revealed: Never
-    reveal_type(i3)  # revealed: Never
-    reveal_type(i4)  # revealed: Never
-    reveal_type(i5)  # revealed: Never
-    reveal_type(i6)  # revealed: Never
-    reveal_type(i7)  # revealed: Never
-    reveal_type(i8)  # revealed: Never
-```
-
-### Simplifications of `bool`, `AlwaysTruthy` and `AlwaysFalsy`
-
-In general, intersections with `AlwaysTruthy` and `AlwaysFalsy` cannot be simplified. Naively, you
-might think that `int & AlwaysFalsy` could simplify to `Literal[0]`, but this is not the case: for
-example, the `False` constant inhabits the type `int & AlwaysFalsy` (due to the fact that
-`False.__class__` is `bool` at runtime, and `bool` subclasses `int`), but `False` does not inhabit
-the type `Literal[0]`.
-
-Nonetheless, intersections of `AlwaysFalsy` or `AlwaysTruthy` with `bool` _can_ be simplified, due
-to the fact that `bool` is a `@final` class at runtime that cannot be subclassed.
-
-```py
-from knot_extensions import Intersection, Not, AlwaysTruthy, AlwaysFalsy
-
-class P: ...
-
-def f(
-    a: Intersection[bool, AlwaysTruthy],
-    b: Intersection[bool, AlwaysFalsy],
-    c: Intersection[bool, Not[AlwaysTruthy]],
-    d: Intersection[bool, Not[AlwaysFalsy]],
-    e: Intersection[bool, AlwaysTruthy, P],
-    f: Intersection[bool, AlwaysFalsy, P],
-    g: Intersection[bool, Not[AlwaysTruthy], P],
-    h: Intersection[bool, Not[AlwaysFalsy], P],
-):
-    reveal_type(a)  # revealed: Literal[True]
-    reveal_type(b)  # revealed: Literal[False]
-    reveal_type(c)  # revealed: Literal[False]
-    reveal_type(d)  # revealed: Literal[True]
-
-    # `bool & AlwaysTruthy & P` -> `Literal[True] & P` -> `Never`
-    reveal_type(e)  # revealed: Never
-    reveal_type(f)  # revealed: Never
-    reveal_type(g)  # revealed: Never
-    reveal_type(h)  # revealed: Never
-```
-
-## Simplification of `LiteralString`, `AlwaysTruthy` and `AlwaysFalsy`
-
-Similarly, intersections between `LiteralString`, `AlwaysTruthy` and `AlwaysFalsy` can be
-simplified, due to the fact that a `LiteralString` inhabitant is known to have `__class__` set to
-exactly `str` (and not a subclass of `str`):
-
-```py
-from knot_extensions import Intersection, Not, AlwaysTruthy, AlwaysFalsy, Unknown
-from typing_extensions import LiteralString
-
-def f(
-    a: Intersection[LiteralString, AlwaysTruthy],
-    b: Intersection[LiteralString, AlwaysFalsy],
-    c: Intersection[LiteralString, Not[AlwaysTruthy]],
-    d: Intersection[LiteralString, Not[AlwaysFalsy]],
-    e: Intersection[AlwaysFalsy, LiteralString],
-    f: Intersection[Not[AlwaysTruthy], LiteralString],
-    g: Intersection[AlwaysTruthy, LiteralString],
-    h: Intersection[Not[AlwaysFalsy], LiteralString],
-    i: Intersection[Unknown, LiteralString, AlwaysFalsy],
-    j: Intersection[Not[AlwaysTruthy], Unknown, LiteralString],
-):
-    reveal_type(a)  # revealed: LiteralString & ~Literal[""]
-    reveal_type(b)  # revealed: Literal[""]
-    reveal_type(c)  # revealed: Literal[""]
-    reveal_type(d)  # revealed: LiteralString & ~Literal[""]
-    reveal_type(e)  # revealed: Literal[""]
-    reveal_type(f)  # revealed: Literal[""]
-    reveal_type(g)  # revealed: LiteralString & ~Literal[""]
-    reveal_type(h)  # revealed: LiteralString & ~Literal[""]
-    reveal_type(i)  # revealed: Unknown & Literal[""]
-    reveal_type(j)  # revealed: Unknown & Literal[""]
-```
-
-## Addition of a type to an intersection with many non-disjoint types
-
-This slightly strange-looking test is a regression test for a mistake that was nearly made in a PR:
-<https://github.com/astral-sh/ruff/pull/15475#discussion_r1915041987>.
-
-```py
-from knot_extensions import AlwaysFalsy, Intersection, Unknown
-from typing_extensions import Literal
-
-def _(x: Intersection[str, Unknown, AlwaysFalsy, Literal[""]]):
-    reveal_type(x)  # revealed: Unknown & Literal[""]
-```
-
-## Non fully-static types
-
-### Negation of dynamic types
-
-`Any` represents the dynamic type, an unknown set of runtime values. The negation of that, `~Any`,
-is still an unknown set of runtime values, so `~Any` is equivalent to `Any`. We therefore eagerly
-simplify `~Any` to `Any` in intersections. The same applies to `Unknown`.
-
-```py
-from knot_extensions import Intersection, Not, Unknown
-from typing_extensions import Any, Never
-
-class P: ...
-
-def any(
-    i1: Not[Any],
-    i2: Intersection[P, Not[Any]],
-    i3: Intersection[Never, Not[Any]],
-) -> None:
-    reveal_type(i1)  # revealed: Any
-    reveal_type(i2)  # revealed: P & Any
-    reveal_type(i3)  # revealed: Never
-
-def unknown(
-    i1: Not[Unknown],
-    i2: Intersection[P, Not[Unknown]],
-    i3: Intersection[Never, Not[Unknown]],
-) -> None:
-    reveal_type(i1)  # revealed: Unknown
-    reveal_type(i2)  # revealed: P & Unknown
-    reveal_type(i3)  # revealed: Never
-```
-
-### Collapsing of multiple `Any`/`Unknown` contributions
-
-The intersection of an unknown set of runtime values with (another) unknown set of runtime values is
-still an unknown set of runtime values:
-
-```py
-from knot_extensions import Intersection, Not, Unknown
-from typing_extensions import Any
-
-class P: ...
-
-def any(
-    i1: Intersection[Any, Any],
-    i2: Intersection[P, Any, Any],
-    i3: Intersection[Any, P, Any],
-    i4: Intersection[Any, Any, P],
-) -> None:
-    reveal_type(i1)  # revealed: Any
-    reveal_type(i2)  # revealed: P & Any
-    reveal_type(i3)  # revealed: Any & P
-    reveal_type(i4)  # revealed: Any & P
-
-def unknown(
-    i1: Intersection[Unknown, Unknown],
-    i2: Intersection[P, Unknown, Unknown],
-    i3: Intersection[Unknown, P, Unknown],
-    i4: Intersection[Unknown, Unknown, P],
-) -> None:
-    reveal_type(i1)  # revealed: Unknown
-    reveal_type(i2)  # revealed: P & Unknown
-    reveal_type(i3)  # revealed: Unknown & P
-    reveal_type(i4)  # revealed: Unknown & P
-```
-
-### No self-cancellation
-
-Dynamic types do not cancel each other out. Intersecting an unknown set of values with the negation
-of another unknown set of values is not necessarily empty, so we keep the positive contribution:
-
-```py
-from knot_extensions import Intersection, Not, Unknown
-
-def any(
-    i1: Intersection[Any, Not[Any]],
-    i2: Intersection[Not[Any], Any],
-) -> None:
-    reveal_type(i1)  # revealed: Any
-    reveal_type(i2)  # revealed: Any
-
-def unknown(
-    i1: Intersection[Unknown, Not[Unknown]],
-    i2: Intersection[Not[Unknown], Unknown],
-) -> None:
-    reveal_type(i1)  # revealed: Unknown
-    reveal_type(i2)  # revealed: Unknown
-```
-
-### Mixed dynamic types
-
-We currently do not simplify mixed dynamic types, but might consider doing so in the future:
-
-```py
-from knot_extensions import Intersection, Not, Unknown
-
-def mixed(
-    i1: Intersection[Any, Unknown],
-    i2: Intersection[Any, Not[Unknown]],
-    i3: Intersection[Not[Any], Unknown],
-    i4: Intersection[Not[Any], Not[Unknown]],
-) -> None:
-    reveal_type(i1)  # revealed: Any & Unknown
-    reveal_type(i2)  # revealed: Any & Unknown
-    reveal_type(i3)  # revealed: Any & Unknown
-    reveal_type(i4)  # revealed: Any & Unknown
-```
-
-[complement laws]: https://en.wikipedia.org/wiki/Complement_(set_theory)
-[de morgan's laws]: https://en.wikipedia.org/wiki/De_Morgan%27s_laws

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

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

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

@@ -0,0 +1,93 @@
+# Literal
+
+<https://typing.readthedocs.io/en/latest/spec/literal.html#literals>
+
+## Parameterization
+
+```py
+from typing import Literal
+from enum import Enum
+
+mode: Literal["w", "r"]
+mode2: Literal["w"] | Literal["r"]
+union_var: Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]
+a1: Literal[26]
+a2: Literal[0x1A]
+a3: Literal[-4]
+a4: Literal["hello world"]
+a5: Literal[b"hello world"]
+a6: Literal[True]
+a7: Literal[None]
+a8: Literal[Literal[1]]
+a9: Literal[Literal["w"], Literal["r"], Literal[Literal["w+"]]]
+
+class Color(Enum):
+    RED = 0
+    GREEN = 1
+    BLUE = 2
+
+b1: Literal[Color.RED]
+
+def f():
+    reveal_type(mode)  # revealed: Literal["w", "r"]
+    reveal_type(mode2)  # revealed: Literal["w", "r"]
+    # TODO: should be revealed: Literal[1, 2, 3, "foo", 5] | None
+    reveal_type(union_var)  # revealed: Literal[1, 2, 3, 5] | Literal["foo"] | None
+    reveal_type(a1)  # revealed: Literal[26]
+    reveal_type(a2)  # revealed: Literal[26]
+    reveal_type(a3)  # revealed: Literal[-4]
+    reveal_type(a4)  # revealed: Literal["hello world"]
+    reveal_type(a5)  # revealed: Literal[b"hello world"]
+    reveal_type(a6)  # revealed: Literal[True]
+    reveal_type(a7)  # revealed: None
+    reveal_type(a8)  # revealed: Literal[1]
+    reveal_type(a9)  # revealed: Literal["w", "r", "w+"]
+    # TODO: This should be Color.RED
+    reveal_type(b1)  # revealed: Literal[0]
+
+# error: [invalid-literal-parameter]
+invalid1: Literal[3 + 4]
+# error: [invalid-literal-parameter]
+invalid2: Literal[4 + 3j]
+# error: [invalid-literal-parameter]
+invalid3: Literal[(3, 4)]
+
+hello = "hello"
+invalid4: Literal[
+    1 + 2,  # error: [invalid-literal-parameter]
+    "foo",
+    hello,  # error: [invalid-literal-parameter]
+    (1, 2, 3),  # error: [invalid-literal-parameter]
+]
+```
+
+## Detecting Literal outside typing and typing_extensions
+
+Only Literal that is defined in typing and typing_extension modules is detected as the special
+Literal.
+
+```pyi path=other.pyi
+from typing import _SpecialForm
+
+Literal: _SpecialForm
+```
+
+```py
+from other import Literal
+
+a1: Literal[26]
+
+def f():
+    reveal_type(a1)  # revealed: @Todo(generics)
+```
+
+## Detecting typing_extensions.Literal
+
+```py
+from typing_extensions import Literal
+
+a1: Literal[26]
+
+def f():
+    reveal_type(a1)  # revealed: Literal[26]
+```

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

@@ -98,7 +98,7 @@ reveal_type(x)
 for x in (1, "a", b"foo"):
     pass
 
-# revealed: Literal[1, "a", b"foo"]
+# revealed: Literal[1] | Literal["a"] | Literal[b"foo"]
 # error: [possibly-unresolved-reference]
 reveal_type(x)
 ```

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

@@ -1,6 +1,6 @@
 # While loops
 
-## Basic `while` loop
+## Basic While Loop
 
 ```py
 def _(flag: bool):
@@ -11,7 +11,7 @@ def _(flag: bool):
     reveal_type(x)  # revealed: Literal[1, 2]
 ```
 
-## `while` with `else` (no `break`)
+## While with else (no break)
 
 ```py
 def _(flag: bool):
@@ -25,7 +25,7 @@ def _(flag: bool):
     reveal_type(x)  # revealed: Literal[3]
 ```
 
-## `while` with `else` (may `break`)
+## While with Else (may break)
 
 ```py
 def _(flag: bool, flag2: bool):
@@ -41,10 +41,10 @@ def _(flag: bool, flag2: bool):
         x = 3
 
     reveal_type(x)  # revealed: Literal[2, 3]
-    reveal_type(y)  # revealed: Literal[4, 1, 2]
+    reveal_type(y)  # revealed: Literal[1, 2, 4]
 ```
 
-## Nested `while` loops
+## Nested while loops
 
 ```py
 def flag() -> bool:
@@ -69,50 +69,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
-```

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

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
@@ -170,35 +170,8 @@ def f(*args, **kwargs) -> int: ...
 
 class A(metaclass=f): ...
 
-# TODO: Should be `int`
-reveal_type(A)  # revealed: Literal[A]
-reveal_type(A.__class__)  # revealed: type[int]
-
-def _(n: int):
-    # error: [invalid-metaclass]
-    class B(metaclass=n): ...
-    # TODO: Should be `Unknown`
-    reveal_type(B)  # revealed: Literal[B]
-    reveal_type(B.__class__)  # revealed: type[Unknown]
-
-def _(flag: bool):
-    m = f if flag else 42
-
-    # error: [invalid-metaclass]
-    class C(metaclass=m): ...
-    # TODO: Should be `int | Unknown`
-    reveal_type(C)  # revealed: Literal[C]
-    reveal_type(C.__class__)  # revealed: type[Unknown]
-
-class SignatureMismatch: ...
-
-# TODO: Emit a diagnostic
-class D(metaclass=SignatureMismatch): ...
-
-# TODO: Should be `Unknown`
-reveal_type(D)  # revealed: Literal[D]
-# TODO: Should be `type[Unknown]`
-reveal_type(D.__class__)  # revealed: Literal[SignatureMismatch]
+# TODO should be `type[int]`
+reveal_type(A.__class__)  # revealed: @Todo(metaclass not a class)
 ```
 
 ## Cyclic
@@ -210,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
@@ -221,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__)
-```

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

@@ -56,7 +56,7 @@ def _(x_flag: bool, y_flag: bool):
 def _(flag1: bool, flag2: bool):
     x = None if flag1 else (1 if flag2 else True)
 
-    reveal_type(x)  # revealed: None | Literal[1, True]
+    reveal_type(x)  # revealed: None | Literal[1] | Literal[True]
     if x is None:
         reveal_type(x)  # revealed: None
     elif x is True:

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

@@ -17,7 +17,7 @@ def _(flag: bool):
             reveal_type(x)  # revealed: Never
 
     if isinstance(x, (int, object)):
-        reveal_type(x)  # revealed: Literal[1, "a"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```
 
 ## `classinfo` is a tuple of types
@@ -30,7 +30,7 @@ def _(flag: bool, flag1: bool, flag2: bool):
     x = 1 if flag else "a"
 
     if isinstance(x, (int, str)):
-        reveal_type(x)  # revealed: Literal[1, "a"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
     else:
         reveal_type(x)  # revealed: Never
 
@@ -43,19 +43,19 @@ def _(flag: bool, flag1: bool, flag2: bool):
     # 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, "a"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
     else:
         reveal_type(x)  # revealed: Never
 
     y = 1 if flag1 else "a" if flag2 else b"b"
     if isinstance(y, (int, str)):
-        reveal_type(y)  # revealed: Literal[1, "a"]
+        reveal_type(y)  # revealed: Literal[1] | Literal["a"]
 
     if isinstance(y, (int, bytes)):
-        reveal_type(y)  # revealed: Literal[1, b"b"]
+        reveal_type(y)  # revealed: Literal[1] | Literal[b"b"]
 
     if isinstance(y, (str, bytes)):
-        reveal_type(y)  # revealed: Literal["a", b"b"]
+        reveal_type(y)  # revealed: Literal["a"] | Literal[b"b"]
 ```
 
 ## `classinfo` is a nested tuple of types
@@ -91,7 +91,8 @@ if isinstance(x, (A, B)):
 elif isinstance(x, (A, C)):
     reveal_type(x)  # revealed: C & ~A & ~B
 else:
-    reveal_type(x)  # revealed: ~A & ~B & ~C
+    # TODO: Should be simplified to ~A & ~B & ~C
+    reveal_type(x)  # revealed: object & ~A & ~B & ~C
 ```
 
 ## No narrowing for instances of `builtins.type`
@@ -106,7 +107,7 @@ def _(flag: bool):
     x = 1 if flag else "foo"
 
     if isinstance(x, t):
-        reveal_type(x)  # revealed: Literal[1, "foo"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["foo"]
 ```
 
 ## Do not use custom `isinstance` for narrowing
@@ -118,7 +119,7 @@ def _(flag: bool):
     x = 1 if flag else "a"
 
     if isinstance(x, int):
-        reveal_type(x)  # revealed: Literal[1, "a"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```
 
 ## Do support narrowing if `isinstance` is aliased
@@ -154,12 +155,12 @@ def _(flag: bool):
     # TODO: this should cause us to emit a diagnostic during
     # type checking
     if isinstance(x, "a"):
-        reveal_type(x)  # revealed: Literal[1, "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, "a"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```
 
 ## Do not narrow if there are keyword arguments
@@ -168,55 +169,8 @@ def _(flag: bool):
 def _(flag: bool):
     x = 1 if flag else "a"
 
-    # error: [unknown-argument]
+    # 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, "a"]
-```
-
-## `type[]` types are narrowed as well as class-literal types
-
-```py
-def _(x: object, y: type[int]):
-    if isinstance(x, y):
-        reveal_type(x)  # revealed: int
-```
-
-## Adding a disjoint element to an existing intersection
-
-We used to incorrectly infer `Literal` booleans for some of these.
-
-```py
-from knot_extensions import Not, Intersection, AlwaysTruthy, AlwaysFalsy
-
-class P: ...
-
-def f(
-    a: Intersection[P, AlwaysTruthy],
-    b: Intersection[P, AlwaysFalsy],
-    c: Intersection[P, Not[AlwaysTruthy]],
-    d: Intersection[P, Not[AlwaysFalsy]],
-):
-    if isinstance(a, bool):
-        reveal_type(a)  # revealed: Never
-    else:
-        # TODO: `bool` is final, so `& ~bool` is redundant here
-        reveal_type(a)  # revealed: P & AlwaysTruthy & ~bool
-
-    if isinstance(b, bool):
-        reveal_type(b)  # revealed: Never
-    else:
-        # TODO: `bool` is final, so `& ~bool` is redundant here
-        reveal_type(b)  # revealed: P & AlwaysFalsy & ~bool
-
-    if isinstance(c, bool):
-        reveal_type(c)  # revealed: Never
-    else:
-        # TODO: `bool` is final, so `& ~bool` is redundant here
-        reveal_type(c)  # revealed: P & ~AlwaysTruthy & ~bool
-
-    if isinstance(d, bool):
-        reveal_type(d)  # revealed: Never
-    else:
-        # TODO: `bool` is final, so `& ~bool` is redundant here
-        reveal_type(d)  # revealed: P & ~AlwaysFalsy & ~bool
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```

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

@@ -90,19 +90,15 @@ def _(t: type[object]):
         if issubclass(t, B):
             reveal_type(t)  # revealed: type[A] & type[B]
     else:
-        reveal_type(t)  # revealed: type & ~type[A]
+        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):
@@ -146,7 +142,7 @@ class A: ...
 
 t = object()
 
-# error: [invalid-argument-type]
+# TODO: we should emit a diagnostic here
 if issubclass(t, A):
     reveal_type(t)  # revealed: type[A]
 ```
@@ -160,7 +156,7 @@ branch:
 ```py
 t = 1
 
-# error: [invalid-argument-type]
+# TODO: we should emit a diagnostic here
 if issubclass(t, int):
     reveal_type(t)  # revealed: Never
 ```
@@ -234,15 +230,8 @@ def flag() -> bool: ...
 
 t = int if flag() else str
 
-# error: [unknown-argument]
+# TODO: this should cause us to emit a diagnostic
+# (`issubclass` has no `foo` parameter)
 if issubclass(t, int, foo="bar"):
     reveal_type(t)  # revealed: Literal[int, str]
 ```
-
-### `type[]` types are narrowed as well as class-literal types
-
-```py
-def _(x: type, y: type[int]):
-    if issubclass(x, y):
-        reveal_type(x)  # revealed: type[int]
-```

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

@@ -16,48 +16,3 @@ def _(flag: bool):
 
     reveal_type(y)  # revealed: Literal[0] | None
 ```
-
-## Class patterns
-
-```py
-def get_object() -> object: ...
-
-class A: ...
-class B: ...
-
-x = get_object()
-
-reveal_type(x)  # revealed: object
-
-match x:
-    case A():
-        reveal_type(x)  # revealed: A
-    case B():
-        # TODO could be `B & ~A`
-        reveal_type(x)  # revealed: B
-
-reveal_type(x)  # revealed: object
-```
-
-## Class pattern with guard
-
-```py
-def get_object() -> object: ...
-
-class A:
-    def y() -> int: ...
-
-class B: ...
-
-x = get_object()
-
-reveal_type(x)  # revealed: object
-
-match x:
-    case A() if reveal_type(x):  # revealed: A
-        pass
-    case B() if reveal_type(x):  # revealed: B
-        pass
-
-reveal_type(x)  # revealed: object
-```

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

@@ -1,331 +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, True, "foo", b"bar"]
-else:
-    reveal_type(x)  # revealed: Literal[0, False, "", b""] | None | tuple[()]
-
-if not x:
-    reveal_type(x)  # revealed: Literal[0, False, "", b""] | None | tuple[()]
-else:
-    reveal_type(x)  # revealed: Literal[-1, True, "foo", b"bar"]
-
-if x and not x:
-    reveal_type(x)  # revealed: Never
-else:
-    reveal_type(x)  # revealed: Literal[0, -1, "", "foo", b"", b"bar"] | bool | None | tuple[()]
-
-if not (x and not x):
-    reveal_type(x)  # revealed: Literal[0, -1, "", "foo", b"", b"bar"] | bool | None | tuple[()]
-else:
-    reveal_type(x)  # revealed: Never
-
-if x or not x:
-    reveal_type(x)  # revealed: Literal[0, -1, "", "foo", b"", b"bar"] | bool | 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[0, -1, "", "foo", b"", b"bar"] | bool | None | tuple[()]
-
-if (isinstance(x, int) or isinstance(x, str)) and x:
-    reveal_type(x)  # revealed: Literal[-1, True, "foo"]
-else:
-    reveal_type(x)  # revealed: Literal[b"", b"bar", 0, False, ""] | None | tuple[()]
-```
-
-## 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 | B
-
-    if x or not x:
-        reveal_type(x)  # revealed: A | B
-    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, "", "hello"]
-
-    z = x if flag() else y
-
-    reveal_type(z)  # revealed: A & str & ~B | Literal[0, 42, "", "hello"]
-
-    if z:
-        reveal_type(z)  # revealed: A & str & ~B & ~AlwaysFalsy | Literal[42, "hello"]
-    else:
-        reveal_type(z)  # revealed: A & str & ~B & ~AlwaysTruthy | Literal[0, ""]
-```
-
-## 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"]
-```
-
-## Control Flow 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
-
-reveal_type(y)  # revealed: A
-```
-
-## 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
-```
-
-## Truthiness narrowing for `LiteralString`
-
-```py
-from typing_extensions import LiteralString
-
-def _(x: LiteralString):
-    if x:
-        reveal_type(x)  # revealed: LiteralString & ~Literal[""]
-    else:
-        reveal_type(x)  # revealed: Literal[""]
-
-    if not x:
-        reveal_type(x)  # revealed: Literal[""]
-    else:
-        reveal_type(x)  # revealed: LiteralString & ~Literal[""]
-```

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

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

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

@@ -37,7 +37,7 @@ class C:
     # error: [possibly-unresolved-reference]
     y = x
 
-reveal_type(C.y)  # revealed: Literal[1, "abc"]
+reveal_type(C.y)  # revealed: Literal[1] | Literal["abc"]
 ```
 
 ## Unbound function local

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

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(return type)
-
-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): ...
-```

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

@@ -1,78 +0,0 @@
-# Ellipsis
-
-## Function and methods
-
-The ellipsis literal `...` can be used as a placeholder default value for a function parameter, in a
-stub file only, regardless of the type of the parameter.
-
-```py path=test.pyi
-def f(x: int = ...) -> None:
-    reveal_type(x)  # revealed: int
-
-def f2(x: str = ...) -> None:
-    reveal_type(x)  # revealed: str
-```
-
-## Class and module symbols
-
-The ellipsis literal can be assigned to a class or module symbol, regardless of its declared type,
-in a stub file only.
-
-```py path=test.pyi
-y: bytes = ...
-reveal_type(y)  # revealed: bytes
-x = ...
-reveal_type(x)  # revealed: Unknown
-
-class Foo:
-    y: int = ...
-
-reveal_type(Foo.y)  # revealed: int
-```
-
-## Unpacking ellipsis literal in assignment
-
-No diagnostic is emitted if an ellipsis literal is "unpacked" in a stub file as part of an
-assignment statement:
-
-```py path=test.pyi
-x, y = ...
-reveal_type(x)  # revealed: Unknown
-reveal_type(y)  # revealed: Unknown
-```
-
-## Unpacking ellipsis literal in for loops
-
-Iterating over an ellipsis literal as part of a `for` loop in a stub is invalid, however, and
-results in a diagnostic:
-
-```py path=test.pyi
-# error: [not-iterable] "Object of type `ellipsis` is not iterable"
-for a, b in ...:
-    reveal_type(a)  # revealed: Unknown
-    reveal_type(b)  # revealed: Unknown
-```
-
-## Ellipsis usage in non stub file
-
-In a non-stub file, there's no special treatment of ellipsis literals. An ellipsis literal can only
-be assigned if `EllipsisType` is actually assignable to the annotated type.
-
-```py
-# error: 7 [invalid-parameter-default] "Default value of type `ellipsis` is not assignable to annotated parameter type `int`"
-def f(x: int = ...) -> None: ...
-
-# error: 1 [invalid-assignment] "Object of type `ellipsis` is not assignable to `int`"
-a: int = ...
-b = ...
-reveal_type(b)  # revealed: ellipsis
-```
-
-## Use of `Ellipsis` symbol
-
-There is no special treatment of the builtin name `Ellipsis` in stubs, only of `...` literals.
-
-```py path=test.pyi
-# error: 7 [invalid-parameter-default] "Default value of type `ellipsis` is not assignable to annotated parameter type `int`"
-def f(x: int = Ellipsis) -> None: ...
-```

crates/red_knot_python_semantic/resources/mdtest/subscript/tuple.md

@@ -77,11 +77,14 @@ def _(m: int, n: int):
 
 ```toml
 [environment]
-python-version = "3.9"
+target-version = "3.9"
 ```
 
 ```py
-# TODO: `tuple[int, str]` is a valid base (generics)
+# TODO:
+#  * `tuple.__class_getitem__` is always bound on 3.9 (`sys.version_info`)
+#  * `tuple[int, str]` is a valid base (generics)
+# error: [call-possibly-unbound-method] "Method `__class_getitem__` of type `Literal[tuple]` is possibly unbound"
 # error: [invalid-base] "Invalid class base with type `GenericAlias` (all bases must be a class, `Any`, `Unknown` or `Todo`)"
 class A(tuple[int, str]): ...
 

crates/red_knot_python_semantic/resources/mdtest/suppressions/knot_ignore.md

@@ -1,182 +0,0 @@
-# Suppressing errors with `knot: ignore`
-
-Type check errors can be suppressed by a `knot: ignore` comment on the same line as the violation.
-
-## Simple `knot: ignore`
-
-```py
-a = 4 + test  # knot: ignore
-```
-
-## Suppressing a specific code
-
-```py
-a = 4 + test  # knot: ignore[unresolved-reference]
-```
-
-## Unused suppression
-
-```py
-test = 10
-# error: [unused-ignore-comment] "Unused `knot: ignore` directive: 'possibly-unresolved-reference'"
-a = test + 3  # knot: ignore[possibly-unresolved-reference]
-```
-
-## Unused suppression if the error codes don't match
-
-```py
-# error: [unresolved-reference]
-# error: [unused-ignore-comment] "Unused `knot: ignore` directive: 'possibly-unresolved-reference'"
-a = test + 3  # knot: ignore[possibly-unresolved-reference]
-```
-
-## Suppressed unused comment
-
-```py
-# error: [unused-ignore-comment]
-a = 10 / 2  # knot: ignore[division-by-zero]
-a = 10 / 2  # knot: ignore[division-by-zero, unused-ignore-comment]
-a = 10 / 2  # knot: ignore[unused-ignore-comment, division-by-zero]
-a = 10 / 2  # knot: ignore[unused-ignore-comment] # type: ignore
-a = 10 / 2  # type: ignore # knot: ignore[unused-ignore-comment]
-```
-
-## Unused ignore comment
-
-```py
-# error: [unused-ignore-comment] "Unused `knot: ignore` directive: 'unused-ignore-comment'"
-a = 10 / 0  # knot: ignore[division-by-zero, unused-ignore-comment]
-```
-
-## Multiple unused comments
-
-Today, Red Knot emits a diagnostic for every unused code. We might want to group the codes by
-comment at some point in the future.
-
-```py
-# error: [unused-ignore-comment] "Unused `knot: ignore` directive: 'division-by-zero'"
-# error: [unused-ignore-comment] "Unused `knot: ignore` directive: 'unresolved-reference'"
-a = 10 / 2  # knot: ignore[division-by-zero, unresolved-reference]
-
-# error: [unused-ignore-comment] "Unused `knot: ignore` directive: 'invalid-assignment'"
-# error: [unused-ignore-comment] "Unused `knot: ignore` directive: 'unresolved-reference'"
-a = 10 / 0  # knot: ignore[invalid-assignment, division-by-zero, unresolved-reference]
-```
-
-## Multiple suppressions
-
-```py
-# fmt: off
-def test(a: f"f-string type annotation", b: b"byte-string-type-annotation"): ...  # knot: ignore[fstring-type-annotation, byte-string-type-annotation]
-```
-
-## Can't suppress syntax errors
-
-<!-- blacken-docs:off -->
-
-```py
-# error: [invalid-syntax]
-# error: [unused-ignore-comment]
-def test(  # knot: ignore
-```
-
-<!-- blacken-docs:on -->
-
-## Can't suppress `revealed-type` diagnostics
-
-```py
-a = 10
-# revealed: Literal[10]
-# error: [unknown-rule] "Unknown rule `revealed-type`"
-reveal_type(a)  # knot: ignore[revealed-type]
-```
-
-## Extra whitespace in type ignore comments is allowed
-
-```py
-a = 10 / 0  # knot   :   ignore
-a = 10 / 0  # knot: ignore  [    division-by-zero   ]
-```
-
-## Whitespace is optional
-
-```py
-# fmt: off
-a = 10 / 0  #knot:ignore[division-by-zero]
-```
-
-## Trailing codes comma
-
-Trailing commas in the codes section are allowed:
-
-```py
-a = 10 / 0  # knot: ignore[division-by-zero,]
-```
-
-## Invalid characters in codes
-
-```py
-# error: [division-by-zero]
-# error: [invalid-ignore-comment] "Invalid `knot: ignore` comment: expected a alphanumeric character or `-` or `_` as code"
-a = 10 / 0  # knot: ignore[*-*]
-```
-
-## Trailing whitespace
-
-<!-- blacken-docs:off -->
-
-```py
-a = 10 / 0  # knot: ignore[division-by-zero]      
-            #                               ^^^^^^ trailing whitespace
-```
-
-<!-- blacken-docs:on -->
-
-## Missing comma
-
-A missing comma results in an invalid suppression comment. We may want to recover from this in the
-future.
-
-```py
-# error: [unresolved-reference]
-# error: [invalid-ignore-comment] "Invalid `knot: ignore` comment: expected a comma separating the rule codes"
-a = x / 0  # knot: ignore[division-by-zero unresolved-reference]
-```
-
-## Missing closing bracket
-
-```py
-# error: [unresolved-reference] "Name `x` used when not defined"
-# error: [invalid-ignore-comment] "Invalid `knot: ignore` comment: expected a comma separating the rule codes"
-a = x / 2  # knot: ignore[unresolved-reference
-```
-
-## Empty codes
-
-An empty codes array suppresses no-diagnostics and is always useless
-
-```py
-# error: [division-by-zero]
-# error: [unused-ignore-comment] "Unused `knot: ignore` without a code"
-a = 4 / 0  # knot: ignore[]
-```
-
-## File-level suppression comments
-
-File level suppression comments are currently intentionally unsupported because we've yet to decide
-if they should use a different syntax that also supports enabling rules or changing the rule's
-severity: `knot: possibly-undefined-reference=error`
-
-```py
-# error: [unused-ignore-comment]
-# knot: ignore[division-by-zero]
-
-a = 4 / 0  # error: [division-by-zero]
-```
-
-## Unknown rule
-
-```py
-# error: [unknown-rule] "Unknown rule `is-equal-14`"
-a = 10 + 4  # knot: ignore[is-equal-14]
-```

crates/red_knot_python_semantic/resources/mdtest/suppressions/no_type_check.md

@@ -1,118 +0,0 @@
-# `@no_type_check`
-
-> If a type checker supports the `no_type_check` decorator for functions, it should suppress all
-> type errors for the def statement and its body including any nested functions or classes. It
-> should also ignore all parameter and return type annotations and treat the function as if it were
-> unannotated. [source](https://typing.readthedocs.io/en/latest/spec/directives.html#no-type-check)
-
-## Error in the function body
-
-```py
-from typing import no_type_check
-
-@no_type_check
-def test() -> int:
-    return a + 5
-```
-
-## Error in nested function
-
-```py
-from typing import no_type_check
-
-@no_type_check
-def test() -> int:
-    def nested():
-        return a + 5
-```
-
-## Error in nested class
-
-```py
-from typing import no_type_check
-
-@no_type_check
-def test() -> int:
-    class Nested:
-        def inner(self):
-            return a + 5
-```
-
-## Error in preceding decorator
-
-Don't suppress diagnostics for decorators appearing before the `no_type_check` decorator.
-
-```py
-from typing import no_type_check
-
-@unknown_decorator  # error: [unresolved-reference]
-@no_type_check
-def test() -> int:
-    return a + 5
-```
-
-## Error in following decorator
-
-Unlike Pyright and mypy, suppress diagnostics appearing after the `no_type_check` decorator. We do
-this because it more closely matches Python's runtime semantics of decorators. For more details, see
-the discussion on the
-[PR adding `@no_type_check` support](https://github.com/astral-sh/ruff/pull/15122#discussion_r1896869411).
-
-```py
-from typing import no_type_check
-
-@no_type_check
-@unknown_decorator
-def test() -> int:
-    return a + 5
-```
-
-## Error in default value
-
-```py
-from typing import no_type_check
-
-@no_type_check
-def test(a: int = "test"):
-    return x + 5
-```
-
-## Error in return value position
-
-```py
-from typing import no_type_check
-
-@no_type_check
-def test() -> Undefined:
-    return x + 5
-```
-
-## `no_type_check` on classes isn't supported
-
-Red Knot does not support decorating classes with `no_type_check`. The behaviour of `no_type_check`
-when applied to classes is
-[not specified currently](https://typing.readthedocs.io/en/latest/spec/directives.html#no-type-check),
-and is not supported by Pyright or mypy.
-
-A future improvement might be to emit a diagnostic if a `no_type_check` annotation is applied to a
-class.
-
-```py
-from typing import no_type_check
-
-@no_type_check
-class Test:
-    def test(self):
-        return a + 5  # error: [unresolved-reference]
-```
-
-## `type: ignore` comments in `@no_type_check` blocks
-
-```py
-from typing import no_type_check
-
-@no_type_check
-def test():
-    # error: [unused-ignore-comment] "Unused `knot: ignore` directive: 'unresolved-reference'"
-    return x + 5  # knot: ignore[unresolved-reference]
-```

crates/red_knot_python_semantic/resources/mdtest/suppressions/type_ignore.md

@@ -1,162 +0,0 @@
-# Suppressing errors with `type: ignore`
-
-Type check errors can be suppressed by a `type: ignore` comment on the same line as the violation.
-
-## Simple `type: ignore`
-
-```py
-a = 4 + test  # type: ignore
-```
-
-## Multiline ranges
-
-A diagnostic with a multiline range can be suppressed by a comment on the same line as the
-diagnostic's start or end. This is the same behavior as Mypy's.
-
-```py
-# fmt: off
-y = (
-    4 / 0  # type: ignore
-)
-
-y = (
-    4 /  # type: ignore
-    0
-)
-
-y = (
-    4 /
-    0  # type: ignore
-)
-```
-
-Pyright diverges from this behavior and instead applies a suppression if its range intersects with
-the diagnostic range. This can be problematic for nested expressions because a suppression in a
-child expression now suppresses errors in the outer expression.
-
-For example, the `type: ignore` comment in this example suppresses the error of adding `2` to
-`"test"` and adding `"other"` to the result of the cast.
-
-```py path=nested.py
-# fmt: off
-from typing import cast
-
-y = (
-    cast(int, "test" +
-            # TODO: Remove the expected error after implementing `invalid-operator` for binary expressions
-            # error: [unused-ignore-comment]
-            2 # type: ignore
-    )
-    + "other"  # TODO: expected-error[invalid-operator]
-)
-```
-
-Mypy flags the second usage.
-
-## Before opening parenthesis
-
-A suppression that applies to all errors before the opening parenthesis.
-
-```py
-a: Test = (  # type: ignore
-  Test()  # error: [unresolved-reference]
-)  # fmt: skip
-```
-
-## Multiline string
-
-```py
-a: int = 4
-a = """
-  This is a multiline string and the suppression is at its end
-"""  # type: ignore
-```
-
-## Line continuations
-
-Suppressions after a line continuation apply to all previous lines.
-
-```py
-# fmt: off
-a = test \
-  + 2  # type: ignore
-
-a = test \
-  + a \
-  + 2  # type: ignore
-```
-
-## Codes
-
-Mypy supports `type: ignore[code]`. Red Knot doesn't understand mypy's rule names. Therefore, ignore
-the codes and suppress all errors.
-
-```py
-a = test  # type: ignore[name-defined]
-```
-
-## Nested comments
-
-```py
-# fmt: off
-a = test \
-  + 2  # fmt: skip # type: ignore
-
-a = test \
-  + 2  # type: ignore # fmt: skip
-```
-
-## Misspelled `type: ignore`
-
-```py
-# error: [unresolved-reference]
-# error: [invalid-ignore-comment]
-a = test + 2  # type: ignoree
-```
-
-## Invalid - ignore on opening parentheses
-
-`type: ignore` comments after an opening parentheses suppress any type errors inside the parentheses
-in Pyright. Neither Ruff, nor mypy support this and neither does Red Knot.
-
-```py
-# fmt: off
-# error: [unused-ignore-comment]
-a = (  # type: ignore
-    test + 4  # error: [unresolved-reference]
-)
-```
-
-## File level suppression
-
-```py
-# type: ignore
-
-a = 10 / 0
-b = a / 0
-```
-
-## File level suppression with leading shebang
-
-```py
-#!/usr/bin/env/python
-# type: ignore
-
-a = 10 / 0
-b = a / 0
-```
-
-## Invalid own-line suppression
-
-```py
-"""
-File level suppressions must come before any non-trivia token,
-including module docstrings. 
-"""
-
-# error: [unused-ignore-comment] "Unused blanket `type: ignore` directive"
-# type: ignore
-
-a = 10 / 0  # error: [division-by-zero]
-b = a / 0  # error: [division-by-zero]
-```

crates/red_knot_python_semantic/resources/mdtest/sys_platform.md

@@ -1,71 +0,0 @@
-# `sys.platform`
-
-## Default value
-
-When no target platform is specified, we fall back to the type of `sys.platform` declared in
-typeshed:
-
-```toml
-[environment]
-# No python-platform entry
-```
-
-```py
-import sys
-
-reveal_type(sys.platform)  # revealed: LiteralString
-```
-
-## Explicit selection of `all` platforms
-
-```toml
-[environment]
-python-platform = "all"
-```
-
-```py
-import sys
-
-reveal_type(sys.platform)  # revealed: LiteralString
-```
-
-## Explicit selection of a specific platform
-
-```toml
-[environment]
-python-platform = "linux"
-```
-
-```py
-import sys
-
-reveal_type(sys.platform)  # revealed: Literal["linux"]
-```
-
-## Testing for a specific platform
-
-### Exact comparison
-
-```toml
-[environment]
-python-platform = "freebsd8"
-```
-
-```py
-import sys
-
-reveal_type(sys.platform == "freebsd8")  # revealed: Literal[True]
-reveal_type(sys.platform == "linux")  # revealed: Literal[False]
-```
-
-### Substring comparison
-
-It is [recommended](https://docs.python.org/3/library/sys.html#sys.platform) to use
-`sys.platform.startswith(...)` for platform checks. This is not yet supported in type inference:
-
-```py
-import sys
-
-reveal_type(sys.platform.startswith("freebsd"))  # revealed: @Todo(Attribute access on `LiteralString` types)
-reveal_type(sys.platform.startswith("linux"))  # revealed: @Todo(Attribute access on `LiteralString` types)
-```

crates/red_knot_python_semantic/resources/mdtest/sys_version_info.md

@@ -2,7 +2,7 @@
 
 ```toml
 [environment]
-python-version = "3.9"
+target-version = "3.9"
 ```
 
 ## The type of `sys.version_info`

crates/red_knot_python_semantic/resources/mdtest/type_alias.md

@@ -1,11 +1,4 @@
-# PEP 695 type aliases
-
-PEP 695 type aliases are only available in Python 3.12 and later:
-
-```toml
-[environment]
-python-version = "3.12"
-```
+# Type aliases
 
 ## Basic
 

crates/red_knot_python_semantic/resources/mdtest/type_api.md

@@ -1,382 +0,0 @@
-# Type API (`knot_extensions`)
-
-This document describes the internal `knot_extensions` API for creating and manipulating types as
-well as testing various type system properties.
-
-## Type extensions
-
-The Python language itself allows us to perform a variety of operations on types. For example, we
-can build a union of types like `int | None`, or we can use type constructors such as `list[int]`
-and `type[int]` to create new types. But some type-level operations that we rely on in Red Knot,
-like intersections, cannot yet be expressed in Python. The `knot_extensions` module provides the
-`Intersection` and `Not` type constructors (special forms) which allow us to construct these types
-directly.
-
-### Negation
-
-```py
-from knot_extensions import Not, static_assert
-
-def negate(n1: Not[int], n2: Not[Not[int]], n3: Not[Not[Not[int]]]) -> None:
-    reveal_type(n1)  # revealed: ~int
-    reveal_type(n2)  # revealed: int
-    reveal_type(n3)  # revealed: ~int
-
-def static_truthiness(not_one: Not[Literal[1]]) -> None:
-    static_assert(not_one != 1)
-    static_assert(not (not_one == 1))
-
-# error: "Special form `knot_extensions.Not` expected exactly one type parameter"
-n: Not[int, str]
-```
-
-### Intersection
-
-```py
-from knot_extensions import Intersection, Not, is_subtype_of, static_assert
-from typing_extensions import Never
-
-class S: ...
-class T: ...
-
-def x(x1: Intersection[S, T], x2: Intersection[S, Not[T]]) -> None:
-    reveal_type(x1)  # revealed: S & T
-    reveal_type(x2)  # revealed: S & ~T
-
-def y(y1: Intersection[int, object], y2: Intersection[int, bool], y3: Intersection[int, Never]) -> None:
-    reveal_type(y1)  # revealed: int
-    reveal_type(y2)  # revealed: bool
-    reveal_type(y3)  # revealed: Never
-
-def z(z1: Intersection[int, Not[Literal[1]], Not[Literal[2]]]) -> None:
-    reveal_type(z1)  # revealed: int & ~Literal[1] & ~Literal[2]
-
-class A: ...
-class B: ...
-class C: ...
-
-type ABC = Intersection[A, B, C]
-
-static_assert(is_subtype_of(ABC, A))
-static_assert(is_subtype_of(ABC, B))
-static_assert(is_subtype_of(ABC, C))
-
-class D: ...
-
-static_assert(not is_subtype_of(ABC, D))
-```
-
-### Unknown type
-
-The `Unknown` type is a special type that we use to represent actually unknown types (no
-annotation), as opposed to `Any` which represents an explicitly unknown type.
-
-```py
-from knot_extensions import Unknown, static_assert, is_assignable_to, is_fully_static
-
-static_assert(is_assignable_to(Unknown, int))
-static_assert(is_assignable_to(int, Unknown))
-
-static_assert(not is_fully_static(Unknown))
-
-def explicit_unknown(x: Unknown, y: tuple[str, Unknown], z: Unknown = 1) -> None:
-    reveal_type(x)  # revealed: Unknown
-    reveal_type(y)  # revealed: tuple[str, Unknown]
-    reveal_type(z)  # revealed: Unknown | Literal[1]
-
-# Unknown can be subclassed, just like Any
-class C(Unknown): ...
-
-# revealed: tuple[Literal[C], Unknown, Literal[object]]
-reveal_type(C.__mro__)
-
-# error: "Special form `knot_extensions.Unknown` expected no type parameter"
-u: Unknown[str]
-```
-
-### `AlwaysTruthy` and `AlwaysFalsy`
-
-`AlwaysTruthy` and `AlwaysFalsy` represent the sets of all possible objects whose truthiness is
-always truthy or falsy, respectively.
-
-They do not accept any type arguments.
-
-```py
-from typing_extensions import Literal
-
-from knot_extensions import AlwaysFalsy, AlwaysTruthy, is_subtype_of, static_assert
-
-static_assert(is_subtype_of(Literal[True], AlwaysTruthy))
-static_assert(is_subtype_of(Literal[False], AlwaysFalsy))
-
-static_assert(not is_subtype_of(int, AlwaysFalsy))
-static_assert(not is_subtype_of(str, AlwaysFalsy))
-
-def _(t: AlwaysTruthy, f: AlwaysFalsy):
-    reveal_type(t)  # revealed: AlwaysTruthy
-    reveal_type(f)  # revealed: AlwaysFalsy
-
-def f(
-    a: AlwaysTruthy[int],  # error: [invalid-type-form]
-    b: AlwaysFalsy[str],  # error: [invalid-type-form]
-):
-    reveal_type(a)  # revealed: Unknown
-    reveal_type(b)  # revealed: Unknown
-```
-
-## Static assertions
-
-### Basics
-
-The `knot_extensions` module provides a `static_assert` function that can be used to enforce
-properties at type-check time. The function takes an arbitrary expression and raises a type error if
-the expression is not of statically known truthiness.
-
-```py
-from knot_extensions import static_assert
-from typing import TYPE_CHECKING
-import sys
-
-static_assert(True)
-static_assert(False)  # error: "Static assertion error: argument evaluates to `False`"
-
-static_assert(False or True)
-static_assert(True and True)
-static_assert(False or False)  # error: "Static assertion error: argument evaluates to `False`"
-static_assert(False and True)  # error: "Static assertion error: argument evaluates to `False`"
-
-static_assert(1 + 1 == 2)
-static_assert(1 + 1 == 3)  # error: "Static assertion error: argument evaluates to `False`"
-
-static_assert("a" in "abc")
-static_assert("d" in "abc")  # error: "Static assertion error: argument evaluates to `False`"
-
-n = None
-static_assert(n is None)
-
-static_assert(TYPE_CHECKING)
-
-static_assert(sys.version_info >= (3, 6))
-```
-
-### Narrowing constraints
-
-Static assertions can be used to enforce narrowing constraints:
-
-```py
-from knot_extensions import static_assert
-
-def f(x: int) -> None:
-    if x != 0:
-        static_assert(x != 0)
-    else:
-        # `int` can be subclassed, so we cannot assert that `x == 0` here:
-        # error: "Static assertion error: argument of type `bool` has an ambiguous static truthiness"
-        static_assert(x == 0)
-```
-
-### Truthy expressions
-
-See also: <https://docs.python.org/3/library/stdtypes.html#truth-value-testing>
-
-```py
-from knot_extensions import static_assert
-
-static_assert(True)
-static_assert(False)  # error: "Static assertion error: argument evaluates to `False`"
-
-static_assert(None)  # error: "Static assertion error: argument of type `None` is statically known to be falsy"
-
-static_assert(1)
-static_assert(0)  # error: "Static assertion error: argument of type `Literal[0]` is statically known to be falsy"
-
-static_assert((0,))
-static_assert(())  # error: "Static assertion error: argument of type `tuple[()]` is statically known to be falsy"
-
-static_assert("a")
-static_assert("")  # error: "Static assertion error: argument of type `Literal[""]` is statically known to be falsy"
-
-static_assert(b"a")
-static_assert(b"")  # error: "Static assertion error: argument of type `Literal[b""]` is statically known to be falsy"
-```
-
-### Error messages
-
-We provide various tailored error messages for wrong argument types to `static_assert`:
-
-```py
-from knot_extensions import static_assert
-
-static_assert(2 * 3 == 6)
-
-# error: "Static assertion error: argument evaluates to `False`"
-static_assert(2 * 3 == 7)
-
-# error: "Static assertion error: argument of type `bool` has an ambiguous static truthiness"
-static_assert(int(2.0 * 3.0) == 6)
-
-class InvalidBoolDunder:
-    def __bool__(self) -> int:
-        return 1
-
-# error: "Static assertion error: argument of type `InvalidBoolDunder` has an ambiguous static truthiness"
-static_assert(InvalidBoolDunder())
-```
-
-### Custom error messages
-
-Alternatively, users can provide custom error messages:
-
-```py
-from knot_extensions import static_assert
-
-# error: "Static assertion error: I really want this to be true"
-static_assert(1 + 1 == 3, "I really want this to be true")
-
-error_message = "A custom message "
-error_message += "constructed from multiple string literals"
-# error: "Static assertion error: A custom message constructed from multiple string literals"
-static_assert(False, error_message)
-
-# There are limitations to what we can still infer as a string literal. In those cases,
-# we simply fall back to the default message.
-shouted_message = "A custom message".upper()
-# error: "Static assertion error: argument evaluates to `False`"
-static_assert(False, shouted_message)
-```
-
-## Type predicates
-
-The `knot_extensions` module also provides predicates to test various properties of types. These are
-implemented as functions that return `Literal[True]` or `Literal[False]` depending on the result of
-the test.
-
-### Equivalence
-
-```py
-from knot_extensions import is_equivalent_to, static_assert
-from typing_extensions import Never, Union
-
-static_assert(is_equivalent_to(type, type[object]))
-static_assert(is_equivalent_to(tuple[int, Never], Never))
-static_assert(is_equivalent_to(int | str, Union[int, str]))
-
-static_assert(not is_equivalent_to(int, str))
-static_assert(not is_equivalent_to(int | str, int | str | bytes))
-```
-
-### Subtyping
-
-```py
-from knot_extensions import is_subtype_of, static_assert
-
-static_assert(is_subtype_of(bool, int))
-static_assert(not is_subtype_of(str, int))
-
-static_assert(is_subtype_of(bool, int | str))
-static_assert(is_subtype_of(str, int | str))
-static_assert(not is_subtype_of(bytes, int | str))
-
-class Base: ...
-class Derived(Base): ...
-class Unrelated: ...
-
-static_assert(is_subtype_of(Derived, Base))
-static_assert(not is_subtype_of(Base, Derived))
-static_assert(is_subtype_of(Base, Base))
-
-static_assert(not is_subtype_of(Unrelated, Base))
-static_assert(not is_subtype_of(Base, Unrelated))
-```
-
-### Assignability
-
-```py
-from knot_extensions import is_assignable_to, static_assert
-from typing import Any
-
-static_assert(is_assignable_to(int, Any))
-static_assert(is_assignable_to(Any, str))
-static_assert(not is_assignable_to(int, str))
-```
-
-### Disjointness
-
-```py
-from knot_extensions import is_disjoint_from, static_assert
-
-static_assert(is_disjoint_from(None, int))
-static_assert(not is_disjoint_from(Literal[2] | str, int))
-```
-
-### Fully static types
-
-```py
-from knot_extensions import is_fully_static, static_assert
-from typing import Any
-
-static_assert(is_fully_static(int | str))
-static_assert(is_fully_static(type[int]))
-
-static_assert(not is_fully_static(int | Any))
-static_assert(not is_fully_static(type[Any]))
-```
-
-### Singleton types
-
-```py
-from knot_extensions import is_singleton, static_assert
-
-static_assert(is_singleton(None))
-static_assert(is_singleton(Literal[True]))
-
-static_assert(not is_singleton(int))
-static_assert(not is_singleton(Literal["a"]))
-```
-
-### Single-valued types
-
-```py
-from knot_extensions import is_single_valued, static_assert
-
-static_assert(is_single_valued(None))
-static_assert(is_single_valued(Literal[True]))
-static_assert(is_single_valued(Literal["a"]))
-
-static_assert(not is_single_valued(int))
-static_assert(not is_single_valued(Literal["a"] | Literal["b"]))
-```
-
-## `TypeOf`
-
-We use `TypeOf` to get the inferred type of an expression. This is useful when we want to refer to
-it in a type expression. For example, if we want to make sure that the class literal type `str` is a
-subtype of `type[str]`, we can not use `is_subtype_of(str, type[str])`, as that would test if the
-type `str` itself is a subtype of `type[str]`. Instead, we can use `TypeOf[str]` to get the type of
-the expression `str`:
-
-```py
-from knot_extensions import TypeOf, is_subtype_of, static_assert
-
-# This is incorrect and therefore fails with ...
-# error: "Static assertion error: argument evaluates to `False`"
-static_assert(is_subtype_of(str, type[str]))
-
-# Correct, returns True:
-static_assert(is_subtype_of(TypeOf[str], type[str]))
-
-class Base: ...
-class Derived(Base): ...
-
-# `TypeOf` can be used in annotations:
-def type_of_annotation() -> None:
-    t1: TypeOf[Base] = Base
-    t2: TypeOf[Base] = Derived  # error: [invalid-assignment]
-
-    # Note how this is different from `type[…]` which includes subclasses:
-    s1: type[Base] = Base
-    s2: type[Base] = Derived  # no error here
-
-# error: "Special form `knot_extensions.TypeOf` expected exactly one type parameter"
-t: TypeOf[int, str, bytes]
-```

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

@@ -0,0 +1,53 @@
+# type[Any]
+
+## Simple
+
+```py
+def f(x: type[Any]):
+    reveal_type(x)  # revealed: type[Any]
+    # TODO: could be `<object.__repr__ type> & Any`
+    reveal_type(x.__repr__)  # revealed: Any
+
+class A: ...
+
+x: type[Any] = object
+x: type[Any] = type
+x: type[Any] = A
+x: type[Any] = A()  # error: [invalid-assignment]
+```
+
+## Bare type
+
+The interpretation of bare `type` is not clear: existing wording in the spec does not match the
+behavior of mypy or pyright. For now we interpret it as simply "an instance of `builtins.type`",
+which is equivalent to `type[object]`. This is similar to the current behavior of mypy, and pyright
+in strict mode.
+
+```py
+def f(x: type):
+    reveal_type(x)  # revealed: type
+    reveal_type(x.__repr__)  # revealed: @Todo(instance attributes)
+
+class A: ...
+
+x: type = object
+x: type = type
+x: type = A
+x: type = A()  # error: [invalid-assignment]
+```
+
+## type[object] != type[Any]
+
+```py
+def f(x: type[object]):
+    reveal_type(x)  # revealed: type[object]
+    # TODO: bound method types
+    reveal_type(x.__repr__)  # revealed: Literal[__repr__]
+
+class A: ...
+
+x: type[object] = object
+x: type[object] = type
+x: type[object] = A
+x: type[object] = A()  # error: [invalid-assignment]
+```