BDD

.github/renovate.json5

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

.github/workflows/build-docker.yml

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

.github/workflows/ci.yaml

@@ -349,7 +349,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@v5
+      - uses: astral-sh/setup-uv@v4
       - uses: actions/download-artifact@v4
         name: Download Ruff binary to test
         id: download-cached-binary
@@ -386,7 +386,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup component add rustfmt
       - uses: Swatinem/rust-cache@v2
-      - run: ./scripts/add_rule.py --name DoTheThing --prefix F --code 999 --linter pyflakes
+      - run: ./scripts/add_rule.py --name DoTheThing --prefix PL --code C0999 --linter pylint
       - run: cargo check
       - run: cargo fmt --all --check
       - run: |
@@ -585,8 +585,7 @@ jobs:
         run: |
           echo '```console' > "$GITHUB_STEP_SUMMARY"
           # Enable color output for pre-commit and remove it for the summary
-          # Use --hook-stage=manual to enable slower pre-commit hooks that are skipped by default
-          SKIP=cargo-fmt,clippy,dev-generate-all pre-commit run --all-files --show-diff-on-failure --color=always --hook-stage=manual | \
+          SKIP=cargo-fmt,clippy,dev-generate-all pre-commit run --all-files --show-diff-on-failure --color=always | \
             tee >(sed -E 's/\x1B\[([0-9]{1,2}(;[0-9]{1,2})*)?[mGK]//g' >> "$GITHUB_STEP_SUMMARY") >&1
           exit_code="${PIPESTATUS[0]}"
           echo '```' >> "$GITHUB_STEP_SUMMARY"
@@ -613,7 +612,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v4
       - uses: Swatinem/rust-cache@v2
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}

.github/workflows/daily_fuzz.yaml

@@ -34,7 +34,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@v5
+      - uses: astral-sh/setup-uv@v4
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
@@ -73,6 +73,6 @@ jobs:
               owner: "astral-sh",
               repo: "ruff",
               title: `Daily parser fuzz failed on ${new Date().toDateString()}`,
-              body: "Run listed here: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}",
+              body: "Runs listed here: https://github.com/astral-sh/ruff/actions/workflows/daily_fuzz.yml",
               labels: ["bug", "parser", "fuzzer"],
             })

.github/workflows/daily_property_tests.yaml

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

.github/workflows/publish-docs.yml

@@ -33,9 +33,8 @@ jobs:
           python-version: 3.12
 
       - name: "Set docs version"
-        env:
-          version: ${{ (inputs.plan != '' && fromJson(inputs.plan).announcement_tag) || inputs.ref }}
         run: |
+          version="${{ (inputs.plan != '' && fromJson(inputs.plan).announcement_tag) || inputs.ref }}"
           # if version is missing, use 'latest'
           if [ -z "$version" ]; then
             echo "Using 'latest' as version"

.github/workflows/publish-pypi.yml

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

.github/zizmor.yml

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

.pre-commit-config.yaml

