Fix is_airflow_* function, add docs

* `airflow.providers_manager.ProvidersManager.dataset_factories` → `airflow.providers_manager.ProvidersManager.asset_factories`
* `airflow.providers_manager.ProvidersManager.dataset_uri_handlers` → `airflow.providers_manager.ProvidersManager.asset_uri_handlers`
* `airflow.providers_manager.ProvidersManager.dataset_to_openlineage_converters` → `airflow.providers_manager.ProvidersManager.asset_to_openlineage_converters`
* `airflow.lineage.hook.DatasetLineageInfo.dataset`  → `airflow.lineage.hook.AssetLineageInfo.asset`

.github/CODEOWNERS

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

.github/ISSUE_TEMPLATE.md

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

.github/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

@@ -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: |

.github/workflows/daily_fuzz.yaml

@@ -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-wasm.yml

@@ -55,9 +55,3 @@ jobs:
         run: npm publish --provenance --access public crates/ruff_wasm/pkg
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-      - name: Archive npm failure logs
-        uses: actions/upload-artifact@v4
-        if: failure()
-        with:
-          name: npm-logs
-          path: ~/.npm/_logs

.github/workflows/release.yml

@@ -202,6 +202,20 @@ jobs:
           name: artifacts-dist-manifest
           path: dist-manifest.json
 
+  custom-publish-pypi:
+    needs:
+      - plan
+      - host
+    if: ${{ !fromJson(needs.plan.outputs.val).announcement_is_prerelease || fromJson(needs.plan.outputs.val).publish_prereleases }}
+    uses: ./.github/workflows/publish-pypi.yml
+    with:
+      plan: ${{ needs.plan.outputs.val }}
+    secrets: inherit
+    # publish jobs get escalated permissions
+    permissions:
+      "id-token": "write"
+      "packages": "write"
+
   custom-publish-wasm:
     needs:
       - plan
@@ -222,11 +236,12 @@ jobs:
     needs:
       - plan
       - host
+      - custom-publish-pypi
       - custom-publish-wasm
     # use "always() && ..." to allow us to wait for all publish jobs while
     # still allowing individual publish jobs to skip themselves (for prereleases).
     # "host" however must run to completion, no skipping allowed!
-    if: ${{ always() && needs.host.result == 'success' && (needs.custom-publish-wasm.result == 'skipped' || needs.custom-publish-wasm.result == 'success') }}
+    if: ${{ always() && needs.host.result == 'success' && (needs.custom-publish-pypi.result == 'skipped' || needs.custom-publish-pypi.result == 'success') && (needs.custom-publish-wasm.result == 'skipped' || needs.custom-publish-wasm.result == 'success') }}
     runs-on: "ubuntu-20.04"
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/sync_typeshed.yaml

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

.github/zizmor.yml

@@ -1,12 +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

@@ -59,7 +59,7 @@ repos:
           - black==24.10.0
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.29.4
+    rev: v1.28.4
     hooks:
       - id: typos
 
@@ -73,7 +73,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.1
+    rev: v0.8.4
     hooks:
       - id: ruff-format
       - id: ruff
@@ -91,19 +91,19 @@ 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.1
+    rev: v0.10.0
     hooks:
       - id: zizmor
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.31.0
+    rev: 0.30.0
     hooks:
       - id: check-github-workflows
 
   # `actionlint` hook, for verifying correct syntax in GitHub Actions workflows.
   # Some additional configuration for `actionlint` can be found in `.github/actionlint.yaml`.
   - repo: https://github.com/rhysd/actionlint
-    rev: v1.7.6
+    rev: v1.7.5
     hooks:
       - id: actionlint
         stages:

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

Cargo.toml

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

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.2/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.9.2/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.8.4/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.8.4/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -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.2
+  rev: v0.8.4
   hooks:
     # Run the linter.
     - id: ruff
@@ -205,7 +196,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: astral-sh/ruff-action@v3
+      - uses: astral-sh/ruff-action@v1
 ```
 
 ### Configuration<a id="configuration"></a>

_typos.toml

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

crates/red_knot/src/main.rs

@@ -8,11 +8,11 @@ use crossbeam::channel as crossbeam_channel;
 use python_version::PythonVersion;
 use red_knot_python_semantic::SitePackages;
 use red_knot_server::run_server;
-use red_knot_workspace::db::ProjectDatabase;
-use red_knot_workspace::project::settings::Configuration;
-use red_knot_workspace::project::ProjectMetadata;
+use red_knot_workspace::db::RootDatabase;
 use red_knot_workspace::watch;
-use red_knot_workspace::watch::ProjectWatcher;
+use red_knot_workspace::watch::WorkspaceWatcher;
+use red_knot_workspace::workspace::settings::Configuration;
+use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::diagnostic::Diagnostic;
 use ruff_db::system::{OsSystem, System, SystemPath, SystemPathBuf};
 use salsa::plumbing::ZalsaDatabase;
@@ -165,7 +165,7 @@ fn run() -> anyhow::Result<ExitStatus> {
 
     let system = OsSystem::new(cwd.clone());
     let cli_configuration = args.to_configuration(&cwd);
-    let workspace_metadata = ProjectMetadata::discover(
+    let workspace_metadata = WorkspaceMetadata::discover(
         system.current_directory(),
         &system,
         Some(&cli_configuration),
@@ -173,7 +173,7 @@ fn run() -> anyhow::Result<ExitStatus> {
 
     // TODO: Use the `program_settings` to compute the key for the database's persistent
     //   cache and load the cache if it exists.
-    let mut db = ProjectDatabase::new(workspace_metadata, system)?;
+    let mut db = RootDatabase::new(workspace_metadata, system)?;
 
     let (main_loop, main_loop_cancellation_token) = MainLoop::new(cli_configuration);
 
@@ -226,7 +226,7 @@ struct MainLoop {
     receiver: crossbeam_channel::Receiver<MainLoopMessage>,
 
     /// The file system watcher, if running in watch mode.
-    watcher: Option<ProjectWatcher>,
+    watcher: Option<WorkspaceWatcher>,
 
     cli_configuration: Configuration,
 }
@@ -246,21 +246,21 @@ impl MainLoop {
         )
     }
 
-    fn watch(mut self, db: &mut ProjectDatabase) -> anyhow::Result<ExitStatus> {
+    fn watch(mut self, db: &mut RootDatabase) -> anyhow::Result<ExitStatus> {
         tracing::debug!("Starting watch mode");
         let sender = self.sender.clone();
         let watcher = watch::directory_watcher(move |event| {
             sender.send(MainLoopMessage::ApplyChanges(event)).unwrap();
         })?;
 
-        self.watcher = Some(ProjectWatcher::new(watcher, db));
+        self.watcher = Some(WorkspaceWatcher::new(watcher, db));
 
         self.run(db);
 
         Ok(ExitStatus::Success)
     }
 
-    fn run(mut self, db: &mut ProjectDatabase) -> ExitStatus {
+    fn run(mut self, db: &mut RootDatabase) -> ExitStatus {
         self.sender.send(MainLoopMessage::CheckWorkspace).unwrap();
 
         let result = self.main_loop(db);
@@ -270,7 +270,7 @@ impl MainLoop {
         result
     }
 
-    fn main_loop(&mut self, db: &mut ProjectDatabase) -> ExitStatus {
+    fn main_loop(&mut self, db: &mut RootDatabase) -> ExitStatus {
         // Schedule the first check.
         tracing::debug!("Starting main loop");
 
@@ -282,7 +282,7 @@ impl MainLoop {
                     let db = db.clone();
                     let sender = self.sender.clone();
 
-                    // Spawn a new task that checks the project. This needs to be done in a separate thread
+                    // Spawn a new task that checks the workspace. This needs to be done in a separate thread
                     // to prevent blocking the main loop here.
                     rayon::spawn(move || {
                         if let Ok(result) = db.check() {

crates/red_knot/tests/file_watching.rs

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

crates/red_knot_python_semantic/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

@@ -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/string.md

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

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

@@ -6,11 +6,14 @@ Several type qualifiers are unsupported by red-knot currently. However, we also
 false-positive errors if you use one in an annotation:
 
 ```py
-from typing_extensions import Final, Required, NotRequired, ReadOnly, TypedDict
+from typing_extensions import Final, ClassVar, Required, NotRequired, ReadOnly, TypedDict
 
 X: Final = 42
 Y: Final[int] = 42
 
+class Foo:
+    A: ClassVar[int] = 42
+
 # TODO: `TypedDict` is actually valid as a base
 # error: [invalid-base]
 class Bar(TypedDict):

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

@@ -122,10 +122,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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

crates/red_knot_python_semantic/resources/mdtest/comparison/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/directives/assert_type.md

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

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

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

crates/red_knot_python_semantic/resources/mdtest/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/if.md

@@ -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/intersection_types.md

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

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

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

@@ -90,7 +90,7 @@ 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`
@@ -146,7 +146,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 +160,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 +234,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, -1, "", "foo", b"", 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, -1, "", "foo", b"", 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[0, -1, "", "foo", b"", b"bar"] | 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[0, -1, "", "foo", b"", b"bar"] | 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
@@ -87,10 +87,10 @@ def f(x: A | B):
     if x and not x:
         reveal_type(x)  # revealed: A & ~AlwaysFalsy & ~AlwaysTruthy | B & ~AlwaysFalsy & ~AlwaysTruthy
     else:
-        reveal_type(x)  # revealed: A | B
+        reveal_type(x)  # revealed: A & ~AlwaysTruthy | B & ~AlwaysTruthy | A & ~AlwaysFalsy | B & ~AlwaysFalsy
 
     if x or not x:
-        reveal_type(x)  # revealed: A | B
+        reveal_type(x)  # revealed: A & ~AlwaysFalsy | B & ~AlwaysFalsy | A & ~AlwaysTruthy | B & ~AlwaysTruthy
     else:
         reveal_type(x)  # revealed: A & ~AlwaysTruthy & ~AlwaysFalsy | B & ~AlwaysTruthy & ~AlwaysFalsy
 ```
@@ -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
@@ -199,7 +199,7 @@ def f(x: Literal[0, 1], y: Literal["", "hello"]):
         reveal_type(y)  # revealed: Literal["", "hello"]
 ```
 
-## Control Flow Merging
+## ControlFlow Merging
 
 After merging control flows, when we take the union of all constraints applied in each branch, we
 should return to the original state.
@@ -214,9 +214,10 @@ if x and not x:
     reveal_type(y)  # revealed: A & ~AlwaysFalsy & ~AlwaysTruthy
 else:
     y = x
-    reveal_type(y)  # revealed: A
+    reveal_type(y)  # revealed: A & ~AlwaysTruthy | A & ~AlwaysFalsy
 
-reveal_type(y)  # revealed: A
+# TODO: It should be A. We should improve UnionBuilder or IntersectionBuilder. (issue #15023)
+reveal_type(y)  # revealed: A & ~AlwaysTruthy | A & ~AlwaysFalsy
 ```
 
 ## Truthiness of classes
