macos 14 runner, no deployment target

.github/CODEOWNERS

@@ -17,5 +17,5 @@
 /scripts/fuzz-parser/ @AlexWaygood
 
 # red-knot
-/crates/red_knot* @carljm @MichaReiser @AlexWaygood @sharkdp
-/crates/ruff_db/ @carljm @MichaReiser @AlexWaygood @sharkdp
+/crates/red_knot* @carljm @MichaReiser @AlexWaygood
+/crates/ruff_db/ @carljm @MichaReiser @AlexWaygood

.github/workflows/build-binaries.yml

@@ -63,7 +63,7 @@ jobs:
 
   macos-x86_64:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: macos-14
+    runs-on: macos-12
     steps:
       - uses: actions/checkout@v4
         with:

.github/workflows/build-docker.yml

@@ -17,21 +17,12 @@ on:
     paths:
       - .github/workflows/build-docker.yml
 
-env:
-  RUFF_BASE_IMG: ghcr.io/${{ github.repository_owner }}/ruff
-
 jobs:
-  docker-build:
-    name: Build Docker image (ghcr.io/astral-sh/ruff) for ${{ matrix.platform }}
+  docker-publish:
+    name: Build Docker image (ghcr.io/astral-sh/ruff)
     runs-on: ubuntu-latest
     environment:
       name: release
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - linux/amd64
-          - linux/arm64
     steps:
       - uses: actions/checkout@v4
         with:
@@ -45,6 +36,12 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ghcr.io/astral-sh/ruff
+
       - name: Check tag consistency
         if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
         run: |