@@ -2,7 +2,6 @@ fail_fast: false
 
 exclude: |
   (?x)^(
-    .github/workflows/release.yml|
     crates/red_knot_vendored/vendor/.*|
     crates/red_knot_workspace/resources/.*|
     crates/ruff_linter/resources/.*|
@@ -23,7 +22,7 @@ repos:
       - id: validate-pyproject
 
   - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.21
+    rev: 0.7.19
     hooks:
       - id: mdformat
         additional_dependencies:
@@ -59,7 +58,7 @@ repos:
           - black==24.10.0
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.29.4
+    rev: v1.28.3
     hooks:
       - id: typos
 
@@ -73,7 +72,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.6
+    rev: v0.8.3
     hooks:
       - id: ruff-format
       - id: ruff
@@ -91,9 +90,12 @@ repos:
   # zizmor detects security vulnerabilities in GitHub Actions workflows.
   # Additional configuration for the tool is found in `.github/zizmor.yml`
   - repo: https://github.com/woodruffw/zizmor-pre-commit
-    rev: v1.0.0
+    rev: v0.9.2
     hooks:
       - id: zizmor
+        # `release.yml` is autogenerated by `dist`; security issues need to be fixed there
+        # (https://opensource.axo.dev/cargo-dist/)
+        exclude: .github/workflows/release.yml
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
     rev: 0.30.0
@@ -103,14 +105,12 @@ repos:
   # `actionlint` hook, for verifying correct syntax in GitHub Actions workflows.
   # Some additional configuration for `actionlint` can be found in `.github/actionlint.yaml`.
   - repo: https://github.com/rhysd/actionlint
-    rev: v1.7.6
+    rev: v1.7.4
     hooks:
       - id: actionlint
-        stages:
-          # This hook is disabled by default, since it's quite slow.
-          # To run all hooks *including* this hook, use `uvx pre-commit run -a --hook-stage=manual`.
-          # To run *just* this hook, use `uvx pre-commit run -a actionlint --hook-stage=manual`.
-          - manual
+        # `release.yml` is autogenerated by `dist`; issues need to be fixed there
+        # (https://opensource.axo.dev/cargo-dist/)
+        exclude: .github/workflows/release.yml
         args:
           - "-ignore=SC2129" # ignorable stylistic lint from shellcheck
           - "-ignore=SC2016" # another shellcheck lint: seems to have false positives?

BREAKING_CHANGES.md

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

CHANGELOG.md

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

CONTRIBUTING.md

@@ -467,7 +467,7 @@ cargo build --release && hyperfine --warmup 10 \
   "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache -e --select W505,E501"
 ```
 
-You can run `uv venv --project ./scripts/benchmarks`, activate the venv and then run `uv sync --project ./scripts/benchmarks` to create a working environment for the
+You can run `poetry install` from `./scripts/benchmarks` to create a working environment for the
 above. All reported benchmarks were computed using the versions specified by
 `./scripts/benchmarks/pyproject.toml` on Python 3.11.
 

Cargo.toml

@@ -55,7 +55,7 @@ camino = { version = "1.1.7" }
 chrono = { version = "0.4.35", default-features = false, features = ["clock"] }
 clap = { version = "4.5.3", features = ["derive"] }
 clap_complete_command = { version = "0.6.0" }
-clearscreen = { version = "4.0.0" }
+clearscreen = { version = "3.0.0" }
 codspeed-criterion-compat = { version = "2.6.0", default-features = false }
 colored = { version = "2.1.0" }
 console_error_panic_hook = { version = "0.1.7" }
@@ -89,7 +89,7 @@ insta = { version = "1.35.1" }
 insta-cmd = { version = "0.6.0" }
 is-macro = { version = "0.3.5" }
 is-wsl = { version = "0.4.0" }
-itertools = { version = "0.14.0" }
+itertools = { version = "0.13.0" }
 js-sys = { version = "0.3.69" }
 jod-thread = { version = "0.1.2" }
 libc = { version = "0.2.153" }
@@ -105,6 +105,7 @@ mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
 notify = { version = "7.0.0" }
 ordermap = { version = "0.5.0" }
+oxidd = { version = "0.9.0", features = ["tdd"] }
 path-absolutize = { version = "3.1.1" }
 path-slash = { version = "0.2.1" }
 pathdiff = { version = "0.2.1" }
@@ -119,7 +120,7 @@ rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
 # When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "88a1d7774d78f048fbd77d40abca9ebd729fd1f0" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "3c7f1694c9efba751dbeeacfbc93b227586e316a" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }

README.md

@@ -116,21 +116,12 @@ For more, see the [documentation](https://docs.astral.sh/ruff/).
 
 ### Installation
 
-Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI.
-
-Invoke Ruff directly with [`uvx`](https://docs.astral.sh/uv/):
-
-```shell
-uvx ruff check   # Lint all files in the current directory.
-uvx ruff format  # Format all files in the current directory.
-```
-
-Or install Ruff with `uv` (recommended), `pip`, or `pipx`:
+Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 
 ```shell
 # With uv.
-uv tool install ruff@latest  # Install Ruff globally.
-uv add --dev ruff            # Or add Ruff to your project.
+uv add --dev ruff     # to add ruff to your project
+uv tool install ruff  # to install ruff globally
 
 # With pip.
 pip install ruff
@@ -149,8 +140,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.9.0/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.9.0/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.8.3/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.8.3/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -183,7 +174,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.9.0
+  rev: v0.8.3
   hooks:
     # Run the linter.
     - id: ruff
@@ -205,7 +196,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: astral-sh/ruff-action@v3
+      - uses: astral-sh/ruff-action@v1
 ```
 
 ### Configuration<a id="configuration"></a>

crates/red_knot/Cargo.toml

@@ -24,6 +24,9 @@ colored = { workspace = true }
 countme = { workspace = true, features = ["enable"] }
 crossbeam = { workspace = true }
 ctrlc = { version = "3.4.4" }
+oxidd = { workspace = true }
+oxidd-core = { version = "0.9.0" }
+oxidd-dump = { version = "0.4.0" }
 rayon = { workspace = true }
 salsa = { workspace = true }
 tracing = { workspace = true, features = ["release_max_level_debug"] }

crates/red_knot/src/main.rs

@@ -105,8 +105,44 @@ pub enum Command {
     Server,
 }
 
+use oxidd::bdd::BDDFunction;
+use oxidd::ManagerRef;
+use oxidd::{BooleanFunction, BooleanFunctionQuant};
+use oxidd_core::Manager;
+use oxidd_dump::dot::dump_all;
+
 #[allow(clippy::print_stdout, clippy::unnecessary_wraps, clippy::print_stderr)]
 pub fn main() -> ExitStatus {
+    let mgr = oxidd::bdd::new_manager(24, 24, 1);
+    let (x, y, z) = mgr.with_manager_exclusive(|mgr| {
+        (
+            BDDFunction::new_var(mgr).unwrap(),
+            BDDFunction::new_var(mgr).unwrap(),
+            BDDFunction::new_var(mgr).unwrap(),
+        )
+    });
+    mgr.with_manager_shared(|manager| {
+        let inner_func = x
+            .or(&y.and(&x.not().unwrap()).unwrap())
+            .unwrap()
+            .or(&y.not().unwrap().and(&x.not().unwrap()).unwrap())
+            .unwrap();
+        let func = z.and(&inner_func).unwrap();
+
+        let func = func.restrict(&z).unwrap();
+
+        manager.gc();
+
+        let file = std::fs::File::create("bdd.dot").expect("could not create `bdd.dot`");
+        dump_all(
+            file,
+            manager,
+            [(&x, "x"), (&y, "y"), (&z, "z")],
+            [(&func, "z ^ (x ∨ (y ∧ ~x) ∨ (~y ∧ ~x))")],
+        )
+        .expect("dot export failed");
+    });
+    panic!("FOO");
     run().unwrap_or_else(|error| {
         use std::io::Write;
 

crates/red_knot_python_semantic/Cargo.toml

@@ -20,14 +20,12 @@ ruff_python_stdlib = { workspace = true }
 ruff_source_file = { workspace = true }
 ruff_text_size = { workspace = true }
 ruff_python_literal = { workspace = true }
-ruff_python_trivia = { workspace = true }
 
 anyhow = { workspace = true }
 bitflags = { workspace = true }
 camino = { workspace = true }
 compact_str = { workspace = true }
 countme = { workspace = true }
-drop_bomb = { workspace = true }
 indexmap = { workspace = true }
 itertools = { workspace = true }
 ordermap = { workspace = true }
@@ -60,3 +58,4 @@ serde = ["ruff_db/serde", "dep:serde"]
 
 [lints]
 workspace = true
+

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

@@ -9,6 +9,8 @@ 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]
@@ -17,6 +19,7 @@ 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
@@ -27,6 +30,9 @@ 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]
@@ -35,6 +41,7 @@ def f():
     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]
 
@@ -54,63 +61,6 @@ invalid4: Literal[
 ]
 ```
 
-## Shortening unions of literals
-
-When a Literal is parameterized with more than one value, it’s treated as exactly to equivalent to
-the union of those types.
-
-```py
-from typing import Literal
-
-def x(
-    a1: Literal[Literal[Literal[1, 2, 3], "foo"], 5, None],
-    a2: Literal["w"] | Literal["r"],
-    a3: Literal[Literal["w"], Literal["r"], Literal[Literal["w+"]]],
-    a4: Literal[True] | Literal[1, 2] | Literal["foo"],
-):
-    reveal_type(a1)  # revealed: Literal[1, 2, 3, "foo", 5] | None
-    reveal_type(a2)  # revealed: Literal["w", "r"]
-    reveal_type(a3)  # revealed: Literal["w", "r", "w+"]
-    reveal_type(a4)  # revealed: Literal[True, 1, 2, "foo"]
-```
-
-## Display of heterogeneous unions of literals
-
-```py
-from typing import Literal, Union
-
-def foo(x: int) -> int:
-    return x + 1
-
-def bar(s: str) -> str:
-    return s
-
-class A: ...
-class B: ...
-
-def union_example(
-    x: Union[
-        # unknown type
-        # error: [unresolved-reference]
-        y,
-        Literal[-1],
-        Literal["A"],
-        Literal[b"A"],
-        Literal[b"\x00"],
-        Literal[b"\x07"],
-        Literal[0],
-        Literal[1],
-        Literal["B"],
-        Literal["foo"],
-        Literal["bar"],
-        Literal["B"],
-        Literal[True],
-        None,
-    ]
-):
-    reveal_type(x)  # revealed: Unknown | Literal[-1, "A", b"A", b"\x00", b"\x07", 0, 1, "B", "foo", "bar", True] | None
-```
-
 ## Detecting Literal outside typing and typing_extensions
 
 Only Literal that is defined in typing and typing_extension modules is detected as the special

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

@@ -73,12 +73,12 @@ qux = (foo, bar)
 reveal_type(qux)  # revealed: tuple[Literal["foo"], Literal["bar"]]
 
 # TODO: Infer "LiteralString"
-reveal_type(foo.join(qux))  # revealed: @Todo(Attribute access on `StringLiteral` types)
+reveal_type(foo.join(qux))  # revealed: @Todo(call todo)
 
 template: LiteralString = "{}, {}"
 reveal_type(template)  # revealed: Literal["{}, {}"]
 # TODO: Infer `LiteralString`
-reveal_type(template.format(foo, bar))  # revealed: @Todo(Attribute access on `StringLiteral` types)
+reveal_type(template.format(foo, bar))  # revealed: @Todo(call todo)
 ```
 
 ### Assignability
@@ -107,7 +107,7 @@ def _(flag: bool):
     qux_2: Literal["qux"] = baz_2  # error: [invalid-assignment]
 
     baz_3 = "foo" if flag else 1
-    reveal_type(baz_3)  # revealed: Literal["foo", 1]
+    reveal_type(baz_3)  # revealed: Literal["foo"] | Literal[1]
     qux_3: LiteralString = baz_3  # error: [invalid-assignment]
 ```
 

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

@@ -47,9 +47,7 @@ def f():
 
 ## `typing.Never`
 
-`typing.Never` is only available in Python 3.11 and later.
-
-### Python 3.11
+`typing.Never` is only available in Python 3.11 and later:
 
 ```toml
 [environment]
@@ -59,17 +57,8 @@ python-version = "3.11"
 ```py
 from typing import Never
 
-reveal_type(Never)  # revealed: typing.Never
-```
+x: Never
 
-### Python 3.10
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-# error: [unresolved-import]
-from typing import Never
+def f():
+    reveal_type(x)  # revealed: Never
 ```

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

@@ -105,7 +105,7 @@ def f1(
 from typing import Literal
 
 def f(v: Literal["a", r"b", b"c", "d" "e", "\N{LATIN SMALL LETTER F}", "\x67", """h"""]):
-    reveal_type(v)  # revealed: Literal["a", "b", b"c", "de", "f", "g", "h"]
+    reveal_type(v)  # revealed: Literal["a", "b", "de", "f", "g", "h"] | Literal[b"c"]
 ```
 
 ## Class variables

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

@@ -33,6 +33,8 @@ b: tuple[int] = (42,)
 c: tuple[str, int] = ("42", 42)
 d: tuple[tuple[str, str], tuple[int, int]] = (("foo", "foo"), (42, 42))
 e: tuple[str, ...] = ()
+# TODO: we should not emit this error
+# error: [call-possibly-unbound-method] "Method `__class_getitem__` of type `Literal[tuple]` is possibly unbound"
 f: tuple[str, *tuple[int, ...], bytes] = ("42", b"42")
 g: tuple[str, Unpack[tuple[int, ...]], bytes] = ("42", b"42")
 h: tuple[list[int], list[int]] = ([], [])
@@ -122,10 +124,3 @@ class Foo: ...
 x = Foo()
 reveal_type(x)  # revealed: Foo
 ```
-
-## Annotated assignments in stub files are inferred correctly
-
-```pyi path=main.pyi
-x: int = 1
-reveal_type(x) # revealed: Literal[1]
-```

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

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

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -1,6 +1,4 @@
-# Attributes
-
-Tests for attribute access on various kinds of types.
+# Class attributes
 
 ## Union of attributes
 
@@ -157,67 +155,3 @@ class Foo: ...
 
 reveal_type(Foo.__class__)  # revealed: Literal[type]
 ```
-
-## Function-literal attributes
-
-Most attribute accesses on function-literal types are delegated to `types.FunctionType`, since all
-functions are instances of that class:
-
-```py path=a.py
-def f(): ...
-
-reveal_type(f.__defaults__)  # revealed: @Todo(instance attributes)
-reveal_type(f.__kwdefaults__)  # revealed: @Todo(instance attributes)
-```
-
-Some attributes are special-cased, however:
-
-```py path=b.py
-def f(): ...
-
-reveal_type(f.__get__)  # revealed: @Todo(`__get__` method on functions)
-reveal_type(f.__call__)  # revealed: @Todo(`__call__` method on functions)
-```
-
-## Int-literal attributes
-
-Most attribute accesses on int-literal types are delegated to `builtins.int`, since all literal
-integers are instances of that class:
-
-```py path=a.py
-reveal_type((2).bit_length)  # revealed: @Todo(instance attributes)
-reveal_type((2).denominator)  # revealed: @Todo(instance attributes)
-```
-
-Some attributes are special-cased, however:
-
-```py path=b.py
-reveal_type((2).numerator)  # revealed: Literal[2]
-reveal_type((2).real)  # revealed: Literal[2]
-```
-
-## Literal `bool` attributes
-
-Most attribute accesses on bool-literal types are delegated to `builtins.bool`, since all literal
-bols are instances of that class:
-
-```py path=a.py
-reveal_type(True.__and__)  # revealed: @Todo(instance attributes)
-reveal_type(False.__or__)  # revealed: @Todo(instance attributes)
-```
-
-Some attributes are special-cased, however:
-
-```py path=b.py
-reveal_type(True.numerator)  # revealed: Literal[1]
-reveal_type(False.real)  # revealed: Literal[0]
-```
-
-## Bytes-literal attributes
-
-All attribute access on literal `bytes` types is currently delegated to `buitins.bytes`:
-
-```py
-reveal_type(b"foo".join)  # revealed: @Todo(instance attributes)
-reveal_type(b"foo".endswith)  # revealed: @Todo(instance attributes)
-```

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

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

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

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

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

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

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

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

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

@@ -32,10 +32,13 @@ def _(flag: bool):
 
 ```py
 if True or (x := 1):
-    # error: [unresolved-reference]
-    reveal_type(x)  # revealed: Unknown
+    # TODO: infer that the second arm is never executed, and raise `unresolved-reference`.
+    # error: [possibly-unresolved-reference]
+    reveal_type(x)  # revealed: Literal[1]
 
 if True and (x := 1):
+    # TODO: infer that the second arm is always executed, do not raise a diagnostic
+    # error: [possibly-unresolved-reference]
     reveal_type(x)  # revealed: Literal[1]
 ```
 

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

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

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

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

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

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

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

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

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

@@ -31,10 +31,10 @@ class C:
     def __lt__(self, other) -> C: ...
 
 x = A() < B() < C()
-reveal_type(x)  # revealed: A & ~AlwaysTruthy | B
+reveal_type(x)  # revealed: A | B
 
 y = 0 < 1 < A() < 3
-reveal_type(y)  # revealed: Literal[False] | A
+reveal_type(y)  # revealed: bool | A
 
 z = 10 < 0 < A() < B() < C()
 reveal_type(z)  # revealed: Literal[False]

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

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

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

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

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

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

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

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

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

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

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

@@ -7,7 +7,7 @@ def _(flag: bool):
     reveal_type(1 if flag else 2)  # revealed: Literal[1, 2]
 ```
 
-## Statically known conditions in if-expressions
+## Statically known branches
 
 ```py
 reveal_type(1 if True else 2)  # revealed: Literal[1]
@@ -31,9 +31,9 @@ The test inside an if expression should not affect code outside of the expressio
 def _(flag: bool):
     x: Literal[42, "hello"] = 42 if flag else "hello"
 
-    reveal_type(x)  # revealed: Literal[42, "hello"]
+    reveal_type(x)  # revealed: Literal[42] | Literal["hello"]
 
     _ = ... if isinstance(x, str) else ...
 
-    reveal_type(x)  # revealed: Literal[42, "hello"]
+    reveal_type(x)  # revealed: Literal[42] | Literal["hello"]
 ```

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

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

crates/red_knot_python_semantic/resources/mdtest/final.md

@@ -1,31 +0,0 @@
-# Tests for the `@typing(_extensions).final` decorator
-
-## Cannot subclass
-
-Don't do this:
-
-```py
-import typing_extensions
-from typing import final
-
-@final
-class A: ...
-
-class B(A): ...  # error: 9 [subclass-of-final-class] "Class `B` cannot inherit from final class `A`"
-
-@typing_extensions.final
-class C: ...
-
-class D(C): ...  # error: [subclass-of-final-class]
-class E: ...
-class F: ...
-class G: ...
-
-# fmt: off
-class H(
-    E,
-    F,
-    A,  # error: [subclass-of-final-class]
-    G,
-): ...
-```

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

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

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

@@ -1,23 +1,7 @@
 # Ellipsis literals
 
-## Python 3.9
-
-```toml
-[environment]
-python-version = "3.9"
-```
+## Simple
 
 ```py
-reveal_type(...)  # revealed: ellipsis
-```
-
-## Python 3.10
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-reveal_type(...)  # revealed: EllipsisType
+reveal_type(...)  # revealed: EllipsisType | ellipsis
 ```

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

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

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

@@ -41,7 +41,7 @@ def _(flag: bool, flag2: bool):
         x = 3
 
     reveal_type(x)  # revealed: Literal[2, 3]
-    reveal_type(y)  # revealed: Literal[4, 1, 2]
+    reveal_type(y)  # revealed: Literal[1, 2, 4]
 ```
 
 ## Nested `while` loops

crates/red_knot_python_semantic/resources/mdtest/metaclass.md

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

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

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

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

@@ -17,7 +17,7 @@ def _(flag: bool):
             reveal_type(x)  # revealed: Never
 
     if isinstance(x, (int, object)):
-        reveal_type(x)  # revealed: Literal[1, "a"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```
 
 ## `classinfo` is a tuple of types
@@ -30,7 +30,7 @@ def _(flag: bool, flag1: bool, flag2: bool):
     x = 1 if flag else "a"
 
     if isinstance(x, (int, str)):
-        reveal_type(x)  # revealed: Literal[1, "a"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
     else:
         reveal_type(x)  # revealed: Never
 
@@ -43,19 +43,19 @@ def _(flag: bool, flag1: bool, flag2: bool):
     # No narrowing should occur if a larger type is also
     # one of the possibilities:
     if isinstance(x, (int, object)):
-        reveal_type(x)  # revealed: Literal[1, "a"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
     else:
         reveal_type(x)  # revealed: Never
 
     y = 1 if flag1 else "a" if flag2 else b"b"
     if isinstance(y, (int, str)):
-        reveal_type(y)  # revealed: Literal[1, "a"]
+        reveal_type(y)  # revealed: Literal[1] | Literal["a"]
 
     if isinstance(y, (int, bytes)):
-        reveal_type(y)  # revealed: Literal[1, b"b"]
+        reveal_type(y)  # revealed: Literal[1] | Literal[b"b"]
 
     if isinstance(y, (str, bytes)):
-        reveal_type(y)  # revealed: Literal["a", b"b"]
+        reveal_type(y)  # revealed: Literal["a"] | Literal[b"b"]
 ```
 
 ## `classinfo` is a nested tuple of types
@@ -107,7 +107,7 @@ def _(flag: bool):
     x = 1 if flag else "foo"
 
     if isinstance(x, t):
-        reveal_type(x)  # revealed: Literal[1, "foo"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["foo"]
 ```
 
 ## Do not use custom `isinstance` for narrowing
@@ -119,7 +119,7 @@ def _(flag: bool):
     x = 1 if flag else "a"
 
     if isinstance(x, int):
-        reveal_type(x)  # revealed: Literal[1, "a"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```
 
 ## Do support narrowing if `isinstance` is aliased
@@ -155,12 +155,12 @@ def _(flag: bool):
     # TODO: this should cause us to emit a diagnostic during
     # type checking
     if isinstance(x, "a"):
-        reveal_type(x)  # revealed: Literal[1, "a"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 
     # TODO: this should cause us to emit a diagnostic during
     # type checking
     if isinstance(x, "int"):
-        reveal_type(x)  # revealed: Literal[1, "a"]
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```
 
 ## Do not narrow if there are keyword arguments
@@ -169,15 +169,8 @@ def _(flag: bool):
 def _(flag: bool):
     x = 1 if flag else "a"
 
-    # error: [unknown-argument]
+    # TODO: this should cause us to emit a diagnostic
+    # (`isinstance` has no `foo` parameter)
     if isinstance(x, int, foo="bar"):
-        reveal_type(x)  # revealed: Literal[1, "a"]
-```
-
-## `type[]` types are narrowed as well as class-literal types
-
-```py
-def _(x: object, y: type[int]):
-    if isinstance(x, y):
-        reveal_type(x)  # revealed: int
+        reveal_type(x)  # revealed: Literal[1] | Literal["a"]
 ```

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

@@ -90,19 +90,15 @@ def _(t: type[object]):
         if issubclass(t, B):
             reveal_type(t)  # revealed: type[A] & type[B]
     else:
-        reveal_type(t)  # revealed: type & ~type[A]
+        reveal_type(t)  # revealed: type[object] & ~type[A]
 ```
 
 ### Handling of `None`
 
-`types.NoneType` is only available in Python 3.10 and later:
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
 ```py
+# TODO: this error should ideally go away once we (1) understand `sys.version_info` branches,
+# and (2) set the target Python version for this test to 3.10.
+# error: [possibly-unbound-import] "Member `NoneType` of module `types` is possibly unbound"
 from types import NoneType
 
 def _(flag: bool):
@@ -146,7 +142,7 @@ class A: ...
 
 t = object()
 
-# error: [invalid-argument-type]
+# TODO: we should emit a diagnostic here
 if issubclass(t, A):
     reveal_type(t)  # revealed: type[A]
 ```
@@ -160,7 +156,7 @@ branch:
 ```py
 t = 1
 
-# error: [invalid-argument-type]
+# TODO: we should emit a diagnostic here
 if issubclass(t, int):
     reveal_type(t)  # revealed: Never
 ```
@@ -234,15 +230,8 @@ def flag() -> bool: ...
 
 t = int if flag() else str
 
-# error: [unknown-argument]
+# TODO: this should cause us to emit a diagnostic
+# (`issubclass` has no `foo` parameter)
 if issubclass(t, int, foo="bar"):
     reveal_type(t)  # revealed: Literal[int, str]
 ```
-
-### `type[]` types are narrowed as well as class-literal types
-
-```py
-def _(x: type, y: type[int]):
-    if issubclass(x, y):
-        reveal_type(x)  # revealed: type[int]
-```

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

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

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

@@ -9,39 +9,39 @@ def foo() -> Literal[0, -1, True, False, "", "foo", b"", b"bar", None] | tuple[(
 x = foo()
 
 if x:
-    reveal_type(x)  # revealed: Literal[-1, True, "foo", b"bar"]
+    reveal_type(x)  # revealed: Literal[-1] | Literal[True] | Literal["foo"] | Literal[b"bar"]
 else:
-    reveal_type(x)  # revealed: Literal[0, False, "", b""] | None | tuple[()]
+    reveal_type(x)  # revealed: Literal[0] | Literal[False] | Literal[""] | Literal[b""] | None | tuple[()]
 
 if not x:
-    reveal_type(x)  # revealed: Literal[0, False, "", b""] | None | tuple[()]
+    reveal_type(x)  # revealed: Literal[0] | Literal[False] | Literal[""] | Literal[b""] | None | tuple[()]
 else:
-    reveal_type(x)  # revealed: Literal[-1, True, "foo", b"bar"]
+    reveal_type(x)  # revealed: Literal[-1] | Literal[True] | Literal["foo"] | Literal[b"bar"]
 
 if x and not x:
     reveal_type(x)  # revealed: Never
 else:
-    reveal_type(x)  # revealed: Literal[0, "", b"", -1, "foo", b"bar"] | bool | None | tuple[()]
+    reveal_type(x)  # revealed: Literal[-1, 0] | bool | Literal["", "foo"] | Literal[b"", b"bar"] | None | tuple[()]
 
 if not (x and not x):
-    reveal_type(x)  # revealed: Literal[0, "", b"", -1, "foo", b"bar"] | bool | None | tuple[()]
+    reveal_type(x)  # revealed: Literal[-1, 0] | bool | Literal["", "foo"] | Literal[b"", b"bar"] | None | tuple[()]
 else:
     reveal_type(x)  # revealed: Never
 
 if x or not x:
-    reveal_type(x)  # revealed: Literal[-1, "foo", b"bar", 0, "", b""] | bool | None | tuple[()]
+    reveal_type(x)  # revealed: Literal[-1, 0] | bool | Literal["foo", ""] | Literal[b"bar", b""] | None | tuple[()]
 else:
     reveal_type(x)  # revealed: Never
 
 if not (x or not x):
     reveal_type(x)  # revealed: Never
 else:
-    reveal_type(x)  # revealed: Literal[-1, "foo", b"bar", 0, "", b""] | bool | None | tuple[()]
+    reveal_type(x)  # revealed: Literal[-1, 0] | bool | Literal["foo", ""] | Literal[b"bar", b""] | None | tuple[()]
 
 if (isinstance(x, int) or isinstance(x, str)) and x:
-    reveal_type(x)  # revealed: Literal[-1, True, "foo"]
+    reveal_type(x)  # revealed: Literal[-1] | Literal[True] | Literal["foo"]
 else:
-    reveal_type(x)  # revealed: Literal[b"", b"bar", 0, False, ""] | None | tuple[()]
+    reveal_type(x)  # revealed: Literal[b"", b"bar"] | None | tuple[()] | Literal[0] | Literal[False] | Literal[""]
 ```
 
 ## Function Literals
@@ -166,16 +166,16 @@ y = literals()
 
 if isinstance(x, str) and not isinstance(x, B):
     reveal_type(x)  # revealed: A & str & ~B
-    reveal_type(y)  # revealed: Literal[0, 42, "", "hello"]
+    reveal_type(y)  # revealed: Literal[0, 42] | Literal["", "hello"]
 
     z = x if flag() else y
 
-    reveal_type(z)  # revealed: A & str & ~B | Literal[0, 42, "", "hello"]
+    reveal_type(z)  # revealed: A & str & ~B | Literal[0, 42] | Literal["", "hello"]
 
     if z:
-        reveal_type(z)  # revealed: A & str & ~B & ~AlwaysFalsy | Literal[42, "hello"]
+        reveal_type(z)  # revealed: A & str & ~B & ~AlwaysFalsy | Literal[42] | Literal["hello"]
     else:
-        reveal_type(z)  # revealed: A & str & ~B & ~AlwaysTruthy | Literal[0, ""]
+        reveal_type(z)  # revealed: A & str & ~B & ~AlwaysTruthy | Literal[0] | Literal[""]
 ```
 
 ## Narrowing Multiple Variables
@@ -219,97 +219,3 @@ else:
 # TODO: It should be A. We should improve UnionBuilder or IntersectionBuilder. (issue #15023)
 reveal_type(y)  # revealed: A & ~AlwaysTruthy | A & ~AlwaysFalsy
 ```
-
-## Truthiness of classes
-
-```py
-class MetaAmbiguous(type):
-    def __bool__(self) -> bool: ...
-
-class MetaFalsy(type):
-    def __bool__(self) -> Literal[False]: ...
-
-class MetaTruthy(type):
-    def __bool__(self) -> Literal[True]: ...
-
-class MetaDeferred(type):
-    def __bool__(self) -> MetaAmbiguous: ...
-
-class AmbiguousClass(metaclass=MetaAmbiguous): ...
-class FalsyClass(metaclass=MetaFalsy): ...
-class TruthyClass(metaclass=MetaTruthy): ...
-class DeferredClass(metaclass=MetaDeferred): ...
-
-def _(
-    a: type[AmbiguousClass],
-    t: type[TruthyClass],
-    f: type[FalsyClass],
-    d: type[DeferredClass],
-    ta: type[TruthyClass | AmbiguousClass],
-    af: type[AmbiguousClass] | type[FalsyClass],
-    flag: bool,
-):
-    reveal_type(ta)  # revealed: type[TruthyClass] | type[AmbiguousClass]
-    if ta:
-        reveal_type(ta)  # revealed: type[TruthyClass] | type[AmbiguousClass] & ~AlwaysFalsy
-
-    reveal_type(af)  # revealed: type[AmbiguousClass] | type[FalsyClass]
-    if af:
-        reveal_type(af)  # revealed: type[AmbiguousClass] & ~AlwaysFalsy
-
-    # TODO: Emit a diagnostic (`d` is not valid in boolean context)
-    if d:
-        # TODO: Should be `Unknown`
-        reveal_type(d)  # revealed: type[DeferredClass] & ~AlwaysFalsy
-
-    tf = TruthyClass if flag else FalsyClass
-    reveal_type(tf)  # revealed: Literal[TruthyClass, FalsyClass]
-
-    if tf:
-        reveal_type(tf)  # revealed: Literal[TruthyClass]
-    else:
-        reveal_type(tf)  # revealed: Literal[FalsyClass]
-```
-
-## Narrowing in chained boolean expressions
-
-```py
-from typing import Literal
-
-class A: ...
-
-def _(x: Literal[0, 1]):
-    reveal_type(x or A())  # revealed: Literal[1] | A
-    reveal_type(x and A())  # revealed: Literal[0] | A
-
-def _(x: str):
-    reveal_type(x or A())  # revealed: str & ~AlwaysFalsy | A
-    reveal_type(x and A())  # revealed: str & ~AlwaysTruthy | A
-
-def _(x: bool | str):
-    reveal_type(x or A())  # revealed: Literal[True] | str & ~AlwaysFalsy | A
-    reveal_type(x and A())  # revealed: Literal[False] | str & ~AlwaysTruthy | A
-
-class Falsy:
-    def __bool__(self) -> Literal[False]: ...
-
-class Truthy:
-    def __bool__(self) -> Literal[True]: ...
-
-def _(x: Falsy | Truthy):
-    reveal_type(x or A())  # revealed: Truthy | A
-    reveal_type(x and A())  # revealed: Falsy | A
-
-class MetaFalsy(type):
-    def __bool__(self) -> Literal[False]: ...
-
-class MetaTruthy(type):
-    def __bool__(self) -> Literal[True]: ...
-
-class FalsyClass(metaclass=MetaFalsy): ...
-class TruthyClass(metaclass=MetaTruthy): ...
-
-def _(x: type[FalsyClass] | type[TruthyClass]):
-    reveal_type(x or A())  # revealed: type[TruthyClass] | A
-    reveal_type(x and A())  # revealed: type[FalsyClass] | A
-```

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

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

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

@@ -25,29 +25,3 @@ def f(): ...
 
 f: int = 1
 ```
-
-## Explicit shadowing involving `def` statements
-
-Since a `def` statement is a declaration, one `def` can shadow another `def`, or shadow a previous
-non-`def` declaration, without error.
-
-```py
-f = 1
-reveal_type(f)  # revealed: Literal[1]
-
-def f(): ...
-
-reveal_type(f)  # revealed: Literal[f]
-
-def f(x: int) -> int:
-    raise NotImplementedError
-
-reveal_type(f)  # revealed: Literal[f]
-
-f: int = 1
-reveal_type(f)  # revealed: Literal[1]
-
-def f(): ...
-
-reveal_type(f)  # revealed: Literal[f]
-```

crates/red_knot_python_semantic/resources/mdtest/slots.md

@@ -1,184 +0,0 @@
-# `__slots__`
-
-## Not specified and empty
-
-```py
-class A: ...
-
-class B:
-    __slots__ = ()
-
-class C:
-    __slots__ = ("lorem", "ipsum")
-
-class AB(A, B): ...  # fine
-class AC(A, C): ...  # fine
-class BC(B, C): ...  # fine
-class ABC(A, B, C): ...  # fine
-```
-
-## Incompatible tuples
-
-```py
-class A:
-    __slots__ = ("a", "b")
-
-class B:
-    __slots__ = ("c", "d")
-
-class C(
-    A,  # error: [incompatible-slots]
-    B,  # error: [incompatible-slots]
-): ...
-```
-
-## Same value
-
-```py
-class A:
-    __slots__ = ("a", "b")
-
-class B:
-    __slots__ = ("a", "b")
-
-class C(
-    A,  # error: [incompatible-slots]
-    B,  # error: [incompatible-slots]
-): ...
-```
-
-## Strings
-
-```py
-class A:
-    __slots__ = "abc"
-
-class B:
-    __slots__ = ("abc",)
-
-class AB(
-    A,  # error: [incompatible-slots]
-    B,  # error: [incompatible-slots]
-): ...
-```
-
-## Invalid
-
-TODO: Emit diagnostics
-
-```py
-class NonString1:
-    __slots__ = 42
-
-class NonString2:
-    __slots__ = b"ar"
-
-class NonIdentifier1:
-    __slots__ = "42"
-
-class NonIdentifier2:
-    __slots__ = ("lorem", "42")
-
-class NonIdentifier3:
-    __slots__ = (e for e in ("lorem", "42"))
-```
-
-## Inheritance
-
-```py
-class A:
-    __slots__ = ("a", "b")
-
-class B(A): ...
-
-class C:
-    __slots__ = ("c", "d")
-
-class D(C): ...
-class E(
-    B,  # error: [incompatible-slots]
-    D,  # error: [incompatible-slots]
-): ...
-```
-
-## Single solid base
-
-```py
-class A:
-    __slots__ = ("a", "b")
-
-class B(A): ...
-class C(A): ...
-class D(B, A): ...  # fine
-class E(B, C, A): ...  # fine
-```
-
-## False negatives
-
-### Possibly unbound
-
-```py
-def _(flag: bool):
-    class A:
-        if flag:
-            __slots__ = ("a", "b")
-
-    class B:
-        __slots__ = ("c", "d")
-
-    # Might or might not be fine at runtime
-    class C(A, B): ...
-```
-
-### Bound but with different types
-
-```py
-def _(flag: bool):
-    class A:
-        if flag:
-            __slots__ = ("a", "b")
-        else:
-            __slots__ = ()
-
-    class B:
-        __slots__ = ("c", "d")
-
-    # Might or might not be fine at runtime
-    class C(A, B): ...
-```
-
-### Non-tuples
-
-```py
-class A:
-    __slots__ = ["a", "b"]  # This is treated as "dynamic"
-
-class B:
-    __slots__ = ("c", "d")
-
-# False negative: [incompatible-slots]
-class C(A, B): ...
-```
-
-### Post-hoc modifications
-
-```py
-class A:
-    __slots__ = ()
-    __slots__ += ("a", "b")
-
-reveal_type(A.__slots__)  # revealed: @Todo(return type)
-
-class B:
-    __slots__ = ("c", "d")
-
-# False negative: [incompatible-slots]
-class C(A, B): ...
-```
-
-### Built-ins with implicit layouts
-
-```py
-# False negative: [incompatible-slots]
-class A(int, str): ...
-```

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

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

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

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

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

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

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

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

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

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

crates/red_knot_python_semantic/resources/mdtest/sys_platform.md

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

crates/red_knot_python_semantic/resources/mdtest/type_api.md

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

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

@@ -142,25 +142,3 @@ class Foo(type[int]): ...
 # TODO: should be `tuple[Literal[Foo], Literal[type], Literal[object]]
 reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
 ```
-
-## `@final` classes
-
-`type[]` types are eagerly converted to class-literal types if a class decorated with `@final` is
-used as the type argument. This applies to standard-library classes and user-defined classes:
-
-```toml
-[environment]
-python-version = "3.10"
-```
-
-```py
-from types import EllipsisType
-from typing import final
-
-@final
-class Foo: ...
-
-def _(x: type[Foo], y: type[EllipsisType]):
-    reveal_type(x)  # revealed: Literal[Foo]
-    reveal_type(y)  # revealed: Literal[EllipsisType]
-```

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

@@ -47,8 +47,9 @@ x: type = A()  # error: [invalid-assignment]
 
 ```py
 def f(x: type[object]):
-    reveal_type(x)  # revealed: type
-    reveal_type(x.__repr__)  # revealed: @Todo(instance attributes)
+    reveal_type(x)  # revealed: type[object]
+    # TODO: bound method types
+    reveal_type(x.__repr__)  # revealed: Literal[__repr__]
 
 class A: ...
 

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_assignable_to.md

@@ -1,352 +0,0 @@
-# Assignable-to relation
-
-The `is_assignable_to(S, T)` relation below checks if type `S` is assignable to type `T` (target).
-This allows us to check if a type `S` can be used in a context where a type `T` is expected
-(function arguments, variable assignments). See the [typing documentation] for a precise definition
-of this concept.
-
-## Basic types
-
-### Fully static
-
-Fully static types participate in subtyping. If a type `S` is a subtype of `T`, `S` will also be
-assignable to `T`. Two equivalent types are subtypes of each other:
-
-```py
-from knot_extensions import static_assert, is_assignable_to
-
-class Parent: ...
-class Child1(Parent): ...
-class Child2(Parent): ...
-class Grandchild(Child1, Child2): ...
-class Unrelated: ...
-
-static_assert(is_assignable_to(int, int))
-static_assert(is_assignable_to(Parent, Parent))
-static_assert(is_assignable_to(Child1, Parent))
-static_assert(is_assignable_to(Grandchild, Parent))
-static_assert(is_assignable_to(Unrelated, Unrelated))
-
-static_assert(not is_assignable_to(str, int))
-static_assert(not is_assignable_to(object, int))
-static_assert(not is_assignable_to(Parent, Child1))
-static_assert(not is_assignable_to(Unrelated, Parent))
-static_assert(not is_assignable_to(Child1, Child2))
-```
-
-### Gradual types
-
-Gradual types do not participate in subtyping, but can still be assignable to other types (and
-static types can be assignable to gradual types):
-
-```py
-from knot_extensions import static_assert, is_assignable_to, Unknown
-from typing import Any
-
-static_assert(is_assignable_to(Unknown, Literal[1]))
-static_assert(is_assignable_to(Any, Literal[1]))
-static_assert(is_assignable_to(Literal[1], Unknown))
-static_assert(is_assignable_to(Literal[1], Any))
-```
-
-## Literal types
-
-### Boolean literals
-
-`Literal[True]` and `Literal[False]` are both subtypes of (and therefore assignable to) `bool`,
-which is in turn a subtype of `int`:
-
-```py
-from knot_extensions import static_assert, is_assignable_to
-from typing import Literal
-
-static_assert(is_assignable_to(Literal[True], Literal[True]))
-static_assert(is_assignable_to(Literal[True], bool))
-static_assert(is_assignable_to(Literal[True], int))
-
-static_assert(not is_assignable_to(Literal[True], Literal[False]))
-static_assert(not is_assignable_to(bool, Literal[True]))
-```
-
-### Integer literals
-
-```py
-from knot_extensions import static_assert, is_assignable_to
-from typing import Literal
-
-static_assert(is_assignable_to(Literal[1], Literal[1]))
-static_assert(is_assignable_to(Literal[1], int))
-
-static_assert(not is_assignable_to(Literal[1], Literal[2]))
-static_assert(not is_assignable_to(int, Literal[1]))
-static_assert(not is_assignable_to(Literal[1], str))
-```
-
-### String literals and `LiteralString`
-
-All string-literal types are subtypes of (and therefore assignable to) `LiteralString`, which is in
-turn a subtype of `str`:
-
-```py
-from knot_extensions import static_assert, is_assignable_to
-from typing_extensions import Literal, LiteralString
-
-static_assert(is_assignable_to(Literal["foo"], Literal["foo"]))
-static_assert(is_assignable_to(Literal["foo"], LiteralString))
-static_assert(is_assignable_to(Literal["foo"], str))
-
-static_assert(is_assignable_to(LiteralString, str))
-
-static_assert(not is_assignable_to(Literal["foo"], Literal["bar"]))
-static_assert(not is_assignable_to(str, Literal["foo"]))
-static_assert(not is_assignable_to(str, LiteralString))
-```
-
-### Byte literals
-
-```py
-from knot_extensions import static_assert, is_assignable_to
-from typing_extensions import Literal, LiteralString
-
-static_assert(is_assignable_to(Literal[b"foo"], bytes))
-static_assert(is_assignable_to(Literal[b"foo"], Literal[b"foo"]))
-
-static_assert(not is_assignable_to(Literal[b"foo"], str))
-static_assert(not is_assignable_to(Literal[b"foo"], LiteralString))
-static_assert(not is_assignable_to(Literal[b"foo"], Literal[b"bar"]))
-static_assert(not is_assignable_to(Literal[b"foo"], Literal["foo"]))
-static_assert(not is_assignable_to(Literal["foo"], Literal[b"foo"]))
-```
-
-## `type[…]` and class literals
-
-In the following tests, `TypeOf[str]` is a singleton type with a single inhabitant, the class `str`.
-This contrasts with `type[str]`, which represents "all possible subclasses of `str`".
-
-Both `TypeOf[str]` and `type[str]` are subtypes of `type` and `type[object]`, which both represent
-"all possible instances of `type`"; therefore both `type[str]` and `TypeOf[str]` are assignable to
-`type`. `type[Any]`, on the other hand, represents a type of unknown size or inhabitants, but which
-is known to be no larger than the set of possible objects represented by `type`.
-
-```py
-from knot_extensions import static_assert, is_assignable_to, Unknown, TypeOf
-from typing import Any
-
-static_assert(is_assignable_to(type, type))
-static_assert(is_assignable_to(type[object], type[object]))
-
-static_assert(is_assignable_to(type, type[object]))
-static_assert(is_assignable_to(type[object], type))
-
-static_assert(is_assignable_to(type[str], type[object]))
-static_assert(is_assignable_to(TypeOf[str], type[object]))
-static_assert(is_assignable_to(type[str], type))
-static_assert(is_assignable_to(TypeOf[str], type))
-
-static_assert(is_assignable_to(type[str], type[str]))
-static_assert(is_assignable_to(TypeOf[str], type[str]))
-
-static_assert(not is_assignable_to(TypeOf[int], type[str]))
-static_assert(not is_assignable_to(type, type[str]))
-static_assert(not is_assignable_to(type[object], type[str]))
-
-static_assert(is_assignable_to(type[Any], type[Any]))
-static_assert(is_assignable_to(type[Any], type[object]))
-static_assert(is_assignable_to(type[object], type[Any]))
-static_assert(is_assignable_to(type, type[Any]))
-static_assert(is_assignable_to(type[Any], type[str]))
-static_assert(is_assignable_to(type[str], type[Any]))
-static_assert(is_assignable_to(TypeOf[str], type[Any]))
-
-static_assert(is_assignable_to(type[Unknown], type[Unknown]))
-static_assert(is_assignable_to(type[Unknown], type[object]))
-static_assert(is_assignable_to(type[object], type[Unknown]))
-static_assert(is_assignable_to(type, type[Unknown]))
-static_assert(is_assignable_to(type[Unknown], type[str]))
-static_assert(is_assignable_to(type[str], type[Unknown]))
-static_assert(is_assignable_to(TypeOf[str], type[Unknown]))
-
-static_assert(is_assignable_to(type[Unknown], type[Any]))
-static_assert(is_assignable_to(type[Any], type[Unknown]))
-
-static_assert(not is_assignable_to(object, type[Any]))
-static_assert(not is_assignable_to(str, type[Any]))
-
-class Meta(type): ...
-
-static_assert(is_assignable_to(type[Any], Meta))
-static_assert(is_assignable_to(type[Unknown], Meta))
-static_assert(is_assignable_to(Meta, type[Any]))
-static_assert(is_assignable_to(Meta, type[Unknown]))
-```
-
-## Tuple types
-
-```py
-from knot_extensions import static_assert, is_assignable_to
-from typing import Literal, Any
-
-static_assert(is_assignable_to(tuple[()], tuple[()]))
-static_assert(is_assignable_to(tuple[int], tuple[int]))
-static_assert(is_assignable_to(tuple[int], tuple[Any]))
-static_assert(is_assignable_to(tuple[Any], tuple[int]))
-static_assert(is_assignable_to(tuple[int, str], tuple[int, str]))
-static_assert(is_assignable_to(tuple[Literal[1], Literal[2]], tuple[int, int]))
-static_assert(is_assignable_to(tuple[Any, Literal[2]], tuple[int, int]))
-static_assert(is_assignable_to(tuple[Literal[1], Any], tuple[int, int]))
-
-static_assert(not is_assignable_to(tuple[()], tuple[int]))
-static_assert(not is_assignable_to(tuple[int], tuple[str]))
-static_assert(not is_assignable_to(tuple[int], tuple[int, str]))
-static_assert(not is_assignable_to(tuple[int, str], tuple[int]))
-static_assert(not is_assignable_to(tuple[int, int], tuple[Literal[1], int]))
-static_assert(not is_assignable_to(tuple[Any, Literal[2]], tuple[int, str]))
-```
-
-## Union types
-
-```py
-from knot_extensions import static_assert, is_assignable_to, Unknown
-from typing import Literal, Any
-
-static_assert(is_assignable_to(int, int | str))
-static_assert(is_assignable_to(str, int | str))
-static_assert(is_assignable_to(int | str, int | str))
-static_assert(is_assignable_to(str | int, int | str))
-static_assert(is_assignable_to(Literal[1], int | str))
-static_assert(is_assignable_to(Literal[1], Unknown | str))
-static_assert(is_assignable_to(Literal[1] | Literal[2], Literal[1] | Literal[2]))
-static_assert(is_assignable_to(Literal[1] | Literal[2], int))
-static_assert(is_assignable_to(Literal[1] | None, int | None))
-static_assert(is_assignable_to(Any, int | str))
-static_assert(is_assignable_to(Any | int, int))
-static_assert(is_assignable_to(str, int | Any))
-
-static_assert(not is_assignable_to(int | None, int))
-static_assert(not is_assignable_to(int | None, str | None))
-static_assert(not is_assignable_to(Literal[1] | None, int))
-static_assert(not is_assignable_to(Literal[1] | None, str | None))
-static_assert(not is_assignable_to(Any | int | str, int))
-```
-
-## Intersection types
-
-```py
-from knot_extensions import static_assert, is_assignable_to, Intersection, Not
-from typing_extensions import Any, Literal
-
-class Parent: ...
-class Child1(Parent): ...
-class Child2(Parent): ...
-class Grandchild(Child1, Child2): ...
-class Unrelated: ...
-
-static_assert(is_assignable_to(Intersection[Child1, Child2], Child1))
-static_assert(is_assignable_to(Intersection[Child1, Child2], Child2))
-static_assert(is_assignable_to(Intersection[Child1, Child2], Parent))
-static_assert(is_assignable_to(Intersection[Child1, Parent], Parent))
-
-static_assert(is_assignable_to(Intersection[Parent, Unrelated], Parent))
-static_assert(is_assignable_to(Intersection[Child1, Unrelated], Child1))
-
-static_assert(is_assignable_to(Intersection[Child1, Not[Child2]], Child1))
-static_assert(is_assignable_to(Intersection[Child1, Not[Child2]], Parent))
-static_assert(is_assignable_to(Intersection[Child1, Not[Grandchild]], Parent))
-
-static_assert(is_assignable_to(Intersection[Child1, Child2], Intersection[Child1, Child2]))
-static_assert(is_assignable_to(Intersection[Child1, Child2], Intersection[Child2, Child1]))
-static_assert(is_assignable_to(Grandchild, Intersection[Child1, Child2]))
-
-static_assert(not is_assignable_to(Parent, Intersection[Parent, Unrelated]))
-static_assert(not is_assignable_to(int, Intersection[int, Not[Literal[1]]]))
-static_assert(not is_assignable_to(int, Not[int]))
-static_assert(not is_assignable_to(int, Not[Literal[1]]))
-
-static_assert(not is_assignable_to(Intersection[Any, Parent], Unrelated))
-
-# TODO: The following assertions should not fail (see https://github.com/astral-sh/ruff/issues/14899)
-# error: [static-assert-error]
-static_assert(is_assignable_to(Intersection[Any, int], int))
-
-# error: [static-assert-error]
-static_assert(is_assignable_to(Intersection[Unrelated, Any], Intersection[Unrelated, Any]))
-# error: [static-assert-error]
-static_assert(is_assignable_to(Intersection[Unrelated, Any], Intersection[Unrelated, Not[Any]]))
-# error: [static-assert-error]
-static_assert(is_assignable_to(Intersection[Unrelated, Any], Not[tuple[Unrelated, Any]]))
-```
-
-## General properties
-
-See also: our property tests in `property_tests.rs`.
-
-### Everything is assignable to `object`
-
-`object` is Python's top type; the set of all possible objects at runtime:
-
-```py
-from knot_extensions import static_assert, is_assignable_to, Unknown
-from typing import Literal, Any
-
-static_assert(is_assignable_to(str, object))
-static_assert(is_assignable_to(Literal[1], object))
-static_assert(is_assignable_to(object, object))
-static_assert(is_assignable_to(type, object))
-static_assert(is_assignable_to(Any, object))
-static_assert(is_assignable_to(Unknown, object))
-static_assert(is_assignable_to(type[object], object))
-static_assert(is_assignable_to(type[str], object))
-static_assert(is_assignable_to(type[Any], object))
-```
-
-### Every type is assignable to `Any` / `Unknown`
-
-`Any` and `Unknown` are gradual types. They could materialize to any given type at runtime, and so
-any type is assignable to them:
-
-```py
-from knot_extensions import static_assert, is_assignable_to, Unknown
-from typing import Literal, Any
-
-static_assert(is_assignable_to(str, Any))
-static_assert(is_assignable_to(Literal[1], Any))
-static_assert(is_assignable_to(object, Any))
-static_assert(is_assignable_to(type, Any))
-static_assert(is_assignable_to(Any, Any))
-static_assert(is_assignable_to(Unknown, Any))
-static_assert(is_assignable_to(type[object], Any))
-static_assert(is_assignable_to(type[str], Any))
-static_assert(is_assignable_to(type[Any], Any))
-
-static_assert(is_assignable_to(str, Unknown))
-static_assert(is_assignable_to(Literal[1], Unknown))
-static_assert(is_assignable_to(object, Unknown))
-static_assert(is_assignable_to(type, Unknown))
-static_assert(is_assignable_to(Any, Unknown))
-static_assert(is_assignable_to(Unknown, Unknown))
-static_assert(is_assignable_to(type[object], Unknown))
-static_assert(is_assignable_to(type[str], Unknown))
-static_assert(is_assignable_to(type[Any], Unknown))
-```
-
-### `Never` is assignable to every type
-
-`Never` is Python's bottom type: the empty set, a type with no inhabitants. It is therefore
-assignable to any arbitrary type.
-
-```py
-from knot_extensions import static_assert, is_assignable_to, Unknown
-from typing_extensions import Never, Any
-
-static_assert(is_assignable_to(Never, str))
-static_assert(is_assignable_to(Never, Literal[1]))
-static_assert(is_assignable_to(Never, object))
-static_assert(is_assignable_to(Never, type))
-static_assert(is_assignable_to(Never, Any))
-static_assert(is_assignable_to(Never, Unknown))
-static_assert(is_assignable_to(Never, type[object]))
-static_assert(is_assignable_to(Never, type[str]))
-static_assert(is_assignable_to(Never, type[Any]))
-```
-
-[typing documentation]: https://typing.readthedocs.io/en/latest/spec/concepts.html#the-assignable-to-or-consistent-subtyping-relation

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

@@ -1,169 +0,0 @@
-# Custom unary operations
-
-## Class instances
-
-```py
-class Yes:
-    def __pos__(self) -> bool:
-        return False
-
-    def __neg__(self) -> str:
-        return "negative"
-
-    def __invert__(self) -> int:
-        return 17
-
-class Sub(Yes): ...
-class No: ...
-
-reveal_type(+Yes())  # revealed: bool
-reveal_type(-Yes())  # revealed: str
-reveal_type(~Yes())  # revealed: int
-
-reveal_type(+Sub())  # revealed: bool
-reveal_type(-Sub())  # revealed: str
-reveal_type(~Sub())  # revealed: int
-
-# error: [unsupported-operator] "Unary operator `+` is unsupported for type `No`"
-reveal_type(+No())  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `-` is unsupported for type `No`"
-reveal_type(-No())  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `~` is unsupported for type `No`"
-reveal_type(~No())  # revealed: Unknown
-```
-
-## Classes
-
-Dunder methods defined in a class are available to instances of that class, but not to the class
-itself. (For these operators to work on the class itself, they would have to be defined on the
-class's type, i.e. `type`.)
-
-```py
-class Yes:
-    def __pos__(self) -> bool:
-        return False
-
-    def __neg__(self) -> str:
-        return "negative"
-
-    def __invert__(self) -> int:
-        return 17
-
-class Sub(Yes): ...
-class No: ...
-
-# error: [unsupported-operator] "Unary operator `+` is unsupported for type `Literal[Yes]`"
-reveal_type(+Yes)  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `-` is unsupported for type `Literal[Yes]`"
-reveal_type(-Yes)  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `~` is unsupported for type `Literal[Yes]`"
-reveal_type(~Yes)  # revealed: Unknown
-
-# error: [unsupported-operator] "Unary operator `+` is unsupported for type `Literal[Sub]`"
-reveal_type(+Sub)  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `-` is unsupported for type `Literal[Sub]`"
-reveal_type(-Sub)  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `~` is unsupported for type `Literal[Sub]`"
-reveal_type(~Sub)  # revealed: Unknown
-
-# error: [unsupported-operator] "Unary operator `+` is unsupported for type `Literal[No]`"
-reveal_type(+No)  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `-` is unsupported for type `Literal[No]`"
-reveal_type(-No)  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `~` is unsupported for type `Literal[No]`"
-reveal_type(~No)  # revealed: Unknown
-```
-
-## Function literals
-
-```py
-def f():
-    pass
-
-# error: [unsupported-operator] "Unary operator `+` is unsupported for type `Literal[f]`"
-reveal_type(+f)  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `-` is unsupported for type `Literal[f]`"
-reveal_type(-f)  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `~` is unsupported for type `Literal[f]`"
-reveal_type(~f)  # revealed: Unknown
-```
-
-## Subclass
-
-```py
-class Yes:
-    def __pos__(self) -> bool:
-        return False
-
-    def __neg__(self) -> str:
-        return "negative"
-
-    def __invert__(self) -> int:
-        return 17
-
-class Sub(Yes): ...
-class No: ...
-
-def yes() -> type[Yes]:
-    return Yes
-
-def sub() -> type[Sub]:
-    return Sub
-
-def no() -> type[No]:
-    return No
-
-# error: [unsupported-operator] "Unary operator `+` is unsupported for type `type[Yes]`"
-reveal_type(+yes())  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `-` is unsupported for type `type[Yes]`"
-reveal_type(-yes())  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `~` is unsupported for type `type[Yes]`"
-reveal_type(~yes())  # revealed: Unknown
-
-# error: [unsupported-operator] "Unary operator `+` is unsupported for type `type[Sub]`"
-reveal_type(+sub())  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `-` is unsupported for type `type[Sub]`"
-reveal_type(-sub())  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `~` is unsupported for type `type[Sub]`"
-reveal_type(~sub())  # revealed: Unknown
-
-# error: [unsupported-operator] "Unary operator `+` is unsupported for type `type[No]`"
-reveal_type(+no())  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `-` is unsupported for type `type[No]`"
-reveal_type(-no())  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `~` is unsupported for type `type[No]`"
-reveal_type(~no())  # revealed: Unknown
-```
-
-## Metaclass
-
-```py
-class Meta(type):
-    def __pos__(self) -> bool:
-        return False
-
-    def __neg__(self) -> str:
-        return "negative"
-
-    def __invert__(self) -> int:
-        return 17
-
-class Yes(metaclass=Meta): ...
-class Sub(Yes): ...
-class No: ...
-
-reveal_type(+Yes)  # revealed: bool
-reveal_type(-Yes)  # revealed: str
-reveal_type(~Yes)  # revealed: int
-
-reveal_type(+Sub)  # revealed: bool
-reveal_type(-Sub)  # revealed: str
-reveal_type(~Sub)  # revealed: int
-
-# error: [unsupported-operator] "Unary operator `+` is unsupported for type `Literal[No]`"
-reveal_type(+No)  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `-` is unsupported for type `Literal[No]`"
-reveal_type(-No)  # revealed: Unknown
-# error: [unsupported-operator] "Unary operator `~` is unsupported for type `Literal[No]`"
-reveal_type(~No)  # revealed: Unknown
-```

crates/red_knot_python_semantic/resources/mdtest/unpacking.md

@@ -61,7 +61,7 @@ reveal_type(c)  # revealed: Literal[4]
 ### Uneven unpacking (1)
 
 ```py
-# error: [invalid-assignment] "Not enough values to unpack (expected 3, got 2)"
+# TODO: Add diagnostic (there aren't enough values to unpack)
 (a, b, c) = (1, 2)
 reveal_type(a)  # revealed: Literal[1]
 reveal_type(b)  # revealed: Literal[2]
@@ -71,7 +71,7 @@ reveal_type(c)  # revealed: Unknown
 ### Uneven unpacking (2)
 
 ```py
-# error: [invalid-assignment] "Too many values to unpack (expected 2, got 3)"
+# TODO: Add diagnostic (too many values to unpack)
 (a, b) = (1, 2, 3)
 reveal_type(a)  # revealed: Literal[1]
 reveal_type(b)  # revealed: Literal[2]
@@ -80,7 +80,7 @@ reveal_type(b)  # revealed: Literal[2]
 ### Starred expression (1)
 
 ```py
-# error: [invalid-assignment] "Not enough values to unpack (expected 3 or more, got 2)"
+# TODO: Add diagnostic (need more values to unpack)
 [a, *b, c, d] = (1, 2)
 reveal_type(a)  # revealed: Literal[1]
 # TODO: Should be list[Any] once support for assigning to starred expression is added
@@ -133,7 +133,7 @@ reveal_type(c)  # revealed: @Todo(starred unpacking)
 ### Starred expression (6)
 
 ```py
-# error: [invalid-assignment] "Not enough values to unpack (expected 5 or more, got 1)"
+# TODO: Add diagnostic (need more values to unpack)
 (a, b, c, *d, e, f) = (1,)
 reveal_type(a)  # revealed: Literal[1]
 reveal_type(b)  # revealed: Unknown
@@ -199,7 +199,7 @@ reveal_type(b)  # revealed: LiteralString
 ### Uneven unpacking (1)
 
 ```py
-# error: [invalid-assignment] "Not enough values to unpack (expected 3, got 2)"
+# TODO: Add diagnostic (there aren't enough values to unpack)
 a, b, c = "ab"
 reveal_type(a)  # revealed: LiteralString
 reveal_type(b)  # revealed: LiteralString
@@ -209,7 +209,7 @@ reveal_type(c)  # revealed: Unknown
 ### Uneven unpacking (2)
 
 ```py
-# error: [invalid-assignment] "Too many values to unpack (expected 2, got 3)"
+# TODO: Add diagnostic (too many values to unpack)
 a, b = "abc"
 reveal_type(a)  # revealed: LiteralString
 reveal_type(b)  # revealed: LiteralString
@@ -218,7 +218,7 @@ reveal_type(b)  # revealed: LiteralString
 ### Starred expression (1)
 
 ```py
-# error: [invalid-assignment] "Not enough values to unpack (expected 3 or more, got 2)"
+# TODO: Add diagnostic (need more values to unpack)
 (a, *b, c, d) = "ab"
 reveal_type(a)  # revealed: LiteralString
 # TODO: Should be list[LiteralString] once support for assigning to starred expression is added
@@ -271,7 +271,7 @@ reveal_type(c)  # revealed: @Todo(starred unpacking)
 ### Unicode
 
 ```py
-# error: [invalid-assignment] "Not enough values to unpack (expected 2, got 1)"
+# TODO: Add diagnostic (need more values to unpack)
 (a, b) = "é"
 
 reveal_type(a)  # revealed: LiteralString
@@ -281,7 +281,7 @@ reveal_type(b)  # revealed: Unknown
 ### Unicode escape (1)
 
 ```py
-# error: [invalid-assignment] "Not enough values to unpack (expected 2, got 1)"
+# TODO: Add diagnostic (need more values to unpack)
 (a, b) = "\u9E6C"
 
 reveal_type(a)  # revealed: LiteralString
@@ -291,7 +291,7 @@ reveal_type(b)  # revealed: Unknown
 ### Unicode escape (2)
 
 ```py
-# error: [invalid-assignment] "Not enough values to unpack (expected 2, got 1)"
+# TODO: Add diagnostic (need more values to unpack)
 (a, b) = "\U0010FFFF"
 
 reveal_type(a)  # revealed: LiteralString
@@ -306,273 +306,3 @@ reveal_type(b)  # revealed: Unknown
 reveal_type(a)  # revealed: LiteralString
 reveal_type(b)  # revealed: LiteralString
 ```
-
-## Union
-
-### Same types
-
-Union of two tuples of equal length and each element is of the same type.
-
-```py
-def _(arg: tuple[int, int] | tuple[int, int]):
-    (a, b) = arg
-    reveal_type(a)  # revealed: int
-    reveal_type(b)  # revealed: int
-```
-
-### Mixed types (1)
-
-Union of two tuples of equal length and one element differs in its type.
-
-```py
-def _(arg: tuple[int, int] | tuple[int, str]):
-    a, b = arg
-    reveal_type(a)  # revealed: int
-    reveal_type(b)  # revealed: int | str
-```
-
-### Mixed types (2)
-
-Union of two tuples of equal length and both the element types are different.
-
-```py
-def _(arg: tuple[int, str] | tuple[str, int]):
-    a, b = arg
-    reveal_type(a)  # revealed: int | str
-    reveal_type(b)  # revealed: str | int
-```
-
-### Mixed types (3)
-
-Union of three tuples of equal length and various combination of element types:
-
-1. All same types
-1. One different type
-1. All different types
-
-```py
-def _(arg: tuple[int, int, int] | tuple[int, str, bytes] | tuple[int, int, str]):
-    a, b, c = arg
-    reveal_type(a)  # revealed: int
-    reveal_type(b)  # revealed: int | str
-    reveal_type(c)  # revealed: int | bytes | str
-```
-
-### Nested
-
-```py
-def _(arg: tuple[int, tuple[str, bytes]] | tuple[tuple[int, bytes], Literal["ab"]]):
-    a, (b, c) = arg
-    reveal_type(a)  # revealed: int | tuple[int, bytes]
-    reveal_type(b)  # revealed: str
-    reveal_type(c)  # revealed: bytes | LiteralString
-```
-
-### Starred expression
-
-```py
-def _(arg: tuple[int, bytes, int] | tuple[int, int, str, int, bytes]):
-    a, *b, c = arg
-    reveal_type(a)  # revealed: int
-    # TODO: Should be `list[bytes | int | str]`
-    reveal_type(b)  # revealed: @Todo(starred unpacking)
-    reveal_type(c)  # revealed: int | bytes
-```
-
-### Size mismatch (1)
-
-```py
-def _(arg: tuple[int, bytes, int] | tuple[int, int, str, int, bytes]):
-    # error: [invalid-assignment] "Too many values to unpack (expected 2, got 3)"
-    # error: [invalid-assignment] "Too many values to unpack (expected 2, got 5)"
-    a, b = arg
-    reveal_type(a)  # revealed: int
-    reveal_type(b)  # revealed: bytes | int
-```
-
-### Size mismatch (2)
-
-```py
-def _(arg: tuple[int, bytes] | tuple[int, str]):
-    # error: [invalid-assignment] "Not enough values to unpack (expected 3, got 2)"
-    # error: [invalid-assignment] "Not enough values to unpack (expected 3, got 2)"
-    a, b, c = arg
-    reveal_type(a)  # revealed: int
-    reveal_type(b)  # revealed: bytes | str
-    reveal_type(c)  # revealed: Unknown
-```
-
-### Same literal types
-
-```py
-def _(flag: bool):
-    if flag:
-        value = (1, 2)
-    else:
-        value = (3, 4)
-
-    a, b = value
-    reveal_type(a)  # revealed: Literal[1, 3]
-    reveal_type(b)  # revealed: Literal[2, 4]
-```
-
-### Mixed literal types
-
-```py
-def _(flag: bool):
-    if flag:
-        value = (1, 2)
-    else:
-        value = ("a", "b")
-
-    a, b = value
-    reveal_type(a)  # revealed: Literal[1, "a"]
-    reveal_type(b)  # revealed: Literal[2, "b"]
-```
-
-### Typing literal
-
-```py
-from typing import Literal
-
-def _(arg: tuple[int, int] | Literal["ab"]):
-    a, b = arg
-    reveal_type(a)  # revealed: int | LiteralString
-    reveal_type(b)  # revealed: int | LiteralString
-```
-
-### Custom iterator (1)
-
-```py
-class Iterator:
-    def __next__(self) -> tuple[int, int] | tuple[int, str]:
-        return (1, 2)
-
-class Iterable:
-    def __iter__(self) -> Iterator:
-        return Iterator()
-
-((a, b), c) = Iterable()
-reveal_type(a)  # revealed: int
-reveal_type(b)  # revealed: int | str
-reveal_type(c)  # revealed: tuple[int, int] | tuple[int, str]
-```
-
-### Custom iterator (2)
-
-```py
-class Iterator:
-    def __next__(self) -> bytes:
-        return b""
-
-class Iterable:
-    def __iter__(self) -> Iterator:
-        return Iterator()
-
-def _(arg: tuple[int, str] | Iterable):
-    a, b = arg
-    reveal_type(a)  # revealed: int | bytes
-    reveal_type(b)  # revealed: str | bytes
-```
-
-## For statement
-
-Unpacking in a `for` statement.
-
-### Same types
-
-```py
-def _(arg: tuple[tuple[int, int], tuple[int, int]]):
-    for a, b in arg:
-        reveal_type(a)  # revealed: int
-        reveal_type(b)  # revealed: int
-```
-
-### Mixed types (1)
-
-```py
-def _(arg: tuple[tuple[int, int], tuple[int, str]]):
-    for a, b in arg:
-        reveal_type(a)  # revealed: int
-        reveal_type(b)  # revealed: int | str
-```
-
-### Mixed types (2)
-
-```py
-def _(arg: tuple[tuple[int, str], tuple[str, int]]):
-    for a, b in arg:
-        reveal_type(a)  # revealed: int | str
-        reveal_type(b)  # revealed: str | int
-```
-
-### Mixed types (3)
-
-```py
-def _(arg: tuple[tuple[int, int, int], tuple[int, str, bytes], tuple[int, int, str]]):
-    for a, b, c in arg:
-        reveal_type(a)  # revealed: int
-        reveal_type(b)  # revealed: int | str
-        reveal_type(c)  # revealed: int | bytes | str
-```
-
-### Same literal values
-
-```py
-for a, b in ((1, 2), (3, 4)):
-    reveal_type(a)  # revealed: Literal[1, 3]
-    reveal_type(b)  # revealed: Literal[2, 4]
-```
-
-### Mixed literal values (1)
-
-```py
-for a, b in ((1, 2), ("a", "b")):
-    reveal_type(a)  # revealed: Literal[1, "a"]
-    reveal_type(b)  # revealed: Literal[2, "b"]
-```
-
-### Mixed literals values (2)
-
-```py
-# error: "Object of type `Literal[1]` is not iterable"
-# error: "Object of type `Literal[2]` is not iterable"
-# error: "Object of type `Literal[4]` is not iterable"
-# error: [invalid-assignment] "Not enough values to unpack (expected 2, got 1)"
-for a, b in (1, 2, (3, "a"), 4, (5, "b"), "c"):
-    reveal_type(a)  # revealed: Unknown | Literal[3, 5] | LiteralString
-    reveal_type(b)  # revealed: Unknown | Literal["a", "b"]
-```
-
-### Custom iterator (1)
-
-```py
-class Iterator:
-    def __next__(self) -> tuple[int, int]:
-        return (1, 2)
-
-class Iterable:
-    def __iter__(self) -> Iterator:
-        return Iterator()
-
-for a, b in Iterable():
-    reveal_type(a)  # revealed: int
-    reveal_type(b)  # revealed: int
-```
-
-### Custom iterator (2)
-
-```py
-class Iterator:
-    def __next__(self) -> bytes:
-        return b""
-
-class Iterable:
-    def __iter__(self) -> Iterator:
-        return Iterator()
-
-def _(arg: tuple[tuple[int, str], Iterable]):
-    for a, b in arg:
-        reveal_type(a)  # revealed: int | bytes
-        reveal_type(b)  # revealed: str | bytes
-```

crates/red_knot_python_semantic/resources/mdtest/with/async.md

@@ -17,5 +17,5 @@ class Manager:
 
 async def test():
     async with Manager() as f:
-        reveal_type(f)  # revealed: @Todo(async `with` statement)
+        reveal_type(f)  # revealed: @Todo(async with statement)
 ```

crates/red_knot_python_semantic/src/ast_node_ref.rs

@@ -43,7 +43,7 @@ impl<T> AstNodeRef<T> {
     }
 
     /// Returns a reference to the wrapped node.
-    pub const fn node(&self) -> &T {
+    pub fn node(&self) -> &T {
         // SAFETY: Holding on to `parsed` ensures that the AST to which `node` belongs is still
         // alive and not moved.
         unsafe { self.node.as_ref() }

crates/red_knot_python_semantic/src/db.rs

@@ -1,4 +1,4 @@
-use crate::lint::{LintRegistry, RuleSelection};
+use crate::lint::RuleSelection;
 use ruff_db::files::File;
 use ruff_db::{Db as SourceDb, Upcast};
 
@@ -8,8 +8,6 @@ pub trait Db: SourceDb + Upcast<dyn SourceDb> {
     fn is_file_open(&self, file: File) -> bool;
 
     fn rule_selection(&self) -> &RuleSelection;
-
-    fn lint_registry(&self) -> &LintRegistry;
 }
 
 #[cfg(test)]
@@ -18,10 +16,10 @@ pub(crate) mod tests {
 
     use crate::program::{Program, SearchPathSettings};
     use crate::python_version::PythonVersion;
-    use crate::{default_lint_registry, ProgramSettings, PythonPlatform};
+    use crate::{default_lint_registry, ProgramSettings};
 
     use super::Db;
-    use crate::lint::{LintRegistry, RuleSelection};
+    use crate::lint::RuleSelection;
     use anyhow::Context;
     use ruff_db::files::{File, Files};
     use ruff_db::system::{DbWithTestSystem, System, SystemPathBuf, TestSystem};
@@ -47,7 +45,7 @@ pub(crate) mod tests {
                 vendored: red_knot_vendored::file_system().clone(),
                 events: Arc::default(),
                 files: Files::default(),
-                rule_selection: Arc::new(RuleSelection::from_registry(default_lint_registry())),
+                rule_selection: Arc::new(RuleSelection::from_registry(&default_lint_registry())),
             }
         }
 
@@ -114,10 +112,6 @@ pub(crate) mod tests {
         fn rule_selection(&self) -> &RuleSelection {
             &self.rule_selection
         }
-
-        fn lint_registry(&self) -> &LintRegistry {
-            default_lint_registry()
-        }
     }
 
     #[salsa::db]
@@ -133,8 +127,6 @@ pub(crate) mod tests {
     pub(crate) struct TestDbBuilder<'a> {
         /// Target Python version
         python_version: PythonVersion,
-        /// Target Python platform
-        python_platform: PythonPlatform,
         /// Path to a custom typeshed directory
         custom_typeshed: Option<SystemPathBuf>,
         /// Path and content pairs for files that should be present
@@ -145,7 +137,6 @@ pub(crate) mod tests {
         pub(crate) fn new() -> Self {
             Self {
                 python_version: PythonVersion::default(),
-                python_platform: PythonPlatform::default(),
                 custom_typeshed: None,
                 files: vec![],
             }
@@ -182,7 +173,6 @@ pub(crate) mod tests {
                 &db,
                 &ProgramSettings {
                     python_version: self.python_version,
-                    python_platform: self.python_platform,
                     search_paths,
                 },
             )

crates/red_knot_python_semantic/src/lib.rs

@@ -3,12 +3,10 @@ use std::hash::BuildHasherDefault;
 use rustc_hash::FxHasher;
 
 use crate::lint::{LintRegistry, LintRegistryBuilder};
-use crate::suppression::{INVALID_IGNORE_COMMENT, UNKNOWN_RULE, UNUSED_IGNORE_COMMENT};
 pub use db::Db;
 pub use module_name::ModuleName;
-pub use module_resolver::{resolve_module, system_module_search_paths, KnownModule, Module};
+pub use module_resolver::{resolve_module, system_module_search_paths, Module};
 pub use program::{Program, ProgramSettings, SearchPathSettings, SitePackages};
-pub use python_platform::PythonPlatform;
 pub use python_version::PythonVersion;
 pub use semantic_model::{HasTy, SemanticModel};
 
@@ -19,36 +17,26 @@ mod module_name;
 mod module_resolver;
 mod node_key;
 mod program;
-mod python_platform;
 mod python_version;
 pub mod semantic_index;
 mod semantic_model;
 pub(crate) mod site_packages;
 mod stdlib;
-mod suppression;
 pub(crate) mod symbol;
 pub mod types;
 mod unpack;
 mod util;
-mod visibility_constraints;
 
 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;
 
-/// Returns the default registry with all known semantic lints.
-pub fn default_lint_registry() -> &'static LintRegistry {
-    static REGISTRY: std::sync::LazyLock<LintRegistry> = std::sync::LazyLock::new(|| {
-        let mut registry = LintRegistryBuilder::default();
-        register_lints(&mut registry);
-        registry.build()
-    });
-
-    &REGISTRY
+/// Creates a new registry with all known semantic lints.
+pub fn default_lint_registry() -> LintRegistry {
+    let mut registry = LintRegistryBuilder::default();
+    register_lints(&mut registry);
+    registry.build()
 }
 
 /// Register all known semantic lints.
 pub fn register_lints(registry: &mut LintRegistryBuilder) {
     types::register_lints(registry);
-    registry.register_lint(&UNUSED_IGNORE_COMMENT);
-    registry.register_lint(&UNKNOWN_RULE);
-    registry.register_lint(&INVALID_IGNORE_COMMENT);
 }

crates/red_knot_python_semantic/src/lint.rs

@@ -321,7 +321,7 @@ impl LintRegistryBuilder {
     }
 }
 
-#[derive(Default, Debug, Clone)]
+#[derive(Default, Debug)]
 pub struct LintRegistry {
     lints: Vec<LintId>,
     by_name: FxHashMap<&'static str, LintEntry>,
@@ -374,7 +374,7 @@ impl LintRegistry {
     }
 }
 
-#[derive(Error, Debug, Clone, PartialEq, Eq)]
+#[derive(Error, Debug, Clone)]
 pub enum GetLintError {
     /// The name maps to this removed lint.
     #[error("lint {0} has been removed")]
@@ -385,7 +385,7 @@ pub enum GetLintError {
     Unknown(String),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum LintEntry {
     /// An existing lint rule. Can be in preview, stable or deprecated.
     Lint(LintId),
@@ -444,11 +444,6 @@ impl RuleSelection {
         self.lints.get(&lint).copied()
     }
 
-    /// Returns `true` if the `lint` is enabled.
-    pub fn is_enabled(&self, lint: LintId) -> bool {
-        self.severity(lint).is_some()
-    }
-
     /// Enables `lint` and configures with the given `severity`.
     ///
     /// Overrides any previous configuration for the lint.

crates/red_knot_python_semantic/src/module_resolver/mod.rs

@@ -1,6 +1,6 @@
 use std::iter::FusedIterator;
 
-pub use module::{KnownModule, Module};
+pub use module::Module;
 pub use resolver::resolve_module;
 pub(crate) use resolver::{file_to_module, SearchPaths};
 use ruff_db::system::SystemPath;

crates/red_knot_python_semantic/src/module_resolver/module.rs

@@ -19,14 +19,12 @@ impl Module {
         search_path: SearchPath,
         file: File,
     ) -> Self {
-        let known = KnownModule::try_from_search_path_and_name(&search_path, &name);
         Self {
             inner: Arc::new(ModuleInner {
                 name,
                 kind,
                 search_path,
                 file,
-                known,
             }),
         }
     }
@@ -41,16 +39,6 @@ impl Module {
         self.inner.file
     }
 
-    /// Is this a module that we special-case somehow? If so, which one?
-    pub fn known(&self) -> Option<KnownModule> {
-        self.inner.known
-    }
-
-    /// Does this module represent the given known module?
-    pub fn is_known(&self, known_module: KnownModule) -> bool {
-        self.known() == Some(known_module)
-    }
-
     /// The search path from which the module was resolved.
     pub(crate) fn search_path(&self) -> &SearchPath {
         &self.inner.search_path
@@ -79,7 +67,6 @@ struct ModuleInner {
     kind: ModuleKind,
     search_path: SearchPath,
     file: File,
-    known: Option<KnownModule>,
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
@@ -96,69 +83,3 @@ impl ModuleKind {
         matches!(self, ModuleKind::Package)
     }
 }
-
-/// Enumeration of various core stdlib modules in which important types are located
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum KnownModule {
-    Builtins,
-    Types,
-    Typeshed,
-    TypingExtensions,
-    Typing,
-    Sys,
-    #[allow(dead_code)]
-    Abc, // currently only used in tests
-    Collections,
-    KnotExtensions,
-}
-
-impl KnownModule {
-    pub const fn as_str(self) -> &'static str {
-        match self {
-            Self::Builtins => "builtins",
-            Self::Types => "types",
-            Self::Typing => "typing",
-            Self::Typeshed => "_typeshed",
-            Self::TypingExtensions => "typing_extensions",
-            Self::Sys => "sys",
-            Self::Abc => "abc",
-            Self::Collections => "collections",
-            Self::KnotExtensions => "knot_extensions",
-        }
-    }
-
-    pub fn name(self) -> ModuleName {
-        let self_as_str = self.as_str();
-        ModuleName::new_static(self_as_str)
-            .unwrap_or_else(|| panic!("{self_as_str} should be a valid module name!"))
-    }
-
-    pub(crate) fn try_from_search_path_and_name(
-        search_path: &SearchPath,
-        name: &ModuleName,
-    ) -> Option<Self> {
-        if !search_path.is_standard_library() {
-            return None;
-        }
-        match name.as_str() {
-            "builtins" => Some(Self::Builtins),
-            "types" => Some(Self::Types),
-            "typing" => Some(Self::Typing),
-            "_typeshed" => Some(Self::Typeshed),
-            "typing_extensions" => Some(Self::TypingExtensions),
-            "sys" => Some(Self::Sys),
-            "abc" => Some(Self::Abc),
-            "collections" => Some(Self::Collections),
-            "knot_extensions" => Some(Self::KnotExtensions),
-            _ => None,
-        }
-    }
-
-    pub const fn is_typing(self) -> bool {
-        matches!(self, Self::Typing)
-    }
-
-    pub const fn is_knot_extensions(self) -> bool {
-        matches!(self, Self::KnotExtensions)
-    }
-}

crates/red_knot_python_semantic/src/module_resolver/resolver.rs

@@ -721,8 +721,8 @@ mod tests {
     use crate::module_name::ModuleName;
     use crate::module_resolver::module::ModuleKind;
     use crate::module_resolver::testing::{FileSpec, MockedTypeshed, TestCase, TestCaseBuilder};
+    use crate::ProgramSettings;
     use crate::PythonVersion;
-    use crate::{ProgramSettings, PythonPlatform};
 
     use super::*;
 
@@ -1262,7 +1262,7 @@ mod tests {
     fn symlink() -> anyhow::Result<()> {
         use anyhow::Context;
 
-        use crate::{program::Program, PythonPlatform};
+        use crate::program::Program;
         use ruff_db::system::{OsSystem, SystemPath};
 
         use crate::db::tests::TestDb;
@@ -1296,7 +1296,6 @@ mod tests {
             &db,
             &ProgramSettings {
                 python_version: PythonVersion::PY38,
-                python_platform: PythonPlatform::default(),
                 search_paths: SearchPathSettings {
                     extra_paths: vec![],
                     src_root: src.clone(),
@@ -1802,7 +1801,6 @@ not_a_directory
             &db,
             &ProgramSettings {
                 python_version: PythonVersion::default(),
-                python_platform: PythonPlatform::default(),
                 search_paths: SearchPathSettings {
                     extra_paths: vec![],
                     src_root: SystemPathBuf::from("/src"),

crates/red_knot_python_semantic/src/module_resolver/testing.rs

@@ -4,7 +4,7 @@ use ruff_db::vendored::VendoredPathBuf;
 use crate::db::tests::TestDb;
 use crate::program::{Program, SearchPathSettings};
 use crate::python_version::PythonVersion;
-use crate::{ProgramSettings, PythonPlatform, SitePackages};
+use crate::{ProgramSettings, SitePackages};
 
 /// A test case for the module resolver.
 ///
@@ -101,7 +101,6 @@ pub(crate) struct UnspecifiedTypeshed;
 pub(crate) struct TestCaseBuilder<T> {
     typeshed_option: T,
     python_version: PythonVersion,
-    python_platform: PythonPlatform,
     first_party_files: Vec<FileSpec>,
     site_packages_files: Vec<FileSpec>,
 }
@@ -148,7 +147,6 @@ impl TestCaseBuilder<UnspecifiedTypeshed> {
         Self {
             typeshed_option: UnspecifiedTypeshed,
             python_version: PythonVersion::default(),
-            python_platform: PythonPlatform::default(),
             first_party_files: vec![],
             site_packages_files: vec![],
         }
@@ -159,14 +157,12 @@ impl TestCaseBuilder<UnspecifiedTypeshed> {
         let TestCaseBuilder {
             typeshed_option: _,
             python_version,
-            python_platform,
             first_party_files,
             site_packages_files,
         } = self;
         TestCaseBuilder {
             typeshed_option: VendoredTypeshed,
             python_version,
-            python_platform,
             first_party_files,
             site_packages_files,
         }
@@ -180,7 +176,6 @@ impl TestCaseBuilder<UnspecifiedTypeshed> {
         let TestCaseBuilder {
             typeshed_option: _,
             python_version,
-            python_platform,
             first_party_files,
             site_packages_files,
         } = self;
@@ -188,7 +183,6 @@ impl TestCaseBuilder<UnspecifiedTypeshed> {
         TestCaseBuilder {
             typeshed_option: typeshed,
             python_version,
-            python_platform,
             first_party_files,
             site_packages_files,
         }
@@ -218,7 +212,6 @@ impl TestCaseBuilder<MockedTypeshed> {
         let TestCaseBuilder {
             typeshed_option,
             python_version,
-            python_platform,
             first_party_files,
             site_packages_files,
         } = self;
@@ -234,7 +227,6 @@ impl TestCaseBuilder<MockedTypeshed> {
             &db,
             &ProgramSettings {
                 python_version,
-                python_platform,
                 search_paths: SearchPathSettings {
                     extra_paths: vec![],
                     src_root: src.clone(),
@@ -277,7 +269,6 @@ impl TestCaseBuilder<VendoredTypeshed> {
         let TestCaseBuilder {
             typeshed_option: VendoredTypeshed,
             python_version,
-            python_platform,
             first_party_files,
             site_packages_files,
         } = self;
@@ -292,7 +283,6 @@ impl TestCaseBuilder<VendoredTypeshed> {
             &db,
             &ProgramSettings {
                 python_version,
-                python_platform,
                 search_paths: SearchPathSettings {
                     site_packages: SitePackages::Known(vec![site_packages.clone()]),
                     ..SearchPathSettings::new(src.clone())

crates/red_knot_python_semantic/src/program.rs

@@ -1,4 +1,3 @@
-use crate::python_platform::PythonPlatform;
 use crate::python_version::PythonVersion;
 use anyhow::Context;
 use salsa::Durability;
@@ -13,8 +12,6 @@ use crate::Db;
 pub struct Program {
     pub python_version: PythonVersion,
 
-    pub python_platform: PythonPlatform,
-
     #[return_ref]
     pub(crate) search_paths: SearchPaths,
 }
@@ -23,7 +20,6 @@ impl Program {
     pub fn from_settings(db: &dyn Db, settings: &ProgramSettings) -> anyhow::Result<Self> {
         let ProgramSettings {
             python_version,
-            python_platform,
             search_paths,
         } = settings;
 
@@ -32,11 +28,9 @@ impl Program {
         let search_paths = SearchPaths::from_settings(db, search_paths)
             .with_context(|| "Invalid search path settings")?;
 
-        Ok(
-            Program::builder(*python_version, python_platform.clone(), search_paths)
-                .durability(Durability::HIGH)
-                .new(db),
-        )
+        Ok(Program::builder(settings.python_version, search_paths)
+            .durability(Durability::HIGH)
+            .new(db))
     }
 
     pub fn update_search_paths(
@@ -63,7 +57,6 @@ impl Program {
 #[cfg_attr(feature = "serde", derive(serde::Serialize))]
 pub struct ProgramSettings {
     pub python_version: PythonVersion,
-    pub python_platform: PythonPlatform,
     pub search_paths: SearchPathSettings,
 }
 

crates/red_knot_python_semantic/src/python_platform.rs

@@ -1,19 +0,0 @@
-/// The target platform to assume when resolving types.
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(rename_all = "kebab-case")
-)]
-pub enum PythonPlatform {
-    /// Do not make any assumptions about the target platform.
-    #[default]
-    All,
-    /// Assume a specific target platform like `linux`, `darwin` or `win32`.
-    ///
-    /// We use a string (instead of individual enum variants), as the set of possible platforms
-    /// may change over time. See <https://docs.python.org/3/library/sys.html#sys.platform> for
-    /// some known platform identifiers.
-    #[cfg_attr(feature = "serde", serde(untagged))]
-    Identifier(String),
-}

crates/red_knot_python_semantic/src/semantic_index.rs

@@ -29,8 +29,7 @@ pub mod symbol;
 mod use_def;
 
 pub(crate) use self::use_def::{
-    BindingWithConstraints, BindingWithConstraintsIterator, DeclarationWithConstraint,
-    DeclarationsIterator, ScopedVisibilityConstraintId,
+    BindingWithConstraints, BindingWithConstraintsIterator, DeclarationsIterator,
 };
 
 type SymbolMap = hashbrown::HashMap<ScopedSymbolId, (), FxBuildHasher>;
@@ -379,12 +378,14 @@ mod tests {
     impl UseDefMap<'_> {
         fn first_public_binding(&self, symbol: ScopedSymbolId) -> Option<Definition<'_>> {
             self.public_bindings(symbol)
-                .find_map(|constrained_binding| constrained_binding.binding)
+                .next()
+                .map(|constrained_binding| constrained_binding.binding)
         }
 
         fn first_binding_at_use(&self, use_id: ScopedUseId) -> Option<Definition<'_>> {
             self.bindings_at_use(use_id)
-                .find_map(|constrained_binding| constrained_binding.binding)
+                .next()
+                .map(|constrained_binding| constrained_binding.binding)
         }
     }
 

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -9,12 +9,12 @@ use ruff_index::IndexVec;
 use ruff_python_ast as ast;
 use ruff_python_ast::name::Name;
 use ruff_python_ast::visitor::{walk_expr, walk_pattern, walk_stmt, Visitor};
+use ruff_python_ast::{BoolOp, Expr};
 
 use crate::ast_node_ref::AstNodeRef;
 use crate::module_name::ModuleName;
 use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey;
 use crate::semantic_index::ast_ids::AstIdsBuilder;
-use crate::semantic_index::constraint::PatternConstraintKind;
 use crate::semantic_index::definition::{
     AssignmentDefinitionNodeRef, ComprehensionDefinitionNodeRef, Definition, DefinitionNodeKey,
     DefinitionNodeRef, ForStmtDefinitionNodeRef, ImportFromDefinitionNodeRef,
@@ -24,12 +24,9 @@ use crate::semantic_index::symbol::{
     FileScopeId, NodeWithScopeKey, NodeWithScopeRef, Scope, ScopeId, ScopedSymbolId,
     SymbolTableBuilder,
 };
-use crate::semantic_index::use_def::{
-    FlowSnapshot, ScopedConstraintId, ScopedVisibilityConstraintId, UseDefMapBuilder,
-};
+use crate::semantic_index::use_def::{FlowSnapshot, UseDefMapBuilder};
 use crate::semantic_index::SemanticIndex;
-use crate::unpack::{Unpack, UnpackValue};
-use crate::visibility_constraints::VisibilityConstraint;
+use crate::unpack::Unpack;
 use crate::Db;
 
 use super::constraint::{Constraint, ConstraintNode, PatternConstraint};
@@ -288,7 +285,11 @@ impl<'db> SemanticIndexBuilder<'db> {
         constraint
     }
 
-    fn build_constraint(&mut self, constraint_node: &ast::Expr) -> Constraint<'db> {
+    fn record_constraint(&mut self, constraint: Constraint<'db>) {
+        self.current_use_def_map_mut().record_constraint(constraint);
+    }
+
+    fn build_constraint(&mut self, constraint_node: &Expr) -> Constraint<'db> {
         let expression = self.add_standalone_expression(constraint_node);
         Constraint {
             node: ConstraintNode::Expression(expression),
@@ -296,89 +297,12 @@ impl<'db> SemanticIndexBuilder<'db> {
         }
     }
 
-    /// Adds a new constraint to the list of all constraints, but does not record it. Returns the
-    /// constraint ID for later recording using [`SemanticIndexBuilder::record_constraint_id`].
-    fn add_constraint(&mut self, constraint: Constraint<'db>) -> ScopedConstraintId {
-        self.current_use_def_map_mut().add_constraint(constraint)
-    }
-
-    /// Negates a constraint and adds it to the list of all constraints, does not record it.
-    fn add_negated_constraint(
-        &mut self,
-        constraint: Constraint<'db>,
-    ) -> (Constraint<'db>, ScopedConstraintId) {
-        let negated = Constraint {
-            node: constraint.node,
-            is_positive: false,
-        };
-        let id = self.current_use_def_map_mut().add_constraint(negated);
-        (negated, id)
-    }
-
-    /// Records a previously added constraint by adding it to all live bindings.
-    fn record_constraint_id(&mut self, constraint: ScopedConstraintId) {
+    fn record_negated_constraint(&mut self, constraint: Constraint<'db>) {
         self.current_use_def_map_mut()
-            .record_constraint_id(constraint);
-    }
-
-    /// Adds and records a constraint, i.e. adds it to all live bindings.
-    fn record_constraint(&mut self, constraint: Constraint<'db>) {
-        self.current_use_def_map_mut().record_constraint(constraint);
-    }
-
-    /// Negates the given constraint and then adds it to all live bindings.
-    fn record_negated_constraint(&mut self, constraint: Constraint<'db>) -> ScopedConstraintId {
-        let (_, id) = self.add_negated_constraint(constraint);
-        self.record_constraint_id(id);
-        id
-    }
-
-    /// Adds a new visibility constraint, but does not record it. Returns the constraint ID
-    /// for later recording using [`SemanticIndexBuilder::record_visibility_constraint_id`].
-    fn add_visibility_constraint(
-        &mut self,
-        constraint: VisibilityConstraint<'db>,
-    ) -> ScopedVisibilityConstraintId {
-        self.current_use_def_map_mut()
-            .add_visibility_constraint(constraint)
-    }
-
-    /// Records a previously added visibility constraint by applying it to all live bindings
-    /// and declarations.
-    fn record_visibility_constraint_id(&mut self, constraint: ScopedVisibilityConstraintId) {
-        self.current_use_def_map_mut()
-            .record_visibility_constraint_id(constraint);
-    }
-
-    /// Negates the given visibility constraint and then adds it to all live bindings and declarations.
-    fn record_negated_visibility_constraint(
-        &mut self,
-        constraint: ScopedVisibilityConstraintId,
-    ) -> ScopedVisibilityConstraintId {
-        self.current_use_def_map_mut()
-            .record_visibility_constraint(VisibilityConstraint::VisibleIfNot(constraint))
-    }
-
-    /// Records a visibility constraint by applying it to all live bindings and declarations.
-    fn record_visibility_constraint(
-        &mut self,
-        constraint: Constraint<'db>,
-    ) -> ScopedVisibilityConstraintId {
-        self.current_use_def_map_mut()
-            .record_visibility_constraint(VisibilityConstraint::VisibleIf(constraint))
-    }
-
-    /// Records a [`VisibilityConstraint::Ambiguous`] constraint.
-    fn record_ambiguous_visibility(&mut self) -> ScopedVisibilityConstraintId {
-        self.current_use_def_map_mut()
-            .record_visibility_constraint(VisibilityConstraint::Ambiguous)
-    }
-
-    /// Simplifies (resets) visibility constraints on all live bindings and declarations that did
-    /// not see any new definitions since the given snapshot.
-    fn simplify_visibility_constraints(&mut self, snapshot: FlowSnapshot) {
-        self.current_use_def_map_mut()
-            .simplify_visibility_constraints(snapshot);
+            .record_constraint(Constraint {
+                node: constraint.node,
+                is_positive: false,
+            });
     }
 
     fn push_assignment(&mut self, assignment: CurrentAssignment<'db>) {
@@ -400,52 +324,30 @@ impl<'db> SemanticIndexBuilder<'db> {
 
     fn add_pattern_constraint(
         &mut self,
-        subject: Expression<'db>,
+        subject: &ast::Expr,
         pattern: &ast::Pattern,
-        guard: Option<&ast::Expr>,
-    ) -> Constraint<'db> {
-        // This is called for the top-level pattern of each match arm. We need to create a
-        // standalone expression for each arm of a match statement, since they can introduce
-        // constraints on the match subject. (Or more accurately, for the match arm's pattern,
-        // since its the pattern that introduces any constraints, not the body.) Ideally, that
-        // standalone expression would wrap the match arm's pattern as a whole. But a standalone
-        // expression can currently only wrap an ast::Expr, which patterns are not. So, we need to
-        // choose an Expr that can “stand in” for the pattern, which we can wrap in a standalone
-        // expression.
-        //
-        // See the comment in TypeInferenceBuilder::infer_match_pattern for more details.
-
-        let guard = guard.map(|guard| self.add_standalone_expression(guard));
-
-        let kind = match pattern {
-            ast::Pattern::MatchValue(pattern) => {
-                let value = self.add_standalone_expression(&pattern.value);
-                PatternConstraintKind::Value(value, guard)
-            }
-            ast::Pattern::MatchSingleton(singleton) => {
-                PatternConstraintKind::Singleton(singleton.value, guard)
-            }
-            ast::Pattern::MatchClass(pattern) => {
-                let cls = self.add_standalone_expression(&pattern.cls);
-                PatternConstraintKind::Class(cls, guard)
-            }
-            _ => PatternConstraintKind::Unsupported,
+    ) -> PatternConstraint<'db> {
+        #[allow(unsafe_code)]
+        let (subject, pattern) = unsafe {
+            (
+                AstNodeRef::new(self.module.clone(), subject),
+                AstNodeRef::new(self.module.clone(), pattern),
+            )
         };
-
         let pattern_constraint = PatternConstraint::new(
             self.db,
             self.file,
             self.current_scope(),
             subject,
-            kind,
+            pattern,
             countme::Count::default(),
         );
-        let constraint = Constraint {
-            node: ConstraintNode::Pattern(pattern_constraint),
-            is_positive: true,
-        };
-        self.current_use_def_map_mut().record_constraint(constraint);
-        constraint
+        self.current_use_def_map_mut()
+            .record_constraint(Constraint {
+                node: ConstraintNode::Pattern(pattern_constraint),
+                is_positive: true,
+            });
+        pattern_constraint
     }
 
     /// Record an expression that needs to be a Salsa ingredient, because we need to infer its type
@@ -824,7 +726,7 @@ where
                                     unsafe {
                                         AstNodeRef::new(self.module.clone(), target)
                                     },
-                                    UnpackValue::Assign(value),
+                                    value,
                                     countme::Count::default(),
                                 )),
                             })
@@ -893,13 +795,10 @@ where
             }
             ast::Stmt::If(node) => {
                 self.visit_expr(&node.test);
-                let mut no_branch_taken = self.flow_snapshot();
-                let mut last_constraint = self.record_expression_constraint(&node.test);
+                let pre_if = self.flow_snapshot();
+                let constraint = self.record_expression_constraint(&node.test);
+                let mut constraints = vec![constraint];
                 self.visit_body(&node.body);
-
-                let visibility_constraint_id = self.record_visibility_constraint(last_constraint);
-                let mut vis_constraints = vec![visibility_constraint_id];
-
                 let mut post_clauses: Vec<FlowSnapshot> = vec![];
                 let elif_else_clauses = node
                     .elif_else_clauses
@@ -921,37 +820,20 @@ where
                     // the state that we merge the other snapshots into
                     post_clauses.push(self.flow_snapshot());
                     // we can only take an elif/else branch if none of the previous ones were
-                    // taken
-                    self.flow_restore(no_branch_taken.clone());
-                    self.record_negated_constraint(last_constraint);
-
-                    let elif_constraint = if let Some(elif_test) = clause_test {
+                    // taken, so the block entry state is always `pre_if`
+                    self.flow_restore(pre_if.clone());
+                    for constraint in &constraints {
+                        self.record_negated_constraint(*constraint);
+                    }
+                    if let Some(elif_test) = clause_test {
                         self.visit_expr(elif_test);
-                        // A test expression is evaluated whether the branch is taken or not
-                        no_branch_taken = self.flow_snapshot();
-                        let constraint = self.record_expression_constraint(elif_test);
-                        Some(constraint)
-                    } else {
-                        None
-                    };
-
+                        constraints.push(self.record_expression_constraint(elif_test));
+                    }
                     self.visit_body(clause_body);
-
-                    for id in &vis_constraints {
-                        self.record_negated_visibility_constraint(*id);
-                    }
-                    if let Some(elif_constraint) = elif_constraint {
-                        last_constraint = elif_constraint;
-                        let id = self.record_visibility_constraint(elif_constraint);
-                        vis_constraints.push(id);
-                    }
                 }
-
                 for post_clause_state in post_clauses {
                     self.flow_merge(post_clause_state);
                 }
-
-                self.simplify_visibility_constraints(no_branch_taken);
             }
             ast::Stmt::While(ast::StmtWhile {
                 test,
@@ -974,8 +856,6 @@ where
                 self.visit_body(body);
                 self.set_inside_loop(outer_loop_state);
 
-                let vis_constraint_id = self.record_visibility_constraint(constraint);
-
                 // Get the break states from the body of this loop, and restore the saved outer
                 // ones.
                 let break_states =
@@ -983,21 +863,15 @@ where
 
                 // We may execute the `else` clause without ever executing the body, so merge in
                 // the pre-loop state before visiting `else`.
-                self.flow_merge(pre_loop.clone());
+                self.flow_merge(pre_loop);
                 self.record_negated_constraint(constraint);
                 self.visit_body(orelse);
-                self.record_negated_visibility_constraint(vis_constraint_id);
 
                 // Breaking out of a while loop bypasses the `else` clause, so merge in the break
                 // states after visiting `else`.
                 for break_state in break_states {
-                    let snapshot = self.flow_snapshot();
-                    self.flow_restore(break_state);
-                    self.record_visibility_constraint(constraint);
-                    self.flow_merge(snapshot);
+                    self.flow_merge(break_state);
                 }
-
-                self.simplify_visibility_constraints(pre_loop);
             }
             ast::Stmt::With(ast::StmtWith {
                 items,
@@ -1035,47 +909,16 @@ where
                     orelse,
                 },
             ) => {
-                debug_assert_eq!(&self.current_assignments, &[]);
-
-                let iter_expr = self.add_standalone_expression(iter);
+                self.add_standalone_expression(iter);
                 self.visit_expr(iter);
 
-                self.record_ambiguous_visibility();
-
                 let pre_loop = self.flow_snapshot();
                 let saved_break_states = std::mem::take(&mut self.loop_break_states);
 
-                let current_assignment = match &**target {
-                    ast::Expr::List(_) | ast::Expr::Tuple(_) => Some(CurrentAssignment::For {
-                        node: for_stmt,
-                        first: true,
-                        unpack: Some(Unpack::new(
-                            self.db,
-                            self.file,
-                            self.current_scope(),
-                            #[allow(unsafe_code)]
-                            unsafe {
-                                AstNodeRef::new(self.module.clone(), target)
-                            },
-                            UnpackValue::Iterable(iter_expr),
-                            countme::Count::default(),
-                        )),
-                    }),
-                    ast::Expr::Name(_) => Some(CurrentAssignment::For {
-                        node: for_stmt,
-                        unpack: None,
-                        first: false,
-                    }),
-                    _ => None,
-                };
-
-                if let Some(current_assignment) = current_assignment {
-                    self.push_assignment(current_assignment);
-                }
+                debug_assert_eq!(&self.current_assignments, &[]);
+                self.push_assignment(for_stmt.into());
                 self.visit_expr(target);
-                if current_assignment.is_some() {
-                    self.pop_assignment();
-                }
+                self.pop_assignment();
 
                 // TODO: Definitions created by loop variables
                 // (and definitions created inside the body)
@@ -1104,61 +947,32 @@ where
                 cases,
                 range: _,
             }) => {
-                debug_assert_eq!(self.current_match_case, None);
-
-                let subject_expr = self.add_standalone_expression(subject);
+                self.add_standalone_expression(subject);
                 self.visit_expr(subject);
-                if cases.is_empty() {
-                    return;
-                };
 
                 let after_subject = self.flow_snapshot();
-                let mut vis_constraints = vec![];
+                let Some((first, remaining)) = cases.split_first() else {
+                    return;
+                };
+                self.add_pattern_constraint(subject, &first.pattern);
+                self.visit_match_case(first);
+
                 let mut post_case_snapshots = vec![];
-                for (i, case) in cases.iter().enumerate() {
-                    if i != 0 {
-                        post_case_snapshots.push(self.flow_snapshot());
-                        self.flow_restore(after_subject.clone());
-                    }
-
-                    self.current_match_case = Some(CurrentMatchCase::new(&case.pattern));
-                    self.visit_pattern(&case.pattern);
-                    self.current_match_case = None;
-                    let constraint_id = self.add_pattern_constraint(
-                        subject_expr,
-                        &case.pattern,
-                        case.guard.as_deref(),
-                    );
-                    if let Some(expr) = &case.guard {
-                        self.visit_expr(expr);
-                    }
-                    self.visit_body(&case.body);
-                    for id in &vis_constraints {
-                        self.record_negated_visibility_constraint(*id);
-                    }
-                    let vis_constraint_id = self.record_visibility_constraint(constraint_id);
-                    vis_constraints.push(vis_constraint_id);
+                for case in remaining {
+                    post_case_snapshots.push(self.flow_snapshot());
+                    self.flow_restore(after_subject.clone());
+                    self.add_pattern_constraint(subject, &case.pattern);
+                    self.visit_match_case(case);
+                }
+                for post_clause_state in post_case_snapshots {
+                    self.flow_merge(post_clause_state);
                 }
-
-                // If there is no final wildcard match case, pretend there is one. This is similar to how
-                // we add an implicit `else` block in if-elif chains, in case it's not present.
                 if !cases
                     .last()
                     .is_some_and(|case| case.guard.is_none() && case.pattern.is_wildcard())
                 {
-                    post_case_snapshots.push(self.flow_snapshot());
-                    self.flow_restore(after_subject.clone());
-
-                    for id in &vis_constraints {
-                        self.record_negated_visibility_constraint(*id);
-                    }
+                    self.flow_merge(after_subject);
                 }
-
-                for post_clause_state in post_case_snapshots {
-                    self.flow_merge(post_clause_state);
-                }
-
-                self.simplify_visibility_constraints(after_subject);
             }
             ast::Stmt::Try(ast::StmtTry {
                 body,
@@ -1168,8 +982,6 @@ where
                 is_star,
                 range: _,
             }) => {
-                self.record_ambiguous_visibility();
-
                 // Save the state prior to visiting any of the `try` block.
                 //
                 // Potentially none of the `try` block could have been executed prior to executing
@@ -1324,18 +1136,12 @@ where
                         Some(CurrentAssignment::AugAssign(aug_assign)) => {
                             self.add_definition(symbol, aug_assign);
                         }
-                        Some(CurrentAssignment::For {
-                            node,
-                            first,
-                            unpack,
-                        }) => {
+                        Some(CurrentAssignment::For(node)) => {
                             self.add_definition(
                                 symbol,
                                 ForStmtDefinitionNodeRef {
-                                    unpack,
-                                    first,
                                     iterable: &node.iter,
-                                    name: name_node,
+                                    target: name_node,
                                     is_async: node.is_async,
                                 },
                             );
@@ -1371,9 +1177,7 @@ where
                     }
                 }
 
-                if let Some(
-                    CurrentAssignment::Assign { first, .. } | CurrentAssignment::For { first, .. },
-                ) = self.current_assignment_mut()
+                if let Some(CurrentAssignment::Assign { first, .. }) = self.current_assignment_mut()
                 {
                     *first = false;
                 }
@@ -1418,19 +1222,19 @@ where
             ast::Expr::If(ast::ExprIf {
                 body, test, orelse, ..
             }) => {
+                // TODO detect statically known truthy or falsy test (via type inference, not naive
+                // AST inspection, so we can't simplify here, need to record test expression for
+                // later checking)
                 self.visit_expr(test);
                 let pre_if = self.flow_snapshot();
                 let constraint = self.record_expression_constraint(test);
                 self.visit_expr(body);
-                let visibility_constraint = self.record_visibility_constraint(constraint);
                 let post_body = self.flow_snapshot();
-                self.flow_restore(pre_if.clone());
+                self.flow_restore(pre_if);
 
                 self.record_negated_constraint(constraint);
                 self.visit_expr(orelse);
-                self.record_negated_visibility_constraint(visibility_constraint);
                 self.flow_merge(post_body);
-                self.simplify_visibility_constraints(pre_if);
             }
             ast::Expr::ListComp(
                 list_comprehension @ ast::ExprListComp {
@@ -1487,55 +1291,27 @@ where
                 range: _,
                 op,
             }) => {
-                let pre_op = self.flow_snapshot();
-
+                // TODO detect statically known truthy or falsy values (via type inference, not naive
+                // AST inspection, so we can't simplify here, need to record test expression for
+                // later checking)
                 let mut snapshots = vec![];
-                let mut visibility_constraints = vec![];
 
                 for (index, value) in values.iter().enumerate() {
                     self.visit_expr(value);
-
-                    for vid in &visibility_constraints {
-                        self.record_visibility_constraint_id(*vid);
-                    }
-
-                    // For the last value, we don't need to model control flow. There is short-circuiting
-                    // anymore.
+                    // In the last value we don't need to take a snapshot nor add a constraint
                     if index < values.len() - 1 {
-                        let constraint = self.build_constraint(value);
-                        let (constraint, constraint_id) = match op {
-                            ast::BoolOp::And => (constraint, self.add_constraint(constraint)),
-                            ast::BoolOp::Or => self.add_negated_constraint(constraint),
-                        };
-                        let visibility_constraint = self
-                            .add_visibility_constraint(VisibilityConstraint::VisibleIf(constraint));
-
-                        let after_expr = self.flow_snapshot();
-
-                        // We first model the short-circuiting behavior. We take the short-circuit
-                        // path here if all of the previous short-circuit paths were not taken, so
-                        // we record all previously existing visibility constraints, and negate the
-                        // one for the current expression.
-                        for vid in &visibility_constraints {
-                            self.record_visibility_constraint_id(*vid);
-                        }
-                        self.record_negated_visibility_constraint(visibility_constraint);
+                        // Snapshot is taken after visiting the expression but before adding the constraint.
                         snapshots.push(self.flow_snapshot());
-
-                        // Then we model the non-short-circuiting behavior. Here, we need to delay
-                        // the application of the visibility constraint until after the expression
-                        // has been evaluated, so we only push it onto the stack here.
-                        self.flow_restore(after_expr);
-                        self.record_constraint_id(constraint_id);
-                        visibility_constraints.push(visibility_constraint);
+                        let constraint = self.build_constraint(value);
+                        match op {
+                            BoolOp::And => self.record_constraint(constraint),
+                            BoolOp::Or => self.record_negated_constraint(constraint),
+                        }
                     }
                 }
-
                 for snapshot in snapshots {
                     self.flow_merge(snapshot);
                 }
-
-                self.simplify_visibility_constraints(pre_op);
             }
             _ => {
                 walk_expr(self, expr);
@@ -1551,6 +1327,18 @@ where
         }
     }
 
+    fn visit_match_case(&mut self, match_case: &'ast ast::MatchCase) {
+        debug_assert!(self.current_match_case.is_none());
+        self.current_match_case = Some(CurrentMatchCase::new(&match_case.pattern));
+        self.visit_pattern(&match_case.pattern);
+        self.current_match_case = None;
+
+        if let Some(expr) = &match_case.guard {
+            self.visit_expr(expr);
+        }
+        self.visit_body(&match_case.body);
+    }
+
     fn visit_pattern(&mut self, pattern: &'ast ast::Pattern) {
         if let ast::Pattern::MatchStar(ast::PatternMatchStar {
             name: Some(name),
@@ -1603,11 +1391,7 @@ enum CurrentAssignment<'a> {
     },
     AnnAssign(&'a ast::StmtAnnAssign),
     AugAssign(&'a ast::StmtAugAssign),
-    For {
-        node: &'a ast::StmtFor,
-        first: bool,
-        unpack: Option<Unpack<'a>>,
-    },
+    For(&'a ast::StmtFor),
     Named(&'a ast::ExprNamed),
     Comprehension {
         node: &'a ast::Comprehension,
@@ -1631,13 +1415,18 @@ impl<'a> From<&'a ast::StmtAugAssign> for CurrentAssignment<'a> {
     }
 }
 
+impl<'a> From<&'a ast::StmtFor> for CurrentAssignment<'a> {
+    fn from(value: &'a ast::StmtFor) -> Self {
+        Self::For(value)
+    }
+}
+
 impl<'a> From<&'a ast::ExprNamed> for CurrentAssignment<'a> {
     fn from(value: &'a ast::ExprNamed) -> Self {
         Self::Named(value)
     }
 }
 
-#[derive(Debug, PartialEq)]
 struct CurrentMatchCase<'a> {
     /// The pattern that's part of the current match case.
     pattern: &'a ast::Pattern,

crates/red_knot_python_semantic/src/semantic_index/constraint.rs

@@ -1,6 +1,7 @@
 use ruff_db::files::File;
-use ruff_python_ast::Singleton;
+use ruff_python_ast as ast;
 
+use crate::ast_node_ref::AstNodeRef;
 use crate::db::Db;
 use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{FileScopeId, ScopeId};
@@ -17,15 +18,6 @@ pub(crate) enum ConstraintNode<'db> {
     Pattern(PatternConstraint<'db>),
 }
 
-/// Pattern kinds for which we support type narrowing and/or static visibility analysis.
-#[derive(Debug, Clone, PartialEq)]
-pub(crate) enum PatternConstraintKind<'db> {
-    Singleton(Singleton, Option<Expression<'db>>),
-    Value(Expression<'db>, Option<Expression<'db>>),
-    Class(Expression<'db>, Option<Expression<'db>>),
-    Unsupported,
-}
-
 #[salsa::tracked]
 pub(crate) struct PatternConstraint<'db> {
     #[id]
@@ -36,11 +28,11 @@ pub(crate) struct PatternConstraint<'db> {
 
     #[no_eq]
     #[return_ref]
-    pub(crate) subject: Expression<'db>,
+    pub(crate) subject: AstNodeRef<ast::Expr>,
 
     #[no_eq]
     #[return_ref]
-    pub(crate) kind: PatternConstraintKind<'db>,
+    pub(crate) pattern: AstNodeRef<ast::Pattern>,
 
     #[no_eq]
     count: countme::Count<PatternConstraint<'static>>,

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -8,7 +8,7 @@ use crate::module_resolver::file_to_module;
 use crate::node_key::NodeKey;
 use crate::semantic_index::symbol::{FileScopeId, ScopeId, ScopedSymbolId};
 use crate::unpack::Unpack;
-use crate::{Db, KnownModule};
+use crate::Db;
 
 /// A definition of a symbol.
 ///
@@ -63,21 +63,17 @@ impl<'db> Definition<'db> {
     }
 
     pub(crate) fn is_builtin_definition(self, db: &'db dyn Db) -> bool {
-        file_to_module(db, self.file(db))
-            .is_some_and(|module| module.is_known(KnownModule::Builtins))
+        file_to_module(db, self.file(db)).is_some_and(|module| {
+            module.search_path().is_standard_library() && matches!(&**module.name(), "builtins")
+        })
     }
 
     /// Return true if this symbol was defined in the `typing` or `typing_extensions` modules
     pub(crate) fn is_typing_definition(self, db: &'db dyn Db) -> bool {
-        matches!(
-            file_to_module(db, self.file(db)).and_then(|module| module.known()),
-            Some(KnownModule::Typing | KnownModule::TypingExtensions)
-        )
-    }
-
-    pub(crate) fn is_knot_extensions_definition(self, db: &'db dyn Db) -> bool {
-        file_to_module(db, self.file(db))
-            .is_some_and(|module| module.is_known(KnownModule::KnotExtensions))
+        file_to_module(db, self.file(db)).is_some_and(|module| {
+            module.search_path().is_standard_library()
+                && matches!(&**module.name(), "typing" | "typing_extensions")
+        })
     }
 }
 
@@ -230,10 +226,8 @@ pub(crate) struct WithItemDefinitionNodeRef<'a> {
 
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct ForStmtDefinitionNodeRef<'a> {
-    pub(crate) unpack: Option<Unpack<'a>>,
     pub(crate) iterable: &'a ast::Expr,
-    pub(crate) name: &'a ast::ExprName,
-    pub(crate) first: bool,
+    pub(crate) target: &'a ast::ExprName,
     pub(crate) is_async: bool,
 }
 
@@ -305,16 +299,12 @@ impl<'db> DefinitionNodeRef<'db> {
                 DefinitionKind::AugmentedAssignment(AstNodeRef::new(parsed, augmented_assignment))
             }
             DefinitionNodeRef::For(ForStmtDefinitionNodeRef {
-                unpack,
                 iterable,
-                name,
-                first,
+                target,
                 is_async,
             }) => DefinitionKind::For(ForStmtDefinitionKind {
-                target: TargetKind::from(unpack),
                 iterable: AstNodeRef::new(parsed.clone(), iterable),
-                name: AstNodeRef::new(parsed, name),
-                first,
+                target: AstNodeRef::new(parsed, target),
                 is_async,
             }),
             DefinitionNodeRef::Comprehension(ComprehensionDefinitionNodeRef {
@@ -393,12 +383,10 @@ impl<'db> DefinitionNodeRef<'db> {
             Self::AnnotatedAssignment(node) => node.into(),
             Self::AugmentedAssignment(node) => node.into(),
             Self::For(ForStmtDefinitionNodeRef {
-                unpack: _,
                 iterable: _,
-                name,
-                first: _,
+                target,
                 is_async: _,
-            }) => name.into(),
+            }) => target.into(),
             Self::Comprehension(ComprehensionDefinitionNodeRef { target, .. }) => target.into(),
             Self::VariadicPositionalParameter(node) => node.into(),
             Self::VariadicKeywordParameter(node) => node.into(),
@@ -465,7 +453,7 @@ pub enum DefinitionKind<'db> {
     Assignment(AssignmentDefinitionKind<'db>),
     AnnotatedAssignment(AstNodeRef<ast::StmtAnnAssign>),
     AugmentedAssignment(AstNodeRef<ast::StmtAugAssign>),
-    For(ForStmtDefinitionKind<'db>),
+    For(ForStmtDefinitionKind),
     Comprehension(ComprehensionDefinitionKind),
     VariadicPositionalParameter(AstNodeRef<ast::Parameter>),
     VariadicKeywordParameter(AstNodeRef<ast::Parameter>),
@@ -478,14 +466,8 @@ pub enum DefinitionKind<'db> {
     TypeVarTuple(AstNodeRef<ast::TypeParamTypeVarTuple>),
 }
 
-impl DefinitionKind<'_> {
-    /// Returns the [`TextRange`] of the definition target.
-    ///
-    /// A definition target would mainly be the node representing the symbol being defined i.e.,
-    /// [`ast::ExprName`] or [`ast::Identifier`] but could also be other nodes.
-    ///
-    /// This is mainly used for logging and debugging purposes.
-    pub(crate) fn target_range(&self) -> TextRange {
+impl Ranged for DefinitionKind<'_> {
+    fn range(&self) -> TextRange {
         match self {
             DefinitionKind::Import(alias) => alias.range(),
             DefinitionKind::ImportFrom(import) => import.alias().range(),
@@ -496,7 +478,7 @@ impl DefinitionKind<'_> {
             DefinitionKind::Assignment(assignment) => assignment.name().range(),
             DefinitionKind::AnnotatedAssignment(assign) => assign.target.range(),
             DefinitionKind::AugmentedAssignment(aug_assign) => aug_assign.target.range(),
-            DefinitionKind::For(for_stmt) => for_stmt.name().range(),
+            DefinitionKind::For(for_stmt) => for_stmt.target().range(),
             DefinitionKind::Comprehension(comp) => comp.target().range(),
             DefinitionKind::VariadicPositionalParameter(parameter) => parameter.name.range(),
             DefinitionKind::VariadicKeywordParameter(parameter) => parameter.name.range(),
@@ -509,7 +491,9 @@ impl DefinitionKind<'_> {
             DefinitionKind::TypeVarTuple(type_var_tuple) => type_var_tuple.name.range(),
         }
     }
+}
 
+impl DefinitionKind<'_> {
     pub(crate) fn category(&self) -> DefinitionCategory {
         match self {
             // functions, classes, and imports always bind, and we consider them declarations
@@ -682,32 +666,22 @@ impl WithItemDefinitionKind {
 }
 
 #[derive(Clone, Debug)]
-pub struct ForStmtDefinitionKind<'db> {
-    target: TargetKind<'db>,
+pub struct ForStmtDefinitionKind {
     iterable: AstNodeRef<ast::Expr>,
-    name: AstNodeRef<ast::ExprName>,
-    first: bool,
+    target: AstNodeRef<ast::ExprName>,
     is_async: bool,
 }
 
-impl<'db> ForStmtDefinitionKind<'db> {
+impl ForStmtDefinitionKind {
     pub(crate) fn iterable(&self) -> &ast::Expr {
         self.iterable.node()
     }
 
-    pub(crate) fn target(&self) -> TargetKind<'db> {
-        self.target
+    pub(crate) fn target(&self) -> &ast::ExprName {
+        self.target.node()
     }
 
-    pub(crate) fn name(&self) -> &ast::ExprName {
-        self.name.node()
-    }
-
-    pub(crate) const fn is_first(&self) -> bool {
-        self.first
-    }
-
-    pub(crate) const fn is_async(&self) -> bool {
+    pub(crate) fn is_async(&self) -> bool {
         self.is_async
     }
 }
@@ -783,6 +757,12 @@ impl From<&ast::StmtAugAssign> for DefinitionNodeKey {
     }
 }
 
+impl From<&ast::StmtFor> for DefinitionNodeKey {
+    fn from(value: &ast::StmtFor) -> Self {
+        Self(NodeKey::from_node(value))
+    }
+}
+
 impl From<&ast::Parameter> for DefinitionNodeKey {
     fn from(node: &ast::Parameter) -> Self {
         Self(NodeKey::from_node(node))

crates/red_knot_python_semantic/src/semantic_index/symbol.rs

@@ -463,7 +463,10 @@ impl NodeWithScopeKind {
     }
 
     pub fn expect_function(&self) -> &ast::StmtFunctionDef {
-        self.as_function().expect("expected function")
+        match self {
+            Self::Function(function) => function.node(),
+            _ => panic!("expected function"),
+        }
     }
 
     pub fn expect_type_alias(&self) -> &ast::StmtTypeAlias {
@@ -472,13 +475,6 @@ impl NodeWithScopeKind {
             _ => panic!("expected type alias"),
         }
     }
-
-    pub const fn as_function(&self) -> Option<&ast::StmtFunctionDef> {
-        match self {
-            Self::Function(function) => Some(function.node()),
-            _ => None,
-        }
-    }
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]

crates/red_knot_python_semantic/src/semantic_index/use_def.rs

@@ -169,11 +169,17 @@
 //! indexvecs in the [`UseDefMap`].
 //!
 //! There is another special kind of possible "definition" for a symbol: there might be a path from
-//! the scope entry to a given use in which the symbol is never bound. We model this with a special
-//! "unbound" definition (a `None` entry at the start of the `all_definitions` vector). If that
-//! sentinel definition is present in the live bindings at a given use, it means that there is a
-//! possible path through control flow in which that symbol is unbound. Similarly, if that sentinel
-//! is present in the live declarations, it means that the symbol is (possibly) undeclared.
+//! the scope entry to a given use in which the symbol is never bound.
+//!
+//! The simplest way to model "unbound" would be as a "binding" itself: the initial "binding" for
+//! each symbol in a scope. But actually modeling it this way would unnecessarily increase the
+//! number of [`Definition`]s that Salsa must track. Since "unbound" is special in that all symbols
+//! share it, and it doesn't have any additional per-symbol state, and constraints are irrelevant
+//! to it, we can represent it more efficiently: we use the `may_be_unbound` boolean on the
+//! [`SymbolBindings`] struct. If this flag is `true` for a use of a symbol, it means the symbol
+//! has a path to the use in which it is never bound. If this flag is `false`, it means we've
+//! eliminated the possibility of unbound: every control flow path to the use includes a binding
+//! for this symbol.
 //!
 //! To build a [`UseDefMap`], the [`UseDefMapBuilder`] is notified of each new use, definition, and
 //! constraint as they are encountered by the
@@ -184,13 +190,11 @@
 //! end of the scope, it records the state for each symbol as the public definitions of that
 //! symbol.
 //!
-//! Let's walk through the above example. Initially we do not have any record of `x`. When we add
-//! the new symbol (before we process the first binding), we create a new undefined `SymbolState`
-//! which has a single live binding (the "unbound" definition) and a single live declaration (the
-//! "undeclared" definition). When we see `x = 1`, we record that as the sole live binding of `x`.
-//! The "unbound" binding is no longer visible. Then we see `x = 2`, and we replace `x = 1` as the
-//! sole live binding of `x`. When we get to `y = x`, we record that the live bindings for that use
-//! of `x` are just the `x = 2` definition.
+//! Let's walk through the above example. Initially we record for `x` that it has no bindings, and
+//! may be unbound. When we see `x = 1`, we record that as the sole live binding of `x`, and flip
+//! `may_be_unbound` to `false`. Then we see `x = 2`, and we replace `x = 1` as the sole live
+//! binding of `x`. When we get to `y = x`, we record that the live bindings for that use of `x`
+//! are just the `x = 2` definition.
 //!
 //! Then we hit the `if` branch. We visit the `test` node (`flag` in this case), since that will
 //! happen regardless. Then we take a pre-branch snapshot of the current state for all symbols,
@@ -203,8 +207,8 @@
 //! be the pre-if conditions; if we are entering the `else` clause, we know that the `if` test
 //! failed and we didn't execute the `if` body. So we first reset the builder to the pre-if state,
 //! using the snapshot we took previously (meaning we now have `x = 2` as the sole binding for `x`
-//! again), and record a *negative* `flag` constraint for all live bindings (`x = 2`). We then
-//! visit the `else` clause, where `x = 4` replaces `x = 2` as the sole live binding of `x`.
+//! again), then visit the `else` clause, where `x = 4` replaces `x = 2` as the sole live binding
+//! of `x`.
 //!
 //! Now we reach the end of the if/else, and want to visit the following code. The state here needs
 //! to reflect that we might have gone through the `if` branch, or we might have gone through the
@@ -213,58 +217,18 @@
 //! snapshot (which has `x = 3` as the only live binding). The result of this merge is that we now
 //! have two live bindings of `x`: `x = 3` and `x = 4`.
 //!
-//! Another piece of information that the `UseDefMap` needs to provide are visibility constraints.
-//! These are similar to the narrowing constraints, but apply to bindings and declarations within a
-//! control flow path. Consider the following example:
-//! ```py
-//! x = 1
-//! if test:
-//!     x = 2
-//!     y = "y"
-//! ```
-//! In principle, there are two possible control flow paths here. However, if we can statically
-//! infer `test` to be always truthy or always falsy (that is, `__bool__` of `test` is of type
-//! `Literal[True]` or `Literal[False]`), we can rule out one of the possible paths. To support
-//! this feature, we record a visibility constraint of `test` to all live bindings and declarations
-//! *after* visiting the body of the `if` statement. And we record a negative visibility constraint
-//! `~test` to all live bindings/declarations in the (implicit) `else` branch. For the example
-//! above, we would record the following visibility constraints (adding the implicit "unbound"
-//! definitions for clarity):
-//! ```py
-//! x = <unbound>  # not live, shadowed by `x = 1`
-//! y = <unbound>  # visibility constraint: ~test
-//!
-//! x = 1  # visibility constraint: ~test
-//! if test:
-//!     x = 2  # visibility constraint: test
-//!     y = "y"  # visibility constraint: test
-//! ```
-//! When we encounter a use of `x` after this `if` statement, we would record two live bindings: `x
-//! = 1` with a constraint of `~test`, and `x = 2` with a constraint of `test`. In type inference,
-//! when we iterate over all live bindings, we can evaluate these constraints to determine if a
-//! particular binding is actually visible. For example, if `test` is always truthy, we only see
-//! the `x = 2` binding. If `test` is always falsy, we only see the `x = 1` binding. And if the
-//! `__bool__` method of `test` returns type `bool`, we can see both bindings.
-//!
-//! Note that we also record visibility constraints for the start of the scope. This is important
-//! to determine if a symbol is definitely bound, possibly unbound, or definitely unbound. In the
-//! example above, The `y = <unbound>` binding is constrained by `~test`, so `y` would only be
-//! definitely-bound if `test` is always truthy.
-//!
 //! The [`UseDefMapBuilder`] itself just exposes methods for taking a snapshot, resetting to a
 //! snapshot, and merging a snapshot into the current state. The logic using these methods lives in
 //! [`SemanticIndexBuilder`](crate::semantic_index::builder::SemanticIndexBuilder), e.g. where it
 //! visits a `StmtIf` node.
 use self::symbol_state::{
     BindingIdWithConstraintsIterator, ConstraintIdIterator, DeclarationIdIterator,
-    ScopedDefinitionId, SymbolBindings, SymbolDeclarations, SymbolState,
+    ScopedConstraintId, ScopedDefinitionId, SymbolBindings, SymbolDeclarations, SymbolState,
 };
-pub(crate) use self::symbol_state::{ScopedConstraintId, ScopedVisibilityConstraintId};
 use crate::semantic_index::ast_ids::ScopedUseId;
 use crate::semantic_index::definition::Definition;
 use crate::semantic_index::symbol::ScopedSymbolId;
-use crate::semantic_index::use_def::symbol_state::DeclarationIdWithConstraint;
-use crate::visibility_constraints::{VisibilityConstraint, VisibilityConstraints};
+use crate::symbol::Boundness;
 use ruff_index::IndexVec;
 use rustc_hash::FxHashMap;
 
@@ -273,20 +237,14 @@ use super::constraint::Constraint;
 mod bitset;
 mod symbol_state;
 
-type AllConstraints<'db> = IndexVec<ScopedConstraintId, Constraint<'db>>;
-
 /// Applicable definitions and constraints for every use of a name.
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) struct UseDefMap<'db> {
-    /// Array of [`Definition`] in this scope. Only the first entry should be `None`;
-    /// this represents the implicit "unbound"/"undeclared" definition of every symbol.
-    all_definitions: IndexVec<ScopedDefinitionId, Option<Definition<'db>>>,
+    /// Array of [`Definition`] in this scope.
+    all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,
 
     /// Array of [`Constraint`] in this scope.
-    all_constraints: AllConstraints<'db>,
-
-    /// Array of [`VisibilityConstraint`]s in this scope.
-    visibility_constraints: VisibilityConstraints<'db>,
+    all_constraints: IndexVec<ScopedConstraintId, Constraint<'db>>,
 
     /// [`SymbolBindings`] reaching a [`ScopedUseId`].
     bindings_by_use: IndexVec<ScopedUseId, SymbolBindings>,
@@ -317,6 +275,14 @@ impl<'db> UseDefMap<'db> {
         self.bindings_iterator(&self.bindings_by_use[use_id])
     }
 
+    pub(crate) fn use_boundness(&self, use_id: ScopedUseId) -> Boundness {
+        if self.bindings_by_use[use_id].may_be_unbound() {
+            Boundness::PossiblyUnbound
+        } else {
+            Boundness::Bound
+        }
+    }
+
     pub(crate) fn public_bindings(
         &self,
         symbol: ScopedSymbolId,
@@ -324,6 +290,14 @@ impl<'db> UseDefMap<'db> {
         self.bindings_iterator(self.public_symbols[symbol].bindings())
     }
 
+    pub(crate) fn public_boundness(&self, symbol: ScopedSymbolId) -> Boundness {
+        if self.public_symbols[symbol].may_be_unbound() {
+            Boundness::PossiblyUnbound
+        } else {
+            Boundness::Bound
+        }
+    }
+
     pub(crate) fn bindings_at_declaration(
         &self,
         declaration: Definition<'db>,
@@ -336,10 +310,10 @@ impl<'db> UseDefMap<'db> {
         }
     }
 
-    pub(crate) fn declarations_at_binding<'map>(
-        &'map self,
+    pub(crate) fn declarations_at_binding(
+        &self,
         binding: Definition<'db>,
-    ) -> DeclarationsIterator<'map, 'db> {
+    ) -> DeclarationsIterator<'_, 'db> {
         if let SymbolDefinitions::Declarations(declarations) =
             &self.definitions_by_definition[&binding]
         {
@@ -349,34 +323,37 @@ impl<'db> UseDefMap<'db> {
         }
     }
 
-    pub(crate) fn public_declarations<'map>(
-        &'map self,
+    pub(crate) fn public_declarations(
+        &self,
         symbol: ScopedSymbolId,
-    ) -> DeclarationsIterator<'map, 'db> {
+    ) -> DeclarationsIterator<'_, 'db> {
         let declarations = self.public_symbols[symbol].declarations();
         self.declarations_iterator(declarations)
     }
 
-    fn bindings_iterator<'map>(
-        &'map self,
-        bindings: &'map SymbolBindings,
-    ) -> BindingWithConstraintsIterator<'map, 'db> {
+    pub(crate) fn has_public_declarations(&self, symbol: ScopedSymbolId) -> bool {
+        !self.public_symbols[symbol].declarations().is_empty()
+    }
+
+    fn bindings_iterator<'a>(
+        &'a self,
+        bindings: &'a SymbolBindings,
+    ) -> BindingWithConstraintsIterator<'a, 'db> {
         BindingWithConstraintsIterator {
             all_definitions: &self.all_definitions,
             all_constraints: &self.all_constraints,
-            visibility_constraints: &self.visibility_constraints,
             inner: bindings.iter(),
         }
     }
 
-    fn declarations_iterator<'map>(
-        &'map self,
-        declarations: &'map SymbolDeclarations,
-    ) -> DeclarationsIterator<'map, 'db> {
+    fn declarations_iterator<'a>(
+        &'a self,
+        declarations: &'a SymbolDeclarations,
+    ) -> DeclarationsIterator<'a, 'db> {
         DeclarationsIterator {
             all_definitions: &self.all_definitions,
-            visibility_constraints: &self.visibility_constraints,
             inner: declarations.iter(),
+            may_be_undeclared: declarations.may_be_undeclared(),
         }
     }
 }
@@ -390,9 +367,8 @@ enum SymbolDefinitions {
 
 #[derive(Debug)]
 pub(crate) struct BindingWithConstraintsIterator<'map, 'db> {
-    all_definitions: &'map IndexVec<ScopedDefinitionId, Option<Definition<'db>>>,
-    all_constraints: &'map AllConstraints<'db>,
-    pub(crate) visibility_constraints: &'map VisibilityConstraints<'db>,
+    all_definitions: &'map IndexVec<ScopedDefinitionId, Definition<'db>>,
+    all_constraints: &'map IndexVec<ScopedConstraintId, Constraint<'db>>,
     inner: BindingIdWithConstraintsIterator<'map>,
 }
 
@@ -400,17 +376,14 @@ impl<'map, 'db> Iterator for BindingWithConstraintsIterator<'map, 'db> {
     type Item = BindingWithConstraints<'map, 'db>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let all_constraints = self.all_constraints;
-
         self.inner
             .next()
-            .map(|binding_id_with_constraints| BindingWithConstraints {
-                binding: self.all_definitions[binding_id_with_constraints.definition],
+            .map(|def_id_with_constraints| BindingWithConstraints {
+                binding: self.all_definitions[def_id_with_constraints.definition],
                 constraints: ConstraintsIterator {
-                    all_constraints,
-                    constraint_ids: binding_id_with_constraints.constraint_ids,
+                    all_constraints: self.all_constraints,
+                    constraint_ids: def_id_with_constraints.constraint_ids,
                 },
-                visibility_constraint: binding_id_with_constraints.visibility_constraint,
             })
     }
 }
@@ -418,13 +391,12 @@ impl<'map, 'db> Iterator for BindingWithConstraintsIterator<'map, 'db> {
 impl std::iter::FusedIterator for BindingWithConstraintsIterator<'_, '_> {}
 
 pub(crate) struct BindingWithConstraints<'map, 'db> {
-    pub(crate) binding: Option<Definition<'db>>,
+    pub(crate) binding: Definition<'db>,
     pub(crate) constraints: ConstraintsIterator<'map, 'db>,
-    pub(crate) visibility_constraint: ScopedVisibilityConstraintId,
 }
 
 pub(crate) struct ConstraintsIterator<'map, 'db> {
-    all_constraints: &'map AllConstraints<'db>,
+    all_constraints: &'map IndexVec<ScopedConstraintId, Constraint<'db>>,
     constraint_ids: ConstraintIdIterator<'map>,
 }
 
@@ -441,31 +413,22 @@ impl<'db> Iterator for ConstraintsIterator<'_, 'db> {
 impl std::iter::FusedIterator for ConstraintsIterator<'_, '_> {}
 
 pub(crate) struct DeclarationsIterator<'map, 'db> {
-    all_definitions: &'map IndexVec<ScopedDefinitionId, Option<Definition<'db>>>,
-    pub(crate) visibility_constraints: &'map VisibilityConstraints<'db>,
+    all_definitions: &'map IndexVec<ScopedDefinitionId, Definition<'db>>,
     inner: DeclarationIdIterator<'map>,
+    may_be_undeclared: bool,
 }
 
-pub(crate) struct DeclarationWithConstraint<'db> {
-    pub(crate) declaration: Option<Definition<'db>>,
-    pub(crate) visibility_constraint: ScopedVisibilityConstraintId,
+impl DeclarationsIterator<'_, '_> {
+    pub(crate) fn may_be_undeclared(&self) -> bool {
+        self.may_be_undeclared
+    }
 }
 
 impl<'db> Iterator for DeclarationsIterator<'_, 'db> {
-    type Item = DeclarationWithConstraint<'db>;
+    type Item = Definition<'db>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.inner.next().map(
-            |DeclarationIdWithConstraint {
-                 definition,
-                 visibility_constraint,
-             }| {
-                DeclarationWithConstraint {
-                    declaration: self.all_definitions[definition],
-                    visibility_constraint,
-                }
-            },
-        )
+        self.inner.next().map(|def_id| self.all_definitions[def_id])
     }
 }
 
@@ -475,25 +438,15 @@ impl std::iter::FusedIterator for DeclarationsIterator<'_, '_> {}
 #[derive(Clone, Debug)]
 pub(super) struct FlowSnapshot {
     symbol_states: IndexVec<ScopedSymbolId, SymbolState>,
-    scope_start_visibility: ScopedVisibilityConstraintId,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub(super) struct UseDefMapBuilder<'db> {
     /// Append-only array of [`Definition`].
-    all_definitions: IndexVec<ScopedDefinitionId, Option<Definition<'db>>>,
+    all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,
 
     /// Append-only array of [`Constraint`].
-    all_constraints: AllConstraints<'db>,
-
-    /// Append-only array of [`VisibilityConstraint`].
-    visibility_constraints: VisibilityConstraints<'db>,
-
-    /// A constraint which describes the visibility of the unbound/undeclared state, i.e.
-    /// whether or not the start of the scope is visible. This is important for cases like
-    /// `if True: x = 1; use(x)` where we need to hide the implicit "x = unbound" binding
-    /// in the "else" branch.
-    scope_start_visibility: ScopedVisibilityConstraintId,
+    all_constraints: IndexVec<ScopedConstraintId, Constraint<'db>>,
 
     /// Live bindings at each so-far-recorded use.
     bindings_by_use: IndexVec<ScopedUseId, SymbolBindings>,
@@ -505,30 +458,14 @@ pub(super) struct UseDefMapBuilder<'db> {
     symbol_states: IndexVec<ScopedSymbolId, SymbolState>,
 }
 
-impl Default for UseDefMapBuilder<'_> {
-    fn default() -> Self {
-        Self {
-            all_definitions: IndexVec::from_iter([None]),
-            all_constraints: IndexVec::new(),
-            visibility_constraints: VisibilityConstraints::default(),
-            scope_start_visibility: ScopedVisibilityConstraintId::ALWAYS_TRUE,
-            bindings_by_use: IndexVec::new(),
-            definitions_by_definition: FxHashMap::default(),
-            symbol_states: IndexVec::new(),
-        }
-    }
-}
-
 impl<'db> UseDefMapBuilder<'db> {
     pub(super) fn add_symbol(&mut self, symbol: ScopedSymbolId) {
-        let new_symbol = self
-            .symbol_states
-            .push(SymbolState::undefined(self.scope_start_visibility));
+        let new_symbol = self.symbol_states.push(SymbolState::undefined());
         debug_assert_eq!(symbol, new_symbol);
     }
 
     pub(super) fn record_binding(&mut self, symbol: ScopedSymbolId, binding: Definition<'db>) {
-        let def_id = self.all_definitions.push(Some(binding));
+        let def_id = self.all_definitions.push(binding);
         let symbol_state = &mut self.symbol_states[symbol];
         self.definitions_by_definition.insert(
             binding,
@@ -537,82 +474,10 @@ impl<'db> UseDefMapBuilder<'db> {
         symbol_state.record_binding(def_id);
     }
 
-    pub(super) fn add_constraint(&mut self, constraint: Constraint<'db>) -> ScopedConstraintId {
-        self.all_constraints.push(constraint)
-    }
-
-    pub(super) fn record_constraint_id(&mut self, constraint: ScopedConstraintId) {
+    pub(super) fn record_constraint(&mut self, constraint: Constraint<'db>) {
+        let constraint_id = self.all_constraints.push(constraint);
         for state in &mut self.symbol_states {
-            state.record_constraint(constraint);
-        }
-    }
-
-    pub(super) fn record_constraint(&mut self, constraint: Constraint<'db>) -> ScopedConstraintId {
-        let new_constraint_id = self.add_constraint(constraint);
-        self.record_constraint_id(new_constraint_id);
-        new_constraint_id
-    }
-
-    pub(super) fn add_visibility_constraint(
-        &mut self,
-        constraint: VisibilityConstraint<'db>,
-    ) -> ScopedVisibilityConstraintId {
-        self.visibility_constraints.add(constraint)
-    }
-
-    pub(super) fn record_visibility_constraint_id(
-        &mut self,
-        constraint: ScopedVisibilityConstraintId,
-    ) {
-        for state in &mut self.symbol_states {
-            state.record_visibility_constraint(&mut self.visibility_constraints, constraint);
-        }
-
-        self.scope_start_visibility = self
-            .visibility_constraints
-            .add_and_constraint(self.scope_start_visibility, constraint);
-    }
-
-    pub(super) fn record_visibility_constraint(
-        &mut self,
-        constraint: VisibilityConstraint<'db>,
-    ) -> ScopedVisibilityConstraintId {
-        let new_constraint_id = self.add_visibility_constraint(constraint);
-        self.record_visibility_constraint_id(new_constraint_id);
-        new_constraint_id
-    }
-
-    /// This method resets the visibility constraints for all symbols to a previous state
-    /// *if* there have been no new declarations or bindings since then. Consider the
-    /// following example:
-    /// ```py
-    /// x = 0
-    /// y = 0
-    /// if test_a:
-    ///     y = 1
-    /// elif test_b:
-    ///     y = 2
-    /// elif test_c:
-    ///    y = 3
-    ///
-    /// # RESET
-    /// ```
-    /// We build a complex visibility constraint for the `y = 0` binding. We build the same
-    /// constraint for the `x = 0` binding as well, but at the `RESET` point, we can get rid
-    /// of it, as the `if`-`elif`-`elif` chain doesn't include any new bindings of `x`.
-    pub(super) fn simplify_visibility_constraints(&mut self, snapshot: FlowSnapshot) {
-        debug_assert!(self.symbol_states.len() >= snapshot.symbol_states.len());
-
-        self.scope_start_visibility = snapshot.scope_start_visibility;
-
-        // Note that this loop terminates when we reach a symbol not present in the snapshot.
-        // This means we keep visibility constraints for all new symbols, which is intended,
-        // since these symbols have been introduced in the corresponding branch, which might
-        // be subject to visibility constraints. We only simplify/reset visibility constraints
-        // for symbols that have the same bindings and declarations present compared to the
-        // snapshot.
-        for (current, snapshot) in self.symbol_states.iter_mut().zip(snapshot.symbol_states) {
-            current.simplify_visibility_constraints(snapshot);
+            state.record_constraint(constraint_id);
         }
     }
 
@@ -621,7 +486,7 @@ impl<'db> UseDefMapBuilder<'db> {
         symbol: ScopedSymbolId,
         declaration: Definition<'db>,
     ) {
-        let def_id = self.all_definitions.push(Some(declaration));
+        let def_id = self.all_definitions.push(declaration);
         let symbol_state = &mut self.symbol_states[symbol];
         self.definitions_by_definition.insert(
             declaration,
@@ -636,7 +501,7 @@ impl<'db> UseDefMapBuilder<'db> {
         definition: Definition<'db>,
     ) {
         // We don't need to store anything in self.definitions_by_definition.
-        let def_id = self.all_definitions.push(Some(definition));
+        let def_id = self.all_definitions.push(definition);
         let symbol_state = &mut self.symbol_states[symbol];
         symbol_state.record_declaration(def_id);
         symbol_state.record_binding(def_id);
@@ -655,7 +520,6 @@ impl<'db> UseDefMapBuilder<'db> {
     pub(super) fn snapshot(&self) -> FlowSnapshot {
         FlowSnapshot {
             symbol_states: self.symbol_states.clone(),
-            scope_start_visibility: self.scope_start_visibility,
         }
     }
 
@@ -669,15 +533,12 @@ impl<'db> UseDefMapBuilder<'db> {
 
         // Restore the current visible-definitions state to the given snapshot.
         self.symbol_states = snapshot.symbol_states;
-        self.scope_start_visibility = snapshot.scope_start_visibility;
 
         // If the snapshot we are restoring is missing some symbols we've recorded since, we need
         // to fill them in so the symbol IDs continue to line up. Since they don't exist in the
         // snapshot, the correct state to fill them in with is "undefined".
-        self.symbol_states.resize(
-            num_symbols,
-            SymbolState::undefined(self.scope_start_visibility),
-        );
+        self.symbol_states
+            .resize(num_symbols, SymbolState::undefined());
     }
 
     /// Merge the given snapshot into the current state, reflecting that we might have taken either
@@ -692,19 +553,13 @@ impl<'db> UseDefMapBuilder<'db> {
         let mut snapshot_definitions_iter = snapshot.symbol_states.into_iter();
         for current in &mut self.symbol_states {
             if let Some(snapshot) = snapshot_definitions_iter.next() {
-                current.merge(snapshot, &mut self.visibility_constraints);
+                current.merge(snapshot);
             } else {
-                current.merge(
-                    SymbolState::undefined(snapshot.scope_start_visibility),
-                    &mut self.visibility_constraints,
-                );
                 // Symbol not present in snapshot, so it's unbound/undeclared from that path.
+                current.set_may_be_unbound();
+                current.set_may_be_undeclared();
             }
         }
-
-        self.scope_start_visibility = self
-            .visibility_constraints
-            .add_or_constraint(self.scope_start_visibility, snapshot.scope_start_visibility);
     }
 
     pub(super) fn finish(mut self) -> UseDefMap<'db> {
@@ -717,7 +572,6 @@ impl<'db> UseDefMapBuilder<'db> {
         UseDefMap {
             all_definitions: self.all_definitions,
             all_constraints: self.all_constraints,
-            visibility_constraints: self.visibility_constraints,
             bindings_by_use: self.bindings_by_use,
             public_symbols: self.symbol_states,
             definitions_by_definition: self.definitions_by_definition,

crates/red_knot_python_semantic/src/semantic_index/use_def/bitset.rs

@@ -32,6 +32,10 @@ impl<const B: usize> BitSet<B> {
         bitset
     }
 
+    pub(super) fn is_empty(&self) -> bool {
+        self.blocks().iter().all(|&b| b == 0)
+    }
+
     /// Convert from Inline to Heap, if needed, and resize the Heap vector, if needed.
     fn resize(&mut self, value: u32) {
         let num_blocks_needed = (value / 64) + 1;
@@ -93,6 +97,19 @@ impl<const B: usize> BitSet<B> {
         }
     }
 
+    /// Union in-place with another [`BitSet`].
+    pub(super) fn union(&mut self, other: &BitSet<B>) {
+        let mut max_len = self.blocks().len();
+        let other_len = other.blocks().len();
+        if other_len > max_len {
+            max_len = other_len;
+            self.resize_blocks(max_len);
+        }
+        for (my_block, other_block) in self.blocks_mut().iter_mut().zip(other.blocks()) {
+            *my_block |= other_block;
+        }
+    }
+
     /// Return an iterator over the values (in ascending order) in this [`BitSet`].
     pub(super) fn iter(&self) -> BitSetIterator<'_, B> {
         let blocks = self.blocks();
@@ -222,6 +239,59 @@ mod tests {
         assert_bitset(&b1, &[89]);
     }
 
+    #[test]
+    fn union() {
+        let mut b1 = BitSet::<1>::with(2);
+        let b2 = BitSet::<1>::with(4);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[2, 4]);
+    }
+
+    #[test]
+    fn union_mixed_1() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(89);
+        b2.insert(5);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 5, 89]);
+    }
+
+    #[test]
+    fn union_mixed_2() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(23);
+        b2.insert(89);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 23, 89]);
+    }
+
+    #[test]
+    fn union_heap() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(89);
+        b2.insert(90);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 89, 90]);
+    }
+
+    #[test]
+    fn union_heap_2() {
+        let mut b1 = BitSet::<1>::with(89);
+        let mut b2 = BitSet::<1>::with(89);
+        b1.insert(91);
+        b2.insert(90);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[89, 90, 91]);
+    }
+
     #[test]
     fn multiple_blocks() {
         let mut b = BitSet::<2>::with(120);
@@ -229,4 +299,11 @@ mod tests {
         assert!(matches!(b, BitSet::Inline(_)));
         assert_bitset(&b, &[45, 120]);
     }
+
+    #[test]
+    fn empty() {
+        let b = BitSet::<1>::default();
+
+        assert!(b.is_empty());
+    }
 }

crates/red_knot_python_semantic/src/semantic_index/use_def/symbol_state.rs

@@ -43,8 +43,6 @@
 //!
 //! Tracking live declarations is simpler, since constraints are not involved, but otherwise very
 //! similar to tracking live bindings.
-use crate::semantic_index::use_def::VisibilityConstraints;
-
 use super::bitset::{BitSet, BitSetIterator};
 use ruff_index::newtype_index;
 use smallvec::SmallVec;
@@ -53,18 +51,9 @@ use smallvec::SmallVec;
 #[newtype_index]
 pub(super) struct ScopedDefinitionId;
 
-impl ScopedDefinitionId {
-    /// A special ID that is used to describe an implicit start-of-scope state. When
-    /// we see that this definition is live, we know that the symbol is (possibly)
-    /// unbound or undeclared at a given usage site.
-    /// When creating a use-def-map builder, we always add an empty `None` definition
-    /// at index 0, so this ID is always present.
-    pub(super) const UNBOUND: ScopedDefinitionId = ScopedDefinitionId::from_u32(0);
-}
-
 /// A newtype-index for a constraint expression in a particular scope.
 #[newtype_index]
-pub(crate) struct ScopedConstraintId;
+pub(super) struct ScopedConstraintId;
 
 /// Can reference this * 64 total definitions inline; more will fall back to the heap.
 const INLINE_BINDING_BLOCKS: usize = 3;
@@ -86,97 +75,58 @@ const INLINE_CONSTRAINT_BLOCKS: usize = 2;
 /// Can keep inline this many live bindings per symbol at a given time; more will go to heap.
 const INLINE_BINDINGS_PER_SYMBOL: usize = 4;
 
-/// Which constraints apply to a given binding?
-type Constraints = BitSet<INLINE_CONSTRAINT_BLOCKS>;
-
-type InlineConstraintArray = [Constraints; INLINE_BINDINGS_PER_SYMBOL];
-
-/// One [`BitSet`] of applicable [`ScopedConstraintId`]s per live binding.
-type ConstraintsPerBinding = SmallVec<InlineConstraintArray>;
-
-/// Iterate over all constraints for a single binding.
-type ConstraintsIterator<'a> = std::slice::Iter<'a, Constraints>;
+/// One [`BitSet`] of applicable [`ScopedConstraintId`] per live binding.
+type InlineConstraintArray = [BitSet<INLINE_CONSTRAINT_BLOCKS>; INLINE_BINDINGS_PER_SYMBOL];
+type Constraints = SmallVec<InlineConstraintArray>;
+type ConstraintsIterator<'a> = std::slice::Iter<'a, BitSet<INLINE_CONSTRAINT_BLOCKS>>;
 type ConstraintsIntoIterator = smallvec::IntoIter<InlineConstraintArray>;
 
-/// A newtype-index for a visibility constraint in a particular scope.
-#[newtype_index]
-pub(crate) struct ScopedVisibilityConstraintId;
-
-impl ScopedVisibilityConstraintId {
-    /// A special ID that is used for an "always true" / "always visible" constraint.
-    /// When we create a new [`VisibilityConstraints`] object, this constraint is always
-    /// present at index 0.
-    pub(crate) const ALWAYS_TRUE: ScopedVisibilityConstraintId =
-        ScopedVisibilityConstraintId::from_u32(0);
-}
-
-const INLINE_VISIBILITY_CONSTRAINTS: usize = 4;
-type InlineVisibilityConstraintsArray =
-    [ScopedVisibilityConstraintId; INLINE_VISIBILITY_CONSTRAINTS];
-
-/// One [`ScopedVisibilityConstraintId`] per live declaration.
-type VisibilityConstraintPerDeclaration = SmallVec<InlineVisibilityConstraintsArray>;
-
-/// One [`ScopedVisibilityConstraintId`] per live binding.
-type VisibilityConstraintPerBinding = SmallVec<InlineVisibilityConstraintsArray>;
-
-/// Iterator over the visibility constraints for all live bindings/declarations.
-type VisibilityConstraintsIterator<'a> = std::slice::Iter<'a, ScopedVisibilityConstraintId>;
-
-type VisibilityConstraintsIntoIterator = smallvec::IntoIter<InlineVisibilityConstraintsArray>;
-
-/// Live declarations for a single symbol at some point in control flow, with their
-/// corresponding visibility constraints.
+/// Live declarations for a single symbol at some point in control flow.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(super) struct SymbolDeclarations {
     /// [`BitSet`]: which declarations (as [`ScopedDefinitionId`]) can reach the current location?
-    pub(crate) live_declarations: Declarations,
+    live_declarations: Declarations,
 
-    /// For each live declaration, which visibility constraint applies to it?
-    pub(crate) visibility_constraints: VisibilityConstraintPerDeclaration,
+    /// Could the symbol be un-declared at this point?
+    may_be_undeclared: bool,
 }
 
 impl SymbolDeclarations {
-    fn undeclared(scope_start_visibility: ScopedVisibilityConstraintId) -> Self {
+    fn undeclared() -> Self {
         Self {
-            live_declarations: Declarations::with(0),
-            visibility_constraints: VisibilityConstraintPerDeclaration::from_iter([
-                scope_start_visibility,
-            ]),
+            live_declarations: Declarations::default(),
+            may_be_undeclared: true,
         }
     }
 
     /// Record a newly-encountered declaration for this symbol.
     fn record_declaration(&mut self, declaration_id: ScopedDefinitionId) {
         self.live_declarations = Declarations::with(declaration_id.into());
-
-        self.visibility_constraints = VisibilityConstraintPerDeclaration::with_capacity(1);
-        self.visibility_constraints
-            .push(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        self.may_be_undeclared = false;
     }
 
-    /// Add given visibility constraint to all live declarations.
-    pub(super) fn record_visibility_constraint(
-        &mut self,
-        visibility_constraints: &mut VisibilityConstraints,
-        constraint: ScopedVisibilityConstraintId,
-    ) {
-        for existing in &mut self.visibility_constraints {
-            *existing = visibility_constraints.add_and_constraint(*existing, constraint);
-        }
+    /// Add undeclared as a possibility for this symbol.
+    fn set_may_be_undeclared(&mut self) {
+        self.may_be_undeclared = true;
     }
 
     /// Return an iterator over live declarations for this symbol.
     pub(super) fn iter(&self) -> DeclarationIdIterator {
         DeclarationIdIterator {
-            declarations: self.live_declarations.iter(),
-            visibility_constraints: self.visibility_constraints.iter(),
+            inner: self.live_declarations.iter(),
         }
     }
+
+    pub(super) fn is_empty(&self) -> bool {
+        self.live_declarations.is_empty()
+    }
+
+    pub(super) fn may_be_undeclared(&self) -> bool {
+        self.may_be_undeclared
+    }
 }
 
-/// Live bindings for a single symbol at some point in control flow. Each live binding comes
-/// with a set of narrowing constraints and a visibility constraint.
+/// Live bindings and narrowing constraints for a single symbol at some point in control flow.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(super) struct SymbolBindings {
     /// [`BitSet`]: which bindings (as [`ScopedDefinitionId`]) can reach the current location?
@@ -186,34 +136,34 @@ pub(super) struct SymbolBindings {
     ///
     /// This is a [`smallvec::SmallVec`] which should always have one [`BitSet`] of constraints per
     /// binding in `live_bindings`.
-    constraints: ConstraintsPerBinding,
+    constraints: Constraints,
 
-    /// For each live binding, which visibility constraint applies to it?
-    visibility_constraints: VisibilityConstraintPerBinding,
+    /// Could the symbol be unbound at this point?
+    may_be_unbound: bool,
 }
 
 impl SymbolBindings {
-    fn unbound(scope_start_visibility: ScopedVisibilityConstraintId) -> Self {
+    fn unbound() -> Self {
         Self {
-            live_bindings: Bindings::with(ScopedDefinitionId::UNBOUND.as_u32()),
-            constraints: ConstraintsPerBinding::from_iter([Constraints::default()]),
-            visibility_constraints: VisibilityConstraintPerBinding::from_iter([
-                scope_start_visibility,
-            ]),
+            live_bindings: Bindings::default(),
+            constraints: Constraints::default(),
+            may_be_unbound: true,
         }
     }
 
+    /// Add Unbound as a possibility for this symbol.
+    fn set_may_be_unbound(&mut self) {
+        self.may_be_unbound = true;
+    }
+
     /// Record a newly-encountered binding for this symbol.
     pub(super) fn record_binding(&mut self, binding_id: ScopedDefinitionId) {
         // The new binding replaces all previous live bindings in this path, and has no
         // constraints.
         self.live_bindings = Bindings::with(binding_id.into());
-        self.constraints = ConstraintsPerBinding::with_capacity(1);
-        self.constraints.push(Constraints::default());
-
-        self.visibility_constraints = VisibilityConstraintPerBinding::with_capacity(1);
-        self.visibility_constraints
-            .push(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        self.constraints = Constraints::with_capacity(1);
+        self.constraints.push(BitSet::default());
+        self.may_be_unbound = false;
     }
 
     /// Add given constraint to all live bindings.
@@ -223,25 +173,17 @@ impl SymbolBindings {
         }
     }
 
-    /// Add given visibility constraint to all live bindings.
-    pub(super) fn record_visibility_constraint(
-        &mut self,
-        visibility_constraints: &mut VisibilityConstraints,
-        constraint: ScopedVisibilityConstraintId,
-    ) {
-        for existing in &mut self.visibility_constraints {
-            *existing = visibility_constraints.add_and_constraint(*existing, constraint);
-        }
-    }
-
-    /// Iterate over currently live bindings for this symbol
+    /// Iterate over currently live bindings for this symbol.
     pub(super) fn iter(&self) -> BindingIdWithConstraintsIterator {
         BindingIdWithConstraintsIterator {
             definitions: self.live_bindings.iter(),
             constraints: self.constraints.iter(),
-            visibility_constraints: self.visibility_constraints.iter(),
         }
     }
+
+    pub(super) fn may_be_unbound(&self) -> bool {
+        self.may_be_unbound
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -252,16 +194,20 @@ pub(super) struct SymbolState {
 
 impl SymbolState {
     /// Return a new [`SymbolState`] representing an unbound, undeclared symbol.
-    pub(super) fn undefined(scope_start_visibility: ScopedVisibilityConstraintId) -> Self {
+    pub(super) fn undefined() -> Self {
         Self {
-            declarations: SymbolDeclarations::undeclared(scope_start_visibility),
-            bindings: SymbolBindings::unbound(scope_start_visibility),
+            declarations: SymbolDeclarations::undeclared(),
+            bindings: SymbolBindings::unbound(),
         }
     }
 
+    /// Add Unbound as a possibility for this symbol.
+    pub(super) fn set_may_be_unbound(&mut self) {
+        self.bindings.set_may_be_unbound();
+    }
+
     /// Record a newly-encountered binding for this symbol.
     pub(super) fn record_binding(&mut self, binding_id: ScopedDefinitionId) {
-        debug_assert_ne!(binding_id, ScopedDefinitionId::UNBOUND);
         self.bindings.record_binding(binding_id);
     }
 
@@ -270,26 +216,9 @@ impl SymbolState {
         self.bindings.record_constraint(constraint_id);
     }
 
-    /// Add given visibility constraint to all live bindings.
-    pub(super) fn record_visibility_constraint(
-        &mut self,
-        visibility_constraints: &mut VisibilityConstraints,
-        constraint: ScopedVisibilityConstraintId,
-    ) {
-        self.bindings
-            .record_visibility_constraint(visibility_constraints, constraint);
-        self.declarations
-            .record_visibility_constraint(visibility_constraints, constraint);
-    }
-
-    pub(super) fn simplify_visibility_constraints(&mut self, snapshot_state: SymbolState) {
-        if self.bindings.live_bindings == snapshot_state.bindings.live_bindings {
-            self.bindings.visibility_constraints = snapshot_state.bindings.visibility_constraints;
-        }
-        if self.declarations.live_declarations == snapshot_state.declarations.live_declarations {
-            self.declarations.visibility_constraints =
-                snapshot_state.declarations.visibility_constraints;
-        }
+    /// Add undeclared as a possibility for this symbol.
+    pub(super) fn set_may_be_undeclared(&mut self) {
+        self.declarations.set_may_be_undeclared();
     }
 
     /// Record a newly-encountered declaration of this symbol.
@@ -298,31 +227,29 @@ impl SymbolState {
     }
 
     /// Merge another [`SymbolState`] into this one.
-    pub(super) fn merge(
-        &mut self,
-        b: SymbolState,
-        visibility_constraints: &mut VisibilityConstraints,
-    ) {
+    pub(super) fn merge(&mut self, b: SymbolState) {
         let mut a = Self {
             bindings: SymbolBindings {
                 live_bindings: Bindings::default(),
-                constraints: ConstraintsPerBinding::default(),
-                visibility_constraints: VisibilityConstraintPerBinding::default(),
+                constraints: Constraints::default(),
+                may_be_unbound: self.bindings.may_be_unbound || b.bindings.may_be_unbound,
             },
             declarations: SymbolDeclarations {
                 live_declarations: self.declarations.live_declarations.clone(),
-                visibility_constraints: VisibilityConstraintPerDeclaration::default(),
+                may_be_undeclared: self.declarations.may_be_undeclared
+                    || b.declarations.may_be_undeclared,
             },
         };
 
         std::mem::swap(&mut a, self);
+        self.declarations
+            .live_declarations
+            .union(&b.declarations.live_declarations);
 
         let mut a_defs_iter = a.bindings.live_bindings.iter();
         let mut b_defs_iter = b.bindings.live_bindings.iter();
         let mut a_constraints_iter = a.bindings.constraints.into_iter();
         let mut b_constraints_iter = b.bindings.constraints.into_iter();
-        let mut a_vis_constraints_iter = a.bindings.visibility_constraints.into_iter();
-        let mut b_vis_constraints_iter = b.bindings.visibility_constraints.into_iter();
 
         let mut opt_a_def: Option<u32> = a_defs_iter.next();
         let mut opt_b_def: Option<u32> = b_defs_iter.next();
@@ -334,30 +261,17 @@ impl SymbolState {
         // path is irrelevant.
 
         // Helper to push `def`, with constraints in `constraints_iter`, onto `self`.
-        let push = |def,
-                    constraints_iter: &mut ConstraintsIntoIterator,
-                    visibility_constraints_iter: &mut VisibilityConstraintsIntoIterator,
-                    merged: &mut Self| {
+        let push = |def, constraints_iter: &mut ConstraintsIntoIterator, merged: &mut Self| {
             merged.bindings.live_bindings.insert(def);
-            // SAFETY: we only ever create SymbolState using [`SymbolState::undefined`], which adds
-            // one "unbound" definition with corresponding narrowing and visibility constraints, or
-            // using [`SymbolState::record_binding`] or [`SymbolState::record_declaration`], which
-            // similarly add one definition with corresponding constraints. [`SymbolState::merge`]
-            // always pushes one definition and one constraint bitset and one visibility constraint
-            // together (just below), so the number of definitions and the number of constraints can
-            // never get out of sync.
+            // SAFETY: we only ever create SymbolState with either no definitions and no constraint
+            // bitsets (`::unbound`) or one definition and one constraint bitset (`::with`), and
+            // `::merge` always pushes one definition and one constraint bitset together (just
+            // below), so the number of definitions and the number of constraint bitsets can never
             // get out of sync.
             let constraints = constraints_iter
                 .next()
                 .expect("definitions and constraints length mismatch");
-            let visibility_constraints = visibility_constraints_iter
-                .next()
-                .expect("definitions and visibility_constraints length mismatch");
             merged.bindings.constraints.push(constraints);
-            merged
-                .bindings
-                .visibility_constraints
-                .push(visibility_constraints);
         };
 
         loop {
@@ -365,139 +279,50 @@ impl SymbolState {
                 (Some(a_def), Some(b_def)) => match a_def.cmp(&b_def) {
                     std::cmp::Ordering::Less => {
                         // Next definition ID is only in `a`, push it to `self` and advance `a`.
-                        push(
-                            a_def,
-                            &mut a_constraints_iter,
-                            &mut a_vis_constraints_iter,
-                            self,
-                        );
+                        push(a_def, &mut a_constraints_iter, self);
                         opt_a_def = a_defs_iter.next();
                     }
                     std::cmp::Ordering::Greater => {
                         // Next definition ID is only in `b`, push it to `self` and advance `b`.
-                        push(
-                            b_def,
-                            &mut b_constraints_iter,
-                            &mut b_vis_constraints_iter,
-                            self,
-                        );
+                        push(b_def, &mut b_constraints_iter, self);
                         opt_b_def = b_defs_iter.next();
                     }
                     std::cmp::Ordering::Equal => {
                         // Next definition is in both; push to `self` and intersect constraints.
-                        push(
-                            a_def,
-                            &mut b_constraints_iter,
-                            &mut b_vis_constraints_iter,
-                            self,
-                        );
-
-                        // SAFETY: see comment in `push` above.
+                        push(a_def, &mut b_constraints_iter, self);
+                        // SAFETY: we only ever create SymbolState with either no definitions and
+                        // no constraint bitsets (`::unbound`) or one definition and one constraint
+                        // bitset (`::with`), and `::merge` always pushes one definition and one
+                        // constraint bitset together (just below), so the number of definitions
+                        // and the number of constraint bitsets can never get out of sync.
                         let a_constraints = a_constraints_iter
                             .next()
                             .expect("definitions and constraints length mismatch");
-                        let current_constraints = self.bindings.constraints.last_mut().unwrap();
-
                         // If the same definition is visible through both paths, any constraint
                         // that applies on only one path is irrelevant to the resulting type from
                         // unioning the two paths, so we intersect the constraints.
-                        current_constraints.intersect(&a_constraints);
-
-                        // For visibility constraints, we merge them using a ternary OR operation:
-                        let a_vis_constraint = a_vis_constraints_iter
-                            .next()
-                            .expect("visibility_constraints length mismatch");
-                        let current_vis_constraint =
-                            self.bindings.visibility_constraints.last_mut().unwrap();
-                        *current_vis_constraint = visibility_constraints
-                            .add_or_constraint(*current_vis_constraint, a_vis_constraint);
-
+                        self.bindings
+                            .constraints
+                            .last_mut()
+                            .unwrap()
+                            .intersect(&a_constraints);
                         opt_a_def = a_defs_iter.next();
                         opt_b_def = b_defs_iter.next();
                     }
                 },
                 (Some(a_def), None) => {
                     // We've exhausted `b`, just push the def from `a` and move on to the next.
-                    push(
-                        a_def,
-                        &mut a_constraints_iter,
-                        &mut a_vis_constraints_iter,
-                        self,
-                    );
+                    push(a_def, &mut a_constraints_iter, self);
                     opt_a_def = a_defs_iter.next();
                 }
                 (None, Some(b_def)) => {
                     // We've exhausted `a`, just push the def from `b` and move on to the next.
-                    push(
-                        b_def,
-                        &mut b_constraints_iter,
-                        &mut b_vis_constraints_iter,
-                        self,
-                    );
+                    push(b_def, &mut b_constraints_iter, self);
                     opt_b_def = b_defs_iter.next();
                 }
                 (None, None) => break,
             }
         }
-
-        // Same as above, but for declarations.
-        let mut a_decls_iter = a.declarations.live_declarations.iter();
-        let mut b_decls_iter = b.declarations.live_declarations.iter();
-        let mut a_vis_constraints_iter = a.declarations.visibility_constraints.into_iter();
-        let mut b_vis_constraints_iter = b.declarations.visibility_constraints.into_iter();
-
-        let mut opt_a_decl: Option<u32> = a_decls_iter.next();
-        let mut opt_b_decl: Option<u32> = b_decls_iter.next();
-
-        let push = |decl,
-                    vis_constraints_iter: &mut VisibilityConstraintsIntoIterator,
-                    merged: &mut Self| {
-            merged.declarations.live_declarations.insert(decl);
-            let vis_constraints = vis_constraints_iter
-                .next()
-                .expect("declarations and visibility_constraints length mismatch");
-            merged
-                .declarations
-                .visibility_constraints
-                .push(vis_constraints);
-        };
-
-        loop {
-            match (opt_a_decl, opt_b_decl) {
-                (Some(a_decl), Some(b_decl)) => match a_decl.cmp(&b_decl) {
-                    std::cmp::Ordering::Less => {
-                        push(a_decl, &mut a_vis_constraints_iter, self);
-                        opt_a_decl = a_decls_iter.next();
-                    }
-                    std::cmp::Ordering::Greater => {
-                        push(b_decl, &mut b_vis_constraints_iter, self);
-                        opt_b_decl = b_decls_iter.next();
-                    }
-                    std::cmp::Ordering::Equal => {
-                        push(a_decl, &mut b_vis_constraints_iter, self);
-
-                        let a_vis_constraint = a_vis_constraints_iter
-                            .next()
-                            .expect("declarations and visibility_constraints length mismatch");
-                        let current = self.declarations.visibility_constraints.last_mut().unwrap();
-                        *current =
-                            visibility_constraints.add_or_constraint(*current, a_vis_constraint);
-
-                        opt_a_decl = a_decls_iter.next();
-                        opt_b_decl = b_decls_iter.next();
-                    }
-                },
-                (Some(a_decl), None) => {
-                    push(a_decl, &mut a_vis_constraints_iter, self);
-                    opt_a_decl = a_decls_iter.next();
-                }
-                (None, Some(b_decl)) => {
-                    push(b_decl, &mut b_vis_constraints_iter, self);
-                    opt_b_decl = b_decls_iter.next();
-                }
-                (None, None) => break,
-            }
-        }
     }
 
     pub(super) fn bindings(&self) -> &SymbolBindings {
@@ -507,44 +332,47 @@ impl SymbolState {
     pub(super) fn declarations(&self) -> &SymbolDeclarations {
         &self.declarations
     }
+
+    /// Could the symbol be unbound?
+    pub(super) fn may_be_unbound(&self) -> bool {
+        self.bindings.may_be_unbound()
+    }
+}
+
+/// The default state of a symbol, if we've seen no definitions of it, is undefined (that is,
+/// both unbound and undeclared).
+impl Default for SymbolState {
+    fn default() -> Self {
+        SymbolState::undefined()
+    }
 }
 
 /// A single binding (as [`ScopedDefinitionId`]) with an iterator of its applicable
-/// narrowing constraints ([`ScopedConstraintId`]) and a corresponding visibility
-/// visibility constraint ([`ScopedVisibilityConstraintId`]).
+/// [`ScopedConstraintId`].
 #[derive(Debug)]
-pub(super) struct BindingIdWithConstraints<'map> {
+pub(super) struct BindingIdWithConstraints<'a> {
     pub(super) definition: ScopedDefinitionId,
-    pub(super) constraint_ids: ConstraintIdIterator<'map>,
-    pub(super) visibility_constraint: ScopedVisibilityConstraintId,
+    pub(super) constraint_ids: ConstraintIdIterator<'a>,
 }
 
 #[derive(Debug)]
-pub(super) struct BindingIdWithConstraintsIterator<'map> {
-    definitions: BindingsIterator<'map>,
-    constraints: ConstraintsIterator<'map>,
-    visibility_constraints: VisibilityConstraintsIterator<'map>,
+pub(super) struct BindingIdWithConstraintsIterator<'a> {
+    definitions: BindingsIterator<'a>,
+    constraints: ConstraintsIterator<'a>,
 }
 
-impl<'map> Iterator for BindingIdWithConstraintsIterator<'map> {
-    type Item = BindingIdWithConstraints<'map>;
+impl<'a> Iterator for BindingIdWithConstraintsIterator<'a> {
+    type Item = BindingIdWithConstraints<'a>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match (
-            self.definitions.next(),
-            self.constraints.next(),
-            self.visibility_constraints.next(),
-        ) {
-            (None, None, None) => None,
-            (Some(def), Some(constraints), Some(visibility_constraint_id)) => {
-                Some(BindingIdWithConstraints {
-                    definition: ScopedDefinitionId::from_u32(def),
-                    constraint_ids: ConstraintIdIterator {
-                        wrapped: constraints.iter(),
-                    },
-                    visibility_constraint: *visibility_constraint_id,
-                })
-            }
+        match (self.definitions.next(), self.constraints.next()) {
+            (None, None) => None,
+            (Some(def), Some(constraints)) => Some(BindingIdWithConstraints {
+                definition: ScopedDefinitionId::from_u32(def),
+                constraint_ids: ConstraintIdIterator {
+                    wrapped: constraints.iter(),
+                },
+            }),
             // SAFETY: see above.
             _ => unreachable!("definitions and constraints length mismatch"),
         }
@@ -568,34 +396,16 @@ impl Iterator for ConstraintIdIterator<'_> {
 
 impl std::iter::FusedIterator for ConstraintIdIterator<'_> {}
 
-/// A single declaration (as [`ScopedDefinitionId`]) with a corresponding visibility
-/// visibility constraint ([`ScopedVisibilityConstraintId`]).
 #[derive(Debug)]
-pub(super) struct DeclarationIdWithConstraint {
-    pub(super) definition: ScopedDefinitionId,
-    pub(super) visibility_constraint: ScopedVisibilityConstraintId,
-}
-
-pub(super) struct DeclarationIdIterator<'map> {
-    pub(crate) declarations: DeclarationsIterator<'map>,
-    pub(crate) visibility_constraints: VisibilityConstraintsIterator<'map>,
+pub(super) struct DeclarationIdIterator<'a> {
+    inner: DeclarationsIterator<'a>,
 }
 
 impl Iterator for DeclarationIdIterator<'_> {
-    type Item = DeclarationIdWithConstraint;
+    type Item = ScopedDefinitionId;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match (self.declarations.next(), self.visibility_constraints.next()) {
-            (None, None) => None,
-            (Some(declaration), Some(&visibility_constraint)) => {
-                Some(DeclarationIdWithConstraint {
-                    definition: ScopedDefinitionId::from_u32(declaration),
-                    visibility_constraint,
-                })
-            }
-            // SAFETY: see above.
-            _ => unreachable!("declarations and visibility_constraints length mismatch"),
-        }
+        self.inner.next().map(ScopedDefinitionId::from_u32)
     }
 }
 
@@ -603,172 +413,176 @@ impl std::iter::FusedIterator for DeclarationIdIterator<'_> {}
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use super::{ScopedConstraintId, ScopedDefinitionId, SymbolState};
 
-    #[track_caller]
-    fn assert_bindings(symbol: &SymbolState, expected: &[&str]) {
+    fn assert_bindings(symbol: &SymbolState, may_be_unbound: bool, expected: &[&str]) {
+        assert_eq!(symbol.may_be_unbound(), may_be_unbound);
         let actual = symbol
             .bindings()
             .iter()
             .map(|def_id_with_constraints| {
-                let def_id = def_id_with_constraints.definition;
-                let def = if def_id == ScopedDefinitionId::UNBOUND {
-                    "unbound".into()
-                } else {
-                    def_id.as_u32().to_string()
-                };
-                let constraints = def_id_with_constraints
-                    .constraint_ids
-                    .map(ScopedConstraintId::as_u32)
-                    .map(|idx| idx.to_string())
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                format!("{def}<{constraints}>")
+                format!(
+                    "{}<{}>",
+                    def_id_with_constraints.definition.as_u32(),
+                    def_id_with_constraints
+                        .constraint_ids
+                        .map(ScopedConstraintId::as_u32)
+                        .map(|idx| idx.to_string())
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
             })
             .collect::<Vec<_>>();
         assert_eq!(actual, expected);
     }
 
-    #[track_caller]
-    pub(crate) fn assert_declarations(symbol: &SymbolState, expected: &[&str]) {
+    pub(crate) fn assert_declarations(
+        symbol: &SymbolState,
+        may_be_undeclared: bool,
+        expected: &[u32],
+    ) {
+        assert_eq!(symbol.declarations.may_be_undeclared(), may_be_undeclared);
         let actual = symbol
             .declarations()
             .iter()
-            .map(
-                |DeclarationIdWithConstraint {
-                     definition,
-                     visibility_constraint: _,
-                 }| {
-                    if definition == ScopedDefinitionId::UNBOUND {
-                        "undeclared".into()
-                    } else {
-                        definition.as_u32().to_string()
-                    }
-                },
-            )
+            .map(ScopedDefinitionId::as_u32)
             .collect::<Vec<_>>();
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn unbound() {
-        let sym = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        let sym = SymbolState::undefined();
 
-        assert_bindings(&sym, &["unbound<>"]);
+        assert_bindings(&sym, true, &[]);
     }
 
     #[test]
     fn with() {
-        let mut sym = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym.record_binding(ScopedDefinitionId::from_u32(1));
+        let mut sym = SymbolState::undefined();
+        sym.record_binding(ScopedDefinitionId::from_u32(0));
 
-        assert_bindings(&sym, &["1<>"]);
+        assert_bindings(&sym, false, &["0<>"]);
+    }
+
+    #[test]
+    fn set_may_be_unbound() {
+        let mut sym = SymbolState::undefined();
+        sym.record_binding(ScopedDefinitionId::from_u32(0));
+        sym.set_may_be_unbound();
+
+        assert_bindings(&sym, true, &["0<>"]);
     }
 
     #[test]
     fn record_constraint() {
-        let mut sym = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym.record_binding(ScopedDefinitionId::from_u32(1));
+        let mut sym = SymbolState::undefined();
+        sym.record_binding(ScopedDefinitionId::from_u32(0));
         sym.record_constraint(ScopedConstraintId::from_u32(0));
 
-        assert_bindings(&sym, &["1<0>"]);
+        assert_bindings(&sym, false, &["0<0>"]);
     }
 
     #[test]
     fn merge() {
-        let mut visibility_constraints = VisibilityConstraints::default();
-
         // merging the same definition with the same constraint keeps the constraint
-        let mut sym1a = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym1a.record_binding(ScopedDefinitionId::from_u32(1));
-        sym1a.record_constraint(ScopedConstraintId::from_u32(0));
+        let mut sym0a = SymbolState::undefined();
+        sym0a.record_binding(ScopedDefinitionId::from_u32(0));
+        sym0a.record_constraint(ScopedConstraintId::from_u32(0));
 
-        let mut sym1b = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym1b.record_binding(ScopedDefinitionId::from_u32(1));
-        sym1b.record_constraint(ScopedConstraintId::from_u32(0));
+        let mut sym0b = SymbolState::undefined();
+        sym0b.record_binding(ScopedDefinitionId::from_u32(0));
+        sym0b.record_constraint(ScopedConstraintId::from_u32(0));
 
-        sym1a.merge(sym1b, &mut visibility_constraints);
-        let mut sym1 = sym1a;
-        assert_bindings(&sym1, &["1<0>"]);
+        sym0a.merge(sym0b);
+        let mut sym0 = sym0a;
+        assert_bindings(&sym0, false, &["0<0>"]);
 
         // merging the same definition with differing constraints drops all constraints
-        let mut sym2a = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym2a.record_binding(ScopedDefinitionId::from_u32(2));
-        sym2a.record_constraint(ScopedConstraintId::from_u32(1));
+        let mut sym1a = SymbolState::undefined();
+        sym1a.record_binding(ScopedDefinitionId::from_u32(1));
+        sym1a.record_constraint(ScopedConstraintId::from_u32(1));
 
-        let mut sym1b = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym1b.record_binding(ScopedDefinitionId::from_u32(2));
+        let mut sym1b = SymbolState::undefined();
+        sym1b.record_binding(ScopedDefinitionId::from_u32(1));
         sym1b.record_constraint(ScopedConstraintId::from_u32(2));
 
-        sym2a.merge(sym1b, &mut visibility_constraints);
-        let sym2 = sym2a;
-        assert_bindings(&sym2, &["2<>"]);
+        sym1a.merge(sym1b);
+        let sym1 = sym1a;
+        assert_bindings(&sym1, false, &["1<>"]);
 
         // merging a constrained definition with unbound keeps both
-        let mut sym3a = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym3a.record_binding(ScopedDefinitionId::from_u32(3));
-        sym3a.record_constraint(ScopedConstraintId::from_u32(3));
+        let mut sym2a = SymbolState::undefined();
+        sym2a.record_binding(ScopedDefinitionId::from_u32(2));
+        sym2a.record_constraint(ScopedConstraintId::from_u32(3));
 
-        let sym2b = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        let sym2b = SymbolState::undefined();
 
-        sym3a.merge(sym2b, &mut visibility_constraints);
-        let sym3 = sym3a;
-        assert_bindings(&sym3, &["unbound<>", "3<3>"]);
+        sym2a.merge(sym2b);
+        let sym2 = sym2a;
+        assert_bindings(&sym2, true, &["2<3>"]);
 
         // merging different definitions keeps them each with their existing constraints
-        sym1.merge(sym3, &mut visibility_constraints);
-        let sym = sym1;
-        assert_bindings(&sym, &["unbound<>", "1<0>", "3<3>"]);
+        sym0.merge(sym2);
+        let sym = sym0;
+        assert_bindings(&sym, true, &["0<0>", "2<3>"]);
     }
 
     #[test]
     fn no_declaration() {
-        let sym = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        let sym = SymbolState::undefined();
 
-        assert_declarations(&sym, &["undeclared"]);
+        assert_declarations(&sym, true, &[]);
     }
 
     #[test]
     fn record_declaration() {
-        let mut sym = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        let mut sym = SymbolState::undefined();
         sym.record_declaration(ScopedDefinitionId::from_u32(1));
 
-        assert_declarations(&sym, &["1"]);
+        assert_declarations(&sym, false, &[1]);
     }
 
     #[test]
     fn record_declaration_override() {
-        let mut sym = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        let mut sym = SymbolState::undefined();
         sym.record_declaration(ScopedDefinitionId::from_u32(1));
         sym.record_declaration(ScopedDefinitionId::from_u32(2));
 
-        assert_declarations(&sym, &["2"]);
+        assert_declarations(&sym, false, &[2]);
     }
 
     #[test]
     fn record_declaration_merge() {
-        let mut visibility_constraints = VisibilityConstraints::default();
-        let mut sym = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        let mut sym = SymbolState::undefined();
         sym.record_declaration(ScopedDefinitionId::from_u32(1));
 
-        let mut sym2 = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        let mut sym2 = SymbolState::undefined();
         sym2.record_declaration(ScopedDefinitionId::from_u32(2));
 
-        sym.merge(sym2, &mut visibility_constraints);
+        sym.merge(sym2);
 
-        assert_declarations(&sym, &["1", "2"]);
+        assert_declarations(&sym, false, &[1, 2]);
     }
 
     #[test]
     fn record_declaration_merge_partial_undeclared() {
-        let mut visibility_constraints = VisibilityConstraints::default();
-        let mut sym = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        let mut sym = SymbolState::undefined();
         sym.record_declaration(ScopedDefinitionId::from_u32(1));
 
-        let sym2 = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        let sym2 = SymbolState::undefined();
 
-        sym.merge(sym2, &mut visibility_constraints);
+        sym.merge(sym2);
 
-        assert_declarations(&sym, &["undeclared", "1"]);
+        assert_declarations(&sym, true, &[1]);
+    }
+
+    #[test]
+    fn set_may_be_undeclared() {
+        let mut sym = SymbolState::undefined();
+        sym.record_declaration(ScopedDefinitionId::from_u32(0));
+        sym.set_may_be_undeclared();
+
+        assert_declarations(&sym, true, &[0]);
     }
 }

crates/red_knot_python_semantic/src/stdlib.rs

@@ -1,19 +1,55 @@
-use crate::module_resolver::{resolve_module, KnownModule};
+use crate::module_name::ModuleName;
+use crate::module_resolver::resolve_module;
 use crate::semantic_index::global_scope;
 use crate::semantic_index::symbol::ScopeId;
 use crate::symbol::Symbol;
 use crate::types::global_symbol;
 use crate::Db;
 
-/// Lookup the type of `symbol` in a given known module
+/// Enumeration of various core stdlib modules, for which we have dedicated Salsa queries.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum CoreStdlibModule {
+    Builtins,
+    Types,
+    Typeshed,
+    TypingExtensions,
+    Typing,
+    Sys,
+    #[allow(dead_code)]
+    Abc, // currently only used in tests
+    Collections,
+}
+
+impl CoreStdlibModule {
+    pub(crate) const fn as_str(self) -> &'static str {
+        match self {
+            Self::Builtins => "builtins",
+            Self::Types => "types",
+            Self::Typing => "typing",
+            Self::Typeshed => "_typeshed",
+            Self::TypingExtensions => "typing_extensions",
+            Self::Sys => "sys",
+            Self::Abc => "abc",
+            Self::Collections => "collections",
+        }
+    }
+
+    pub(crate) fn name(self) -> ModuleName {
+        let self_as_str = self.as_str();
+        ModuleName::new_static(self_as_str)
+            .unwrap_or_else(|| panic!("{self_as_str} should be a valid module name!"))
+    }
+}
+
+/// Lookup the type of `symbol` in a given core module
 ///
-/// Returns `Symbol::Unbound` if the given known module cannot be resolved for some reason
-pub(crate) fn known_module_symbol<'db>(
+/// Returns `Symbol::Unbound` if the given core module cannot be resolved for some reason
+pub(crate) fn core_module_symbol<'db>(
     db: &'db dyn Db,
-    known_module: KnownModule,
+    core_module: CoreStdlibModule,
     symbol: &str,
 ) -> Symbol<'db> {
-    resolve_module(db, &known_module.name())
+    resolve_module(db, &core_module.name())
         .map(|module| global_symbol(db, module.file(), symbol))
         .unwrap_or(Symbol::Unbound)
 }
@@ -23,7 +59,7 @@ pub(crate) fn known_module_symbol<'db>(
 /// Returns `Symbol::Unbound` if the `builtins` module isn't available for some reason.
 #[inline]
 pub(crate) fn builtins_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
-    known_module_symbol(db, KnownModule::Builtins, symbol)
+    core_module_symbol(db, CoreStdlibModule::Builtins, symbol)
 }
 
 /// Lookup the type of `symbol` in the `typing` module namespace.
@@ -32,7 +68,7 @@ pub(crate) fn builtins_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db>
 #[inline]
 #[cfg(test)]
 pub(crate) fn typing_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
-    known_module_symbol(db, KnownModule::Typing, symbol)
+    core_module_symbol(db, CoreStdlibModule::Typing, symbol)
 }
 
 /// Lookup the type of `symbol` in the `typing_extensions` module namespace.
@@ -40,13 +76,13 @@ pub(crate) fn typing_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
 /// Returns `Symbol::Unbound` if the `typing_extensions` module isn't available for some reason.
 #[inline]
 pub(crate) fn typing_extensions_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
-    known_module_symbol(db, KnownModule::TypingExtensions, symbol)
+    core_module_symbol(db, CoreStdlibModule::TypingExtensions, symbol)
 }
 
 /// Get the scope of a core stdlib module.
 ///
 /// Can return `None` if a custom typeshed is used that is missing the core module in question.
-fn core_module_scope(db: &dyn Db, core_module: KnownModule) -> Option<ScopeId<'_>> {
+fn core_module_scope(db: &dyn Db, core_module: CoreStdlibModule) -> Option<ScopeId<'_>> {
     resolve_module(db, &core_module.name()).map(|module| global_scope(db, module.file()))
 }
 
@@ -54,5 +90,5 @@ fn core_module_scope(db: &dyn Db, core_module: KnownModule) -> Option<ScopeId<'_
 ///
 /// Can return `None` if a custom typeshed is used that is missing `builtins.pyi`.
 pub(crate) fn builtins_module_scope(db: &dyn Db) -> Option<ScopeId<'_>> {
-    core_module_scope(db, KnownModule::Builtins)
+    core_module_scope(db, CoreStdlibModule::Builtins)
 }

crates/red_knot_python_semantic/src/symbol.rs

@@ -35,7 +35,7 @@ impl Boundness {
 /// possibly_unbound:  Symbol::Type(Type::IntLiteral(2), Boundness::PossiblyUnbound),
 /// non_existent:      Symbol::Unbound,
 /// ```
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub(crate) enum Symbol<'db> {
     Type(Type<'db>, Boundness),
     Unbound,

crates/red_knot_python_semantic/src/types/call.rs

@@ -1,32 +1,16 @@
-use super::context::InferContext;
-use super::diagnostic::CALL_NON_CALLABLE;
-use super::{Severity, Signature, Type, TypeArrayDisplay, UnionBuilder};
-use crate::types::diagnostic::STATIC_ASSERT_ERROR;
+use super::diagnostic::{TypeCheckDiagnosticsBuilder, CALL_NON_CALLABLE};
+use super::{Severity, Type, TypeArrayDisplay, UnionBuilder};
 use crate::Db;
 use ruff_db::diagnostic::DiagnosticId;
 use ruff_python_ast as ast;
 
-mod arguments;
-mod bind;
-
-pub(super) use arguments::{Argument, CallArguments};
-pub(super) use bind::{bind_call, CallBinding};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(super) enum StaticAssertionErrorKind<'db> {
-    ArgumentIsFalse,
-    ArgumentIsFalsy(Type<'db>),
-    ArgumentTruthinessIsAmbiguous(Type<'db>),
-    CustomError(&'db str),
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(super) enum CallOutcome<'db> {
     Callable {
-        binding: CallBinding<'db>,
+        return_ty: Type<'db>,
     },
     RevealType {
-        binding: CallBinding<'db>,
+        return_ty: Type<'db>,
         revealed_ty: Type<'db>,
     },
     NotCallable {
@@ -40,16 +24,12 @@ pub(super) enum CallOutcome<'db> {
         called_ty: Type<'db>,
         call_outcome: Box<CallOutcome<'db>>,
     },
-    StaticAssertionError {
-        binding: CallBinding<'db>,
-        error_kind: StaticAssertionErrorKind<'db>,
-    },
 }
 
 impl<'db> CallOutcome<'db> {
     /// Create a new `CallOutcome::Callable` with given return type.
-    pub(super) fn callable(binding: CallBinding<'db>) -> CallOutcome<'db> {
-        CallOutcome::Callable { binding }
+    pub(super) fn callable(return_ty: Type<'db>) -> CallOutcome<'db> {
+        CallOutcome::Callable { return_ty }
     }
 
     /// Create a new `CallOutcome::NotCallable` with given not-callable type.
@@ -58,9 +38,9 @@ impl<'db> CallOutcome<'db> {
     }
 
     /// Create a new `CallOutcome::RevealType` with given revealed and return types.
-    pub(super) fn revealed(binding: CallBinding<'db>, revealed_ty: Type<'db>) -> CallOutcome<'db> {
+    pub(super) fn revealed(return_ty: Type<'db>, revealed_ty: Type<'db>) -> CallOutcome<'db> {
         CallOutcome::RevealType {
-            binding,
+            return_ty,
             revealed_ty,
         }
     }
@@ -79,11 +59,11 @@ impl<'db> CallOutcome<'db> {
     /// Get the return type of the call, or `None` if not callable.
     pub(super) fn return_ty(&self, db: &'db dyn Db) -> Option<Type<'db>> {
         match self {
-            Self::Callable { binding } => Some(binding.return_ty()),
+            Self::Callable { return_ty } => Some(*return_ty),
             Self::RevealType {
-                binding,
+                return_ty,
                 revealed_ty: _,
-            } => Some(binding.return_ty()),
+            } => Some(*return_ty),
             Self::NotCallable { not_callable_ty: _ } => None,
             Self::Union {
                 outcomes,
@@ -102,28 +82,28 @@ impl<'db> CallOutcome<'db> {
                 })
                 .map(UnionBuilder::build),
             Self::PossiblyUnboundDunderCall { call_outcome, .. } => call_outcome.return_ty(db),
-            Self::StaticAssertionError { .. } => Some(Type::none(db)),
         }
     }
 
     /// Get the return type of the call, emitting default diagnostics if needed.
-    pub(super) fn unwrap_with_diagnostic(
+    pub(super) fn unwrap_with_diagnostic<'a>(
         &self,
-        context: &InferContext<'db>,
+        db: &'db dyn Db,
         node: ast::AnyNodeRef,
+        diagnostics: &'a mut TypeCheckDiagnosticsBuilder<'db>,
     ) -> Type<'db> {
-        match self.return_ty_result(context, node) {
+        match self.return_ty_result(db, node, diagnostics) {
             Ok(return_ty) => return_ty,
             Err(NotCallableError::Type {
                 not_callable_ty,
                 return_ty,
             }) => {
-                context.report_lint(
+                diagnostics.add_lint(
                     &CALL_NON_CALLABLE,
                     node,
                     format_args!(
                         "Object of type `{}` is not callable",
-                        not_callable_ty.display(context.db())
+                        not_callable_ty.display(db)
                     ),
                 );
                 return_ty
@@ -133,13 +113,13 @@ impl<'db> CallOutcome<'db> {
                 called_ty,
                 return_ty,
             }) => {
-                context.report_lint(
+                diagnostics.add_lint(
                     &CALL_NON_CALLABLE,
                     node,
                     format_args!(
                         "Object of type `{}` is not callable (due to union element `{}`)",
-                        called_ty.display(context.db()),
-                        not_callable_ty.display(context.db()),
+                        called_ty.display(db),
+                        not_callable_ty.display(db),
                     ),
                 );
                 return_ty
@@ -149,13 +129,13 @@ impl<'db> CallOutcome<'db> {
                 called_ty,
                 return_ty,
             }) => {
-                context.report_lint(
+                diagnostics.add_lint(
                     &CALL_NON_CALLABLE,
                     node,
                     format_args!(
                         "Object of type `{}` is not callable (due to union elements {})",
-                        called_ty.display(context.db()),
-                        not_callable_tys.display(context.db()),
+                        called_ty.display(db),
+                        not_callable_tys.display(db),
                     ),
                 );
                 return_ty
@@ -164,12 +144,12 @@ impl<'db> CallOutcome<'db> {
                 callable_ty: called_ty,
                 return_ty,
             }) => {
-                context.report_lint(
+                diagnostics.add_lint(
                     &CALL_NON_CALLABLE,
                     node,
                     format_args!(
                         "Object of type `{}` is not callable (possibly unbound `__call__` method)",
-                        called_ty.display(context.db())
+                        called_ty.display(db)
                     ),
                 );
                 return_ty
@@ -178,31 +158,25 @@ impl<'db> CallOutcome<'db> {
     }
 
     /// Get the return type of the call as a result.
-    pub(super) fn return_ty_result(
+    pub(super) fn return_ty_result<'a>(
         &self,
-        context: &InferContext<'db>,
+        db: &'db dyn Db,
         node: ast::AnyNodeRef,
+        diagnostics: &'a mut TypeCheckDiagnosticsBuilder<'db>,
     ) -> Result<Type<'db>, NotCallableError<'db>> {
-        // TODO should this method emit diagnostics directly, or just return results that allow the
-        // caller to decide about emitting diagnostics? Currently it emits binding diagnostics, but
-        // only non-callable diagnostics in the union case, which is inconsistent.
         match self {
-            Self::Callable { binding } => {
-                binding.report_diagnostics(context, node);
-                Ok(binding.return_ty())
-            }
+            Self::Callable { return_ty } => Ok(*return_ty),
             Self::RevealType {
-                binding,
+                return_ty,
                 revealed_ty,
             } => {
-                binding.report_diagnostics(context, node);
-                context.report_diagnostic(
+                diagnostics.add(
                     node,
                     DiagnosticId::RevealedType,
                     Severity::Info,
-                    format_args!("Revealed type is `{}`", revealed_ty.display(context.db())),
+                    format_args!("Revealed type is `{}`", revealed_ty.display(db)),
                 );
-                Ok(binding.return_ty())
+                Ok(*return_ty)
             }
             Self::NotCallable { not_callable_ty } => Err(NotCallableError::Type {
                 not_callable_ty: *not_callable_ty,
@@ -213,16 +187,14 @@ impl<'db> CallOutcome<'db> {
                 call_outcome,
             } => Err(NotCallableError::PossiblyUnboundDunderCall {
                 callable_ty: *called_ty,
-                return_ty: call_outcome
-                    .return_ty(context.db())
-                    .unwrap_or(Type::Unknown),
+                return_ty: call_outcome.return_ty(db).unwrap_or(Type::Unknown),
             }),
             Self::Union {
                 outcomes,
                 called_ty,
             } => {
                 let mut not_callable = vec![];
-                let mut union_builder = UnionBuilder::new(context.db());
+                let mut union_builder = UnionBuilder::new(db);
                 let mut revealed = false;
                 for outcome in outcomes {
                     let return_ty = match outcome {
@@ -231,17 +203,17 @@ impl<'db> CallOutcome<'db> {
                             Type::Unknown
                         }
                         Self::RevealType {
-                            binding,
+                            return_ty,
                             revealed_ty: _,
                         } => {
                             if revealed {
-                                binding.return_ty()
+                                *return_ty
                             } else {
                                 revealed = true;
-                                outcome.unwrap_with_diagnostic(context, node)
+                                outcome.unwrap_with_diagnostic(db, node, diagnostics)
                             }
                         }
-                        _ => outcome.unwrap_with_diagnostic(context, node),
+                        _ => outcome.unwrap_with_diagnostic(db, node, diagnostics),
                     };
                     union_builder = union_builder.add(return_ty);
                 }
@@ -264,51 +236,6 @@ impl<'db> CallOutcome<'db> {
                     }),
                 }
             }
-            CallOutcome::StaticAssertionError {
-                binding,
-                error_kind,
-            } => {
-                binding.report_diagnostics(context, node);
-
-                match error_kind {
-                    StaticAssertionErrorKind::ArgumentIsFalse => {
-                        context.report_lint(
-                            &STATIC_ASSERT_ERROR,
-                            node,
-                            format_args!("Static assertion error: argument evaluates to `False`"),
-                        );
-                    }
-                    StaticAssertionErrorKind::ArgumentIsFalsy(parameter_ty) => {
-                        context.report_lint(
-                            &STATIC_ASSERT_ERROR,
-                            node,
-                            format_args!(
-                                "Static assertion error: argument of type `{parameter_ty}` is statically known to be falsy",
-                                parameter_ty=parameter_ty.display(context.db())
-                            ),
-                        );
-                    }
-                    StaticAssertionErrorKind::ArgumentTruthinessIsAmbiguous(parameter_ty) => {
-                        context.report_lint(
-                            &STATIC_ASSERT_ERROR,
-                            node,
-                            format_args!(
-                                "Static assertion error: argument of type `{parameter_ty}` has an ambiguous static truthiness",
-                                parameter_ty=parameter_ty.display(context.db())
-                            ),
-                        );
-                    }
-                    StaticAssertionErrorKind::CustomError(message) => {
-                        context.report_lint(
-                            &STATIC_ASSERT_ERROR,
-                            node,
-                            format_args!("Static assertion error: {message}"),
-                        );
-                    }
-                }
-
-                Ok(Type::Unknown)
-            }
         }
     }
 }

crates/red_knot_python_semantic/src/types/call/arguments.rs

@@ -1,73 +0,0 @@
-use super::Type;
-
-/// Typed arguments for a single call, in source order.
-#[derive(Clone, Debug, Default)]
-pub(crate) struct CallArguments<'a, 'db>(Vec<Argument<'a, 'db>>);
-
-impl<'a, 'db> CallArguments<'a, 'db> {
-    /// Create a [`CallArguments`] from an iterator over non-variadic positional argument types.
-    pub(crate) fn positional(positional_tys: impl IntoIterator<Item = Type<'db>>) -> Self {
-        positional_tys
-            .into_iter()
-            .map(Argument::Positional)
-            .collect()
-    }
-
-    /// Prepend an extra positional argument.
-    pub(crate) fn with_self(&self, self_ty: Type<'db>) -> Self {
-        let mut arguments = Vec::with_capacity(self.0.len() + 1);
-        arguments.push(Argument::Synthetic(self_ty));
-        arguments.extend_from_slice(&self.0);
-        Self(arguments)
-    }
-
-    pub(crate) fn iter(&self) -> impl Iterator<Item = &Argument<'a, 'db>> {
-        self.0.iter()
-    }
-
-    // TODO this should be eliminated in favor of [`bind_call`]
-    pub(crate) fn first_argument(&self) -> Option<Type<'db>> {
-        self.0.first().map(Argument::ty)
-    }
-}
-
-impl<'db, 'a, 'b> IntoIterator for &'b CallArguments<'a, 'db> {
-    type Item = &'b Argument<'a, 'db>;
-    type IntoIter = std::slice::Iter<'b, Argument<'a, 'db>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.iter()
-    }
-}
-
-impl<'a, 'db> FromIterator<Argument<'a, 'db>> for CallArguments<'a, 'db> {
-    fn from_iter<T: IntoIterator<Item = Argument<'a, 'db>>>(iter: T) -> Self {
-        Self(iter.into_iter().collect())
-    }
-}
-
-#[derive(Clone, Debug)]
-pub(crate) enum Argument<'a, 'db> {
-    /// The synthetic `self` or `cls` argument, which doesn't appear explicitly at the call site.
-    Synthetic(Type<'db>),
-    /// A positional argument.
-    Positional(Type<'db>),
-    /// A starred positional argument (e.g. `*args`).
-    Variadic(Type<'db>),
-    /// A keyword argument (e.g. `a=1`).
-    Keyword { name: &'a str, ty: Type<'db> },
-    /// The double-starred keywords argument (e.g. `**kwargs`).
-    Keywords(Type<'db>),
-}
-
-impl<'db> Argument<'_, 'db> {
-    fn ty(&self) -> Type<'db> {
-        match self {
-            Self::Synthetic(ty) => *ty,
-            Self::Positional(ty) => *ty,
-            Self::Variadic(ty) => *ty,
-            Self::Keyword { name: _, ty } => *ty,
-            Self::Keywords(ty) => *ty,
-        }
-    }
-}

crates/red_knot_python_semantic/src/types/call/bind.rs

@@ -1,411 +0,0 @@
-use super::{Argument, CallArguments, InferContext, Signature, Type};
-use crate::db::Db;
-use crate::types::diagnostic::{
-    INVALID_ARGUMENT_TYPE, MISSING_ARGUMENT, PARAMETER_ALREADY_ASSIGNED,
-    TOO_MANY_POSITIONAL_ARGUMENTS, UNKNOWN_ARGUMENT,
-};
-use crate::types::signatures::Parameter;
-use crate::types::UnionType;
-use ruff_python_ast as ast;
-
-/// Bind a [`CallArguments`] against a callable [`Signature`].
-///
-/// The returned [`CallBinding`] provides the return type of the call, the bound types for all
-/// parameters, and any errors resulting from binding the call.
-pub(crate) fn bind_call<'db>(
-    db: &'db dyn Db,
-    arguments: &CallArguments<'_, 'db>,
-    signature: &Signature<'db>,
-    callable_ty: Option<Type<'db>>,
-) -> CallBinding<'db> {
-    let parameters = signature.parameters();
-    // The type assigned to each parameter at this call site.
-    let mut parameter_tys = vec![None; parameters.len()];
-    let mut errors = vec![];
-    let mut next_positional = 0;
-    let mut first_excess_positional = None;
-    let mut num_synthetic_args = 0;
-    let get_argument_index = |argument_index: usize, num_synthetic_args: usize| {
-        if argument_index >= num_synthetic_args {
-            // Adjust the argument index to skip synthetic args, which don't appear at the call
-            // site and thus won't be in the Call node arguments list.
-            Some(argument_index - num_synthetic_args)
-        } else {
-            // we are erroring on a synthetic argument, we'll just emit the diagnostic on the
-            // entire Call node, since there's no argument node for this argument at the call site
-            None
-        }
-    };
-    for (argument_index, argument) in arguments.iter().enumerate() {
-        let (index, parameter, argument_ty, positional) = match argument {
-            Argument::Positional(ty) | Argument::Synthetic(ty) => {
-                if matches!(argument, Argument::Synthetic(_)) {
-                    num_synthetic_args += 1;
-                }
-                let Some((index, parameter)) = parameters
-                    .get_positional(next_positional)
-                    .map(|param| (next_positional, param))
-                    .or_else(|| parameters.variadic())
-                else {
-                    first_excess_positional.get_or_insert(argument_index);
-                    next_positional += 1;
-                    continue;
-                };
-                next_positional += 1;
-                (index, parameter, ty, !parameter.is_variadic())
-            }
-            Argument::Keyword { name, ty } => {
-                let Some((index, parameter)) = parameters
-                    .keyword_by_name(name)
-                    .or_else(|| parameters.keyword_variadic())
-                else {
-                    errors.push(CallBindingError::UnknownArgument {
-                        argument_name: ast::name::Name::new(name),
-                        argument_index: get_argument_index(argument_index, num_synthetic_args),
-                    });
-                    continue;
-                };
-                (index, parameter, ty, false)
-            }
-
-            Argument::Variadic(_) | Argument::Keywords(_) => {
-                // TODO
-                continue;
-            }
-        };
-        if let Some(expected_ty) = parameter.annotated_ty() {
-            if !argument_ty.is_assignable_to(db, expected_ty) {
-                errors.push(CallBindingError::InvalidArgumentType {
-                    parameter: ParameterContext::new(parameter, index, positional),
-                    argument_index: get_argument_index(argument_index, num_synthetic_args),
-                    expected_ty,
-                    provided_ty: *argument_ty,
-                });
-            }
-        }
-        if let Some(existing) = parameter_tys[index].replace(*argument_ty) {
-            if parameter.is_variadic() {
-                let union = UnionType::from_elements(db, [existing, *argument_ty]);
-                parameter_tys[index].replace(union);
-            } else {
-                errors.push(CallBindingError::ParameterAlreadyAssigned {
-                    argument_index: get_argument_index(argument_index, num_synthetic_args),
-                    parameter: ParameterContext::new(parameter, index, positional),
-                });
-            }
-        }
-    }
-    if let Some(first_excess_argument_index) = first_excess_positional {
-        errors.push(CallBindingError::TooManyPositionalArguments {
-            first_excess_argument_index: get_argument_index(
-                first_excess_argument_index,
-                num_synthetic_args,
-            ),
-            expected_positional_count: parameters.positional().count(),
-            provided_positional_count: next_positional,
-        });
-    }
-    let mut missing = vec![];
-    for (index, bound_ty) in parameter_tys.iter().enumerate() {
-        if bound_ty.is_none() {
-            let param = &parameters[index];
-            if param.is_variadic() || param.is_keyword_variadic() || param.default_ty().is_some() {
-                // variadic/keywords and defaulted arguments are not required
-                continue;
-            }
-            missing.push(ParameterContext::new(param, index, false));
-        }
-    }
-
-    if !missing.is_empty() {
-        errors.push(CallBindingError::MissingArguments {
-            parameters: ParameterContexts(missing),
-        });
-    }
-
-    CallBinding {
-        callable_ty,
-        return_ty: signature.return_ty.unwrap_or(Type::Unknown),
-        parameter_tys: parameter_tys
-            .into_iter()
-            .map(|opt_ty| opt_ty.unwrap_or(Type::Unknown))
-            .collect(),
-        errors,
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct CallBinding<'db> {
-    /// Type of the callable object (function, class...)
-    callable_ty: Option<Type<'db>>,
-
-    /// Return type of the call.
-    return_ty: Type<'db>,
-
-    /// Bound types for parameters, in parameter source order.
-    parameter_tys: Box<[Type<'db>]>,
-
-    /// Call binding errors, if any.
-    errors: Vec<CallBindingError<'db>>,
-}
-
-impl<'db> CallBinding<'db> {
-    // TODO remove this constructor and construct always from `bind_call`
-    pub(crate) fn from_return_ty(return_ty: Type<'db>) -> Self {
-        Self {
-            callable_ty: None,
-            return_ty,
-            parameter_tys: Box::default(),
-            errors: vec![],
-        }
-    }
-
-    pub(crate) fn set_return_ty(&mut self, return_ty: Type<'db>) {
-        self.return_ty = return_ty;
-    }
-
-    pub(crate) fn return_ty(&self) -> Type<'db> {
-        self.return_ty
-    }
-
-    pub(crate) fn parameter_tys(&self) -> &[Type<'db>] {
-        &self.parameter_tys
-    }
-
-    pub(crate) fn one_parameter_ty(&self) -> Option<Type<'db>> {
-        match self.parameter_tys() {
-            [ty] => Some(*ty),
-            _ => None,
-        }
-    }
-
-    pub(crate) fn two_parameter_tys(&self) -> Option<(Type<'db>, Type<'db>)> {
-        match self.parameter_tys() {
-            [first, second] => Some((*first, *second)),
-            _ => None,
-        }
-    }
-
-    fn callable_name(&self, db: &'db dyn Db) -> Option<&str> {
-        match self.callable_ty {
-            Some(Type::FunctionLiteral(function)) => Some(function.name(db)),
-            Some(Type::ClassLiteral(class_type)) => Some(class_type.class.name(db)),
-            _ => None,
-        }
-    }
-
-    pub(super) fn report_diagnostics(&self, context: &InferContext<'db>, node: ast::AnyNodeRef) {
-        let callable_name = self.callable_name(context.db());
-        for error in &self.errors {
-            error.report_diagnostic(context, node, callable_name);
-        }
-    }
-}
-
-/// Information needed to emit a diagnostic regarding a parameter.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct ParameterContext {
-    name: Option<ast::name::Name>,
-    index: usize,
-
-    /// Was the argument for this parameter passed positionally, and matched to a non-variadic
-    /// positional parameter? (If so, we will provide the index in the diagnostic, not just the
-    /// name.)
-    positional: bool,
-}
-
-impl ParameterContext {
-    fn new(parameter: &Parameter, index: usize, positional: bool) -> Self {
-        Self {
-            name: parameter.display_name(),
-            index,
-            positional,
-        }
-    }
-}
-
-impl std::fmt::Display for ParameterContext {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if let Some(name) = &self.name {
-            if self.positional {
-                write!(f, "{} (`{name}`)", self.index + 1)
-            } else {
-                write!(f, "`{name}`")
-            }
-        } else {
-            write!(f, "{}", self.index + 1)
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct ParameterContexts(Vec<ParameterContext>);
-
-impl std::fmt::Display for ParameterContexts {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut iter = self.0.iter();
-        if let Some(first) = iter.next() {
-            write!(f, "{first}")?;
-            for param in iter {
-                f.write_str(", ")?;
-                write!(f, "{param}")?;
-            }
-        }
-        Ok(())
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum CallBindingError<'db> {
-    /// The type of an argument is not assignable to the annotated type of its corresponding
-    /// parameter.
-    InvalidArgumentType {
-        parameter: ParameterContext,
-        argument_index: Option<usize>,
-        expected_ty: Type<'db>,
-        provided_ty: Type<'db>,
-    },
-    /// One or more required parameters (that is, with no default) is not supplied by any argument.
-    MissingArguments { parameters: ParameterContexts },
-    /// A call argument can't be matched to any parameter.
-    UnknownArgument {
-        argument_name: ast::name::Name,
-        argument_index: Option<usize>,
-    },
-    /// More positional arguments are provided in the call than can be handled by the signature.
-    TooManyPositionalArguments {
-        first_excess_argument_index: Option<usize>,
-        expected_positional_count: usize,
-        provided_positional_count: usize,
-    },
-    /// Multiple arguments were provided for a single parameter.
-    ParameterAlreadyAssigned {
-        argument_index: Option<usize>,
-        parameter: ParameterContext,
-    },
-}
-
-impl<'db> CallBindingError<'db> {
-    pub(super) fn report_diagnostic(
-        &self,
-        context: &InferContext<'db>,
-        node: ast::AnyNodeRef,
-        callable_name: Option<&str>,
-    ) {
-        match self {
-            Self::InvalidArgumentType {
-                parameter,
-                argument_index,
-                expected_ty,
-                provided_ty,
-            } => {
-                let provided_ty_display = provided_ty.display(context.db());
-                let expected_ty_display = expected_ty.display(context.db());
-                context.report_lint(
-                    &INVALID_ARGUMENT_TYPE,
-                    Self::get_node(node, *argument_index),
-                    format_args!(
-                        "Object of type `{provided_ty_display}` cannot be assigned to \
-                        parameter {parameter}{}; expected type `{expected_ty_display}`",
-                        if let Some(callable_name) = callable_name {
-                            format!(" of function `{callable_name}`")
-                        } else {
-                            String::new()
-                        }
-                    ),
-                );
-            }
-
-            Self::TooManyPositionalArguments {
-                first_excess_argument_index,
-                expected_positional_count,
-                provided_positional_count,
-            } => {
-                context.report_lint(
-                    &TOO_MANY_POSITIONAL_ARGUMENTS,
-                    Self::get_node(node, *first_excess_argument_index),
-                    format_args!(
-                        "Too many positional arguments{}: expected \
-                        {expected_positional_count}, got {provided_positional_count}",
-                        if let Some(callable_name) = callable_name {
-                            format!(" to function `{callable_name}`")
-                        } else {
-                            String::new()
-                        }
-                    ),
-                );
-            }
-
-            Self::MissingArguments { parameters } => {
-                let s = if parameters.0.len() == 1 { "" } else { "s" };
-                context.report_lint(
-                    &MISSING_ARGUMENT,
-                    node,
-                    format_args!(
-                        "No argument{s} provided for required parameter{s} {parameters}{}",
-                        if let Some(callable_name) = callable_name {
-                            format!(" of function `{callable_name}`")
-                        } else {
-                            String::new()
-                        }
-                    ),
-                );
-            }
-
-            Self::UnknownArgument {
-                argument_name,
-                argument_index,
-            } => {
-                context.report_lint(
-                    &UNKNOWN_ARGUMENT,
-                    Self::get_node(node, *argument_index),
-                    format_args!(
-                        "Argument `{argument_name}` does not match any known parameter{}",
-                        if let Some(callable_name) = callable_name {
-                            format!(" of function `{callable_name}`")
-                        } else {
-                            String::new()
-                        }
-                    ),
-                );
-            }
-
-            Self::ParameterAlreadyAssigned {
-                argument_index,
-                parameter,
-            } => {
-                context.report_lint(
-                    &PARAMETER_ALREADY_ASSIGNED,
-                    Self::get_node(node, *argument_index),
-                    format_args!(
-                        "Multiple values provided for parameter {parameter}{}",
-                        if let Some(callable_name) = callable_name {
-                            format!(" of function `{callable_name}`")
-                        } else {
-                            String::new()
-                        }
-                    ),
-                );
-            }
-        }
-    }
-
-    fn get_node(node: ast::AnyNodeRef, argument_index: Option<usize>) -> ast::AnyNodeRef {
-        // If we have a Call node and an argument index, report the diagnostic on the correct
-        // argument node; otherwise, report it on the entire provided node.
-        match (node, argument_index) {
-            (ast::AnyNodeRef::ExprCall(call_node), Some(argument_index)) => {
-                match call_node
-                    .arguments
-                    .arguments_source_order()
-                    .nth(argument_index)
-                    .expect("argument index should not be out of range")
-                {
-                    ast::ArgOrKeyword::Arg(expr) => expr.into(),
-                    ast::ArgOrKeyword::Keyword(keyword) => keyword.into(),
-                }
-            }
-            _ => node,
-        }
-    }
-}

crates/red_knot_python_semantic/src/types/class_base.rs

@@ -18,13 +18,6 @@ pub enum ClassBase<'db> {
 }
 
 impl<'db> ClassBase<'db> {
-    pub const fn is_dynamic(self) -> bool {
-        match self {
-            ClassBase::Any | ClassBase::Unknown | ClassBase::Todo(_) => true,
-            ClassBase::Class(_) => false,
-        }
-    }
-
     pub fn display(self, db: &'db dyn Db) -> impl std::fmt::Display + 'db {
         struct Display<'db> {
             base: ClassBase<'db>,
@@ -100,11 +93,7 @@ impl<'db> ClassBase<'db> {
                 | KnownInstanceType::Required
                 | KnownInstanceType::TypeAlias
                 | KnownInstanceType::ReadOnly
-                | KnownInstanceType::Optional
-                | KnownInstanceType::Not
-                | KnownInstanceType::Intersection
-                | KnownInstanceType::TypeOf => None,
-                KnownInstanceType::Unknown => Some(Self::Unknown),
+                | KnownInstanceType::Optional => None,
                 KnownInstanceType::Any => Some(Self::Any),
                 // TODO: Classes inheriting from `typing.Type` et al. also have `Generic` in their MRO
                 KnownInstanceType::Dict => {

crates/red_knot_python_semantic/src/types/context.rs

@@ -1,202 +0,0 @@
-use std::fmt;
-
-use drop_bomb::DebugDropBomb;
-use ruff_db::{
-    diagnostic::{DiagnosticId, Severity},
-    files::File,
-};
-use ruff_python_ast::AnyNodeRef;
-use ruff_text_size::Ranged;
-
-use super::{binding_ty, KnownFunction, TypeCheckDiagnostic, TypeCheckDiagnostics};
-
-use crate::semantic_index::semantic_index;
-use crate::semantic_index::symbol::ScopeId;
-use crate::{
-    lint::{LintId, LintMetadata},
-    suppression::suppressions,
-    Db,
-};
-
-/// Context for inferring the types of a single file.
-///
-/// One context exists for at least for every inferred region but it's
-/// possible that inferring a sub-region, like an unpack assignment, creates
-/// a sub-context.
-///
-/// Tracks the reported diagnostics of the inferred region.
-///
-/// ## Consuming
-/// It's important that the context is explicitly consumed before dropping by calling
-/// [`InferContext::finish`] and the returned diagnostics must be stored
-/// on the current [`TypeInference`](super::infer::TypeInference) result.
-pub(crate) struct InferContext<'db> {
-    db: &'db dyn Db,
-    scope: ScopeId<'db>,
-    file: File,
-    diagnostics: std::cell::RefCell<TypeCheckDiagnostics>,
-    no_type_check: InNoTypeCheck,
-    bomb: DebugDropBomb,
-}
-
-impl<'db> InferContext<'db> {
-    pub(crate) fn new(db: &'db dyn Db, scope: ScopeId<'db>) -> Self {
-        Self {
-            db,
-            scope,
-            file: scope.file(db),
-            diagnostics: std::cell::RefCell::new(TypeCheckDiagnostics::default()),
-            no_type_check: InNoTypeCheck::default(),
-            bomb: DebugDropBomb::new("`InferContext` needs to be explicitly consumed by calling `::finish` to prevent accidental loss of diagnostics."),
-        }
-    }
-
-    /// The file for which the types are inferred.
-    pub(crate) fn file(&self) -> File {
-        self.file
-    }
-
-    pub(crate) fn db(&self) -> &'db dyn Db {
-        self.db
-    }
-
-    pub(crate) fn extend<T>(&mut self, other: &T)
-    where
-        T: WithDiagnostics,
-    {
-        self.diagnostics.get_mut().extend(other.diagnostics());
-    }
-
-    /// Reports a lint located at `node`.
-    pub(super) fn report_lint(
-        &self,
-        lint: &'static LintMetadata,
-        node: AnyNodeRef,
-        message: fmt::Arguments,
-    ) {
-        if !self.db.is_file_open(self.file) {
-            return;
-        }
-
-        // Skip over diagnostics if the rule is disabled.
-        let Some(severity) = self.db.rule_selection().severity(LintId::of(lint)) else {
-            return;
-        };
-
-        if self.is_in_no_type_check() {
-            return;
-        }
-
-        let suppressions = suppressions(self.db, self.file);
-
-        if let Some(suppression) = suppressions.find_suppression(node.range(), LintId::of(lint)) {
-            self.diagnostics.borrow_mut().mark_used(suppression.id());
-            return;
-        }
-
-        self.report_diagnostic(node, DiagnosticId::Lint(lint.name()), severity, message);
-    }
-
-    /// Adds a new diagnostic.
-    ///
-    /// The diagnostic does not get added if the rule isn't enabled for this file.
-    pub(super) fn report_diagnostic(
-        &self,
-        node: AnyNodeRef,
-        id: DiagnosticId,
-        severity: Severity,
-        message: fmt::Arguments,
-    ) {
-        if !self.db.is_file_open(self.file) {
-            return;
-        }
-
-        // TODO: Don't emit the diagnostic if:
-        // * The enclosing node contains any syntax errors
-        // * The rule is disabled for this file. We probably want to introduce a new query that
-        //   returns a rule selector for a given file that respects the package's settings,
-        //   any global pragma comments in the file, and any per-file-ignores.
-
-        self.diagnostics.borrow_mut().push(TypeCheckDiagnostic {
-            file: self.file,
-            id,
-            message: message.to_string(),
-            range: node.range(),
-            severity,
-        });
-    }
-
-    pub(super) fn set_in_no_type_check(&mut self, no_type_check: InNoTypeCheck) {
-        self.no_type_check = no_type_check;
-    }
-
-    fn is_in_no_type_check(&self) -> bool {
-        match self.no_type_check {
-            InNoTypeCheck::Possibly => {
-                // Accessing the semantic index here is fine because
-                // the index belongs to the same file as for which we emit the diagnostic.
-                let index = semantic_index(self.db, self.file);
-
-                let scope_id = self.scope.file_scope_id(self.db);
-
-                // Inspect all ancestor function scopes by walking bottom up and infer the function's type.
-                let mut function_scope_tys = index
-                    .ancestor_scopes(scope_id)
-                    .filter_map(|(_, scope)| scope.node().as_function())
-                    .filter_map(|function| {
-                        binding_ty(self.db, index.definition(function)).into_function_literal()
-                    });
-
-                // Iterate over all functions and test if any is decorated with `@no_type_check`.
-                function_scope_tys.any(|function_ty| {
-                    function_ty
-                        .decorators(self.db)
-                        .iter()
-                        .filter_map(|decorator| decorator.into_function_literal())
-                        .any(|decorator_ty| {
-                            decorator_ty.is_known(self.db, KnownFunction::NoTypeCheck)
-                        })
-                })
-            }
-            InNoTypeCheck::Yes => true,
-        }
-    }
-
-    /// Are we currently inferring types in a stub file?
-    pub(crate) fn in_stub(&self) -> bool {
-        self.file.is_stub(self.db().upcast())
-    }
-
-    #[must_use]
-    pub(crate) fn finish(mut self) -> TypeCheckDiagnostics {
-        self.bomb.defuse();
-        let mut diagnostics = self.diagnostics.into_inner();
-        diagnostics.shrink_to_fit();
-        diagnostics
-    }
-}
-
-impl fmt::Debug for InferContext<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("TyContext")
-            .field("file", &self.file)
-            .field("diagnostics", &self.diagnostics)
-            .field("defused", &self.bomb)
-            .finish()
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
-pub(crate) enum InNoTypeCheck {
-    /// The inference might be in a `no_type_check` block but only if any
-    /// ancestor function is decorated with `@no_type_check`.
-    #[default]
-    Possibly,
-
-    /// The inference is known to be in an `@no_type_check` decorated function.
-    Yes,
-}
-
-pub(crate) trait WithDiagnostics {
-    fn diagnostics(&self) -> &TypeCheckDiagnostics;
-}

crates/red_knot_python_semantic/src/types/diagnostic.rs

@@ -1,18 +1,15 @@
-use super::context::InferContext;
-use crate::declare_lint;
-use crate::lint::{Level, LintRegistryBuilder, LintStatus};
-use crate::suppression::FileSuppressionId;
+use crate::lint::{Level, LintId, LintMetadata, LintRegistryBuilder, LintStatus};
 use crate::types::string_annotation::{
     BYTE_STRING_TYPE_ANNOTATION, ESCAPE_CHARACTER_IN_FORWARD_ANNOTATION, FSTRING_TYPE_ANNOTATION,
     IMPLICIT_CONCATENATED_STRING_TYPE_ANNOTATION, INVALID_SYNTAX_IN_FORWARD_ANNOTATION,
     RAW_STRING_TYPE_ANNOTATION,
 };
 use crate::types::{ClassLiteralType, Type};
+use crate::{declare_lint, Db};
 use ruff_db::diagnostic::{Diagnostic, DiagnosticId, Severity};
 use ruff_db::files::File;
 use ruff_python_ast::{self as ast, AnyNodeRef};
 use ruff_text_size::{Ranged, TextRange};
-use rustc_hash::FxHashSet;
 use std::borrow::Cow;
 use std::fmt::Formatter;
 use std::ops::Deref;
@@ -27,37 +24,27 @@ pub(crate) fn register_lints(registry: &mut LintRegistryBuilder) {
     registry.register_lint(&CYCLIC_CLASS_DEFINITION);
     registry.register_lint(&DIVISION_BY_ZERO);
     registry.register_lint(&DUPLICATE_BASE);
-    registry.register_lint(&INCOMPATIBLE_SLOTS);
     registry.register_lint(&INCONSISTENT_MRO);
     registry.register_lint(&INDEX_OUT_OF_BOUNDS);
-    registry.register_lint(&INVALID_ARGUMENT_TYPE);
     registry.register_lint(&INVALID_ASSIGNMENT);
     registry.register_lint(&INVALID_BASE);
     registry.register_lint(&INVALID_CONTEXT_MANAGER);
     registry.register_lint(&INVALID_DECLARATION);
     registry.register_lint(&INVALID_EXCEPTION_CAUGHT);
-    registry.register_lint(&INVALID_METACLASS);
     registry.register_lint(&INVALID_PARAMETER_DEFAULT);
-    registry.register_lint(&INVALID_RAISE);
     registry.register_lint(&INVALID_TYPE_FORM);
     registry.register_lint(&INVALID_TYPE_VARIABLE_CONSTRAINTS);
-    registry.register_lint(&MISSING_ARGUMENT);
     registry.register_lint(&NON_SUBSCRIPTABLE);
     registry.register_lint(&NOT_ITERABLE);
-    registry.register_lint(&PARAMETER_ALREADY_ASSIGNED);
     registry.register_lint(&POSSIBLY_UNBOUND_ATTRIBUTE);
     registry.register_lint(&POSSIBLY_UNBOUND_IMPORT);
     registry.register_lint(&POSSIBLY_UNRESOLVED_REFERENCE);
-    registry.register_lint(&SUBCLASS_OF_FINAL_CLASS);
-    registry.register_lint(&TOO_MANY_POSITIONAL_ARGUMENTS);
     registry.register_lint(&UNDEFINED_REVEAL);
-    registry.register_lint(&UNKNOWN_ARGUMENT);
     registry.register_lint(&UNRESOLVED_ATTRIBUTE);
     registry.register_lint(&UNRESOLVED_IMPORT);
     registry.register_lint(&UNRESOLVED_REFERENCE);
     registry.register_lint(&UNSUPPORTED_OPERATOR);
     registry.register_lint(&ZERO_STEPSIZE_IN_SLICE);
-    registry.register_lint(&STATIC_ASSERT_ERROR);
 
     // String annotations
     registry.register_lint(&BYTE_STRING_TYPE_ANNOTATION);
@@ -156,64 +143,6 @@ declare_lint! {
     }
 }
 
-declare_lint! {
-    /// ## What it does
-    /// Checks for classes whose bases define incompatible `__slots__`.
-    ///
-    /// ## Why is this bad?
-    /// Inheriting from bases with incompatible `__slots__`s
-    /// will lead to a `TypeError` at runtime.
-    ///
-    /// Classes with no or empty `__slots__` are always compatible:
-    ///
-    /// ```python
-    /// class A: ...
-    /// class B:
-    ///     __slots__ = ()
-    /// class C:
-    ///     __slots__ = ("a", "b")
-    ///
-    /// # fine
-    /// class D(A, B, C): ...
-    /// ```
-    ///
-    /// Multiple inheritance from more than one different class
-    /// defining non-empty `__slots__` is not allowed:
-    ///
-    /// ```python
-    /// class A:
-    ///     __slots__ = ("a", "b")
-    ///
-    /// class B:
-    ///     __slots__ = ("a", "b")  # Even if the values are the same
-    ///
-    /// # TypeError: multiple bases have instance lay-out conflict
-    /// class C(A, B): ...
-    /// ```
-    ///
-    /// ## Known problems
-    /// Dynamic (not tuple or string literal) `__slots__` are not checked.
-    /// Additionally, classes inheriting from built-in classes with implicit layouts
-    /// like `str` or `int` are also not checked.
-    ///
-    /// ```pycon
-    /// >>> hasattr(int, "__slots__")
-    /// False
-    /// >>> hasattr(str, "__slots__")
-    /// False
-    /// >>> class A(int, str): ...
-    /// Traceback (most recent call last):
-    ///   File "<python-input-0>", line 1, in <module>
-    ///     class A(int, str): ...
-    /// TypeError: multiple bases have instance lay-out conflict
-    /// ```
-    pub(crate) static INCOMPATIBLE_SLOTS = {
-        summary: "detects class definitions whose MRO has conflicting `__slots__`",
-        status: LintStatus::preview("1.0.0"),
-        default_level: Level::Error,
-    }
-}
-
 declare_lint! {
     /// TODO #14889
     pub(crate) static INCONSISTENT_MRO = {
@@ -233,27 +162,6 @@ declare_lint! {
     }
 }
 
-declare_lint! {
-    /// ## What it does
-    /// Detects call arguments whose type is not assignable to the corresponding typed parameter.
-    ///
-    /// ## Why is this bad?
-    /// Passing an argument of a type the function (or callable object) does not accept violates
-    /// the expectations of the function author and may cause unexpected runtime errors within the
-    /// body of the function.
-    ///
-    /// ## Examples
-    /// ```python
-    /// def func(x: int): ...
-    /// func("foo")  # error: [invalid-argument-type]
-    /// ```
-    pub(crate) static INVALID_ARGUMENT_TYPE = {
-        summary: "detects call arguments whose type is not assignable to the corresponding typed parameter",
-        status: LintStatus::preview("1.0.0"),
-        default_level: Level::Error,
-    }
-}
-
 declare_lint! {
     /// TODO #14889
     pub(crate) static INVALID_ASSIGNMENT = {
@@ -291,7 +199,6 @@ declare_lint! {
 }
 
 declare_lint! {
-    /// ## What it does
     /// Checks for exception handlers that catch non-exception classes.
     ///
     /// ## Why is this bad?
@@ -326,33 +233,6 @@ declare_lint! {
     }
 }
 
-declare_lint! {
-    /// ## What it does
-    /// Checks for arguments to `metaclass=` that are invalid.
-    ///
-    /// ## Why is this bad?
-    /// Python allows arbitrary expressions to be used as the argument to `metaclass=`.
-    /// These expressions, however, need to be callable and accept the same arguments
-    /// as `type.__new__`.
-    ///
-    /// ## Example
-    ///
-    /// ```python
-    /// def f(): ...
-    ///
-    /// # TypeError: f() takes 0 positional arguments but 3 were given
-    /// class B(metaclass=f): ...
-    /// ```
-    ///
-    /// ## References
-    /// - [Python documentation: Metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)
-    pub(crate) static INVALID_METACLASS = {
-        summary: "detects invalid `metaclass=` arguments",
-        status: LintStatus::preview("1.0.0"),
-        default_level: Level::Error,
-    }
-}
-
 declare_lint! {
     /// ## What it does
     /// Checks for default values that can't be assigned to the parameter's annotated type.
@@ -366,49 +246,6 @@ declare_lint! {
     }
 }
 
-declare_lint! {
-    /// Checks for `raise` statements that raise non-exceptions or use invalid
-    /// causes for their raised exceptions.
-    ///
-    /// ## Why is this bad?
-    /// Only subclasses or instances of `BaseException` can be raised.
-    /// For an exception's cause, the same rules apply, except that `None` is also
-    /// permitted. Violating these rules results in a `TypeError` at runtime.
-    ///
-    /// ## Examples
-    /// ```python
-    /// def f():
-    ///     try:
-    ///         something()
-    ///     except NameError:
-    ///         raise "oops!" from f
-    ///
-    /// def g():
-    ///     raise NotImplemented from 42
-    /// ```
-    ///
-    /// Use instead:
-    /// ```python
-    /// def f():
-    ///     try:
-    ///         something()
-    ///     except NameError as e:
-    ///         raise RuntimeError("oops!") from e
-    ///
-    /// def g():
-    ///     raise NotImplementedError from None
-    /// ```
-    ///
-    /// ## References
-    /// - [Python documentation: The `raise` statement](https://docs.python.org/3/reference/simple_stmts.html#raise)
-    /// - [Python documentation: Built-in Exceptions](https://docs.python.org/3/library/exceptions.html#built-in-exceptions)
-    pub(crate) static INVALID_RAISE = {
-        summary: "detects `raise` statements that raise invalid exceptions or use invalid causes",
-        status: LintStatus::preview("1.0.0"),
-        default_level: Level::Error,
-    }
-}
-
 declare_lint! {
     /// ## What it does
     /// Checks for invalid type expressions.
@@ -431,25 +268,6 @@ declare_lint! {
     }
 }
 
-declare_lint! {
-    /// ## What it does
-    /// Checks for missing required arguments in a call.
-    ///
-    /// ## Why is this bad?
-    /// Failing to provide a required argument will raise a `TypeError` at runtime.
-    ///
-    /// ## Examples
-    /// ```python
-    /// def func(x: int): ...
-    /// func()  # TypeError: func() missing 1 required positional argument: 'x'
-    /// ```
-    pub(crate) static MISSING_ARGUMENT = {
-        summary: "detects missing required arguments in a call",
-        status: LintStatus::preview("1.0.0"),
-        default_level: Level::Error,
-    }
-}
-
 declare_lint! {
     /// ## What it does
     /// Checks for subscripting objects that do not support subscripting.
@@ -488,27 +306,6 @@ declare_lint! {
     }
 }
 
-declare_lint! {
-    /// ## What it does
-    /// Checks for calls which provide more than one argument for a single parameter.
-    ///
-    /// ## Why is this bad?
-    /// Providing multiple values for a single parameter will raise a `TypeError` at runtime.
-    ///
-    /// ## Examples
-    ///
-    /// ```python
-    /// def f(x: int) -> int: ...
-    ///
-    /// f(1, x=2)  # Error raised here
-    /// ```
-    pub(crate) static PARAMETER_ALREADY_ASSIGNED = {
-        summary: "detects multiple arguments for the same parameter",
-        status: LintStatus::preview("1.0.0"),
-        default_level: Level::Error,
-    }
-}
-
 declare_lint! {
     /// ## What it does
     /// Checks for possibly unbound attributes.
@@ -552,50 +349,6 @@ declare_lint! {
     }
 }
 
-declare_lint! {
-    /// ## What it does
-    /// Checks for classes that subclass final classes.
-    ///
-    /// ## Why is this bad?
-    /// Decorating a class with `@final` declares to the type checker that it should not be subclassed.
-    ///
-    /// ## Example
-    ///
-    /// ```python
-    /// from typing import final
-    ///
-    /// @final
-    /// class A: ...
-    /// class B(A): ...  # Error raised here
-    /// ```
-    pub(crate) static SUBCLASS_OF_FINAL_CLASS = {
-        summary: "detects subclasses of final classes",
-        status: LintStatus::preview("1.0.0"),
-        default_level: Level::Error,
-    }
-}
-
-declare_lint! {
-    /// ## What it does
-    /// Checks for calls that pass more positional arguments than the callable can accept.
-    ///
-    /// ## Why is this bad?
-    /// Passing too many positional arguments will raise `TypeError` at runtime.
-    ///
-    /// ## Example
-    ///
-    /// ```python
-    /// def f(): ...
-    ///
-    /// f("foo")  # Error raised here
-    /// ```
-    pub(crate) static TOO_MANY_POSITIONAL_ARGUMENTS = {
-        summary: "detects calls passing too many positional arguments",
-        status: LintStatus::preview("1.0.0"),
-        default_level: Level::Error,
-    }
-}
-
 declare_lint! {
     /// ## What it does
     /// Checks for calls to `reveal_type` without importing it.
@@ -612,27 +365,6 @@ declare_lint! {
     }
 }
 
-declare_lint! {
-    /// ## What it does
-    /// Checks for keyword arguments in calls that don't match any parameter of the callable.
-    ///
-    /// ## Why is this bad?
-    /// Providing an unknown keyword argument will raise `TypeError` at runtime.
-    ///
-    /// ## Example
-    ///
-    /// ```python
-    /// def f(x: int) -> int: ...
-    ///
-    /// f(x=1, y=2)  # Error raised here
-    /// ```
-    pub(crate) static UNKNOWN_ARGUMENT = {
-        summary: "detects unknown keyword arguments in calls",
-        status: LintStatus::preview("1.0.0"),
-        default_level: Level::Error,
-    }
-}
-
 declare_lint! {
     /// ## What it does
     /// Checks for unresolved attributes.
@@ -708,32 +440,13 @@ declare_lint! {
     }
 }
 
-declare_lint! {
-    /// ## What it does
-    /// Makes sure that the argument of `static_assert` is statically known to be true.
-    ///
-    /// ## Examples
-    /// ```python
-    /// from knot_extensions import static_assert
-    ///
-    /// static_assert(1 + 1 == 3)  # error: evaluates to `False`
-    ///
-    /// static_assert(int(2.0 * 3.0) == 6)  # error: does not have a statically known truthiness
-    /// ```
-    pub(crate) static STATIC_ASSERT_ERROR = {
-        summary: "Failed static assertion",
-        status: LintStatus::preview("1.0.0"),
-        default_level: Level::Error,
-    }
-}
-
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub struct TypeCheckDiagnostic {
-    pub(crate) id: DiagnosticId,
-    pub(crate) message: String,
-    pub(crate) range: TextRange,
-    pub(crate) severity: Severity,
-    pub(crate) file: File,
+    pub(super) id: DiagnosticId,
+    pub(super) message: String,
+    pub(super) range: TextRange,
+    pub(super) severity: Severity,
+    pub(super) file: File,
 }
 
 impl TypeCheckDiagnostic {
@@ -787,41 +500,41 @@ impl Ranged for TypeCheckDiagnostic {
 /// each Salsa-struct comes with an overhead.
 #[derive(Default, Eq, PartialEq)]
 pub struct TypeCheckDiagnostics {
-    diagnostics: Vec<Arc<TypeCheckDiagnostic>>,
-    used_suppressions: FxHashSet<FileSuppressionId>,
+    inner: Vec<std::sync::Arc<TypeCheckDiagnostic>>,
 }
 
 impl TypeCheckDiagnostics {
-    pub(crate) fn push(&mut self, diagnostic: TypeCheckDiagnostic) {
-        self.diagnostics.push(Arc::new(diagnostic));
-    }
-
-    pub(super) fn extend(&mut self, other: &TypeCheckDiagnostics) {
-        self.diagnostics.extend_from_slice(&other.diagnostics);
-        self.used_suppressions.extend(&other.used_suppressions);
-    }
-
-    pub(crate) fn mark_used(&mut self, suppression_id: FileSuppressionId) {
-        self.used_suppressions.insert(suppression_id);
-    }
-
-    pub(crate) fn is_used(&self, suppression_id: FileSuppressionId) -> bool {
-        self.used_suppressions.contains(&suppression_id)
-    }
-
-    pub(crate) fn used_len(&self) -> usize {
-        self.used_suppressions.len()
+    pub(super) fn push(&mut self, diagnostic: TypeCheckDiagnostic) {
+        self.inner.push(Arc::new(diagnostic));
     }
 
     pub(crate) fn shrink_to_fit(&mut self) {
-        self.used_suppressions.shrink_to_fit();
-        self.diagnostics.shrink_to_fit();
+        self.inner.shrink_to_fit();
+    }
+}
+
+impl Extend<TypeCheckDiagnostic> for TypeCheckDiagnostics {
+    fn extend<T: IntoIterator<Item = TypeCheckDiagnostic>>(&mut self, iter: T) {
+        self.inner.extend(iter.into_iter().map(std::sync::Arc::new));
+    }
+}
+
+impl Extend<std::sync::Arc<TypeCheckDiagnostic>> for TypeCheckDiagnostics {
+    fn extend<T: IntoIterator<Item = Arc<TypeCheckDiagnostic>>>(&mut self, iter: T) {
+        self.inner.extend(iter);
+    }
+}
+
+impl<'a> Extend<&'a std::sync::Arc<TypeCheckDiagnostic>> for TypeCheckDiagnostics {
+    fn extend<T: IntoIterator<Item = &'a Arc<TypeCheckDiagnostic>>>(&mut self, iter: T) {
+        self.inner
+            .extend(iter.into_iter().map(std::sync::Arc::clone));
     }
 }
 
 impl std::fmt::Debug for TypeCheckDiagnostics {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.diagnostics.fmt(f)
+        self.inner.fmt(f)
     }
 }
 
@@ -829,7 +542,7 @@ impl Deref for TypeCheckDiagnostics {
     type Target = [std::sync::Arc<TypeCheckDiagnostic>];
 
     fn deref(&self) -> &Self::Target {
-        &self.diagnostics
+        &self.inner
     }
 }
 
@@ -838,7 +551,7 @@ impl IntoIterator for TypeCheckDiagnostics {
     type IntoIter = std::vec::IntoIter<std::sync::Arc<TypeCheckDiagnostic>>;
 
     fn into_iter(self) -> Self::IntoIter {
-        self.diagnostics.into_iter()
+        self.inner.into_iter()
     }
 }
 
@@ -847,193 +560,227 @@ impl<'a> IntoIterator for &'a TypeCheckDiagnostics {
     type IntoIter = std::slice::Iter<'a, std::sync::Arc<TypeCheckDiagnostic>>;
 
     fn into_iter(self) -> Self::IntoIter {
-        self.diagnostics.iter()
+        self.inner.iter()
     }
 }
 
-/// Emit a diagnostic declaring that the object represented by `node` is not iterable
-pub(super) fn report_not_iterable(context: &InferContext, node: AnyNodeRef, not_iterable_ty: Type) {
-    context.report_lint(
-        &NOT_ITERABLE,
-        node,
-        format_args!(
-            "Object of type `{}` is not iterable",
-            not_iterable_ty.display(context.db())
-        ),
-    );
+pub(super) struct TypeCheckDiagnosticsBuilder<'db> {
+    db: &'db dyn Db,
+    file: File,
+    diagnostics: TypeCheckDiagnostics,
 }
 
-/// Emit a diagnostic declaring that the object represented by `node` is not iterable
-/// because its `__iter__` method is possibly unbound.
-pub(super) fn report_not_iterable_possibly_unbound(
-    context: &InferContext,
-    node: AnyNodeRef,
-    element_ty: Type,
-) {
-    context.report_lint(
-        &NOT_ITERABLE,
-        node,
-        format_args!(
-            "Object of type `{}` is not iterable because its `__iter__` method is possibly unbound",
-            element_ty.display(context.db())
-        ),
-    );
-}
-
-/// Emit a diagnostic declaring that an index is out of bounds for a tuple.
-pub(super) fn report_index_out_of_bounds(
-    context: &InferContext,
-    kind: &'static str,
-    node: AnyNodeRef,
-    tuple_ty: Type,
-    length: usize,
-    index: i64,
-) {
-    context.report_lint(
-        &INDEX_OUT_OF_BOUNDS,
-        node,
-        format_args!(
-            "Index {index} is out of bounds for {kind} `{}` with length {length}",
-            tuple_ty.display(context.db())
-        ),
-    );
-}
-
-/// Emit a diagnostic declaring that a type does not support subscripting.
-pub(super) fn report_non_subscriptable(
-    context: &InferContext,
-    node: AnyNodeRef,
-    non_subscriptable_ty: Type,
-    method: &str,
-) {
-    context.report_lint(
-        &NON_SUBSCRIPTABLE,
-        node,
-        format_args!(
-            "Cannot subscript object of type `{}` with no `{method}` method",
-            non_subscriptable_ty.display(context.db())
-        ),
-    );
-}
-
-pub(super) fn report_unresolved_module<'db>(
-    context: &InferContext,
-    import_node: impl Into<AnyNodeRef<'db>>,
-    level: u32,
-    module: Option<&str>,
-) {
-    context.report_lint(
-        &UNRESOLVED_IMPORT,
-        import_node.into(),
-        format_args!(
-            "Cannot resolve import `{}{}`",
-            ".".repeat(level as usize),
-            module.unwrap_or_default()
-        ),
-    );
-}
-
-pub(super) fn report_slice_step_size_zero(context: &InferContext, node: AnyNodeRef) {
-    context.report_lint(
-        &ZERO_STEPSIZE_IN_SLICE,
-        node,
-        format_args!("Slice step size can not be zero"),
-    );
-}
-
-pub(super) fn report_invalid_assignment(
-    context: &InferContext,
-    node: AnyNodeRef,
-    declared_ty: Type,
-    assigned_ty: Type,
-) {
-    match declared_ty {
-        Type::ClassLiteral(ClassLiteralType { class }) => {
-            context.report_lint(&INVALID_ASSIGNMENT, node, format_args!(
-                    "Implicit shadowing of class `{}`; annotate to make it explicit if this is intentional",
-                    class.name(context.db())));
-        }
-        Type::FunctionLiteral(function) => {
-            context.report_lint(&INVALID_ASSIGNMENT, node, format_args!(
-                    "Implicit shadowing of function `{}`; annotate to make it explicit if this is intentional",
-                    function.name(context.db())));
-        }
-        _ => {
-            context.report_lint(
-                &INVALID_ASSIGNMENT,
-                node,
-                format_args!(
-                    "Object of type `{}` is not assignable to `{}`",
-                    assigned_ty.display(context.db()),
-                    declared_ty.display(context.db()),
-                ),
-            );
+impl<'db> TypeCheckDiagnosticsBuilder<'db> {
+    pub(super) fn new(db: &'db dyn Db, file: File) -> Self {
+        Self {
+            db,
+            file,
+            diagnostics: TypeCheckDiagnostics::default(),
         }
     }
-}
-
-pub(super) fn report_possibly_unresolved_reference(
-    context: &InferContext,
-    expr_name_node: &ast::ExprName,
-) {
-    let ast::ExprName { id, .. } = expr_name_node;
-
-    context.report_lint(
-        &POSSIBLY_UNRESOLVED_REFERENCE,
-        expr_name_node.into(),
-        format_args!("Name `{id}` used when possibly not defined"),
-    );
-}
-
-pub(super) fn report_unresolved_reference(context: &InferContext, expr_name_node: &ast::ExprName) {
-    let ast::ExprName { id, .. } = expr_name_node;
-
-    context.report_lint(
-        &UNRESOLVED_REFERENCE,
-        expr_name_node.into(),
-        format_args!("Name `{id}` used when not defined"),
-    );
-}
-
-pub(super) fn report_invalid_exception_caught(context: &InferContext, node: &ast::Expr, ty: Type) {
-    context.report_lint(
-        &INVALID_EXCEPTION_CAUGHT,
-        node.into(),
-        format_args!(
-            "Cannot catch object of type `{}` in an exception handler \
-            (must be a `BaseException` subclass or a tuple of `BaseException` subclasses)",
-            ty.display(context.db())
-        ),
-    );
-}
-
-pub(crate) fn report_invalid_exception_raised(context: &InferContext, node: &ast::Expr, ty: Type) {
-    context.report_lint(
-        &INVALID_RAISE,
-        node.into(),
-        format_args!(
-            "Cannot raise object of type `{}` (must be a `BaseException` subclass or instance)",
-            ty.display(context.db())
-        ),
-    );
-}
-
-pub(crate) fn report_invalid_exception_cause(context: &InferContext, node: &ast::Expr, ty: Type) {
-    context.report_lint(
-        &INVALID_RAISE,
-        node.into(),
-        format_args!(
-            "Cannot use object of type `{}` as exception cause \
-            (must be a `BaseException` subclass or instance or `None`)",
-            ty.display(context.db())
-        ),
-    );
-}
-
-pub(crate) fn report_base_with_incompatible_slots(context: &InferContext, node: &ast::Expr) {
-    context.report_lint(
-        &INCOMPATIBLE_SLOTS,
-        node.into(),
-        format_args!("Class base has incompatible `__slots__`"),
-    );
+
+    /// Emit a diagnostic declaring that the object represented by `node` is not iterable
+    pub(super) fn add_not_iterable(&mut self, node: AnyNodeRef, not_iterable_ty: Type<'db>) {
+        self.add_lint(
+            &NOT_ITERABLE,
+            node,
+            format_args!(
+                "Object of type `{}` is not iterable",
+                not_iterable_ty.display(self.db)
+            ),
+        );
+    }
+
+    /// Emit a diagnostic declaring that the object represented by `node` is not iterable
+    /// because its `__iter__` method is possibly unbound.
+    pub(super) fn add_not_iterable_possibly_unbound(
+        &mut self,
+        node: AnyNodeRef,
+        element_ty: Type<'db>,
+    ) {
+        self.add_lint(
+            &NOT_ITERABLE,
+            node,
+            format_args!(
+                "Object of type `{}` is not iterable because its `__iter__` method is possibly unbound",
+                element_ty.display(self.db)
+            ),
+        );
+    }
+
+    /// Emit a diagnostic declaring that an index is out of bounds for a tuple.
+    pub(super) fn add_index_out_of_bounds(
+        &mut self,
+        kind: &'static str,
+        node: AnyNodeRef,
+        tuple_ty: Type<'db>,
+        length: usize,
+        index: i64,
+    ) {
+        self.add_lint(
+            &INDEX_OUT_OF_BOUNDS,
+            node,
+            format_args!(
+                "Index {index} is out of bounds for {kind} `{}` with length {length}",
+                tuple_ty.display(self.db)
+            ),
+        );
+    }
+
+    /// Emit a diagnostic declaring that a type does not support subscripting.
+    pub(super) fn add_non_subscriptable(
+        &mut self,
+        node: AnyNodeRef,
+        non_subscriptable_ty: Type<'db>,
+        method: &str,
+    ) {
+        self.add_lint(
+            &NON_SUBSCRIPTABLE,
+            node,
+            format_args!(
+                "Cannot subscript object of type `{}` with no `{method}` method",
+                non_subscriptable_ty.display(self.db)
+            ),
+        );
+    }
+
+    pub(super) fn add_unresolved_module(
+        &mut self,
+        import_node: impl Into<AnyNodeRef<'db>>,
+        level: u32,
+        module: Option<&str>,
+    ) {
+        self.add_lint(
+            &UNRESOLVED_IMPORT,
+            import_node.into(),
+            format_args!(
+                "Cannot resolve import `{}{}`",
+                ".".repeat(level as usize),
+                module.unwrap_or_default()
+            ),
+        );
+    }
+
+    pub(super) fn add_slice_step_size_zero(&mut self, node: AnyNodeRef) {
+        self.add_lint(
+            &ZERO_STEPSIZE_IN_SLICE,
+            node,
+            format_args!("Slice step size can not be zero"),
+        );
+    }
+
+    pub(super) fn add_invalid_assignment(
+        &mut self,
+        node: AnyNodeRef,
+        declared_ty: Type<'db>,
+        assigned_ty: Type<'db>,
+    ) {
+        match declared_ty {
+            Type::ClassLiteral(ClassLiteralType { class }) => {
+                self.add_lint(&INVALID_ASSIGNMENT, node, format_args!(
+                        "Implicit shadowing of class `{}`; annotate to make it explicit if this is intentional",
+                        class.name(self.db)));
+            }
+            Type::FunctionLiteral(function) => {
+                self.add_lint(&INVALID_ASSIGNMENT, node, format_args!(
+                        "Implicit shadowing of function `{}`; annotate to make it explicit if this is intentional",
+                        function.name(self.db)));
+            }
+            _ => {
+                self.add_lint(
+                    &INVALID_ASSIGNMENT,
+                    node,
+                    format_args!(
+                        "Object of type `{}` is not assignable to `{}`",
+                        assigned_ty.display(self.db),
+                        declared_ty.display(self.db),
+                    ),
+                );
+            }
+        }
+    }
+
+    pub(super) fn add_possibly_unresolved_reference(&mut self, expr_name_node: &ast::ExprName) {
+        let ast::ExprName { id, .. } = expr_name_node;
+
+        self.add_lint(
+            &POSSIBLY_UNRESOLVED_REFERENCE,
+            expr_name_node.into(),
+            format_args!("Name `{id}` used when possibly not defined"),
+        );
+    }
+
+    pub(super) fn add_unresolved_reference(&mut self, expr_name_node: &ast::ExprName) {
+        let ast::ExprName { id, .. } = expr_name_node;
+
+        self.add_lint(
+            &UNRESOLVED_REFERENCE,
+            expr_name_node.into(),
+            format_args!("Name `{id}` used when not defined"),
+        );
+    }
+
+    pub(super) fn add_invalid_exception_caught(&mut self, db: &dyn Db, node: &ast::Expr, ty: Type) {
+        self.add_lint(
+            &INVALID_EXCEPTION_CAUGHT,
+            node.into(),
+            format_args!(
+                "Cannot catch object of type `{}` in an exception handler \
+                (must be a `BaseException` subclass or a tuple of `BaseException` subclasses)",
+                ty.display(db)
+            ),
+        );
+    }
+
+    pub(super) fn add_lint(
+        &mut self,
+        lint: &'static LintMetadata,
+        node: AnyNodeRef,
+        message: std::fmt::Arguments,
+    ) {
+        // Skip over diagnostics if the rule is disabled.
+        let Some(severity) = self.db.rule_selection().severity(LintId::of(lint)) else {
+            return;
+        };
+
+        self.add(node, DiagnosticId::Lint(lint.name()), severity, message);
+    }
+
+    /// Adds a new diagnostic.
+    ///
+    /// The diagnostic does not get added if the rule isn't enabled for this file.
+    pub(super) fn add(
+        &mut self,
+        node: AnyNodeRef,
+        id: DiagnosticId,
+        severity: Severity,
+        message: std::fmt::Arguments,
+    ) {
+        if !self.db.is_file_open(self.file) {
+            return;
+        }
+
+        // TODO: Don't emit the diagnostic if:
+        // * The enclosing node contains any syntax errors
+        // * The rule is disabled for this file. We probably want to introduce a new query that
+        //   returns a rule selector for a given file that respects the package's settings,
+        //   any global pragma comments in the file, and any per-file-ignores.
+
+        self.diagnostics.push(TypeCheckDiagnostic {
+            file: self.file,
+            id,
+            message: message.to_string(),
+            range: node.range(),
+            severity,
+        });
+    }
+
+    pub(super) fn extend(&mut self, diagnostics: &TypeCheckDiagnostics) {
+        self.diagnostics.extend(diagnostics);
+    }
+
+    pub(super) fn finish(mut self) -> TypeCheckDiagnostics {
+        self.diagnostics.shrink_to_fit();
+        self.diagnostics
+    }
 }

crates/red_knot_python_semantic/src/types/display.rs

@@ -8,8 +8,8 @@ use ruff_python_literal::escape::AsciiEscape;
 
 use crate::types::class_base::ClassBase;
 use crate::types::{
-    ClassLiteralType, InstanceType, IntersectionType, KnownClass, StringLiteralType, Type,
-    UnionType,
+    ClassLiteralType, InstanceType, IntersectionType, KnownClass, StringLiteralType,
+    SubclassOfType, Type, UnionType,
 };
 use crate::Db;
 use rustc_hash::FxHashMap;
@@ -84,14 +84,16 @@ impl Display for DisplayRepresentation<'_> {
             }
             // TODO functions and classes should display using a fully qualified name
             Type::ClassLiteral(ClassLiteralType { class }) => f.write_str(class.name(self.db)),
-            Type::SubclassOf(subclass_of_ty) => match subclass_of_ty.subclass_of() {
+            Type::SubclassOf(SubclassOfType {
+                base: ClassBase::Class(class),
+            }) => {
                 // Only show the bare class name here; ClassBase::display would render this as
                 // type[<class 'Foo'>] instead of type[Foo].
-                ClassBase::Class(class) => write!(f, "type[{}]", class.name(self.db)),
-                base @ (ClassBase::Any | ClassBase::Todo(_) | ClassBase::Unknown) => {
-                    write!(f, "type[{}]", base.display(self.db))
-                }
-            },
+                write!(f, "type[{}]", class.name(self.db))
+            }
+            Type::SubclassOf(SubclassOfType { base }) => {
+                write!(f, "type[{}]", base.display(self.db))
+            }
             Type::KnownInstance(known_instance) => f.write_str(known_instance.repr(self.db)),
             Type::FunctionLiteral(function) => f.write_str(function.name(self.db)),
             Type::Union(union) => union.display(self.db).fmt(f),
@@ -175,9 +177,12 @@ impl Display for DisplayUnionType<'_> {
 
         for element in elements {
             if let Ok(kind) = CondensedDisplayTypeKind::try_from(*element) {
-                let Some(condensed_kind) = grouped_condensed_kinds.remove(&kind) else {
+                let Some(mut condensed_kind) = grouped_condensed_kinds.remove(&kind) else {
                     continue;
                 };
+                if kind == CondensedDisplayTypeKind::Int {
+                    condensed_kind.sort_unstable_by_key(|ty| ty.expect_int_literal());
+                }
                 join.entry(&DisplayLiteralGroup {
                     literals: condensed_kind,
                     db: self.db,
@@ -218,12 +223,17 @@ impl Display for DisplayLiteralGroup<'_> {
 
 /// Enumeration of literal types that are displayed in a "condensed way" inside `Literal` slices.
 ///
-/// For example, `Literal[1] | Literal[2] | Literal["s"]` is displayed as `"Literal[1, 2, "s"]"`.
+/// For example, `Literal[1] | Literal[2]` is displayed as `"Literal[1, 2]"`.
+/// Not all `Literal` types are displayed using `Literal` slices
+/// (e.g. it would be inappropriate to display `LiteralString`
+/// as `Literal[LiteralString]`).
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
 enum CondensedDisplayTypeKind {
     Class,
     Function,
-    LiteralExpression,
+    Int,
+    String,
+    Bytes,
 }
 
 impl TryFrom<Type<'_>> for CondensedDisplayTypeKind {
@@ -233,10 +243,9 @@ impl TryFrom<Type<'_>> for CondensedDisplayTypeKind {
         match value {
             Type::ClassLiteral(_) => Ok(Self::Class),
             Type::FunctionLiteral(_) => Ok(Self::Function),
-            Type::IntLiteral(_)
-            | Type::StringLiteral(_)
-            | Type::BytesLiteral(_)
-            | Type::BooleanLiteral(_) => Ok(Self::LiteralExpression),
+            Type::IntLiteral(_) => Ok(Self::Int),
+            Type::StringLiteral(_) => Ok(Self::String),
+            Type::BytesLiteral(_) => Ok(Self::Bytes),
             _ => Err(()),
         }
     }
@@ -315,12 +324,6 @@ impl<'db> TypeArrayDisplay<'db> for Vec<Type<'db>> {
     }
 }
 
-impl<'db> TypeArrayDisplay<'db> for [Type<'db>] {
-    fn display(&self, db: &'db dyn Db) -> DisplayTypeArray {
-        DisplayTypeArray { types: self, db }
-    }
-}
-
 pub(crate) struct DisplayTypeArray<'b, 'db> {
     types: &'b [Type<'db>],
     db: &'db dyn Db,
@@ -363,8 +366,64 @@ impl Display for DisplayStringLiteralType<'_> {
 
 #[cfg(test)]
 mod tests {
+    use ruff_db::files::system_path_to_file;
+    use ruff_db::system::DbWithTestSystem;
+
     use crate::db::tests::setup_db;
-    use crate::types::{SliceLiteralType, StringLiteralType, Type};
+    use crate::types::{global_symbol, SliceLiteralType, StringLiteralType, Type, UnionType};
+
+    #[test]
+    fn test_condense_literal_display_by_type() -> anyhow::Result<()> {
+        let mut db = setup_db();
+
+        db.write_dedented(
+            "src/main.py",
+            "
+            def foo(x: int) -> int:
+                return x + 1
+
+            def bar(s: str) -> str:
+                return s
+
+            class A: ...
+            class B: ...
+            ",
+        )?;
+        let mod_file = system_path_to_file(&db, "src/main.py").expect("file to exist");
+
+        let union_elements = &[
+            Type::Unknown,
+            Type::IntLiteral(-1),
+            global_symbol(&db, mod_file, "A").expect_type(),
+            Type::string_literal(&db, "A"),
+            Type::bytes_literal(&db, &[0u8]),
+            Type::bytes_literal(&db, &[7u8]),
+            Type::IntLiteral(0),
+            Type::IntLiteral(1),
+            Type::string_literal(&db, "B"),
+            global_symbol(&db, mod_file, "foo").expect_type(),
+            global_symbol(&db, mod_file, "bar").expect_type(),
+            global_symbol(&db, mod_file, "B").expect_type(),
+            Type::BooleanLiteral(true),
+            Type::none(&db),
+        ];
+        let union = UnionType::from_elements(&db, union_elements).expect_union();
+        let display = format!("{}", union.display(&db));
+        assert_eq!(
+            display,
+            concat!(
+                "Unknown | ",
+                "Literal[-1, 0, 1] | ",
+                "Literal[A, B] | ",
+                "Literal[\"A\", \"B\"] | ",
+                "Literal[b\"\\x00\", b\"\\x07\"] | ",
+                "Literal[foo, bar] | ",
+                "Literal[True] | ",
+                "None"
+            )
+        );
+        Ok(())
+    }
 
     #[test]
     fn test_slice_literal_display() {