@@ -312,20 +313,3 @@ def _(x: type[FalsyClass] | type[TruthyClass]):
     reveal_type(x or A())  # revealed: type[TruthyClass] | A
     reveal_type(x and A())  # revealed: type[FalsyClass] | A
 ```
-
-## Truthiness narrowing for `LiteralString`
-
-```py
-from typing_extensions import LiteralString
-
-def _(x: LiteralString):
-    if x:
-        reveal_type(x)  # revealed: LiteralString & ~Literal[""]
-    else:
-        reveal_type(x)  # revealed: Literal[""]
-
-    if not x:
-        reveal_type(x)  # revealed: Literal[""]
-    else:
-        reveal_type(x)  # revealed: LiteralString & ~Literal[""]
-```

crates/red_knot_python_semantic/resources/mdtest/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/slots.md

@@ -167,7 +167,7 @@ class A:
     __slots__ = ()
     __slots__ += ("a", "b")
 
-reveal_type(A.__slots__)  # revealed: @Todo(return type)
+reveal_type(A.__slots__)  # revealed: @Todo(Support for more binary expressions)
 
 class B:
     __slots__ = ("c", "d")

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/sys_platform.md

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

crates/red_knot_python_semantic/resources/mdtest/type_of/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/type_properties/is_equivalent_to.md

@@ -1,35 +0,0 @@
-# Equivalence relation
-
-`is_equivalent_to` implements [the equivalence relation] for fully static types.
-
-Two types `A` and `B` are equivalent iff `A` is a subtype of `B` and `B` is a subtype of `A`.
-
-## Basic
-
-```py
-from typing import Any
-from typing_extensions import Literal
-from knot_extensions import Unknown, is_equivalent_to, static_assert
-
-static_assert(is_equivalent_to(Literal[1, 2], Literal[1, 2]))
-static_assert(is_equivalent_to(type[object], type))
-
-static_assert(not is_equivalent_to(Any, Any))
-static_assert(not is_equivalent_to(Unknown, Unknown))
-static_assert(not is_equivalent_to(Any, None))
-static_assert(not is_equivalent_to(Literal[1, 2], Literal[1, 0]))
-static_assert(not is_equivalent_to(Literal[1, 2], Literal[1, 2, 3]))
-```
-
-## Equivalence is commutative
-
-```py
-from typing_extensions import Literal
-from knot_extensions import is_equivalent_to, static_assert
-
-static_assert(is_equivalent_to(type, type[object]))
-static_assert(not is_equivalent_to(Literal[1, 0], Literal[1, 2]))
-static_assert(not is_equivalent_to(Literal[1, 2, 3], Literal[1, 2]))
-```
-
-[the equivalence relation]: https://typing.readthedocs.io/en/latest/spec/glossary.html#term-equivalent

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

@@ -1,453 +0,0 @@
-# Subtype relation
-
-The `is_subtype_of(S, T)` relation below checks if type `S` is a subtype of type `T`.
-
-A fully static type `S` is a subtype of another fully static type `T` iff the set of values
-represented by `S` is a subset of the set of values represented by `T`.
-
-See the [typing documentation] for more information.
-
-## Basic builtin types
-
-- `bool` is a subtype of `int`. This is modeled after Python's runtime behavior, where `int` is a
-    supertype of `bool` (present in `bool`s bases and MRO).
-- `int` is not a subtype of `float`/`complex`, even though `float`/`complex` can be used in place of
-    `int` in some contexts (see [special case for float and complex]).
-
-```py
-from knot_extensions import is_subtype_of, static_assert
-
-static_assert(is_subtype_of(bool, bool))
-static_assert(is_subtype_of(bool, int))
-static_assert(is_subtype_of(bool, object))
-
-static_assert(is_subtype_of(int, int))
-static_assert(is_subtype_of(int, object))
-
-static_assert(is_subtype_of(object, object))
-
-static_assert(not is_subtype_of(int, bool))
-static_assert(not is_subtype_of(int, str))
-static_assert(not is_subtype_of(object, int))
-
-static_assert(not is_subtype_of(int, float))
-static_assert(not is_subtype_of(int, complex))
-
-static_assert(is_subtype_of(TypeError, Exception))
-static_assert(is_subtype_of(FloatingPointError, Exception))
-```
-
-## Class hierarchies
-
-```py
-from knot_extensions import is_subtype_of, static_assert
-from typing_extensions import Never
-
-class A: ...
-class B1(A): ...
-class B2(A): ...
-class C(B1, B2): ...
-
-static_assert(is_subtype_of(B1, A))
-static_assert(not is_subtype_of(A, B1))
-
-static_assert(is_subtype_of(B2, A))
-static_assert(not is_subtype_of(A, B2))
-
-static_assert(not is_subtype_of(B1, B2))
-static_assert(not is_subtype_of(B2, B1))
-
-static_assert(is_subtype_of(C, B1))
-static_assert(is_subtype_of(C, B2))
-static_assert(not is_subtype_of(B1, C))
-static_assert(not is_subtype_of(B2, C))
-static_assert(is_subtype_of(C, A))
-static_assert(not is_subtype_of(A, C))
-
-static_assert(is_subtype_of(Never, A))
-static_assert(is_subtype_of(Never, B1))
-static_assert(is_subtype_of(Never, B2))
-static_assert(is_subtype_of(Never, C))
-
-static_assert(is_subtype_of(A, object))
-static_assert(is_subtype_of(B1, object))
-static_assert(is_subtype_of(B2, object))
-static_assert(is_subtype_of(C, object))
-```
-
-## Literal types
-
-```py
-from typing_extensions import Literal, LiteralString
-from knot_extensions import is_subtype_of, static_assert
-
-# Boolean literals
-static_assert(is_subtype_of(Literal[True], bool))
-static_assert(is_subtype_of(Literal[True], int))
-static_assert(is_subtype_of(Literal[True], object))
-
-# Integer literals
-static_assert(is_subtype_of(Literal[1], int))
-static_assert(is_subtype_of(Literal[1], object))
-
-static_assert(not is_subtype_of(Literal[1], bool))
-
-# See the note above (or link below) concerning int and float/complex
-static_assert(not is_subtype_of(Literal[1], float))
-
-# String literals
-static_assert(is_subtype_of(Literal["foo"], LiteralString))
-static_assert(is_subtype_of(Literal["foo"], str))
-static_assert(is_subtype_of(Literal["foo"], object))
-
-static_assert(is_subtype_of(LiteralString, str))
-static_assert(is_subtype_of(LiteralString, object))
-
-# Bytes literals
-static_assert(is_subtype_of(Literal[b"foo"], bytes))
-static_assert(is_subtype_of(Literal[b"foo"], object))
-```
-
-## Tuple types
-
-```py
-from knot_extensions import is_subtype_of, static_assert
-
-class A1: ...
-class B1(A1): ...
-class A2: ...
-class B2(A2): ...
-class Unrelated: ...
-
-static_assert(is_subtype_of(B1, A1))
-static_assert(is_subtype_of(B2, A2))
-
-# Zero-element tuples
-static_assert(is_subtype_of(tuple[()], tuple[()]))
-static_assert(not is_subtype_of(tuple[()], tuple[Unrelated]))
-
-# One-element tuples
-static_assert(is_subtype_of(tuple[B1], tuple[A1]))
-static_assert(not is_subtype_of(tuple[B1], tuple[Unrelated]))
-static_assert(not is_subtype_of(tuple[B1], tuple[()]))
-static_assert(not is_subtype_of(tuple[B1], tuple[A1, Unrelated]))
-
-# Two-element tuples
-static_assert(is_subtype_of(tuple[B1, B2], tuple[A1, A2]))
-static_assert(not is_subtype_of(tuple[B1, B2], tuple[Unrelated, A2]))
-static_assert(not is_subtype_of(tuple[B1, B2], tuple[A1, Unrelated]))
-static_assert(not is_subtype_of(tuple[B1, B2], tuple[Unrelated, Unrelated]))
-static_assert(not is_subtype_of(tuple[B1, B2], tuple[()]))
-static_assert(not is_subtype_of(tuple[B1, B2], tuple[A1]))
-static_assert(not is_subtype_of(tuple[B1, B2], tuple[A1, A2, Unrelated]))
-
-static_assert(is_subtype_of(tuple[int], tuple))
-```
-
-## Union types
-
-```py
-from knot_extensions import is_subtype_of, static_assert
-
-class A: ...
-class B1(A): ...
-class B2(A): ...
-class Unrelated1: ...
-class Unrelated2: ...
-
-static_assert(is_subtype_of(B1, A))
-static_assert(is_subtype_of(B2, A))
-
-# Union on the right hand side
-static_assert(is_subtype_of(B1, A | Unrelated1))
-static_assert(is_subtype_of(B1, Unrelated1 | A))
-
-static_assert(not is_subtype_of(B1, Unrelated1 | Unrelated2))
-
-# Union on the left hand side
-static_assert(is_subtype_of(B1 | B2, A))
-static_assert(is_subtype_of(B1 | B2 | A, object))
-
-static_assert(not is_subtype_of(B1 | Unrelated1, A))
-static_assert(not is_subtype_of(Unrelated1 | B1, A))
-
-# Union on both sides
-static_assert(is_subtype_of(B1 | bool, A | int))
-static_assert(is_subtype_of(B1 | bool, int | A))
-
-static_assert(not is_subtype_of(B1 | bool, Unrelated1 | int))
-static_assert(not is_subtype_of(B1 | bool, int | Unrelated1))
-
-# Example: Unions of literals
-static_assert(is_subtype_of(Literal[1, 2, 3], int))
-static_assert(not is_subtype_of(Literal[1, "two", 3], int))
-```
-
-## Intersection types
-
-```py
-from typing_extensions import Literal, LiteralString
-from knot_extensions import Intersection, Not, is_subtype_of, static_assert
-
-class A: ...
-class B1(A): ...
-class B2(A): ...
-class C(B1, B2): ...
-class Unrelated: ...
-
-static_assert(is_subtype_of(B1, A))
-static_assert(is_subtype_of(B2, A))
-static_assert(is_subtype_of(C, A))
-static_assert(is_subtype_of(C, B1))
-static_assert(is_subtype_of(C, B2))
-
-# For complements, the subtyping relation is reversed:
-static_assert(is_subtype_of(Not[A], Not[B1]))
-static_assert(is_subtype_of(Not[A], Not[B2]))
-static_assert(is_subtype_of(Not[A], Not[C]))
-static_assert(is_subtype_of(Not[B1], Not[C]))
-static_assert(is_subtype_of(Not[B2], Not[C]))
-
-# The intersection of two types is a subtype of both:
-static_assert(is_subtype_of(Intersection[B1, B2], B1))
-static_assert(is_subtype_of(Intersection[B1, B2], B2))
-# … and of their common supertype:
-static_assert(is_subtype_of(Intersection[B1, B2], A))
-
-# A common subtype of two types is a subtype of their intersection:
-static_assert(is_subtype_of(C, Intersection[B1, B2]))
-# … but not the other way around:
-static_assert(not is_subtype_of(Intersection[B1, B2], C))
-
-# "Removing" B1 from A leaves a subtype of A.
-static_assert(is_subtype_of(Intersection[A, Not[B1]], A))
-static_assert(is_subtype_of(Intersection[A, Not[B1]], Not[B1]))
-
-# B1 and B2 are not disjoint, so this is not true:
-static_assert(not is_subtype_of(B2, Intersection[A, Not[B1]]))
-# … but for two disjoint subtypes, it is:
-static_assert(is_subtype_of(Literal[2], Intersection[int, Not[Literal[1]]]))
-
-# A and Unrelated are not related, so this is not true:
-static_assert(not is_subtype_of(Intersection[A, Not[B1]], Not[Unrelated]))
-# … but for a disjoint type like `None`, it is:
-static_assert(is_subtype_of(Intersection[A, Not[B1]], Not[None]))
-
-# Complements of types are still subtypes of `object`:
-static_assert(is_subtype_of(Not[A], object))
-
-# More examples:
-static_assert(is_subtype_of(type[str], Not[None]))
-static_assert(is_subtype_of(Not[LiteralString], object))
-
-static_assert(not is_subtype_of(Intersection[int, Not[Literal[2]]], Intersection[int, Not[Literal[3]]]))
-static_assert(not is_subtype_of(Not[Literal[2]], Not[Literal[3]]))
-static_assert(not is_subtype_of(Not[Literal[2]], Not[int]))
-static_assert(not is_subtype_of(int, Not[Literal[3]]))
-static_assert(not is_subtype_of(Literal[1], Intersection[int, Not[Literal[1]]]))
-```
-
-## Special types
-
-### `Never`
-
-`Never` is a subtype of all types.
-
-```py
-from typing_extensions import Literal, Never
-from knot_extensions import AlwaysTruthy, AlwaysFalsy, is_subtype_of, static_assert
-
-static_assert(is_subtype_of(Never, Never))
-static_assert(is_subtype_of(Never, Literal[True]))
-static_assert(is_subtype_of(Never, bool))
-static_assert(is_subtype_of(Never, int))
-static_assert(is_subtype_of(Never, object))
-
-static_assert(is_subtype_of(Never, AlwaysTruthy))
-static_assert(is_subtype_of(Never, AlwaysFalsy))
-```
-
-### `AlwaysTruthy` and `AlwaysFalsy`
-
-```py
-from knot_extensions import AlwaysTruthy, AlwaysFalsy, is_subtype_of, static_assert
-
-static_assert(is_subtype_of(Literal[1], AlwaysTruthy))
-static_assert(is_subtype_of(Literal[0], AlwaysFalsy))
-
-static_assert(is_subtype_of(AlwaysTruthy, object))
-static_assert(is_subtype_of(AlwaysFalsy, object))
-
-static_assert(not is_subtype_of(Literal[1], AlwaysFalsy))
-static_assert(not is_subtype_of(Literal[0], AlwaysTruthy))
-
-static_assert(not is_subtype_of(str, AlwaysTruthy))
-static_assert(not is_subtype_of(str, AlwaysFalsy))
-```
-
-### Module literals
-
-```py
-from types import ModuleType
-from knot_extensions import TypeOf, is_subtype_of, static_assert
-from typing_extensions import assert_type
-import typing
-
-assert_type(typing, TypeOf[typing])
-
-static_assert(is_subtype_of(TypeOf[typing], ModuleType))
-```
-
-### Slice literals
-
-```py
-from knot_extensions import TypeOf, is_subtype_of, static_assert
-
-static_assert(is_subtype_of(TypeOf[1:2:3], slice))
-```
-
-### Special forms
-
-```py
-from typing import _SpecialForm
-from knot_extensions import TypeOf, is_subtype_of, static_assert
-
-static_assert(is_subtype_of(TypeOf[Literal], _SpecialForm))
-static_assert(is_subtype_of(TypeOf[Literal], object))
-
-static_assert(not is_subtype_of(_SpecialForm, TypeOf[Literal]))
-```
-
-## Class literal types and `type[…]`
-
-### Basic
-
-```py
-from typing import _SpecialForm
-from typing_extensions import Literal, assert_type
-from knot_extensions import TypeOf, is_subtype_of, static_assert
-
-class Meta(type): ...
-class HasCustomMetaclass(metaclass=Meta): ...
-
-type LiteralBool = TypeOf[bool]
-type LiteralInt = TypeOf[int]
-type LiteralStr = TypeOf[str]
-type LiteralObject = TypeOf[object]
-
-assert_type(bool, LiteralBool)
-assert_type(int, LiteralInt)
-assert_type(str, LiteralStr)
-assert_type(object, LiteralObject)
-
-# bool
-
-static_assert(is_subtype_of(LiteralBool, LiteralBool))
-static_assert(is_subtype_of(LiteralBool, type[bool]))
-static_assert(is_subtype_of(LiteralBool, type[int]))
-static_assert(is_subtype_of(LiteralBool, type[object]))
-static_assert(is_subtype_of(LiteralBool, type))
-static_assert(is_subtype_of(LiteralBool, object))
-
-static_assert(not is_subtype_of(LiteralBool, LiteralInt))
-static_assert(not is_subtype_of(LiteralBool, LiteralObject))
-static_assert(not is_subtype_of(LiteralBool, bool))
-
-static_assert(not is_subtype_of(type, type[bool]))
-
-# int
-
-static_assert(is_subtype_of(LiteralInt, LiteralInt))
-static_assert(is_subtype_of(LiteralInt, type[int]))
-static_assert(is_subtype_of(LiteralInt, type[object]))
-static_assert(is_subtype_of(LiteralInt, type))
-static_assert(is_subtype_of(LiteralInt, object))
-
-static_assert(not is_subtype_of(LiteralInt, LiteralObject))
-static_assert(not is_subtype_of(LiteralInt, int))
-
-static_assert(not is_subtype_of(type, type[int]))
-
-# LiteralString
-
-static_assert(is_subtype_of(LiteralStr, type[str]))
-static_assert(is_subtype_of(LiteralStr, type))
-static_assert(is_subtype_of(LiteralStr, type[object]))
-
-static_assert(not is_subtype_of(type[str], LiteralStr))
-
-# custom meta classes
-
-type LiteralHasCustomMetaclass = TypeOf[HasCustomMetaclass]
-
-static_assert(is_subtype_of(LiteralHasCustomMetaclass, Meta))
-static_assert(is_subtype_of(Meta, type[object]))
-static_assert(is_subtype_of(Meta, type))
-
-static_assert(not is_subtype_of(Meta, type[type]))
-```
-
-### Unions of class literals
-
-```py
-from typing_extensions import assert_type
-from knot_extensions import TypeOf, is_subtype_of, static_assert
-
-class Base: ...
-class Derived(Base): ...
-class Unrelated: ...
-
-type LiteralBase = TypeOf[Base]
-type LiteralDerived = TypeOf[Derived]
-type LiteralUnrelated = TypeOf[Unrelated]
-
-assert_type(Base, LiteralBase)
-assert_type(Derived, LiteralDerived)
-assert_type(Unrelated, LiteralUnrelated)
-
-static_assert(is_subtype_of(LiteralBase, type))
-static_assert(is_subtype_of(LiteralBase, object))
-
-static_assert(is_subtype_of(LiteralBase, type[Base]))
-static_assert(is_subtype_of(LiteralDerived, type[Base]))
-static_assert(is_subtype_of(LiteralDerived, type[Derived]))
-
-static_assert(not is_subtype_of(LiteralBase, type[Derived]))
-static_assert(is_subtype_of(type[Derived], type[Base]))
-
-static_assert(is_subtype_of(LiteralBase | LiteralUnrelated, type))
-static_assert(is_subtype_of(LiteralBase | LiteralUnrelated, object))
-```
-
-## Non-fully-static types
-
-`Any`, `Unknown`, `Todo` and derivatives thereof do not participate in subtyping.
-
-```py
-from knot_extensions import Unknown, is_subtype_of, static_assert, Intersection
-from typing_extensions import Any
-
-static_assert(not is_subtype_of(Any, Any))
-static_assert(not is_subtype_of(Any, int))
-static_assert(not is_subtype_of(int, Any))
-static_assert(not is_subtype_of(Any, object))
-static_assert(not is_subtype_of(object, Any))
-
-static_assert(not is_subtype_of(int, Any | int))
-static_assert(not is_subtype_of(Intersection[Any, int], int))
-static_assert(not is_subtype_of(tuple[int, int], tuple[int, Any]))
-
-# The same for `Unknown`:
-static_assert(not is_subtype_of(Unknown, Unknown))
-static_assert(not is_subtype_of(Unknown, int))
-static_assert(not is_subtype_of(int, Unknown))
-static_assert(not is_subtype_of(Unknown, object))
-static_assert(not is_subtype_of(object, Unknown))
-
-static_assert(not is_subtype_of(int, Unknown | int))
-static_assert(not is_subtype_of(Intersection[Unknown, int], int))
-static_assert(not is_subtype_of(tuple[int, int], tuple[int, Unknown]))
-```
-
-[special case for float and complex]: https://typing.readthedocs.io/en/latest/spec/special-types.html#special-cases-for-float-and-complex
-[typing documentation]: https://typing.readthedocs.io/en/latest/spec/concepts.html#subtype-supertype-and-type-equivalence

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

@@ -1,33 +0,0 @@
-# Tuples containing `Never`
-
-A heterogeneous `tuple[…]` type that contains `Never` as a type argument simplifies to `Never`. One
-way to think about this is the following: in order to construct a tuple, you need to have an object
-of every element type. But since there is no object of type `Never`, you cannot construct the tuple.
-Such a tuple type is therefore uninhabited and equivalent to `Never`.
-
-In the language of algebraic data types, a tuple type is a product type and `Never` acts like the
-zero element in multiplication, similar to how a Cartesian product with the empty set is the empty
-set.
-
-```py
-from knot_extensions import static_assert, is_equivalent_to
-from typing_extensions import Never, NoReturn
-
-static_assert(is_equivalent_to(Never, tuple[Never]))
-static_assert(is_equivalent_to(Never, tuple[Never, int]))
-static_assert(is_equivalent_to(Never, tuple[int, Never]))
-static_assert(is_equivalent_to(Never, tuple[int, Never, str]))
-static_assert(is_equivalent_to(Never, tuple[int, tuple[str, Never]]))
-static_assert(is_equivalent_to(Never, tuple[tuple[str, Never], int]))
-
-# The empty tuple is *not* equivalent to Never!
-static_assert(not is_equivalent_to(Never, tuple[()]))
-
-# NoReturn is just a different spelling of Never, so the same is true for NoReturn
-static_assert(is_equivalent_to(NoReturn, tuple[NoReturn]))
-static_assert(is_equivalent_to(NoReturn, tuple[NoReturn, int]))
-static_assert(is_equivalent_to(NoReturn, tuple[int, NoReturn]))
-static_assert(is_equivalent_to(NoReturn, tuple[int, NoReturn, str]))
-static_assert(is_equivalent_to(NoReturn, tuple[int, tuple[str, NoReturn]]))
-static_assert(is_equivalent_to(NoReturn, tuple[tuple[str, NoReturn], int]))
-```

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

@@ -34,10 +34,6 @@ 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:

crates/red_knot_python_semantic/resources/mdtest/union_types.md

@@ -1,143 +0,0 @@
-# Union types
-
-This test suite covers certain basic properties and simplification strategies for union types.
-
-## Basic unions
-
-```py
-from typing import Literal
-
-def _(u1: int | str, u2: Literal[0] | Literal[1]) -> None:
-    reveal_type(u1)  # revealed: int | str
-    reveal_type(u2)  # revealed: Literal[0, 1]
-```
-
-## Duplicate elements are collapsed
-
-```py
-def _(u1: int | int | str, u2: int | str | int) -> None:
-    reveal_type(u1)  # revealed: int | str
-    reveal_type(u2)  # revealed: int | str
-```
-
-## `Never` is removed
-
-`Never` is an empty set, a type with no inhabitants. Its presence in a union is always redundant,
-and so we eagerly simplify it away. `NoReturn` is equivalent to `Never`.
-
-```py
-from typing_extensions import Never, NoReturn
-
-def never(u1: int | Never, u2: int | Never | str) -> None:
-    reveal_type(u1)  # revealed: int
-    reveal_type(u2)  # revealed:  int | str
-
-def noreturn(u1: int | NoReturn, u2: int | NoReturn | str) -> None:
-    reveal_type(u1)  # revealed: int
-    reveal_type(u2)  # revealed:  int | str
-```
-
-## Flattening of nested unions
-
-```py
-from typing import Literal
-
-def _(
-    u1: (int | str) | bytes,
-    u2: int | (str | bytes),
-    u3: int | (str | (bytes | complex)),
-) -> None:
-    reveal_type(u1)  # revealed: int | str | bytes
-    reveal_type(u2)  # revealed: int | str | bytes
-    reveal_type(u3)  # revealed: int | str | bytes | complex
-```
-
-## Simplification using subtyping
-
-The type `S | T` can be simplified to `T` if `S` is a subtype of `T`:
-
-```py
-from typing_extensions import Literal, LiteralString
-
-def _(
-    u1: str | LiteralString, u2: LiteralString | str, u3: Literal["a"] | str | LiteralString, u4: str | bytes | LiteralString
-) -> None:
-    reveal_type(u1)  # revealed: str
-    reveal_type(u2)  # revealed: str
-    reveal_type(u3)  # revealed: str
-    reveal_type(u4)  # revealed: str | bytes
-```
-
-## Boolean literals
-
-The union `Literal[True] | Literal[False]` is exactly equivalent to `bool`:
-
-```py
-from typing import Literal
-
-def _(
-    u1: Literal[True, False],
-    u2: bool | Literal[True],
-    u3: Literal[True] | bool,
-    u4: Literal[True] | Literal[True, 17],
-    u5: Literal[True, False, True, 17],
-) -> None:
-    reveal_type(u1)  # revealed: bool
-    reveal_type(u2)  # revealed: bool
-    reveal_type(u3)  # revealed: bool
-    reveal_type(u4)  # revealed: Literal[True, 17]
-    reveal_type(u5)  # revealed: bool | Literal[17]
-```
-
-## Do not erase `Unknown`
-
-```py
-from knot_extensions import Unknown
-
-def _(u1: Unknown | str, u2: str | Unknown) -> None:
-    reveal_type(u1)  # revealed: Unknown | str
-    reveal_type(u2)  # revealed: str | Unknown
-```
-
-## Collapse multiple `Unknown`s
-
-Since `Unknown` is a gradual type, it is not a subtype of anything, but multiple `Unknown`s in a
-union are still redundant:
-
-```py
-from knot_extensions import Unknown
-
-def _(u1: Unknown | Unknown | str, u2: Unknown | str | Unknown, u3: str | Unknown | Unknown) -> None:
-    reveal_type(u1)  # revealed: Unknown | str
-    reveal_type(u2)  # revealed: Unknown | str
-    reveal_type(u3)  # revealed: str | Unknown
-```
-
-## Subsume multiple elements
-
-Simplifications still apply when `Unknown` is present.
-
-```py
-from knot_extensions import Unknown
-
-def _(u1: str | Unknown | int | object):
-    reveal_type(u1)  # revealed: Unknown | object
-```
-
-## Union of intersections
-
-We can simplify unions of intersections:
-
-```py
-from knot_extensions import Intersection, Not
-
-class P: ...
-class Q: ...
-
-def _(
-    i1: Intersection[P, Q] | Intersection[P, Q],
-    i2: Intersection[P, Q] | Intersection[Q, P],
-) -> None:
-    reveal_type(i1)  # revealed: P & Q
-    reveal_type(i2)  # revealed: P & Q
-```

crates/red_knot_python_semantic/resources/mdtest/unpacking.md

@@ -426,8 +426,8 @@ def _(flag: bool):
         value = ("a", "b")
 
     a, b = value
-    reveal_type(a)  # revealed: Literal[1, "a"]
-    reveal_type(b)  # revealed: Literal[2, "b"]
+    reveal_type(a)  # revealed: Literal[1] | Literal["a"]
+    reveal_type(b)  # revealed: Literal[2] | Literal["b"]
 ```
 
 ### Typing literal