@@ -58,233 +55,14 @@ jobs:
             echo "Releasing ${version}"
           fi
 
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          # Defining this makes sure the org.opencontainers.image.version OCI label becomes the actual release version and not the branch name
-          tags: |
-            type=raw,value=dry-run,enable=${{ inputs.plan == '' || fromJson(inputs.plan).announcement_tag_is_implicit }}
-            type=pep440,pattern={{ version }},value=${{ inputs.plan != '' && fromJson(inputs.plan).announcement_tag || 'dry-run' }},enable=${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-
-      - name: Normalize Platform Pair (replace / with -)
-        run: |
-          platform=${{ matrix.platform }}
-          echo "PLATFORM_TUPLE=${platform//\//-}" >> $GITHUB_ENV
-
-      # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
-      - name: Build and push by digest
-        id: build
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          platforms: ${{ matrix.platform }}
-          cache-from: type=gha,scope=ruff-${{ env.PLATFORM_TUPLE }}
-          cache-to: type=gha,mode=min,scope=ruff-${{ env.PLATFORM_TUPLE }}
-          labels: ${{ steps.meta.outputs.labels }}
-          outputs: type=image,name=${{ env.RUFF_BASE_IMG }},push-by-digest=true,name-canonical=true,push=${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-
-      - name: Export digests
-        run: |
-          mkdir -p /tmp/digests
-          digest="${{ steps.build.outputs.digest }}"
-          touch "/tmp/digests/${digest#sha256:}"
-
-      - name: Upload digests
-        uses: actions/upload-artifact@v4
-        with:
-          name: digests-${{ env.PLATFORM_TUPLE }}
-          path: /tmp/digests/*
-          if-no-files-found: error
-          retention-days: 1
-
-  docker-publish:
-    name: Publish Docker image (ghcr.io/astral-sh/ruff)
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    needs:
-      - docker-build
-    if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-    steps:
-      - name: Download digests
-        uses: actions/download-artifact@v4
-        with:
-          path: /tmp/digests
-          pattern: digests-*
-          merge-multiple: true
-
-      - uses: docker/setup-buildx-action@v3
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          # Order is on purpose such that the label org.opencontainers.image.version has the first pattern with the full version
-          tags: |
-            type=pep440,pattern={{ version }},value=${{ fromJson(inputs.plan).announcement_tag }}
-            type=pep440,pattern={{ major }}.{{ minor }},value=${{ fromJson(inputs.plan).announcement_tag }}
-
-      - uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
-      - name: Create manifest list and push
-        working-directory: /tmp/digests
-        # The jq command expands the docker/metadata json "tags" array entry to `-t tag1 -t tag2 ...` for each tag in the array
-        # 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: |
-          docker buildx imagetools create \
-            $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf '${{ env.RUFF_BASE_IMG }}@sha256:%s ' *)
-
-  docker-publish-extra:
-    name: Publish additional Docker image based on ${{ matrix.image-mapping }}
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    needs:
-      - docker-publish
-    if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-    strategy:
-      fail-fast: false
-      matrix:
-        # Mapping of base image followed by a comma followed by one or more base tags (comma separated)
-        # Note, org.opencontainers.image.version label will use the first base tag (use the most specific tag first)
-        image-mapping:
-          - alpine:3.20,alpine3.20,alpine
-          - debian:bookworm-slim,bookworm-slim,debian-slim
-          - buildpack-deps:bookworm,bookworm,debian
-    steps:
-      - uses: docker/setup-buildx-action@v3
-
-      - uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Generate Dynamic Dockerfile Tags
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          # Extract the image and tags from the matrix variable
-          IFS=',' read -r BASE_IMAGE BASE_TAGS <<< "${{ matrix.image-mapping }}"
-
-          # Generate Dockerfile content
-          cat <<EOF > Dockerfile
-          FROM ${BASE_IMAGE}
-          COPY --from=${{ env.RUFF_BASE_IMG }}:latest /ruff /usr/local/bin/ruff
-          ENTRYPOINT []
-          CMD ["/usr/local/bin/ruff"]
-          EOF
-
-          # Initialize a variable to store all tag docker metadata patterns
-          TAG_PATTERNS=""
-
-          # 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=${{ 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
-
-          # Remove the trailing newline from the pattern list
-          TAG_PATTERNS="${TAG_PATTERNS%\\n}"
-
-          # Export image cache name
-          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
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        # ghcr.io prefers index level annotations
-        env:
-          DOCKER_METADATA_ANNOTATIONS_LEVELS: index
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          flavor: |
-            latest=false
-          tags: |
-            ${{ env.TAG_PATTERNS }}
-
-      - name: Build and push
+      - name: "Build and push Docker image"
         uses: docker/build-push-action@v6
         with:
           context: .
           platforms: linux/amd64,linux/arm64
-          # We do not really need to cache here as the Dockerfile is tiny
-          #cache-from: type=gha,scope=ruff-${{ env.IMAGE_REF }}
-          #cache-to: type=gha,mode=min,scope=ruff-${{ env.IMAGE_REF }}
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
+          # Reuse the builder
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+          push: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
+          tags: ghcr.io/astral-sh/ruff:latest,ghcr.io/astral-sh/ruff:${{ (inputs.plan != '' && fromJson(inputs.plan).announcement_tag) || 'dry-run' }}
           labels: ${{ steps.meta.outputs.labels }}
-          annotations: ${{ steps.meta.outputs.annotations }}
-
-  # This is effectively a duplicate of `docker-publish` to make https://github.com/astral-sh/ruff/pkgs/container/ruff
-  # show the ruff base image first since GitHub always shows the last updated image digests
-  # This works by annotating the original digests (previously non-annotated) which triggers an update to ghcr.io
-  docker-republish:
-    name: Annotate Docker image (ghcr.io/astral-sh/ruff)
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    needs:
-      - docker-publish-extra
-    if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-    steps:
-      - name: Download digests
-        uses: actions/download-artifact@v4
-        with:
-          path: /tmp/digests
-          pattern: digests-*
-          merge-multiple: true
-
-      - uses: docker/setup-buildx-action@v3
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        env:
-          DOCKER_METADATA_ANNOTATIONS_LEVELS: index
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          # Order is on purpose such that the label org.opencontainers.image.version has the first pattern with the full version
-          tags: |
-            type=pep440,pattern={{ version }},value=${{ fromJson(inputs.plan).announcement_tag }}
-            type=pep440,pattern={{ major }}.{{ minor }},value=${{ fromJson(inputs.plan).announcement_tag }}
-
-      - uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
-      - name: Create manifest list and push
-        working-directory: /tmp/digests
-        # The readarray part is used to make sure the quoting and special characters are preserved on expansion (e.g. spaces)
-        # The jq command expands the docker/metadata json "tags" array entry to `-t tag1 -t tag2 ...` for each tag in the array
-        # 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: |
-          readarray -t lines <<< "$DOCKER_METADATA_OUTPUT_ANNOTATIONS"; annotations=(); for line in "${lines[@]}"; do annotations+=(--annotation "$line"); done
-          docker buildx imagetools create \
-            "${annotations[@]}" \
-            $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf '${{ env.RUFF_BASE_IMG }}@sha256:%s ' *)

.github/workflows/ci.yaml

@@ -16,7 +16,7 @@ env:
   CARGO_TERM_COLOR: always
   RUSTUP_MAX_RETRIES: 10
   PACKAGE_NAME: ruff
-  PYTHON_VERSION: "3.12"
+  PYTHON_VERSION: "3.11"
 
 jobs:
   determine_changes:
@@ -193,7 +193,7 @@ jobs:
         run: rustup target add wasm32-unknown-unknown
       - uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 18
           cache: "npm"
           cache-dependency-path: playground/package-lock.json
       - uses: jetli/wasm-pack-action@v0.4.0

.github/workflows/macos-12.yml

@@ -0,0 +1,76 @@
+name: "Test macOS 12 (x86_64)"
+
+on:
+  pull_request
+
+env:
+  PACKAGE_NAME: ruff
+  MODULE_NAME: ruff
+  PYTHON_VERSION: "3.11"
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  CARGO_TERM_COLOR: always
+  RUSTUP_MAX_RETRIES: 10
+
+jobs:
+  macos-x86_64:
+    runs-on: macos-14
+#    env:
+#      MACOSX_DEPLOYMENT_TARGET: 13.7
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: "Prep README.md"
+        run: python scripts/transform_readme.py --target pypi
+      - name: "Build wheels - x86_64"
+        uses: PyO3/maturin-action@v1
+        with:
+          target: x86_64
+          args: --release --locked --out dist
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-macos-x86_64
+          path: dist
+      - name: "Archive binary"
+        run: |
+          TARGET=x86_64-apple-darwin
+          ARCHIVE_NAME=ruff-$TARGET
+          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
+
+          mkdir -p $ARCHIVE_NAME
+          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
+          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
+          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
+      - name: "Upload binary"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-macos-x86_64
+          path: |
+            *.tar.gz
+            *.sha256
+
+  test:
+    needs: macos-x86_64
+    runs-on: macos-12
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: "Download binaries"
+        uses: actions/download-artifact@v4
+        with:
+          name: artifacts-macos-x86_64
+      - name: "Extract"
+        run: tar xzvf ruff-x86_64-apple-darwin.tar.gz
+      - name: "Run Ruff"
+        run: ./ruff-x86_64-apple-darwin/ruff --help

.github/workflows/publish-playground.yml

@@ -29,7 +29,7 @@ jobs:
         run: rustup target add wasm32-unknown-unknown
       - uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 18
           cache: "npm"
           cache-dependency-path: playground/package-lock.json
       - uses: jetli/wasm-pack-action@v0.4.0
@@ -47,7 +47,7 @@ jobs:
         working-directory: playground
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.11.0
+        uses: cloudflare/wrangler-action@v3.7.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/publish-pypi.yml

@@ -21,12 +21,14 @@ jobs:
       # For PyPI's trusted publishing.
       id-token: write
     steps:
-      - name: "Install uv"
-        uses: astral-sh/setup-uv@v3
       - uses: actions/download-artifact@v4
         with:
           pattern: wheels-*
           path: wheels
           merge-multiple: true
       - name: Publish to PyPi
-        run: uv publish -v wheels/*
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true
+          packages-dir: wheels
+          verbose: true

.github/workflows/publish-wasm.yml

@@ -43,7 +43,7 @@ jobs:
       - run: cp LICENSE crates/ruff_wasm/pkg # wasm-pack does not put the LICENSE file in the pkg
       - uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 18
           registry-url: "https://registry.npmjs.org"
       - name: "Publish (dry-run)"
         if: ${{ inputs.plan == '' || fromJson(inputs.plan).announcement_tag_is_implicit }}

.pre-commit-config.yaml

@@ -1,4 +1,4 @@
-fail_fast: false
+fail_fast: true
 
 exclude: |
   (?x)^(
@@ -17,12 +17,12 @@ exclude: |
 
 repos:
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.22
+    rev: v0.20.2
     hooks:
       - id: validate-pyproject
 
   - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.18
+    rev: 0.7.17
     hooks:
       - id: mdformat
         additional_dependencies:
@@ -45,21 +45,8 @@ repos:
             | docs/\w+\.md
           )$
 
-  - repo: https://github.com/adamchainz/blacken-docs
-    rev: 1.19.1
-    hooks:
-      - id: blacken-docs
-        args: ["--pyi", "--line-length", "130"]
-        files: '^crates/.*/resources/mdtest/.*\.md'
-        exclude: |
-          (?x)^(
-            .*?invalid(_.+)_syntax.md
-          )$
-        additional_dependencies:
-          - black==24.10.0
-
   - repo: https://github.com/crate-ci/typos
-    rev: v1.27.0
+    rev: v1.25.0
     hooks:
       - id: typos
 
@@ -73,7 +60,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.2
+    rev: v0.6.9
     hooks:
       - id: ruff-format
       - id: ruff

BREAKING_CHANGES.md

@@ -1,18 +1,5 @@
 # Breaking Changes
 
-## 0.7.0
-
-- The pytest rules `PT001` and `PT023` now default to omitting the decorator parentheses when there are no arguments
-    ([#12838](https://github.com/astral-sh/ruff/pull/12838), [#13292](https://github.com/astral-sh/ruff/pull/13292)).
-    This was a change that we attempted to make in Ruff v0.6.0, but only partially made due to an error on our part.
-    See the [blog post](https://astral.sh/blog/ruff-v0.7.0) for more details.
-- The `useless-try-except` rule (in our `tryceratops` category) has been recoded from `TRY302` to
-    `TRY203` ([#13502](https://github.com/astral-sh/ruff/pull/13502)). This ensures Ruff's code is consistent with
-    the same rule in the [`tryceratops`](https://github.com/guilatrova/tryceratops) linter.
-- The `lint.allow-unused-imports` setting has been removed ([#13677](https://github.com/astral-sh/ruff/pull/13677)). Use
-    [`lint.pyflakes.allow-unused-imports`](https://docs.astral.sh/ruff/settings/#lint_pyflakes_allowed-unused-imports)
-    instead.
-
 ## 0.6.0
 
 - Detect imports in `src` layouts by default for `isort` rules ([#12848](https://github.com/astral-sh/ruff/pull/12848))

CHANGELOG.md

@@ -1,140 +1,5 @@
 # Changelog
 
-## 0.7.3
-
-### Preview features
-
-- Formatter: Disallow single-line implicit concatenated strings ([#13928](https://github.com/astral-sh/ruff/pull/13928))
-- \[`flake8-pyi`\] Include all Python file types for `PYI006` and `PYI066` ([#14059](https://github.com/astral-sh/ruff/pull/14059))
-- \[`flake8-simplify`\] Implement `split-of-static-string` (`SIM905`) ([#14008](https://github.com/astral-sh/ruff/pull/14008))
-- \[`refurb`\] Implement `subclass-builtin` (`FURB189`) ([#14105](https://github.com/astral-sh/ruff/pull/14105))
-- \[`ruff`\] Improve diagnostic messages and docs (`RUF031`, `RUF032`, `RUF034`) ([#14068](https://github.com/astral-sh/ruff/pull/14068))
-
-### Rule changes
-
-- Detect items that hash to same value in duplicate sets (`B033`, `PLC0208`) ([#14064](https://github.com/astral-sh/ruff/pull/14064))
-- \[`eradicate`\] Better detection of IntelliJ language injection comments (`ERA001`) ([#14094](https://github.com/astral-sh/ruff/pull/14094))
-- \[`flake8-pyi`\] Add autofix for `docstring-in-stub` (`PYI021`) ([#14150](https://github.com/astral-sh/ruff/pull/14150))
-- \[`flake8-pyi`\] Update `duplicate-literal-member` (`PYI062`) to alawys provide an autofix ([#14188](https://github.com/astral-sh/ruff/pull/14188))
-- \[`pyflakes`\] Detect items that hash to same value in duplicate dictionaries (`F601`) ([#14065](https://github.com/astral-sh/ruff/pull/14065))
-- \[`ruff`\] Fix false positive for decorators (`RUF028`) ([#14061](https://github.com/astral-sh/ruff/pull/14061))
-
-### Bug fixes
-
-- Avoid parsing joint rule codes as distinct codes in `# noqa` ([#12809](https://github.com/astral-sh/ruff/pull/12809))
-- \[`eradicate`\] ignore `# language=` in commented-out-code rule (ERA001) ([#14069](https://github.com/astral-sh/ruff/pull/14069))
-- \[`flake8-bugbear`\] - do not run `mutable-argument-default` on stubs (`B006`) ([#14058](https://github.com/astral-sh/ruff/pull/14058))
-- \[`flake8-builtins`\] Skip lambda expressions in `builtin-argument-shadowing (A002)` ([#14144](https://github.com/astral-sh/ruff/pull/14144))
-- \[`flake8-comprehension`\] Also remove trailing comma while fixing `C409` and `C419` ([#14097](https://github.com/astral-sh/ruff/pull/14097))
-- \[`flake8-simplify`\] Allow `open` without context manager in `return` statement (`SIM115`) ([#14066](https://github.com/astral-sh/ruff/pull/14066))
-- \[`pylint`\] Respect hash-equivalent literals in `iteration-over-set` (`PLC0208`) ([#14063](https://github.com/astral-sh/ruff/pull/14063))
-- \[`pylint`\] Update known dunder methods for Python 3.13 (`PLW3201`) ([#14146](https://github.com/astral-sh/ruff/pull/14146))
-- \[`pyupgrade`\] - ignore kwarg unpacking for `UP044` ([#14053](https://github.com/astral-sh/ruff/pull/14053))
-- \[`refurb`\] Parse more exotic decimal strings in `verbose-decimal-constructor` (`FURB157`) ([#14098](https://github.com/astral-sh/ruff/pull/14098))
-
-### Documentation
-
-- Add links to missing related options within rule documentations ([#13971](https://github.com/astral-sh/ruff/pull/13971))
-- Add rule short code to mkdocs tags to allow searching via rule codes ([#14040](https://github.com/astral-sh/ruff/pull/14040))
-
-## 0.7.2
-
-### Preview features
-
-- Fix formatting of single with-item with trailing comment ([#14005](https://github.com/astral-sh/ruff/pull/14005))
-- \[`pyupgrade`\] Add PEP 646 `Unpack` conversion to `*` with fix (`UP044`) ([#13988](https://github.com/astral-sh/ruff/pull/13988))
-
-### Rule changes
-
-- Regenerate `known_stdlibs.rs` with stdlibs 2024.10.25 ([#13963](https://github.com/astral-sh/ruff/pull/13963))
-- \[`flake8-no-pep420`\] Skip namespace package enforcement for PEP 723 scripts (`INP001`) ([#13974](https://github.com/astral-sh/ruff/pull/13974))
-
-### Server
-
-- Fix server panic when undoing an edit ([#14010](https://github.com/astral-sh/ruff/pull/14010))
-
-### Bug fixes
-
-- Fix issues in discovering ruff in pip build environments ([#13881](https://github.com/astral-sh/ruff/pull/13881))
-- \[`flake8-type-checking`\] Fix false positive for `singledispatchmethod` (`TCH003`) ([#13941](https://github.com/astral-sh/ruff/pull/13941))
-- \[`flake8-type-checking`\] Treat return type of `singledispatch` as runtime-required (`TCH003`) ([#13957](https://github.com/astral-sh/ruff/pull/13957))
-
-### Documentation
-
-- \[`flake8-simplify`\] Include caveats of enabling `if-else-block-instead-of-if-exp` (`SIM108`) ([#14019](https://github.com/astral-sh/ruff/pull/14019))
-
-## 0.7.1
-
-### Preview features
-
-- Fix `E221` and `E222` to flag missing or extra whitespace around `==` operator ([#13890](https://github.com/astral-sh/ruff/pull/13890))
-- Formatter: Alternate quotes for strings inside f-strings in preview  ([#13860](https://github.com/astral-sh/ruff/pull/13860))
-- Formatter: Join implicit concatenated strings when they fit on a line ([#13663](https://github.com/astral-sh/ruff/pull/13663))
-- \[`pylint`\] Restrict `iteration-over-set` to only work on sets of literals (`PLC0208`) ([#13731](https://github.com/astral-sh/ruff/pull/13731))
-
-### Rule changes
-
-- \[`flake8-type-checking`\] Support auto-quoting when annotations contain quotes ([#11811](https://github.com/astral-sh/ruff/pull/11811))
-
-### Server
-
-- Avoid indexing the workspace for single-file mode ([#13770](https://github.com/astral-sh/ruff/pull/13770))
-
-### Bug fixes
-
-- Make `ARG002` compatible with `EM101` when raising `NotImplementedError` ([#13714](https://github.com/astral-sh/ruff/pull/13714))
-
-### Other changes
-
-- Introduce more Docker tags for Ruff (similar to uv) ([#13274](https://github.com/astral-sh/ruff/pull/13274))
-
-## 0.7.0
-
-Check out the [blog post](https://astral.sh/blog/ruff-v0.7.0) for a migration guide and overview of the changes!
-
-### Breaking changes
-
-- The pytest rules `PT001` and `PT023` now default to omitting the decorator parentheses when there are no arguments
-    ([#12838](https://github.com/astral-sh/ruff/pull/12838), [#13292](https://github.com/astral-sh/ruff/pull/13292)).
-    This was a change that we attempted to make in Ruff v0.6.0, but only partially made due to an error on our part.
-    See the [blog post](https://astral.sh/blog/ruff-v0.7.0) for more details.
-- The `useless-try-except` rule (in our `tryceratops` category) has been recoded from `TRY302` to
-    `TRY203` ([#13502](https://github.com/astral-sh/ruff/pull/13502)). This ensures Ruff's code is consistent with
-    the same rule in the [`tryceratops`](https://github.com/guilatrova/tryceratops) linter.
-- The `lint.allow-unused-imports` setting has been removed ([#13677](https://github.com/astral-sh/ruff/pull/13677)). Use
-    [`lint.pyflakes.allow-unused-imports`](https://docs.astral.sh/ruff/settings/#lint_pyflakes_allowed-unused-imports)
-    instead.
-
-### Formatter preview style
-
-- Normalize implicit concatenated f-string quotes per part ([#13539](https://github.com/astral-sh/ruff/pull/13539))
-
-### Preview linter features
-
-- \[`refurb`\] implement `hardcoded-string-charset` (FURB156) ([#13530](https://github.com/astral-sh/ruff/pull/13530))
-- \[`refurb`\] Count codepoints not bytes for `slice-to-remove-prefix-or-suffix (FURB188)` ([#13631](https://github.com/astral-sh/ruff/pull/13631))
-
-### Rule changes
-
-- \[`pylint`\] Mark `PLE1141` fix as unsafe ([#13629](https://github.com/astral-sh/ruff/pull/13629))
-- \[`flake8-async`\] Consider async generators to be "checkpoints" for `cancel-scope-no-checkpoint` (`ASYNC100`) ([#13639](https://github.com/astral-sh/ruff/pull/13639))
-- \[`flake8-bugbear`\] Do not suggest setting parameter `strict=` to `False` in `B905` diagnostic message ([#13656](https://github.com/astral-sh/ruff/pull/13656))
-- \[`flake8-todos`\] Only flag the word "TODO", not words starting with "todo" (`TD006`) ([#13640](https://github.com/astral-sh/ruff/pull/13640))
-- \[`pycodestyle`\] Fix whitespace-related false positives and false negatives inside type-parameter lists (`E231`, `E251`) ([#13704](https://github.com/astral-sh/ruff/pull/13704))
-- \[`flake8-simplify`\] Stabilize preview behavior for `SIM115` so that the rule can detect files
-    being opened from a wider range of standard-library functions ([#12959](https://github.com/astral-sh/ruff/pull/12959)).
-
-### CLI
-
-- Add explanation of fixable in `--statistics` command ([#13774](https://github.com/astral-sh/ruff/pull/13774))
-
-### Bug fixes
-
-- \[`pyflakes`\] Allow `ipytest` cell magic (`F401`) ([#13745](https://github.com/astral-sh/ruff/pull/13745))
-- \[`flake8-use-pathlib`\] Fix `PTH123` false positive when `open` is passed a file descriptor ([#13616](https://github.com/astral-sh/ruff/pull/13616))
-- \[`flake8-bandit`\] Detect patterns from multi line SQL statements (`S608`) ([#13574](https://github.com/astral-sh/ruff/pull/13574))
-- \[`flake8-pyi`\] - Fix dropped expressions in `PYI030` autofix ([#13727](https://github.com/astral-sh/ruff/pull/13727))
-
 ## 0.6.9
 
 ### Preview features

Cargo.lock

@@ -69,7 +69,7 @@ version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ccaf7e9dfbb6ab22c82e473cd1a8a7bd313c19a5b7e40970f3d89ef5a5c9e81e"
 dependencies = [
- "unicode-width 0.1.13",
+ "unicode-width",
  "yansi-term",
 ]
 
@@ -123,9 +123,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.92"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74f37166d7d48a0284b99dd824694c26119c700b53bf0d1540cdb147dbdaaf13"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
 
 [[package]]
 name = "append-only-vec"
@@ -407,7 +407,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -491,7 +491,7 @@ dependencies = [
  "encode_unicode",
  "lazy_static",
  "libc",
- "unicode-width 0.1.13",
+ "unicode-width",
  "windows-sys 0.52.0",
 ]
 
@@ -687,7 +687,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim 0.10.0",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -698,7 +698,7 @@ checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -750,27 +750,6 @@ dependencies = [
  "crypto-common",
 ]
 
-[[package]]
-name = "dir-test"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c44bdf9319ad5223afb7eb15a7110452b0adf0373ea6756561b2c708eef0dd1"
-dependencies = [
- "dir-test-macros",
-]
-
-[[package]]
-name = "dir-test-macros"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "644f96047137dfaa7a09e34d4623f9e52a1926ecc25ba32ad2ba3fc422536b25"
-dependencies = [
- "glob",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "dirs"
 version = "4.0.0"
@@ -900,9 +879,9 @@ checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
 
 [[package]]
 name = "fern"
-version = "0.7.0"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69ff9c9d5fb3e6da8ac2f77ab76fe7e8087d512ce095200f8f29ac5b656cf6dc"
+checksum = "d9f0c14694cbd524c8720dd69b0e3179344f04ebb5f90f2e4a440c6ea3b2f1ee"
 dependencies = [
  "log",
 ]
@@ -978,7 +957,7 @@ version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
 dependencies = [
- "unicode-width 0.1.13",
+ "unicode-width",
 ]
 
 [[package]]
@@ -1162,12 +1141,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.6.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
+checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5"
 dependencies = [
  "equivalent",
- "hashbrown 0.15.0",
+ "hashbrown 0.14.5",
  "serde",
 ]
 
@@ -1181,7 +1160,7 @@ dependencies = [
  "instant",
  "number_prefix",
  "portable-atomic",
- "unicode-width 0.1.13",
+ "unicode-width",
  "vt100",
 ]
 
@@ -1193,9 +1172,9 @@ checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
 
 [[package]]
 name = "inotify"
-version = "0.10.2"
+version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdd168d97690d0b8c412d6b6c10360277f4d7ee495c5d0d5d5fe0854923255cc"
+checksum = "f8069d3ec154eb856955c1c0fbffefbf5f3c40a104ec912d4797314c1801abff"
 dependencies = [
  "bitflags 1.3.2",
  "inotify-sys",
@@ -1213,9 +1192,9 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.41.1"
+version = "1.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e9ffc4d4892617c50a928c52b2961cb5174b6fc6ebf252b2fac9d21955c48b8"
+checksum = "6593a41c7a73841868772495db7dc1e8ecab43bb5c0b6da2059246c4b506ab60"
 dependencies = [
  "console",
  "globset",
@@ -1267,7 +1246,7 @@ dependencies = [
  "Inflector",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -1367,9 +1346,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.161"
+version = "0.2.159"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1"
+checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5"
 
 [[package]]
 name = "libcst"
@@ -1393,7 +1372,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2ae40017ac09cd2c6a53504cb3c871c7f2b41466eac5bc66ba63f39073b467b"
 dependencies = [
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -1532,15 +1511,14 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.0.2"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
 dependencies = [
- "hermit-abi",
  "libc",
  "log",
  "wasi",
- "windows-sys 0.52.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -1594,11 +1572,12 @@ dependencies = [
 
 [[package]]
 name = "notify"
-version = "7.0.0"
+version = "6.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c533b4c39709f9ba5005d8002048266593c1cfaf3c5f0739d5b8ab0c6c504009"
+checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
 dependencies = [
  "bitflags 2.6.0",
+ "crossbeam-channel",
  "filetime",
  "fsevent-sys",
  "inotify",
@@ -1606,18 +1585,8 @@ dependencies = [
  "libc",
  "log",
  "mio",
- "notify-types",
  "walkdir",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "notify-types"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7393c226621f817964ffb3dc5704f9509e107a8b024b489cc2c1b217378785df"
-dependencies = [
- "instant",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -1791,17 +1760,18 @@ dependencies = [
  "once_cell",
  "regex",
  "serde",
- "unicode-width 0.1.13",
+ "unicode-width",
 ]
 
 [[package]]
 name = "pep440_rs"
-version = "0.7.2"
+version = "0.6.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0922a442c78611fa8c5ed6065d2d898a820cf12fa90604217fdb2d01675efec7"
+checksum = "466eada3179c2e069ca897b99006cbb33f816290eaeec62464eea907e22ae385"
 dependencies = [
+ "once_cell",
  "serde",
- "unicode-width 0.2.0",
+ "unicode-width",
  "unscanny",
 ]
 
@@ -1817,7 +1787,7 @@ dependencies = [
  "serde",
  "thiserror",
  "tracing",
- "unicode-width 0.1.13",
+ "unicode-width",
  "url",
 ]
 
@@ -1858,7 +1828,7 @@ dependencies = [
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -1973,9 +1943,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.89"
+version = "1.0.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
+checksum = "b3e4daa0dcf6feba26f985457cdf104d4b4256fc5a09547140f3631bb076b19a"
 dependencies = [
  "unicode-ident",
 ]
@@ -2110,15 +2080,14 @@ dependencies = [
  "camino",
  "compact_str",
  "countme",
- "dir-test",
  "hashbrown 0.15.0",
- "indexmap",
  "insta",
  "itertools 0.13.0",
  "memchr",
  "ordermap",
  "red_knot_test",
  "red_knot_vendored",
+ "rstest",
  "ruff_db",
  "ruff_index",
  "ruff_python_ast",
@@ -2167,7 +2136,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "colored",
- "memchr",
+ "once_cell",
  "red_knot_python_semantic",
  "red_knot_vendored",
  "regex",
@@ -2185,6 +2154,7 @@ dependencies = [
 name = "red_knot_vendored"
 version = "0.0.0"
 dependencies = [
+ "once_cell",
  "path-slash",
  "ruff_db",
  "walkdir",
@@ -2258,9 +2228,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.11.1"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+checksum = "38200e5ee88914975b69f657f0801b6f6dccafd44fd9326302a4aaeecfacb1d8"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -2300,6 +2270,12 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
+[[package]]
+name = "relative-path"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
+
 [[package]]
 name = "ring"
 version = "0.17.8"
@@ -2315,9 +2291,36 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "rstest"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b423f0e62bdd61734b67cd21ff50871dfaeb9cc74f869dcd6af974fbcb19936"
+dependencies = [
+ "rstest_macros",
+ "rustc_version",
+]
+
+[[package]]
+name = "rstest_macros"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e1711e7d14f74b12a58411c542185ef7fb7f2e7f8ee6e2940a883628522b42"
+dependencies = [
+ "cfg-if",
+ "glob",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "relative-path",
+ "rustc_version",
+ "syn",
+ "unicode-ident",
+]
+
 [[package]]
 name = "ruff"
-version = "0.7.3"
+version = "0.6.9"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2379,6 +2382,7 @@ dependencies = [
  "codspeed-criterion-compat",
  "criterion",
  "mimalloc",
+ "once_cell",
  "rayon",
  "red_knot_python_semantic",
  "red_knot_workspace",
@@ -2502,7 +2506,7 @@ dependencies = [
  "serde",
  "static_assertions",
  "tracing",
- "unicode-width 0.1.13",
+ "unicode-width",
 ]
 
 [[package]]
@@ -2511,6 +2515,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "clap",
+ "once_cell",
  "red_knot_python_semantic",
  "ruff_cache",
  "ruff_db",
@@ -2534,7 +2539,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.7.3"
+version = "0.6.9"
 dependencies = [
  "aho-corasick",
  "annotate-snippets 0.9.2",
@@ -2555,9 +2560,10 @@ dependencies = [
  "log",
  "memchr",
  "natord",
+ "once_cell",
  "path-absolutize",
  "pathdiff",
- "pep440_rs 0.7.2",
+ "pep440_rs 0.6.6",
  "pyproject-toml",
  "quick-junit",
  "regex",
@@ -2588,7 +2594,7 @@ dependencies = [
  "toml",
  "typed-arena",
  "unicode-normalization",
- "unicode-width 0.1.13",
+ "unicode-width",
  "unicode_names2",
  "url",
 ]
@@ -2601,7 +2607,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "ruff_python_trivia",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -2610,6 +2616,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "itertools 0.13.0",
+ "once_cell",
  "rand",
  "ruff_diagnostics",
  "ruff_source_file",
@@ -2631,14 +2638,13 @@ dependencies = [
  "compact_str",
  "is-macro",
  "itertools 0.13.0",
- "memchr",
+ "once_cell",
  "ruff_cache",
  "ruff_macros",
  "ruff_python_trivia",
  "ruff_source_file",
  "ruff_text_size",
  "rustc-hash 2.0.0",
- "salsa",
  "schemars",
  "serde",
 ]
@@ -2658,6 +2664,7 @@ dependencies = [
 name = "ruff_python_codegen"
 version = "0.0.0"
 dependencies = [
+ "once_cell",
  "ruff_python_ast",
  "ruff_python_literal",
  "ruff_python_parser",
@@ -2675,6 +2682,7 @@ dependencies = [
  "insta",
  "itertools 0.13.0",
  "memchr",
+ "once_cell",
  "regex",
  "ruff_cache",
  "ruff_formatter",
@@ -2761,6 +2769,7 @@ dependencies = [
  "ruff_python_ast",
  "ruff_python_parser",
  "ruff_python_stdlib",
+ "ruff_source_file",
  "ruff_text_size",
  "rustc-hash 2.0.0",
  "schemars",
@@ -2791,6 +2800,7 @@ dependencies = [
  "insta",
  "ruff_python_parser",
  "ruff_python_trivia",
+ "ruff_source_file",
  "ruff_text_size",
 ]
 
@@ -2823,7 +2833,6 @@ dependencies = [
  "serde",
  "serde_json",
  "shellexpand",
- "thiserror",
  "tracing",
  "tracing-subscriber",
 ]
@@ -2833,6 +2842,7 @@ name = "ruff_source_file"
 version = "0.0.0"
 dependencies = [
  "memchr",
+ "once_cell",
  "ruff_text_size",
  "serde",
 ]
@@ -2849,7 +2859,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.7.3"
+version = "0.6.9"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -2888,7 +2898,7 @@ dependencies = [
  "matchit",
  "path-absolutize",
  "path-slash",
- "pep440_rs 0.7.2",
+ "pep440_rs 0.6.6",
  "regex",
  "ruff_cache",
  "ruff_formatter",
@@ -2930,6 +2940,15 @@ version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152"
 
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
 [[package]]
 name = "rustix"
 version = "0.38.37"
@@ -2990,7 +3009,7 @@ checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
 [[package]]
 name = "salsa"
 version = "0.18.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=254c749b02cde2fd29852a7463a33e800b771758#254c749b02cde2fd29852a7463a33e800b771758"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=b14be5c0392f4c55eca60b92e457a35549372382#b14be5c0392f4c55eca60b92e457a35549372382"
 dependencies = [
  "append-only-vec",
  "arc-swap",
@@ -3010,17 +3029,17 @@ dependencies = [
 [[package]]
 name = "salsa-macro-rules"
 version = "0.1.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=254c749b02cde2fd29852a7463a33e800b771758#254c749b02cde2fd29852a7463a33e800b771758"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=b14be5c0392f4c55eca60b92e457a35549372382#b14be5c0392f4c55eca60b92e457a35549372382"
 
 [[package]]
 name = "salsa-macros"
 version = "0.18.0"
-source = "git+https://github.com/salsa-rs/salsa.git?rev=254c749b02cde2fd29852a7463a33e800b771758#254c749b02cde2fd29852a7463a33e800b771758"
+source = "git+https://github.com/salsa-rs/salsa.git?rev=b14be5c0392f4c55eca60b92e457a35549372382#b14be5c0392f4c55eca60b92e457a35549372382"
 dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
  "synstructure",
 ]
 
@@ -3054,7 +3073,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -3076,10 +3095,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
 
 [[package]]
-name = "serde"
-version = "1.0.214"
+name = "semver"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
+checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
+
+[[package]]
+name = "serde"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
 dependencies = [
  "serde_derive",
 ]
@@ -3097,13 +3122,13 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.214"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -3114,14 +3139,14 @@ checksum = "330f01ce65a3a5fe59a60c82f3c9a024b573b8a6e875bd233fe5f934e71d54e3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.132"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d726bfaff4b320266d395898905d0eba0345aae23b54aee3a737e260fd46db03"
+checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
 dependencies = [
  "itoa",
  "memchr",
@@ -3137,7 +3162,7 @@ checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -3178,7 +3203,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -3280,7 +3305,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -3291,20 +3316,9 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
 
 [[package]]
 name = "syn"
-version = "1.0.109"
+version = "2.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.87"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d"
+checksum = "89132cd0bf050864e1d38dc3bbc07a0eb8e7530af26344d3d2bbbef83499f590"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3319,7 +3333,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -3382,7 +3396,7 @@ dependencies = [
  "cfg-if",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -3393,28 +3407,28 @@ checksum = "5c89e72a01ed4c579669add59014b9a524d609c0c88c6a585ce37485879f6ffb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
  "test-case-core",
 ]
 
 [[package]]
 name = "thiserror"
-version = "1.0.67"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3c6efbfc763e64eb85c11c25320f0737cb7364c4b6336db90aa9ebe27a0bbd"
+checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.67"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b607164372e89797d78b8e23a6d67d5d1038c1c65efd52e1389ef8b77caba2a6"
+checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -3526,7 +3540,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -3690,12 +3704,6 @@ version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
 
-[[package]]
-name = "unicode-width"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
-
 [[package]]
 name = "unicode_names2"
 version = "1.3.0"
@@ -3766,9 +3774,9 @@ checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
 
 [[package]]
 name = "uuid"
-version = "1.11.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8c5f0a0af699448548ad1a2fbf920fb4bee257eae39953ba95cb84891a0446a"
+checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314"
 dependencies = [
  "getrandom",
  "rand",
@@ -3778,13 +3786,13 @@ dependencies = [
 
 [[package]]
 name = "uuid-macro-internal"
-version = "1.11.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b91f57fe13a38d0ce9e28a03463d8d3c2468ed03d75375110ec71d93b449a08"
+checksum = "ee1cd046f83ea2c4e920d6ee9f7c3537ef928d75dce5d84a87c2c5d6b3999a3a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -3807,7 +3815,7 @@ checksum = "84cd863bf0db7e392ba3bd04994be3473491b31e66340672af5d11943c6274de"
 dependencies = [
  "itoa",
  "log",
- "unicode-width 0.1.13",
+ "unicode-width",
  "vte",
 ]
 
@@ -3870,7 +3878,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
  "wasm-bindgen-shared",
 ]
 
@@ -3904,7 +3912,7 @@ checksum = "26c6ab57572f7a24a4985830b120de1594465e5d500f24afe89e16b4e833ef68"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -3938,7 +3946,7 @@ checksum = "c97b2ef2c8d627381e51c071c2ab328eac606d3f69dd82bcbca20a9e389d95f0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]
@@ -4226,7 +4234,7 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn",
 ]
 
 [[package]]

Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-rust-version = "1.80"
+rust-version = "1.76"
 homepage = "https://docs.astral.sh/ruff"
 documentation = "https://docs.astral.sh/ruff"
 repository = "https://github.com/astral-sh/ruff"
@@ -65,11 +65,10 @@ compact_str = "0.8.0"
 criterion = { version = "0.5.1", default-features = false }
 crossbeam = { version = "0.8.4" }
 dashmap = { version = "6.0.1" }
-dir-test = { version = "0.3.0" }
 drop_bomb = { version = "0.1.5" }
 env_logger = { version = "0.11.0" }
 etcetera = { version = "0.8.0" }
-fern = { version = "0.7.0" }
+fern = { version = "0.6.1" }
 filetime = { version = "0.2.23" }
 glob = { version = "0.3.1" }
 globset = { version = "0.4.14" }
@@ -81,7 +80,6 @@ hashbrown = { version = "0.15.0", default-features = false, features = [
 ignore = { version = "0.4.22" }
 imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
-indexmap = {version = "2.6.0" }
 indicatif = { version = "0.17.8" }
 indoc = { version = "2.0.4" }
 insta = { version = "1.35.1" }
@@ -102,12 +100,13 @@ matchit = { version = "0.8.1" }
 memchr = { version = "2.7.1" }
 mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
-notify = { version = "7.0.0" }
+notify = { version = "6.1.1" }
+once_cell = { version = "1.19.0" }
 ordermap = { version = "0.5.0" }
 path-absolutize = { version = "3.1.1" }
 path-slash = { version = "0.2.1" }
 pathdiff = { version = "0.2.1" }
-pep440_rs = { version = "0.7.1" }
+pep440_rs = { version = "0.6.0", features = ["serde"] }
 pretty_assertions = "1.3.0"
 proc-macro2 = { version = "1.0.79" }
 pyproject-toml = { version = "0.9.0" }
@@ -116,8 +115,9 @@ quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
+rstest = { version = "0.22.0", default-features = false }
 rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "254c749b02cde2fd29852a7463a33e800b771758" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "b14be5c0392f4c55eca60b92e457a35549372382" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -189,9 +189,8 @@ missing_panics_doc = "allow"
 module_name_repetitions = "allow"
 must_use_candidate = "allow"
 similar_names = "allow"
-single_match_else = "allow"
 too_many_lines = "allow"
-# Without the hashes we run into a `rustfmt` bug in some snapshot tests, see #13250
+# To allow `#[allow(clippy::all)]` in `crates/ruff_python_parser/src/python.rs`.
 needless_raw_string_hashes = "allow"
 # Disallowed restriction lints
 print_stdout = "warn"
@@ -204,10 +203,6 @@ get_unwrap = "warn"
 rc_buffer = "warn"
 rc_mutex = "warn"
 rest_pat_in_fully_bound_structs = "warn"
-# nursery rules
-redundant_clone = "warn"
-debug_assert_with_mut_call = "warn"
-unused_peekable = "warn"
 
 [profile.release]
 # Note that we set these explicitly, and these values

Dockerfile

@@ -1,4 +1,4 @@
-FROM --platform=$BUILDPLATFORM ubuntu AS build
+FROM --platform=$BUILDPLATFORM ubuntu as build
 ENV HOME="/root"
 WORKDIR $HOME
 

README.md

@@ -136,8 +136,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.7.3/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.7.3/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.6.9/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.6.9/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -170,7 +170,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.7.3
+  rev: v0.6.9
   hooks:
     # Run the linter.
     - id: ruff
@@ -417,7 +417,6 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [Babel](https://github.com/python-babel/babel)
 - Benchling ([Refac](https://github.com/benchling/refac))
 - [Bokeh](https://github.com/bokeh/bokeh)
-- CrowdCent ([NumerBlox](https://github.com/crowdcent/numerblox)) <!-- typos: ignore -->
 - [Cryptography (PyCA)](https://github.com/pyca/cryptography)
 - CERN ([Indico](https://getindico.io/))
 - [DVC](https://github.com/iterative/dvc)

_typos.toml

@@ -12,7 +12,6 @@ pn = "pn"  # `import panel as pn` is a thing
 poit = "poit"
 BA = "BA" # acronym for "Bad Allowed", used in testing.
 jod = "jod" # e.g., `jod-thread`
-Numer = "Numer" # Library name 'NumerBlox' in "Who's Using Ruff?"
 
 [default]
 extend-ignore-re = [

crates/red_knot/src/main.rs

@@ -5,6 +5,8 @@ use anyhow::{anyhow, Context};
 use clap::Parser;
 use colored::Colorize;
 use crossbeam::channel as crossbeam_channel;
+use salsa::plumbing::ZalsaDatabase;
+
 use red_knot_python_semantic::SitePackages;
 use red_knot_server::run_server;
 use red_knot_workspace::db::RootDatabase;
@@ -12,9 +14,7 @@ use red_knot_workspace::watch;
 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};
@@ -144,7 +144,7 @@ pub fn main() -> ExitStatus {
 }
 
 fn run() -> anyhow::Result<ExitStatus> {
-    let args = Args::parse_from(std::env::args());
+    let args = Args::parse_from(std::env::args().collect::<Vec<_>>());
 
     if matches!(args.command, Some(Command::Server)) {
         return run_server().map(|()| ExitStatus::Success);
@@ -318,9 +318,8 @@ impl MainLoop {
                 } => {
                     let has_diagnostics = !result.is_empty();
                     if check_revision == revision {
-                        #[allow(clippy::print_stdout)]
                         for diagnostic in result {
-                            println!("{}", diagnostic.display(db));
+                            tracing::error!("{}", diagnostic);
                         }
                     } else {
                         tracing::debug!(
@@ -379,10 +378,7 @@ impl MainLoopCancellationToken {
 #[derive(Debug)]
 enum MainLoopMessage {
     CheckWorkspace,
-    CheckCompleted {
-        result: Vec<Box<dyn Diagnostic>>,
-        revision: u64,
-    },
+    CheckCompleted { result: Vec<String>, revision: u64 },
     ApplyChanges(Vec<watch::ChangeEvent>),
     Exit,
 }

crates/red_knot_python_semantic/Cargo.toml

@@ -13,7 +13,7 @@ license = { workspace = true }
 [dependencies]
 ruff_db = { workspace = true }
 ruff_index = { workspace = true }
-ruff_python_ast = { workspace = true, features = ["salsa"] }
+ruff_python_ast = { workspace = true }
 ruff_python_stdlib = { workspace = true }
 ruff_source_file = { workspace = true }
 ruff_text_size = { workspace = true }
@@ -24,8 +24,7 @@ bitflags = { workspace = true }
 camino = { workspace = true }
 compact_str = { workspace = true }
 countme = { workspace = true }
-indexmap = { workspace = true }
-itertools = { workspace = true }
+itertools = { workspace = true}
 ordermap = { workspace = true }
 salsa = { workspace = true }
 thiserror = { workspace = true }
@@ -44,9 +43,10 @@ red_knot_test = { workspace = true }
 red_knot_vendored = { workspace = true }
 
 anyhow = { workspace = true }
-dir-test = { workspace = true }
 insta = { workspace = true }
+rstest = { workspace = true }
 tempfile = { workspace = true }
 
 [lints]
 workspace = true
+

crates/red_knot_python_semantic/build.rs

@@ -1,4 +1,4 @@
 /// Rebuild the crate if a test file is added or removed from
 pub fn main() {
-    println!("cargo::rerun-if-changed=resources/mdtest");
+    println!("cargo:rerun-if-changed=resources/mdtest");
 }

crates/red_knot_python_semantic/resources/mdtest/.mdformat.toml

@@ -1 +0,0 @@
-wrap = 100

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

@@ -1,18 +0,0 @@
-# Starred expression annotations
-
-Type annotations for `*args` can be starred expressions themselves:
-
-```py
-from typing_extensions import TypeVarTuple
-
-Ts = TypeVarTuple("Ts")
-
-def append_int(*args: *Ts) -> tuple[*Ts, int]:
-    # TODO: should show some representation of the variadic generic type
-    reveal_type(args)  # revealed: @Todo
-
-    return (*args, 1)
-
-# TODO should be tuple[Literal[True], Literal["a"], int]
-reveal_type(append_int(True, "a"))  # revealed: @Todo
-```

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

@@ -1,9 +0,0 @@
-# String annotations
-
-```py
-def f() -> "int":
-    return 1
-
-# TODO: We do not support string annotations, but we should not panic if we encounter them
-reveal_type(f())  # revealed: @Todo
-```

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

@@ -13,100 +13,13 @@ reveal_type(y)  # revealed: Literal[1]
 ## Violates own annotation
 
 ```py
-x: int = "foo"  # error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `int`"
+x: int = 'foo' # error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `int`"
+
 ```
 
 ## Violates previous annotation
 
 ```py
 x: int
-x = "foo"  # error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `int`"
-```
-
-## Tuple annotations are understood
-
-```py path=module.py
-from typing_extensions import Unpack
-
-a: tuple[()] = ()
-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]] = ([], [])
-i: tuple[str | int, str | int] = (42, 42)
-j: tuple[str | int] = (42,)
-```
-
-```py path=script.py
-from module import a, b, c, d, e, f, g, h, i, j
-
-reveal_type(a)  # revealed: tuple[()]
-reveal_type(b)  # revealed: tuple[int]
-reveal_type(c)  # revealed: tuple[str, int]
-reveal_type(d)  # revealed: tuple[tuple[str, str], tuple[int, int]]
-
-# TODO: homogenous tuples, PEP-646 tuples
-reveal_type(e)  # revealed: @Todo
-reveal_type(f)  # revealed: @Todo
-reveal_type(g)  # revealed: @Todo
-
-# TODO: support more kinds of type expressions in annotations
-reveal_type(h)  # revealed: @Todo
-
-reveal_type(i)  # revealed: tuple[str | int, str | int]
-reveal_type(j)  # revealed: tuple[str | int]
-```
-
-## Incorrect tuple assignments are complained about
-
-```py
-# error: [invalid-assignment] "Object of type `tuple[Literal[1], Literal[2]]` is not assignable to `tuple[()]`"
-a: tuple[()] = (1, 2)
-
-# error: [invalid-assignment] "Object of type `tuple[Literal["foo"]]` is not assignable to `tuple[int]`"
-b: tuple[int] = ("foo",)
-
-# error: [invalid-assignment] "Object of type `tuple[list, Literal["foo"]]` is not assignable to `tuple[str | int, str]`"
-c: tuple[str | int, str] = ([], "foo")
-```
-
-## PEP-604 annotations are supported
-
-```py
-def foo() -> str | int | None:
-    return None
-
-reveal_type(foo())  # revealed: str | int | None
-
-def bar() -> str | str | None:
-    return None
-
-reveal_type(bar())  # revealed: str | None
-
-def baz() -> str | str:
-    return "Hello, world!"
-
-reveal_type(baz())  # revealed: str
-```
-
-## Attribute expressions in type annotations are understood
-
-```py
-import builtins
-
-int = "foo"
-a: builtins.int = 42
-
-# error: [invalid-assignment] "Object of type `Literal["bar"]` is not assignable to `int`"
-b: builtins.int = "bar"
-
-c: builtins.tuple[builtins.tuple[builtins.int, builtins.int], builtins.int] = ((42, 42), 42)
-
-# error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `tuple[tuple[int, int], int]`"
-c: builtins.tuple[builtins.tuple[builtins.int, builtins.int], builtins.int] = "foo"
+x = 'foo'  # error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `int`"
 ```

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

@@ -1,182 +0,0 @@
-# Augmented assignment
-
-## Basic
-
-```py
-x = 3
-x -= 1
-reveal_type(x)  # revealed: Literal[2]
-
-x = 1.0
-x /= 2
-reveal_type(x)  # revealed: float
-```
-
-## Dunder methods
-
-```py
-class C:
-    def __isub__(self, other: int) -> str:
-        return "Hello, world!"
-
-x = C()
-x -= 1
-reveal_type(x)  # revealed: str
-
-class C:
-    def __iadd__(self, other: str) -> float:
-        return 1.0
-
-x = C()
-x += "Hello"
-reveal_type(x)  # revealed: float
-```
-
-## Unsupported types
-
-```py
-class C:
-    def __isub__(self, other: str) -> int:
-        return 42
-
-x = C()
-x -= 1
-
-# TODO: should error, once operand type check is implemented
-reveal_type(x)  # revealed: int
-```
-
-## Method union
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-class Foo:
-    if bool_instance():
-        def __iadd__(self, other: int) -> str:
-            return "Hello, world!"
-    else:
-        def __iadd__(self, other: int) -> int:
-            return 42
-
-f = Foo()
-f += 12
-
-reveal_type(f)  # revealed: str | int
-```
-
-## Partially bound `__iadd__`
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class Foo:
-    if bool_instance():
-        def __iadd__(self, other: str) -> int:
-            return 42
-
-f = Foo()
-
-# TODO: We should emit an `unsupported-operator` error here, possibly with the information
-# that `Foo.__iadd__` may be unbound as additional context.
-f += "Hello, world!"
-
-reveal_type(f)  # revealed: int | Unknown
-```
-
-## Partially bound with `__add__`
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class Foo:
-    def __add__(self, other: str) -> str:
-        return "Hello, world!"
-    if bool_instance():
-        def __iadd__(self, other: str) -> int:
-            return 42
-
-f = Foo()
-f += "Hello, world!"
-
-reveal_type(f)  # revealed: int | str
-```
-
-## Partially bound target union
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class Foo:
-    def __add__(self, other: int) -> str:
-        return "Hello, world!"
-    if bool_instance():
-        def __iadd__(self, other: int) -> int:
-            return 42
-
-if bool_instance():
-    f = Foo()
-else:
-    f = 42.0
-f += 12
-
-reveal_type(f)  # revealed: int | str | float
-```
-
-## Target union
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-class Foo:
-    def __iadd__(self, other: int) -> str:
-        return "Hello, world!"
-
-if flag:
-    f = Foo()
-else:
-    f = 42.0
-f += 12
-
-reveal_type(f)  # revealed: str | float
-```
-
-## Partially bound target union with `__add__`
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-class Foo:
-    def __add__(self, other: int) -> str:
-        return "Hello, world!"
-    if bool_instance():
-        def __iadd__(self, other: int) -> int:
-            return 42
-
-class Bar:
-    def __add__(self, other: int) -> bytes:
-        return b"Hello, world!"
-
-    def __iadd__(self, other: int) -> float:
-        return 42.0
-
-if flag:
-    f = Foo()
-else:
-    f = Bar()
-f += 12
-
-reveal_type(f)  # revealed: int | str | float
-```

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

@@ -3,57 +3,22 @@
 ## Unbound
 
 ```py
-x = foo  # error: [unresolved-reference] "Name `foo` used when not defined"
+x = foo
 foo = 1
-
-# No error `unresolved-reference` diagnostic is reported for `x`. This is
-# desirable because we would get a lot of cascading errors even though there
-# is only one root cause (the unbound variable `foo`).
-
-# revealed: Unknown
-reveal_type(x)
+reveal_type(x)  # revealed: Unbound
 ```
 
-Note: in this particular example, one could argue that the most likely error would be a wrong order
-of the `x`/`foo` definitions, and so it could be desirable to infer `Literal[1]` for the type of
-`x`. On the other hand, there might be a variable `fob` a little higher up in this file, and the
-actual error might have been just a typo. Inferring `Unknown` thus seems like the safest option.
-
 ## Unbound class variable
 
 Name lookups within a class scope fall back to globals, but lookups of class attributes don't.
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 x = 1
-
 class C:
     y = x
     if flag:
         x = 2
 
-reveal_type(C.x)  # revealed: Literal[2]
-reveal_type(C.y)  # revealed: Literal[1]
-```
-
-## Possibly unbound in class and global scope
-
-```py
-def bool_instance() -> bool:
-    return True
-
-if bool_instance():
-    x = "abc"
-
-class C:
-    if bool_instance():
-        x = 1
-
-    # error: [possibly-unresolved-reference]
-    y = x
-
-reveal_type(C.y)  # revealed: Literal[1] | Literal["abc"]
+reveal_type(C.x) # revealed: Literal[2]
+reveal_type(C.y) # revealed: Literal[1]
 ```

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -3,53 +3,13 @@
 ## Union of attributes
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
 if flag:
     class C:
         x = 1
-
 else:
     class C:
         x = 2
 
-reveal_type(C.x)  # revealed: Literal[1, 2]
-```
-
-## Inherited attributes
-
-```py
-class A:
-    X = "foo"
-
-class B(A): ...
-class C(B): ...
-
-reveal_type(C.X)  # revealed: Literal["foo"]
-```
-
-## Inherited attributes (multiple inheritance)
-
-```py
-class O: ...
-
-class F(O):
-    X = 56
-
-class E(O):
-    X = 42
-
-class D(O): ...
-class C(D, F): ...
-class B(E, D): ...
-class A(B, C): ...
-
-# revealed: tuple[Literal[A], Literal[B], Literal[E], Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
-reveal_type(A.__mro__)
-
-# `E` is earlier in the MRO than `F`, so we should use the type of `E.X`
-reveal_type(A.X)  # revealed: Literal[42]
+y = C.x
+reveal_type(y)  # revealed: Literal[1, 2]
 ```

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

@@ -1,48 +0,0 @@
-## Binary operations on booleans
-
-## Basic Arithmetic
-
-We try to be precise and all operations except for division will result in Literal type.
-
-```py
-a = True
-b = False
-
-reveal_type(a + a)  # revealed: Literal[2]
-reveal_type(a + b)  # revealed: Literal[1]
-reveal_type(b + a)  # revealed: Literal[1]
-reveal_type(b + b)  # revealed: Literal[0]
-
-reveal_type(a - a)  # revealed: Literal[0]
-reveal_type(a - b)  # revealed: Literal[1]
-reveal_type(b - a)  # revealed: Literal[-1]
-reveal_type(b - b)  # revealed: Literal[0]
-
-reveal_type(a * a)  # revealed: Literal[1]
-reveal_type(a * b)  # revealed: Literal[0]
-reveal_type(b * a)  # revealed: Literal[0]
-reveal_type(b * b)  # revealed: Literal[0]
-
-reveal_type(a % a)  # revealed: Literal[0]
-reveal_type(b % a)  # revealed: Literal[0]
-
-reveal_type(a // a)  # revealed: Literal[1]
-reveal_type(b // a)  # revealed: Literal[0]
-
-reveal_type(a**a)  # revealed: Literal[1]
-reveal_type(a**b)  # revealed: Literal[1]
-reveal_type(b**a)  # revealed: Literal[0]
-reveal_type(b**b)  # revealed: Literal[1]
-
-# Division
-reveal_type(a / a)  # revealed: float
-reveal_type(b / a)  # revealed: float
-b / b  # error: [division-by-zero] "Cannot divide object of type `Literal[False]` by zero"
-a / b  # error: [division-by-zero] "Cannot divide object of type `Literal[True]` by zero"
-
-# bitwise OR
-reveal_type(a | a)  # revealed: Literal[True]
-reveal_type(a | b)  # revealed: Literal[True]
-reveal_type(b | a)  # revealed: Literal[True]
-reveal_type(b | b)  # revealed: Literal[False]
-```

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

@@ -1,435 +0,0 @@
-# Binary operations on instances
-
-Binary operations in Python are implemented by means of magic double-underscore methods.
-
-For references, see:
-
-- <https://snarky.ca/unravelling-binary-arithmetic-operations-in-python/>
-- <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>
-
-## Operations
-
-We support inference for all Python's binary operators: `+`, `-`, `*`, `@`, `/`, `//`, `%`, `**`,
-`<<`, `>>`, `&`, `^`, and `|`.
-
-```py
-class A:
-    def __add__(self, other) -> A:
-        return self
-
-    def __sub__(self, other) -> A:
-        return self
-
-    def __mul__(self, other) -> A:
-        return self
-
-    def __matmul__(self, other) -> A:
-        return self
-
-    def __truediv__(self, other) -> A:
-        return self
-
-    def __floordiv__(self, other) -> A:
-        return self
-
-    def __mod__(self, other) -> A:
-        return self
-
-    def __pow__(self, other) -> A:
-        return self
-
-    def __lshift__(self, other) -> A:
-        return self
-
-    def __rshift__(self, other) -> A:
-        return self
-
-    def __and__(self, other) -> A:
-        return self
-
-    def __xor__(self, other) -> A:
-        return self
-
-    def __or__(self, other) -> A:
-        return self
-
-class B: ...
-
-reveal_type(A() + B())  # revealed: A
-reveal_type(A() - B())  # revealed: A
-reveal_type(A() * B())  # revealed: A
-reveal_type(A() @ B())  # revealed: A
-reveal_type(A() / B())  # revealed: A
-reveal_type(A() // B())  # revealed: A
-reveal_type(A() % B())  # revealed: A
-reveal_type(A() ** B())  # revealed: A
-reveal_type(A() << B())  # revealed: A
-reveal_type(A() >> B())  # revealed: A
-reveal_type(A() & B())  # revealed: A
-reveal_type(A() ^ B())  # revealed: A
-reveal_type(A() | B())  # revealed: A
-```
-
-## Reflected
-
-We also support inference for reflected operations:
-
-```py
-class A:
-    def __radd__(self, other) -> A:
-        return self
-
-    def __rsub__(self, other) -> A:
-        return self
-
-    def __rmul__(self, other) -> A:
-        return self
-
-    def __rmatmul__(self, other) -> A:
-        return self
-
-    def __rtruediv__(self, other) -> A:
-        return self
-
-    def __rfloordiv__(self, other) -> A:
-        return self
-
-    def __rmod__(self, other) -> A:
-        return self
-
-    def __rpow__(self, other) -> A:
-        return self
-
-    def __rlshift__(self, other) -> A:
-        return self
-
-    def __rrshift__(self, other) -> A:
-        return self
-
-    def __rand__(self, other) -> A:
-        return self
-
-    def __rxor__(self, other) -> A:
-        return self
-
-    def __ror__(self, other) -> A:
-        return self
-
-class B: ...
-
-reveal_type(B() + A())  # revealed: A
-reveal_type(B() - A())  # revealed: A
-reveal_type(B() * A())  # revealed: A
-reveal_type(B() @ A())  # revealed: A
-reveal_type(B() / A())  # revealed: A
-reveal_type(B() // A())  # revealed: A
-reveal_type(B() % A())  # revealed: A
-reveal_type(B() ** A())  # revealed: A
-reveal_type(B() << A())  # revealed: A
-reveal_type(B() >> A())  # revealed: A
-reveal_type(B() & A())  # revealed: A
-reveal_type(B() ^ A())  # revealed: A
-reveal_type(B() | A())  # revealed: A
-```
-
-## Returning a different type
-
-The magic methods aren't required to return the type of `self`:
-
-```py
-class A:
-    def __add__(self, other) -> int:
-        return 1
-
-    def __rsub__(self, other) -> int:
-        return 1
-
-class B: ...
-
-reveal_type(A() + B())  # revealed: int
-reveal_type(B() - A())  # revealed: int
-```
-
-## Non-reflected precedence in general
-
-In general, if the left-hand side defines `__add__` and the right-hand side defines `__radd__` and
-the right-hand side is not a subtype of the left-hand side, `lhs.__add__` will take precedence:
-
-```py
-class A:
-    def __add__(self, other: B) -> int:
-        return 42
-
-class B:
-    def __radd__(self, other: A) -> str:
-        return "foo"
-
-reveal_type(A() + B())  # revealed:  int
-
-# Edge case: C is a subtype of C, *but* if the two sides are of *equal* types,
-# the lhs *still* takes precedence
-class C:
-    def __add__(self, other: C) -> int:
-        return 42
-
-    def __radd__(self, other: C) -> str:
-        return "foo"
-
-reveal_type(C() + C())  # revealed: int
-```
-
-## Reflected precedence for subtypes (in some cases)
-
-If the right-hand operand is a subtype of the left-hand operand and has a different implementation
-of the reflected method, the reflected method on the right-hand operand takes precedence.
-
-```py
-class A:
-    def __add__(self, other) -> str:
-        return "foo"
-
-    def __radd__(self, other) -> str:
-        return "foo"
-
-class MyString(str): ...
-
-class B(A):
-    def __radd__(self, other) -> MyString:
-        return MyString()
-
-reveal_type(A() + B())  # revealed: MyString
-
-# N.B. Still a subtype of `A`, even though `A` does not appear directly in the class's `__bases__`
-class C(B): ...
-
-reveal_type(A() + C())  # revealed: MyString
-```
-
-## Reflected precedence 2
-
-If the right-hand operand is a subtype of the left-hand operand, but does not override the reflected
-method, the left-hand operand's non-reflected method still takes precedence:
-
-```py
-class A:
-    def __add__(self, other) -> str:
-        return "foo"
-
-    def __radd__(self, other) -> int:
-        return 42
-
-class B(A): ...
-
-reveal_type(A() + B())  # revealed: str
-```
-
-## Only reflected supported
-
-For example, at runtime, `(1).__add__(1.2)` is `NotImplemented`, but `(1.2).__radd__(1) == 2.2`,
-meaning that `1 + 1.2` succeeds at runtime (producing `2.2`). The runtime tries the second one only
-if the first one returns `NotImplemented` to signal failure.
-
-Typeshed and other stubs annotate dunder-method calls that would return `NotImplemented` as being
-"illegal" calls. `int.__add__` is annotated as only "accepting" `int`s, even though it
-strictly-speaking "accepts" any other object without raising an exception -- it will simply return
-`NotImplemented`, allowing the runtime to try the `__radd__` method of the right-hand operand as
-well.
-
-```py
-class A:
-    def __sub__(self, other: A) -> A:
-        return A()
-
-class B:
-    def __rsub__(self, other: A) -> B:
-        return B()
-
-# TODO: this should be `B` (the return annotation of `B.__rsub__`),
-# because `A.__sub__` is annotated as only accepting `A`,
-# but `B.__rsub__` will accept `A`.
-reveal_type(A() - B())  # revealed: A
-```
-
-## Callable instances as dunders
-
-Believe it or not, this is supported at runtime:
-
-```py
-class A:
-    def __call__(self, other) -> int:
-        return 42
-
-class B:
-    __add__ = A()
-
-reveal_type(B() + B())  # revealed: int
-```
-
-## Integration test: numbers from typeshed
-
-```py
-reveal_type(3j + 3.14)  # revealed: complex
-reveal_type(4.2 + 42)  # revealed: float
-reveal_type(3j + 3)  # revealed: complex
-
-# TODO should be complex, need to check arg type and fall back to `rhs.__radd__`
-reveal_type(3.14 + 3j)  # revealed: float
-
-# TODO should be float, need to check arg type and fall back to `rhs.__radd__`
-reveal_type(42 + 4.2)  # revealed: int
-
-# TODO should be complex, need to check arg type and fall back to `rhs.__radd__`
-reveal_type(3 + 3j)  # revealed: int
-
-def returns_int() -> int:
-    return 42
-
-def returns_bool() -> bool:
-    return True
-
-x = returns_bool()
-y = returns_int()
-
-reveal_type(x + y)  # revealed: int
-reveal_type(4.2 + x)  # revealed: float
-
-# TODO should be float, need to check arg type and fall back to `rhs.__radd__`
-reveal_type(y + 4.12)  # revealed: int
-```
-
-## With literal types
-
-When we have a literal type for one operand, we're able to fall back to the instance handling for
-its instance super-type.
-
-```py
-class A:
-    def __add__(self, other) -> A:
-        return self
-
-    def __radd__(self, other) -> A:
-        return self
-
-reveal_type(A() + 1)  # revealed: A
-# TODO should be `A` since `int.__add__` doesn't support `A` instances
-reveal_type(1 + A())  # revealed: int
-
-reveal_type(A() + "foo")  # revealed: A
-# TODO should be `A` since `str.__add__` doesn't support `A` instances
-# TODO overloads
-reveal_type("foo" + A())  # revealed: @Todo
-
-reveal_type(A() + b"foo")  # revealed: A
-# TODO should be `A` since `bytes.__add__` doesn't support `A` instances
-reveal_type(b"foo" + A())  # revealed: bytes
-
-reveal_type(A() + ())  # revealed: A
-# TODO this should be `A`, since `tuple.__add__` doesn't support `A` instances
-reveal_type(() + A())  # revealed: @Todo
-
-literal_string_instance = "foo" * 1_000_000_000
-# the test is not testing what it's meant to be testing if this isn't a `LiteralString`:
-reveal_type(literal_string_instance)  # revealed: LiteralString
-
-reveal_type(A() + literal_string_instance)  # revealed: A
-# TODO should be `A` since `str.__add__` doesn't support `A` instances
-# TODO overloads
-reveal_type(literal_string_instance + A())  # revealed: @Todo
-```
-
-## Operations involving instances of classes inheriting from `Any`
-
-`Any` and `Unknown` represent a set of possible runtime objects, wherein the bounds of the set are
-unknown. Whether the left-hand operand's dunder or the right-hand operand's reflected dunder depends
-on whether the right-hand operand is an instance of a class that is a subclass of the left-hand
-operand's class and overrides the reflected dunder. In the following example, because of the
-unknowable nature of `Any`/`Unknown`, we must consider both possibilities: `Any`/`Unknown` might
-resolve to an unknown third class that inherits from `X` and overrides `__radd__`; but it also might
-not. Thus, the correct answer here for the `reveal_type` is `int | Unknown`.
-
-```py
-from does_not_exist import Foo  # error: [unresolved-import]
-
-reveal_type(Foo)  # revealed: Unknown
-
-class X:
-    def __add__(self, other: object) -> int:
-        return 42
-
-class Y(Foo): ...
-
-# TODO: Should be `int | Unknown`; see above discussion.
-reveal_type(X() + Y())  # revealed: int
-```
-
-## Unsupported
-
-### Dunder as instance attribute
-
-The magic method must exist on the class, not just on the instance:
-
-```py
-def add_impl(self, other) -> int:
-    return 1
-
-class A:
-    def __init__(self):
-        self.__add__ = add_impl
-
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `A` and `A`"
-# revealed: Unknown
-reveal_type(A() + A())
-```
-
-### Missing dunder
-
-```py
-class A: ...
-
-# error: [unsupported-operator]
-# revealed: Unknown
-reveal_type(A() + A())
-```
-
-### Wrong position
-
-A left-hand dunder method doesn't apply for the right-hand operand, or vice versa:
-
-```py
-class A:
-    def __add__(self, other) -> int: ...
-
-class B:
-    def __radd__(self, other) -> int: ...
-
-class C: ...
-
-# error: [unsupported-operator]
-# revealed: Unknown
-reveal_type(C() + A())
-
-# error: [unsupported-operator]
-# revealed: Unknown
-reveal_type(B() + C())
-```
-
-### Reflected dunder is not tried between two objects of the same type
-
-For the specific case where the left-hand operand is the exact same type as the right-hand operand,
-the reflected dunder of the right-hand operand is not tried; the runtime short-circuits after trying
-the unreflected dunder of the left-hand operand. For context, see
-[this mailing list discussion](https://mail.python.org/archives/list/python-dev@python.org/thread/7NZUCODEAPQFMRFXYRMGJXDSIS3WJYIV/).
-
-```py
-class Foo:
-    def __radd__(self, other: Foo) -> Foo:
-        return self
-
-# error: [unsupported-operator]
-# revealed: Unknown
-reveal_type(Foo() + Foo())
-```
-
-### Wrong type
-
-TODO: check signature and error if `other` is the wrong type

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

@@ -1,70 +1,36 @@
-# Binary operations on integers
+## Binary operations on integers
 
 ## Basic Arithmetic
 
 ```py
-reveal_type(2 + 1)  # revealed: Literal[3]
-reveal_type(3 - 4)  # revealed: Literal[-1]
-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]
-```
+a = 2 + 1
+b = a - 4
+c = a * b
+d = c // 3
+e = c / 3
+f = 5 % 3
 
-## Power
-
-For power if the result fits in the int literal type it will be a Literal type. Otherwise the
-outcome is int.
-
-```py
-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
+reveal_type(a)  # revealed: Literal[3]
+reveal_type(b)  # revealed: Literal[-1]
+reveal_type(c)  # revealed: Literal[-3]
+reveal_type(d)  # revealed: Literal[-1]
+reveal_type(e)  # revealed: float
+reveal_type(f)  # revealed: Literal[2]
 ```
 
 ## Division by Zero
 
-This error is really outside the current Python type system, because e.g. `int.__truediv__` and
-friends are not annotated to indicate that it's an error, and we don't even have a facility to
-permit such an annotation. So arguably divide-by-zero should be a lint error rather than a type
-checker error. But we choose to go ahead and error in the cases that are very likely to be an error:
-dividing something typed as `int` or `float` by something known to be `Literal[0]`.
-
-This isn't _definitely_ an error, because the object typed as `int` or `float` could be an instance
-of a custom subclass which overrides division behavior to handle zero without error. But if this
-unusual case occurs, the error can be avoided by explicitly typing the dividend as that safe custom
-subclass; we only emit the error if the LHS type is exactly `int` or `float`, not if its a subclass.
-
 ```py
+# TODO: `a` should be `int` and `e` should be `float` once we support inference.
 a = 1 / 0  # error: "Cannot divide object of type `Literal[1]` by zero"
-reveal_type(a)  # revealed: float
-
 b = 2 // 0  # error: "Cannot floor divide object of type `Literal[2]` by zero"
-reveal_type(b)  # revealed: int
-
 c = 3 % 0  # error: "Cannot reduce object of type `Literal[3]` modulo zero"
+d = int() / 0  # error: "Cannot divide object of type `int` by zero"
+e = 1.0 / 0  # error: "Cannot divide object of type `float` by zero"
+
+reveal_type(a)  # revealed: float
+reveal_type(b)  # revealed: int
 reveal_type(c)  # revealed: int
-
-# error: "Cannot divide object of type `int` by zero"
-# revealed: float
-reveal_type(int() / 0)
-
-# error: "Cannot divide object of type `Literal[1]` by zero"
-# revealed: float
-reveal_type(1 / False)
-# error: [division-by-zero] "Cannot divide object of type `Literal[True]` by zero"
-True / False
-# error: [division-by-zero] "Cannot divide object of type `Literal[True]` by zero"
-bool(1) / False
-
-# error: "Cannot divide object of type `float` by zero"
-# revealed: float
-reveal_type(1.0 / 0)
-
-class MyInt(int): ...
-
-# No error for a subclass of int
-# revealed: float
-reveal_type(MyInt(3) / 0)
+reveal_type(d)  # revealed: @Todo
+reveal_type(e)  # revealed: @Todo
 ```

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

@@ -1,78 +0,0 @@
-# Short-Circuit Evaluation
-
-## Not all boolean expressions must be evaluated
-
-In `or` expressions, if the left-hand side is truthy, the right-hand side is not evaluated.
-Similarly, in `and` expressions, if the left-hand side is falsy, the right-hand side is not
-evaluated.
-
-```py
-def bool_instance() -> bool:
-    return True
-
-if bool_instance() or (x := 1):
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-
-if bool_instance() and (x := 1):
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-```
-
-## First expression is always evaluated
-
-```py
-def bool_instance() -> bool:
-    return True
-
-if (x := 1) or bool_instance():
-    reveal_type(x)  # revealed: Literal[1]
-
-if (x := 1) and bool_instance():
-    reveal_type(x)  # revealed: Literal[1]
-```
-
-## Statically known truthiness
-
-```py
-if True or (x := 1):
-    # TODO: infer that the second arm is never executed, and raise `unresolved-reference`.
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-
-if True and (x := 1):
-    # TODO: infer that the second arm is always executed, do not raise a diagnostic
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-```
-
-## Later expressions can always use variables from earlier expressions
-
-```py
-def bool_instance() -> bool:
-    return True
-
-bool_instance() or (x := 1) or reveal_type(x)  # revealed: Literal[1]
-
-# error: [unresolved-reference]
-bool_instance() or reveal_type(y) or (y := 1)  # revealed: Unknown
-```
-
-## Nested expressions
-
-```py
-def bool_instance() -> bool:
-    return True
-
-if bool_instance() or ((x := 1) and bool_instance()):
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-
-if ((y := 1) and bool_instance()) or bool_instance():
-    reveal_type(y)  # revealed: Literal[1]
-
-# error: [possibly-unresolved-reference]
-if (bool_instance() and (z := 1)) or reveal_type(z):  # revealed: Literal[1]
-    # error: [possibly-unresolved-reference]
-    reveal_type(z)  # revealed: Literal[1]
-```

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

@@ -11,65 +11,11 @@ class Multiplier:
         return number * self.factor
 
 a = Multiplier(2.0)(3.0)
-reveal_type(a)  # revealed: float
 
 class Unit: ...
 
-b = Unit()(3.0)  # error: "Object of type `Unit` is not callable"
-reveal_type(b)  # revealed: Unknown
-```
-
-## Possibly unbound `__call__` method
-
-```py
-def flag() -> bool: ...
-
-class PossiblyNotCallable:
-    if flag():
-        def __call__(self) -> int: ...
-
-a = PossiblyNotCallable()
-result = a()  # error: "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
-reveal_type(result)  # revealed: int
-```
-
-## Possibly unbound callable
-
-```py
-def flag() -> bool: ...
-
-if flag():
-    class PossiblyUnbound:
-        def __call__(self) -> int: ...
-
-# error: [possibly-unresolved-reference]
-a = PossiblyUnbound()
-reveal_type(a())  # revealed: int
-```
-
-## Non-callable `__call__`
-
-```py
-class NonCallable:
-    __call__ = 1
-
-a = NonCallable()
-# error: "Object of type `NonCallable` is not callable"
-reveal_type(a())  # revealed: Unknown
-```
-
-## Possibly non-callable `__call__`
-
-```py
-def flag() -> bool: ...
-
-class NonCallable:
-    if flag():
-        __call__ = 1
-    else:
-        def __call__(self) -> int: ...
-
-a = NonCallable()
-# error: "Object of type `Literal[1] | Literal[__call__]` is not callable (due to union element `Literal[1]`)"
-reveal_type(a())  # revealed: Unknown | int
+b = Unit()(3.0) # error: "Object of type `Unit` is not callable"
+
+reveal_type(a) # revealed: float
+reveal_type(b) # revealed: Unknown
 ```

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

@@ -3,5 +3,6 @@
 ```py
 class Foo: ...
 
-reveal_type(Foo())  # revealed: Foo
+x = Foo()
+reveal_type(x)  # revealed: Foo
 ```

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

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

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

@@ -3,40 +3,28 @@
 ## Union of return types
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
 if flag:
-
     def f() -> int:
         return 1
-
 else:
-
     def f() -> str:
-        return "foo"
+        return 'foo'
 
-reveal_type(f())  # revealed: int | str
+x = f()
+reveal_type(x)  # revealed: int | str
 ```
 
 ## Calling with an unknown union
 
 ```py
-from nonexistent import f  # error: [unresolved-import] "Cannot resolve import `nonexistent`"
-
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
+from nonexistent import f # error: [unresolved-import] "Cannot resolve import `nonexistent`"
 
 if flag:
-
     def f() -> int:
         return 1
 
-reveal_type(f())  # revealed: Unknown | int
+x = f()
+reveal_type(x)  # revealed: Unknown | int
 ```
 
 ## Non-callable elements in a union
@@ -44,15 +32,9 @@ reveal_type(f())  # revealed: Unknown | int
 Calling a union with a non-callable element should emit a diagnostic.
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
 if flag:
     f = 1
 else:
-
     def f() -> int:
         return 1
 
@@ -65,23 +47,16 @@ reveal_type(x)  # revealed: Unknown | int
 Calling a union with multiple non-callable elements should mention all of them in the diagnostic.
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-
 if flag:
     f = 1
 elif flag2:
-    f = "foo"
+    f = 'foo'
 else:
-
     def f() -> int:
         return 1
 
-# error: "Object of type `Literal[1] | Literal["foo"] | Literal[f]` is not callable (due to union elements Literal[1], Literal["foo"])"
-# revealed: Unknown | int
-reveal_type(f())
+x = f()  # error: "Object of type `Literal[1] | Literal["foo"] | Literal[f]` is not callable (due to union elements Literal[1], Literal["foo"])"
+reveal_type(x)  # revealed: Unknown | int
 ```
 
 ## All non-callable union elements
@@ -89,15 +64,10 @@ reveal_type(f())
 Calling a union with no callable elements can emit a simpler diagnostic.
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
 if flag:
     f = 1
 else:
-    f = "foo"
+    f = 'foo'
 
 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/byte_literals.md

@@ -1,43 +1,43 @@
-# Comparison: Byte literals
+### Comparison: Byte literals
 
-These tests assert that we infer precise `Literal` types for comparisons between objects inferred as
-having `Literal` bytes types:
+These tests assert that we infer precise `Literal` types for comparisons between objects
+inferred as having `Literal` bytes types:
 
 ```py
 reveal_type(b"abc" == b"abc")  # revealed: Literal[True]
-reveal_type(b"abc" == b"ab")  # revealed: Literal[False]
+reveal_type(b"abc" == b"ab")   # revealed: Literal[False]
 
 reveal_type(b"abc" != b"abc")  # revealed: Literal[False]
-reveal_type(b"abc" != b"ab")  # revealed: Literal[True]
+reveal_type(b"abc" != b"ab")   # revealed: Literal[True]
 
-reveal_type(b"abc" < b"abd")  # revealed: Literal[True]
-reveal_type(b"abc" < b"abb")  # revealed: Literal[False]
+reveal_type(b"abc" < b"abd")   # revealed: Literal[True]
+reveal_type(b"abc" < b"abb")   # revealed: Literal[False]
 
 reveal_type(b"abc" <= b"abc")  # revealed: Literal[True]
 reveal_type(b"abc" <= b"abb")  # revealed: Literal[False]
 
-reveal_type(b"abc" > b"abd")  # revealed: Literal[False]
-reveal_type(b"abc" > b"abb")  # revealed: Literal[True]
+reveal_type(b"abc" > b"abd")   # revealed: Literal[False]
+reveal_type(b"abc" > b"abb")   # revealed: Literal[True]
 
 reveal_type(b"abc" >= b"abc")  # revealed: Literal[True]
 reveal_type(b"abc" >= b"abd")  # revealed: Literal[False]
 
-reveal_type(b"" in b"")  # revealed: Literal[True]
-reveal_type(b"" in b"abc")  # revealed: Literal[True]
-reveal_type(b"abc" in b"")  # revealed: Literal[False]
-reveal_type(b"ab" in b"abc")  # revealed: Literal[True]
-reveal_type(b"abc" in b"abc")  # revealed: Literal[True]
-reveal_type(b"d" in b"abc")  # revealed: Literal[False]
-reveal_type(b"ac" in b"abc")  # revealed: Literal[False]
+reveal_type(b"" in b"")                      # revealed: Literal[True]
+reveal_type(b"" in b"abc")                   # revealed: Literal[True]
+reveal_type(b"abc" in b"")                   # revealed: Literal[False]
+reveal_type(b"ab" in b"abc")                 # revealed: Literal[True]
+reveal_type(b"abc" in b"abc")                # revealed: Literal[True]
+reveal_type(b"d" in b"abc")                  # revealed: Literal[False]
+reveal_type(b"ac" in b"abc")                 # revealed: Literal[False]
 reveal_type(b"\x81\x82" in b"\x80\x81\x82")  # revealed: Literal[True]
 reveal_type(b"\x82\x83" in b"\x80\x81\x82")  # revealed: Literal[False]
 
-reveal_type(b"ab" not in b"abc")  # revealed: Literal[False]
-reveal_type(b"ac" not in b"abc")  # revealed: Literal[True]
+reveal_type(b"ab" not in b"abc")             # revealed: Literal[False]
+reveal_type(b"ac" not in b"abc")             # revealed: Literal[True]
 
-reveal_type(b"abc" is b"abc")  # revealed: bool
-reveal_type(b"abc" is b"ab")  # revealed: Literal[False]
+reveal_type(b"abc" is b"abc")      # revealed: bool
+reveal_type(b"abc" is b"ab")       # revealed: Literal[False]
 
 reveal_type(b"abc" is not b"abc")  # revealed: bool
-reveal_type(b"abc" is not b"ab")  # revealed: Literal[True]
+reveal_type(b"abc" is not b"ab")   # revealed: Literal[True]
 ```

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

@@ -1,40 +0,0 @@
-# Identity tests
-
-```py
-class A: ...
-
-def get_a() -> A: ...
-def get_object() -> object: ...
-
-a1 = get_a()
-a2 = get_a()
-
-n1 = None
-n2 = None
-
-o = get_object()
-
-reveal_type(a1 is a1)  # revealed: bool
-reveal_type(a1 is a2)  # revealed: bool
-
-reveal_type(n1 is n1)  # revealed: Literal[True]
-reveal_type(n1 is n2)  # revealed: Literal[True]
-
-reveal_type(a1 is n1)  # revealed: Literal[False]
-reveal_type(n1 is a1)  # revealed: Literal[False]
-
-reveal_type(a1 is o)  # revealed: bool
-reveal_type(n1 is o)  # revealed: bool
-
-reveal_type(a1 is not a1)  # revealed: bool
-reveal_type(a1 is not a2)  # revealed: bool
-
-reveal_type(n1 is not n1)  # revealed: Literal[False]
-reveal_type(n1 is not n2)  # revealed: Literal[False]
-
-reveal_type(a1 is not n1)  # revealed: Literal[True]
-reveal_type(n1 is not a1)  # revealed: Literal[True]
-
-reveal_type(a1 is not o)  # revealed: bool
-reveal_type(n1 is not o)  # revealed: bool
-```

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

@@ -1,160 +0,0 @@
-# Comparison: Membership Test
-
-In Python, the term "membership test operators" refers to the operators `in` and `not in`. To
-customize their behavior, classes can implement one of the special methods `__contains__`,
-`__iter__`, or `__getitem__`.
-
-For references, see:
-
-- <https://docs.python.org/3/reference/expressions.html#membership-test-details>
-- <https://docs.python.org/3/reference/datamodel.html#object.__contains__>
-- <https://snarky.ca/unravelling-membership-testing/>
-
-## Implements `__contains__`
-
-Classes can support membership tests by implementing the `__contains__` method:
-
-```py
-class A:
-    def __contains__(self, item: str) -> bool:
-        return True
-
-reveal_type("hello" in A())  # revealed: bool
-reveal_type("hello" not in A())  # revealed: bool
-# TODO: should emit diagnostic, need to check arg type, will fail
-reveal_type(42 in A())  # revealed: bool
-reveal_type(42 not in A())  # revealed: bool
-```
-
-## Implements `__iter__`
-
-Classes that don't implement `__contains__`, but do implement `__iter__`, also support containment
-checks; the needle will be sought in their iterated items:
-
-```py
-class StringIterator:
-    def __next__(self) -> str:
-        return "foo"
-
-class A:
-    def __iter__(self) -> StringIterator:
-        return StringIterator()
-
-reveal_type("hello" in A())  # revealed: bool
-reveal_type("hello" not in A())  # revealed: bool
-reveal_type(42 in A())  # revealed: bool
-reveal_type(42 not in A())  # revealed: bool
-```
-
-## Implements `__getitems__`
-
-The final fallback is to implement `__getitem__` for integer keys. Python will call `__getitem__`
-with `0`, `1`, `2`... until either the needle is found (leading the membership test to evaluate to
-`True`) or `__getitem__` raises `IndexError` (the raised exception is swallowed, but results in the
-membership test evaluating to `False`).
-
-```py
-class A:
-    def __getitem__(self, key: int) -> str:
-        return "foo"
-
-reveal_type("hello" in A())  # revealed: bool
-reveal_type("hello" not in A())  # revealed: bool
-reveal_type(42 in A())  # revealed: bool
-reveal_type(42 not in A())  # revealed: bool
-```
-
-## Wrong Return Type
-
-Python coerces the results of containment checks to `bool`, even if `__contains__` returns a
-non-bool:
-
-```py
-class A:
-    def __contains__(self, item: str) -> str:
-        return "foo"
-
-reveal_type("hello" in A())  # revealed: bool
-reveal_type("hello" not in A())  # revealed: bool
-```
-
-## Literal Result for `in` and `not in`
-
-`__contains__` with a literal return type may result in a `BooleanLiteral` outcome.
-
-```py
-from typing import Literal
-
-class AlwaysTrue:
-    def __contains__(self, item: int) -> Literal[1]:
-        return 1
-
-class AlwaysFalse:
-    def __contains__(self, item: int) -> Literal[""]:
-        return ""
-
-reveal_type(42 in AlwaysTrue())  # revealed: Literal[True]
-reveal_type(42 not in AlwaysTrue())  # revealed: Literal[False]
-
-reveal_type(42 in AlwaysFalse())  # revealed: Literal[False]
-reveal_type(42 not in AlwaysFalse())  # revealed: Literal[True]
-```
-
-## No Fallback for `__contains__`
-
-If `__contains__` is implemented, checking membership of a type it doesn't accept is an error; it
-doesn't result in a fallback to `__iter__` or `__getitem__`:
-
-```py
-class CheckContains: ...
-class CheckIter: ...
-class CheckGetItem: ...
-
-class CheckIterIterator:
-    def __next__(self) -> CheckIter:
-        return CheckIter()
-
-class A:
-    def __contains__(self, item: CheckContains) -> bool:
-        return True
-
-    def __iter__(self) -> CheckIterIterator:
-        return CheckIterIterator()
-
-    def __getitem__(self, key: int) -> CheckGetItem:
-        return CheckGetItem()
-
-reveal_type(CheckContains() in A())  # revealed: bool
-
-# TODO: should emit diagnostic, need to check arg type,
-# should not fall back to __iter__ or __getitem__
-reveal_type(CheckIter() in A())  # revealed: bool
-reveal_type(CheckGetItem() in A())  # revealed: bool
-
-class B:
-    def __iter__(self) -> CheckIterIterator:
-        return CheckIterIterator()
-
-    def __getitem__(self, key: int) -> CheckGetItem:
-        return CheckGetItem()
-
-reveal_type(CheckIter() in B())  # revealed: bool
-# Always use `__iter__`, regardless of iterated type; there's no NotImplemented
-# in this case, so there's no fallback to `__getitem__`
-reveal_type(CheckGetItem() in B())  # revealed: bool
-```
-
-## Invalid Old-Style Iteration
-
-If `__getitem__` is implemented but does not accept integer arguments, then the membership test is
-not supported and should trigger a diagnostic.
-
-```py
-class A:
-    def __getitem__(self, key: str) -> str:
-        return "foo"
-
-# TODO should emit a diagnostic
-reveal_type(42 in A())  # revealed: bool
-reveal_type("hello" in A())  # revealed: bool
-```

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

@@ -1,328 +0,0 @@
-# Comparison: Rich Comparison
-
-Rich comparison operations (`==`, `!=`, `<`, `<=`, `>`, `>=`) in Python are implemented through
-double-underscore methods that allow customization of comparison behavior.
-
-For references, see:
-
-- <https://docs.python.org/3/reference/datamodel.html#object.__lt__>
-- <https://snarky.ca/unravelling-rich-comparison-operators/>
-
-## Rich Comparison Dunder Implementations For Same Class
-
-Classes can support rich comparison by implementing dunder methods like `__eq__`, `__ne__`, etc. The
-most common case involves implementing these methods for the same type:
-
-```py
-from __future__ import annotations
-
-class A:
-    def __eq__(self, other: A) -> int:
-        return 42
-
-    def __ne__(self, other: A) -> float:
-        return 42.0
-
-    def __lt__(self, other: A) -> str:
-        return "42"
-
-    def __le__(self, other: A) -> bytes:
-        return b"42"
-
-    def __gt__(self, other: A) -> list:
-        return [42]
-
-    def __ge__(self, other: A) -> set:
-        return {42}
-
-reveal_type(A() == A())  # revealed: int
-reveal_type(A() != A())  # revealed: float
-reveal_type(A() < A())  # revealed: str
-reveal_type(A() <= A())  # revealed: bytes
-reveal_type(A() > A())  # revealed: list
-reveal_type(A() >= A())  # revealed: set
-```
-
-## Rich Comparison Dunder Implementations for Other Class
-
-In some cases, classes may implement rich comparison dunder methods for comparisons with a different
-type:
-
-```py
-from __future__ import annotations
-
-class A:
-    def __eq__(self, other: B) -> int:
-        return 42
-
-    def __ne__(self, other: B) -> float:
-        return 42.0
-
-    def __lt__(self, other: B) -> str:
-        return "42"
-
-    def __le__(self, other: B) -> bytes:
-        return b"42"
-
-    def __gt__(self, other: B) -> list:
-        return [42]
-
-    def __ge__(self, other: B) -> set:
-        return {42}
-
-class B: ...
-
-reveal_type(A() == B())  # revealed: int
-reveal_type(A() != B())  # revealed: float
-reveal_type(A() < B())  # revealed: str
-reveal_type(A() <= B())  # revealed: bytes
-reveal_type(A() > B())  # revealed: list
-reveal_type(A() >= B())  # revealed: set
-```
-
-## Reflected Comparisons
-
-Fallback to the right-hand side’s comparison methods occurs when the left-hand side does not define
-them. Note: class `B` has its own `__eq__` and `__ne__` methods to override those of `object`, but
-these methods will be ignored here because they require a mismatched operand type.
-
-```py
-from __future__ import annotations
-
-class A:
-    def __eq__(self, other: B) -> int:
-        return 42
-
-    def __ne__(self, other: B) -> float:
-        return 42.0
-
-    def __lt__(self, other: B) -> str:
-        return "42"
-
-    def __le__(self, other: B) -> bytes:
-        return b"42"
-
-    def __gt__(self, other: B) -> list:
-        return [42]
-
-    def __ge__(self, other: B) -> set:
-        return {42}
-
-class B:
-    # To override builtins.object.__eq__ and builtins.object.__ne__
-    # TODO these should emit an invalid override diagnostic
-    def __eq__(self, other: str) -> B:
-        return B()
-
-    def __ne__(self, other: str) -> B:
-        return B()
-
-# TODO: should be `int` and `float`.
-# Need to check arg type and fall back to `rhs.__eq__` and `rhs.__ne__`.
-#
-# Because `object.__eq__` and `object.__ne__` accept `object` in typeshed,
-# this can only happen with an invalid override of these methods,
-# but we still support it.
-reveal_type(B() == A())  # revealed: B
-reveal_type(B() != A())  # revealed: B
-
-reveal_type(B() < A())  # revealed: list
-reveal_type(B() <= A())  # revealed: set
-
-reveal_type(B() > A())  # revealed: str
-reveal_type(B() >= A())  # revealed: bytes
-
-class C:
-    def __gt__(self, other: C) -> int:
-        return 42
-
-    def __ge__(self, other: C) -> float:
-        return 42.0
-
-reveal_type(C() < C())  # revealed: int
-reveal_type(C() <= C())  # revealed: float
-```
-
-## Reflected Comparisons with Subclasses
-
-When subclasses override comparison methods, these overridden methods take precedence over those in
-the parent class. Class `B` inherits from `A` and redefines comparison methods to return types other
-than `A`.
-
-```py
-from __future__ import annotations
-
-class A:
-    def __eq__(self, other: A) -> A:
-        return A()
-
-    def __ne__(self, other: A) -> A:
-        return A()
-
-    def __lt__(self, other: A) -> A:
-        return A()
-
-    def __le__(self, other: A) -> A:
-        return A()
-
-    def __gt__(self, other: A) -> A:
-        return A()
-
-    def __ge__(self, other: A) -> A:
-        return A()
-
-class B(A):
-    def __eq__(self, other: A) -> int:
-        return 42
-
-    def __ne__(self, other: A) -> float:
-        return 42.0
-
-    def __lt__(self, other: A) -> str:
-        return "42"
-
-    def __le__(self, other: A) -> bytes:
-        return b"42"
-
-    def __gt__(self, other: A) -> list:
-        return [42]
-
-    def __ge__(self, other: A) -> set:
-        return {42}
-
-reveal_type(A() == B())  # revealed: int
-reveal_type(A() != B())  # revealed: float
-
-reveal_type(A() < B())  # revealed: list
-reveal_type(A() <= B())  # revealed: set
-
-reveal_type(A() > B())  # revealed: str
-reveal_type(A() >= B())  # revealed: bytes
-```
-
-## Reflected Comparisons with Subclass But Falls Back to LHS
-
-In the case of a subclass, the right-hand side has priority. However, if the overridden dunder
-method has an mismatched type to operand, the comparison will fall back to the left-hand side.
-
-```py
-from __future__ import annotations
-
-class A:
-    def __lt__(self, other: A) -> A:
-        return A()
-
-    def __gt__(self, other: A) -> A:
-        return A()
-
-class B(A):
-    def __lt__(self, other: int) -> B:
-        return B()
-
-    def __gt__(self, other: int) -> B:
-        return B()
-
-# TODO: should be `A`, need to check argument type and fall back to LHS method
-reveal_type(A() < B())  # revealed: B
-reveal_type(A() > B())  # revealed: B
-```
-
-## Operations involving instances of classes inheriting from `Any`
-
-`Any` and `Unknown` represent a set of possible runtime objects, wherein the bounds of the set are
-unknown. Whether the left-hand operand's dunder or the right-hand operand's reflected dunder depends
-on whether the right-hand operand is an instance of a class that is a subclass of the left-hand
-operand's class and overrides the reflected dunder. In the following example, because of the
-unknowable nature of `Any`/`Unknown`, we must consider both possibilities: `Any`/`Unknown` might
-resolve to an unknown third class that inherits from `X` and overrides `__gt__`; but it also might
-not. Thus, the correct answer here for the `reveal_type` is `int | Unknown`.
-
-(This test is referenced from `mdtest/binary/instances.md`)
-
-```py
-from does_not_exist import Foo  # error: [unresolved-import]
-
-reveal_type(Foo)  # revealed: Unknown
-
-class X:
-    def __lt__(self, other: object) -> int:
-        return 42
-
-class Y(Foo): ...
-
-# TODO: Should be `int | Unknown`; see above discussion.
-reveal_type(X() < Y())  # revealed: int
-```
-
-## Equality and Inequality Fallback
-
-This test confirms that `==` and `!=` comparisons default to identity comparisons (`is`, `is not`)
-when argument types do not match the method signature.
-
-Please refer to the [docs](https://docs.python.org/3/reference/datamodel.html#object.__eq__)
-
-```py
-from __future__ import annotations
-
-class A:
-    # TODO both these overrides should emit invalid-override diagnostic
-    def __eq__(self, other: int) -> A:
-        return A()
-
-    def __ne__(self, other: int) -> A:
-        return A()
-
-# TODO: it should be `bool`, need to check arg type and fall back to `is` and `is not`
-reveal_type(A() == A())  # revealed: A
-reveal_type(A() != A())  # revealed: A
-```
-
-## Object Comparisons with Typeshed
-
-```py
-class A: ...
-
-reveal_type(A() == object())  # revealed: bool
-reveal_type(A() != object())  # revealed: bool
-reveal_type(object() == A())  # revealed: bool
-reveal_type(object() != A())  # revealed: bool
-
-# error: [unsupported-operator] "Operator `<` is not supported for types `A` and `object`"
-# revealed: Unknown
-reveal_type(A() < object())
-```
-
-## Numbers Comparison with typeshed
-
-```py
-reveal_type(1 == 1.0)  # revealed: bool
-reveal_type(1 != 1.0)  # revealed: bool
-reveal_type(1 < 1.0)  # revealed: bool
-reveal_type(1 <= 1.0)  # revealed: bool
-reveal_type(1 > 1.0)  # revealed: bool
-reveal_type(1 >= 1.0)  # revealed: bool
-
-reveal_type(1 == 2j)  # revealed: bool
-reveal_type(1 != 2j)  # revealed: bool
-
-# TODO: should be Unknown and emit diagnostic,
-# need to check arg type and should be failed
-reveal_type(1 < 2j)  # revealed: bool
-reveal_type(1 <= 2j)  # revealed: bool
-reveal_type(1 > 2j)  # revealed: bool
-reveal_type(1 >= 2j)  # revealed: bool
-
-def bool_instance() -> bool:
-    return True
-
-def int_instance() -> int:
-    return 42
-
-x = bool_instance()
-y = int_instance()
-
-reveal_type(x < y)  # revealed: bool
-reveal_type(y < x)  # revealed: bool
-reveal_type(4.2 < x)  # revealed: bool
-reveal_type(x < 4.2)  # revealed: bool
-```

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

@@ -1,29 +1,41 @@
-# Comparison: Integers
+# Comparing integers
 
 ## Integer literals
 
 ```py
-reveal_type(1 == 1 == True)  # revealed: Literal[True]
-reveal_type(1 == 1 == 2 == 4)  # revealed: Literal[False]
-reveal_type(False < True <= 2 < 3 != 6)  # revealed: Literal[True]
-reveal_type(1 < 1)  # revealed: Literal[False]
-reveal_type(1 > 1)  # revealed: Literal[False]
-reveal_type(1 is 1)  # revealed: bool
-reveal_type(1 is not 1)  # revealed: bool
-reveal_type(1 is 2)  # revealed: Literal[False]
-reveal_type(1 is not 7)  # revealed: Literal[True]
-# TODO: should be Unknown, and emit diagnostic, once we check call argument types
-reveal_type(1 <= "" and 0 < 1)  # revealed: bool
+a = 1 == 1 == True
+b = 1 == 1 == 2 == 4
+c = False < True <= 2 < 3 != 6
+d = 1 < 1
+e = 1 > 1
+f = 1 is 1
+g = 1 is not 1
+h = 1 is 2
+i = 1 is not 7
+j = 1 <= "" and 0 < 1
+
+reveal_type(a)  # revealed: Literal[True]
+reveal_type(b)  # revealed: Literal[False]
+reveal_type(c)  # revealed: Literal[True]
+reveal_type(d)  # revealed: Literal[False]
+reveal_type(e)  # revealed: Literal[False]
+reveal_type(f)  # revealed: bool
+reveal_type(g)  # revealed: bool
+reveal_type(h)  # revealed: Literal[False]
+reveal_type(i)  # revealed: Literal[True]
+reveal_type(j)  # revealed: @Todo | Literal[True]
 ```
 
 ## Integer instance
 
 ```py
 # TODO: implement lookup of `__eq__` on typeshed `int` stub.
-def int_instance() -> int:
-    return 42
+def int_instance() -> int: ...
+a = 1 == int_instance()
+b = 9 < int_instance()
+c = int_instance() < int_instance()
 
-reveal_type(1 == int_instance())  # revealed: bool
-reveal_type(9 < int_instance())  # revealed: bool
-reveal_type(int_instance() < int_instance())  # revealed: bool
+reveal_type(a)  # revealed: @Todo
+reveal_type(b)  # revealed: bool
+reveal_type(c)  # revealed: bool
 ```

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

@@ -1,155 +0,0 @@
-# Comparison: Intersections
-
-## Positive contributions
-
-If we have an intersection type `A & B` and we get a definitive true/false answer for one of the
-types, we can infer that the result for the intersection type is also true/false:
-
-```py
-class Base: ...
-
-class Child1(Base):
-    def __eq__(self, other) -> Literal[True]:
-        return True
-
-class Child2(Base): ...
-
-def get_base() -> Base: ...
-
-x = get_base()
-c1 = Child1()
-
-# Create an intersection type through narrowing:
-if isinstance(x, Child1):
-    if isinstance(x, Child2):
-        reveal_type(x)  # revealed: Child1 & Child2
-
-        reveal_type(x == 1)  # revealed: Literal[True]
-
-        # Other comparison operators fall back to the base type:
-        reveal_type(x > 1)  # revealed: bool
-        reveal_type(x is c1)  # revealed: bool
-```
-
-## Negative contributions
-
-Negative contributions to the intersection type only allow simplifications in a few special cases
-(equality and identity comparisons).
-
-### Equality comparisons
-
-#### Literal strings
-
-```py
-x = "x" * 1_000_000_000
-y = "y" * 1_000_000_000
-reveal_type(x)  # revealed: LiteralString
-
-if x != "abc":
-    reveal_type(x)  # revealed: LiteralString & ~Literal["abc"]
-
-    reveal_type(x == "abc")  # revealed: Literal[False]
-    reveal_type("abc" == x)  # revealed: Literal[False]
-    reveal_type(x == "something else")  # revealed: bool
-    reveal_type("something else" == x)  # revealed: bool
-
-    reveal_type(x != "abc")  # revealed: Literal[True]
-    reveal_type("abc" != x)  # revealed: Literal[True]
-    reveal_type(x != "something else")  # revealed: bool
-    reveal_type("something else" != x)  # revealed: bool
-
-    reveal_type(x == y)  # revealed: bool
-    reveal_type(y == x)  # revealed: bool
-    reveal_type(x != y)  # revealed: bool
-    reveal_type(y != x)  # revealed: bool
-
-    reveal_type(x >= "abc")  # revealed: bool
-    reveal_type("abc" >= x)  # revealed: bool
-
-    reveal_type(x in "abc")  # revealed: bool
-    reveal_type("abc" in x)  # revealed: bool
-```
-
-#### Integers
-
-```py
-def get_int() -> int: ...
-
-x = get_int()
-
-if x != 1:
-    reveal_type(x)  # revealed: int & ~Literal[1]
-
-    reveal_type(x != 1)  # revealed: Literal[True]
-    reveal_type(x != 2)  # revealed: bool
-
-    reveal_type(x == 1)  # revealed: Literal[False]
-    reveal_type(x == 2)  # revealed: bool
-```
-
-### Identity comparisons
-
-```py
-class A: ...
-
-def get_object() -> object: ...
-
-o = object()
-
-a = A()
-n = None
-
-if o is not None:
-    reveal_type(o)  # revealed: object & ~None
-
-    reveal_type(o is n)  # revealed: Literal[False]
-    reveal_type(o is not n)  # revealed: Literal[True]
-```
-
-## Diagnostics
-
-### Unsupported operators for positive contributions
-
-Raise an error if any of the positive contributions to the intersection type are unsupported for the
-given operator:
-
-```py
-class Container:
-    def __contains__(self, x) -> bool: ...
-
-class NonContainer: ...
-
-def get_object() -> object: ...
-
-x = get_object()
-
-if isinstance(x, Container):
-    if isinstance(x, NonContainer):
-        reveal_type(x)  # revealed: Container & NonContainer
-
-        # error: [unsupported-operator] "Operator `in` is not supported for types `int` and `NonContainer`"
-        reveal_type(2 in x)  # revealed: bool
-```
-
-### Unsupported operators for negative contributions
-
-Do *not* raise an error if any of the negative contributions to the intersection type are
-unsupported for the given operator:
-
-```py
-class Container:
-    def __contains__(self, x) -> bool: ...
-
-class NonContainer: ...
-
-def get_object() -> object: ...
-
-x = get_object()
-
-if isinstance(x, Container):
-    if not isinstance(x, NonContainer):
-        reveal_type(x)  # revealed: Container & ~NonContainer
-
-        # No error here!
-        reveal_type(2 in x)  # revealed: bool
-```

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

@@ -1,13 +1,13 @@
-# Comparison: Non boolean returns
+# Non boolean returns
 
 Walking through examples:
 
 - `a = A() < B() < C()`
 
     1. `A() < B() and B() < C()` - split in N comparison
-    1. `A()` and `B()` - evaluate outcome types
-    1. `bool` and `bool` - evaluate truthiness
-    1. `A | B` - union of "first true" types
+    1. `A()` and `B()`              - evaluate outcome types
+    1. `bool` and `bool`            - evaluate truthiness
+    1. `A | B`                    - union of "first true" types
 
 - `b = 0 < 1 < A() < 3`
 
@@ -20,22 +20,18 @@ Walking through examples:
 
 ```py
 from __future__ import annotations
-
 class A:
     def __lt__(self, other) -> A: ...
-
 class B:
     def __lt__(self, other) -> B: ...
-
 class C:
     def __lt__(self, other) -> C: ...
 
-x = A() < B() < C()
-reveal_type(x)  # revealed: A | B
+a = A() < B() < C()
+b = 0 < 1 < A() < 3
+c = 10 < 0 < A() < B() < C()
 
-y = 0 < 1 < A() < 3
-reveal_type(y)  # revealed: bool | A
-
-z = 10 < 0 < A() < B() < C()
-reveal_type(z)  # revealed: Literal[False]
+reveal_type(a)  # revealed: A | B
+reveal_type(b)  # revealed: bool | A
+reveal_type(c)  # revealed: Literal[False]
 ```

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

@@ -1,20 +1,29 @@
-# Comparison: Strings
+# Comparing strings
 
 ## String literals
 
 ```py
 def str_instance() -> str: ...
-
-reveal_type("abc" == "abc")  # revealed: Literal[True]
-reveal_type("ab_cd" <= "ab_ce")  # revealed: Literal[True]
-reveal_type("abc" in "ab cd")  # revealed: Literal[False]
-reveal_type("" not in "hello")  # revealed: Literal[False]
-reveal_type("--" is "--")  # revealed: bool
-reveal_type("A" is "B")  # revealed: Literal[False]
-reveal_type("--" is not "--")  # revealed: bool
-reveal_type("A" is not "B")  # revealed: Literal[True]
-reveal_type(str_instance() < "...")  # revealed: bool
-
+a = "abc" == "abc"
+b = "ab_cd" <= "ab_ce"
+c = "abc" in "ab cd"
+d = "" not in "hello"
+e = "--" is "--"
+f = "A" is "B"
+g = "--" is not "--"
+h = "A" is not "B"
+i = str_instance() < "..."
 # ensure we're not comparing the interned salsa symbols, which compare by order of declaration.
-reveal_type("ab" < "ab_cd")  # revealed: Literal[True]
+j = "ab" < "ab_cd"
+
+reveal_type(a)  # revealed: Literal[True]
+reveal_type(b)  # revealed: Literal[True]
+reveal_type(c)  # revealed: Literal[False]
+reveal_type(d)  # revealed: Literal[False]
+reveal_type(e)  # revealed: bool
+reveal_type(f)  # revealed: Literal[False]
+reveal_type(g)  # revealed: bool
+reveal_type(h)  # revealed: Literal[True]
+reveal_type(i)  # revealed: bool
+reveal_type(j)  # revealed: Literal[True]
 ```

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

@@ -1,4 +1,4 @@
-# Comparison: Tuples
+# Comparison - Tuples
 
 ## Heterogeneous
 
@@ -18,16 +18,16 @@ b = (1, "test", (3, 14), False)
 
 reveal_type(a == a)  # revealed: Literal[True]
 reveal_type(a != a)  # revealed: Literal[False]
-reveal_type(a < a)  # revealed: Literal[False]
+reveal_type(a < a)   # revealed: Literal[False]
 reveal_type(a <= a)  # revealed: Literal[True]
-reveal_type(a > a)  # revealed: Literal[False]
+reveal_type(a > a)   # revealed: Literal[False]
 reveal_type(a >= a)  # revealed: Literal[True]
 
 reveal_type(a == b)  # revealed: Literal[False]
 reveal_type(a != b)  # revealed: Literal[True]
-reveal_type(a < b)  # revealed: Literal[True]
+reveal_type(a < b)   # revealed: Literal[True]
 reveal_type(a <= b)  # revealed: Literal[True]
-reveal_type(a > b)  # revealed: Literal[False]
+reveal_type(a > b)   # revealed: Literal[False]
 reveal_type(a >= b)  # revealed: Literal[False]
 ```
 
@@ -39,9 +39,9 @@ b = (1, 2, 3, 4)
 
 reveal_type(a == b)  # revealed: Literal[False]
 reveal_type(a != b)  # revealed: Literal[True]
-reveal_type(a < b)  # revealed: Literal[True]
+reveal_type(a < b)   # revealed: Literal[True]
 reveal_type(a <= b)  # revealed: Literal[True]
-reveal_type(a > b)  # revealed: Literal[False]
+reveal_type(a > b)   # revealed: Literal[False]
 reveal_type(a >= b)  # revealed: Literal[False]
 
 c = ("a", "b", "c", "d")
@@ -49,9 +49,9 @@ d = ("a", "b", "c")
 
 reveal_type(c == d)  # revealed: Literal[False]
 reveal_type(c != d)  # revealed: Literal[True]
-reveal_type(c < d)  # revealed: Literal[False]
+reveal_type(c < d)   # revealed: Literal[False]
 reveal_type(c <= d)  # revealed: Literal[False]
-reveal_type(c > d)  # revealed: Literal[True]
+reveal_type(c > d)   # revealed: Literal[True]
 reveal_type(c >= d)  # revealed: Literal[True]
 ```
 
@@ -59,51 +59,51 @@ reveal_type(c >= d)  # revealed: Literal[True]
 
 ```py
 def bool_instance() -> bool: ...
-def int_instance() -> int:
-    return 42
+def int_instance() -> int: ...
 
 a = (bool_instance(),)
 b = (int_instance(),)
 
-reveal_type(a == a)  # revealed: bool
-reveal_type(a != a)  # revealed: bool
-reveal_type(a < a)  # revealed: bool
-reveal_type(a <= a)  # revealed: bool
-reveal_type(a > a)  # revealed: bool
-reveal_type(a >= a)  # revealed: bool
+# TODO: All @Todo should be `bool`
+reveal_type(a == a)  # revealed: @Todo
+reveal_type(a != a)  # revealed: @Todo
+reveal_type(a < a)   # revealed: @Todo
+reveal_type(a <= a)  # revealed: @Todo
+reveal_type(a > a)   # revealed: @Todo
+reveal_type(a >= a)  # revealed: @Todo
 
-reveal_type(a == b)  # revealed: bool
-reveal_type(a != b)  # revealed: bool
-reveal_type(a < b)  # revealed: bool
-reveal_type(a <= b)  # revealed: bool
-reveal_type(a > b)  # revealed: bool
-reveal_type(a >= b)  # revealed: bool
+reveal_type(a == b)  # revealed: @Todo
+reveal_type(a != b)  # revealed: @Todo
+reveal_type(a < b)   # revealed: @Todo
+reveal_type(a <= b)  # revealed: @Todo
+reveal_type(a > b)   # revealed: @Todo
+reveal_type(a >= b)  # revealed: @Todo
 ```
 
 #### Comparison Unsupported
 
-If two tuples contain types that do not support comparison, the result may be `Unknown`. However,
-`==` and `!=` are exceptions and can still provide definite results.
+If two tuples contain types that do not support comparison, the result may be `Unknown`.
+However, `==` and `!=` are exceptions and can still provide definite results.
 
 ```py
 a = (1, 2)
 b = (1, "hello")
 
-# TODO: should be Literal[False], once we implement (in)equality for mismatched literals
-reveal_type(a == b)  # revealed: bool
+# TODO: should be Literal[False]
+reveal_type(a == b)  # revealed: @Todo
 
-# TODO: should be Literal[True], once we implement (in)equality for mismatched literals
-reveal_type(a != b)  # revealed: bool
+# TODO: should be Literal[True]
+reveal_type(a != b)  # revealed: @Todo
 
 # TODO: should be Unknown and add more informative diagnostics
-reveal_type(a < b)  # revealed: bool
-reveal_type(a <= b)  # revealed: bool
-reveal_type(a > b)  # revealed: bool
-reveal_type(a >= b)  # revealed: bool
+reveal_type(a < b)   # revealed: @Todo
+reveal_type(a <= b)  # revealed: @Todo
+reveal_type(a > b)   # revealed: @Todo
+reveal_type(a >= b)  # revealed: @Todo
 ```
 
-However, if the lexicographic comparison completes without reaching a point where str and int are
-compared, Python will still produce a result based on the prior elements.
+However, if the lexicographic comparison completes without reaching a point where str and int are compared,
+Python will still produce a result based on the prior elements.
 
 ```py path=short_circuit.py
 a = (1, 2)
@@ -111,9 +111,9 @@ b = (999999, "hello")
 
 reveal_type(a == b)  # revealed: Literal[False]
 reveal_type(a != b)  # revealed: Literal[True]
-reveal_type(a < b)  # revealed: Literal[True]
+reveal_type(a < b)   # revealed: Literal[True]
 reveal_type(a <= b)  # revealed: Literal[True]
-reveal_type(a > b)  # revealed: Literal[False]
+reveal_type(a > b)   # revealed: Literal[False]
 reveal_type(a >= b)  # revealed: Literal[False]
 ```
 
@@ -126,16 +126,16 @@ c = (b, b, b)
 
 reveal_type(c == c)  # revealed: Literal[True]
 reveal_type(c != c)  # revealed: Literal[False]
-reveal_type(c < c)  # revealed: Literal[False]
+reveal_type(c < c)   # revealed: Literal[False]
 reveal_type(c <= c)  # revealed: Literal[True]
-reveal_type(c > c)  # revealed: Literal[False]
+reveal_type(c > c)   # revealed: Literal[False]
 reveal_type(c >= c)  # revealed: Literal[True]
 ```
 
 #### Non Boolean Rich Comparisons
 
 ```py
-class A:
+class A():
     def __eq__(self, o) -> str: ...
     def __ne__(self, o) -> int: ...
     def __lt__(self, o) -> float: ...
@@ -145,12 +145,13 @@ class A:
 
 a = (A(), A())
 
-reveal_type(a == a)  # revealed: bool
-reveal_type(a != a)  # revealed: bool
-reveal_type(a < a)  # revealed: bool
-reveal_type(a <= a)  # revealed: bool
-reveal_type(a > a)  # revealed: bool
-reveal_type(a >= a)  # revealed: bool
+# TODO: All @Todo should be bool
+reveal_type(a == a)  # revealed: @Todo
+reveal_type(a != a)  # revealed: @Todo
+reveal_type(a < a)   # revealed: @Todo
+reveal_type(a <= a)  # revealed: @Todo
+reveal_type(a > a)   # revealed: @Todo
+reveal_type(a >= a)  # revealed: @Todo
 ```
 
 ### Membership Test Comparisons
@@ -158,8 +159,7 @@ reveal_type(a >= a)  # revealed: bool
 "Membership Test Comparisons" refers to the operators `in` and `not in`.
 
 ```py
-def int_instance() -> int:
-    return 42
+def int_instance() -> int: ...
 
 a = (1, 2)
 b = ((3, 4), (1, 2))
@@ -172,8 +172,9 @@ reveal_type(a not in b)  # revealed: Literal[False]
 reveal_type(a in c)  # revealed: Literal[False]
 reveal_type(a not in c)  # revealed: Literal[True]
 
-reveal_type(a in d)  # revealed: bool
-reveal_type(a not in d)  # revealed: bool
+# TODO: All @Todo should be bool
+reveal_type(a in d)  # revealed: @Todo
+reveal_type(a not in d)  # revealed: @Todo
 ```
 
 ### Identity Comparisons
@@ -188,10 +189,10 @@ c = (1, 2, 3)
 reveal_type(a is (1, 2))  # revealed: bool
 reveal_type(a is not (1, 2))  # revealed: bool
 
-# TODO should be Literal[False] once we implement comparison of mismatched literal types
-reveal_type(a is b)  # revealed: bool
-# TODO should be Literal[True] once we implement comparison of mismatched literal types
-reveal_type(a is not b)  # revealed: bool
+# TODO: Update to Literal[False] once str == int comparison is implemented
+reveal_type(a is b)  # revealed: @Todo
+# TODO: Update to Literal[True] once str == int comparison is implemented
+reveal_type(a is not b)  # revealed: @Todo
 
 reveal_type(a is c)  # revealed: Literal[False]
 reveal_type(a is not c)  # revealed: Literal[True]

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

@@ -1,88 +0,0 @@
-# Comparison: Unions
-
-## Union on one side of the comparison
-
-Comparisons on union types need to consider all possible cases:
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-one_or_two = 1 if flag else 2
-
-reveal_type(one_or_two <= 2)  # revealed: Literal[True]
-reveal_type(one_or_two <= 1)  # revealed: bool
-reveal_type(one_or_two <= 0)  # revealed: Literal[False]
-
-reveal_type(2 >= one_or_two)  # revealed: Literal[True]
-reveal_type(1 >= one_or_two)  # revealed: bool
-reveal_type(0 >= one_or_two)  # revealed: Literal[False]
-
-reveal_type(one_or_two < 1)  # revealed: Literal[False]
-reveal_type(one_or_two < 2)  # revealed: bool
-reveal_type(one_or_two < 3)  # revealed: Literal[True]
-
-reveal_type(one_or_two > 0)  # revealed: Literal[True]
-reveal_type(one_or_two > 1)  # revealed: bool
-reveal_type(one_or_two > 2)  # revealed: Literal[False]
-
-reveal_type(one_or_two == 3)  # revealed: Literal[False]
-reveal_type(one_or_two == 1)  # revealed: bool
-
-reveal_type(one_or_two != 3)  # revealed: Literal[True]
-reveal_type(one_or_two != 1)  # revealed: bool
-
-a_or_ab = "a" if flag else "ab"
-
-reveal_type(a_or_ab in "ab")  # revealed: Literal[True]
-reveal_type("a" in a_or_ab)  # revealed: Literal[True]
-
-reveal_type("c" not in a_or_ab)  # revealed: Literal[True]
-reveal_type("a" not in a_or_ab)  # revealed: Literal[False]
-
-reveal_type("b" in a_or_ab)  # revealed: bool
-reveal_type("b" not in a_or_ab)  # revealed: bool
-
-one_or_none = 1 if flag else None
-
-reveal_type(one_or_none is None)  # revealed: bool
-reveal_type(one_or_none is not None)  # revealed: bool
-```
-
-## Union on both sides of the comparison
-
-With unions on both sides, we need to consider the full cross product of options when building the
-resulting (union) type:
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag_s, flag_l = bool_instance(), bool_instance()
-small = 1 if flag_s else 2
-large = 2 if flag_l else 3
-
-reveal_type(small <= large)  # revealed: Literal[True]
-reveal_type(small >= large)  # revealed: bool
-
-reveal_type(small < large)  # revealed: bool
-reveal_type(small > large)  # revealed: Literal[False]
-```
-
-## Unsupported operations
-
-Make sure we emit a diagnostic if *any* of the possible comparisons is unsupported. For now, we fall
-back to `bool` for the result type instead of trying to infer something more precise from the other
-(supported) variants:
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-x = [1, 2] if flag else 1
-
-result = 1 in x  # error: "Operator `in` is not supported"
-reveal_type(result)  # revealed: bool
-```

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

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

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

@@ -3,10 +3,6 @@
 ## Simple if-expression
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 x = 1 if flag else 2
 reveal_type(x)  # revealed: Literal[1, 2]
 ```
@@ -14,25 +10,19 @@ reveal_type(x)  # revealed: Literal[1, 2]
 ## If-expression with walrus operator
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 y = 0
 z = 0
 x = (y := 1) if flag else (z := 2)
+a = y
+b = z
 reveal_type(x)  # revealed: Literal[1, 2]
-reveal_type(y)  # revealed: Literal[0, 1]
-reveal_type(z)  # revealed: Literal[0, 2]
+reveal_type(a)  # revealed: Literal[0, 1]
+reveal_type(b)  # revealed: Literal[0, 2]
 ```
 
 ## Nested if-expression
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
 x = 1 if flag else 2 if flag2 else 3
 reveal_type(x)  # revealed: Literal[1, 2, 3]
 ```
@@ -40,10 +30,6 @@ reveal_type(x)  # revealed: Literal[1, 2, 3]
 ## None
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 x = 1 if flag else None
 reveal_type(x)  # revealed: Literal[1] | None
 ```

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

@@ -3,26 +3,20 @@
 ## Simple if
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 y = 1
 y = 2
 
 if flag:
     y = 3
 
-reveal_type(y)  # revealed: Literal[2, 3]
+x = y
+
+reveal_type(x)  # revealed: Literal[2, 3]
 ```
 
 ## Simple if-elif-else
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
 y = 1
 y = 2
 if flag:
@@ -36,24 +30,13 @@ else:
 x = y
 
 reveal_type(x)  # revealed: Literal[3, 4, 5]
-
-# revealed: Literal[2]
-# error: [possibly-unresolved-reference]
-reveal_type(r)
-
-# revealed: Literal[5]
-# error: [possibly-unresolved-reference]
-reveal_type(s)
+reveal_type(r)  # revealed: Unbound | Literal[2]
+reveal_type(s)  # revealed: Unbound | Literal[5]
 ```
 
 ## Single symbol across if-elif-else
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-
 if flag:
     y = 1
 elif flag2:
@@ -66,10 +49,6 @@ reveal_type(y)  # revealed: Literal[1, 2, 3]
 ## if-elif-else without else assignment
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
 y = 0
 if flag:
     y = 1
@@ -83,10 +62,6 @@ reveal_type(y)  # revealed: Literal[0, 1, 2]
 ## if-elif-else with intervening assignment
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
 y = 0
 if flag:
     y = 1
@@ -101,10 +76,6 @@ reveal_type(y)  # revealed: Literal[0, 1, 2]
 ## Nested if statement
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
 y = 0
 if flag:
     if flag2:
@@ -115,16 +86,13 @@ reveal_type(y)  # revealed: Literal[0, 1]
 ## if-elif without else
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
 y = 1
 y = 2
 if flag:
     y = 3
 elif flag2:
     y = 4
+x = y
 
-reveal_type(y)  # revealed: Literal[2, 3, 4]
+reveal_type(x)  # revealed: Literal[2, 3, 4]
 ```

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

@@ -21,9 +21,7 @@ match 0:
     case 2:
         y = 3
 
-# revealed: Literal[2, 3]
-# error: [possibly-unresolved-reference]
-reveal_type(y)
+reveal_type(y)  # revealed: Unbound | Literal[2, 3]
 ```
 
 ## Basic match

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

@@ -10,10 +10,6 @@ x: str  # error: [invalid-declaration] "Cannot declare type `str` for inferred t
 ## Incompatible declarations
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 if flag:
     x: str
 else:
@@ -24,10 +20,6 @@ x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`:
 ## Partial declarations
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 if flag:
     x: int
 x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: Unknown, int"
@@ -36,10 +28,6 @@ x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`:
 ## Incompatible declarations with bad assignment
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 if flag:
     x: str
 else:
@@ -47,5 +35,5 @@ else:
 
 # error: [conflicting-declarations]
 # error: [invalid-assignment]
-x = b"foo"
+x = b'foo'
 ```

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

@@ -4,9 +4,8 @@
 
 ```py
 import re
-
 try:
-    help()
+    x
 except NameError as e:
     reveal_type(e)  # revealed: NameError
 except re.error as f:
@@ -16,10 +15,10 @@ except re.error as f:
 ## Unknown type in except handler does not cause spurious diagnostic
 
 ```py
-from nonexistent_module import foo  # error: [unresolved-import]
+from nonexistent_module import foo # error: [unresolved-import]
 
 try:
-    help()
+    x
 except foo as e:
     reveal_type(foo)  # revealed: Unknown
     reveal_type(e)  # revealed: Unknown
@@ -31,7 +30,7 @@ except foo as e:
 EXCEPTIONS = (AttributeError, TypeError)
 
 try:
-    help()
+    x
 except (RuntimeError, OSError) as e:
     reveal_type(e)  # revealed: RuntimeError | OSError
 except EXCEPTIONS as f:
@@ -41,14 +40,9 @@ except EXCEPTIONS as f:
 ## Dynamic exception types
 
 ```py
-# TODO: we should not emit these `call-possibly-unbound-method` errors for `tuple.__class_getitem__`
-def foo(
-    x: type[AttributeError],
-    y: tuple[type[OSError], type[RuntimeError]],  # error: [call-possibly-unbound-method]
-    z: tuple[type[BaseException], ...],  # error: [call-possibly-unbound-method]
-):
+def foo(x: type[AttributeError], y: tuple[type[OSError], type[RuntimeError]], z: tuple[type[BaseException], ...]):
     try:
-        help()
+        w
     except x as e:
         # TODO: should be `AttributeError`
         reveal_type(e)  # revealed: @Todo

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

@@ -1,37 +1,44 @@
 # Control flow for exception handlers
 
-These tests assert that we understand the possible "definition states" (which symbols might or might
-not be defined) in the various branches of a `try`/`except`/`else`/`finally` block.
+These tests assert that we understand the possible "definition states" (which
+symbols might or might not be defined) in the various branches of a
+`try`/`except`/`else`/`finally` block.
 
-For a full writeup on the semantics of exception handlers, see [this document][1].
+For a full writeup on the semantics of exception handlers,
+see [this document][1].
 
-The tests throughout this Markdown document use functions with names starting with `could_raise_*`
-to mark definitions that might or might not succeed (as the function could raise an exception). A
-type checker must assume that any arbitrary function call could raise an exception in Python; this
-is just a naming convention used in these tests for clarity, and to future-proof the tests against
-possible future improvements whereby certain statements or expressions could potentially be inferred
-as being incapable of causing an exception to be raised.
+The tests throughout this Markdown document use functions with names starting
+with `could_raise_*` to mark definitions that might or might not succeed
+(as the function could raise an exception). A type checker must assume that any
+arbitrary function call could raise an exception in Python; this is just a
+naming convention used in these tests for clarity, and to future-proof the
+tests against possible future improvements whereby certain statements or
+expressions could potentially be inferred as being incapable of causing an
+exception to be raised.
 
 ## A single bare `except`
 
-Consider the following `try`/`except` block, with a single bare `except:`. There are different types
-for the variable `x` in the two branches of this block, and we can't determine which branch might
-have been taken from the perspective of code following this block. The inferred type after the
-block's conclusion is therefore the union of the type at the end of the `try` suite (`str`) and the
-type at the end of the `except` suite (`Literal[2]`).
+Consider the following `try`/`except` block, with a single bare `except:`.
+There are different types for the variable `x` in the two branches of this
+block, and we can't determine which branch might have been taken from the
+perspective of code following this block. The inferred type after the block's
+conclusion is therefore the union of the type at the end of the `try` suite
+(`str`) and the type at the end of the `except` suite (`Literal[2]`).
 
-*Within* the `except` suite, we must infer a union of all possible "definition states" we could have
-been in at any point during the `try` suite. This is because control flow could have jumped to the
-`except` suite without any of the `try`-suite definitions successfully completing, with only *some*
-of the `try`-suite definitions successfully completing, or indeed with *all* of them successfully
-completing. The type of `x` at the beginning of the `except` suite in this example is therefore
-`Literal[1] | str`, taking into account that we might have jumped to the `except` suite before the
-`x = could_raise_returns_str()` redefinition, but we *also* could have jumped to the `except` suite
-*after* that redefinition.
+*Within* the `except` suite, we must infer a union of all possible "definition
+states" we could have been in at any point during the `try` suite. This is
+because control flow could have jumped to the `except` suite without any of the
+`try`-suite definitions successfully completing, with only *some* of the
+`try`-suite definitions successfully completing, or indeed with *all* of them
+successfully completing. The type of `x` at the beginning of the `except` suite
+in this example is therefore `Literal[1] | str`, taking into account that we
+might have jumped to the `except` suite before the
+`x = could_raise_returns_str()` redefinition, but we *also* could have jumped
+to the `except` suite *after* that redefinition.
 
 ```py path=union_type_inferred.py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 x = 1
 
@@ -47,12 +54,13 @@ except:
 reveal_type(x)  # revealed: str | Literal[2]
 ```
 
-If `x` has the same type at the end of both branches, however, the branches unify and `x` is not
-inferred as having a union type following the `try`/`except` block:
+If `x` has the same type at the end of both branches, however, the branches
+unify and `x` is not inferred as having a union type following the
+`try`/`except` block:
 
 ```py path=branches_unify_to_non_union_type.py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 x = 1
 
@@ -66,16 +74,17 @@ reveal_type(x)  # revealed: str
 
 ## A non-bare `except`
 
-For simple `try`/`except` blocks, an `except TypeError:` handler has the same control flow semantics
-as an `except:` handler. An `except TypeError:` handler will not catch *all* exceptions: if this is
-the only handler, it opens up the possibility that an exception might occur that would not be
-handled. However, as described in [the document on exception-handling semantics][1], that would lead
-to termination of the scope. It's therefore irrelevant to consider this possibility when it comes to
-control-flow analysis.
+For simple `try`/`except` blocks, an `except TypeError:` handler has the same
+control flow semantics as an `except:` handler. An `except TypeError:` handler
+will not catch *all* exceptions: if this is the only handler, it opens up the
+possibility that an exception might occur that would not be handled. However,
+as described in [the document on exception-handling semantics][1], that would
+lead to termination of the scope. It's therefore irrelevant to consider this
+possibility when it comes to control-flow analysis.
 
 ```py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 x = 1
 
@@ -93,9 +102,11 @@ reveal_type(x)  # revealed: str | Literal[2]
 
 ## Multiple `except` branches
 
-If the scope reaches the final `reveal_type` call in this example, either the `try`-block suite of
-statements was executed in its entirety, or exactly one `except` suite was executed in its entirety.
-The inferred type of `x` at this point is the union of the types at the end of the three suites:
+If the scope reaches the final `reveal_type` call in this example,
+either the `try`-block suite of statements was executed in its entirety,
+or exactly one `except` suite was executed in its entirety.
+The inferred type of `x` at this point is the union of the types at the end of
+the three suites:
 
 - At the end of `try`, `type(x) == str`
 - At the end of `except TypeError`, `x == 2`
@@ -103,7 +114,7 @@ The inferred type of `x` at this point is the union of the types at the end of t
 
 ```py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 x = 1
 
@@ -125,17 +136,18 @@ reveal_type(x)  # revealed: str | Literal[2, 3]
 
 ## Exception handlers with `else` branches (but no `finally`)
 
-If we reach the `reveal_type` call at the end of this scope, either the `try` and `else` suites were
-both executed in their entireties, or the `except` suite was executed in its entirety. The type of
-`x` at this point is the union of the type at the end of the `else` suite and the type at the end of
-the `except` suite:
+If we reach the `reveal_type` call at the end of this scope,
+either the `try` and `else` suites were both executed in their entireties,
+or the `except` suite was executed in its entirety. The type of `x` at this
+point is the union of the type at the end of the `else` suite and the type at
+the end of the `except` suite:
 
 - At the end of `else`, `x == 3`
 - At the end of `except`, `x == 2`
 
 ```py path=single_except.py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 x = 1
 
@@ -155,14 +167,15 @@ else:
 reveal_type(x)  # revealed: Literal[2, 3]
 ```
 
-For a block that has multiple `except` branches and an `else` branch, the same principle applies. In
-order to reach the final `reveal_type` call, either exactly one of the `except` suites must have
-been executed in its entirety, or the `try` suite and the `else` suite must both have been executed
+For a block that has multiple `except` branches and an `else` branch, the same
+principle applies. In order to reach the final `reveal_type` call,
+either exactly one of the `except` suites must have been executed in its
+entirety, or the `try` suite and the `else` suite must both have been executed
 in their entireties:
 
 ```py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 x = 1
 
@@ -188,13 +201,14 @@ reveal_type(x)  # revealed: Literal[2, 3, 4]
 
 ## Exception handlers with `finally` branches (but no `except` branches)
 
-A `finally` suite is *always* executed. As such, if we reach the `reveal_type` call at the end of
-this example, we know that `x` *must* have been reassigned to `2` during the `finally` suite. The
-type of `x` at the end of the example is therefore `Literal[2]`:
+A `finally` suite is *always* executed. As such, if we reach the `reveal_type`
+call at the end of this example, we know that `x` *must* have been reassigned
+to `2` during the `finally` suite. The type of `x` at the end of the example is
+therefore `Literal[2]`:
 
 ```py path=redef_in_finally.py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 x = 1
 
@@ -209,17 +223,19 @@ finally:
 reveal_type(x)  # revealed: Literal[2]
 ```
 
-If `x` was *not* redefined in the `finally` suite, however, things are somewhat more complicated. If
-we reach the final `reveal_type` call, unlike the state when we're visiting the `finally` suite, we
-know that the `try`-block suite ran to completion. This means that there are fewer possible states
-at this point than there were when we were inside the `finally` block.
+If `x` was *not* redefined in the `finally` suite, however, things are somewhat
+more complicated. If we reach the final `reveal_type` call,
+unlike the state when we're visiting the `finally` suite,
+we know that the `try`-block suite ran to completion.
+This means that there are fewer possible states at this point than there were
+when we were inside the `finally` block.
 
-(Our current model does *not* correctly infer the types *inside* `finally` suites, however; this is
-still a TODO item for us.)
+(Our current model does *not* correctly infer the types *inside* `finally`
+suites, however; this is still a TODO item for us.)
 
 ```py path=no_redef_in_finally.py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 x = 1
 
@@ -236,25 +252,25 @@ reveal_type(x)  # revealed: str
 
 ## Combining an `except` branch with a `finally` branch
 
-As previously stated, we do not yet have accurate inference for types *inside* `finally` suites.
-When we do, however, we will have to take account of the following possibilities inside `finally`
-suites:
+As previously stated, we do not yet have accurate inference for types *inside*
+`finally` suites. When we do, however, we will have to take account of the
+following possibilities inside `finally` suites:
 
 - The `try` suite could have run to completion
-- Or we could have jumped from halfway through the `try` suite to an `except` suite, and the
-    `except` suite ran to completion
-- Or we could have jumped from halfway through the `try` suite straight to the `finally` suite due
-    to an unhandled exception
-- Or we could have jumped from halfway through the `try` suite to an `except` suite, only for an
-    exception raised in the `except` suite to cause us to jump to the `finally` suite before the
-    `except` suite ran to completion
+- Or we could have jumped from halfway through the `try` suite to an `except`
+    suite, and the `except` suite ran to completion
+- Or we could have jumped from halfway through the `try` suite straight to the
+    `finally` suite due to an unhandled exception
+- Or we could have jumped from halfway through the `try` suite to an
+    `except` suite, only for an exception raised in the `except` suite to cause
+    us to jump to the `finally` suite before the `except` suite ran to completion
 
 ```py path=redef_in_finally.py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 def could_raise_returns_bytes() -> bytes:
-    return b"foo"
+    return b'foo'
 
 def could_raise_returns_bool() -> bool:
     return True
@@ -280,18 +296,19 @@ finally:
 reveal_type(x)  # revealed: Literal[2]
 ```
 
-Now for an example without a redefinition in the `finally` suite. As before, there *should* be fewer
-possibilities after completion of the `finally` suite than there were during the `finally` suite
-itself. (In some control-flow possibilities, some exceptions were merely *suspended* during the
-`finally` suite; these lead to the scope's termination following the conclusion of the `finally`
-suite.)
+Now for an example without a redefinition in the `finally` suite.
+As before, there *should* be fewer possibilities after completion of the
+`finally` suite than there were during the `finally` suite itself.
+(In some control-flow possibilities, some exceptions were merely *suspended*
+during the `finally` suite; these lead to the scope's termination following the
+conclusion of the `finally` suite.)
 
 ```py path=no_redef_in_finally.py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 def could_raise_returns_bytes() -> bytes:
-    return b"foo"
+    return b'foo'
 
 def could_raise_returns_bool() -> bool:
     return True
@@ -319,10 +336,10 @@ An example with multiple `except` branches and a `finally` branch:
 
 ```py path=multiple_except_branches.py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 def could_raise_returns_bytes() -> bytes:
-    return b"foo"
+    return b'foo'
 
 def could_raise_returns_bool() -> bool:
     return True
@@ -360,16 +377,16 @@ reveal_type(x)  # revealed: str | bool | float
 
 ## Combining `except`, `else` and `finally` branches
 
-If the exception handler has an `else` branch, we must also take into account the possibility that
-control flow could have jumped to the `finally` suite from partway through the `else` suite due to
-an exception raised *there*.
+If the exception handler has an `else` branch, we must also take into account
+the possibility that control flow could have jumped to the `finally` suite from
+partway through the `else` suite due to an exception raised *there*.
 
 ```py path=single_except_branch.py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 def could_raise_returns_bytes() -> bytes:
-    return b"foo"
+    return b'foo'
 
 def could_raise_returns_bool() -> bool:
     return True
@@ -409,10 +426,10 @@ The same again, this time with multiple `except` branches:
 
 ```py path=multiple_except_branches.py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 def could_raise_returns_bytes() -> bytes:
-    return b"foo"
+    return b'foo'
 
 def could_raise_returns_bool() -> bool:
     return True
@@ -462,20 +479,22 @@ reveal_type(x)  # revealed: bool | float | slice
 
 ## Nested `try`/`except` blocks
 
-It would take advanced analysis, which we are not yet capable of, to be able to determine that an
-exception handler always suppresses all exceptions. This is partly because it is possible for
-statements in `except`, `else` and `finally` suites to raise exceptions as well as statements in
-`try` suites. This means that if an exception handler is nested inside the `try` statement of an
-enclosing exception handler, it should (at least for now) be treated the same as any other node: as
-a suite containing statements that could possibly raise exceptions, which would lead to control flow
-jumping out of that suite prior to the suite running to completion.
+It would take advanced analysis, which we are not yet capable of, to be able
+to determine that an exception handler always suppresses all exceptions. This
+is partly because it is possible for statements in `except`, `else` and
+`finally` suites to raise exceptions as well as statements in `try` suites.
+This means that if an exception handler is nested inside the `try` statement of
+an enclosing exception handler, it should (at least for now) be treated the
+same as any other node: as a suite containing statements that could possibly
+raise exceptions, which would lead to control flow jumping out of that suite
+prior to the suite running to completion.
 
 ```py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 def could_raise_returns_bytes() -> bytes:
-    return b"foo"
+    return b'foo'
 
 def could_raise_returns_bool() -> bool:
     return True
@@ -561,15 +580,15 @@ reveal_type(x)  # revealed: bytearray | Bar
 
 ## Nested scopes inside `try` blocks
 
-Shadowing a variable in an inner scope has no effect on type inference of the variable by that name
-in the outer scope:
+Shadowing a variable in an inner scope has no effect on type inference of the
+variable by that name in the outer scope:
 
 ```py
 def could_raise_returns_str() -> str:
-    return "foo"
+    return 'foo'
 
 def could_raise_returns_bytes() -> bytes:
-    return b"foo"
+    return b'foo'
 
 def could_raise_returns_range() -> range:
     return range(42)
@@ -583,7 +602,6 @@ def could_raise_returns_float() -> float:
 x = 1
 
 try:
-
     def foo(param=could_raise_returns_str()):
         x = could_raise_returns_str()
 
@@ -601,6 +619,7 @@ try:
             # TODO: should be `str | bytes | bytearray | float`
             reveal_type(x)  # revealed: bytes | float
         reveal_type(x)  # revealed: bytes | float
+
     x = foo
     reveal_type(x)  # revealed: Literal[foo]
 except:

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

@@ -4,7 +4,7 @@
 
 ```py
 try:
-    help()
+    x
 except* BaseException as e:
     reveal_type(e)  # revealed: BaseExceptionGroup
 ```
@@ -13,7 +13,7 @@ except* BaseException as e:
 
 ```py
 try:
-    help()
+    x
 except* OSError as e:
     # TODO(Alex): more precise would be `ExceptionGroup[OSError]`
     reveal_type(e)  # revealed: BaseExceptionGroup
@@ -23,8 +23,8 @@ except* OSError as e:
 
 ```py
 try:
-    help()
+    x
 except* (TypeError, AttributeError) as e:
-    # TODO(Alex): more precise would be `ExceptionGroup[TypeError | AttributeError]`.
+    #TODO(Alex): more precise would be `ExceptionGroup[TypeError | AttributeError]`.
     reveal_type(e)  # revealed: BaseExceptionGroup
 ```

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

@@ -1,13 +0,0 @@
-# Exception Handling
-
-## Invalid syntax
-
-```py
-from typing_extensions import reveal_type
-
-try:
-    print
-except as e:  # error: [invalid-syntax]
-    reveal_type(e)  # revealed: Unknown
-
-```

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

@@ -6,14 +6,23 @@
 def foo() -> str:
     pass
 
-reveal_type(True or False)  # revealed: Literal[True]
-reveal_type("x" or "y" or "z")  # revealed: Literal["x"]
-reveal_type("" or "y" or "z")  # revealed: Literal["y"]
-reveal_type(False or "z")  # revealed: Literal["z"]
-reveal_type(False or True)  # revealed: Literal[True]
-reveal_type(False or False)  # revealed: Literal[False]
-reveal_type(foo() or False)  # revealed: str | Literal[False]
-reveal_type(foo() or True)  # revealed: str | Literal[True]
+a = True or False
+b = 'x' or 'y' or 'z'
+c = '' or 'y' or 'z'
+d = False or 'z'
+e = False or True
+f = False or False
+g = foo() or False
+h = foo() or True
+
+reveal_type(a)  # revealed: Literal[True]
+reveal_type(b)  # revealed: Literal["x"]
+reveal_type(c)  # revealed: Literal["y"]
+reveal_type(d)  # revealed: Literal["z"]
+reveal_type(e)  # revealed: Literal[True]
+reveal_type(f)  # revealed: Literal[False]
+reveal_type(g)  # revealed: str | Literal[False]
+reveal_type(h)  # revealed: str | Literal[True]
 ```
 
 ## AND
@@ -22,13 +31,21 @@ reveal_type(foo() or True)  # revealed: str | Literal[True]
 def foo() -> str:
     pass
 
-reveal_type(True and False)  # revealed: Literal[False]
-reveal_type(False and True)  # revealed: Literal[False]
-reveal_type(foo() and False)  # revealed: str | Literal[False]
-reveal_type(foo() and True)  # revealed: str | Literal[True]
-reveal_type("x" and "y" and "z")  # revealed: Literal["z"]
-reveal_type("x" and "y" and "")  # revealed: Literal[""]
-reveal_type("" and "y")  # revealed: Literal[""]
+a = True and False
+b = False and True
+c = foo() and False
+d = foo() and True
+e = 'x' and 'y' and 'z'
+f = 'x' and 'y' and ''
+g = '' and 'y'
+
+reveal_type(a)  # revealed: Literal[False]
+reveal_type(b)  # revealed: Literal[False]
+reveal_type(c)  # revealed: str | Literal[False]
+reveal_type(d)  # revealed: str | Literal[True]
+reveal_type(e)  # revealed: Literal["z"]
+reveal_type(f)  # revealed: Literal[""]
+reveal_type(g)  # revealed: Literal[""]
 ```
 
 ## Simple function calls to bool
@@ -51,12 +68,19 @@ reveal_type(x)  # revealed: bool
 def foo() -> str:
     pass
 
-reveal_type("x" and "y" or "z")  # revealed: Literal["y"]
-reveal_type("x" or "y" and "z")  # revealed: Literal["x"]
-reveal_type("" and "y" or "z")  # revealed: Literal["z"]
-reveal_type("" or "y" and "z")  # revealed: Literal["z"]
-reveal_type("x" and "y" or "")  # revealed: Literal["y"]
-reveal_type("x" or "y" and "")  # revealed: Literal["x"]
+a = "x" and "y" or "z"
+b = "x" or "y" and "z"
+c = "" and "y" or "z"
+d = "" or "y" and "z"
+e = "x" and "y" or ""
+f = "x" or "y" and ""
+
+reveal_type(a)  # revealed: Literal["y"]
+reveal_type(b)  # revealed: Literal["x"]
+reveal_type(c)  # revealed: Literal["z"]
+reveal_type(d)  # revealed: Literal["z"]
+reveal_type(e)  # revealed: Literal["y"]
+reveal_type(f)  # revealed: Literal["x"]
 ```
 
 ## `bool()` function
@@ -66,45 +90,62 @@ reveal_type("x" or "y" and "")  # revealed: Literal["x"]
 ```py path=a.py
 redefined_builtin_bool = bool
 
-def my_bool(x) -> bool:
-    return True
+def my_bool(x)-> bool: pass
 ```
 
 ```py
 from a import redefined_builtin_bool, my_bool
+a = redefined_builtin_bool(0)
+b = my_bool(0)
 
-reveal_type(redefined_builtin_bool(0))  # revealed: Literal[False]
-reveal_type(my_bool(0))  # revealed: bool
+reveal_type(a)  # revealed: Literal[False]
+reveal_type(b)  # revealed: bool
 ```
 
 ## Truthy values
 
 ```py
-reveal_type(bool(1))  # revealed: Literal[True]
-reveal_type(bool((0,)))  # revealed: Literal[True]
-reveal_type(bool("NON EMPTY"))  # revealed: Literal[True]
-reveal_type(bool(True))  # revealed: Literal[True]
+a = bool(1)
+b = bool((0,))
+c = bool("NON EMPTY")
+d = bool(True)
 
-def foo(): ...
+def foo(): pass
+e = bool(foo)
 
-reveal_type(bool(foo))  # revealed: Literal[True]
+reveal_type(a)  # revealed: Literal[True]
+reveal_type(b)  # revealed: Literal[True]
+reveal_type(c)  # revealed: Literal[True]
+reveal_type(d)  # revealed: Literal[True]
+reveal_type(e)  # revealed: Literal[True]
 ```
 
 ## Falsy values
 
 ```py
-reveal_type(bool(0))  # revealed: Literal[False]
-reveal_type(bool(()))  # revealed: Literal[False]
-reveal_type(bool(None))  # revealed: Literal[False]
-reveal_type(bool(""))  # revealed: Literal[False]
-reveal_type(bool(False))  # revealed: Literal[False]
-reveal_type(bool())  # revealed: Literal[False]
+a = bool(0)
+b = bool(())
+c = bool(None)
+d = bool("")
+e = bool(False)
+f = bool()
+
+reveal_type(a)  # revealed: Literal[False]
+reveal_type(b)  # revealed: Literal[False]
+reveal_type(c)  # revealed: Literal[False]
+reveal_type(d)  # revealed: Literal[False]
+reveal_type(e)  # revealed: Literal[False]
+reveal_type(f)  # revealed: Literal[False]
 ```
 
 ## Ambiguous values
 
 ```py
-reveal_type(bool([]))  # revealed: bool
-reveal_type(bool({}))  # revealed: bool
-reveal_type(bool(set()))  # revealed: bool
+a = bool([])
+b = bool({})
+c = bool(set())
+
+reveal_type(a)  # revealed: bool
+reveal_type(b)  # revealed: bool
+reveal_type(c)  # revealed: bool
 ```

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

@@ -1,24 +0,0 @@
-# If expression
-
-## Union
-
-```py
-def bool_instance() -> bool:
-    return True
-
-reveal_type(1 if bool_instance() else 2)  # revealed: Literal[1, 2]
-```
-
-## Statically known branches
-
-```py
-reveal_type(1 if True else 2)  # revealed: Literal[1]
-reveal_type(1 if "not empty" else 2)  # revealed: Literal[1]
-reveal_type(1 if (1,) else 2)  # revealed: Literal[1]
-reveal_type(1 if 1 else 2)  # revealed: Literal[1]
-
-reveal_type(1 if False else 2)  # revealed: Literal[2]
-reveal_type(1 if None else 2)  # revealed: Literal[2]
-reveal_type(1 if "" else 2)  # revealed: Literal[2]
-reveal_type(1 if 0 else 2)  # revealed: Literal[2]
-```

crates/red_knot_python_semantic/resources/mdtest/generics.md

@@ -1,68 +0,0 @@
-# PEP 695 Generics
-
-## Class Declarations
-
-Basic PEP 695 generics
-
-```py
-class MyBox[T]:
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
-    data: T
-    box_model_number = 695
-
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
-    def __init__(self, data: T):
-        self.data = data
-
-box: MyBox[int] = MyBox(5)
-
-# TODO should emit a diagnostic here (str is not assignable to int)
-wrong_innards: MyBox[int] = MyBox("five")
-
-# TODO reveal int
-reveal_type(box.data)  # revealed: @Todo
-
-reveal_type(MyBox.box_model_number)  # revealed: Literal[695]
-```
-
-## Subclassing
-
-```py
-class MyBox[T]:
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
-    data: T
-
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
-    def __init__(self, data: T):
-        self.data = data
-
-# TODO not error on the subscripting or the use of type param
-# error: [unresolved-reference] "Name `T` used when not defined"
-# error: [non-subscriptable]
-class MySecureBox[T](MyBox[T]): ...
-
-secure_box: MySecureBox[int] = MySecureBox(5)
-reveal_type(secure_box)  # revealed: MySecureBox
-# TODO reveal int
-reveal_type(secure_box.data)  # revealed: @Todo
-```
-
-## Cyclical class definition
-
-In type stubs, classes can reference themselves in their base class definitions. For example, in
-`typeshed`, we have `class str(Sequence[str]): ...`.
-
-This should hold true even with generics at play.
-
-```py path=a.pyi
-class Seq[T]: ...
-
-# TODO not error on the subscripting
-class S[T](Seq[S]): ...  # error: [non-subscriptable]
-
-reveal_type(S)  # revealed: Literal[S]
-```

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

@@ -3,25 +3,21 @@
 ## Class import following
 
 ```py
-from b import C as D
-
-E = D
-reveal_type(E)  # revealed: Literal[C]
+from b import C as D; E = D
+reveal_type(E) # revealed: Literal[C]
 ```
 
 ```py path=b.py
-class C: ...
+class C: pass
 ```
 
 ## Module member resolution
 
 ```py
-import b
-
-D = b.C
-reveal_type(D)  # revealed: Literal[C]
+import b; D = b.C
+reveal_type(D) # revealed: Literal[C]
 ```
 
 ```py path=b.py
-class C: ...
+class C: pass
 ```

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

@@ -1,8 +1,6 @@
 # Importing builtin module
 
 ```py
-import builtins
-
-x = builtins.copyright
-reveal_type(x)  # revealed: Literal[copyright]
+import builtins; x = builtins.copyright
+reveal_type(x) # revealed: Literal[copyright]
 ```

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

@@ -3,26 +3,15 @@
 ## Maybe unbound
 
 ```py path=maybe_unbound.py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 if flag:
     y = 3
-
-x = y  # error: [possibly-unresolved-reference]
-
-# revealed: Literal[3]
-reveal_type(x)
-
-# revealed: Literal[3]
-# error: [possibly-unresolved-reference]
-reveal_type(y)
+x = y
+reveal_type(x)  # revealed: Unbound | Literal[3]
+reveal_type(y)  # revealed: Unbound | Literal[3]
 ```
 
 ```py
 from maybe_unbound import x, y
-
 reveal_type(x)  # revealed: Literal[3]
 reveal_type(y)  # revealed: Literal[3]
 ```
@@ -30,50 +19,21 @@ reveal_type(y)  # revealed: Literal[3]
 ## Maybe unbound annotated
 
 ```py path=maybe_unbound_annotated.py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
 if flag:
     y: int = 3
-x = y  # error: [possibly-unresolved-reference]
-
-# revealed: Literal[3]
-reveal_type(x)
-
-# revealed: Literal[3]
-# error: [possibly-unresolved-reference]
-reveal_type(y)
+x = y
+reveal_type(x)  # revealed: Unbound | Literal[3]
+reveal_type(y)  # revealed: Unbound | Literal[3]
 ```
 
 Importing an annotated name prefers the declared type over the inferred type:
 
 ```py
 from maybe_unbound_annotated import x, y
-
 reveal_type(x)  # revealed: Literal[3]
 reveal_type(y)  # revealed: int
 ```
 
-## Maybe undeclared
-
-Importing a possibly undeclared name still gives us its declared type:
-
-```py path=maybe_undeclared.py
-def bool_instance() -> bool:
-    return True
-
-if bool_instance():
-    x: int
-```
-
-```py
-from maybe_undeclared import x
-
-reveal_type(x)  # revealed: int
-```
-
 ## Reimport
 
 ```py path=c.py
@@ -81,20 +41,14 @@ def f(): ...
 ```
 
 ```py path=b.py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 if flag:
     from c import f
 else:
-
     def f(): ...
 ```
 
 ```py
 from b import f
-
 # TODO: We should disambiguate in such cases, showing `Literal[b.f, c.f]`.
 reveal_type(f)  # revealed: Literal[f, f]
 ```
@@ -109,10 +63,6 @@ x: int
 ```
 
 ```py path=b.py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 if flag:
     from c import x
 else:
@@ -121,6 +71,5 @@ else:
 
 ```py
 from b import x
-
 reveal_type(x)  # revealed: int
 ```

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

@@ -3,16 +3,14 @@
 ## Unresolved import statement
 
 ```py
-import bar  # error: "Cannot resolve import `bar`"
-
+import bar # error: "Cannot resolve import `bar`"
 reveal_type(bar)  # revealed: Unknown
 ```
 
 ## Unresolved import from statement
 
 ```py
-from bar import baz  # error: "Cannot resolve import `bar`"
-
+from bar import baz # error: "Cannot resolve import `bar`"
 reveal_type(baz)  # revealed: Unknown
 ```
 
@@ -22,16 +20,14 @@ reveal_type(baz)  # revealed: Unknown
 ```
 
 ```py
-from a import thing  # error: "Module `a` has no member `thing`"
-
+from a import thing # error: "Module `a` has no member `thing`"
 reveal_type(thing)  # revealed: Unknown
 ```
 
 ## Resolved import of symbol from unresolved import
 
 ```py path=a.py
-import foo as foo  # error: "Cannot resolve import `foo`"
-
+import foo as foo # error: "Cannot resolve import `foo`"
 reveal_type(foo)  # revealed: Unknown
 ```
 
@@ -40,7 +36,6 @@ import" violation:
 
 ```py
 from a import foo
-
 reveal_type(foo)  # revealed: Unknown
 ```
 
@@ -53,5 +48,5 @@ x: int
 ```py
 from b import x
 
-x = "foo"  # error: [invalid-assignment] "Object of type `Literal["foo"]"
+x = 'foo'  # error: [invalid-assignment] "Object of type `Literal["foo"]"
 ```

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

@@ -6,8 +6,7 @@
 ```
 
 ```py path=package/bar.py
-from .foo import X  # error: [unresolved-import]
-
+from .foo import X # error: [unresolved-import]
 reveal_type(X)  # revealed: Unknown
 ```
 
@@ -22,7 +21,6 @@ X = 42
 
 ```py path=package/bar.py
 from .foo import X
-
 reveal_type(X)  # revealed: Literal[42]
 ```
 
@@ -37,7 +35,6 @@ X = 42
 
 ```py path=package/bar.py
 from .foo.bar.baz import X
-
 reveal_type(X)  # revealed: Literal[42]
 ```
 
@@ -49,15 +46,13 @@ X = 42
 
 ```py path=package/bar.py
 from . import X
-
 reveal_type(X)  # revealed: Literal[42]
 ```
 
 ## Non-existent + bare to package
 
 ```py path=package/bar.py
-from . import X  # error: [unresolved-import]
-
+from . import X # error: [unresolved-import]
 reveal_type(X)  # revealed: Unknown
 ```
 
@@ -65,7 +60,6 @@ reveal_type(X)  # revealed: Unknown
 
 ```py path=package/__init__.py
 from .foo import X
-
 reveal_type(X)  # revealed: Literal[42]
 ```
 
@@ -76,9 +70,8 @@ X = 42
 ## Non-existent + dunder init
 
 ```py path=package/__init__.py
-from .foo import X  # error: [unresolved-import]
-
-reveal_type(X)  # revealed: Unknown
+from .foo import X # error: [unresolved-import]
+reveal_type(X)     # revealed: Unknown
 ```
 
 ## Long relative import
@@ -92,7 +85,6 @@ X = 42
 
 ```py path=package/subpackage/subsubpackage/bar.py
 from ...foo import X
-
 reveal_type(X)  # revealed: Literal[42]
 ```
 
@@ -102,13 +94,12 @@ reveal_type(X)  # revealed: Literal[42]
 ```
 
 ```py path=package/foo.py
-x  # error: [unresolved-reference]
+x
 ```
 
 ```py path=package/bar.py
-from .foo import x  # error: [unresolved-import]
-
-reveal_type(x)  # revealed: Unknown
+from .foo import x # error: [unresolved-import]
+reveal_type(x)     # revealed: Unknown
 ```
 
 ## Bare to module
@@ -123,11 +114,10 @@ X = 42
 ```py path=package/bar.py
 # TODO: support submodule imports
 from . import foo  # error: [unresolved-import]
-
 y = foo.X
 
 # TODO: should be `Literal[42]`
-reveal_type(y)  # revealed: Unknown
+reveal_type(y)     # revealed: Unknown
 ```
 
 ## Non-existent + bare to module
@@ -139,5 +129,5 @@ reveal_type(y)  # revealed: Unknown
 # TODO: support submodule imports
 from . import foo  # error: [unresolved-import]
 
-reveal_type(foo)  # revealed: Unknown
+reveal_type(foo)   # revealed: Unknown
 ```

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

@@ -4,7 +4,6 @@
 
 ```py
 from b import x
-
 y = x
 reveal_type(y)  # revealed: int
 ```
@@ -17,7 +16,6 @@ x: int
 
 ```py
 from b import x
-
 y = x
 reveal_type(y)  # revealed: int
 ```

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

@@ -1,6 +1,8 @@
 # Boolean literals
 
 ```py
-reveal_type(True)  # revealed: Literal[True]
-reveal_type(False)  # revealed: Literal[False]
+x = True
+y = False
+reveal_type(x)  # revealed: Literal[True]
+reveal_type(y)  # revealed: Literal[False]
 ```

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

@@ -1,10 +0,0 @@
-# Bytes literals
-
-## Simple
-
-```py
-reveal_type(b"red" b"knot")  # revealed: Literal[b"redknot"]
-reveal_type(b"hello")  # revealed: Literal[b"hello"]
-reveal_type(b"world" + b"!")  # revealed: Literal[b"world!"]
-reveal_type(b"\xff\x00")  # revealed: Literal[b"\xff\x00"]
-```

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

@@ -3,5 +3,6 @@
 ## Empty dictionary
 
 ```py
-reveal_type({})  # revealed: dict
+x = {}
+reveal_type(x)  # revealed: dict
 ```

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

@@ -3,5 +3,6 @@
 ## Empty list
 
 ```py
-reveal_type([])  # revealed: list
+x = []
+reveal_type(x)  # revealed: list
 ```

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

@@ -3,5 +3,6 @@
 ## Basic set
 
 ```py
-reveal_type({1, 2})  # revealed: set
+x = {1, 2}
+reveal_type(x)  # revealed: set
 ```

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

@@ -3,15 +3,18 @@
 ## Empty tuple
 
 ```py
-reveal_type(())  # revealed: tuple[()]
+x = ()
+reveal_type(x)  # revealed: tuple[()]
 ```
 
 ## Heterogeneous tuple
 
 ```py
-reveal_type((1, "a"))  # revealed: tuple[Literal[1], Literal["a"]]
+x = (1, 'a')
+y = (1, (2, 3))
+z = (x, 2)
 
-reveal_type((1, (2, 3)))  # revealed: tuple[Literal[1], tuple[Literal[2], Literal[3]]]
-
-reveal_type(((1, "a"), 2))  # revealed: tuple[tuple[Literal[1], Literal["a"]], Literal[2]]
+reveal_type(x)  # revealed: tuple[Literal[1], Literal["a"]]
+reveal_type(y)  # revealed: tuple[Literal[1], tuple[Literal[2], Literal[3]]]
+reveal_type(z)  # revealed: tuple[tuple[Literal[1], Literal["a"]], Literal[2]]
 ```

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

@@ -7,27 +7,38 @@ x = 0
 y = str()
 z = False
 
-reveal_type(f"hello")  # revealed: Literal["hello"]
-reveal_type(f"h {x}")  # revealed: Literal["h 0"]
-reveal_type("one " f"single " f"literal")  # revealed: Literal["one single literal"]
-reveal_type("first " f"second({x})" f" third")  # revealed: Literal["first second(0) third"]
-reveal_type(f"-{y}-")  # revealed: str
-reveal_type(f"-{y}-" f"--" "--")  # revealed: str
-reveal_type(f"{z} == {False} is {True}")  # revealed: Literal["False == False is True"]
+a = f'hello'
+b = f'h {x}'
+c = 'one ' f'single ' f'literal'
+d = 'first ' f'second({b})' f' third'
+e = f'-{y}-'
+f = f'-{y}-' f'--' '--'
+g = f'{z} == {False} is {True}'
+
+reveal_type(a)  # revealed: Literal["hello"]
+reveal_type(b)  # revealed: Literal["h 0"]
+reveal_type(c)  # revealed: Literal["one single literal"]
+reveal_type(d)  # revealed: Literal["first second(h 0) third"]
+reveal_type(e)  # revealed: str
+reveal_type(f)  # revealed: str
+reveal_type(g)  # revealed: Literal["False == False is True"]
 ```
 
 ## Conversion Flags
 
 ```py
-string = "hello"
+string = 'hello'
+a = f'{string!r}'
 
 # TODO: should be `Literal["'hello'"]`
-reveal_type(f"{string!r}")  # revealed: str
+reveal_type(a)  # revealed: str
 ```
 
 ## Format Specifiers
 
 ```py
+a = f'{1:02}'
+
 # TODO: should be `Literal["01"]`
-reveal_type(f"{1:02}")  # revealed: str
+reveal_type(a)  # revealed: str
 ```

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

@@ -1,91 +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"]
-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)]
-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
-```
-
-## 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/literal/string.md

@@ -3,19 +3,24 @@
 ## Simple
 
 ```py
-reveal_type("Hello")  # revealed: Literal["Hello"]
-reveal_type("world")  # revealed: Literal["world"]
-reveal_type("Guten " + "Tag")  # revealed: Literal["Guten Tag"]
-reveal_type("bon " + "jour")  # revealed: Literal["bon jour"]
+w = "Hello"
+x = 'world'
+y = "Guten " + 'tag'
+z = 'bon ' + "jour"
+
+reveal_type(w)  # revealed: Literal["Hello"]
+reveal_type(x)  # revealed: Literal["world"]
+reveal_type(y)  # revealed: Literal["Guten tag"]
+reveal_type(z)  # revealed: Literal["bon jour"]
 ```
 
 ## Nested Quotes
 
 ```py
-reveal_type('I say "hello" to you')  # revealed: Literal["I say \"hello\" to you"]
-
-# revealed: Literal["You say \"hey\" back"]
-reveal_type("You say \"hey\" back")  # fmt: skip
-
-reveal_type('No "closure here')  # revealed: Literal["No \"closure here"]
+x = 'I say "hello" to you'
+y = "You say \"hey\" back"
+z = 'No "closure here'
+reveal_type(x)  # revealed: Literal["I say \"hello\" to you"]
+reveal_type(y)  # revealed: Literal["You say \"hey\" back"]
+reveal_type(z)  # revealed: Literal["No \"closure here"]
 ```

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

@@ -17,10 +17,8 @@ async def foo():
     async for x in Iterator():
         pass
 
-    # TODO: should reveal `Unknown` because `__aiter__` is not defined
-    # revealed: @Todo
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)
+    # TODO
+    reveal_type(x)  # revealed: Unbound | @Todo
 ```
 
 ## Basic async for loop
@@ -35,11 +33,9 @@ async def foo():
         def __aiter__(self) -> IntAsyncIterator:
             return IntAsyncIterator()
 
-    # TODO(Alex): async iterables/iterators!
+    #TODO(Alex): async iterables/iterators!
     async for x in IntAsyncIterable():
         pass
 
-    # error: [possibly-unresolved-reference]
-    # revealed: @Todo
-    reveal_type(x)
+    reveal_type(x)  # revealed: Unbound | @Todo
 ```

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

@@ -14,9 +14,7 @@ class IntIterable:
 for x in IntIterable():
     pass
 
-# revealed: int
-# error: [possibly-unresolved-reference]
-reveal_type(x)
+reveal_type(x)  # revealed: Unbound | int
 ```
 
 ## With previous definition
@@ -30,7 +28,7 @@ class IntIterable:
     def __iter__(self) -> IntIterator:
         return IntIterator()
 
-x = "foo"
+x = 'foo'
 
 for x in IntIterable():
     pass
@@ -52,7 +50,7 @@ class IntIterable:
 for x in IntIterable():
     pass
 else:
-    x = "foo"
+    x = 'foo'
 
 reveal_type(x)  # revealed: Literal["foo"]
 ```
@@ -72,7 +70,7 @@ for x in IntIterable():
     if x > 5:
         break
 else:
-    x = "foo"
+    x = 'foo'
 
 reveal_type(x)  # revealed: int | Literal["foo"]
 ```
@@ -87,49 +85,38 @@ class OldStyleIterable:
 for x in OldStyleIterable():
     pass
 
-# revealed: int
-# error: [possibly-unresolved-reference]
-reveal_type(x)
+reveal_type(x)  # revealed: Unbound | int
 ```
 
 ## With heterogeneous tuple
 
 ```py
-for x in (1, "a", b"foo"):
+for x in (1, 'a', b'foo'):
     pass
 
-# revealed: Literal[1] | Literal["a"] | Literal[b"foo"]
-# error: [possibly-unresolved-reference]
-reveal_type(x)
+reveal_type(x)  # revealed: Unbound | Literal[1] | Literal["a"] | Literal[b"foo"]
 ```
 
 ## With non-callable iterator
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
 class NotIterable:
     if flag:
         __iter__ = 1
     else:
         __iter__ = None
 
-for x in NotIterable():  # error: "Object of type `NotIterable` is not iterable"
+for x in NotIterable(): # error: "Object of type `NotIterable` is not iterable"
     pass
 
-# revealed: Unknown
-# error: [possibly-unresolved-reference]
-reveal_type(x)
+reveal_type(x)  # revealed: Unbound | Unknown
 ```
 
 ## Invalid iterable
 
 ```py
 nonsense = 123
-for x in nonsense:  # error: "Object of type `Literal[123]` is not iterable"
+for x in nonsense: # error: "Object of type `Literal[123]` is not iterable"
     pass
 ```
 
@@ -139,145 +126,9 @@ for x in nonsense:  # error: "Object of type `Literal[123]` is not iterable"
 class NotIterable:
     def __getitem__(self, key: int) -> int:
         return 42
+
     __iter__ = None
 
-for x in NotIterable():  # error: "Object of type `NotIterable` is not iterable"
+for x in NotIterable(): # error: "Object of type `NotIterable` is not iterable"
     pass
 ```
-
-## Union type as iterable
-
-```py
-class TestIter:
-    def __next__(self) -> int:
-        return 42
-
-class Test:
-    def __iter__(self) -> TestIter:
-        return TestIter()
-
-class Test2:
-    def __iter__(self) -> TestIter:
-        return TestIter()
-
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-for x in Test() if flag else Test2():
-    reveal_type(x)  # revealed: int
-```
-
-## Union type as iterator
-
-```py
-class TestIter:
-    def __next__(self) -> int:
-        return 42
-
-class TestIter2:
-    def __next__(self) -> int:
-        return 42
-
-class Test:
-    def __iter__(self) -> TestIter | TestIter2:
-        return TestIter()
-
-for x in Test():
-    reveal_type(x)  # revealed: int
-```
-
-## Union type as iterable and union type as iterator
-
-```py
-class TestIter:
-    def __next__(self) -> int | Exception:
-        return 42
-
-class TestIter2:
-    def __next__(self) -> str | tuple[int, int]:
-        return "42"
-
-class TestIter3:
-    def __next__(self) -> bytes:
-        return b"42"
-
-class TestIter4:
-    def __next__(self) -> memoryview:
-        return memoryview(b"42")
-
-class Test:
-    def __iter__(self) -> TestIter | TestIter2:
-        return TestIter()
-
-class Test2:
-    def __iter__(self) -> TestIter3 | TestIter4:
-        return TestIter3()
-
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-for x in Test() if flag else Test2():
-    reveal_type(x)  # revealed: int | Exception | str | tuple[int, int] | bytes | memoryview
-```
-
-## Union type as iterable where one union element has no `__iter__` method
-
-```py
-class TestIter:
-    def __next__(self) -> int:
-        return 42
-
-class Test:
-    def __iter__(self) -> TestIter:
-        return TestIter()
-
-def coinflip() -> bool:
-    return True
-
-# error: [not-iterable] "Object of type `Test | Literal[42]` is not iterable because its `__iter__` method is possibly unbound"
-for x in Test() if coinflip() else 42:
-    reveal_type(x)  # revealed: int
-```
-
-## Union type as iterable where one union element has invalid `__iter__` method
-
-```py
-class TestIter:
-    def __next__(self) -> int:
-        return 42
-
-class Test:
-    def __iter__(self) -> TestIter:
-        return TestIter()
-
-class Test2:
-    def __iter__(self) -> int:
-        return 42
-
-def coinflip() -> bool:
-    return True
-
-# error: "Object of type `Test | Test2` is not iterable"
-for x in Test() if coinflip() else Test2():
-    reveal_type(x)  # revealed: Unknown
-```
-
-## Union type as iterator where one union element has no `__next__` method
-
-```py
-class TestIter:
-    def __next__(self) -> int:
-        return 42
-
-class Test:
-    def __iter__(self) -> TestIter | int:
-        return TestIter()
-
-# error: [not-iterable] "Object of type `Test` is not iterable"
-for x in Test():
-    reveal_type(x)  # revealed: Unknown
-```

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

@@ -3,7 +3,7 @@
 ## Yield must be iterable
 
 ```py
-class NotIterable: ...
+class NotIterable: pass
 
 class Iterator:
     def __next__(self) -> int:
@@ -14,5 +14,5 @@ class Iterable:
 
 def generator_function():
     yield from Iterable()
-    yield from NotIterable()  # error: "Object of type `NotIterable` is not iterable"
+    yield from NotIterable() # error: "Object of type `NotIterable` is not iterable"
 ```

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

@@ -3,10 +3,6 @@
 ## Basic While Loop
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 x = 1
 while flag:
     x = 2
@@ -17,27 +13,20 @@ reveal_type(x)  # revealed: Literal[1, 2]
 ## While with else (no break)
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 x = 1
 while flag:
     x = 2
 else:
-    reveal_type(x)  # revealed: Literal[1, 2]
+    y = x
     x = 3
 
 reveal_type(x)  # revealed: Literal[3]
+reveal_type(y)  # revealed: Literal[1, 2]
 ```
 
 ## While with Else (may break)
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
 x = 1
 y = 0
 while flag:

crates/red_knot_python_semantic/resources/mdtest/metaclass.md

@@ -1,196 +0,0 @@
-## Default
-
-```py
-class M(type): ...
-
-reveal_type(M.__class__)  # revealed: Literal[type]
-```
-
-## `object`
-
-```py
-reveal_type(object.__class__)  # revealed: Literal[type]
-```
-
-## `type`
-
-```py
-reveal_type(type.__class__)  # revealed: Literal[type]
-```
-
-## Basic
-
-```py
-class M(type): ...
-class B(metaclass=M): ...
-
-reveal_type(B.__class__)  # revealed: Literal[M]
-```
-
-## Invalid metaclass
-
-A class which doesn't inherit `type` (and/or doesn't implement a custom `__new__` accepting the same
-arguments as `type.__new__`) isn't a valid metaclass.
-
-```py
-class M: ...
-class A(metaclass=M): ...
-
-# TODO: emit a diagnostic for the invalid metaclass
-reveal_type(A.__class__)  # revealed: Literal[M]
-```
-
-## Linear inheritance
-
-If a class is a subclass of a class with a custom metaclass, then the subclass will also have that
-metaclass.
-
-```py
-class M(type): ...
-class A(metaclass=M): ...
-class B(A): ...
-
-reveal_type(B.__class__)  # revealed: Literal[M]
-```
-
-## Conflict (1)
-
-The metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its
-bases. ("Strict subclass" is a synonym for "proper subclass"; a non-strict subclass can be a
-subclass or the class itself.)
-
-```py
-class M1(type): ...
-class M2(type): ...
-class A(metaclass=M1): ...
-class B(metaclass=M2): ...
-
-# error: [conflicting-metaclass] "The metaclass of a derived class (`C`) must be a subclass of the metaclasses of all its bases, but `M1` (metaclass of base class `A`) and `M2` (metaclass of base class `B`) have no subclass relationship"
-class C(A, B): ...
-
-reveal_type(C.__class__)  # revealed: Unknown
-```
-
-## Conflict (2)
-
-The metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its
-bases. ("Strict subclass" is a synonym for "proper subclass"; a non-strict subclass can be a
-subclass or the class itself.)
-
-```py
-class M1(type): ...
-class M2(type): ...
-class A(metaclass=M1): ...
-
-# error: [conflicting-metaclass] "The metaclass of a derived class (`B`) must be a subclass of the metaclasses of all its bases, but `M2` (metaclass of `B`) and `M1` (metaclass of base class `A`) have no subclass relationship"
-class B(A, metaclass=M2): ...
-
-reveal_type(B.__class__)  # revealed: Unknown
-```
-
-## Common metaclass
-
-A class has two explicit bases, both of which have the same metaclass.
-
-```py
-class M(type): ...
-class A(metaclass=M): ...
-class B(metaclass=M): ...
-class C(A, B): ...
-
-reveal_type(C.__class__)  # revealed: Literal[M]
-```
-
-## Metaclass metaclass
-
-A class has an explicit base with a custom metaclass. That metaclass itself has a custom metaclass.
-
-```py
-class M1(type): ...
-class M2(type, metaclass=M1): ...
-class M3(M2): ...
-class A(metaclass=M3): ...
-class B(A): ...
-
-reveal_type(A.__class__)  # revealed: Literal[M3]
-```
-
-## Diamond inheritance
-
-```py
-class M(type): ...
-class M1(M): ...
-class M2(M): ...
-class M12(M1, M2): ...
-class A(metaclass=M1): ...
-class B(metaclass=M2): ...
-class C(metaclass=M12): ...
-
-# error: [conflicting-metaclass] "The metaclass of a derived class (`D`) must be a subclass of the metaclasses of all its bases, but `M1` (metaclass of base class `A`) and `M2` (metaclass of base class `B`) have no subclass relationship"
-class D(A, B, C): ...
-
-reveal_type(D.__class__)  # revealed: Unknown
-```
-
-## Unknown
-
-```py
-from nonexistent_module import UnknownClass  # error: [unresolved-import]
-
-class C(UnknownClass): ...
-
-# TODO: should be `type[type] & Unknown`
-reveal_type(C.__class__)  # revealed: Literal[type]
-
-class M(type): ...
-class A(metaclass=M): ...
-class B(A, UnknownClass): ...
-
-# TODO: should be `type[M] & Unknown`
-reveal_type(B.__class__)  # revealed: Literal[M]
-```
-
-## Duplicate
-
-```py
-class M(type): ...
-class A(metaclass=M): ...
-class B(A, A): ...  # error: [duplicate-base] "Duplicate base class `A`"
-
-reveal_type(B.__class__)  # revealed: Literal[M]
-```
-
-## Non-class
-
-When a class has an explicit `metaclass` that is not a class, but is a callable that accepts
-`type.__new__` arguments, we should return the meta type of its return type.
-
-```py
-def f(*args, **kwargs) -> int: ...
-
-class A(metaclass=f): ...
-
-# TODO should be `type[int]`
-reveal_type(A.__class__)  # revealed: @Todo
-```
-
-## Cyclic
-
-Retrieving the metaclass of a cyclically defined class should not cause an infinite loop.
-
-```py path=a.pyi
-class A(B): ...  # error: [cyclic-class-def]
-class B(C): ...  # error: [cyclic-class-def]
-class C(A): ...  # error: [cyclic-class-def]
-
-reveal_type(A.__class__)  # revealed: Unknown
-```
-
-## PEP 695 generic
-
-```py
-class M(type): ...
-class A[T: str](metaclass=M): ...
-
-reveal_type(A.__class__)  # revealed: Literal[M]
-```

crates/red_knot_python_semantic/resources/mdtest/mro.md

@@ -1,409 +0,0 @@
-# Method Resolution Order tests
-
-Tests that assert that we can infer the correct type for a class's `__mro__` attribute.
-
-This attribute is rarely accessed directly at runtime. However, it's extremely important for *us* to
-know the precise possible values of a class's Method Resolution Order, or we won't be able to infer
-the correct type of attributes accessed from instances.
-
-For documentation on method resolution orders, see:
-
-- <https://docs.python.org/3/glossary.html#term-method-resolution-order>
-- <https://docs.python.org/3/howto/mro.html#python-2-3-mro>
-
-## No bases
-
-```py
-class C: ...
-
-reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[object]]
-```
-
-## The special case: `object` itself
-
-```py
-reveal_type(object.__mro__)  # revealed: tuple[Literal[object]]
-```
-
-## Explicit inheritance from `object`
-
-```py
-class C(object): ...
-
-reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[object]]
-```
-
-## Explicit inheritance from non-`object` single base
-
-```py
-class A: ...
-class B(A): ...
-
-reveal_type(B.__mro__)  # revealed: tuple[Literal[B], Literal[A], Literal[object]]
-```
-
-## Linearization of multiple bases
-
-```py
-class A: ...
-class B: ...
-class C(A, B): ...
-
-reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[A], Literal[B], Literal[object]]
-```
-
-## Complex diamond inheritance (1)
-
-This is "ex_2" from <https://docs.python.org/3/howto/mro.html#the-end>
-
-```py
-class O: ...
-class X(O): ...
-class Y(O): ...
-class A(X, Y): ...
-class B(Y, X): ...
-
-reveal_type(A.__mro__)  # revealed: tuple[Literal[A], Literal[X], Literal[Y], Literal[O], Literal[object]]
-reveal_type(B.__mro__)  # revealed: tuple[Literal[B], Literal[Y], Literal[X], Literal[O], Literal[object]]
-```
-
-## Complex diamond inheritance (2)
-
-This is "ex_5" from <https://docs.python.org/3/howto/mro.html#the-end>
-
-```py
-class O: ...
-class F(O): ...
-class E(O): ...
-class D(O): ...
-class C(D, F): ...
-class B(D, E): ...
-class A(B, C): ...
-
-# revealed: tuple[Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
-reveal_type(C.__mro__)
-# revealed: tuple[Literal[B], Literal[D], Literal[E], Literal[O], Literal[object]]
-reveal_type(B.__mro__)
-# revealed: tuple[Literal[A], Literal[B], Literal[C], Literal[D], Literal[E], Literal[F], Literal[O], Literal[object]]
-reveal_type(A.__mro__)
-```
-
-## Complex diamond inheritance (3)
-
-This is "ex_6" from <https://docs.python.org/3/howto/mro.html#the-end>
-
-```py
-class O: ...
-class F(O): ...
-class E(O): ...
-class D(O): ...
-class C(D, F): ...
-class B(E, D): ...
-class A(B, C): ...
-
-# revealed: tuple[Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
-reveal_type(C.__mro__)
-# revealed: tuple[Literal[B], Literal[E], Literal[D], Literal[O], Literal[object]]
-reveal_type(B.__mro__)
-# revealed: tuple[Literal[A], Literal[B], Literal[E], Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
-reveal_type(A.__mro__)
-```
-
-## Complex diamond inheritance (4)
-
-This is "ex_9" from <https://docs.python.org/3/howto/mro.html#the-end>
-
-```py
-class O: ...
-class A(O): ...
-class B(O): ...
-class C(O): ...
-class D(O): ...
-class E(O): ...
-class K1(A, B, C): ...
-class K2(D, B, E): ...
-class K3(D, A): ...
-class Z(K1, K2, K3): ...
-
-# revealed: tuple[Literal[K1], Literal[A], Literal[B], Literal[C], Literal[O], Literal[object]]
-reveal_type(K1.__mro__)
-# revealed: tuple[Literal[K2], Literal[D], Literal[B], Literal[E], Literal[O], Literal[object]]
-reveal_type(K2.__mro__)
-# revealed: tuple[Literal[K3], Literal[D], Literal[A], Literal[O], Literal[object]]
-reveal_type(K3.__mro__)
-# revealed: tuple[Literal[Z], Literal[K1], Literal[K2], Literal[K3], Literal[D], Literal[A], Literal[B], Literal[C], Literal[E], Literal[O], Literal[object]]
-reveal_type(Z.__mro__)
-```
-
-## Inheritance from `Unknown`
-
-```py
-from does_not_exist import DoesNotExist  # error: [unresolved-import]
-
-class A(DoesNotExist): ...
-class B: ...
-class C: ...
-class D(A, B, C): ...
-class E(B, C): ...
-class F(E, A): ...
-
-reveal_type(A.__mro__)  # revealed: tuple[Literal[A], Unknown, Literal[object]]
-reveal_type(D.__mro__)  # revealed: tuple[Literal[D], Literal[A], Unknown, Literal[B], Literal[C], Literal[object]]
-reveal_type(E.__mro__)  # revealed: tuple[Literal[E], Literal[B], Literal[C], Literal[object]]
-reveal_type(F.__mro__)  # revealed: tuple[Literal[F], Literal[E], Literal[B], Literal[C], Literal[A], Unknown, Literal[object]]
-```
-
-## `__bases__` lists that cause errors at runtime
-
-If the class's `__bases__` cause an exception to be raised at runtime and therefore the class
-creation to fail, we infer the class's `__mro__` as being `[<class>, Unknown, object]`:
-
-```py
-# error: [inconsistent-mro] "Cannot create a consistent method resolution order (MRO) for class `Foo` with bases list `[<class 'object'>, <class 'int'>]`"
-class Foo(object, int): ...
-
-reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
-
-class Bar(Foo): ...
-
-reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Literal[Foo], Unknown, Literal[object]]
-
-# This is the `TypeError` at the bottom of "ex_2"
-# in the examples at <https://docs.python.org/3/howto/mro.html#the-end>
-class O: ...
-class X(O): ...
-class Y(O): ...
-class A(X, Y): ...
-class B(Y, X): ...
-
-reveal_type(A.__mro__)  # revealed: tuple[Literal[A], Literal[X], Literal[Y], Literal[O], Literal[object]]
-reveal_type(B.__mro__)  # revealed: tuple[Literal[B], Literal[Y], Literal[X], Literal[O], Literal[object]]
-
-# error: [inconsistent-mro] "Cannot create a consistent method resolution order (MRO) for class `Z` with bases list `[<class 'A'>, <class 'B'>]`"
-class Z(A, B): ...
-
-reveal_type(Z.__mro__)  # revealed: tuple[Literal[Z], Unknown, Literal[object]]
-
-class AA(Z): ...
-
-reveal_type(AA.__mro__)  # revealed: tuple[Literal[AA], Literal[Z], Unknown, Literal[object]]
-```
-
-## `__bases__` includes a `Union`
-
-We don't support union types in a class's bases; a base must resolve to a single `ClassLiteralType`.
-If we find a union type in a class's bases, we infer the class's `__mro__` as being
-`[<class>, Unknown, object]`, the same as for MROs that cause errors at runtime.
-
-```py
-def returns_bool() -> bool:
-    return True
-
-class A: ...
-class B: ...
-
-if returns_bool():
-    x = A
-else:
-    x = B
-
-reveal_type(x)  # revealed: Literal[A, B]
-
-# error: 11 [invalid-base] "Invalid class base with type `Literal[A, B]` (all bases must be a class, `Any`, `Unknown` or `Todo`)"
-class Foo(x): ...
-
-reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
-```
-
-## `__bases__` includes multiple `Union`s
-
-```py
-def returns_bool() -> bool:
-    return True
-
-class A: ...
-class B: ...
-class C: ...
-class D: ...
-
-if returns_bool():
-    x = A
-else:
-    x = B
-
-if returns_bool():
-    y = C
-else:
-    y = D
-
-reveal_type(x)  # revealed: Literal[A, B]
-reveal_type(y)  # revealed: Literal[C, D]
-
-# error: 11 [invalid-base] "Invalid class base with type `Literal[A, B]` (all bases must be a class, `Any`, `Unknown` or `Todo`)"
-# error: 14 [invalid-base] "Invalid class base with type `Literal[C, D]` (all bases must be a class, `Any`, `Unknown` or `Todo`)"
-class Foo(x, y): ...
-
-reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
-```
-
-## `__bases__` lists that cause errors... now with `Union`s
-
-```py
-def returns_bool() -> bool:
-    return True
-
-class O: ...
-class X(O): ...
-class Y(O): ...
-
-if bool():
-    foo = Y
-else:
-    foo = object
-
-# error: 21 [invalid-base] "Invalid class base with type `Literal[Y, object]` (all bases must be a class, `Any`, `Unknown` or `Todo`)"
-class PossibleError(foo, X): ...
-
-reveal_type(PossibleError.__mro__)  # revealed: tuple[Literal[PossibleError], Unknown, Literal[object]]
-
-class A(X, Y): ...
-
-reveal_type(A.__mro__)  # revealed: tuple[Literal[A], Literal[X], Literal[Y], Literal[O], Literal[object]]
-
-if returns_bool():
-    class B(X, Y): ...
-
-else:
-    class B(Y, X): ...
-
-# revealed: tuple[Literal[B], Literal[X], Literal[Y], Literal[O], Literal[object]] | tuple[Literal[B], Literal[Y], Literal[X], Literal[O], Literal[object]]
-reveal_type(B.__mro__)
-
-# error: 12 [invalid-base] "Invalid class base with type `Literal[B, B]` (all bases must be a class, `Any`, `Unknown` or `Todo`)"
-class Z(A, B): ...
-
-reveal_type(Z.__mro__)  # revealed: tuple[Literal[Z], Unknown, Literal[object]]
-```
-
-## `__bases__` lists with duplicate bases
-
-```py
-class Foo(str, str): ...  # error: 16 [duplicate-base] "Duplicate base class `str`"
-
-reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
-
-class Spam: ...
-class Eggs: ...
-class Ham(
-    Spam,
-    Eggs,
-    Spam,  # error: [duplicate-base] "Duplicate base class `Spam`"
-    Eggs,  # error: [duplicate-base] "Duplicate base class `Eggs`"
-): ...
-
-reveal_type(Ham.__mro__)  # revealed: tuple[Literal[Ham], Unknown, Literal[object]]
-
-class Mushrooms: ...
-class Omelette(Spam, Eggs, Mushrooms, Mushrooms): ...  # error: [duplicate-base]
-
-reveal_type(Omelette.__mro__)  # revealed: tuple[Literal[Omelette], Unknown, Literal[object]]
-```
-
-## `__bases__` lists with duplicate `Unknown` bases
-
-```py
-# error: [unresolved-import]
-# error: [unresolved-import]
-from does_not_exist import unknown_object_1, unknown_object_2
-
-reveal_type(unknown_object_1)  # revealed: Unknown
-reveal_type(unknown_object_2)  # revealed: Unknown
-
-# We *should* emit an error here to warn the user that we have no idea
-# what the MRO of this class should really be.
-# However, we don't complain about "duplicate base classes" here,
-# even though two classes are both inferred as being `Unknown`.
-#
-# (TODO: should we revisit this? Does it violate the gradual guarantee?
-# Should we just silently infer `[Foo, Unknown, object]` as the MRO here
-# without emitting any error at all? Not sure...)
-#
-# error: [inconsistent-mro] "Cannot create a consistent method resolution order (MRO) for class `Foo` with bases list `[Unknown, Unknown]`"
-class Foo(unknown_object_1, unknown_object_2): ...
-
-reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
-```
-
-## Unrelated objects inferred as `Any`/`Unknown` do not have special `__mro__` attributes
-
-```py
-from does_not_exist import unknown_object  # error: [unresolved-import]
-
-reveal_type(unknown_object)  # revealed: Unknown
-reveal_type(unknown_object.__mro__)  # revealed: Unknown
-```
-
-## Classes that inherit from themselves
-
-These are invalid, but we need to be able to handle them gracefully without panicking.
-
-```py path=a.pyi
-class Foo(Foo): ...  # error: [cyclic-class-def]
-
-reveal_type(Foo)  # revealed: Literal[Foo]
-reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
-
-class Bar: ...
-class Baz: ...
-class Boz(Bar, Baz, Boz): ...  # error: [cyclic-class-def]
-
-reveal_type(Boz)  # revealed: Literal[Boz]
-reveal_type(Boz.__mro__)  # revealed: tuple[Literal[Boz], Unknown, Literal[object]]
-```
-
-## Classes with indirect cycles in their MROs
-
-These are similarly unlikely, but we still shouldn't crash:
-
-```py path=a.pyi
-class Foo(Bar): ...  # error: [cyclic-class-def]
-class Bar(Baz): ...  # error: [cyclic-class-def]
-class Baz(Foo): ...  # error: [cyclic-class-def]
-
-reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
-reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Unknown, Literal[object]]
-reveal_type(Baz.__mro__)  # revealed: tuple[Literal[Baz], Unknown, Literal[object]]
-```
-
-## Classes with cycles in their MROs, and multiple inheritance
-
-```py path=a.pyi
-class Spam: ...
-class Foo(Bar): ...  # error: [cyclic-class-def]
-class Bar(Baz): ...  # error: [cyclic-class-def]
-class Baz(Foo, Spam): ...  # error: [cyclic-class-def]
-
-reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
-reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Unknown, Literal[object]]
-reveal_type(Baz.__mro__)  # revealed: tuple[Literal[Baz], Unknown, Literal[object]]
-```
-
-## Classes with cycles in their MRO, and a sub-graph
-
-```py path=a.pyi
-class FooCycle(BarCycle): ...  # error: [cyclic-class-def]
-class Foo: ...
-class BarCycle(FooCycle): ...  # error: [cyclic-class-def]
-class Bar(Foo): ...
-
-# TODO: can we avoid emitting the errors for these?
-# The classes have cyclic superclasses,
-# but are not themselves cyclic...
-class Baz(Bar, BarCycle): ...  # error: [cyclic-class-def]
-class Spam(Baz): ...  # error: [cyclic-class-def]
-
-reveal_type(FooCycle.__mro__)  # revealed: tuple[Literal[FooCycle], Unknown, Literal[object]]
-reveal_type(BarCycle.__mro__)  # revealed: tuple[Literal[BarCycle], Unknown, Literal[object]]
-reveal_type(Baz.__mro__)  # revealed: tuple[Literal[Baz], Unknown, Literal[object]]
-reveal_type(Spam.__mro__)  # revealed: tuple[Literal[Spam], Unknown, Literal[object]]
-```

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

@@ -1,93 +0,0 @@
-# Narrowing in boolean expressions
-
-In `or` expressions, the right-hand side is evaluated only if the left-hand side is **falsy**. So
-when the right-hand side is evaluated, we know the left side has failed.
-
-Similarly, in `and` expressions, the right-hand side is evaluated only if the left-hand side is
-**truthy**. So when the right-hand side is evaluated, we know the left side has succeeded.
-
-## Narrowing in `or`
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class A: ...
-
-x: A | None = A() if bool_instance() else None
-
-isinstance(x, A) or reveal_type(x)  # revealed: None
-x is None or reveal_type(x)  # revealed: A
-reveal_type(x)  # revealed: A | None
-```
-
-## Narrowing in `and`
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class A: ...
-
-x: A | None = A() if bool_instance() else None
-
-isinstance(x, A) and reveal_type(x)  # revealed: A
-x is None and reveal_type(x)  # revealed: None
-reveal_type(x)  # revealed: A | None
-```
-
-## Multiple `and` arms
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class A: ...
-
-x: A | None = A() if bool_instance() else None
-
-bool_instance() and isinstance(x, A) and reveal_type(x)  # revealed: A
-isinstance(x, A) and bool_instance() and reveal_type(x)  # revealed: A
-reveal_type(x) and isinstance(x, A) and bool_instance()  # revealed: A | None
-```
-
-## Multiple `or` arms
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class A: ...
-
-x: A | None = A() if bool_instance() else None
-
-bool_instance() or isinstance(x, A) or reveal_type(x)  # revealed: None
-isinstance(x, A) or bool_instance() or reveal_type(x)  # revealed: None
-reveal_type(x) or isinstance(x, A) or bool_instance()  # revealed: A | None
-```
-
-## Multiple predicates
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class A: ...
-
-x: A | None | Literal[1] = A() if bool_instance() else None if bool_instance() else 1
-
-x is None or isinstance(x, A) or reveal_type(x)  # revealed: Literal[1]
-```
-
-## Mix of `and` and `or`
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class A: ...
-
-x: A | None | Literal[1] = A() if bool_instance() else None if bool_instance() else 1
-
-isinstance(x, A) or x is not None and reveal_type(x)  # revealed: Literal[1]
-```

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

@@ -1,282 +0,0 @@
-# Narrowing for conditionals with boolean expressions
-
-## Narrowing in `and` conditional
-
-```py
-class A: ...
-class B: ...
-
-def instance() -> A | B:
-    return A()
-
-x = instance()
-
-if isinstance(x, A) and isinstance(x, B):
-    reveal_type(x)  # revealed:  A & B
-else:
-    reveal_type(x)  # revealed:  B & ~A | A & ~B
-```
-
-## Arms might not add narrowing constraints
-
-```py
-class A: ...
-class B: ...
-
-def bool_instance() -> bool:
-    return True
-
-def instance() -> A | B:
-    return A()
-
-x = instance()
-
-if isinstance(x, A) and bool_instance():
-    reveal_type(x)  # revealed: A
-else:
-    reveal_type(x)  # revealed: A | B
-
-if bool_instance() and isinstance(x, A):
-    reveal_type(x)  # revealed: A
-else:
-    reveal_type(x)  # revealed: A | B
-
-reveal_type(x)  # revealed: A | B
-```
-
-## Statically known arms
-
-```py
-class A: ...
-class B: ...
-
-def instance() -> A | B:
-    return A()
-
-x = instance()
-
-if isinstance(x, A) and True:
-    reveal_type(x)  # revealed: A
-else:
-    reveal_type(x)  # revealed: B & ~A
-
-if True and isinstance(x, A):
-    reveal_type(x)  # revealed: A
-else:
-    reveal_type(x)  # revealed: B & ~A
-
-if False and isinstance(x, A):
-    # TODO: should emit an `unreachable code` diagnostic
-    reveal_type(x)  # revealed: A
-else:
-    reveal_type(x)  # revealed: A | B
-
-if False or isinstance(x, A):
-    reveal_type(x)  # revealed: A
-else:
-    reveal_type(x)  # revealed: B & ~A
-
-if True or isinstance(x, A):
-    reveal_type(x)  # revealed: A | B
-else:
-    # TODO: should emit an `unreachable code` diagnostic
-    reveal_type(x)  # revealed: B & ~A
-
-reveal_type(x)  # revealed: A | B
-```
-
-## The type of multiple symbols can be narrowed down
-
-```py
-class A: ...
-class B: ...
-
-def instance() -> A | B:
-    return A()
-
-x = instance()
-y = instance()
-
-if isinstance(x, A) and isinstance(y, B):
-    reveal_type(x)  # revealed: A
-    reveal_type(y)  # revealed: B
-else:
-    # No narrowing: Only-one or both checks might have failed
-    reveal_type(x)  # revealed: A | B
-    reveal_type(y)  # revealed: A | B
-
-reveal_type(x)  # revealed: A | B
-reveal_type(y)  # revealed: A | B
-```
-
-## Narrowing in `or` conditional
-
-```py
-class A: ...
-class B: ...
-class C: ...
-
-def instance() -> A | B | C:
-    return A()
-
-x = instance()
-
-if isinstance(x, A) or isinstance(x, B):
-    reveal_type(x)  # revealed:  A | B
-else:
-    reveal_type(x)  # revealed:  C & ~A & ~B
-```
-
-## In `or`, all arms should add constraint in order to narrow
-
-```py
-class A: ...
-class B: ...
-class C: ...
-
-def instance() -> A | B | C:
-    return A()
-
-def bool_instance() -> bool:
-    return True
-
-x = instance()
-
-if isinstance(x, A) or isinstance(x, B) or bool_instance():
-    reveal_type(x)  # revealed:  A | B | C
-else:
-    reveal_type(x)  # revealed:  C & ~A & ~B
-```
-
-## in `or`, all arms should narrow the same set of symbols
-
-```py
-class A: ...
-class B: ...
-class C: ...
-
-def instance() -> A | B | C:
-    return A()
-
-x = instance()
-y = instance()
-
-if isinstance(x, A) or isinstance(y, A):
-    # The predicate might be satisfied by the right side, so the type of `x` can’t be narrowed down here.
-    reveal_type(x)  # revealed:  A | B | C
-    # The same for `y`
-    reveal_type(y)  # revealed:  A | B | C
-else:
-    reveal_type(x)  # revealed:  B & ~A | C & ~A
-    reveal_type(y)  # revealed:  B & ~A | C & ~A
-
-if (isinstance(x, A) and isinstance(y, A)) or (isinstance(x, B) and isinstance(y, B)):
-    # Here, types of `x` and `y` can be narrowd since all `or` arms constraint them.
-    reveal_type(x)  # revealed:  A | B
-    reveal_type(y)  # revealed:  A | B
-else:
-    reveal_type(x)  # revealed:  A | B | C
-    reveal_type(y)  # revealed:  A | B | C
-```
-
-## mixing `and` and `not`
-
-```py
-class A: ...
-class B: ...
-class C: ...
-
-def instance() -> A | B | C:
-    return A()
-
-x = instance()
-
-if isinstance(x, B) and not isinstance(x, C):
-    reveal_type(x)  # revealed:  B & ~C
-else:
-    # ~(B & ~C) -> ~B | C -> (A & ~B) | (C & ~B) | C -> (A & ~B) | C
-    reveal_type(x)  # revealed: A & ~B | C
-```
-
-## mixing `or` and `not`
-
-```py
-class A: ...
-class B: ...
-class C: ...
-
-def instance() -> A | B | C:
-    return A()
-
-x = instance()
-
-if isinstance(x, B) or not isinstance(x, C):
-    reveal_type(x)  # revealed: B | A & ~C
-else:
-    reveal_type(x)  # revealed: C & ~B
-```
-
-## `or` with nested `and`
-
-```py
-class A: ...
-class B: ...
-class C: ...
-
-def instance() -> A | B | C:
-    return A()
-
-x = instance()
-
-if isinstance(x, A) or (isinstance(x, B) and not isinstance(x, C)):
-    reveal_type(x)  # revealed:  A | B & ~C
-else:
-    # ~(A | (B & ~C)) -> ~A & ~(B & ~C) -> ~A & (~B | C) -> (~A & C) | (~A ~ B)
-    reveal_type(x)  # revealed:  C & ~A
-```
-
-## `and` with nested `or`
-
-```py
-class A: ...
-class B: ...
-class C: ...
-
-def instance() -> A | B | C:
-    return A()
-
-x = instance()
-
-if isinstance(x, A) and (isinstance(x, B) or not isinstance(x, C)):
-    # A & (B | ~C) -> (A & B) | (A & ~C)
-    reveal_type(x)  # revealed:  A & B | A & ~C
-else:
-    # ~((A & B) | (A & ~C)) ->
-    # ~(A & B) & ~(A & ~C) ->
-    # (~A | ~B) & (~A | C) ->
-    # [(~A | ~B) & ~A] | [(~A | ~B) & C] ->
-    # ~A | (~A & C) | (~B & C) ->
-    # ~A | (C & ~B) ->
-    # ~A | (C & ~B)  The positive side of ~A is  A | B | C ->
-    reveal_type(x)  # revealed:  B & ~A | C & ~A | C & ~B
-```
-
-## Boolean expression internal narrowing
-
-```py
-def optional_string() -> str | None:
-    return None
-
-x = optional_string()
-y = optional_string()
-
-if x is None and y is not x:
-    reveal_type(y)  # revealed: str
-
-# Neither of the conditions alone is sufficient for narrowing y's type:
-if x is None:
-    reveal_type(y)  # revealed: str | None
-
-if y is not x:
-    reveal_type(y)  # revealed: str | None
-```

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

@@ -1,57 +0,0 @@
-# Narrowing for conditionals with elif and else
-
-## Positive contributions become negative in elif-else blocks
-
-```py
-def int_instance() -> int:
-    return 42
-
-x = int_instance()
-
-if x == 1:
-    # cannot narrow; could be a subclass of `int`
-    reveal_type(x)  # revealed: int
-elif x == 2:
-    reveal_type(x)  # revealed: int & ~Literal[1]
-elif x != 3:
-    reveal_type(x)  # revealed: int & ~Literal[1] & ~Literal[2] & ~Literal[3]
-```
-
-## Positive contributions become negative in elif-else blocks, with simplification
-
-```py
-def bool_instance() -> bool:
-    return True
-
-x = 1 if bool_instance() else 2 if bool_instance() else 3
-
-if x == 1:
-    # TODO should be Literal[1]
-    reveal_type(x)  # revealed: Literal[1, 2, 3]
-elif x == 2:
-    # TODO should be Literal[2]
-    reveal_type(x)  # revealed: Literal[2, 3]
-else:
-    reveal_type(x)  # revealed: Literal[3]
-```
-
-## Multiple negative contributions using elif, with simplification
-
-```py
-def bool_instance() -> bool:
-    return True
-
-x = 1 if bool_instance() else 2 if bool_instance() else 3
-
-if x != 1:
-    reveal_type(x)  # revealed: Literal[2, 3]
-elif x != 2:
-    # TODO should be `Literal[1]`
-    reveal_type(x)  # revealed: Literal[1, 3]
-elif x == 3:
-    # TODO should be Never
-    reveal_type(x)  # revealed: Literal[1, 2, 3]
-else:
-    # TODO should be Never
-    reveal_type(x)  # revealed: Literal[1, 2]
-```

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

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

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

@@ -5,16 +5,10 @@
 The type guard removes `None` from the union type:
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 x = None if flag else 1
 
 if x is not None:
     reveal_type(x)  # revealed: Literal[1]
-else:
-    reveal_type(x)  # revealed: None
 
 reveal_type(x)  # revealed: None | Literal[1]
 ```
@@ -22,23 +16,19 @@ reveal_type(x)  # revealed: None | Literal[1]
 ## `is not` for other singleton types
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
 x = True if flag else False
 reveal_type(x)  # revealed: bool
 
 if x is not False:
-    reveal_type(x)  # revealed: Literal[True]
-else:
-    reveal_type(x)  # revealed: Literal[False]
+    # TODO the following should be `Literal[True]`
+    reveal_type(x)  # revealed: bool & ~Literal[False]
 ```
 
 ## `is not` for non-singleton types
 
-Non-singleton types should *not* narrow the type: two instances of a non-singleton class may occupy
-different addresses in memory even if they compare equal.
+Non-singleton types should *not* narrow the type: two instances of a
+non-singleton class may occupy different addresses in memory even if
+they compare equal.
 
 ```py
 x = 345
@@ -46,51 +36,4 @@ y = 345
 
 if x is not y:
     reveal_type(x)  # revealed: Literal[345]
-else:
-    reveal_type(x)  # revealed: Literal[345]
-```
-
-## `is not` for other types
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class A: ...
-
-x = A()
-y = x if bool_instance() else None
-
-if y is not x:
-    reveal_type(y)  # revealed: A | None
-else:
-    reveal_type(y)  # revealed: A
-
-reveal_type(y)  # revealed: A | None
-```
-
-## `is not` in chained comparisons
-
-The type guard removes `False` from the union type of the tested value only.
-
-```py
-def bool_instance() -> bool:
-    return True
-
-x_flag, y_flag = bool_instance(), bool_instance()
-x = True if x_flag else False
-y = True if y_flag else False
-
-reveal_type(x)  # revealed: bool
-reveal_type(y)  # revealed: bool
-
-if y is not x is not False:  # Interpreted as `(y is not x) and (x is not False)`
-    reveal_type(x)  # revealed: Literal[True]
-    reveal_type(y)  # revealed: bool
-else:
-    # The negation of the clause above is (y is x) or (x is False)
-    # So we can't narrow the type of x or y here, because each arm of the `or` could be true
-
-    reveal_type(x)  # revealed: bool
-    reveal_type(y)  # revealed: bool
 ```

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

@@ -1,56 +0,0 @@
-# Narrowing for nested conditionals
-
-## Multiple negative contributions
-
-```py
-def int_instance() -> int:
-    return 42
-
-x = int_instance()
-
-if x != 1:
-    if x != 2:
-        if x != 3:
-            reveal_type(x)  # revealed: int & ~Literal[1] & ~Literal[2] & ~Literal[3]
-```
-
-## Multiple negative contributions with simplification
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag1, flag2 = bool_instance(), bool_instance()
-x = 1 if flag1 else 2 if flag2 else 3
-
-if x != 1:
-    reveal_type(x)  # revealed: Literal[2, 3]
-    if x != 2:
-        reveal_type(x)  # revealed: Literal[3]
-```
-
-## elif-else blocks
-
-```py
-def bool_instance() -> bool:
-    return True
-
-x = 1 if bool_instance() else 2 if bool_instance() else 3
-
-if x != 1:
-    reveal_type(x)  # revealed: Literal[2, 3]
-    if x == 2:
-        # TODO should be `Literal[2]`
-        reveal_type(x)  # revealed: Literal[2, 3]
-    elif x == 3:
-        reveal_type(x)  # revealed: Literal[3]
-    else:
-        reveal_type(x)  # revealed: Never
-
-elif x != 2:
-    # TODO should be Literal[1]
-    reveal_type(x)  # revealed: Literal[1, 3]
-else:
-    # TODO should be Never
-    reveal_type(x)  # revealed: Literal[1, 2, 3]
-```

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

@@ -1,33 +0,0 @@
-# Narrowing for `not` conditionals
-
-The `not` operator negates a constraint.
-
-## `not is None`
-
-```py
-def bool_instance() -> bool:
-    return True
-
-x = None if bool_instance() else 1
-
-if not x is None:
-    reveal_type(x)  # revealed: Literal[1]
-else:
-    reveal_type(x)  # revealed: None
-
-reveal_type(x)  # revealed: None | Literal[1]
-```
-
-## `not isinstance`
-
-```py
-def bool_instance() -> bool:
-    return True
-
-x = 1 if bool_instance() else "a"
-
-if not isinstance(x, (int)):
-    reveal_type(x)  # revealed: Literal["a"]
-else:
-    reveal_type(x)  # revealed: Literal[1]
-```

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

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

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

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

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

@@ -1,244 +0,0 @@
-# Narrowing for `issubclass` checks
-
-Narrowing for `issubclass(class, classinfo)` expressions.
-
-## `classinfo` is a single type
-
-### Basic example
-
-```py
-def flag() -> bool: ...
-
-t = int if flag() else str
-
-if issubclass(t, bytes):
-    reveal_type(t)  # revealed: Never
-
-if issubclass(t, object):
-    reveal_type(t)  # revealed: Literal[int, str]
-
-if issubclass(t, int):
-    reveal_type(t)  # revealed: Literal[int]
-else:
-    reveal_type(t)  # revealed: Literal[str]
-
-if issubclass(t, str):
-    reveal_type(t)  # revealed: Literal[str]
-    if issubclass(t, int):
-        reveal_type(t)  # revealed: Never
-```
-
-### Proper narrowing in `elif` and `else` branches
-
-```py
-def flag() -> bool: ...
-
-t = int if flag() else str if flag() else bytes
-
-if issubclass(t, int):
-    reveal_type(t)  # revealed: Literal[int]
-else:
-    reveal_type(t)  # revealed: Literal[str, bytes]
-
-if issubclass(t, int):
-    reveal_type(t)  # revealed: Literal[int]
-elif issubclass(t, str):
-    reveal_type(t)  # revealed: Literal[str]
-else:
-    reveal_type(t)  # revealed: Literal[bytes]
-```
-
-### Multiple derived classes
-
-```py
-class Base: ...
-class Derived1(Base): ...
-class Derived2(Base): ...
-class Unrelated: ...
-
-def flag() -> bool: ...
-
-t1 = Derived1 if flag() else Derived2
-
-if issubclass(t1, Base):
-    reveal_type(t1)  # revealed: Literal[Derived1, Derived2]
-
-if issubclass(t1, Derived1):
-    reveal_type(t1)  # revealed: Literal[Derived1]
-else:
-    reveal_type(t1)  # revealed: Literal[Derived2]
-
-t2 = Derived1 if flag() else Base
-
-if issubclass(t2, Base):
-    reveal_type(t2)  # revealed: Literal[Derived1, Base]
-
-t3 = Derived1 if flag() else Unrelated
-
-if issubclass(t3, Base):
-    reveal_type(t3)  # revealed: Literal[Derived1]
-else:
-    reveal_type(t3)  # revealed: Literal[Unrelated]
-```
-
-### Narrowing for non-literals
-
-```py
-class A: ...
-class B: ...
-
-def get_class() -> type[object]: ...
-
-t = get_class()
-
-if issubclass(t, A):
-    reveal_type(t)  # revealed: type[A]
-    if issubclass(t, B):
-        reveal_type(t)  # revealed: type[A] & type[B]
-else:
-    reveal_type(t)  # revealed: type[object] & ~type[A]
-```
-
-### Handling of `None`
-
-```py
-from types import NoneType
-
-def flag() -> bool: ...
-
-t = int if flag() else NoneType
-
-if issubclass(t, NoneType):
-    reveal_type(t)  # revealed: Literal[NoneType]
-
-if issubclass(t, type(None)):
-    # TODO: this should be just `Literal[NoneType]`
-    reveal_type(t)  # revealed: Literal[int, NoneType]
-```
-
-## `classinfo` contains multiple types
-
-### (Nested) tuples of types
-
-```py
-class Unrelated: ...
-
-def flag() -> bool: ...
-
-t = int if flag() else str if flag() else bytes
-
-if issubclass(t, (int, (Unrelated, (bytes,)))):
-    reveal_type(t)  # revealed: Literal[int, bytes]
-else:
-    reveal_type(t)  # revealed: Literal[str]
-```
-
-## Special cases
-
-### Emit a diagnostic if the first argument is of wrong type
-
-#### Too wide
-
-`type[object]` is a subtype of `object`, but not every `object` can be passed as the first argument
-to `issubclass`:
-
-```py
-class A: ...
-
-def get_object() -> object: ...
-
-t = get_object()
-
-# TODO: we should emit a diagnostic here
-if issubclass(t, A):
-    reveal_type(t)  # revealed: type[A]
-```
-
-#### Wrong
-
-`Literal[1]` and `type` are entirely disjoint, so the inferred type of `Literal[1] & type[int]` is
-eagerly simplified to `Never` as a result of the type narrowing in the `if issubclass(t, int)`
-branch:
-
-```py
-t = 1
-
-# TODO: we should emit a diagnostic here
-if issubclass(t, int):
-    reveal_type(t)  # revealed: Never
-```
-
-### Do not use custom `issubclass` for narrowing
-
-```py
-def issubclass(c, ci):
-    return True
-
-def flag() -> bool: ...
-
-t = int if flag() else str
-if issubclass(t, int):
-    reveal_type(t)  # revealed: Literal[int, str]
-```
-
-### Do support narrowing if `issubclass` is aliased
-
-```py
-issubclass_alias = issubclass
-
-def flag() -> bool: ...
-
-t = int if flag() else str
-if issubclass_alias(t, int):
-    reveal_type(t)  # revealed: Literal[int]
-```
-
-### Do support narrowing if `issubclass` is imported
-
-```py
-from builtins import issubclass as imported_issubclass
-
-def flag() -> bool: ...
-
-t = int if flag() else str
-if imported_issubclass(t, int):
-    reveal_type(t)  # revealed: Literal[int]
-```
-
-### Do not narrow if second argument is not a proper `classinfo` argument
-
-```py
-from typing import Any
-
-def flag() -> bool: ...
-
-t = int if flag() else str
-
-# TODO: this should cause us to emit a diagnostic during
-# type checking
-if issubclass(t, "str"):
-    reveal_type(t)  # revealed: Literal[int, str]
-
-# TODO: this should cause us to emit a diagnostic during
-# type checking
-if issubclass(t, (bytes, "str")):
-    reveal_type(t)  # revealed: Literal[int, str]
-
-# TODO: this should cause us to emit a diagnostic during
-# type checking
-if issubclass(t, Any):
-    reveal_type(t)  # revealed: Literal[int, str]
-```
-
-### Do not narrow if there are keyword arguments
-
-```py
-def flag() -> bool: ...
-
-t = int if flag() else str
-
-# 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]
-```

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

@@ -3,11 +3,6 @@
 ## Single `match` pattern
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
 x = None if flag else 1
 reveal_type(x)  # revealed: None | Literal[1]
 
@@ -17,5 +12,6 @@ match x:
     case None:
         y = x
 
-reveal_type(y)  # revealed: Literal[0] | None
+# TODO intersection simplification: should be just Literal[0] | None
+reveal_type(y)  # revealed: Literal[0] | None | Literal[1] & None
 ```

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

@@ -0,0 +1,9 @@
+# `is not None` narrowing
+
+```py
+x = None if flag else 1
+if x is not None:
+    reveal_type(x)  # revealed: Literal[1]
+
+reveal_type(x)  # revealed: None | Literal[1]
+```

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

@@ -1,136 +0,0 @@
-# Implicit globals from `types.ModuleType`
-
-## Implicit `ModuleType` globals
-
-All modules are instances of `types.ModuleType`. If a name can't be found in any local or global
-scope, we look it up as an attribute on `types.ModuleType` in typeshed before deciding that the name
-is unbound.
-
-```py
-reveal_type(__name__)  # revealed: str
-reveal_type(__file__)  # revealed: str | None
-reveal_type(__loader__)  # revealed: LoaderProtocol | None
-reveal_type(__package__)  # revealed: str | None
-reveal_type(__doc__)  # revealed: str | None
-
-# TODO: Should be `ModuleSpec | None`
-# (needs support for `*` imports)
-reveal_type(__spec__)  # revealed: Unknown | None
-
-# TODO: generics
-reveal_type(__path__)  # revealed: @Todo
-
-class X:
-    reveal_type(__name__)  # revealed: str
-
-def foo():
-    reveal_type(__name__)  # revealed: str
-```
-
-However, three attributes on `types.ModuleType` are not present as implicit module globals; these
-are excluded:
-
-```py path=unbound_dunders.py
-# error: [unresolved-reference]
-# revealed: Unknown
-reveal_type(__getattr__)
-
-# error: [unresolved-reference]
-# revealed: Unknown
-reveal_type(__dict__)
-
-# error: [unresolved-reference]
-# revealed: Unknown
-reveal_type(__init__)
-```
-
-## Accessed as attributes
-
-`ModuleType` attributes can also be accessed as attributes on module-literal types. The special
-attributes `__dict__` and `__init__`, and all attributes on `builtins.object`, can also be accessed
-as attributes on module-literal types, despite the fact that these are inaccessible as globals from
-inside the module:
-
-```py
-import typing
-
-reveal_type(typing.__name__)  # revealed: str
-reveal_type(typing.__init__)  # revealed: Literal[__init__]
-
-# These come from `builtins.object`, not `types.ModuleType`:
-reveal_type(typing.__eq__)  # revealed: Literal[__eq__]
-
-reveal_type(typing.__class__)  # revealed: Literal[type]
-
-# TODO: needs support for attribute access on instances, properties and generics;
-# should be `dict[str, Any]`
-reveal_type(typing.__dict__)  # revealed: @Todo
-```
-
-Typeshed includes a fake `__getattr__` method in the stub for `types.ModuleType` to help out with
-dynamic imports; but we ignore that for module-literal types where we know exactly which module
-we're dealing with:
-
-```py path=__getattr__.py
-import typing
-
-reveal_type(typing.__getattr__)  # revealed: Unknown
-```
-
-## `types.ModuleType.__dict__` takes precedence over global variable `__dict__`
-
-It's impossible to override the `__dict__` attribute of `types.ModuleType` instances from inside the
-module; we should prioritise the attribute in the `types.ModuleType` stub over a variable named
-`__dict__` in the module's global namespace:
-
-```py path=foo.py
-__dict__ = "foo"
-
-reveal_type(__dict__)  # revealed: Literal["foo"]
-```
-
-```py path=bar.py
-import foo
-from foo import __dict__ as foo_dict
-
-# TODO: needs support for attribute access on instances, properties, and generics;
-# should be `dict[str, Any]` for both of these:
-reveal_type(foo.__dict__)  # revealed: @Todo
-reveal_type(foo_dict)  # revealed: @Todo
-```
-
-## Conditionally global or `ModuleType` attribute
-
-Attributes overridden in the module namespace take priority. If a builtin name is conditionally
-defined as a global, however, a name lookup should union the `ModuleType` type with the
-conditionally defined type:
-
-```py
-__file__ = 42
-
-def returns_bool() -> bool:
-    return True
-
-if returns_bool():
-    __name__ = 1
-
-reveal_type(__file__)  # revealed: Literal[42]
-reveal_type(__name__)  # revealed: Literal[1] | str
-```
-
-## Conditionally global or `ModuleType` attribute, with annotation
-
-The same is true if the name is annotated:
-
-```py
-__file__: int = 42
-
-def returns_bool() -> bool:
-    return True
-
-if returns_bool():
-    __name__: int = 1
-
-reveal_type(__file__)  # revealed: Literal[42]
-reveal_type(__name__)  # revealed: Literal[1] | str
-```

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

@@ -3,9 +3,8 @@
 ## Implicit error
 
 ```py
-class C: ...
-
-C = 1  # error: "Implicit shadowing of class `C`; annotate to make it explicit if this is intentional"
+class C: pass
+C = 1 # error: "Implicit shadowing of class `C`; annotate to make it explicit if this is intentional"
 ```
 
 ## Explicit
@@ -13,7 +12,6 @@ C = 1  # error: "Implicit shadowing of class `C`; annotate to make it explicit i
 No diagnostic is raised in the case of explicit shadowing:
 
 ```py
-class C: ...
-
+class C: pass
 C: int = 1
 ```

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

@@ -2,8 +2,7 @@
 
 ## Parameter
 
-Parameter `x` of type `str` is shadowed and reassigned with a new `int` value inside the function.
-No diagnostics should be generated.
+Parameter `x` of type `str` is shadowed and reassigned with a new `int` value inside the function. No diagnostics should be generated.
 
 ```py path=a.py
 def f(x: str):
@@ -13,15 +12,13 @@ def f(x: str):
 ## Implicit error
 
 ```py path=a.py
-def f(): ...
-
-f = 1  # error: "Implicit shadowing of function `f`; annotate to make it explicit if this is intentional"
+def f(): pass
+f = 1 # error: "Implicit shadowing of function `f`; annotate to make it explicit if this is intentional"
 ```
 
 ## Explicit shadowing
 
 ```py path=a.py
-def f(): ...
-
+def f(): pass
 f: int = 1
 ```

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

@@ -3,14 +3,9 @@
 ## Shadow after incompatible declarations is OK
 
 ```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
 if flag:
     x: str
 else:
     x: int
-x: bytes = b"foo"
+x: bytes = b'foo'
 ```

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

@@ -2,16 +2,9 @@
 
 ## Cyclical class definition
 
-In type stubs, classes can reference themselves in their base class definitions. For example, in
-`typeshed`, we have `class str(Sequence[str]): ...`.
+In type stubs, classes can reference themselves in their base class definitions. For example, in `typeshed`, we have `class str(Sequence[str]): ...`.
 
 ```py path=a.pyi
-class Foo[T]: ...
-
-# TODO: actually is subscriptable
-# error: [non-subscriptable]
-class Bar(Foo[Bar]): ...
-
-reveal_type(Bar)  # revealed: Literal[Bar]
-reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Unknown, Literal[object]]
+class C(C): ...
+reveal_type(C)  # revealed: Literal[C]
 ```

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

@@ -1,57 +1,15 @@
-# Bytes subscripts
+# Bytes subscript
 
-## Indexing
+## Simple
 
 ```py
-b = b"\x00abc\xff"
+w = b'red' b'knot'
+x = b'hello'
+y = b'world' + b'!'
+z = b'\xff\x00'
 
-reveal_type(b[0])  # revealed: Literal[b"\x00"]
-reveal_type(b[1])  # revealed: Literal[b"a"]
-reveal_type(b[4])  # revealed: Literal[b"\xff"]
-
-reveal_type(b[-1])  # revealed: Literal[b"\xff"]
-reveal_type(b[-2])  # revealed: Literal[b"c"]
-reveal_type(b[-5])  # revealed: Literal[b"\x00"]
-
-reveal_type(b[False])  # revealed: Literal[b"\x00"]
-reveal_type(b[True])  # revealed: Literal[b"a"]
-
-x = b[5]  # error: [index-out-of-bounds] "Index 5 is out of bounds for bytes literal `Literal[b"\x00abc\xff"]` with length 5"
-reveal_type(x)  # revealed: Unknown
-
-y = b[-6]  # error: [index-out-of-bounds] "Index -6 is out of bounds for bytes literal `Literal[b"\x00abc\xff"]` with length 5"
-reveal_type(y)  # revealed: Unknown
-
-def int_instance() -> int:
-    return 42
-
-a = b"abcde"[int_instance()]
-# TODO: Support overloads... Should be `bytes`
-reveal_type(a)  # revealed: @Todo
-```
-
-## Slices
-
-```py
-b = b"\x00abc\xff"
-
-reveal_type(b[0:2])  # revealed: Literal[b"\x00a"]
-reveal_type(b[-3:])  # revealed: Literal[b"bc\xff"]
-
-b[0:4:0]  # error: [zero-stepsize-in-slice]
-b[:4:0]  # error: [zero-stepsize-in-slice]
-b[0::0]  # error: [zero-stepsize-in-slice]
-b[::0]  # error: [zero-stepsize-in-slice]
-
-def int_instance() -> int: ...
-
-byte_slice1 = b[int_instance() : int_instance()]
-# TODO: Support overloads... Should be `bytes`
-reveal_type(byte_slice1)  # revealed: @Todo
-
-def bytes_instance() -> bytes: ...
-
-byte_slice2 = bytes_instance()[0:5]
-# TODO: Support overloads... Should be `bytes`
-reveal_type(byte_slice2)  # revealed: @Todo
+reveal_type(w)  # revealed: Literal[b"redknot"]
+reveal_type(x)  # revealed: Literal[b"hello"]
+reveal_type(y)  # revealed: Literal[b"world!"]
+reveal_type(z)  # revealed: Literal[b"\xff\x00"]
 ```

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

@@ -3,8 +3,7 @@
 ## Class getitem unbound
 
 ```py
-class NotSubscriptable: ...
-
+class NotSubscriptable: pass
 a = NotSubscriptable[0]  # error: "Cannot subscript object of type `Literal[NotSubscriptable]` with no `__class_getitem__` method"
 ```
 
@@ -15,7 +14,8 @@ class Identity:
     def __class_getitem__(cls, item: int) -> str:
         return item
 
-reveal_type(Identity[0])  # revealed: str
+a = Identity[0]  
+reveal_type(a) # revealed: str
 ```
 
 ## Class getitem union
@@ -23,37 +23,39 @@ reveal_type(Identity[0])  # revealed: str
 ```py
 flag = True
 
-class UnionClassGetItem:
+class Identity:
     if flag:
-
         def __class_getitem__(cls, item: int) -> str:
             return item
     else:
-
         def __class_getitem__(cls, item: int) -> int:
             return item
 
-reveal_type(UnionClassGetItem[0])  # revealed: str | int
+a = Identity[0]  
+reveal_type(a) # revealed: str | int
 ```
 
 ## Class getitem with class union
 
 ```py
-def bool_instance() -> bool:
-    return True
+flag = True
 
-class A:
+class Identity1:
     def __class_getitem__(cls, item: int) -> str:
         return item
 
-class B:
+class Identity2:
     def __class_getitem__(cls, item: int) -> int:
         return item
 
-x = A if bool_instance() else B
+if flag:
+    a = Identity1
+else:
+    a = Identity2
 
-reveal_type(x)  # revealed: Literal[A, B]
-reveal_type(x[0])  # revealed: str | int
+b = a[0]
+reveal_type(a) # revealed: Literal[Identity1, Identity2]
+reveal_type(b) # revealed: str | int
 ```
 
 ## Class getitem with unbound method union
@@ -62,16 +64,14 @@ reveal_type(x[0])  # revealed: str | int
 flag = True
 
 if flag:
-    class Spam:
+    class Identity:
         def __class_getitem__(self, x: int) -> str:
-            return "foo"
-
+            pass
 else:
-    class Spam: ...
+    class Identity: pass
 
-# error: [call-possibly-unbound-method] "Method `__class_getitem__` of type `Literal[Spam, Spam]` is possibly unbound"
-# revealed: str
-reveal_type(Spam[42])
+a = Identity[42] # error: [call-non-callable] "Method `__class_getitem__` of type `Literal[__class_getitem__] | Unbound` is not callable on object of type `Literal[Identity, Identity]`" 
+reveal_type(a) # revealed: str | Unknown 
 ```
 
 ## TODO: Class getitem non-class union
@@ -80,15 +80,13 @@ reveal_type(Spam[42])
 flag = True
 
 if flag:
-    class Eggs:
+    class Identity:
         def __class_getitem__(self, x: int) -> str:
-            return "foo"
-
+            pass
 else:
-    Eggs = 1
+    Identity = 1
 
-a = Eggs[42]  # error: "Cannot subscript object of type `Literal[Eggs] | Literal[1]` with no `__getitem__` method"
-
-# TODO: should _probably_ emit `str | Unknown`
-reveal_type(a)  # revealed: Unknown
+a = Identity[42] # error: "Cannot subscript object of type `Literal[Identity] | Literal[1]` with no `__getitem__` method"
+# TODO: should _probably_ emit `str | Unknown` 
+reveal_type(a) # revealed: Unknown 
 ```

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

@@ -3,8 +3,7 @@
 ## Getitem unbound
 
 ```py
-class NotSubscriptable: ...
-
+class NotSubscriptable: pass
 a = NotSubscriptable()[0]  # error: "Cannot subscript object of type `NotSubscriptable` with no `__getitem__` method"
 ```
 
@@ -24,7 +23,8 @@ class Identity:
     def __getitem__(self, index: int) -> int:
         return index
 
-reveal_type(Identity()[0])  # revealed: int
+a = Identity()[0]  
+reveal_type(a) # revealed: int
 ```
 
 ## Getitem union
@@ -34,13 +34,12 @@ flag = True
 
 class Identity:
     if flag:
-
         def __getitem__(self, index: int) -> int:
             return index
     else:
-
         def __getitem__(self, index: int) -> str:
             return str(index)
 
-reveal_type(Identity()[0])  # revealed: int | str
+a = Identity()[0]  
+reveal_type(a) # revealed: int | str
 ```

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

@@ -10,28 +10,24 @@ A list can be indexed into with:
 ```py
 x = [1, 2, 3]
 reveal_type(x)  # revealed: list
-
 # TODO reveal int
 reveal_type(x[0])  # revealed: @Todo
-
 # TODO reveal list
 reveal_type(x[0:1])  # revealed: @Todo
-
 # TODO error
 reveal_type(x["a"])  # revealed: @Todo
 ```
 
 ## Assignments within list assignment
 
-In assignment, we might also have a named assignment. This should also get type checked.
+In assignment, we might also have a named assignment.
+This should also get type checked.
 
 ```py
 x = [1, 2, 3]
 x[0 if (y := 2) else 1] = 5
-
 # TODO error? (indeterminite index type)
 x["a" if (y := 2) else 1] = 6
-
 # TODO error (can't index via string)
 x["a" if (y := 2) else "b"] = 6
 ```

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

@@ -1,13 +0,0 @@
-# Stepsize zero in slices
-
-We raise a `zero-stepsize-in-slice` diagnostic when trying to slice a literal string, bytes, or
-tuple with a step size of zero (see tests in `string.md`, `bytes.md` and `tuple.md`). But we don't
-want to raise this diagnostic when slicing a custom type:
-
-```py
-class MySequence:
-    def __getitem__(self, s: slice) -> int:
-        return 0
-
-MySequence()[0:1:0]  # No error
-```

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

@@ -1,99 +1,32 @@
-# String subscripts
+# Subscript on strings
 
-## Indexing
+## Simple
 
 ```py
-s = "abcde"
+s = 'abcde'
 
-reveal_type(s[0])  # revealed: Literal["a"]
-reveal_type(s[1])  # revealed: Literal["b"]
-reveal_type(s[-1])  # revealed: Literal["e"]
-reveal_type(s[-2])  # revealed: Literal["d"]
+a = s[0]
+b = s[1]
+c = s[-1]
+d = s[-2]
+e = s[8]        # error: [index-out-of-bounds] "Index 8 is out of bounds for string `Literal["abcde"]` with length 5"
+f = s[-8]       # error: [index-out-of-bounds] "Index -8 is out of bounds for string `Literal["abcde"]` with length 5"
 
-reveal_type(s[False])  # revealed: Literal["a"]
-reveal_type(s[True])  # revealed: Literal["b"]
+reveal_type(a)  # revealed: Literal["a"]
+reveal_type(b)  # revealed: Literal["b"]
+reveal_type(c)  # revealed: Literal["e"]
+reveal_type(d)  # revealed: Literal["d"]
+reveal_type(e)  # revealed: Unknown
+reveal_type(f)  # revealed: Unknown
+```
 
-a = s[8]  # error: [index-out-of-bounds] "Index 8 is out of bounds for string `Literal["abcde"]` with length 5"
-reveal_type(a)  # revealed: Unknown
+## Function return
 
-b = s[-8]  # error: [index-out-of-bounds] "Index -8 is out of bounds for string `Literal["abcde"]` with length 5"
-reveal_type(b)  # revealed: Unknown
+```py
+def add(x: int, y: int) -> int:
+    return x + y
 
-def int_instance() -> int: ...
-
-a = "abcde"[int_instance()]
+a = 'abcde'[add(0, 1)]
 # TODO: Support overloads... Should be `str`
 reveal_type(a)  # revealed: @Todo
 ```
-
-## Slices
-
-```py
-s = "abcde"
-
-reveal_type(s[0:0])  # revealed: Literal[""]
-reveal_type(s[0:1])  # revealed: Literal["a"]
-reveal_type(s[0:2])  # revealed: Literal["ab"]
-reveal_type(s[0:5])  # revealed: Literal["abcde"]
-reveal_type(s[0:6])  # revealed: Literal["abcde"]
-reveal_type(s[1:3])  # revealed: Literal["bc"]
-
-reveal_type(s[-3:5])  # revealed: Literal["cde"]
-reveal_type(s[-4:-2])  # revealed: Literal["bc"]
-reveal_type(s[-10:10])  # revealed: Literal["abcde"]
-
-reveal_type(s[0:])  # revealed: Literal["abcde"]
-reveal_type(s[2:])  # revealed: Literal["cde"]
-reveal_type(s[5:])  # revealed: Literal[""]
-reveal_type(s[:2])  # revealed: Literal["ab"]
-reveal_type(s[:0])  # revealed: Literal[""]
-reveal_type(s[:2])  # revealed: Literal["ab"]
-reveal_type(s[:10])  # revealed: Literal["abcde"]
-reveal_type(s[:])  # revealed: Literal["abcde"]
-
-reveal_type(s[::-1])  # revealed: Literal["edcba"]
-reveal_type(s[::2])  # revealed: Literal["ace"]
-reveal_type(s[-2:-5:-1])  # revealed: Literal["dcb"]
-reveal_type(s[::-2])  # revealed: Literal["eca"]
-reveal_type(s[-1::-3])  # revealed: Literal["eb"]
-
-reveal_type(s[None:2:None])  # revealed: Literal["ab"]
-reveal_type(s[1:None:1])  # revealed: Literal["bcde"]
-reveal_type(s[None:None:None])  # revealed: Literal["abcde"]
-
-start = 1
-stop = None
-step = 2
-reveal_type(s[start:stop:step])  # revealed: Literal["bd"]
-
-reveal_type(s[False:True])  # revealed: Literal["a"]
-reveal_type(s[True:3])  # revealed: Literal["bc"]
-
-s[0:4:0]  # error: [zero-stepsize-in-slice]
-s[:4:0]  # error: [zero-stepsize-in-slice]
-s[0::0]  # error: [zero-stepsize-in-slice]
-s[::0]  # error: [zero-stepsize-in-slice]
-
-def int_instance() -> int: ...
-
-substring1 = s[int_instance() : int_instance()]
-# TODO: Support overloads... Should be `LiteralString`
-reveal_type(substring1)  # revealed: @Todo
-
-def str_instance() -> str: ...
-
-substring2 = str_instance()[0:5]
-# TODO: Support overloads... Should be `str`
-reveal_type(substring2)  # revealed: @Todo
-```
-
-## Unsupported slice types
-
-```py
-# TODO: It would be great if we raised an error here. This can be done once
-# we have support for overloads and generics, and once typeshed has a more
-# precise annotation for `str.__getitem__`, that makes use of the generic
-# `slice[..]` type. We could then infer `slice[str, str]` here and see that
-# it doesn't match the signature of `str.__getitem__`.
-"foo"["bar":"baz"]
-```