@@ -528,8 +528,8 @@ for a, b in ((1, 2), (3, 4)):
 
 ```py
 for a, b in ((1, 2), ("a", "b")):
-    reveal_type(a)  # revealed: Literal[1, "a"]
-    reveal_type(b)  # revealed: Literal[2, "b"]
+    reveal_type(a)  # revealed: Literal[1] | Literal["a"]
+    reveal_type(b)  # revealed: Literal[2] | Literal["b"]
 ```
 
 ### Mixed literals values (2)

crates/red_knot_python_semantic/src/db.rs

@@ -180,7 +180,7 @@ pub(crate) mod tests {
 
             Program::from_settings(
                 &db,
-                ProgramSettings {
+                &ProgramSettings {
                     python_version: self.python_version,
                     python_platform: self.python_platform,
                     search_paths,

crates/red_knot_python_semantic/src/module_resolver/module.rs

@@ -109,7 +109,6 @@ pub enum KnownModule {
     #[allow(dead_code)]
     Abc, // currently only used in tests
     Collections,
-    KnotExtensions,
 }
 
 impl KnownModule {
@@ -123,7 +122,6 @@ impl KnownModule {
             Self::Sys => "sys",
             Self::Abc => "abc",
             Self::Collections => "collections",
-            Self::KnotExtensions => "knot_extensions",
         }
     }
 
@@ -149,20 +147,11 @@ impl KnownModule {
             "sys" => Some(Self::Sys),
             "abc" => Some(Self::Abc),
             "collections" => Some(Self::Collections),
-            "knot_extensions" => Some(Self::KnotExtensions),
             _ => None,
         }
     }
 
-    pub const fn is_builtins(self) -> bool {
-        matches!(self, Self::Builtins)
-    }
-
     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

@@ -1294,7 +1294,7 @@ mod tests {
 
         Program::from_settings(
             &db,
-            ProgramSettings {
+            &ProgramSettings {
                 python_version: PythonVersion::PY38,
                 python_platform: PythonPlatform::default(),
                 search_paths: SearchPathSettings {
@@ -1800,7 +1800,7 @@ not_a_directory
 
         Program::from_settings(
             &db,
-            ProgramSettings {
+            &ProgramSettings {
                 python_version: PythonVersion::default(),
                 python_platform: PythonPlatform::default(),
                 search_paths: SearchPathSettings {

crates/red_knot_python_semantic/src/module_resolver/testing.rs

@@ -232,7 +232,7 @@ impl TestCaseBuilder<MockedTypeshed> {
 
         Program::from_settings(
             &db,
-            ProgramSettings {
+            &ProgramSettings {
                 python_version,
                 python_platform,
                 search_paths: SearchPathSettings {
@@ -290,7 +290,7 @@ impl TestCaseBuilder<VendoredTypeshed> {
 
         Program::from_settings(
             &db,
-            ProgramSettings {
+            &ProgramSettings {
                 python_version,
                 python_platform,
                 search_paths: SearchPathSettings {

crates/red_knot_python_semantic/src/program.rs

@@ -1,18 +1,18 @@
-use crate::module_resolver::SearchPaths;
 use crate::python_platform::PythonPlatform;
 use crate::python_version::PythonVersion;
-use crate::Db;
-
 use anyhow::Context;
-use ruff_db::system::{SystemPath, SystemPathBuf};
 use salsa::Durability;
 use salsa::Setter;
 
+use ruff_db::system::{SystemPath, SystemPathBuf};
+
+use crate::module_resolver::SearchPaths;
+use crate::Db;
+
 #[salsa::input(singleton)]
 pub struct Program {
     pub python_version: PythonVersion,
 
-    #[return_ref]
     pub python_platform: PythonPlatform,
 
     #[return_ref]
@@ -20,51 +20,25 @@ pub struct Program {
 }
 
 impl Program {
-    pub fn from_settings(db: &dyn Db, settings: ProgramSettings) -> anyhow::Result<Self> {
+    pub fn from_settings(db: &dyn Db, settings: &ProgramSettings) -> anyhow::Result<Self> {
         let ProgramSettings {
             python_version,
             python_platform,
             search_paths,
         } = settings;
 
-        tracing::info!("Python version: Python {python_version}, platform: {python_platform}");
+        tracing::info!("Python version: Python {python_version}");
 
-        let search_paths = SearchPaths::from_settings(db, &search_paths)
+        let search_paths = SearchPaths::from_settings(db, search_paths)
             .with_context(|| "Invalid search path settings")?;
 
         Ok(
-            Program::builder(python_version, python_platform, search_paths)
+            Program::builder(*python_version, python_platform.clone(), search_paths)
                 .durability(Durability::HIGH)
                 .new(db),
         )
     }
 
-    pub fn update_from_settings(
-        self,
-        db: &mut dyn Db,
-        settings: ProgramSettings,
-    ) -> anyhow::Result<()> {
-        let ProgramSettings {
-            python_version,
-            python_platform,
-            search_paths,
-        } = settings;
-
-        if &python_platform != self.python_platform(db) {
-            tracing::debug!("Updating python platform: `{python_platform:?}`");
-            self.set_python_platform(db).to(python_platform);
-        }
-
-        if python_version != self.python_version(db) {
-            tracing::debug!("Updating python version: Python {python_version}");
-            self.set_python_version(db).to(python_version);
-        }
-
-        self.update_search_paths(db, &search_paths)?;
-
-        Ok(())
-    }
-
     pub fn update_search_paths(
         self,
         db: &mut dyn Db,
@@ -102,7 +76,7 @@ pub struct SearchPathSettings {
     /// or pyright's stubPath configuration setting.
     pub extra_paths: Vec<SystemPathBuf>,
 
-    /// The root of the project, used for finding first-party modules.
+    /// The root of the workspace, used for finding first-party modules.
     pub src_root: SystemPathBuf,
 
     /// Optional path to a "custom typeshed" directory on disk for us to use for standard-library types.

crates/red_knot_python_semantic/src/python_platform.rs

@@ -1,5 +1,3 @@
-use std::fmt::{Display, Formatter};
-
 /// The target platform to assume when resolving types.
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 #[cfg_attr(
@@ -19,12 +17,3 @@ pub enum PythonPlatform {
     #[cfg_attr(feature = "serde", serde(untagged))]
     Identifier(String),
 }
-
-impl Display for PythonPlatform {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            PythonPlatform::All => f.write_str("all"),
-            PythonPlatform::Identifier(name) => f.write_str(name),
-        }
-    }
-}

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -404,17 +404,6 @@ impl<'db> SemanticIndexBuilder<'db> {
         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 {
@@ -425,10 +414,6 @@ impl<'db> SemanticIndexBuilder<'db> {
             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,
         };
 
@@ -893,11 +878,12 @@ 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 visibility_constraint_id = self.record_visibility_constraint(constraint);
                 let mut vis_constraints = vec![visibility_constraint_id];
 
                 let mut post_clauses: Vec<FlowSnapshot> = vec![];
@@ -921,27 +907,26 @@ 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);
+                    // 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);
+                    }
 
                     let elif_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);
+                        constraints.push(constraint);
                         Some(constraint)
                     } else {
                         None
                     };
-
                     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);
                     }
@@ -951,7 +936,7 @@ where
                     self.flow_merge(post_clause_state);
                 }
 
-                self.simplify_visibility_constraints(no_branch_taken);
+                self.simplify_visibility_constraints(pre_if);
             }
             ast::Stmt::While(ast::StmtWhile {
                 test,
@@ -1104,35 +1089,37 @@ where
                 cases,
                 range: _,
             }) => {
-                debug_assert_eq!(self.current_match_case, None);
-
                 let subject_expr = self.add_standalone_expression(subject);
                 self.visit_expr(subject);
-                if cases.is_empty() {
+
+                let after_subject = self.flow_snapshot();
+                let Some((first, remaining)) = cases.split_first() else {
                     return;
                 };
 
-                let after_subject = self.flow_snapshot();
-                let mut vis_constraints = vec![];
-                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());
-                    }
+                let first_constraint_id = self.add_pattern_constraint(
+                    subject_expr,
+                    &first.pattern,
+                    first.guard.as_deref(),
+                );
 
-                    self.current_match_case = Some(CurrentMatchCase::new(&case.pattern));
-                    self.visit_pattern(&case.pattern);
-                    self.current_match_case = None;
+                self.visit_match_case(first);
+
+                let first_vis_constraint_id =
+                    self.record_visibility_constraint(first_constraint_id);
+                let mut vis_constraints = vec![first_vis_constraint_id];
+
+                let mut post_case_snapshots = vec![];
+                for case in remaining {
+                    post_case_snapshots.push(self.flow_snapshot());
+                    self.flow_restore(after_subject.clone());
                     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);
+                    self.visit_match_case(case);
+
                     for id in &vis_constraints {
                         self.record_negated_visibility_constraint(*id);
                     }
@@ -1551,6 +1538,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),
@@ -1637,7 +1636,6 @@ impl<'a> From<&'a ast::ExprNamed> for CurrentAssignment<'a> {
     }
 }
 
-#[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

@@ -22,7 +22,6 @@ pub(crate) enum ConstraintNode<'db> {
 pub(crate) enum PatternConstraintKind<'db> {
     Singleton(Singleton, Option<Expression<'db>>),
     Value(Expression<'db>, Option<Expression<'db>>),
-    Class(Expression<'db>, Option<Expression<'db>>),
     Unsupported,
 }
 

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -4,10 +4,11 @@ use ruff_python_ast as ast;
 use ruff_text_size::{Ranged, TextRange};
 
 use crate::ast_node_ref::AstNodeRef;
+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;
+use crate::{Db, KnownModule};
 
 /// A definition of a symbol.
 ///
@@ -60,6 +61,19 @@ impl<'db> Definition<'db> {
     pub(crate) fn is_binding(self, db: &'db dyn Db) -> bool {
         self.kind(db).category().is_binding()
     }
+
+    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))
+    }
+
+    /// 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)
+        )
+    }
 }
 
 #[derive(Copy, Clone, Debug)]

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

@@ -93,19 +93,6 @@ 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();
@@ -235,59 +222,6 @@ 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);

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

@@ -316,9 +316,6 @@ impl SymbolState {
         };
 
         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();
@@ -452,8 +449,10 @@ impl SymbolState {
         let mut opt_a_decl: Option<u32> = a_decls_iter.next();
         let mut opt_b_decl: Option<u32> = b_decls_iter.next();
 
-        let push = |vis_constraints_iter: &mut VisibilityConstraintsIntoIterator,
+        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");
@@ -467,15 +466,15 @@ impl SymbolState {
             match (opt_a_decl, opt_b_decl) {
                 (Some(a_decl), Some(b_decl)) => match a_decl.cmp(&b_decl) {
                     std::cmp::Ordering::Less => {
-                        push(&mut a_vis_constraints_iter, self);
+                        push(a_decl, &mut a_vis_constraints_iter, self);
                         opt_a_decl = a_decls_iter.next();
                     }
                     std::cmp::Ordering::Greater => {
-                        push(&mut b_vis_constraints_iter, self);
+                        push(b_decl, &mut b_vis_constraints_iter, self);
                         opt_b_decl = b_decls_iter.next();
                     }
                     std::cmp::Ordering::Equal => {
-                        push(&mut b_vis_constraints_iter, self);
+                        push(a_decl, &mut b_vis_constraints_iter, self);
 
                         let a_vis_constraint = a_vis_constraints_iter
                             .next()
@@ -488,12 +487,12 @@ impl SymbolState {
                         opt_b_decl = b_decls_iter.next();
                     }
                 },
-                (Some(_), None) => {
-                    push(&mut a_vis_constraints_iter, self);
+                (Some(a_decl), None) => {
+                    push(a_decl, &mut a_vis_constraints_iter, self);
                     opt_a_decl = a_decls_iter.next();
                 }
-                (None, Some(_)) => {
-                    push(&mut b_vis_constraints_iter, self);
+                (None, Some(b_decl)) => {
+                    push(b_decl, &mut b_vis_constraints_iter, self);
                     opt_b_decl = b_decls_iter.next();
                 }
                 (None, None) => break,

crates/red_knot_python_semantic/src/types/call.rs

@@ -1,32 +1,17 @@
 use super::context::InferContext;
-use super::diagnostic::{CALL_NON_CALLABLE, TYPE_ASSERTION_FAILURE};
-use super::{Severity, Signature, Type, TypeArrayDisplay, UnionBuilder};
-use crate::types::diagnostic::STATIC_ASSERT_ERROR;
+use super::diagnostic::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,20 +25,12 @@ pub(super) enum CallOutcome<'db> {
         called_ty: Type<'db>,
         call_outcome: Box<CallOutcome<'db>>,
     },
-    StaticAssertionError {
-        binding: CallBinding<'db>,
-        error_kind: StaticAssertionErrorKind<'db>,
-    },
-    AssertType {
-        binding: CallBinding<'db>,
-        asserted_ty: Type<'db>,
-    },
 }
 
 impl<'db> CallOutcome<'db> {
-    /// Create a new `CallOutcome::Callable` with given binding.
-    pub(super) fn callable(binding: CallBinding<'db>) -> CallOutcome<'db> {
-        CallOutcome::Callable { binding }
+    /// Create a new `CallOutcome::Callable` with given return type.
+    pub(super) fn callable(return_ty: Type<'db>) -> CallOutcome<'db> {
+        CallOutcome::Callable { return_ty }
     }
 
     /// Create a new `CallOutcome::NotCallable` with given not-callable type.
@@ -62,9 +39,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,
         }
     }
@@ -80,22 +57,14 @@ impl<'db> CallOutcome<'db> {
         }
     }
 
-    /// Create a new `CallOutcome::AssertType` with given asserted and return types.
-    pub(super) fn asserted(binding: CallBinding<'db>, asserted_ty: Type<'db>) -> CallOutcome<'db> {
-        CallOutcome::AssertType {
-            binding,
-            asserted_ty,
-        }
-    }
-
     /// 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,
@@ -109,16 +78,11 @@ impl<'db> CallOutcome<'db> {
                     match (acc, ty) {
                         (None, None) => None,
                         (None, Some(ty)) => Some(UnionBuilder::new(db).add(ty)),
-                        (Some(builder), ty) => Some(builder.add(ty.unwrap_or(Type::unknown()))),
+                        (Some(builder), ty) => Some(builder.add(ty.unwrap_or(Type::Unknown))),
                     }
                 })
                 .map(UnionBuilder::build),
             Self::PossiblyUnboundDunderCall { call_outcome, .. } => call_outcome.return_ty(db),
-            Self::StaticAssertionError { .. } => Some(Type::none(db)),
-            Self::AssertType {
-                binding,
-                asserted_ty: _,
-            } => Some(binding.return_ty()),
         }
     }
 
@@ -199,30 +163,23 @@ impl<'db> CallOutcome<'db> {
         context: &InferContext<'db>,
         node: ast::AnyNodeRef,
     ) -> 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(
                     node,
                     DiagnosticId::RevealedType,
                     Severity::Info,
                     format_args!("Revealed type is `{}`", revealed_ty.display(context.db())),
                 );
-                Ok(binding.return_ty())
+                Ok(*return_ty)
             }
             Self::NotCallable { not_callable_ty } => Err(NotCallableError::Type {
                 not_callable_ty: *not_callable_ty,
-                return_ty: Type::unknown(),
+                return_ty: Type::Unknown,
             }),
             Self::PossiblyUnboundDunderCall {
                 called_ty,
@@ -231,7 +188,7 @@ impl<'db> CallOutcome<'db> {
                 callable_ty: *called_ty,
                 return_ty: call_outcome
                     .return_ty(context.db())
-                    .unwrap_or(Type::unknown()),
+                    .unwrap_or(Type::Unknown),
             }),
             Self::Union {
                 outcomes,
@@ -244,14 +201,14 @@ impl<'db> CallOutcome<'db> {
                     let return_ty = match outcome {
                         Self::NotCallable { not_callable_ty } => {
                             not_callable.push(*not_callable_ty);
-                            Type::unknown()
+                            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)
@@ -280,73 +237,6 @@ impl<'db> CallOutcome<'db> {
                     }),
                 }
             }
-            Self::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())
-            }
-            Self::AssertType {
-                binding,
-                asserted_ty,
-            } => {
-                let [actual_ty, _asserted] = binding.parameter_tys() else {
-                    return Ok(binding.return_ty());
-                };
-
-                if !actual_ty.is_gradual_equivalent_to(context.db(), *asserted_ty) {
-                    context.report_lint(
-                        &TYPE_ASSERTION_FAILURE,
-                        node,
-                        format_args!(
-                            "Actual type `{}` is not the same as asserted type `{}`",
-                            actual_ty.display(context.db()),
-                            asserted_ty.display(context.db()),
-                        ),
-                    );
-                }
-
-                Ok(binding.return_ty())
-            }
         }
     }
 }

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() || parameter.is_keyword_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

@@ -1,5 +1,5 @@
 use crate::types::{
-    todo_type, Class, ClassLiteralType, DynamicType, KnownClass, KnownInstanceType, Type,
+    todo_type, Class, ClassLiteralType, KnownClass, KnownInstanceType, TodoType, Type,
 };
 use crate::Db;
 use itertools::Either;
@@ -8,29 +8,16 @@ use itertools::Either;
 ///
 /// This is much more limited than the [`Type`] enum:
 /// all types that would be invalid to have as a class base are
-/// transformed into [`ClassBase::unknown`]
+/// transformed into [`ClassBase::Unknown`]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, salsa::Update)]
 pub enum ClassBase<'db> {
-    Dynamic(DynamicType),
+    Any,
+    Unknown,
+    Todo(TodoType),
     Class(Class<'db>),
 }
 
 impl<'db> ClassBase<'db> {
-    pub const fn any() -> Self {
-        Self::Dynamic(DynamicType::Any)
-    }
-
-    pub const fn unknown() -> Self {
-        Self::Dynamic(DynamicType::Unknown)
-    }
-
-    pub const fn is_dynamic(self) -> bool {
-        match self {
-            ClassBase::Dynamic(_) => true,
-            ClassBase::Class(_) => false,
-        }
-    }
-
     pub fn display(self, db: &'db dyn Db) -> impl std::fmt::Display + 'db {
         struct Display<'db> {
             base: ClassBase<'db>,
@@ -40,7 +27,9 @@ impl<'db> ClassBase<'db> {
         impl std::fmt::Display for Display<'_> {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 match self.base {
-                    ClassBase::Dynamic(dynamic) => dynamic.fmt(f),
+                    ClassBase::Any => f.write_str("Any"),
+                    ClassBase::Todo(todo) => todo.fmt(f),
+                    ClassBase::Unknown => f.write_str("Unknown"),
                     ClassBase::Class(class) => write!(f, "<class '{}'>", class.name(self.db)),
                 }
             }
@@ -54,7 +43,7 @@ impl<'db> ClassBase<'db> {
         KnownClass::Object
             .to_class_literal(db)
             .into_class_literal()
-            .map_or(Self::unknown(), |ClassLiteralType { class }| {
+            .map_or(Self::Unknown, |ClassLiteralType { class }| {
                 Self::Class(class)
             })
     }
@@ -64,7 +53,9 @@ impl<'db> ClassBase<'db> {
     /// Return `None` if `ty` is not an acceptable type for a class base.
     pub(super) fn try_from_ty(db: &'db dyn Db, ty: Type<'db>) -> Option<Self> {
         match ty {
-            Type::Dynamic(dynamic) => Some(Self::Dynamic(dynamic)),
+            Type::Any => Some(Self::Any),
+            Type::Unknown => Some(Self::Unknown),
+            Type::Todo(todo) => Some(Self::Todo(todo)),
             Type::ClassLiteral(ClassLiteralType { class }) => Some(Self::Class(class)),
             Type::Union(_) => None, // TODO -- forces consideration of multiple possible MROs?
             Type::Intersection(_) => None, // TODO -- probably incorrect?
@@ -102,14 +93,8 @@ impl<'db> ClassBase<'db> {
                 | KnownInstanceType::Required
                 | KnownInstanceType::TypeAlias
                 | KnownInstanceType::ReadOnly
-                | KnownInstanceType::Optional
-                | KnownInstanceType::Not
-                | KnownInstanceType::Intersection
-                | KnownInstanceType::TypeOf
-                | KnownInstanceType::AlwaysTruthy
-                | KnownInstanceType::AlwaysFalsy => None,
-                KnownInstanceType::Unknown => Some(Self::unknown()),
-                KnownInstanceType::Any => Some(Self::any()),
+                | KnownInstanceType::Optional => None,
+                KnownInstanceType::Any => Some(Self::Any),
                 // TODO: Classes inheriting from `typing.Type` et al. also have `Generic` in their MRO
                 KnownInstanceType::Dict => {
                     Self::try_from_ty(db, KnownClass::Dict.to_class_literal(db))
@@ -154,7 +139,7 @@ impl<'db> ClassBase<'db> {
     pub(super) fn into_class(self) -> Option<Class<'db>> {
         match self {
             Self::Class(class) => Some(class),
-            Self::Dynamic(_) => None,
+            _ => None,
         }
     }
 
@@ -164,7 +149,13 @@ impl<'db> ClassBase<'db> {
         db: &'db dyn Db,
     ) -> Either<impl Iterator<Item = ClassBase<'db>>, impl Iterator<Item = ClassBase<'db>>> {
         match self {
-            ClassBase::Dynamic(_) => Either::Left([self, ClassBase::object(db)].into_iter()),
+            ClassBase::Any => Either::Left([ClassBase::Any, ClassBase::object(db)].into_iter()),
+            ClassBase::Unknown => {
+                Either::Left([ClassBase::Unknown, ClassBase::object(db)].into_iter())
+            }
+            ClassBase::Todo(todo) => {
+                Either::Left([ClassBase::Todo(todo), ClassBase::object(db)].into_iter())
+            }
             ClassBase::Class(class) => Either::Right(class.iter_mro(db)),
         }
     }
@@ -179,7 +170,9 @@ impl<'db> From<Class<'db>> for ClassBase<'db> {
 impl<'db> From<ClassBase<'db>> for Type<'db> {
     fn from(value: ClassBase<'db>) -> Self {
         match value {
-            ClassBase::Dynamic(dynamic) => Type::Dynamic(dynamic),
+            ClassBase::Any => Type::Any,
+            ClassBase::Todo(todo) => Type::Todo(todo),
+            ClassBase::Unknown => Type::Unknown,
             ClassBase::Class(class) => Type::class_literal(class),
         }
     }

crates/red_knot_python_semantic/src/types/context.rs

@@ -162,11 +162,6 @@ impl<'db> InferContext<'db> {
         }
     }
 
-    /// 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();

crates/red_knot_python_semantic/src/types/diagnostic.rs

@@ -30,35 +30,27 @@ pub(crate) fn register_lints(registry: &mut LintRegistryBuilder) {
     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(&TYPE_ASSERTION_FAILURE);
-    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);
@@ -234,27 +226,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 = {
@@ -292,7 +263,6 @@ declare_lint! {
 }
 
 declare_lint! {
-    /// ## What it does
     /// Checks for exception handlers that catch non-exception classes.
     ///
     /// ## Why is this bad?
@@ -327,33 +297,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.
@@ -432,25 +375,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.
@@ -489,27 +413,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.
@@ -576,49 +479,6 @@ declare_lint! {
     }
 }
 
-declare_lint! {
-    /// ## What it does
-    /// Checks for `assert_type()` calls where the actual type
-    /// is not the same as the asserted type.
-    ///
-    /// ## Why is this bad?
-    /// `assert_type()` allows confirming the inferred type of a certain value.
-    ///
-    /// ## Example
-    ///
-    /// ```python
-    /// def _(x: int):
-    ///     assert_type(x, int)  # fine
-    ///     assert_type(x, str)  # error: Actual type does not match asserted type
-    /// ```
-    pub(crate) static TYPE_ASSERTION_FAILURE = {
-        summary: "detects failed type assertions",
-        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.
@@ -635,27 +495,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.
@@ -731,25 +570,6 @@ 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,

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;
@@ -65,8 +65,9 @@ struct DisplayRepresentation<'db> {
 impl Display for DisplayRepresentation<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self.ty {
-            Type::Dynamic(dynamic) => dynamic.fmt(f),
+            Type::Any => f.write_str("Any"),
             Type::Never => f.write_str("Never"),
+            Type::Unknown => f.write_str("Unknown"),
             Type::Instance(InstanceType { class }) => {
                 let representation = match class.known(self.db) {
                     Some(KnownClass::NoneType) => "None",
@@ -75,17 +76,24 @@ impl Display for DisplayRepresentation<'_> {
                 };
                 f.write_str(representation)
             }
+            // `[Type::Todo]`'s display should be explicit that is not a valid display of
+            // any other type
+            Type::Todo(todo) => write!(f, "@Todo{todo}"),
             Type::ModuleLiteral(module) => {
                 write!(f, "<module '{}'>", module.module(self.db).name())
             }
             // 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)),
-                ClassBase::Dynamic(dynamic) => write!(f, "type[{dynamic}]"),
-            },
+                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),
@@ -169,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,
@@ -212,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 {
@@ -227,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(()),
         }
     }
@@ -357,8 +372,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() {

crates/red_knot_python_semantic/src/types/mro.rs

@@ -34,7 +34,7 @@ impl<'db> Mro<'db> {
     pub(super) fn from_error(db: &'db dyn Db, class: Class<'db>) -> Self {
         Self::from([
             ClassBase::Class(class),
-            ClassBase::unknown(),
+            ClassBase::Unknown,
             ClassBase::object(db),
         ])
     }

crates/red_knot_python_semantic/src/types/narrow.rs

@@ -7,8 +7,8 @@ use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{ScopeId, ScopedSymbolId, SymbolTable};
 use crate::semantic_index::symbol_table;
 use crate::types::{
-    infer_expression_types, ClassLiteralType, IntersectionBuilder, KnownClass, KnownFunction,
-    SubclassOfType, Truthiness, Type, UnionBuilder,
+    infer_expression_types, ClassLiteralType, IntersectionBuilder, KnownClass,
+    KnownConstraintFunction, KnownFunction, Truthiness, Type, UnionBuilder,
 };
 use crate::Db;
 use itertools::Itertools;
@@ -83,39 +83,28 @@ fn all_negative_narrowing_constraints_for_expression<'db>(
     NarrowingConstraintsBuilder::new(db, ConstraintNode::Expression(expression), false).finish()
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum KnownConstraintFunction {
-    /// `builtins.isinstance`
-    IsInstance,
-    /// `builtins.issubclass`
-    IsSubclass,
-}
-
-impl KnownConstraintFunction {
-    /// Generate a constraint from the type of a `classinfo` argument to `isinstance` or `issubclass`.
-    ///
-    /// The `classinfo` argument can be a class literal, a tuple of (tuples of) class literals. PEP 604
-    /// union types are not yet supported. Returns `None` if the `classinfo` argument has a wrong type.
-    fn generate_constraint<'db>(self, db: &'db dyn Db, classinfo: Type<'db>) -> Option<Type<'db>> {
-        let constraint_fn = |class| match self {
-            KnownConstraintFunction::IsInstance => Type::instance(class),
-            KnownConstraintFunction::IsSubclass => SubclassOfType::from(db, class),
-        };
-
-        match classinfo {
-            Type::Tuple(tuple) => {
-                let mut builder = UnionBuilder::new(db);
-                for element in tuple.elements(db) {
-                    builder = builder.add(self.generate_constraint(db, *element)?);
-                }
-                Some(builder.build())
+/// Generate a constraint from the type of a `classinfo` argument to `isinstance` or `issubclass`.
+///
+/// The `classinfo` argument can be a class literal, a tuple of (tuples of) class literals. PEP 604
+/// union types are not yet supported. Returns `None` if the `classinfo` argument has a wrong type.
+fn generate_classinfo_constraint<'db, F>(
+    db: &'db dyn Db,
+    classinfo: &Type<'db>,
+    to_constraint: F,
+) -> Option<Type<'db>>
+where
+    F: Fn(ClassLiteralType<'db>) -> Type<'db> + Copy,
+{
+    match classinfo {
+        Type::Tuple(tuple) => {
+            let mut builder = UnionBuilder::new(db);
+            for element in tuple.elements(db) {
+                builder = builder.add(generate_classinfo_constraint(db, element, to_constraint)?);
             }
-            Type::ClassLiteral(ClassLiteralType { class }) => Some(constraint_fn(class)),
-            Type::SubclassOf(subclass_of_ty) => {
-                subclass_of_ty.subclass_of().into_class().map(constraint_fn)
-            }
-            _ => None,
+            Some(builder.build())
         }
+        Type::ClassLiteral(class_literal_type) => Some(to_constraint(*class_literal_type)),
+        _ => None,
     }
 }
 
@@ -233,9 +222,6 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
             PatternConstraintKind::Singleton(singleton, _guard) => {
                 self.evaluate_match_pattern_singleton(*subject, *singleton)
             }
-            PatternConstraintKind::Class(cls, _guard) => {
-                self.evaluate_match_pattern_class(*subject, *cls)
-            }
             // TODO: support more pattern kinds
             PatternConstraintKind::Value(..) | PatternConstraintKind::Unsupported => None,
         }
@@ -443,13 +429,24 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
                 let class_info_ty =
                     inference.expression_ty(class_info.scoped_expression_id(self.db, scope));
 
-                function
-                    .generate_constraint(self.db, class_info_ty)
-                    .map(|constraint| {
+                let to_constraint = match function {
+                    KnownConstraintFunction::IsInstance => {
+                        |class_literal: ClassLiteralType<'db>| Type::instance(class_literal.class)
+                    }
+                    KnownConstraintFunction::IsSubclass => {
+                        |class_literal: ClassLiteralType<'db>| {
+                            Type::subclass_of(class_literal.class)
+                        }
+                    }
+                };
+
+                generate_classinfo_constraint(self.db, &class_info_ty, to_constraint).map(
+                    |constraint| {
                         let mut constraints = NarrowingConstraints::default();
                         constraints.insert(symbol, constraint.negate_if(self.db, !is_positive));
                         constraints
-                    })
+                    },
+                )
             }
             // for the expression `bool(E)`, we further narrow the type based on `E`
             Type::ClassLiteral(class_type)
@@ -489,27 +486,6 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
         }
     }
 
-    fn evaluate_match_pattern_class(
-        &mut self,
-        subject: Expression<'db>,
-        cls: Expression<'db>,
-    ) -> Option<NarrowingConstraints<'db>> {
-        if let Some(ast::ExprName { id, .. }) = subject.node_ref(self.db).as_name_expr() {
-            // SAFETY: we should always have a symbol for every Name node.
-            let symbol = self.symbols().symbol_id_by_name(id).unwrap();
-            let scope = self.scope();
-            let inference = infer_expression_types(self.db, cls);
-            let ty = inference
-                .expression_ty(cls.node_ref(self.db).scoped_expression_id(self.db, scope))
-                .to_instance(self.db);
-            let mut constraints = NarrowingConstraints::default();
-            constraints.insert(symbol, ty);
-            Some(constraints)
-        } else {
-            None
-        }
-    }
-
     fn evaluate_bool_op(
         &mut self,
         expr_bool_op: &ExprBoolOp,

crates/red_knot_python_semantic/src/types/property_tests.rs

@@ -28,7 +28,7 @@ use std::sync::{Arc, Mutex, MutexGuard, OnceLock};
 
 use super::tests::Ty;
 use crate::db::tests::{setup_db, TestDb};
-use crate::types::{IntersectionBuilder, KnownClass, Type, UnionType};
+use crate::types::KnownClass;
 use quickcheck::{Arbitrary, Gen};
 
 fn arbitrary_core_type(g: &mut Gen) -> Ty {
@@ -123,61 +123,14 @@ impl Arbitrary for Ty {
     }
 
     fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+        // This is incredibly naive. We can do much better here by
+        // trying various subsets of the elements in unions, tuples,
+        // and intersections. For now, we only try to shrink by
+        // reducing unions/tuples/intersections to a single element.
         match self.clone() {
-            Ty::Union(types) => Box::new(types.shrink().filter_map(|elts| match elts.len() {
-                0 => None,
-                1 => Some(elts.into_iter().next().unwrap()),
-                _ => Some(Ty::Union(elts)),
-            })),
-            Ty::Tuple(types) => Box::new(types.shrink().filter_map(|elts| match elts.len() {
-                0 => None,
-                1 => Some(elts.into_iter().next().unwrap()),
-                _ => Some(Ty::Tuple(elts)),
-            })),
-            Ty::Intersection { pos, neg } => {
-                // Shrinking on intersections is not exhaustive!
-                //
-                // We try to shrink the positive side or the negative side,
-                // but we aren't shrinking both at the same time.
-                //
-                // This should remove positive or negative constraints but
-                // won't shrink (A & B & ~C & ~D) to (A & ~C) in one shrink
-                // iteration.
-                //
-                // Instead, it hopes that (A & B & ~C) or (A & ~C & ~D) fails
-                // so that shrinking can happen there.
-                let pos_orig = pos.clone();
-                let neg_orig = neg.clone();
-                Box::new(
-                    // we shrink negative constraints first, as
-                    // intersections with only negative constraints are
-                    // more confusing
-                    neg.shrink()
-                        .map(move |shrunk_neg| Ty::Intersection {
-                            pos: pos_orig.clone(),
-                            neg: shrunk_neg,
-                        })
-                        .chain(pos.shrink().map(move |shrunk_pos| Ty::Intersection {
-                            pos: shrunk_pos,
-                            neg: neg_orig.clone(),
-                        }))
-                        .filter_map(|ty| {
-                            if let Ty::Intersection { pos, neg } = &ty {
-                                match (pos.len(), neg.len()) {
-                                    // an empty intersection does not mean
-                                    // anything
-                                    (0, 0) => None,
-                                    // a single positive element should be
-                                    // unwrapped
-                                    (1, 0) => Some(pos[0].clone()),
-                                    _ => Some(ty),
-                                }
-                            } else {
-                                unreachable!()
-                            }
-                        }),
-                )
-            }
+            Ty::Union(types) => Box::new(types.into_iter()),
+            Ty::Tuple(types) => Box::new(types.into_iter()),
+            Ty::Intersection { pos, neg } => Box::new(pos.into_iter().chain(neg)),
             _ => Box::new(std::iter::empty()),
         }
     }
@@ -219,41 +172,14 @@ macro_rules! type_property_test {
     };
 }
 
-fn intersection<'db>(db: &'db TestDb, s: Type<'db>, t: Type<'db>) -> Type<'db> {
-    IntersectionBuilder::new(db)
-        .add_positive(s)
-        .add_positive(t)
-        .build()
-}
-
-fn union<'db>(db: &'db TestDb, s: Type<'db>, t: Type<'db>) -> Type<'db> {
-    UnionType::from_elements(db, [s, t])
-}
-
 mod stable {
-    use super::union;
-    use crate::types::{KnownClass, Type};
-
-    // Reflexivity: `T` is equivalent to itself.
+    // `T` is equivalent to itself.
     type_property_test!(
         equivalent_to_is_reflexive, db,
         forall types t. t.is_fully_static(db) => t.is_equivalent_to(db, t)
     );
 
-    // Symmetry: If `S` is equivalent to `T`, then `T` must be equivalent to `S`.
-    // Note that this (trivially) holds true for gradual types as well.
-    type_property_test!(
-        equivalent_to_is_symmetric, db,
-        forall types s, t. s.is_equivalent_to(db, t) => t.is_equivalent_to(db, s)
-    );
-
-    // Transitivity: If `S` is equivalent to `T` and `T` is equivalent to `U`, then `S` must be equivalent to `U`.
-    type_property_test!(
-        equivalent_to_is_transitive, db,
-        forall types s, t, u. s.is_equivalent_to(db, t) && t.is_equivalent_to(db, u) => s.is_equivalent_to(db, u)
-    );
-
-    // A fully static type `T` is a subtype of itself.
+    // `T` is a subtype of itself.
     type_property_test!(
         subtype_of_is_reflexive, db,
         forall types t. t.is_fully_static(db) => t.is_subtype_of(db, t)
@@ -283,6 +209,12 @@ mod stable {
         forall types s, t. s.is_subtype_of(db, t) => !s.is_disjoint_from(db, t) || s.is_never()
     );
 
+    // `T` can be assigned to itself.
+    type_property_test!(
+        assignable_to_is_reflexive, db,
+        forall types t. t.is_assignable_to(db, t)
+    );
+
     // `S <: T` implies that `S` can be assigned to `T`.
     type_property_test!(
         subtype_of_implies_assignable_to, db,
@@ -306,38 +238,6 @@ mod stable {
         non_fully_static_types_do_not_participate_in_subtyping, db,
         forall types s, t. !s.is_fully_static(db) => !s.is_subtype_of(db, t) && !t.is_subtype_of(db, s)
     );
-
-    // All types should be assignable to `object`
-    type_property_test!(
-        all_types_assignable_to_object, db,
-        forall types t. t.is_assignable_to(db, KnownClass::Object.to_instance(db))
-    );
-
-    // And for fully static types, they should also be subtypes of `object`
-    type_property_test!(
-        all_fully_static_types_subtype_of_object, db,
-        forall types t. t.is_fully_static(db) => t.is_subtype_of(db, KnownClass::Object.to_instance(db))
-    );
-
-    // Never should be assignable to every type
-    type_property_test!(
-        never_assignable_to_every_type, db,
-        forall types t. Type::Never.is_assignable_to(db, t)
-    );
-
-    // And it should be a subtype of all fully static types
-    type_property_test!(
-        never_subtype_of_every_fully_static_type, db,
-        forall types t. t.is_fully_static(db) => Type::Never.is_subtype_of(db, t)
-    );
-
-    // For any two fully static types, each type in the pair must be a subtype of their union.
-    type_property_test!(
-        all_fully_static_type_pairs_are_subtype_of_their_union, db,
-        forall types s, t.
-            s.is_fully_static(db) && t.is_fully_static(db)
-            => s.is_subtype_of(db, union(db, s, t)) && t.is_subtype_of(db, union(db, s, t))
-    );
 }
 
 /// This module contains property tests that currently lead to many false positives.
@@ -348,17 +248,7 @@ mod stable {
 /// tests to the `stable` section. In the meantime, it can still be useful to run these
 /// tests (using [`types::property_tests::flaky`]), to see if there are any new obvious bugs.
 mod flaky {
-    use super::{intersection, union};
-
-    // Currently fails due to https://github.com/astral-sh/ruff/issues/14899
-    // `T` can be assigned to itself.
-    type_property_test!(
-        assignable_to_is_reflexive, db,
-        forall types t. t.is_assignable_to(db, t)
-    );
-
     // `S <: T` and `T <: S` implies that `S` is equivalent to `T`.
-    // This very often passes now, but occasionally flakes due to https://github.com/astral-sh/ruff/issues/15380
     type_property_test!(
         subtype_of_is_antisymmetric, db,
         forall types s, t. s.is_subtype_of(db, t) && t.is_subtype_of(db, s) => s.is_equivalent_to(db, t)
@@ -369,39 +259,4 @@ mod flaky {
         double_negation_is_identity, db,
         forall types t. t.negate(db).negate(db).is_equivalent_to(db, t)
     );
-
-    // ~T should be disjoint from T
-    type_property_test!(
-        negation_is_disjoint, db,
-        forall types t. t.is_fully_static(db) => t.negate(db).is_disjoint_from(db, t)
-    );
-
-    // If `S <: T`, then `~T <: ~S`.
-    type_property_test!(
-        negation_reverses_subtype_order, db,
-        forall types s, t. s.is_subtype_of(db, t) => t.negate(db).is_subtype_of(db, s.negate(db))
-    );
-
-    // For two fully static types, their intersection must be a subtype of each type in the pair.
-    type_property_test!(
-        all_fully_static_type_pairs_are_supertypes_of_their_intersection, db,
-        forall types s, t.
-            s.is_fully_static(db) && t.is_fully_static(db)
-            => intersection(db, s, t).is_subtype_of(db, s) && intersection(db, s, t).is_subtype_of(db, t)
-    );
-
-    // And for non-fully-static types, the intersection of a pair of types
-    // should be assignable to both types of the pair.
-    // Currently fails due to https://github.com/astral-sh/ruff/issues/14899
-    type_property_test!(
-        all_type_pairs_can_be_assigned_from_their_intersection, db,
-        forall types s, t. intersection(db, s, t).is_assignable_to(db, s) && intersection(db, s, t).is_assignable_to(db, t)
-    );
-
-    // For *any* pair of types, whether fully static or not,
-    // each of the pair should be assignable to the union of the two.
-    type_property_test!(
-        all_type_pairs_are_assignable_to_their_union, db,
-        forall types s, t. s.is_assignable_to(db, union(db, s, t)) && t.is_assignable_to(db, union(db, s, t))
-    );
 }

crates/red_knot_python_semantic/src/types/signatures.rs

@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 use super::{definition_expression_ty, Type};
 use crate::Db;
 use crate::{semantic_index::definition::Definition, types::todo_type};
@@ -6,18 +7,10 @@ use ruff_python_ast::{self as ast, name::Name};
 /// A typed callable signature.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct Signature<'db> {
-    /// Parameters, in source order.
-    ///
-    /// The ordering of parameters in a valid signature must be: first positional-only parameters,
-    /// then positional-or-keyword, then optionally the variadic parameter, then keyword-only
-    /// parameters, and last, optionally the variadic keywords parameter. Parameters with defaults
-    /// must come after parameters without defaults.
-    ///
-    /// We may get invalid signatures, though, and need to handle them without panicking.
     parameters: Parameters<'db>,
 
-    /// Annotated return type, if any.
-    pub(crate) return_ty: Option<Type<'db>>,
+    /// Annotated return type (Unknown if no annotation.)
+    pub(crate) return_ty: Type<'db>,
 }
 
 impl<'db> Signature<'db> {
@@ -25,7 +18,7 @@ impl<'db> Signature<'db> {
     pub(crate) fn todo() -> Self {
         Self {
             parameters: Parameters::todo(),
-            return_ty: Some(todo_type!("return type")),
+            return_ty: todo_type!("return type"),
         }
     }
 
@@ -35,13 +28,17 @@ impl<'db> Signature<'db> {
         definition: Definition<'db>,
         function_node: &'db ast::StmtFunctionDef,
     ) -> Self {
-        let return_ty = function_node.returns.as_ref().map(|returns| {
-            if function_node.is_async {
-                todo_type!("generic types.CoroutineType")
-            } else {
-                definition_expression_ty(db, definition, returns.as_ref())
-            }
-        });
+        let return_ty = function_node
+            .returns
+            .as_ref()
+            .map(|returns| {
+                if function_node.is_async {
+                    todo_type!("generic types.CoroutineType")
+                } else {
+                    definition_expression_ty(db, definition, returns.as_ref())
+                }
+            })
+            .unwrap_or(Type::Unknown);
 
         Self {
             parameters: Parameters::from_parameters(
@@ -52,32 +49,45 @@ impl<'db> Signature<'db> {
             return_ty,
         }
     }
-
-    /// Return the parameters in this signature.
-    pub(crate) fn parameters(&self) -> &Parameters<'db> {
-        &self.parameters
-    }
 }
 
-// TODO: use SmallVec here once invariance bug is fixed
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct Parameters<'db>(Vec<Parameter<'db>>);
+/// The parameters portion of a typed signature.
+///
+/// The ordering of parameters is always as given in this struct: first positional-only parameters,
+/// then positional-or-keyword, then optionally the variadic parameter, then keyword-only
+/// parameters, and last, optionally the variadic keywords parameter.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub(super) struct Parameters<'db> {
+    /// Parameters which may only be filled by positional arguments.
+    positional_only: Box<[ParameterWithDefault<'db>]>,
+
+    /// Parameters which may be filled by positional or keyword arguments.
+    positional_or_keyword: Box<[ParameterWithDefault<'db>]>,
+
+    /// The `*args` variadic parameter, if any.
+    variadic: Option<Parameter<'db>>,
+
+    /// Parameters which may only be filled by keyword arguments.
+    keyword_only: Box<[ParameterWithDefault<'db>]>,
+
+    /// The `**kwargs` variadic keywords parameter, if any.
+    keywords: Option<Parameter<'db>>,
+}
 
 impl<'db> Parameters<'db> {
     /// Return todo parameters: (*args: Todo, **kwargs: Todo)
     fn todo() -> Self {
-        Self(vec![
-            Parameter {
+        Self {
+            variadic: Some(Parameter {
                 name: Some(Name::new_static("args")),
-                annotated_ty: Some(todo_type!("todo signature *args")),
-                kind: ParameterKind::Variadic,
-            },
-            Parameter {
+                annotated_ty: todo_type!(),
+            }),
+            keywords: Some(Parameter {
                 name: Some(Name::new_static("kwargs")),
-                annotated_ty: Some(todo_type!("todo signature **kwargs")),
-                kind: ParameterKind::KeywordVariadic,
-            },
-        ])
+                annotated_ty: todo_type!(),
+            }),
+            ..Default::default()
+        }
     }
 
     fn from_parameters(
@@ -93,238 +103,94 @@ impl<'db> Parameters<'db> {
             kwarg,
             range: _,
         } = parameters;
-        let default_ty = |parameter_with_default: &ast::ParameterWithDefault| {
-            parameter_with_default
-                .default
-                .as_deref()
-                .map(|default| definition_expression_ty(db, definition, default))
-        };
-        let positional_only = posonlyargs.iter().map(|arg| {
-            Parameter::from_node_and_kind(
-                db,
-                definition,
-                &arg.parameter,
-                ParameterKind::PositionalOnly {
-                    default_ty: default_ty(arg),
-                },
-            )
-        });
-        let positional_or_keyword = args.iter().map(|arg| {
-            Parameter::from_node_and_kind(
-                db,
-                definition,
-                &arg.parameter,
-                ParameterKind::PositionalOrKeyword {
-                    default_ty: default_ty(arg),
-                },
-            )
-        });
+        let positional_only = posonlyargs
+            .iter()
+            .map(|arg| ParameterWithDefault::from_node(db, definition, arg))
+            .collect();
+        let positional_or_keyword = args
+            .iter()
+            .map(|arg| ParameterWithDefault::from_node(db, definition, arg))
+            .collect();
         let variadic = vararg
             .as_ref()
-            .map(|arg| Parameter::from_node_and_kind(db, definition, arg, ParameterKind::Variadic));
-        let keyword_only = kwonlyargs.iter().map(|arg| {
-            Parameter::from_node_and_kind(
-                db,
-                definition,
-                &arg.parameter,
-                ParameterKind::KeywordOnly {
-                    default_ty: default_ty(arg),
-                },
-            )
-        });
-        let keywords = kwarg.as_ref().map(|arg| {
-            Parameter::from_node_and_kind(db, definition, arg, ParameterKind::KeywordVariadic)
-        });
-        Self(
-            positional_only
-                .chain(positional_or_keyword)
-                .chain(variadic)
-                .chain(keyword_only)
-                .chain(keywords)
-                .collect(),
-        )
-    }
-
-    pub(crate) fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub(crate) fn iter(&self) -> std::slice::Iter<Parameter<'db>> {
-        self.0.iter()
-    }
-
-    /// Iterate initial positional parameters, not including variadic parameter, if any.
-    ///
-    /// For a valid signature, this will be all positional parameters. In an invalid signature,
-    /// there could be non-initial positional parameters; effectively, we just won't consider those
-    /// to be positional, which is fine.
-    pub(crate) fn positional(&self) -> impl Iterator<Item = &Parameter<'db>> {
-        self.iter().take_while(|param| param.is_positional())
-    }
-
-    /// Return parameter at given index, or `None` if index is out-of-range.
-    pub(crate) fn get(&self, index: usize) -> Option<&Parameter<'db>> {
-        self.0.get(index)
-    }
-
-    /// Return positional parameter at given index, or `None` if `index` is out of range.
-    ///
-    /// Does not return variadic parameter.
-    pub(crate) fn get_positional(&self, index: usize) -> Option<&Parameter<'db>> {
-        self.get(index)
-            .and_then(|parameter| parameter.is_positional().then_some(parameter))
-    }
-
-    /// Return the variadic parameter (`*args`), if any, and its index, or `None`.
-    pub(crate) fn variadic(&self) -> Option<(usize, &Parameter<'db>)> {
-        self.iter()
-            .enumerate()
-            .find(|(_, parameter)| parameter.is_variadic())
-    }
-
-    /// Return parameter (with index) for given name, or `None` if no such parameter.
-    ///
-    /// Does not return keywords (`**kwargs`) parameter.
-    ///
-    /// In an invalid signature, there could be multiple parameters with the same name; we will
-    /// just return the first that matches.
-    pub(crate) fn keyword_by_name(&self, name: &str) -> Option<(usize, &Parameter<'db>)> {
-        self.iter()
-            .enumerate()
-            .find(|(_, parameter)| parameter.callable_by_name(name))
-    }
-
-    /// Return the keywords parameter (`**kwargs`), if any, and its index, or `None`.
-    pub(crate) fn keyword_variadic(&self) -> Option<(usize, &Parameter<'db>)> {
-        self.iter()
-            .enumerate()
-            .rfind(|(_, parameter)| parameter.is_keyword_variadic())
-    }
-}
-
-impl<'db, 'a> IntoIterator for &'a Parameters<'db> {
-    type Item = &'a Parameter<'db>;
-    type IntoIter = std::slice::Iter<'a, Parameter<'db>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.iter()
-    }
-}
-
-impl<'db> std::ops::Index<usize> for Parameters<'db> {
-    type Output = Parameter<'db>;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        &self.0[index]
+            .map(|arg| Parameter::from_node(db, definition, arg));
+        let keyword_only = kwonlyargs
+            .iter()
+            .map(|arg| ParameterWithDefault::from_node(db, definition, arg))
+            .collect();
+        let keywords = kwarg
+            .as_ref()
+            .map(|arg| Parameter::from_node(db, definition, arg));
+        Self {
+            positional_only,
+            positional_or_keyword,
+            variadic,
+            keyword_only,
+            keywords,
+        }
     }
 }
 
+/// A single parameter of a typed signature, with optional default value.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct Parameter<'db> {
+pub(super) struct ParameterWithDefault<'db> {
+    parameter: Parameter<'db>,
+
+    /// Type of the default value, if any.
+    default_ty: Option<Type<'db>>,
+}
+
+impl<'db> ParameterWithDefault<'db> {
+    fn from_node(
+        db: &'db dyn Db,
+        definition: Definition<'db>,
+        parameter_with_default: &'db ast::ParameterWithDefault,
+    ) -> Self {
+        Self {
+            default_ty: parameter_with_default
+                .default
+                .as_deref()
+                .map(|default| definition_expression_ty(db, definition, default)),
+            parameter: Parameter::from_node(db, definition, &parameter_with_default.parameter),
+        }
+    }
+}
+
+/// A single parameter of a typed signature.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) struct Parameter<'db> {
     /// Parameter name.
     ///
     /// It is possible for signatures to be defined in ways that leave positional-only parameters
     /// nameless (e.g. via `Callable` annotations).
     name: Option<Name>,
 
-    /// Annotated type of the parameter.
-    annotated_ty: Option<Type<'db>>,
-
-    kind: ParameterKind<'db>,
+    /// Annotated type of the parameter (Unknown if no annotation.)
+    annotated_ty: Type<'db>,
 }
 
 impl<'db> Parameter<'db> {
-    fn from_node_and_kind(
+    fn from_node(
         db: &'db dyn Db,
         definition: Definition<'db>,
         parameter: &'db ast::Parameter,
-        kind: ParameterKind<'db>,
     ) -> Self {
-        Self {
+        Parameter {
             name: Some(parameter.name.id.clone()),
             annotated_ty: parameter
                 .annotation
                 .as_deref()
-                .map(|annotation| definition_expression_ty(db, definition, annotation)),
-            kind,
+                .map(|annotation| definition_expression_ty(db, definition, annotation))
+                .unwrap_or(Type::Unknown),
         }
     }
-
-    pub(crate) fn is_variadic(&self) -> bool {
-        matches!(self.kind, ParameterKind::Variadic)
-    }
-
-    pub(crate) fn is_keyword_variadic(&self) -> bool {
-        matches!(self.kind, ParameterKind::KeywordVariadic)
-    }
-
-    pub(crate) fn is_positional(&self) -> bool {
-        matches!(
-            self.kind,
-            ParameterKind::PositionalOnly { .. } | ParameterKind::PositionalOrKeyword { .. }
-        )
-    }
-
-    pub(crate) fn callable_by_name(&self, name: &str) -> bool {
-        match self.kind {
-            ParameterKind::PositionalOrKeyword { .. } | ParameterKind::KeywordOnly { .. } => self
-                .name
-                .as_ref()
-                .is_some_and(|param_name| param_name == name),
-            _ => false,
-        }
-    }
-
-    /// Annotated type of the parameter, if annotated.
-    pub(crate) fn annotated_ty(&self) -> Option<Type<'db>> {
-        self.annotated_ty
-    }
-
-    /// Name of the parameter (if it has one).
-    pub(crate) fn name(&self) -> Option<&ast::name::Name> {
-        self.name.as_ref()
-    }
-
-    /// Display name of the parameter, if it has one.
-    pub(crate) fn display_name(&self) -> Option<ast::name::Name> {
-        self.name().map(|name| match self.kind {
-            ParameterKind::Variadic => ast::name::Name::new(format!("*{name}")),
-            ParameterKind::KeywordVariadic => ast::name::Name::new(format!("**{name}")),
-            _ => name.clone(),
-        })
-    }
-
-    /// Default-value type of the parameter, if any.
-    pub(crate) fn default_ty(&self) -> Option<Type<'db>> {
-        match self.kind {
-            ParameterKind::PositionalOnly { default_ty } => default_ty,
-            ParameterKind::PositionalOrKeyword { default_ty } => default_ty,
-            ParameterKind::Variadic => None,
-            ParameterKind::KeywordOnly { default_ty } => default_ty,
-            ParameterKind::KeywordVariadic => None,
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum ParameterKind<'db> {
-    /// Positional-only parameter, e.g. `def f(x, /): ...`
-    PositionalOnly { default_ty: Option<Type<'db>> },
-    /// Positional-or-keyword parameter, e.g. `def f(x): ...`
-    PositionalOrKeyword { default_ty: Option<Type<'db>> },
-    /// Variadic parameter, e.g. `def f(*args): ...`
-    Variadic,
-    /// Keyword-only parameter, e.g. `def f(*, x): ...`
-    KeywordOnly { default_ty: Option<Type<'db>> },
-    /// Variadic keywords parameter, e.g. `def f(**kwargs): ...`
-    KeywordVariadic,
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::db::tests::{setup_db, TestDb};
-    use crate::types::{global_symbol, FunctionType, KnownClass};
+    use crate::types::{global_symbol, FunctionType};
     use ruff_db::system::DbWithTestSystem;
 
     #[track_caller]
@@ -336,8 +202,39 @@ mod tests {
     }
 
     #[track_caller]
-    fn assert_params<'db>(signature: &Signature<'db>, expected: &[Parameter<'db>]) {
-        assert_eq!(signature.parameters.0.as_slice(), expected);
+    fn assert_param_with_default<'db>(
+        db: &'db TestDb,
+        param_with_default: &ParameterWithDefault<'db>,
+        expected_name: &'static str,
+        expected_annotation_ty_display: &'static str,
+        expected_default_ty_display: Option<&'static str>,
+    ) {
+        assert_eq!(
+            param_with_default
+                .default_ty
+                .map(|ty| ty.display(db).to_string()),
+            expected_default_ty_display.map(ToString::to_string)
+        );
+        assert_param(
+            db,
+            &param_with_default.parameter,
+            expected_name,
+            expected_annotation_ty_display,
+        );
+    }
+
+    #[track_caller]
+    fn assert_param<'db>(
+        db: &'db TestDb,
+        param: &Parameter<'db>,
+        expected_name: &'static str,
+        expected_annotation_ty_display: &'static str,
+    ) {
+        assert_eq!(param.name.as_ref().unwrap(), expected_name);
+        assert_eq!(
+            param.annotated_ty.display(db).to_string(),
+            expected_annotation_ty_display
+        );
     }
 
     #[test]
@@ -348,8 +245,13 @@ mod tests {
 
         let sig = func.internal_signature(&db);
 
-        assert!(sig.return_ty.is_none());
-        assert_params(&sig, &[]);
+        assert_eq!(sig.return_ty.display(&db).to_string(), "Unknown");
+        let params = sig.parameters;
+        assert!(params.positional_only.is_empty());
+        assert!(params.positional_or_keyword.is_empty());
+        assert!(params.variadic.is_none());
+        assert!(params.keyword_only.is_empty());
+        assert!(params.keywords.is_none());
     }
 
     #[test]
@@ -369,74 +271,34 @@ mod tests {
 
         let sig = func.internal_signature(&db);
 
-        assert_eq!(sig.return_ty.unwrap().display(&db).to_string(), "bytes");
-        assert_params(
-            &sig,
-            &[
-                Parameter {
-                    name: Some(Name::new_static("a")),
-                    annotated_ty: None,
-                    kind: ParameterKind::PositionalOnly { default_ty: None },
-                },
-                Parameter {
-                    name: Some(Name::new_static("b")),
-                    annotated_ty: Some(KnownClass::Int.to_instance(&db)),
-                    kind: ParameterKind::PositionalOnly { default_ty: None },
-                },
-                Parameter {
-                    name: Some(Name::new_static("c")),
-                    annotated_ty: None,
-                    kind: ParameterKind::PositionalOnly {
-                        default_ty: Some(Type::IntLiteral(1)),
-                    },
-                },
-                Parameter {
-                    name: Some(Name::new_static("d")),
-                    annotated_ty: Some(KnownClass::Int.to_instance(&db)),
-                    kind: ParameterKind::PositionalOnly {
-                        default_ty: Some(Type::IntLiteral(2)),
-                    },
-                },
-                Parameter {
-                    name: Some(Name::new_static("e")),
-                    annotated_ty: None,
-                    kind: ParameterKind::PositionalOrKeyword {
-                        default_ty: Some(Type::IntLiteral(3)),
-                    },
-                },
-                Parameter {
-                    name: Some(Name::new_static("f")),
-                    annotated_ty: Some(Type::IntLiteral(4)),
-                    kind: ParameterKind::PositionalOrKeyword {
-                        default_ty: Some(Type::IntLiteral(4)),
-                    },
-                },
-                Parameter {
-                    name: Some(Name::new_static("args")),
-                    annotated_ty: Some(KnownClass::Object.to_instance(&db)),
-                    kind: ParameterKind::Variadic,
-                },
-                Parameter {
-                    name: Some(Name::new_static("g")),
-                    annotated_ty: None,
-                    kind: ParameterKind::KeywordOnly {
-                        default_ty: Some(Type::IntLiteral(5)),
-                    },
-                },
-                Parameter {
-                    name: Some(Name::new_static("h")),
-                    annotated_ty: Some(Type::IntLiteral(6)),
-                    kind: ParameterKind::KeywordOnly {
-                        default_ty: Some(Type::IntLiteral(6)),
-                    },
-                },
-                Parameter {
-                    name: Some(Name::new_static("kwargs")),
-                    annotated_ty: Some(KnownClass::Str.to_instance(&db)),
-                    kind: ParameterKind::KeywordVariadic,
-                },
-            ],
-        );
+        assert_eq!(sig.return_ty.display(&db).to_string(), "bytes");
+        let params = sig.parameters;
+        let [a, b, c, d] = &params.positional_only[..] else {
+            panic!("expected four positional-only parameters");
+        };
+        let [e, f] = &params.positional_or_keyword[..] else {
+            panic!("expected two positional-or-keyword parameters");
+        };
+        let Some(args) = params.variadic else {
+            panic!("expected a variadic parameter");
+        };
+        let [g, h] = &params.keyword_only[..] else {
+            panic!("expected two keyword-only parameters");
+        };
+        let Some(kwargs) = params.keywords else {
+            panic!("expected a kwargs parameter");
+        };
+
+        assert_param_with_default(&db, a, "a", "Unknown", None);
+        assert_param_with_default(&db, b, "b", "int", None);
+        assert_param_with_default(&db, c, "c", "Unknown", Some("Literal[1]"));
+        assert_param_with_default(&db, d, "d", "int", Some("Literal[2]"));
+        assert_param_with_default(&db, e, "e", "Unknown", Some("Literal[3]"));
+        assert_param_with_default(&db, f, "f", "Literal[4]", Some("Literal[4]"));
+        assert_param_with_default(&db, g, "g", "Unknown", Some("Literal[5]"));
+        assert_param_with_default(&db, h, "h", "Literal[6]", Some("Literal[6]"));
+        assert_param(&db, &args, "args", "object");
+        assert_param(&db, &kwargs, "kwargs", "str");
     }
 
     #[test]
@@ -460,17 +322,11 @@ mod tests {
 
         let sig = func.internal_signature(&db);
 
-        let [Parameter {
-            name: Some(name),
-            annotated_ty,
-            kind: ParameterKind::PositionalOrKeyword { .. },
-        }] = &sig.parameters.0[..]
-        else {
+        let [a] = &sig.parameters.positional_or_keyword[..] else {
             panic!("expected one positional-or-keyword parameter");
         };
-        assert_eq!(name, "a");
         // Parameter resolution not deferred; we should see A not B
-        assert_eq!(annotated_ty.unwrap().display(&db).to_string(), "A");
+        assert_param_with_default(&db, a, "a", "A", None);
     }
 
     #[test]
@@ -494,17 +350,11 @@ mod tests {
 
         let sig = func.internal_signature(&db);
 
-        let [Parameter {
-            name: Some(name),
-            annotated_ty,
-            kind: ParameterKind::PositionalOrKeyword { .. },
-        }] = &sig.parameters.0[..]
-        else {
+        let [a] = &sig.parameters.positional_or_keyword[..] else {
             panic!("expected one positional-or-keyword parameter");
         };
-        assert_eq!(name, "a");
         // Parameter resolution deferred; we should see B
-        assert_eq!(annotated_ty.unwrap().display(&db).to_string(), "B");
+        assert_param_with_default(&db, a, "a", "B", None);
     }
 
     #[test]
@@ -528,23 +378,12 @@ mod tests {
 
         let sig = func.internal_signature(&db);
 
-        let [Parameter {
-            name: Some(a_name),
-            annotated_ty: a_annotated_ty,
-            kind: ParameterKind::PositionalOrKeyword { .. },
-        }, Parameter {
-            name: Some(b_name),
-            annotated_ty: b_annotated_ty,
-            kind: ParameterKind::PositionalOrKeyword { .. },
-        }] = &sig.parameters.0[..]
-        else {
+        let [a, b] = &sig.parameters.positional_or_keyword[..] else {
             panic!("expected two positional-or-keyword parameters");
         };
-        assert_eq!(a_name, "a");
-        assert_eq!(b_name, "b");
         // TODO resolution should not be deferred; we should see A not B
-        assert_eq!(a_annotated_ty.unwrap().display(&db).to_string(), "B");
-        assert_eq!(b_annotated_ty.unwrap().display(&db).to_string(), "T");
+        assert_param_with_default(&db, a, "a", "B", None);
+        assert_param_with_default(&db, b, "b", "T", None);
     }
 
     #[test]
@@ -568,23 +407,12 @@ mod tests {
 
         let sig = func.internal_signature(&db);
 
-        let [Parameter {
-            name: Some(a_name),
-            annotated_ty: a_annotated_ty,
-            kind: ParameterKind::PositionalOrKeyword { .. },
-        }, Parameter {
-            name: Some(b_name),
-            annotated_ty: b_annotated_ty,
-            kind: ParameterKind::PositionalOrKeyword { .. },
-        }] = &sig.parameters.0[..]
-        else {
+        let [a, b] = &sig.parameters.positional_or_keyword[..] else {
             panic!("expected two positional-or-keyword parameters");
         };
-        assert_eq!(a_name, "a");
-        assert_eq!(b_name, "b");
         // Parameter resolution deferred; we should see B
-        assert_eq!(a_annotated_ty.unwrap().display(&db).to_string(), "B");
-        assert_eq!(b_annotated_ty.unwrap().display(&db).to_string(), "T");
+        assert_param_with_default(&db, a, "a", "B", None);
+        assert_param_with_default(&db, b, "b", "T", None);
     }
 
     #[test]

crates/red_knot_python_semantic/src/types/string_annotation.rs

@@ -1,7 +1,7 @@
 use ruff_db::source::source_text;
 use ruff_python_ast::str::raw_contents;
-use ruff_python_ast::{self as ast, ModExpression};
-use ruff_python_parser::Parsed;
+use ruff_python_ast::{self as ast, ModExpression, StringFlags};
+use ruff_python_parser::{parse_expression_range, Parsed};
 use ruff_text_size::Ranged;
 
 use crate::declare_lint;
@@ -153,7 +153,19 @@ pub(crate) fn parse_string_annotation(
         } else if raw_contents(node_text)
             .is_some_and(|raw_contents| raw_contents == string_literal.as_str())
         {
-            match ruff_python_parser::parse_string_annotation(source.as_str(), string_literal) {
+            let range_excluding_quotes = string_literal
+                .range()
+                .add_start(string_literal.flags.opener_len())
+                .sub_end(string_literal.flags.closer_len());
+
+            // TODO: Support multiline strings like:
+            // ```py
+            // x: """
+            //     int
+            //     | float
+            // """ = 1
+            // ```
+            match parse_expression_range(source.as_str(), range_excluding_quotes) {
                 Ok(parsed) => return Some(parsed),
                 Err(parse_error) => context.report_lint(
                     &INVALID_SYNTAX_IN_FORWARD_ANNOTATION,

crates/red_knot_python_semantic/src/types/subclass_of.rs

@@ -1,89 +0,0 @@
-use super::{ClassBase, ClassLiteralType, Db, KnownClass, Symbol, Type};
-
-/// A type that represents `type[C]`, i.e. the class object `C` and class objects that are subclasses of `C`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, salsa::Update)]
-pub struct SubclassOfType<'db> {
-    // Keep this field private, so that the only way of constructing the struct is through the `from` method.
-    subclass_of: ClassBase<'db>,
-}
-
-impl<'db> SubclassOfType<'db> {
-    /// Construct a new [`Type`] instance representing a given class object (or a given dynamic type)
-    /// and all possible subclasses of that class object/dynamic type.
-    ///
-    /// This method does not always return a [`Type::SubclassOf`] variant.
-    /// If the class object is known to be a final class,
-    /// this method will return a [`Type::ClassLiteral`] variant; this is a more precise type.
-    /// If the class object is `builtins.object`, `Type::Instance(<builtins.type>)` will be returned;
-    /// this is no more precise, but it is exactly equivalent to `type[object]`.
-    ///
-    /// The eager normalization here means that we do not need to worry elsewhere about distinguishing
-    /// between `@final` classes and other classes when dealing with [`Type::SubclassOf`] variants.
-    pub(crate) fn from(db: &'db dyn Db, subclass_of: impl Into<ClassBase<'db>>) -> Type<'db> {
-        let subclass_of = subclass_of.into();
-        match subclass_of {
-            ClassBase::Dynamic(_) => Type::SubclassOf(Self { subclass_of }),
-            ClassBase::Class(class) => {
-                if class.is_final(db) {
-                    Type::ClassLiteral(ClassLiteralType { class })
-                } else if class.is_known(db, KnownClass::Object) {
-                    KnownClass::Type.to_instance(db)
-                } else {
-                    Type::SubclassOf(Self { subclass_of })
-                }
-            }
-        }
-    }
-
-    /// Return a [`Type`] instance representing the type `type[Unknown]`.
-    pub(crate) const fn subclass_of_unknown() -> Type<'db> {
-        Type::SubclassOf(SubclassOfType {
-            subclass_of: ClassBase::unknown(),
-        })
-    }
-
-    /// Return a [`Type`] instance representing the type `type[Any]`.
-    pub(crate) const fn subclass_of_any() -> Type<'db> {
-        Type::SubclassOf(SubclassOfType {
-            subclass_of: ClassBase::any(),
-        })
-    }
-
-    /// Return the inner [`ClassBase`] value wrapped by this `SubclassOfType`.
-    pub(crate) const fn subclass_of(self) -> ClassBase<'db> {
-        self.subclass_of
-    }
-
-    pub const fn is_dynamic(self) -> bool {
-        // Unpack `self` so that we're forced to update this method if any more fields are added in the future.
-        let Self { subclass_of } = self;
-        subclass_of.is_dynamic()
-    }
-
-    pub const fn is_fully_static(self) -> bool {
-        !self.is_dynamic()
-    }
-
-    pub(crate) fn member(self, db: &'db dyn Db, name: &str) -> Symbol<'db> {
-        Type::from(self.subclass_of).member(db, name)
-    }
-
-    /// Return `true` if `self` is a subtype of `other`.
-    ///
-    /// This can only return `true` if `self.subclass_of` is a [`ClassBase::Class`] variant;
-    /// only fully static types participate in subtyping.
-    pub(crate) fn is_subtype_of(self, db: &'db dyn Db, other: SubclassOfType<'db>) -> bool {
-        match (self.subclass_of, other.subclass_of) {
-            // Non-fully-static types do not participate in subtyping
-            (ClassBase::Dynamic(_), _) | (_, ClassBase::Dynamic(_)) => false,
-
-            // For example, `type[bool]` describes all possible runtime subclasses of the class `bool`,
-            // and `type[int]` describes all possible runtime subclasses of the class `int`.
-            // The first set is a subset of the second set, because `bool` is itself a subclass of `int`.
-            (ClassBase::Class(self_class), ClassBase::Class(other_class)) => {
-                // N.B. The subclass relation is fully static
-                self_class.is_subclass_of(db, other_class)
-            }
-        }
-    }
-}

crates/red_knot_python_semantic/src/types/unpacker.rs

@@ -45,15 +45,6 @@ impl<'db> Unpacker<'db> {
         let mut value_ty = infer_expression_types(self.db(), value.expression())
             .expression_ty(value.scoped_expression_id(self.db(), self.scope));
 
-        if value.is_assign()
-            && self.context.in_stub()
-            && value
-                .expression()
-                .node_ref(self.db())
-                .is_ellipsis_literal_expr()
-        {
-            value_ty = Type::unknown();
-        }
         if value.is_iterable() {
             // If the value is an iterable, then the type that needs to be unpacked is the iterator
             // type.
@@ -105,7 +96,7 @@ impl<'db> Unpacker<'db> {
                             // with each individual character, instead of just an array of
                             // `LiteralString`, but there would be a cost and it's not clear that
                             // it's worth it.
-                            TupleType::from_elements(
+                            Type::tuple(
                                 self.db(),
                                 std::iter::repeat(Type::LiteralString)
                                     .take(string_literal_ty.python_len(self.db())),
@@ -164,7 +155,7 @@ impl<'db> Unpacker<'db> {
                 for (index, element) in elts.iter().enumerate() {
                     // SAFETY: `target_types` is initialized with the same length as `elts`.
                     let element_ty = match target_types[index].as_slice() {
-                        [] => Type::unknown(),
+                        [] => Type::Unknown,
                         types => UnionType::from_elements(self.db(), types),
                     };
                     self.unpack_inner(element, element_ty);
@@ -241,7 +232,7 @@ impl<'db> Unpacker<'db> {
 
             // Subtract 1 to insert the starred expression type at the correct
             // index.
-            element_types.resize(targets.len() - 1, Type::unknown());
+            element_types.resize(targets.len() - 1, Type::Unknown);
             // TODO: This should be `list[Unknown]`
             element_types.insert(starred_index, todo_type!("starred unpacking"));
 

crates/red_knot_python_semantic/src/unpack.rs

@@ -76,11 +76,6 @@ impl<'db> UnpackValue<'db> {
         matches!(self, UnpackValue::Iterable(_))
     }
 
-    /// Returns `true` if the value is being assigned to a target.
-    pub(crate) const fn is_assign(self) -> bool {
-        matches!(self, UnpackValue::Assign(_))
-    }
-
     /// Returns the underlying [`Expression`] that is being unpacked.
     pub(crate) const fn expression(self) -> Expression<'db> {
         match self {

crates/red_knot_python_semantic/src/visibility_constraints.rs

@@ -329,9 +329,9 @@ impl<'db> VisibilityConstraints<'db> {
                         Truthiness::Ambiguous
                     }
                 }
-                PatternConstraintKind::Singleton(..)
-                | PatternConstraintKind::Class(..)
-                | PatternConstraintKind::Unsupported => Truthiness::Ambiguous,
+                PatternConstraintKind::Singleton(..) | PatternConstraintKind::Unsupported => {
+                    Truthiness::Ambiguous
+                }
             },
         }
     }

crates/red_knot_server/src/lib.rs

@@ -11,10 +11,10 @@ use crate::server::Server;
 mod message;
 
 mod edit;
-mod logging;
 mod server;
 mod session;
 mod system;
+mod trace;
 
 pub(crate) const SERVER_NAME: &str = "red-knot";
 pub(crate) const DIAGNOSTIC_NAME: &str = "Red Knot";

crates/red_knot_server/src/logging.rs

@@ -1,114 +0,0 @@
-//! The logging system for `red_knot server`.
-//!
-//! Log messages are controlled by the `logLevel` setting which defaults to `"info"`. Log messages
-//! are written to `stderr` by default, which should appear in the logs for most LSP clients. A
-//! `logFile` path can also be specified in the settings, and output will be directed there
-//! instead.
-use core::str;
-use serde::Deserialize;
-use std::{path::PathBuf, str::FromStr, sync::Arc};
-use tracing::level_filters::LevelFilter;
-use tracing_subscriber::{
-    fmt::{time::Uptime, writer::BoxMakeWriter},
-    layer::SubscriberExt,
-    Layer,
-};
-
-pub(crate) fn init_logging(log_level: LogLevel, log_file: Option<&std::path::Path>) {
-    let log_file = log_file
-        .map(|path| {
-            // this expands `logFile` so that tildes and environment variables
-            // are replaced with their values, if possible.
-            if let Some(expanded) = shellexpand::full(&path.to_string_lossy())
-                .ok()
-                .and_then(|path| PathBuf::from_str(&path).ok())
-            {
-                expanded
-            } else {
-                path.to_path_buf()
-            }
-        })
-        .and_then(|path| {
-            std::fs::OpenOptions::new()
-                .create(true)
-                .append(true)
-                .open(&path)
-                .map_err(|err| {
-                    #[allow(clippy::print_stderr)]
-                    {
-                        eprintln!(
-                            "Failed to open file at {} for logging: {err}",
-                            path.display()
-                        );
-                    }
-                })
-                .ok()
-        });
-
-    let logger = match log_file {
-        Some(file) => BoxMakeWriter::new(Arc::new(file)),
-        None => BoxMakeWriter::new(std::io::stderr),
-    };
-    let subscriber = tracing_subscriber::Registry::default().with(
-        tracing_subscriber::fmt::layer()
-            .with_timer(Uptime::default())
-            .with_thread_names(true)
-            .with_ansi(false)
-            .with_writer(logger)
-            .with_filter(LogLevelFilter { filter: log_level }),
-    );
-
-    tracing::subscriber::set_global_default(subscriber)
-        .expect("should be able to set global default subscriber");
-}
-
-/// The log level for the server as provided by the client during initialization.
-///
-/// The default log level is `info`.
-#[derive(Clone, Copy, Debug, Deserialize, Default, PartialEq, Eq, PartialOrd, Ord)]
-#[serde(rename_all = "lowercase")]
-pub(crate) enum LogLevel {
-    Error,
-    Warn,
-    #[default]
-    Info,
-    Debug,
-    Trace,
-}
-
-impl LogLevel {
-    fn trace_level(self) -> tracing::Level {
-        match self {
-            Self::Error => tracing::Level::ERROR,
-            Self::Warn => tracing::Level::WARN,
-            Self::Info => tracing::Level::INFO,
-            Self::Debug => tracing::Level::DEBUG,
-            Self::Trace => tracing::Level::TRACE,
-        }
-    }
-}
-
-/// Filters out traces which have a log level lower than the `logLevel` set by the client.
-struct LogLevelFilter {
-    filter: LogLevel,
-}
-
-impl<S> tracing_subscriber::layer::Filter<S> for LogLevelFilter {
-    fn enabled(
-        &self,
-        meta: &tracing::Metadata<'_>,
-        _: &tracing_subscriber::layer::Context<'_, S>,
-    ) -> bool {
-        let filter = if meta.target().starts_with("red_knot") {
-            self.filter.trace_level()
-        } else {
-            tracing::Level::INFO
-        };
-
-        meta.level() <= &filter
-    }
-
-    fn max_level_hint(&self) -> Option<tracing::level_filters::LevelFilter> {
-        Some(LevelFilter::from_level(self.filter.trace_level()))
-    }
-}