Remove TODO message

## Summary

This PR implements [`use-implicit-booleaness-not-len` /
`C1802`](https://pylint.pycqa.org/en/latest/user_guide/messages/convention/use-implicit-booleaness-not-len.html)
> For sequences, (strings, lists, tuples), use the fact that empty
sequences are false.

---------

Co-authored-by: xbrtnik1 <524841@mail.muni.cz>
Co-authored-by: xbrtnik1 <xbrtnik1@mail.muni.cz>

.editorconfig

@@ -17,4 +17,7 @@ indent_size = 4
 trim_trailing_whitespace = false
 
 [*.md]
-max_line_length = 100
+max_line_length = 100
+
+[*.toml]
+indent_size = 4

.github/workflows/ci.yaml

@@ -16,7 +16,7 @@ env:
   CARGO_TERM_COLOR: always
   RUSTUP_MAX_RETRIES: 10
   PACKAGE_NAME: ruff
-  PYTHON_VERSION: "3.11"
+  PYTHON_VERSION: "3.12"
 
 jobs:
   determine_changes:
@@ -115,7 +115,7 @@ jobs:
 
   cargo-test-linux:
     name: "cargo test (linux)"
-    runs-on: ubuntu-latest
+    runs-on: depot-ubuntu-22.04-16
     needs: determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
@@ -157,9 +157,36 @@ jobs:
           name: ruff
           path: target/debug/ruff
 
+  cargo-test-linux-release:
+    name: "cargo test (linux, release)"
+    runs-on: depot-ubuntu-22.04-16
+    needs: determine_changes
+    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - name: "Install mold"
+        uses: rui314/setup-mold@v1
+      - name: "Install cargo nextest"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-nextest
+      - name: "Install cargo insta"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-insta
+      - uses: Swatinem/rust-cache@v2
+      - name: "Run tests"
+        shell: bash
+        env:
+          NEXTEST_PROFILE: "ci"
+        run: cargo insta test --release --all-features --unreferenced reject --test-runner nextest
+
   cargo-test-windows:
     name: "cargo test (windows)"
-    runs-on: windows-latest
+    runs-on: windows-latest-xlarge
     needs: determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
@@ -197,6 +224,8 @@ jobs:
           cache: "npm"
           cache-dependency-path: playground/package-lock.json
       - uses: jetli/wasm-pack-action@v0.4.0
+        with:
+          version: v0.13.1
       - uses: Swatinem/rust-cache@v2
       - name: "Test ruff_wasm"
         run: |
@@ -210,8 +239,7 @@ jobs:
   cargo-build-release:
     name: "cargo build (release)"
     runs-on: macos-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
+    if: ${{ github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
@@ -255,11 +283,11 @@ jobs:
           NEXTEST_PROFILE: "ci"
         run: cargo +${{ steps.msrv.outputs.value }} insta test --all-features --unreferenced reject --test-runner nextest
 
-  cargo-fuzz:
-    name: "cargo fuzz"
+  cargo-fuzz-build:
+    name: "cargo fuzz build"
     runs-on: ubuntu-latest
     needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
+    if: ${{ github.ref == 'refs/heads/main' }}
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
@@ -278,7 +306,7 @@ jobs:
       - run: cargo fuzz build -s none
 
   fuzz-parser:
-    name: "Fuzz the parser"
+    name: "fuzz parser"
     runs-on: ubuntu-latest
     needs:
       - cargo-test-linux
@@ -307,7 +335,7 @@ jobs:
           # Make executable, since artifact download doesn't preserve this
           chmod +x ${{ steps.download-cached-binary.outputs.download-path }}/ruff
 
-          python scripts/fuzz-parser/fuzz.py 0-500 --test-executable ${{ steps.download-cached-binary.outputs.download-path }}/ruff
+          python scripts/fuzz-parser/fuzz.py --bin ruff 0-500 --test-executable ${{ steps.download-cached-binary.outputs.download-path }}/ruff
 
   scripts:
     name: "test scripts"
@@ -331,7 +359,7 @@ jobs:
 
   ecosystem:
     name: "ecosystem"
-    runs-on: ubuntu-latest
+    runs-on: depot-ubuntu-latest-8
     needs:
       - cargo-test-linux
       - determine_changes
@@ -561,12 +589,12 @@ jobs:
         run: rustup show
       - name: "Cache rust"
         uses: Swatinem/rust-cache@v2
-      - name: "Formatter progress"
+      - name: "Run checks"
         run: scripts/formatter_ecosystem_checks.sh
       - name: "Github step summary"
-        run: cat target/progress_projects_stats.txt > $GITHUB_STEP_SUMMARY
+        run: cat target/formatter-ecosystem/stats.txt > $GITHUB_STEP_SUMMARY
       - name: "Remove checkouts from cache"
-        run: rm -r target/progress_projects
+        run: rm -r target/formatter-ecosystem
 
   check-ruff-lsp:
     name: "test ruff-lsp"

.github/workflows/daily_fuzz.yaml

@@ -49,7 +49,7 @@ jobs:
         # but this is outweighed by the fact that a release build takes *much* longer to compile in CI
         run: cargo build --locked
       - name: Fuzz
-        run: python scripts/fuzz-parser/fuzz.py $(shuf -i 0-9999999999999999999 -n 1000) --test-executable target/debug/ruff
+        run: python scripts/fuzz-parser/fuzz.py --bin ruff $(shuf -i 0-9999999999999999999 -n 1000) --test-executable target/debug/ruff
 
   create-issue-on-failure:
     name: Create an issue if the daily fuzz surfaced any bugs

.github/workflows/publish-playground.yml

@@ -47,7 +47,7 @@ jobs:
         working-directory: playground
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.9.0
+        uses: cloudflare/wrangler-action@v3.12.1
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/release.yml

@@ -1,4 +1,4 @@
-# This file was autogenerated by cargo-dist: https://opensource.axo.dev/cargo-dist/
+# This file was autogenerated by dist: https://opensource.axo.dev/cargo-dist/
 #
 # Copyright 2022-2024, axodotdev
 # SPDX-License-Identifier: MIT or Apache-2.0
@@ -6,7 +6,7 @@
 # CI that:
 #
 # * checks for a Git Tag that looks like a release
-# * builds artifacts with cargo-dist (archives, installers, hashes)
+# * builds artifacts with dist (archives, installers, hashes)
 # * uploads those artifacts to temporary workflow zip
 # * on success, uploads the artifacts to a GitHub Release
 #
@@ -24,10 +24,10 @@ permissions:
 # must be a Cargo-style SemVer Version (must have at least major.minor.patch).
 #
 # If PACKAGE_NAME is specified, then the announcement will be for that
-# package (erroring out if it doesn't have the given version or isn't cargo-dist-able).
+# package (erroring out if it doesn't have the given version or isn't dist-able).
 #
 # If PACKAGE_NAME isn't specified, then the announcement will be for all
-# (cargo-dist-able) packages in the workspace with that version (this mode is
+# (dist-able) packages in the workspace with that version (this mode is
 # intended for workspaces with only one dist-able package, or with all dist-able
 # packages versioned/released in lockstep).
 #
@@ -48,7 +48,7 @@ on:
         type: string
 
 jobs:
-  # Run 'cargo dist plan' (or host) to determine what tasks we need to do
+  # Run 'dist plan' (or host) to determine what tasks we need to do
   plan:
     runs-on: "ubuntu-20.04"
     outputs:
@@ -62,16 +62,16 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      - name: Install cargo-dist
+      - name: Install dist
         # we specify bash to get pipefail; it guards against the `curl` command
         # failing. otherwise `sh` won't catch that `curl` returned non-0
         shell: bash
-        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.22.1/cargo-dist-installer.sh | sh"
-      - name: Cache cargo-dist
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.25.2-prerelease.3/cargo-dist-installer.sh | sh"
+      - name: Cache dist
         uses: actions/upload-artifact@v4
         with:
           name: cargo-dist-cache
-          path: ~/.cargo/bin/cargo-dist
+          path: ~/.cargo/bin/dist
       # sure would be cool if github gave us proper conditionals...
       # so here's a doubly-nested ternary-via-truthiness to try to provide the best possible
       # functionality based on whether this is a pull_request, and whether it's from a fork.
@@ -79,8 +79,8 @@ jobs:
       # but also really annoying to build CI around when it needs secrets to work right.)
       - id: plan
         run: |
-          cargo dist ${{ (inputs.tag && inputs.tag != 'dry-run' && format('host --steps=create --tag={0}', inputs.tag)) || 'plan' }} --output-format=json > plan-dist-manifest.json
-          echo "cargo dist ran successfully"
+          dist ${{ (inputs.tag && inputs.tag != 'dry-run' && format('host --steps=create --tag={0}', inputs.tag)) || 'plan' }} --output-format=json > plan-dist-manifest.json
+          echo "dist ran successfully"
           cat plan-dist-manifest.json
           echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
       - name: "Upload dist-manifest.json"
@@ -124,12 +124,12 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      - name: Install cached cargo-dist
+      - name: Install cached dist
         uses: actions/download-artifact@v4
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/cargo-dist
+      - run: chmod +x ~/.cargo/bin/dist
       # Get all the local artifacts for the global tasks to use (for e.g. checksums)
       - name: Fetch local artifacts
         uses: actions/download-artifact@v4
@@ -140,8 +140,8 @@ jobs:
       - id: cargo-dist
         shell: bash
         run: |
-          cargo dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
-          echo "cargo dist ran successfully"
+          dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
+          echo "dist ran successfully"
 
           # Parse out what we just built and upload it to scratch storage
           echo "paths<<EOF" >> "$GITHUB_OUTPUT"
@@ -174,12 +174,12 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      - name: Install cached cargo-dist
+      - name: Install cached dist
         uses: actions/download-artifact@v4
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/cargo-dist
+      - run: chmod +x ~/.cargo/bin/dist
       # Fetch artifacts from scratch-storage
       - name: Fetch artifacts
         uses: actions/download-artifact@v4
@@ -191,7 +191,7 @@ jobs:
       - id: host
         shell: bash
         run: |
-          cargo dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
+          dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
           echo "artifacts uploaded and released successfully"
           cat dist-manifest.json
           echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
@@ -202,15 +202,46 @@ 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
+      - host
+    if: ${{ !fromJson(needs.plan.outputs.val).announcement_is_prerelease || fromJson(needs.plan.outputs.val).publish_prereleases }}
+    uses: ./.github/workflows/publish-wasm.yml
+    with:
+      plan: ${{ needs.plan.outputs.val }}
+    secrets: inherit
+    # publish jobs get escalated permissions
+    permissions:
+      "contents": "read"
+      "id-token": "write"
+      "packages": "write"
+
   # Create a GitHub Release while uploading all files to it
   announce:
     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' }}
+    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 }}

.pre-commit-config.yaml

@@ -17,7 +17,7 @@ exclude: |
 
 repos:
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.21
+    rev: v0.23
     hooks:
       - id: validate-pyproject
 
@@ -51,11 +51,15 @@ repos:
       - id: blacken-docs
         args: ["--pyi", "--line-length", "130"]
         files: '^crates/.*/resources/mdtest/.*\.md'
+        exclude: |
+          (?x)^(
+            .*?invalid(_.+)*_syntax\.md
+          )$
         additional_dependencies:
           - black==24.10.0
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.26.0
+    rev: v1.27.3
     hooks:
       - id: typos
 
@@ -69,7 +73,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.0
+    rev: v0.7.4
     hooks:
       - id: ruff-format
       - id: ruff

BREAKING_CHANGES.md

@@ -1,5 +1,30 @@
 # Breaking Changes
 
+## 0.8.0
+
+- **Default to Python 3.9**
+
+    Ruff now defaults to Python 3.9 instead of 3.8 if no explicit Python version is configured using [`ruff.target-version`](https://docs.astral.sh/ruff/settings/#target-version) or [`project.requires-python`](https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#python-requires) ([#13896](https://github.com/astral-sh/ruff/pull/13896))
+
+- **Changed location of `pydoclint` diagnostics**
+
+    [`pydoclint`](https://docs.astral.sh/ruff/rules/#pydoclint-doc) diagnostics now point to the first-line of the problematic docstring. Previously, this was not the case.
+
+    If you've opted into these preview rules but have them suppressed using
+    [`noqa`](https://docs.astral.sh/ruff/linter/#error-suppression) comments in
+    some places, this change may mean that you need to move the `noqa` suppression
+    comments. Most users should be unaffected by this change.
+
+- **Use XDG (i.e. `~/.local/bin`) instead of the Cargo home directory in the standalone installer**
+
+    Previously, Ruff's installer used `$CARGO_HOME` or `~/.cargo/bin` for its target install directory. Now, Ruff will be installed into `$XDG_BIN_HOME`, `$XDG_DATA_HOME/../bin`, or `~/.local/bin` (in that order).
+
+    This change is only relevant to users of the standalone Ruff installer (using the shell or PowerShell script). If you installed Ruff using uv or pip, you should be unaffected.
+
+- **Changes to the line width calculation**
+
+    Ruff now uses a new version of the [unicode-width](https://github.com/unicode-rs/unicode-width) Rust crate to calculate the line width. In very rare cases, this may lead to lines containing Unicode characters being reformatted, or being considered too long when they were not before ([`E501`](https://docs.astral.sh/ruff/rules/line-too-long/)).
+
 ## 0.7.0
 
 - The pytest rules `PT001` and `PT023` now default to omitting the decorator parentheses when there are no arguments

CHANGELOG.md

@@ -1,5 +1,190 @@
 # Changelog
 
+## 0.8.0
+
+Check out the [blog post](https://astral.sh/blog/ruff-v0.8.0) for a migration guide and overview of the changes!
+
+### Breaking changes
+
+See also, the "Remapped rules" section which may result in disabled rules.
+
+- **Default to Python 3.9**
+
+    Ruff now defaults to Python 3.9 instead of 3.8 if no explicit Python version is configured using [`ruff.target-version`](https://docs.astral.sh/ruff/settings/#target-version) or [`project.requires-python`](https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#python-requires) ([#13896](https://github.com/astral-sh/ruff/pull/13896))
+
+- **Changed location of `pydoclint` diagnostics**
+
+    [`pydoclint`](https://docs.astral.sh/ruff/rules/#pydoclint-doc) diagnostics now point to the first-line of the problematic docstring. Previously, this was not the case.
+
+    If you've opted into these preview rules but have them suppressed using
+    [`noqa`](https://docs.astral.sh/ruff/linter/#error-suppression) comments in
+    some places, this change may mean that you need to move the `noqa` suppression
+    comments. Most users should be unaffected by this change.
+
+- **Use XDG (i.e. `~/.local/bin`) instead of the Cargo home directory in the standalone installer**
+
+    Previously, Ruff's installer used `$CARGO_HOME` or `~/.cargo/bin` for its target install directory. Now, Ruff will be installed into `$XDG_BIN_HOME`, `$XDG_DATA_HOME/../bin`, or `~/.local/bin` (in that order).
+
+    This change is only relevant to users of the standalone Ruff installer (using the shell or PowerShell script). If you installed Ruff using uv or pip, you should be unaffected.
+
+- **Changes to the line width calculation**
+
+    Ruff now uses a new version of the [unicode-width](https://github.com/unicode-rs/unicode-width) Rust crate to calculate the line width. In very rare cases, this may lead to lines containing Unicode characters being reformatted, or being considered too long when they were not before ([`E501`](https://docs.astral.sh/ruff/rules/line-too-long/)).
+
+### Removed Rules
+
+The following deprecated rules have been removed:
+
+- [`missing-type-self`](https://docs.astral.sh/ruff/rules/missing-type-self/) (`ANN101`)
+- [`missing-type-cls`](https://docs.astral.sh/ruff/rules/missing-type-cls/) (`ANN102`)
+- [`syntax-error`](https://docs.astral.sh/ruff/rules/syntax-error/) (`E999`)
+- [`pytest-missing-fixture-name-underscore`](https://docs.astral.sh/ruff/rules/pytest-missing-fixture-name-underscore/) (`PT004`)
+- [`pytest-incorrect-fixture-name-underscore`](https://docs.astral.sh/ruff/rules/pytest-incorrect-fixture-name-underscore/) (`PT005`)
+- [`unpacked-list-comprehension`](https://docs.astral.sh/ruff/rules/unpacked-list-comprehension/) (`UP027`)
+
+### Remapped rules
+
+The following rules have been remapped to new rule codes:
+
+- [`flake8-type-checking`](https://docs.astral.sh/ruff/rules/#flake8-type-checking-tc): `TCH` to `TC`
+
+### Stabilization
+
+The following rules have been stabilized and are no longer in preview:
+
+- [`builtin-import-shadowing`](https://docs.astral.sh/ruff/rules/builtin-import-shadowing/) (`A004`)
+- [`mutable-contextvar-default`](https://docs.astral.sh/ruff/rules/mutable-contextvar-default/) (`B039`)
+- [`fast-api-redundant-response-model`](https://docs.astral.sh/ruff/rules/fast-api-redundant-response-model/) (`FAST001`)
+- [`fast-api-non-annotated-dependency`](https://docs.astral.sh/ruff/rules/fast-api-non-annotated-dependency/) (`FAST002`)
+- [`dict-index-missing-items`](https://docs.astral.sh/ruff/rules/dict-index-missing-items/) (`PLC0206`)
+- [`pep484-style-positional-only-parameter`](https://docs.astral.sh/ruff/rules/pep484-style-positional-only-parameter/) (`PYI063`)
+- [`redundant-final-literal`](https://docs.astral.sh/ruff/rules/redundant-final-literal/) (`PYI064`)
+- [`bad-version-info-order`](https://docs.astral.sh/ruff/rules/bad-version-info-order/) (`PYI066`)
+- [`parenthesize-chained-operators`](https://docs.astral.sh/ruff/rules/parenthesize-chained-operators/) (`RUF021`)
+- [`unsorted-dunder-all`](https://docs.astral.sh/ruff/rules/unsorted-dunder-all/) (`RUF022`)
+- [`unsorted-dunder-slots`](https://docs.astral.sh/ruff/rules/unsorted-dunder-slots/) (`RUF023`)
+- [`assert-with-print-message`](https://docs.astral.sh/ruff/rules/assert-with-print-message/) (`RUF030`)
+- [`unnecessary-default-type-args`](https://docs.astral.sh/ruff/rules/unnecessary-default-type-args/) (`UP043`)
+
+The following behaviors have been stabilized:
+
+- [`ambiguous-variable-name`](https://docs.astral.sh/ruff/rules/ambiguous-variable-name/) (`E741`): Violations in stub files are now ignored. Stub authors typically don't control variable names.
+- [`printf-string-formatting`](https://docs.astral.sh/ruff/rules/printf-string-formatting/) (`UP031`): Report all `printf`-like usages even if no autofix is available
+
+The following fixes have been stabilized:
+
+- [`zip-instead-of-pairwise`](https://docs.astral.sh/ruff/rules/zip-instead-of-pairwise/) (`RUF007`)
+
+### Preview features
+
+- \[`flake8-datetimez`\] Exempt `min.time()` and `max.time()` (`DTZ901`) ([#14394](https://github.com/astral-sh/ruff/pull/14394))
+- \[`flake8-pie`\] Mark fix as unsafe if the following statement is a string literal (`PIE790`) ([#14393](https://github.com/astral-sh/ruff/pull/14393))
+- \[`flake8-pyi`\] New rule `redundant-none-literal` (`PYI061`) ([#14316](https://github.com/astral-sh/ruff/pull/14316))
+- \[`flake8-pyi`\] Add autofix for `redundant-numeric-union` (`PYI041`) ([#14273](https://github.com/astral-sh/ruff/pull/14273))
+- \[`ruff`\] New rule `map-int-version-parsing` (`RUF048`) ([#14373](https://github.com/astral-sh/ruff/pull/14373))
+- \[`ruff`\] New rule `redundant-bool-literal` (`RUF038`) ([#14319](https://github.com/astral-sh/ruff/pull/14319))
+- \[`ruff`\] New rule `unraw-re-pattern` (`RUF039`) ([#14446](https://github.com/astral-sh/ruff/pull/14446))
+- \[`pycodestyle`\] Exempt `pytest.importorskip()` calls (`E402`) ([#14474](https://github.com/astral-sh/ruff/pull/14474))
+- \[`pylint`\] Autofix suggests using sets when possible (`PLR1714`) ([#14372](https://github.com/astral-sh/ruff/pull/14372))
+
+### Rule changes
+
+- [`invalid-pyproject-toml`](https://docs.astral.sh/ruff/rules/invalid-pyproject-toml/) (`RUF200`): Updated to reflect the provisionally accepted [PEP 639](https://peps.python.org/pep-0639/).
+- \[`flake8-pyi`\] Avoid panic in unfixable case (`PYI041`) ([#14402](https://github.com/astral-sh/ruff/pull/14402))
+- \[`flake8-type-checking`\] Correctly handle quotes in subscript expression when generating an autofix ([#14371](https://github.com/astral-sh/ruff/pull/14371))
+- \[`pylint`\] Suggest correct autofix for `__contains__` (`PLC2801`) ([#14424](https://github.com/astral-sh/ruff/pull/14424))
+
+### Configuration
+
+- Ruff now emits a warning instead of an error when a configuration [`ignore`](https://docs.astral.sh/ruff/settings/#lint_ignore)s a rule that has been removed ([#14435](https://github.com/astral-sh/ruff/pull/14435))
+- Ruff now validates that `lint.flake8-import-conventions.aliases` only uses valid module names and aliases ([#14477](https://github.com/astral-sh/ruff/pull/14477))
+
+## 0.7.4
+
+### Preview features
+
+- \[`flake8-datetimez`\] Detect usages of `datetime.max`/`datetime.min` (`DTZ901`) ([#14288](https://github.com/astral-sh/ruff/pull/14288))
+- \[`flake8-logging`\] Implement `root-logger-calls` (`LOG015`) ([#14302](https://github.com/astral-sh/ruff/pull/14302))
+- \[`flake8-no-pep420`\] Detect empty implicit namespace packages (`INP001`) ([#14236](https://github.com/astral-sh/ruff/pull/14236))
+- \[`flake8-pyi`\] Add "replace with `Self`" fix (`PYI019`) ([#14238](https://github.com/astral-sh/ruff/pull/14238))
+- \[`perflint`\] Implement quick-fix for `manual-list-comprehension` (`PERF401`) ([#13919](https://github.com/astral-sh/ruff/pull/13919))
+- \[`pylint`\] Implement `shallow-copy-environ` (`W1507`) ([#14241](https://github.com/astral-sh/ruff/pull/14241))
+- \[`ruff`\] Implement `none-not-at-end-of-union` (`RUF036`) ([#14314](https://github.com/astral-sh/ruff/pull/14314))
+- \[`ruff`\] Implementation `unsafe-markup-call` from `flake8-markupsafe` plugin (`RUF035`) ([#14224](https://github.com/astral-sh/ruff/pull/14224))
+- \[`ruff`\] Report problems for `attrs` dataclasses (`RUF008`, `RUF009`) ([#14327](https://github.com/astral-sh/ruff/pull/14327))
+
+### Rule changes
+
+- \[`flake8-boolean-trap`\] Exclude dunder methods that define operators (`FBT001`) ([#14203](https://github.com/astral-sh/ruff/pull/14203))
+- \[`flake8-pyi`\] Add "replace with `Self`" fix (`PYI034`) ([#14217](https://github.com/astral-sh/ruff/pull/14217))
+- \[`flake8-pyi`\] Always autofix `duplicate-union-members` (`PYI016`) ([#14270](https://github.com/astral-sh/ruff/pull/14270))
+- \[`flake8-pyi`\] Improve autofix for nested and mixed type unions for `unnecessary-type-union` (`PYI055`) ([#14272](https://github.com/astral-sh/ruff/pull/14272))
+- \[`flake8-pyi`\] Mark fix as unsafe when type annotation contains comments for `duplicate-literal-member` (`PYI062`) ([#14268](https://github.com/astral-sh/ruff/pull/14268))
+
+### Server
+
+- Use the current working directory to resolve settings from `ruff.configuration` ([#14352](https://github.com/astral-sh/ruff/pull/14352))
+
+### Bug fixes
+
+- Avoid conflicts between `PLC014` (`useless-import-alias`) and `I002` (`missing-required-import`) by considering `lint.isort.required-imports` for `PLC014` ([#14287](https://github.com/astral-sh/ruff/pull/14287))
+- \[`flake8-type-checking`\] Skip quoting annotation if it becomes invalid syntax (`TCH001`)
+- \[`flake8-pyi`\] Avoid using `typing.Self` in stub files pre-Python 3.11 (`PYI034`) ([#14230](https://github.com/astral-sh/ruff/pull/14230))
+- \[`flake8-pytest-style`\] Flag `pytest.raises` call with keyword argument `expected_exception` (`PT011`) ([#14298](https://github.com/astral-sh/ruff/pull/14298))
+- \[`flake8-simplify`\] Infer "unknown" truthiness for literal iterables whose items are all unpacks (`SIM222`) ([#14263](https://github.com/astral-sh/ruff/pull/14263))
+- \[`flake8-type-checking`\] Fix false positives for `typing.Annotated` (`TCH001`) ([#14311](https://github.com/astral-sh/ruff/pull/14311))
+- \[`pylint`\] Allow `await` at the top-level scope of a notebook (`PLE1142`) ([#14225](https://github.com/astral-sh/ruff/pull/14225))
+- \[`pylint`\] Fix miscellaneous issues in `await-outside-async` detection (`PLE1142`) ([#14218](https://github.com/astral-sh/ruff/pull/14218))
+- \[`pyupgrade`\] Avoid applying PEP 646 rewrites in invalid contexts (`UP044`) ([#14234](https://github.com/astral-sh/ruff/pull/14234))
+- \[`pyupgrade`\] Detect permutations in redundant open modes (`UP015`) ([#14255](https://github.com/astral-sh/ruff/pull/14255))
+- \[`refurb`\] Avoid triggering `hardcoded-string-charset` for reordered sets (`FURB156`) ([#14233](https://github.com/astral-sh/ruff/pull/14233))
+- \[`refurb`\] Further special cases added to `verbose-decimal-constructor` (`FURB157`) ([#14216](https://github.com/astral-sh/ruff/pull/14216))
+- \[`refurb`\] Use `UserString` instead of non-existent `UserStr` (`FURB189`) ([#14209](https://github.com/astral-sh/ruff/pull/14209))
+- \[`ruff`\] Avoid treating lowercase letters as `# noqa` codes (`RUF100`) ([#14229](https://github.com/astral-sh/ruff/pull/14229))
+- \[`ruff`\] Do not report when `Optional` has no type arguments (`RUF013`) ([#14181](https://github.com/astral-sh/ruff/pull/14181))
+
+### Documentation
+
+- Add "Notebook behavior" section for `F704`, `PLE1142` ([#14266](https://github.com/astral-sh/ruff/pull/14266))
+- Document comment policy around fix safety ([#14300](https://github.com/astral-sh/ruff/pull/14300))
+
+## 0.7.3
+
+### Preview features
+
+- Formatter: Disallow single-line implicit concatenated strings ([#13928](https://github.com/astral-sh/ruff/pull/13928))
+- \[`flake8-pyi`\] Include all Python file types for `PYI006` and `PYI066` ([#14059](https://github.com/astral-sh/ruff/pull/14059))
+- \[`flake8-simplify`\] Implement `split-of-static-string` (`SIM905`) ([#14008](https://github.com/astral-sh/ruff/pull/14008))
+- \[`refurb`\] Implement `subclass-builtin` (`FURB189`) ([#14105](https://github.com/astral-sh/ruff/pull/14105))
+- \[`ruff`\] Improve diagnostic messages and docs (`RUF031`, `RUF032`, `RUF034`) ([#14068](https://github.com/astral-sh/ruff/pull/14068))
+
+### Rule changes
+
+- Detect items that hash to same value in duplicate sets (`B033`, `PLC0208`) ([#14064](https://github.com/astral-sh/ruff/pull/14064))
+- \[`eradicate`\] Better detection of IntelliJ language injection comments (`ERA001`) ([#14094](https://github.com/astral-sh/ruff/pull/14094))
+- \[`flake8-pyi`\] Add autofix for `docstring-in-stub` (`PYI021`) ([#14150](https://github.com/astral-sh/ruff/pull/14150))
+- \[`flake8-pyi`\] Update `duplicate-literal-member` (`PYI062`) to alawys provide an autofix ([#14188](https://github.com/astral-sh/ruff/pull/14188))
+- \[`pyflakes`\] Detect items that hash to same value in duplicate dictionaries (`F601`) ([#14065](https://github.com/astral-sh/ruff/pull/14065))
+- \[`ruff`\] Fix false positive for decorators (`RUF028`) ([#14061](https://github.com/astral-sh/ruff/pull/14061))
+
+### Bug fixes
+
+- Avoid parsing joint rule codes as distinct codes in `# noqa` ([#12809](https://github.com/astral-sh/ruff/pull/12809))
+- \[`eradicate`\] ignore `# language=` in commented-out-code rule (ERA001) ([#14069](https://github.com/astral-sh/ruff/pull/14069))
+- \[`flake8-bugbear`\] - do not run `mutable-argument-default` on stubs (`B006`) ([#14058](https://github.com/astral-sh/ruff/pull/14058))
+- \[`flake8-builtins`\] Skip lambda expressions in `builtin-argument-shadowing (A002)` ([#14144](https://github.com/astral-sh/ruff/pull/14144))
+- \[`flake8-comprehension`\] Also remove trailing comma while fixing `C409` and `C419` ([#14097](https://github.com/astral-sh/ruff/pull/14097))
+- \[`flake8-simplify`\] Allow `open` without context manager in `return` statement (`SIM115`) ([#14066](https://github.com/astral-sh/ruff/pull/14066))
+- \[`pylint`\] Respect hash-equivalent literals in `iteration-over-set` (`PLC0208`) ([#14063](https://github.com/astral-sh/ruff/pull/14063))
+- \[`pylint`\] Update known dunder methods for Python 3.13 (`PLW3201`) ([#14146](https://github.com/astral-sh/ruff/pull/14146))
+- \[`pyupgrade`\] - ignore kwarg unpacking for `UP044` ([#14053](https://github.com/astral-sh/ruff/pull/14053))
+- \[`refurb`\] Parse more exotic decimal strings in `verbose-decimal-constructor` (`FURB157`) ([#14098](https://github.com/astral-sh/ruff/pull/14098))
+
+### Documentation
+
+- Add links to missing related options within rule documentations ([#13971](https://github.com/astral-sh/ruff/pull/13971))
+- Add rule short code to mkdocs tags to allow searching via rule codes ([#14040](https://github.com/astral-sh/ruff/pull/14040))
+
 ## 0.7.2
 
 ### Preview features
@@ -892,7 +1077,7 @@ The following deprecated CLI commands have been removed:
 ### Preview features
 
 - \[`flake8-bugbear`\] Implement `return-in-generator` (`B901`) ([#11644](https://github.com/astral-sh/ruff/pull/11644))
-- \[`flake8-pyi`\] Implement `PYI063` ([#11699](https://github.com/astral-sh/ruff/pull/11699))
+- \[`flake8-pyi`\] Implement `pep484-style-positional-only-parameter` (`PYI063`) ([#11699](https://github.com/astral-sh/ruff/pull/11699))
 - \[`pygrep_hooks`\] Check blanket ignores via file-level pragmas (`PGH004`) ([#11540](https://github.com/astral-sh/ruff/pull/11540))
 
 ### Rule changes

Cargo.toml

@@ -65,7 +65,8 @@ compact_str = "0.8.0"
 criterion = { version = "0.5.1", default-features = false }
 crossbeam = { version = "0.8.4" }
 dashmap = { version = "6.0.1" }
-dir-test = { version = "0.3.0" }
+dir-test = { version = "0.4.0" }
+dunce = { version = "1.0.5" }
 drop_bomb = { version = "0.1.5" }
 env_logger = { version = "0.11.0" }
 etcetera = { version = "0.8.0" }
@@ -81,6 +82,7 @@ hashbrown = { version = "0.15.0", default-features = false, features = [
 ignore = { version = "0.4.22" }
 imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
+indexmap = { version = "2.6.0" }
 indicatif = { version = "0.17.8" }
 indoc = { version = "2.0.4" }
 insta = { version = "1.35.1" }
@@ -101,7 +103,7 @@ matchit = { version = "0.8.1" }
 memchr = { version = "2.7.1" }
 mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
-notify = { version = "6.1.1" }
+notify = { version = "7.0.0" }
 ordermap = { version = "0.5.0" }
 path-absolutize = { version = "3.1.1" }
 path-slash = { version = "0.2.1" }
@@ -109,7 +111,7 @@ pathdiff = { version = "0.2.1" }
 pep440_rs = { version = "0.7.1" }
 pretty_assertions = "1.3.0"
 proc-macro2 = { version = "1.0.79" }
-pyproject-toml = { version = "0.9.0" }
+pyproject-toml = { version = "0.13.4" }
 quick-junit = { version = "0.5.0" }
 quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }
@@ -135,7 +137,7 @@ strum_macros = { version = "0.26.0" }
 syn = { version = "2.0.55" }
 tempfile = { version = "3.9.0" }
 test-case = { version = "3.3.1" }
-thiserror = { version = "1.0.58" }
+thiserror = { version = "2.0.0" }
 tikv-jemallocator = { version = "0.6.0" }
 toml = { version = "0.8.11" }
 tracing = { version = "0.1.40" }
@@ -149,7 +151,7 @@ tracing-tree = { version = "0.4.0" }
 typed-arena = { version = "2.0.2" }
 unic-ucd-category = { version = "0.9" }
 unicode-ident = { version = "1.0.12" }
-unicode-width = { version = "0.1.11" }
+unicode-width = { version = "0.2.0" }
 unicode_names2 = { version = "1.2.2" }
 unicode-normalization = { version = "0.1.23" }
 ureq = { version = "2.9.6" }
@@ -246,10 +248,10 @@ debug = 1
 [profile.dist]
 inherits = "release"
 
-# Config for 'cargo dist'
+# Config for 'dist'
 [workspace.metadata.dist]
-# The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax)
-cargo-dist-version = "0.22.1"
+# The preferred dist version to use in CI (Cargo.toml SemVer syntax)
+cargo-dist-version = "0.25.2-prerelease.3"
 # CI backends to support
 ci = "github"
 # The installers to generate for each app
@@ -280,29 +282,25 @@ targets = [
 ]
 # Whether to auto-include files like READMEs, LICENSEs, and CHANGELOGs (default true)
 auto-includes = false
-# Whether cargo-dist should create a GitHub Release or use an existing draft
+# Whether dist should create a Github Release or use an existing draft
 create-release = true
 # Which actions to run on pull requests
 pr-run-mode = "skip"
 # Whether CI should trigger releases with dispatches instead of tag pushes
 dispatch-releases = true
-# Which phase cargo-dist should use to create the GitHub release
+# Which phase dist should use to create the GitHub release
 github-release = "announce"
 # Whether CI should include auto-generated code to build local artifacts
 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-pypi", "./publish-wasm"]
+publish-jobs = ["./publish-pypi", "./publish-wasm"]
 # Post-announce jobs to run in CI
-post-announce-jobs = [
-    "./notify-dependents",
-    "./publish-docs",
-    "./publish-playground",
-]
+post-announce-jobs = ["./notify-dependents", "./publish-docs", "./publish-playground"]
 # Custom permissions for GitHub Jobs
 github-custom-job-permissions = { "build-docker" = { packages = "write", contents = "read" }, "publish-wasm" = { contents = "read", id-token = "write", packages = "write" } }
 # Whether to install an updater program
 install-updater = false
 # Path that installers should place binaries in
-install-path = "CARGO_HOME"
+install-path = ["$XDG_BIN_HOME/", "$XDG_DATA_HOME/../bin", "~/.local/bin"]

README.md

@@ -136,8 +136,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.7.2/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.7.2/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.8.0/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.8.0/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -170,7 +170,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.7.2
+  rev: v0.8.0
   hooks:
     # Run the linter.
     - id: ruff
@@ -238,8 +238,8 @@ exclude = [
 line-length = 88
 indent-width = 4
 
-# Assume Python 3.8
-target-version = "py38"
+# Assume Python 3.9
+target-version = "py39"
 
 [lint]
 # Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.

_typos.toml

@@ -1,6 +1,11 @@
 [files]
 # https://github.com/crate-ci/typos/issues/868
-extend-exclude = ["crates/red_knot_vendored/vendor/**/*", "**/resources/**/*", "**/snapshots/**/*"]
+extend-exclude = [
+  "crates/red_knot_vendored/vendor/**/*",
+  "**/resources/**/*",
+  "**/snapshots/**/*",
+  "crates/red_knot_workspace/src/workspace/pyproject/package_name.rs"
+]
 
 [default.extend-words]
 "arange" = "arange"  # e.g. `numpy.arange`

crates/red_knot/Cargo.toml

@@ -34,6 +34,7 @@ tracing-tree = { workspace = true }
 [dev-dependencies]
 filetime = { workspace = true }
 tempfile = { workspace = true }
+ruff_db = { workspace = true, features = ["testing"] }
 
 [lints]
 workspace = true

crates/red_knot/src/main.rs

@@ -5,8 +5,6 @@ use anyhow::{anyhow, Context};
 use clap::Parser;
 use colored::Colorize;
 use crossbeam::channel as crossbeam_channel;
-use salsa::plumbing::ZalsaDatabase;
-
 use red_knot_python_semantic::SitePackages;
 use red_knot_server::run_server;
 use red_knot_workspace::db::RootDatabase;
@@ -14,7 +12,9 @@ use red_knot_workspace::watch;
 use red_knot_workspace::watch::WorkspaceWatcher;
 use red_knot_workspace::workspace::settings::Configuration;
 use red_knot_workspace::workspace::WorkspaceMetadata;
+use ruff_db::diagnostic::Diagnostic;
 use ruff_db::system::{OsSystem, System, SystemPath, SystemPathBuf};
+use salsa::plumbing::ZalsaDatabase;
 use target_version::TargetVersion;
 
 use crate::logging::{setup_tracing, Verbosity};
@@ -183,10 +183,10 @@ fn run() -> anyhow::Result<ExitStatus> {
 
     let system = OsSystem::new(cwd.clone());
     let cli_configuration = args.to_configuration(&cwd);
-    let workspace_metadata = WorkspaceMetadata::from_path(
+    let workspace_metadata = WorkspaceMetadata::discover(
         system.current_directory(),
         &system,
-        Some(cli_configuration.clone()),
+        Some(&cli_configuration),
     )?;
 
     // TODO: Use the `program_settings` to compute the key for the database's persistent
@@ -318,8 +318,9 @@ impl MainLoop {
                 } => {
                     let has_diagnostics = !result.is_empty();
                     if check_revision == revision {
+                        #[allow(clippy::print_stdout)]
                         for diagnostic in result {
-                            tracing::error!("{}", diagnostic);
+                            println!("{}", diagnostic.display(db));
                         }
                     } else {
                         tracing::debug!(
@@ -378,7 +379,10 @@ impl MainLoopCancellationToken {
 #[derive(Debug)]
 enum MainLoopMessage {
     CheckWorkspace,
-    CheckCompleted { result: Vec<String>, revision: u64 },
+    CheckCompleted {
+        result: Vec<Box<dyn Diagnostic>>,
+        revision: u64,
+    },
     ApplyChanges(Vec<watch::ChangeEvent>),
     Exit,
 }

crates/red_knot/src/target_version.rs

@@ -4,8 +4,8 @@
 #[derive(Copy, Clone, Hash, Debug, PartialEq, Eq, PartialOrd, Ord, Default, clap::ValueEnum)]
 pub enum TargetVersion {
     Py37,
-    #[default]
     Py38,
+    #[default]
     Py39,
     Py310,
     Py311,
@@ -46,3 +46,17 @@ impl From<TargetVersion> for red_knot_python_semantic::PythonVersion {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::target_version::TargetVersion;
+    use red_knot_python_semantic::PythonVersion;
+
+    #[test]
+    fn same_default_as_python_version() {
+        assert_eq!(
+            PythonVersion::from(TargetVersion::default()),
+            PythonVersion::default()
+        );
+    }
+}

crates/red_knot/tests/file_watching.rs

@@ -4,9 +4,8 @@ use std::io::Write;
 use std::time::Duration;
 
 use anyhow::{anyhow, Context};
-
 use red_knot_python_semantic::{resolve_module, ModuleName, Program, PythonVersion, SitePackages};
-use red_knot_workspace::db::RootDatabase;
+use red_knot_workspace::db::{Db, RootDatabase};
 use red_knot_workspace::watch;
 use red_knot_workspace::watch::{directory_watcher, WorkspaceWatcher};
 use red_knot_workspace::workspace::settings::{Configuration, SearchPathConfiguration};
@@ -14,6 +13,7 @@ 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::testing::{setup_logging, setup_logging_with_filter};
 use ruff_db::Upcast;
 
 struct TestCase {
@@ -46,6 +46,8 @@ impl TestCase {
     }
 
     fn try_stop_watch(&mut self, timeout: Duration) -> Option<Vec<watch::ChangeEvent>> {
+        tracing::debug!("Try stopping watch with timeout {:?}", timeout);
+
         let watcher = self
             .watcher
             .take()
@@ -55,8 +57,11 @@ impl TestCase {
             .changes_receiver
             .recv_timeout(timeout)
             .unwrap_or_default();
+
         watcher.flush();
+        tracing::debug!("Flushed file watcher");
         watcher.stop();
+        tracing::debug!("Stopping file watcher");
 
         for event in &self.changes_receiver {
             all_events.extend(event);
@@ -69,7 +74,6 @@ impl TestCase {
         Some(all_events)
     }
 
-    #[cfg(unix)]
     fn take_watch_changes(&self) -> Vec<watch::ChangeEvent> {
         self.try_take_watch_changes(Duration::from_secs(10))
             .expect("Expected watch changes but observed none")
@@ -110,8 +114,8 @@ impl TestCase {
     ) -> anyhow::Result<()> {
         let program = Program::get(self.db());
 
-        self.configuration.search_paths = configuration.clone();
-        let new_settings = configuration.into_settings(self.db.workspace().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)?;
 
@@ -204,7 +208,9 @@ where
             .as_utf8_path()
             .canonicalize_utf8()
             .with_context(|| "Failed to canonicalize root path.")?,
-    );
+    )
+    .simplified()
+    .to_path_buf();
 
     let workspace_path = root_path.join("workspace");
 
@@ -241,8 +247,7 @@ where
         search_paths,
     };
 
-    let workspace =
-        WorkspaceMetadata::from_path(&workspace_path, &system, Some(configuration.clone()))?;
+    let workspace = WorkspaceMetadata::discover(&workspace_path, &system, Some(&configuration))?;
 
     let db = RootDatabase::new(workspace, system)?;
 
@@ -599,6 +604,8 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
 
 #[test]
 fn directory_renamed() -> anyhow::Result<()> {
+    let _tracing = setup_logging_with_filter("file_watching=TRACE,red_knot=TRACE");
+
     let mut case = setup([
         ("bar.py", "import sub.a"),
         ("sub/__init__.py", ""),
@@ -639,6 +646,10 @@ fn directory_renamed() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
+    for event in &changes {
+        tracing::debug!("Event: {:?}", event);
+    }
+
     case.apply_changes(changes);
 
     // `import sub.a` should no longer resolve
@@ -1311,3 +1322,138 @@ mod unix {
         Ok(())
     }
 }
+
+#[test]
+fn nested_packages_delete_root() -> anyhow::Result<()> {
+    let mut case = setup(|root: &SystemPath, workspace_root: &SystemPath| {
+        std::fs::write(
+            workspace_root.join("pyproject.toml").as_std_path(),
+            r#"
+            [project]
+            name = "inner"
+            "#,
+        )?;
+
+        std::fs::write(
+            root.join("pyproject.toml").as_std_path(),
+            r#"
+            [project]
+            name = "outer"
+            "#,
+        )?;
+
+        Ok(())
+    })?;
+
+    assert_eq!(
+        case.db().workspace().root(case.db()),
+        &*case.workspace_path("")
+    );
+
+    std::fs::remove_file(case.workspace_path("pyproject.toml").as_std_path())?;
+
+    let changes = case.stop_watch();
+
+    case.apply_changes(changes);
+
+    // 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 _ = setup_logging();
+    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();
+
+    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();
+
+    case.apply_changes(changes);
+
+    assert_eq!(case.db().workspace().packages(case.db()).len(), 2);
+
+    Ok(())
+}

crates/red_knot_python_semantic/Cargo.toml

@@ -14,6 +14,7 @@ license = { workspace = true }
 ruff_db = { workspace = true }
 ruff_index = { workspace = true }
 ruff_python_ast = { workspace = true }
+ruff_python_parser = { workspace = true }
 ruff_python_stdlib = { workspace = true }
 ruff_source_file = { workspace = true }
 ruff_text_size = { workspace = true }
@@ -24,13 +25,15 @@ bitflags = { workspace = true }
 camino = { workspace = true }
 compact_str = { workspace = true }
 countme = { workspace = true }
-itertools = { workspace = true}
+indexmap = { workspace = true }
+itertools = { workspace = true }
 ordermap = { workspace = true }
 salsa = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 rustc-hash = { workspace = true }
 hashbrown = { workspace = true }
+serde = { workspace = true, optional = true }
 smallvec = { workspace = true }
 static_assertions = { workspace = true }
 test-case = { workspace = true }
@@ -43,10 +46,9 @@ red_knot_test = { workspace = true }
 red_knot_vendored = { workspace = true }
 
 anyhow = { workspace = true }
-dir-test = {workspace = true}
+dir-test = { workspace = true }
 insta = { workspace = true }
 tempfile = { workspace = true }
 
 [lints]
 workspace = true
-

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

@@ -0,0 +1,62 @@
+# NoReturn & Never
+
+`NoReturn` is used to annotate the return type for functions that never return. `Never` is the
+bottom type, representing the empty set of Python objects. These two annotations can be used
+interchangeably.
+
+## Function Return Type Annotation
+
+```py
+from typing import NoReturn
+
+def stop() -> NoReturn:
+    raise RuntimeError("no way")
+
+# revealed: Never
+reveal_type(stop())
+```
+
+## Assignment
+
+```py
+from typing import NoReturn, Never, Any
+
+# error: [invalid-type-parameter] "Type `typing.Never` expected no type parameter"
+x: Never[int]
+a1: NoReturn
+# TODO: Test `Never` is only available in python >= 3.11
+a2: Never
+b1: Any
+b2: int
+
+def f():
+    # revealed: Never
+    reveal_type(a1)
+    # revealed: Never
+    reveal_type(a2)
+
+    # Never is assignable to all types.
+    v1: int = a1
+    v2: str = a1
+    # Other types are not assignable to Never except for Never (and Any).
+    v3: Never = b1
+    v4: Never = a2
+    v5: Any = b2
+    # error: [invalid-assignment] "Object of type `Literal[1]` is not assignable to `Never`"
+    v6: Never = 1
+```
+
+## Typing Extensions
+
+```py
+from typing_extensions import NoReturn, Never
+
+x: NoReturn
+y: Never
+
+def f():
+    # revealed: Never
+    reveal_type(x)
+    # revealed: Never
+    reveal_type(y)
+```

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

@@ -0,0 +1,47 @@
+# Optional
+
+## Annotation
+
+`typing.Optional` is equivalent to using the type with a None in a Union.
+
+```py
+from typing import Optional
+
+a: Optional[int]
+a1: Optional[bool]
+a2: Optional[Optional[bool]]
+a3: Optional[None]
+
+def f():
+    # revealed: int | None
+    reveal_type(a)
+    # revealed: bool | None
+    reveal_type(a1)
+    # revealed: bool | None
+    reveal_type(a2)
+    # revealed: None
+    reveal_type(a3)
+```
+
+## Assignment
+
+```py
+from typing import Optional
+
+a: Optional[int] = 1
+a = None
+# error: [invalid-assignment] "Object of type `Literal[""]` is not assignable to `int | None`"
+a = ""
+```
+
+## Typing Extensions
+
+```py
+from typing_extensions import Optional
+
+a: Optional[int]
+
+def f():
+    # revealed: int | None
+    reveal_type(a)
+```

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

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

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

@@ -0,0 +1,218 @@
+# String annotations
+
+## Simple
+
+```py
+def f() -> "int":
+    return 1
+
+reveal_type(f())  # revealed: int
+```
+
+## Nested
+
+```py
+def f() -> "'int'":
+    return 1
+
+reveal_type(f())  # revealed: int
+```
+
+## Type expression
+
+```py
+def f1() -> "int | str":
+    return 1
+
+def f2() -> "tuple[int, str]":
+    return 1
+
+reveal_type(f1())  # revealed: int | str
+reveal_type(f2())  # revealed: tuple[int, str]
+```
+
+## Partial
+
+```py
+def f() -> tuple[int, "str"]:
+    return 1
+
+reveal_type(f())  # revealed: tuple[int, str]
+```
+
+## Deferred
+
+```py
+def f() -> "Foo":
+    return Foo()
+
+class Foo:
+    pass
+
+reveal_type(f())  # revealed: Foo
+```
+
+## Deferred (undefined)
+
+```py
+# error: [unresolved-reference]
+def f() -> "Foo":
+    pass
+
+reveal_type(f())  # revealed: Unknown
+```
+
+## Partial deferred
+
+```py
+def f() -> int | "Foo":
+    return 1
+
+class Foo:
+    pass
+
+reveal_type(f())  # revealed: int | Foo
+```
+
+## `typing.Literal`
+
+```py
+from typing import Literal
+
+def f1() -> Literal["Foo", "Bar"]:
+    return "Foo"
+
+def f2() -> 'Literal["Foo", "Bar"]':
+    return "Foo"
+
+class Foo:
+    pass
+
+reveal_type(f1())  # revealed: Literal["Foo", "Bar"]
+reveal_type(f2())  # revealed: Literal["Foo", "Bar"]
+```
+
+## Various string kinds
+
+```py
+# error: [annotation-raw-string] "Type expressions cannot use raw string literal"
+def f1() -> r"int":
+    return 1
+
+# error: [annotation-f-string] "Type expressions cannot use f-strings"
+def f2() -> f"int":
+    return 1
+
+# error: [annotation-byte-string] "Type expressions cannot use bytes literal"
+def f3() -> b"int":
+    return 1
+
+def f4() -> "int":
+    return 1
+
+# error: [annotation-implicit-concat] "Type expressions cannot span multiple string literals"
+def f5() -> "in" "t":
+    return 1
+
+# error: [annotation-escape-character] "Type expressions cannot contain escape characters"
+def f6() -> "\N{LATIN SMALL LETTER I}nt":
+    return 1
+
+# error: [annotation-escape-character] "Type expressions cannot contain escape characters"
+def f7() -> "\x69nt":
+    return 1
+
+def f8() -> """int""":
+    return 1
+
+def f9() -> "b'int'":
+    return 1
+
+reveal_type(f1())  # revealed: Unknown
+reveal_type(f2())  # revealed: Unknown
+reveal_type(f3())  # revealed: Unknown
+reveal_type(f4())  # revealed: int
+reveal_type(f5())  # revealed: Unknown
+reveal_type(f6())  # revealed: Unknown
+reveal_type(f7())  # revealed: Unknown
+reveal_type(f8())  # revealed: int
+reveal_type(f9())  # revealed: Unknown
+```
+
+## Various string kinds in `typing.Literal`
+
+```py
+from typing import Literal
+
+def f() -> Literal["a", r"b", b"c", "d" "e", "\N{LATIN SMALL LETTER F}", "\x67", """h"""]:
+    return "normal"
+
+reveal_type(f())  # revealed: Literal["a", "b", "de", "f", "g", "h"] | Literal[b"c"]
+```
+
+## Class variables
+
+```py
+MyType = int
+
+class Aliases:
+    MyType = str
+
+    forward: "MyType"
+    not_forward: MyType
+
+reveal_type(Aliases.forward)  # revealed: str
+reveal_type(Aliases.not_forward)  # revealed: str
+```
+
+## Annotated assignment
+
+```py
+a: "int" = 1
+b: "'int'" = 1
+c: "Foo"
+# error: [invalid-assignment] "Object of type `Literal[1]` is not assignable to `Foo`"
+d: "Foo" = 1
+
+class Foo:
+    pass
+
+c = Foo()
+
+reveal_type(a)  # revealed: Literal[1]
+reveal_type(b)  # revealed: Literal[1]
+reveal_type(c)  # revealed: Foo
+reveal_type(d)  # revealed: Foo
+```
+
+## Parameter
+
+TODO: Add tests once parameter inference is supported
+
+## Invalid expressions
+
+The expressions in these string annotations aren't valid expressions in this context but we
+shouldn't panic.
+
+```py
+a: "1 or 2"
+b: "(x := 1)"
+c: "1 + 2"
+d: "lambda x: x"
+e: "x if True else y"
+f: "{'a': 1, 'b': 2}"
+g: "{1, 2}"
+h: "[i for i in range(5)]"
+i: "{i for i in range(5)}"
+j: "{i: i for i in range(5)}"
+k: "(i for i in range(5))"
+l: "await 1"
+# error: [forward-annotation-syntax-error]
+m: "yield 1"
+# error: [forward-annotation-syntax-error]
+n: "yield from 1"
+o: "1 < 2"
+p: "call()"
+r: "[1, 2]"
+s: "(1, 2)"
+```

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

@@ -0,0 +1,61 @@
+# Union
+
+## Annotation
+
+`typing.Union` can be used to construct union types same as `|` operator.
+
+```py
+from typing import Union
+
+a: Union[int, str]
+a1: Union[int, bool]
+a2: Union[int, Union[float, str]]
+a3: Union[int, None]
+a4: Union[Union[float, str]]
+a5: Union[int]
+a6: Union[()]
+
+def f():
+    # revealed: int | str
+    reveal_type(a)
+    # Since bool is a subtype of int we simplify to int here. But we do allow assigning boolean values (see below).
+    # revealed: int
+    reveal_type(a1)
+    # revealed: int | float | str
+    reveal_type(a2)
+    # revealed: int | None
+    reveal_type(a3)
+    # revealed: float | str
+    reveal_type(a4)
+    # revealed: int
+    reveal_type(a5)
+    # revealed: Never
+    reveal_type(a6)
+```
+
+## Assignment
+
+```py
+from typing import Union
+
+a: Union[int, str]
+a = 1
+a = ""
+a1: Union[int, bool]
+a1 = 1
+a1 = True
+# error: [invalid-assignment] "Object of type `Literal[b""]` is not assignable to `int | str`"
+a = b""
+```
+
+## Typing Extensions
+
+```py
+from typing_extensions import Union
+
+a: Union[int, str]
+
+def f():
+    # revealed: int | str
+    reveal_type(a)
+```

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

@@ -51,12 +51,12 @@ reveal_type(c)  # revealed: tuple[str, int]
 reveal_type(d)  # revealed: tuple[tuple[str, str], tuple[int, int]]
 
 # TODO: homogenous tuples, PEP-646 tuples
-reveal_type(e)  # revealed: @Todo
-reveal_type(f)  # revealed: @Todo
-reveal_type(g)  # revealed: @Todo
+reveal_type(e)  # revealed: @Todo(full tuple[...] support)
+reveal_type(f)  # revealed: @Todo(full tuple[...] support)
+reveal_type(g)  # revealed: @Todo(full tuple[...] support)
 
 # TODO: support more kinds of type expressions in annotations
-reveal_type(h)  # revealed: @Todo
+reveal_type(h)  # revealed: @Todo(full tuple[...] support)
 
 reveal_type(i)  # revealed: tuple[str | int, str | int]
 reveal_type(j)  # revealed: tuple[str | int]
@@ -110,3 +110,29 @@ c: builtins.tuple[builtins.tuple[builtins.int, builtins.int], builtins.int] = ((
 # error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `tuple[tuple[int, int], int]`"
 c: builtins.tuple[builtins.tuple[builtins.int, builtins.int], builtins.int] = "foo"
 ```
+
+## Future annotations are deferred
+
+```py
+from __future__ import annotations
+
+x: Foo
+
+class Foo:
+    pass
+
+x = Foo()
+reveal_type(x)  # revealed: Foo
+```
+
+## Annotations in stub files are deferred
+
+```pyi path=main.pyi
+x: Foo
+
+class Foo:
+    pass
+
+x = Foo()
+reveal_type(x)  # revealed: Foo
+```

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

@@ -85,7 +85,7 @@ f = Foo()
 # that `Foo.__iadd__` may be unbound as additional context.
 f += "Hello, world!"
 
-reveal_type(f)  # revealed: int
+reveal_type(f)  # revealed: int | Unknown
 ```
 
 ## Partially bound with `__add__`
@@ -104,8 +104,7 @@ class Foo:
 f = Foo()
 f += "Hello, world!"
 
-# TODO(charlie): This should be `int | str`, since `__iadd__` may be unbound.
-reveal_type(f)  # revealed: int
+reveal_type(f)  # revealed: int | str
 ```
 
 ## Partially bound target union
@@ -127,8 +126,7 @@ else:
     f = 42.0
 f += 12
 
-# TODO(charlie): This should be `str | int | float`
-reveal_type(f)  # revealed: @Todo
+reveal_type(f)  # revealed: int | str | float
 ```
 
 ## Target union
@@ -149,6 +147,36 @@ else:
     f = 42.0
 f += 12
 
-# TODO(charlie): This should be `str | float`.
-reveal_type(f)  # revealed: @Todo
+reveal_type(f)  # revealed: str | float
+```
+
+## Partially bound target union with `__add__`
+
+```py
+def bool_instance() -> bool:
+    return True
+
+flag = bool_instance()
+
+class Foo:
+    def __add__(self, other: int) -> str:
+        return "Hello, world!"
+    if bool_instance():
+        def __iadd__(self, other: int) -> int:
+            return 42
+
+class Bar:
+    def __add__(self, other: int) -> bytes:
+        return b"Hello, world!"
+
+    def __iadd__(self, other: int) -> float:
+        return 42.0
+
+if flag:
+    f = Foo()
+else:
+    f = Bar()
+f += 12
+
+reveal_type(f)  # revealed: int | str | float
 ```

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

@@ -35,6 +35,7 @@ class C:
     if flag:
         x = 2
 
+# error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C]` is possibly unbound"
 reveal_type(C.x)  # revealed: Literal[2]
 reveal_type(C.y)  # revealed: Literal[1]
 ```

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -9,12 +9,128 @@ def bool_instance() -> bool:
 flag = bool_instance()
 
 if flag:
-    class C:
+    class C1:
         x = 1
 
 else:
-    class C:
+    class C1:
         x = 2
 
-reveal_type(C.x)  # revealed: Literal[1, 2]
+class C2:
+    if flag:
+        x = 3
+    else:
+        x = 4
+
+reveal_type(C1.x)  # revealed: Literal[1, 2]
+reveal_type(C2.x)  # revealed: Literal[3, 4]
+```
+
+## Inherited attributes
+
+```py
+class A:
+    X = "foo"
+
+class B(A): ...
+class C(B): ...
+
+reveal_type(C.X)  # revealed: Literal["foo"]
+```
+
+## Inherited attributes (multiple inheritance)
+
+```py
+class O: ...
+
+class F(O):
+    X = 56
+
+class E(O):
+    X = 42
+
+class D(O): ...
+class C(D, F): ...
+class B(E, D): ...
+class A(B, C): ...
+
+# revealed: tuple[Literal[A], Literal[B], Literal[E], Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
+reveal_type(A.__mro__)
+
+# `E` is earlier in the MRO than `F`, so we should use the type of `E.X`
+reveal_type(A.X)  # revealed: Literal[42]
+```
+
+## Unions with possibly unbound paths
+
+### Definite boundness within a class
+
+In this example, the `x` attribute is not defined in the `C2` element of the union:
+
+```py
+def bool_instance() -> bool:
+    return True
+
+class C1:
+    x = 1
+
+class C2: ...
+
+class C3:
+    x = 3
+
+flag1 = bool_instance()
+flag2 = bool_instance()
+
+C = C1 if flag1 else C2 if flag2 else C3
+
+# error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C1, C2, C3]` is possibly unbound"
+reveal_type(C.x)  # revealed: Literal[1, 3]
+```
+
+### Possibly-unbound within a class
+
+We raise the same diagnostic if the attribute is possibly-unbound in at least one element of the
+union:
+
+```py
+def bool_instance() -> bool:
+    return True
+
+class C1:
+    x = 1
+
+class C2:
+    if bool_instance():
+        x = 2
+
+class C3:
+    x = 3
+
+flag1 = bool_instance()
+flag2 = bool_instance()
+
+C = C1 if flag1 else C2 if flag2 else C3
+
+# error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C1, C2, C3]` is possibly unbound"
+reveal_type(C.x)  # revealed: Literal[1, 2, 3]
+```
+
+## Unions with all paths unbound
+
+If the symbol is unbound in all elements of the union, we detect that:
+
+```py
+def bool_instance() -> bool:
+    return True
+
+class C1: ...
+class C2: ...
+
+flag = bool_instance()
+
+C = C1 if flag else C2
+
+# error: [unresolved-attribute] "Type `Literal[C1, C2]` has no attribute `x`"
+reveal_type(C.x)  # revealed: Unknown
 ```

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

@@ -202,11 +202,7 @@ reveal_type(A() + B())  # revealed: MyString
 # N.B. Still a subtype of `A`, even though `A` does not appear directly in the class's `__bases__`
 class C(B): ...
 
-# TODO: we currently only understand direct subclasses as subtypes of the superclass.
-# We need to iterate through the full MRO rather than just the class's bases;
-# if we do, we'll understand `C` as a subtype of `A`, and correctly understand this as being
-# `MyString` rather than `str`
-reveal_type(A() + C())  # revealed: str
+reveal_type(A() + C())  # revealed: MyString
 ```
 
 ## Reflected precedence 2
@@ -321,7 +317,7 @@ reveal_type(1 + A())  # revealed: int
 reveal_type(A() + "foo")  # revealed: A
 # TODO should be `A` since `str.__add__` doesn't support `A` instances
 # TODO overloads
-reveal_type("foo" + A())  # revealed: @Todo
+reveal_type("foo" + A())  # revealed: @Todo(return type)
 
 reveal_type(A() + b"foo")  # revealed: A
 # TODO should be `A` since `bytes.__add__` doesn't support `A` instances
@@ -329,7 +325,7 @@ reveal_type(b"foo" + A())  # revealed: bytes
 
 reveal_type(A() + ())  # revealed: A
 # TODO this should be `A`, since `tuple.__add__` doesn't support `A` instances
-reveal_type(() + A())  # revealed: @Todo
+reveal_type(() + A())  # revealed: @Todo(return type)
 
 literal_string_instance = "foo" * 1_000_000_000
 # the test is not testing what it's meant to be testing if this isn't a `LiteralString`:
@@ -338,7 +334,7 @@ reveal_type(literal_string_instance)  # revealed: LiteralString
 reveal_type(A() + literal_string_instance)  # revealed: A
 # TODO should be `A` since `str.__add__` doesn't support `A` instances
 # TODO overloads
-reveal_type(literal_string_instance + A())  # revealed: @Todo
+reveal_type(literal_string_instance + A())  # revealed: @Todo(return type)
 ```
 
 ## Operations involving instances of classes inheriting from `Any`

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

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

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

@@ -16,7 +16,16 @@ async def get_int_async() -> int:
     return 42
 
 # TODO: we don't yet support `types.CoroutineType`, should be generic `Coroutine[Any, Any, int]`
-reveal_type(get_int_async())  # revealed: @Todo
+reveal_type(get_int_async())  # revealed: @Todo(generic types.CoroutineType)
+```
+
+## Generic
+
+```py
+def get_int[T]() -> int:
+    return 42
+
+reveal_type(get_int())  # revealed: int
 ```
 
 ## Decorated
@@ -27,6 +36,8 @@ from typing import Callable
 def foo() -> int:
     return 42
 
+# TODO: This should be resolved once we understand `Callable` annotations
+# error: [annotation-with-invalid-expression]
 def decorator(func) -> Callable[[], int]:
     return foo
 
@@ -35,7 +46,7 @@ def bar() -> str:
     return "bar"
 
 # TODO: should reveal `int`, as the decorator replaces `bar` with `foo`
-reveal_type(bar())  # revealed: @Todo
+reveal_type(bar())  # revealed: @Todo(return type)
 ```
 
 ## Invalid callable
@@ -44,3 +55,16 @@ reveal_type(bar())  # revealed: @Todo
 nonsense = 123
 x = nonsense()  # error: "Object of type `Literal[123]` is not callable"
 ```
+
+## Potentially unbound function
+
+```py
+def flag() -> bool: ...
+
+if flag():
+    def foo() -> int:
+        return 42
+
+# error: [possibly-unresolved-reference]
+reveal_type(foo())  # revealed: int
+```

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

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

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

@@ -93,13 +93,11 @@ class AlwaysFalse:
     def __contains__(self, item: int) -> Literal[""]:
         return ""
 
-# TODO: it should be Literal[True] and Literal[False]
-reveal_type(42 in AlwaysTrue())  # revealed: @Todo
-reveal_type(42 not in AlwaysTrue())  # revealed: @Todo
+reveal_type(42 in AlwaysTrue())  # revealed: Literal[True]
+reveal_type(42 not in AlwaysTrue())  # revealed: Literal[False]
 
-# TODO: it should be Literal[False] and Literal[True]
-reveal_type(42 in AlwaysFalse())  # revealed: @Todo
-reveal_type(42 not in AlwaysFalse())  # revealed: @Todo
+reveal_type(42 in AlwaysFalse())  # revealed: Literal[False]
+reveal_type(42 not in AlwaysFalse())  # revealed: Literal[True]
 ```
 
 ## No Fallback for `__contains__`

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

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

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

@@ -58,7 +58,9 @@ reveal_type(c >= d)  # revealed: Literal[True]
 #### Results with Ambiguity
 
 ```py
-def bool_instance() -> bool: ...
+def bool_instance() -> bool:
+    return True
+
 def int_instance() -> int:
     return 42
 
@@ -134,23 +136,158 @@ reveal_type(c >= c)  # revealed: Literal[True]
 
 #### Non Boolean Rich Comparisons
 
+Rich comparison methods defined in a class affect tuple comparisons as well. Proper type inference
+should be possible even in cases where these methods return non-boolean types.
+
+Note: Tuples use lexicographic comparisons. If the `==` result for all paired elements in the tuple
+is True, the comparison then considers the tuple’s length. Regardless of the return type of the
+dunder methods, the final result can still be a boolean value.
+
+(+cpython: For tuples, `==` and `!=` always produce boolean results, regardless of the return type
+of the dunder methods.)
+
 ```py
+from __future__ import annotations
+
 class A:
-    def __eq__(self, o) -> str: ...
-    def __ne__(self, o) -> int: ...
-    def __lt__(self, o) -> float: ...
-    def __le__(self, o) -> object: ...
-    def __gt__(self, o) -> tuple: ...
-    def __ge__(self, o) -> list: ...
+    def __eq__(self, o: object) -> str:
+        return "hello"
+
+    def __ne__(self, o: object) -> bytes:
+        return b"world"
+
+    def __lt__(self, o: A) -> float:
+        return 3.14
+
+    def __le__(self, o: A) -> complex:
+        return complex(0.5, -0.5)
+
+    def __gt__(self, o: A) -> tuple:
+        return (1, 2, 3)
+
+    def __ge__(self, o: A) -> list:
+        return [1, 2, 3]
 
 a = (A(), A())
 
+reveal_type(a == a)  # revealed: bool
+reveal_type(a != a)  # revealed: bool
+reveal_type(a < a)  # revealed: float | Literal[False]
+reveal_type(a <= a)  # revealed: complex | Literal[True]
+reveal_type(a > a)  # revealed: tuple | Literal[False]
+reveal_type(a >= a)  # revealed: list | Literal[True]
+
+# If lexicographic comparison is finished before comparing A()
+b = ("1_foo", A())
+c = ("2_bar", A())
+
+reveal_type(b == c)  # revealed: Literal[False]
+reveal_type(b != c)  # revealed: Literal[True]
+reveal_type(b < c)  # revealed: Literal[True]
+reveal_type(b <= c)  # revealed: Literal[True]
+reveal_type(b > c)  # revealed: Literal[False]
+reveal_type(b >= c)  # revealed: Literal[False]
+
+class B:
+    def __lt__(self, o: B) -> set:
+        return set()
+
+reveal_type((A(), B()) < (A(), B()))  # revealed: float | set | Literal[False]
+```
+
+#### Special Handling of Eq and NotEq in Lexicographic Comparisons
+
+> Example: `(int_instance(), "foo") == (int_instance(), "bar")`
+
+`Eq` and `NotEq` have unique behavior compared to other operators in lexicographic comparisons.
+Specifically, for `Eq`, if any non-equal pair exists within the tuples being compared, we can
+immediately conclude that the tuples are not equal. Conversely, for `NotEq`, if any non-equal pair
+exists, we can determine that the tuples are unequal.
+
+In contrast, with operators like `<` and `>`, the comparison must consider each pair of elements
+sequentially, and the final outcome might remain ambiguous until all pairs are compared.
+
+```py
+def str_instance() -> str:
+    return "hello"
+
+def int_instance() -> int:
+    return 42
+
+reveal_type("foo" == "bar")  # revealed: Literal[False]
+reveal_type(("foo",) == ("bar",))  # revealed: Literal[False]
+reveal_type((4, "foo") == (4, "bar"))  # revealed: Literal[False]
+reveal_type((int_instance(), "foo") == (int_instance(), "bar"))  # revealed: Literal[False]
+
+a = (str_instance(), int_instance(), "foo")
+
 reveal_type(a == a)  # revealed: bool
 reveal_type(a != a)  # revealed: bool
 reveal_type(a < a)  # revealed: bool
 reveal_type(a <= a)  # revealed: bool
 reveal_type(a > a)  # revealed: bool
 reveal_type(a >= a)  # revealed: bool
+
+b = (str_instance(), int_instance(), "bar")
+
+reveal_type(a == b)  # revealed: Literal[False]
+reveal_type(a != b)  # revealed: Literal[True]
+reveal_type(a < b)  # revealed: bool
+reveal_type(a <= b)  # revealed: bool
+reveal_type(a > b)  # revealed: bool
+reveal_type(a >= b)  # revealed: bool
+
+c = (str_instance(), int_instance(), "foo", "different_length")
+reveal_type(a == c)  # revealed: Literal[False]
+reveal_type(a != c)  # revealed: Literal[True]
+reveal_type(a < c)  # revealed: bool
+reveal_type(a <= c)  # revealed: bool
+reveal_type(a > c)  # revealed: bool
+reveal_type(a >= c)  # revealed: bool
+```
+
+#### Error Propagation
+
+Errors occurring within a tuple comparison should propagate outward. However, if the tuple
+comparison can clearly conclude before encountering an error, the error should not be raised.
+
+```py
+def int_instance() -> int:
+    return 42
+
+def str_instance() -> str:
+    return "hello"
+
+class A: ...
+
+# error: [unsupported-operator] "Operator `<` is not supported for types `A` and `A`"
+A() < A()
+# error: [unsupported-operator] "Operator `<=` is not supported for types `A` and `A`"
+A() <= A()
+# error: [unsupported-operator] "Operator `>` is not supported for types `A` and `A`"
+A() > A()
+# error: [unsupported-operator] "Operator `>=` is not supported for types `A` and `A`"
+A() >= A()
+
+a = (0, int_instance(), A())
+
+# error: [unsupported-operator] "Operator `<` is not supported for types `A` and `A`, in comparing `tuple[Literal[0], int, A]` with `tuple[Literal[0], int, A]`"
+reveal_type(a < a)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `<=` is not supported for types `A` and `A`, in comparing `tuple[Literal[0], int, A]` with `tuple[Literal[0], int, A]`"
+reveal_type(a <= a)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `>` is not supported for types `A` and `A`, in comparing `tuple[Literal[0], int, A]` with `tuple[Literal[0], int, A]`"
+reveal_type(a > a)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `>=` is not supported for types `A` and `A`, in comparing `tuple[Literal[0], int, A]` with `tuple[Literal[0], int, A]`"
+reveal_type(a >= a)  # revealed: Unknown
+
+# Comparison between `a` and `b` should only involve the first elements, `Literal[0]` and `Literal[99999]`,
+# and should terminate immediately.
+b = (99999, int_instance(), A())
+
+reveal_type(a < b)  # revealed: Literal[True]
+reveal_type(a <= b)  # revealed: Literal[True]
+reveal_type(a > b)  # revealed: Literal[False]
+reveal_type(a >= b)  # revealed: Literal[False]
 ```
 
 ### Membership Test Comparisons

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

@@ -4,6 +4,8 @@
 def bool_instance() -> bool:
     return True
 
+class A: ...
+
 a = 1 in 7  # error: "Operator `in` is not supported for types `Literal[1]` and `Literal[7]`"
 reveal_type(a)  # revealed: bool
 
@@ -33,4 +35,8 @@ reveal_type(e)  # revealed: bool
 f = (1, 2) < (1, "hello")
 # TODO: should be Unknown, once operand type check is implemented
 reveal_type(f)  # revealed: bool
+
+# error: [unsupported-operator] "Operator `<` is not supported for types `A` and `A`, in comparing `tuple[bool, A]` with `tuple[bool, A]`"
+g = (bool_instance(), A()) < (bool_instance(), A())
+reveal_type(g)  # revealed: Unknown
 ```

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

@@ -41,21 +41,20 @@ except EXCEPTIONS as f:
 ## Dynamic exception types
 
 ```py
-# TODO: we should not emit these `call-possibly-unbound-method` errors for `tuple.__class_getitem__`
 def foo(
     x: type[AttributeError],
-    y: tuple[type[OSError], type[RuntimeError]],  # error: [call-possibly-unbound-method]
-    z: tuple[type[BaseException], ...],  # error: [call-possibly-unbound-method]
+    y: tuple[type[OSError], type[RuntimeError]],
+    z: tuple[type[BaseException], ...],
 ):
     try:
         help()
     except x as e:
         # TODO: should be `AttributeError`
-        reveal_type(e)  # revealed: @Todo
+        reveal_type(e)  # revealed: @Todo(exception type)
     except y as f:
         # TODO: should be `OSError | RuntimeError`
-        reveal_type(f)  # revealed: @Todo
+        reveal_type(f)  # revealed: @Todo(exception type)
     except z as g:
         # TODO: should be `BaseException`
-        reveal_type(g)  # revealed: @Todo
+        reveal_type(g)  # revealed: @Todo(exception type)
 ```

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

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

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

@@ -0,0 +1,28 @@
+# Attribute access
+
+## Boundness
+
+```py
+def flag() -> bool: ...
+
+class A:
+    always_bound = 1
+
+    if flag():
+        union = 1
+    else:
+        union = "abc"
+
+    if flag():
+        possibly_unbound = "abc"
+
+reveal_type(A.always_bound)  # revealed: Literal[1]
+
+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"]
+
+# error: [unresolved-attribute] "Type `Literal[A]` has no attribute `non_existent`"
+reveal_type(A.non_existent)  # revealed: Unknown
+```

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

@@ -0,0 +1,43 @@
+# If expression
+
+## Union
+
+```py
+def bool_instance() -> bool:
+    return True
+
+reveal_type(1 if bool_instance() else 2)  # revealed: Literal[1, 2]
+```
+
+## Statically known branches
+
+```py
+reveal_type(1 if True else 2)  # revealed: Literal[1]
+reveal_type(1 if "not empty" else 2)  # revealed: Literal[1]
+reveal_type(1 if (1,) else 2)  # revealed: Literal[1]
+reveal_type(1 if 1 else 2)  # revealed: Literal[1]
+
+reveal_type(1 if False else 2)  # revealed: Literal[2]
+reveal_type(1 if None else 2)  # revealed: Literal[2]
+reveal_type(1 if "" else 2)  # revealed: Literal[2]
+reveal_type(1 if 0 else 2)  # revealed: Literal[2]
+```
+
+## Leaked Narrowing Constraint
+
+(issue #14588)
+
+The test inside an if expression should not affect code outside of the expression.
+
+```py
+def bool_instance() -> bool:
+    return True
+
+x: Literal[42, "hello"] = 42 if bool_instance() else "hello"
+
+reveal_type(x)  # revealed: Literal[42] | Literal["hello"]
+
+_ = ... if isinstance(x, str) else ...
+
+reveal_type(x)  # revealed: Literal[42] | Literal["hello"]
+```

crates/red_knot_python_semantic/resources/mdtest/generics.md

@@ -6,13 +6,9 @@ Basic PEP 695 generics
 
 ```py
 class MyBox[T]:
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
     data: T
     box_model_number = 695
 
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
     def __init__(self, data: T):
         self.data = data
 
@@ -22,7 +18,7 @@ box: MyBox[int] = MyBox(5)
 wrong_innards: MyBox[int] = MyBox("five")
 
 # TODO reveal int
-reveal_type(box.data)  # revealed: @Todo
+reveal_type(box.data)  # revealed: @Todo(instance attributes)
 
 reveal_type(MyBox.box_model_number)  # revealed: Literal[695]
 ```
@@ -31,24 +27,19 @@ reveal_type(MyBox.box_model_number)  # revealed: Literal[695]
 
 ```py
 class MyBox[T]:
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
     data: T
 
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
     def __init__(self, data: T):
         self.data = data
 
-# TODO not error on the subscripting or the use of type param
-# error: [unresolved-reference] "Name `T` used when not defined"
+# TODO not error on the subscripting
 # error: [non-subscriptable]
 class MySecureBox[T](MyBox[T]): ...
 
 secure_box: MySecureBox[int] = MySecureBox(5)
 reveal_type(secure_box)  # revealed: MySecureBox
 # TODO reveal int
-reveal_type(secure_box.data)  # revealed: @Todo
+reveal_type(secure_box.data)  # revealed: @Todo(instance attributes)
 ```
 
 ## Cyclical class definition
@@ -66,3 +57,23 @@ class S[T](Seq[S]): ...  # error: [non-subscriptable]
 
 reveal_type(S)  # revealed: Literal[S]
 ```
+
+## Type params
+
+A PEP695 type variable defines a value of type `typing.TypeVar`.
+
+```py
+def f[T]():
+    reveal_type(T)  # revealed: T
+    reveal_type(T.__name__)  # revealed: Literal["T"]
+```
+
+## Minimum two constraints
+
+A typevar with less than two constraints emits a diagnostic:
+
+```py
+# error: [invalid-typevar-constraints] "TypeVar must have at least two constrained types"
+def f[T: (int,)]():
+    pass
+```

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

@@ -21,6 +21,7 @@ reveal_type(y)
 ```
 
 ```py
+# error: [possibly-unbound-import] "Member `y` of module `maybe_unbound` is possibly unbound"
 from maybe_unbound import x, y
 
 reveal_type(x)  # revealed: Literal[3]
@@ -50,6 +51,7 @@ reveal_type(y)
 Importing an annotated name prefers the declared type over the inferred type:
 
 ```py
+# error: [possibly-unbound-import] "Member `y` of module `maybe_unbound_annotated` is possibly unbound"
 from maybe_unbound_annotated import x, y
 
 reveal_type(x)  # revealed: Literal[3]

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

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

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

@@ -18,7 +18,7 @@ async def foo():
         pass
 
     # TODO: should reveal `Unknown` because `__aiter__` is not defined
-    # revealed: @Todo
+    # revealed: @Todo(async iterables/iterators)
     # error: [possibly-unresolved-reference]
     reveal_type(x)
 ```
@@ -40,6 +40,6 @@ async def foo():
         pass
 
     # error: [possibly-unresolved-reference]
-    # revealed: @Todo
+    # revealed: @Todo(async iterables/iterators)
     reveal_type(x)
 ```

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

@@ -238,7 +238,7 @@ class Test:
 def coinflip() -> bool:
     return True
 
-# TODO: we should emit a diagnostic here (it might not be iterable)
+# error: [not-iterable] "Object of type `Test | Literal[42]` is not iterable because its `__iter__` method is possibly unbound"
 for x in Test() if coinflip() else 42:
     reveal_type(x)  # revealed: int
 ```

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

@@ -52,3 +52,29 @@ else:
 reveal_type(x)  # revealed: Literal[2, 3]
 reveal_type(y)  # revealed: Literal[1, 2, 4]
 ```
+
+## Nested while loops
+
+```py
+def flag() -> bool:
+    return True
+
+x = 1
+
+while flag():
+    x = 2
+
+    while flag():
+        x = 3
+        if flag():
+            break
+    else:
+        x = 4
+
+    if flag():
+        break
+else:
+    x = 5
+
+reveal_type(x)  # revealed: Literal[3, 4, 5]
+```

crates/red_knot_python_semantic/resources/mdtest/metaclass.md

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

crates/red_knot_python_semantic/resources/mdtest/mro.md

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

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

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

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

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

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

@@ -0,0 +1,152 @@
+# Narrowing for checks involving `type(x)`
+
+## `type(x) is C`
+
+```py
+class A: ...
+class B: ...
+
+def get_a_or_b() -> A | B:
+    return A()
+
+x = get_a_or_b()
+
+if type(x) is A:
+    reveal_type(x)  # revealed: A
+else:
+    # It would be wrong to infer `B` here. The type
+    # of `x` could be a subclass of `A`, so we need
+    # to infer the full union type:
+    reveal_type(x)  # revealed: A | B
+```
+
+## `type(x) is not C`
+
+```py
+class A: ...
+class B: ...
+
+def get_a_or_b() -> A | B:
+    return A()
+
+x = get_a_or_b()
+
+if type(x) is not A:
+    # Same reasoning as above: no narrowing should occur here.
+    reveal_type(x)  # revealed: A | B
+else:
+    reveal_type(x)  # revealed: A
+```
+
+## `type(x) == C`, `type(x) != C`
+
+No narrowing can occur for equality comparisons, since there might be a custom `__eq__`
+implementation on the metaclass.
+
+TODO: Narrowing might be possible in some cases where the classes themselves are `@final` or their
+metaclass is `@final`.
+
+```py
+class IsEqualToEverything(type):
+    def __eq__(cls, other):
+        return True
+
+class A(metaclass=IsEqualToEverything): ...
+class B(metaclass=IsEqualToEverything): ...
+
+def get_a_or_b() -> A | B:
+    return B()
+
+x = get_a_or_b()
+
+if type(x) == A:
+    reveal_type(x)  # revealed: A | B
+
+if type(x) != A:
+    reveal_type(x)  # revealed: A | B
+```
+
+## No narrowing for custom `type` callable
+
+```py
+class A: ...
+class B: ...
+
+def type(x):
+    return int
+
+def get_a_or_b() -> A | B:
+    return A()
+
+x = get_a_or_b()
+
+if type(x) is A:
+    reveal_type(x)  # revealed: A | B
+else:
+    reveal_type(x)  # revealed: A | B
+```
+
+## No narrowing for multiple arguments
+
+No narrowing should occur if `type` is used to dynamically create a class:
+
+```py
+def get_str_or_int() -> str | int:
+    return "test"
+
+x = get_str_or_int()
+
+if type(x, (), {}) is str:
+    reveal_type(x)  # revealed: str | int
+else:
+    reveal_type(x)  # revealed: str | int
+```
+
+## No narrowing for keyword arguments
+
+`type` can't be used with a keyword argument:
+
+```py
+def get_str_or_int() -> str | int:
+    return "test"
+
+x = get_str_or_int()
+
+# TODO: we could issue a diagnostic here
+if type(object=x) is str:
+    reveal_type(x)  # revealed: str | int
+```
+
+## Narrowing if `type` is aliased
+
+```py
+class A: ...
+class B: ...
+
+alias_for_type = type
+
+def get_a_or_b() -> A | B:
+    return A()
+
+x = get_a_or_b()
+
+if alias_for_type(x) is A:
+    reveal_type(x)  # revealed: A
+```
+
+## Limitations
+
+```py
+class Base: ...
+class Derived(Base): ...
+
+def get_base() -> Base:
+    return Base()
+
+x = get_base()
+
+if type(x) is Base:
+    # Ideally, this could be narrower, but there is now way to
+    # express a constraint like `Base & ~ProperSubtypeOf[Base]`.
+    reveal_type(x)  # revealed: Base
+```

crates/red_knot_python_semantic/resources/mdtest/regression/14334_diagnostics_in_wrong_file.md

@@ -0,0 +1,13 @@
+# Regression test for #14334
+
+Regression test for [this issue](https://github.com/astral-sh/ruff/issues/14334).
+
+```py path=base.py
+# error: [invalid-base]
+class Base(2): ...
+```
+
+```py path=a.py
+# No error here
+from base import Base
+```

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

@@ -17,8 +17,7 @@ reveal_type(__doc__)  # revealed: str | None
 # (needs support for `*` imports)
 reveal_type(__spec__)  # revealed: Unknown | None
 
-# TODO: generics
-reveal_type(__path__)  # revealed: @Todo
+reveal_type(__path__)  # revealed: @Todo(generics)
 
 class X:
     reveal_type(__name__)  # revealed: str
@@ -58,15 +57,13 @@ reveal_type(typing.__name__)  # revealed: str
 reveal_type(typing.__init__)  # revealed: Literal[__init__]
 
 # These come from `builtins.object`, not `types.ModuleType`:
-# TODO: we don't currently understand `types.ModuleType` as inheriting from `object`;
-# these should not reveal `Unknown`:
-reveal_type(typing.__eq__)  # revealed: Unknown
-reveal_type(typing.__class__)  # revealed: Unknown
-reveal_type(typing.__module__)  # revealed: Unknown
+reveal_type(typing.__eq__)  # revealed: Literal[__eq__]
+
+reveal_type(typing.__class__)  # revealed: Literal[type]
 
 # TODO: needs support for attribute access on instances, properties and generics;
 # should be `dict[str, Any]`
-reveal_type(typing.__dict__)  # revealed: @Todo
+reveal_type(typing.__dict__)  # revealed: @Todo(instance attributes)
 ```
 
 Typeshed includes a fake `__getattr__` method in the stub for `types.ModuleType` to help out with
@@ -76,6 +73,7 @@ we're dealing with:
 ```py path=__getattr__.py
 import typing
 
+# error: [unresolved-attribute]
 reveal_type(typing.__getattr__)  # revealed: Unknown
 ```
 
@@ -97,8 +95,8 @@ from foo import __dict__ as foo_dict
 
 # TODO: needs support for attribute access on instances, properties, and generics;
 # should be `dict[str, Any]` for both of these:
-reveal_type(foo.__dict__)  # revealed: @Todo
-reveal_type(foo_dict)  # revealed: @Todo
+reveal_type(foo.__dict__)  # revealed: @Todo(instance attributes)
+reveal_type(foo_dict)  # revealed: @Todo(instance attributes)
 ```
 
 ## Conditionally global or `ModuleType` attribute

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

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

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

@@ -27,7 +27,7 @@ def int_instance() -> int:
 
 a = b"abcde"[int_instance()]
 # TODO: Support overloads... Should be `bytes`
-reveal_type(a)  # revealed: @Todo
+reveal_type(a)  # revealed: @Todo(return type)
 ```
 
 ## Slices
@@ -47,11 +47,11 @@ def int_instance() -> int: ...
 
 byte_slice1 = b[int_instance() : int_instance()]
 # TODO: Support overloads... Should be `bytes`
-reveal_type(byte_slice1)  # revealed: @Todo
+reveal_type(byte_slice1)  # revealed: @Todo(return type)
 
 def bytes_instance() -> bytes: ...
 
 byte_slice2 = bytes_instance()[0:5]
 # TODO: Support overloads... Should be `bytes`
-reveal_type(byte_slice2)  # revealed: @Todo
+reveal_type(byte_slice2)  # revealed: @Todo(return type)
 ```

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

@@ -39,7 +39,8 @@ reveal_type(UnionClassGetItem[0])  # revealed: str | int
 ## Class getitem with class union
 
 ```py
-flag = True
+def bool_instance() -> bool:
+    return True
 
 class A:
     def __class_getitem__(cls, item: int) -> str:
@@ -49,7 +50,7 @@ class B:
     def __class_getitem__(cls, item: int) -> int:
         return item
 
-x = A if flag else B
+x = A if bool_instance() else B
 
 reveal_type(x)  # revealed: Literal[A, B]
 reveal_type(x[0])  # revealed: str | int

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

@@ -12,13 +12,13 @@ x = [1, 2, 3]
 reveal_type(x)  # revealed: list
 
 # TODO reveal int
-reveal_type(x[0])  # revealed: @Todo
+reveal_type(x[0])  # revealed: @Todo(return type)
 
 # TODO reveal list
-reveal_type(x[0:1])  # revealed: @Todo
+reveal_type(x[0:1])  # revealed: @Todo(return type)
 
 # TODO error
-reveal_type(x["a"])  # revealed: @Todo
+reveal_type(x["a"])  # revealed: @Todo(return type)
 ```
 
 ## Assignments within list assignment

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

@@ -23,7 +23,7 @@ def int_instance() -> int: ...
 
 a = "abcde"[int_instance()]
 # TODO: Support overloads... Should be `str`
-reveal_type(a)  # revealed: @Todo
+reveal_type(a)  # revealed: @Todo(return type)
 ```
 
 ## Slices
@@ -78,13 +78,13 @@ def int_instance() -> int: ...
 
 substring1 = s[int_instance() : int_instance()]
 # TODO: Support overloads... Should be `LiteralString`
-reveal_type(substring1)  # revealed: @Todo
+reveal_type(substring1)  # revealed: @Todo(return type)
 
 def str_instance() -> str: ...
 
 substring2 = str_instance()[0:5]
 # TODO: Support overloads... Should be `str`
-reveal_type(substring2)  # revealed: @Todo
+reveal_type(substring2)  # revealed: @Todo(return type)
 ```
 
 ## Unsupported slice types

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

@@ -71,5 +71,5 @@ def int_instance() -> int: ...
 
 tuple_slice = t[int_instance() : int_instance()]
 # TODO: Support overloads... Should be `tuple[Literal[1, 'a', b"b"] | None, ...]`
-reveal_type(tuple_slice)  # revealed: @Todo
+reveal_type(tuple_slice)  # revealed: @Todo(return type)
 ```

crates/red_knot_python_semantic/resources/mdtest/sys_version_info.md

@@ -0,0 +1,138 @@
+# `sys.version_info`
+
+## The type of `sys.version_info`
+
+The type of `sys.version_info` is `sys._version_info`, at least according to typeshed's stubs (which
+we treat as the single source of truth for the standard library). This is quite a complicated type
+in typeshed, so there are many things we don't fully understand about the type yet; this is the
+source of several TODOs in this test file. Many of these TODOs should be naturally fixed as we
+implement more type-system features in the future.
+
+```py
+import sys
+
+reveal_type(sys.version_info)  # revealed: _version_info
+```
+
+## Literal types from comparisons
+
+Comparing `sys.version_info` with a 2-element tuple of literal integers always produces a `Literal`
+type:
+
+```py
+import sys
+
+reveal_type(sys.version_info >= (3, 9))  # revealed: Literal[True]
+reveal_type((3, 9) <= sys.version_info)  # revealed: Literal[True]
+
+reveal_type(sys.version_info > (3, 9))  # revealed: Literal[True]
+reveal_type((3, 9) < sys.version_info)  # revealed: Literal[True]
+
+reveal_type(sys.version_info < (3, 9))  # revealed: Literal[False]
+reveal_type((3, 9) > sys.version_info)  # revealed: Literal[False]
+
+reveal_type(sys.version_info <= (3, 9))  # revealed: Literal[False]
+reveal_type((3, 9) >= sys.version_info)  # revealed: Literal[False]
+
+reveal_type(sys.version_info == (3, 9))  # revealed: Literal[False]
+reveal_type((3, 9) == sys.version_info)  # revealed: Literal[False]
+
+reveal_type(sys.version_info != (3, 9))  # revealed: Literal[True]
+reveal_type((3, 9) != sys.version_info)  # revealed: Literal[True]
+```
+
+## Non-literal types from comparisons
+
+Comparing `sys.version_info` with tuples of other lengths will sometimes produce `Literal` types,
+sometimes not:
+
+```py
+import sys
+
+reveal_type(sys.version_info >= (3, 9, 1))  # revealed: bool
+reveal_type(sys.version_info >= (3, 9, 1, "final", 0))  # revealed: bool
+
+# TODO: While this won't fail at runtime, the user has probably made a mistake
+# if they're comparing a tuple of length >5 with `sys.version_info`
+# (`sys.version_info` is a tuple of length 5). It might be worth
+# emitting a lint diagnostic of some kind warning them about the probable error?
+reveal_type(sys.version_info >= (3, 9, 1, "final", 0, 5))  # revealed: bool
+
+reveal_type(sys.version_info == (3, 8, 1, "finallllll", 0))  # revealed: Literal[False]
+```
+
+## Imports and aliases
+
+Comparisons with `sys.version_info` still produce literal types, even if the symbol is aliased to
+another name:
+
+```py
+from sys import version_info
+from sys import version_info as foo
+
+reveal_type(version_info >= (3, 9))  # revealed: Literal[True]
+reveal_type(foo >= (3, 9))  # revealed: Literal[True]
+
+bar = version_info
+reveal_type(bar >= (3, 9))  # revealed: Literal[True]
+```
+
+## Non-stdlib modules named `sys`
+
+Only comparisons with the symbol `version_info` from the `sys` module produce literal types:
+
+```py path=package/__init__.py
+```
+
+```py path=package/sys.py
+version_info: tuple[int, int] = (4, 2)
+```
+
+```py path=package/script.py
+from .sys import version_info
+
+reveal_type(version_info >= (3, 9))  # revealed: bool
+```
+
+## Accessing fields by name
+
+The fields of `sys.version_info` can be accessed by name:
+
+```py path=a.py
+import sys
+
+reveal_type(sys.version_info.major >= 3)  # revealed: Literal[True]
+reveal_type(sys.version_info.minor >= 9)  # revealed: Literal[True]
+reveal_type(sys.version_info.minor >= 10)  # revealed: Literal[False]
+```
+
+But the `micro`, `releaselevel` and `serial` fields are inferred as `@Todo` until we support
+properties on instance types:
+
+```py path=b.py
+import sys
+
+reveal_type(sys.version_info.micro)  # revealed: @Todo(instance attributes)
+reveal_type(sys.version_info.releaselevel)  # revealed: @Todo(instance attributes)
+reveal_type(sys.version_info.serial)  # revealed: @Todo(instance attributes)
+```
+
+## Accessing fields by index/slice
+
+The fields of `sys.version_info` can be accessed by index or by slice:
+
+```py
+import sys
+
+reveal_type(sys.version_info[0] < 3)  # revealed: Literal[False]
+reveal_type(sys.version_info[1] > 9)  # revealed: Literal[False]
+
+# revealed: tuple[Literal[3], Literal[9], int, Literal["alpha", "beta", "candidate", "final"], int]
+reveal_type(sys.version_info[:5])
+
+reveal_type(sys.version_info[:2] >= (3, 9))  # revealed: Literal[True]
+reveal_type(sys.version_info[0:2] >= (3, 10))  # revealed: Literal[False]
+reveal_type(sys.version_info[:3] >= (3, 10, 1))  # revealed: Literal[False]
+reveal_type(sys.version_info[3] == "final")  # revealed: bool
+reveal_type(sys.version_info[3] == "finalllllll")  # revealed: Literal[False]
+```

crates/red_knot_python_semantic/resources/mdtest/type_alias.md

@@ -0,0 +1,71 @@
+# Type aliases
+
+## Basic
+
+```py
+type IntOrStr = int | str
+
+reveal_type(IntOrStr)  # revealed: typing.TypeAliasType
+reveal_type(IntOrStr.__name__)  # revealed: Literal["IntOrStr"]
+
+x: IntOrStr = 1
+
+reveal_type(x)  # revealed: Literal[1]
+
+def f() -> None:
+    reveal_type(x)  # revealed: int | str
+```
+
+## `__value__` attribute
+
+```py
+type IntOrStr = int | str
+
+# TODO: This should either fall back to the specified type from typeshed,
+# which is `Any`, or be the actual type of the runtime value expression
+# `int | str`, i.e. `types.UnionType`.
+reveal_type(IntOrStr.__value__)  # revealed: @Todo(instance attributes)
+```
+
+## Invalid assignment
+
+```py
+type OptionalInt = int | None
+
+# error: [invalid-assignment]
+x: OptionalInt = "1"
+```
+
+## Type aliases in type aliases
+
+```py
+type IntOrStr = int | str
+type IntOrStrOrBytes = IntOrStr | bytes
+
+x: IntOrStrOrBytes = 1
+
+def f() -> None:
+    reveal_type(x)  # revealed: int | str | bytes
+```
+
+## Aliased type aliases
+
+```py
+type IntOrStr = int | str
+MyIntOrStr = IntOrStr
+
+x: MyIntOrStr = 1
+
+# error: [invalid-assignment]
+y: MyIntOrStr = None
+```
+
+## Generic type aliases
+
+```py
+type ListOrSet[T] = list[T] | set[T]
+
+# TODO: Should be `tuple[typing.TypeVar | typing.ParamSpec | typing.TypeVarTuple, ...]`,
+# as specified in the `typeshed` stubs.
+reveal_type(ListOrSet.__type_params__)  # revealed: @Todo(instance attributes)
+```

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

@@ -1,6 +1,10 @@
-# Unary Operations
+# Invert, UAdd, USub
+
+## Instance
 
 ```py
+from typing import Literal
+
 class Number:
     def __init__(self, value: int):
         self.value = 1
@@ -18,7 +22,7 @@ a = Number()
 
 reveal_type(+a)  # revealed: int
 reveal_type(-a)  # revealed: int
-reveal_type(~a)  # revealed: @Todo
+reveal_type(~a)  # revealed: Literal[True]
 
 class NoDunder: ...
 

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

@@ -10,8 +10,6 @@ reveal_type(not not None)  # revealed: Literal[False]
 ## Function
 
 ```py
-from typing import reveal_type
-
 def f():
     return 1
 
@@ -115,3 +113,101 @@ reveal_type(not ())  # revealed: Literal[True]
 reveal_type(not ("hello",))  # revealed: Literal[False]
 reveal_type(not (1, "hello"))  # revealed: Literal[False]
 ```
+
+## Instance
+
+Not operator is inferred based on
+<https://docs.python.org/3/library/stdtypes.html#truth-value-testing>. An instance is True or False
+if the `__bool__` method says so.
+
+At runtime, the `__len__` method is a fallback for `__bool__`, but we can't make use of that. If we
+have a class that defines `__len__` but not `__bool__`, it is possible that any subclass could add a
+`__bool__` method that would invalidate whatever conclusion we drew from `__len__`. So instances of
+classes without a `__bool__` method, with or without `__len__`, must be inferred as unknown
+truthiness.
+
+```py
+class AlwaysTrue:
+    def __bool__(self) -> Literal[True]:
+        return True
+
+# revealed: Literal[False]
+reveal_type(not AlwaysTrue())
+
+class AlwaysFalse:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+# revealed: Literal[True]
+reveal_type(not AlwaysFalse())
+
+# We don't get into a cycle if someone sets their `__bool__` method to the `bool` builtin:
+class BoolIsBool:
+    __bool__ = bool
+
+# revealed: bool
+reveal_type(not BoolIsBool())
+
+# At runtime, no `__bool__` and no `__len__` means truthy, but we can't rely on that, because
+# a subclass could add a `__bool__` method.
+class NoBoolMethod: ...
+
+# revealed: bool
+reveal_type(not NoBoolMethod())
+
+# And we can't rely on `__len__` for the same reason: a subclass could add `__bool__`.
+class LenZero:
+    def __len__(self) -> Literal[0]:
+        return 0
+
+# revealed: bool
+reveal_type(not LenZero())
+
+class LenNonZero:
+    def __len__(self) -> Literal[1]:
+        return 1
+
+# revealed: bool
+reveal_type(not LenNonZero())
+
+class WithBothLenAndBool1:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+    def __len__(self) -> Literal[2]:
+        return 2
+
+# revealed: Literal[True]
+reveal_type(not WithBothLenAndBool1())
+
+class WithBothLenAndBool2:
+    def __bool__(self) -> Literal[True]:
+        return True
+
+    def __len__(self) -> Literal[0]:
+        return 0
+
+# revealed: Literal[False]
+reveal_type(not WithBothLenAndBool2())
+
+# TODO: raise diagnostic when __bool__ method is not valid: [unsupported-operator] "Method __bool__ for type `MethodBoolInvalid` should return `bool`, returned type `int`"
+# https://docs.python.org/3/reference/datamodel.html#object.__bool__
+class MethodBoolInvalid:
+    def __bool__(self) -> int:
+        return 0
+
+# revealed: bool
+reveal_type(not MethodBoolInvalid())
+
+# Don't trust a possibly-unbound `__bool__` method:
+def get_flag() -> bool:
+    return True
+
+class PossiblyUnboundBool:
+    if get_flag():
+        def __bool__(self) -> Literal[False]:
+            return False
+
+# revealed: bool
+reveal_type(not PossiblyUnboundBool())
+```

crates/red_knot_python_semantic/resources/mdtest/unpacking.md

@@ -84,7 +84,7 @@ reveal_type(b)  # revealed: Literal[2]
 [a, *b, c, d] = (1, 2)
 reveal_type(a)  # revealed: Literal[1]
 # TODO: Should be list[Any] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: Literal[2]
 reveal_type(d)  # revealed: Unknown
 ```
@@ -95,7 +95,7 @@ reveal_type(d)  # revealed: Unknown
 [a, *b, c] = (1, 2)
 reveal_type(a)  # revealed: Literal[1]
 # TODO: Should be list[Any] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: Literal[2]
 ```
 
@@ -105,7 +105,7 @@ reveal_type(c)  # revealed: Literal[2]
 [a, *b, c] = (1, 2, 3)
 reveal_type(a)  # revealed: Literal[1]
 # TODO: Should be list[int] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: Literal[3]
 ```
 
@@ -115,7 +115,7 @@ reveal_type(c)  # revealed: Literal[3]
 [a, *b, c, d] = (1, 2, 3, 4, 5, 6)
 reveal_type(a)  # revealed: Literal[1]
 # TODO: Should be list[int] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: Literal[5]
 reveal_type(d)  # revealed: Literal[6]
 ```
@@ -127,7 +127,7 @@ reveal_type(d)  # revealed: Literal[6]
 reveal_type(a)  # revealed: Literal[1]
 reveal_type(b)  # revealed: Literal[2]
 # TODO: Should be list[int] once support for assigning to starred expression is added
-reveal_type(c)  # revealed: @Todo
+reveal_type(c)  # revealed: @Todo(starred unpacking)
 ```
 
 ### Starred expression (6)
@@ -138,20 +138,15 @@ reveal_type(c)  # revealed: @Todo
 reveal_type(a)  # revealed: Literal[1]
 reveal_type(b)  # revealed: Unknown
 reveal_type(c)  # revealed: Unknown
-reveal_type(d)  # revealed: @Todo
+reveal_type(d)  # revealed: @Todo(starred unpacking)
 reveal_type(e)  # revealed: Unknown
 reveal_type(f)  # revealed: Unknown
 ```
 
 ### Non-iterable unpacking
 
-TODO: Remove duplicate diagnostics. This is happening because for a sequence-like assignment target,
-multiple definitions are created and the inference engine runs on each of them which results in
-duplicate diagnostics.
-
 ```py
 # error: "Object of type `Literal[1]` is not iterable"
-# error: "Object of type `Literal[1]` is not iterable"
 a, b = 1
 reveal_type(a)  # revealed: Unknown
 reveal_type(b)  # revealed: Unknown
@@ -227,7 +222,7 @@ reveal_type(b)  # revealed: LiteralString
 (a, *b, c, d) = "ab"
 reveal_type(a)  # revealed: LiteralString
 # TODO: Should be list[LiteralString] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: LiteralString
 reveal_type(d)  # revealed: Unknown
 ```
@@ -238,7 +233,7 @@ reveal_type(d)  # revealed: Unknown
 (a, *b, c) = "ab"
 reveal_type(a)  # revealed: LiteralString
 # TODO: Should be list[Any] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: LiteralString
 ```
 
@@ -248,7 +243,7 @@ reveal_type(c)  # revealed: LiteralString
 (a, *b, c) = "abc"
 reveal_type(a)  # revealed: LiteralString
 # TODO: Should be list[LiteralString] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: LiteralString
 ```
 
@@ -258,7 +253,7 @@ reveal_type(c)  # revealed: LiteralString
 (a, *b, c, d) = "abcdef"
 reveal_type(a)  # revealed: LiteralString
 # TODO: Should be list[LiteralString] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: LiteralString
 reveal_type(d)  # revealed: LiteralString
 ```
@@ -270,5 +265,5 @@ reveal_type(d)  # revealed: LiteralString
 reveal_type(a)  # revealed: LiteralString
 reveal_type(b)  # revealed: LiteralString
 # TODO: Should be list[int] once support for assigning to starred expression is added
-reveal_type(c)  # revealed: @Todo
+reveal_type(c)  # revealed: @Todo(starred unpacking)
 ```

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

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

crates/red_knot_python_semantic/src/lib.rs

@@ -22,6 +22,7 @@ pub(crate) mod site_packages;
 mod stdlib;
 pub(crate) mod symbol;
 pub mod types;
+mod unpack;
 mod util;
 
 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;

crates/red_knot_python_semantic/src/module_resolver/typeshed.rs

@@ -459,11 +459,11 @@ foo: 3.8-   # trailing comment
 ";
         let parsed_versions = TypeshedVersions::from_str(VERSIONS).unwrap();
         assert_eq!(parsed_versions.len(), 3);
-        assert_snapshot!(parsed_versions.to_string(), @r###"
+        assert_snapshot!(parsed_versions.to_string(), @r"
         bar: 2.7-3.10
         bar.baz: 3.1-3.9
         foo: 3.8-
-        "###
+        "
         );
     }
 

crates/red_knot_python_semantic/src/node_key.rs

@@ -1,14 +1,14 @@
-use ruff_python_ast::{AnyNodeRef, NodeKind};
-use ruff_text_size::{Ranged, TextRange};
+use ruff_python_ast::AnyNodeRef;
 
 /// Compact key for a node for use in a hash map.
 ///
-/// Compares two nodes by their kind and text range.
+/// Stores the memory address of the node, because using the range and the kind
+/// of the node is not enough to uniquely identify them in ASTs resulting from
+/// invalid syntax. For example, parsing the input `for` results in a `StmtFor`
+/// AST node where both the `target` and the `iter` field are `ExprName` nodes
+/// with the same (empty) range `3..3`.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub(super) struct NodeKey {
-    kind: NodeKind,
-    range: TextRange,
-}
+pub(super) struct NodeKey(usize);
 
 impl NodeKey {
     pub(super) fn from_node<'a, N>(node: N) -> Self
@@ -16,9 +16,6 @@ impl NodeKey {
         N: Into<AnyNodeRef<'a>>,
     {
         let node = node.into();
-        NodeKey {
-            kind: node.kind(),
-            range: node.range(),
-        }
+        NodeKey(node.as_ptr().as_ptr() as usize)
     }
 }

crates/red_knot_python_semantic/src/program.rs

@@ -54,6 +54,7 @@ impl Program {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
 pub struct ProgramSettings {
     pub target_version: PythonVersion,
     pub search_paths: SearchPathSettings,
@@ -61,6 +62,7 @@ pub struct ProgramSettings {
 
 /// Configures the search paths for module resolution.
 #[derive(Eq, PartialEq, Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
 pub struct SearchPathSettings {
     /// List of user-provided paths that should take first priority in the module resolution.
     /// Examples in other type checkers are mypy's MYPYPATH environment variable,
@@ -91,6 +93,7 @@ impl SearchPathSettings {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
 pub enum SitePackages {
     Derived {
         venv_path: SystemPathBuf,

crates/red_knot_python_semantic/src/python_version.rs

@@ -5,6 +5,7 @@ use std::fmt;
 /// Unlike the `TargetVersion` enums in the CLI crates,
 /// this does not necessarily represent a Python version that we actually support.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
 pub struct PythonVersion {
     pub major: u8,
     pub minor: u8,
@@ -38,7 +39,7 @@ impl PythonVersion {
 
 impl Default for PythonVersion {
     fn default() -> Self {
-        Self::PY38
+        Self::PY39
     }
 }
 

crates/red_knot_python_semantic/src/semantic_index.rs

@@ -125,6 +125,7 @@ impl<'db> SemanticIndex<'db> {
     ///
     /// Use the Salsa cached [`symbol_table()`] query if you only need the
     /// symbol table for a single scope.
+    #[track_caller]
     pub(super) fn symbol_table(&self, scope_id: FileScopeId) -> Arc<SymbolTable> {
         self.symbol_tables[scope_id].clone()
     }
@@ -133,15 +134,18 @@ impl<'db> SemanticIndex<'db> {
     ///
     /// Use the Salsa cached [`use_def_map()`] query if you only need the
     /// use-def map for a single scope.
+    #[track_caller]
     pub(super) fn use_def_map(&self, scope_id: FileScopeId) -> Arc<UseDefMap> {
         self.use_def_maps[scope_id].clone()
     }
 
+    #[track_caller]
     pub(crate) fn ast_ids(&self, scope_id: FileScopeId) -> &AstIds {
         &self.ast_ids[scope_id]
     }
 
     /// Returns the ID of the `expression`'s enclosing scope.
+    #[track_caller]
     pub(crate) fn expression_scope_id(
         &self,
         expression: impl Into<ExpressionNodeKey>,
@@ -151,11 +155,13 @@ impl<'db> SemanticIndex<'db> {
 
     /// Returns the [`Scope`] of the `expression`'s enclosing scope.
     #[allow(unused)]
+    #[track_caller]
     pub(crate) fn expression_scope(&self, expression: impl Into<ExpressionNodeKey>) -> &Scope {
         &self.scopes[self.expression_scope_id(expression)]
     }
 
     /// Returns the [`Scope`] with the given id.
+    #[track_caller]
     pub(crate) fn scope(&self, id: FileScopeId) -> &Scope {
         &self.scopes[id]
     }
@@ -172,6 +178,7 @@ impl<'db> SemanticIndex<'db> {
 
     /// Returns the parent scope of `scope_id`.
     #[allow(unused)]
+    #[track_caller]
     pub(crate) fn parent_scope(&self, scope_id: FileScopeId) -> Option<&Scope> {
         Some(&self.scopes[self.parent_scope_id(scope_id)?])
     }
@@ -195,6 +202,7 @@ impl<'db> SemanticIndex<'db> {
     }
 
     /// Returns the [`Definition`] salsa ingredient for `definition_key`.
+    #[track_caller]
     pub(crate) fn definition(
         &self,
         definition_key: impl Into<DefinitionNodeKey>,
@@ -206,6 +214,7 @@ impl<'db> SemanticIndex<'db> {
     /// Panics if we have no expression ingredient for that node. We can only call this method for
     /// standalone-inferable expressions, which we call `add_standalone_expression` for in
     /// [`SemanticIndexBuilder`].
+    #[track_caller]
     pub(crate) fn expression(
         &self,
         expression_key: impl Into<ExpressionNodeKey>,
@@ -213,8 +222,18 @@ impl<'db> SemanticIndex<'db> {
         self.expressions_by_node[&expression_key.into()]
     }
 
+    pub(crate) fn try_expression(
+        &self,
+        expression_key: impl Into<ExpressionNodeKey>,
+    ) -> Option<Expression<'db>> {
+        self.expressions_by_node
+            .get(&expression_key.into())
+            .copied()
+    }
+
     /// Returns the id of the scope that `node` creates. This is different from [`Definition::scope`] which
     /// returns the scope in which that definition is defined in.
+    #[track_caller]
     pub(crate) fn node_scope(&self, node: NodeWithScopeRef) -> FileScopeId {
         self.scopes_by_node[&node.node_key()]
     }

crates/red_knot_python_semantic/src/semantic_index/ast_ids.rs

@@ -49,56 +49,50 @@ fn ast_ids<'db>(db: &'db dyn Db, scope: ScopeId) -> &'db AstIds {
     semantic_index(db, scope.file(db)).ast_ids(scope.file_scope_id(db))
 }
 
-pub trait HasScopedUseId {
-    /// The type of the ID uniquely identifying the use.
-    type Id: Copy;
-
-    /// Returns the ID that uniquely identifies the use in `scope`.
-    fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id;
-}
-
 /// Uniquely identifies a use of a name in a [`crate::semantic_index::symbol::FileScopeId`].
 #[newtype_index]
 pub struct ScopedUseId;
 
-impl HasScopedUseId for ast::ExprName {
-    type Id = ScopedUseId;
+pub trait HasScopedUseId {
+    /// Returns the ID that uniquely identifies the use in `scope`.
+    fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId;
+}
 
-    fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id {
+impl HasScopedUseId for ast::ExprName {
+    fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId {
         let expression_ref = ExpressionRef::from(self);
         expression_ref.scoped_use_id(db, scope)
     }
 }
 
 impl HasScopedUseId for ast::ExpressionRef<'_> {
-    type Id = ScopedUseId;
-
-    fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id {
+    fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId {
         let ast_ids = ast_ids(db, scope);
         ast_ids.use_id(*self)
     }
 }
 
-pub trait HasScopedAstId {
-    /// The type of the ID uniquely identifying the node.
-    type Id: Copy;
-
-    /// Returns the ID that uniquely identifies the node in `scope`.
-    fn scoped_ast_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id;
-}
-
 /// Uniquely identifies an [`ast::Expr`] in a [`crate::semantic_index::symbol::FileScopeId`].
 #[newtype_index]
 pub struct ScopedExpressionId;
 
+pub trait HasScopedExpressionId {
+    /// Returns the ID that uniquely identifies the node in `scope`.
+    fn scoped_expression_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedExpressionId;
+}
+
+impl<T: HasScopedExpressionId> HasScopedExpressionId for Box<T> {
+    fn scoped_expression_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedExpressionId {
+        self.as_ref().scoped_expression_id(db, scope)
+    }
+}
+
 macro_rules! impl_has_scoped_expression_id {
     ($ty: ty) => {
-        impl HasScopedAstId for $ty {
-            type Id = ScopedExpressionId;
-
-            fn scoped_ast_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id {
+        impl HasScopedExpressionId for $ty {
+            fn scoped_expression_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedExpressionId {
                 let expression_ref = ExpressionRef::from(self);
-                expression_ref.scoped_ast_id(db, scope)
+                expression_ref.scoped_expression_id(db, scope)
             }
         }
     };
@@ -138,29 +132,20 @@ impl_has_scoped_expression_id!(ast::ExprSlice);
 impl_has_scoped_expression_id!(ast::ExprIpyEscapeCommand);
 impl_has_scoped_expression_id!(ast::Expr);
 
-impl HasScopedAstId for ast::ExpressionRef<'_> {
-    type Id = ScopedExpressionId;
-
-    fn scoped_ast_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id {
+impl HasScopedExpressionId for ast::ExpressionRef<'_> {
+    fn scoped_expression_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedExpressionId {
         let ast_ids = ast_ids(db, scope);
         ast_ids.expression_id(*self)
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub(super) struct AstIdsBuilder {
     expressions_map: FxHashMap<ExpressionNodeKey, ScopedExpressionId>,
     uses_map: FxHashMap<ExpressionNodeKey, ScopedUseId>,
 }
 
 impl AstIdsBuilder {
-    pub(super) fn new() -> Self {
-        Self {
-            expressions_map: FxHashMap::default(),
-            uses_map: FxHashMap::default(),
-        }
-    }
-
     /// Adds `expr` to the expression ids map and returns its id.
     pub(super) fn record_expression(&mut self, expr: &ast::Expr) -> ScopedExpressionId {
         let expression_id = self.expressions_map.len().into();

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -25,27 +25,42 @@ use crate::semantic_index::symbol::{
 };
 use crate::semantic_index::use_def::{FlowSnapshot, UseDefMapBuilder};
 use crate::semantic_index::SemanticIndex;
+use crate::unpack::Unpack;
 use crate::Db;
 
 use super::constraint::{Constraint, ConstraintNode, PatternConstraint};
 use super::definition::{
-    AssignmentKind, DefinitionCategory, ExceptHandlerDefinitionNodeRef,
-    MatchPatternDefinitionNodeRef, WithItemDefinitionNodeRef,
+    DefinitionCategory, ExceptHandlerDefinitionNodeRef, MatchPatternDefinitionNodeRef,
+    WithItemDefinitionNodeRef,
 };
 
 mod except_handlers;
 
+/// Are we in a state where a `break` statement is allowed?
+#[derive(Clone, Copy, Debug)]
+enum LoopState {
+    InLoop,
+    NotInLoop,
+}
+
+impl LoopState {
+    fn is_inside(self) -> bool {
+        matches!(self, LoopState::InLoop)
+    }
+}
+
 pub(super) struct SemanticIndexBuilder<'db> {
     // Builder state
     db: &'db dyn Db,
     file: File,
     module: &'db ParsedModule,
-    scope_stack: Vec<FileScopeId>,
+    scope_stack: Vec<(FileScopeId, LoopState)>,
     /// The assignments we're currently visiting, with
     /// the most recent visit at the end of the Vec
     current_assignments: Vec<CurrentAssignment<'db>>,
     /// The match case we're currently visiting.
     current_match_case: Option<CurrentMatchCase<'db>>,
+
     /// Flow states at each `break` in the current loop.
     loop_break_states: Vec<FlowSnapshot>,
     /// Per-scope contexts regarding nested `try`/`except` statements
@@ -101,9 +116,24 @@ impl<'db> SemanticIndexBuilder<'db> {
         *self
             .scope_stack
             .last()
+            .map(|(scope, _)| scope)
             .expect("Always to have a root scope")
     }
 
+    fn loop_state(&self) -> LoopState {
+        self.scope_stack
+            .last()
+            .expect("Always to have a root scope")
+            .1
+    }
+
+    fn set_inside_loop(&mut self, state: LoopState) {
+        self.scope_stack
+            .last_mut()
+            .expect("Always to have a root scope")
+            .1 = state;
+    }
+
     fn push_scope(&mut self, node: NodeWithScopeRef) {
         let parent = self.current_scope();
         self.push_scope_with_parent(node, Some(parent));
@@ -112,38 +142,33 @@ impl<'db> SemanticIndexBuilder<'db> {
     fn push_scope_with_parent(&mut self, node: NodeWithScopeRef, parent: Option<FileScopeId>) {
         let children_start = self.scopes.next_index() + 1;
 
+        #[allow(unsafe_code)]
         let scope = Scope {
             parent,
-            kind: node.scope_kind(),
+            // SAFETY: `node` is guaranteed to be a child of `self.module`
+            node: unsafe { node.to_kind(self.module.clone()) },
             descendents: children_start..children_start,
         };
         self.try_node_context_stack_manager.enter_nested_scope();
 
         let file_scope_id = self.scopes.push(scope);
-        self.symbol_tables.push(SymbolTableBuilder::new());
-        self.use_def_maps.push(UseDefMapBuilder::new());
-        let ast_id_scope = self.ast_ids.push(AstIdsBuilder::new());
+        self.symbol_tables.push(SymbolTableBuilder::default());
+        self.use_def_maps.push(UseDefMapBuilder::default());
+        let ast_id_scope = self.ast_ids.push(AstIdsBuilder::default());
 
-        #[allow(unsafe_code)]
-        // SAFETY: `node` is guaranteed to be a child of `self.module`
-        let scope_id = ScopeId::new(
-            self.db,
-            self.file,
-            file_scope_id,
-            unsafe { node.to_kind(self.module.clone()) },
-            countme::Count::default(),
-        );
+        let scope_id = ScopeId::new(self.db, self.file, file_scope_id, countme::Count::default());
 
         self.scope_ids_by_scope.push(scope_id);
-        self.scopes_by_node.insert(node.node_key(), file_scope_id);
+        let previous = self.scopes_by_node.insert(node.node_key(), file_scope_id);
+        debug_assert_eq!(previous, None);
 
         debug_assert_eq!(ast_id_scope, file_scope_id);
 
-        self.scope_stack.push(file_scope_id);
+        self.scope_stack.push((file_scope_id, LoopState::NotInLoop));
     }
 
     fn pop_scope(&mut self) -> FileScopeId {
-        let id = self.scope_stack.pop().expect("Root scope to be present");
+        let (id, _) = self.scope_stack.pop().expect("Root scope to be present");
         let children_end = self.scopes.next_index();
         let scope = &mut self.scopes[id];
         scope.descendents = scope.descendents.start..children_end;
@@ -203,10 +228,10 @@ impl<'db> SemanticIndexBuilder<'db> {
         self.current_symbol_table().mark_symbol_used(id);
     }
 
-    fn add_definition<'a>(
+    fn add_definition(
         &mut self,
         symbol: ScopedSymbolId,
-        definition_node: impl Into<DefinitionNodeRef<'a>>,
+        definition_node: impl Into<DefinitionNodeRef<'db>>,
     ) -> Definition<'db> {
         let definition_node: DefinitionNodeRef<'_> = definition_node.into();
         #[allow(unsafe_code)]
@@ -285,8 +310,12 @@ impl<'db> SemanticIndexBuilder<'db> {
         debug_assert!(popped_assignment.is_some());
     }
 
-    fn current_assignment(&self) -> Option<&CurrentAssignment<'db>> {
-        self.current_assignments.last()
+    fn current_assignment(&self) -> Option<CurrentAssignment<'db>> {
+        self.current_assignments.last().copied()
+    }
+
+    fn current_assignment_mut(&mut self) -> Option<&mut CurrentAssignment<'db>> {
+        self.current_assignments.last_mut()
     }
 
     fn add_pattern_constraint(
@@ -373,6 +402,11 @@ impl<'db> SemanticIndexBuilder<'db> {
                 if let Some(default) = default {
                     self.visit_expr(default);
                 }
+                match type_param {
+                    ast::TypeParam::TypeVar(node) => self.add_definition(symbol, node),
+                    ast::TypeParam::ParamSpec(node) => self.add_definition(symbol, node),
+                    ast::TypeParam::TypeVarTuple(node) => self.add_definition(symbol, node),
+                };
             }
         }
 
@@ -445,7 +479,7 @@ impl<'db> SemanticIndexBuilder<'db> {
         self.pop_scope();
     }
 
-    fn declare_parameter(&mut self, parameter: AnyParameterRef) {
+    fn declare_parameter(&mut self, parameter: AnyParameterRef<'db>) {
         let symbol = self.add_symbol(parameter.name().id().clone());
 
         let definition = self.add_definition(symbol, parameter);
@@ -584,6 +618,27 @@ where
                     },
                 );
             }
+            ast::Stmt::TypeAlias(type_alias) => {
+                let symbol = self.add_symbol(
+                    type_alias
+                        .name
+                        .as_name_expr()
+                        .map(|name| name.id.clone())
+                        .unwrap_or("<unknown>".into()),
+                );
+                self.add_definition(symbol, type_alias);
+                self.visit_expr(&type_alias.name);
+
+                self.with_type_params(
+                    NodeWithScopeRef::TypeAliasTypeParameters(type_alias),
+                    type_alias.type_params.as_ref(),
+                    |builder| {
+                        builder.push_scope(NodeWithScopeRef::TypeAlias(type_alias));
+                        builder.visit_expr(&type_alias.value);
+                        builder.pop_scope()
+                    },
+                );
+            }
             ast::Stmt::Import(node) => {
                 for alias in &node.names {
                     let symbol_name = if let Some(asname) = &alias.asname {
@@ -619,24 +674,48 @@ where
             }
             ast::Stmt::Assign(node) => {
                 debug_assert_eq!(&self.current_assignments, &[]);
+
                 self.visit_expr(&node.value);
-                self.add_standalone_expression(&node.value);
-                for (target_index, target) in node.targets.iter().enumerate() {
-                    let kind = match target {
-                        ast::Expr::List(_) | ast::Expr::Tuple(_) => Some(AssignmentKind::Sequence),
-                        ast::Expr::Name(_) => Some(AssignmentKind::Name),
+                let value = self.add_standalone_expression(&node.value);
+
+                for target in &node.targets {
+                    // We only handle assignments to names and unpackings here, other targets like
+                    // attribute and subscript are handled separately as they don't create a new
+                    // definition.
+                    let current_assignment = match target {
+                        ast::Expr::List(_) | ast::Expr::Tuple(_) => {
+                            Some(CurrentAssignment::Assign {
+                                node,
+                                first: true,
+                                unpack: Some(Unpack::new(
+                                    self.db,
+                                    self.file,
+                                    self.current_scope(),
+                                    #[allow(unsafe_code)]
+                                    unsafe {
+                                        AstNodeRef::new(self.module.clone(), target)
+                                    },
+                                    value,
+                                    countme::Count::default(),
+                                )),
+                            })
+                        }
+                        ast::Expr::Name(_) => Some(CurrentAssignment::Assign {
+                            node,
+                            unpack: None,
+                            first: false,
+                        }),
                         _ => None,
                     };
-                    if let Some(kind) = kind {
-                        self.push_assignment(CurrentAssignment::Assign {
-                            assignment: node,
-                            target_index,
-                            kind,
-                        });
+
+                    if let Some(current_assignment) = current_assignment {
+                        self.push_assignment(current_assignment);
                     }
+
                     self.visit_expr(target);
-                    if kind.is_some() {
-                        // only need to pop in the case where we pushed something
+
+                    if current_assignment.is_some() {
+                        // Only need to pop in the case where we pushed something
                         self.pop_assignment();
                     }
                 }
@@ -647,9 +726,18 @@ where
                 if let Some(value) = &node.value {
                     self.visit_expr(value);
                 }
-                self.push_assignment(node.into());
-                self.visit_expr(&node.target);
-                self.pop_assignment();
+
+                // See https://docs.python.org/3/library/ast.html#ast.AnnAssign
+                if matches!(
+                    *node.target,
+                    ast::Expr::Attribute(_) | ast::Expr::Subscript(_) | ast::Expr::Name(_)
+                ) {
+                    self.push_assignment(node.into());
+                    self.visit_expr(&node.target);
+                    self.pop_assignment();
+                } else {
+                    self.visit_expr(&node.target);
+                }
             }
             ast::Stmt::AugAssign(
                 aug_assign @ ast::StmtAugAssign {
@@ -661,9 +749,18 @@ where
             ) => {
                 debug_assert_eq!(&self.current_assignments, &[]);
                 self.visit_expr(value);
-                self.push_assignment(aug_assign.into());
-                self.visit_expr(target);
-                self.pop_assignment();
+
+                // See https://docs.python.org/3/library/ast.html#ast.AugAssign
+                if matches!(
+                    **target,
+                    ast::Expr::Attribute(_) | ast::Expr::Subscript(_) | ast::Expr::Name(_)
+                ) {
+                    self.push_assignment(aug_assign.into());
+                    self.visit_expr(target);
+                    self.pop_assignment();
+                } else {
+                    self.visit_expr(target);
+                }
             }
             ast::Stmt::If(node) => {
                 self.visit_expr(&node.test);
@@ -716,7 +813,10 @@ where
 
                 // TODO: definitions created inside the body should be fully visible
                 // to other statements/expressions inside the body --Alex/Carl
+                let outer_loop_state = self.loop_state();
+                self.set_inside_loop(LoopState::InLoop);
                 self.visit_body(body);
+                self.set_inside_loop(outer_loop_state);
 
                 // Get the break states from the body of this loop, and restore the saved outer
                 // ones.
@@ -755,7 +855,9 @@ where
                 self.visit_body(body);
             }
             ast::Stmt::Break(_) => {
-                self.loop_break_states.push(self.flow_snapshot());
+                if self.loop_state().is_inside() {
+                    self.loop_break_states.push(self.flow_snapshot());
+                }
             }
 
             ast::Stmt::For(
@@ -782,7 +884,10 @@ where
                 // TODO: Definitions created by loop variables
                 // (and definitions created inside the body)
                 // are fully visible to other statements/expressions inside the body --Alex/Carl
+                let outer_loop_state = self.loop_state();
+                self.set_inside_loop(LoopState::InLoop);
                 self.visit_body(body);
+                self.set_inside_loop(outer_loop_state);
 
                 let break_states =
                     std::mem::replace(&mut self.loop_break_states, saved_break_states);
@@ -970,19 +1075,19 @@ where
                 }
 
                 if is_definition {
-                    match self.current_assignment().copied() {
+                    match self.current_assignment() {
                         Some(CurrentAssignment::Assign {
-                            assignment,
-                            target_index,
-                            kind,
+                            node,
+                            first,
+                            unpack,
                         }) => {
                             self.add_definition(
                                 symbol,
                                 AssignmentDefinitionNodeRef {
-                                    assignment,
-                                    target_index,
+                                    unpack,
+                                    value: &node.value,
                                     name: name_node,
-                                    kind,
+                                    first,
                                 },
                             );
                         }
@@ -1033,14 +1138,25 @@ where
                     }
                 }
 
+                if let Some(CurrentAssignment::Assign { first, .. }) = self.current_assignment_mut()
+                {
+                    *first = false;
+                }
+
                 walk_expr(self, expr);
             }
             ast::Expr::Named(node) => {
                 // TODO walrus in comprehensions is implicitly nonlocal
                 self.visit_expr(&node.value);
-                self.push_assignment(node.into());
-                self.visit_expr(&node.target);
-                self.pop_assignment();
+
+                // See https://peps.python.org/pep-0572/#differences-between-assignment-expressions-and-assignment-statements
+                if node.target.is_name_expr() {
+                    self.push_assignment(node.into());
+                    self.visit_expr(&node.target);
+                    self.pop_assignment();
+                } else {
+                    self.visit_expr(&node.target);
+                }
             }
             ast::Expr::Lambda(lambda) => {
                 if let Some(parameters) = &lambda.parameters {
@@ -1074,9 +1190,12 @@ where
                 // later checking)
                 self.visit_expr(test);
                 let pre_if = self.flow_snapshot();
+                let constraint = self.record_expression_constraint(test);
                 self.visit_expr(body);
                 let post_body = self.flow_snapshot();
                 self.flow_restore(pre_if);
+
+                self.record_negated_constraint(constraint);
                 self.visit_expr(orelse);
                 self.flow_merge(post_body);
             }
@@ -1229,9 +1348,9 @@ where
 #[derive(Copy, Clone, Debug, PartialEq)]
 enum CurrentAssignment<'a> {
     Assign {
-        assignment: &'a ast::StmtAssign,
-        target_index: usize,
-        kind: AssignmentKind,
+        node: &'a ast::StmtAssign,
+        first: bool,
+        unpack: Option<Unpack<'a>>,
     },
     AnnAssign(&'a ast::StmtAnnAssign),
     AugAssign(&'a ast::StmtAugAssign),

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -6,8 +6,22 @@ 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;
 
+/// A definition of a symbol.
+///
+/// ## Module-local type
+/// This type should not be used as part of any cross-module API because
+/// it holds a reference to the AST node. Range-offset changes
+/// then propagate through all usages, and deserialization requires
+/// reparsing the entire module.
+///
+/// E.g. don't use this type in:
+///
+/// * a return type of a cross-module query
+/// * a field of a type that is a return type of a cross-module query
+/// * an argument of a cross-module query
 #[salsa::tracked]
 pub struct Definition<'db> {
     /// The file in which the definition occurs.
@@ -24,7 +38,7 @@ pub struct Definition<'db> {
 
     #[no_eq]
     #[return_ref]
-    pub(crate) kind: DefinitionKind,
+    pub(crate) kind: DefinitionKind<'db>,
 
     #[no_eq]
     count: countme::Count<Definition<'static>>,
@@ -69,6 +83,7 @@ pub(crate) enum DefinitionNodeRef<'a> {
     For(ForStmtDefinitionNodeRef<'a>),
     Function(&'a ast::StmtFunctionDef),
     Class(&'a ast::StmtClassDef),
+    TypeAlias(&'a ast::StmtTypeAlias),
     NamedExpression(&'a ast::ExprNamed),
     Assignment(AssignmentDefinitionNodeRef<'a>),
     AnnotatedAssignment(&'a ast::StmtAnnAssign),
@@ -78,6 +93,9 @@ pub(crate) enum DefinitionNodeRef<'a> {
     WithItem(WithItemDefinitionNodeRef<'a>),
     MatchPattern(MatchPatternDefinitionNodeRef<'a>),
     ExceptHandler(ExceptHandlerDefinitionNodeRef<'a>),
+    TypeVar(&'a ast::TypeParamTypeVar),
+    ParamSpec(&'a ast::TypeParamParamSpec),
+    TypeVarTuple(&'a ast::TypeParamTypeVarTuple),
 }
 
 impl<'a> From<&'a ast::StmtFunctionDef> for DefinitionNodeRef<'a> {
@@ -92,6 +110,12 @@ impl<'a> From<&'a ast::StmtClassDef> for DefinitionNodeRef<'a> {
     }
 }
 
+impl<'a> From<&'a ast::StmtTypeAlias> for DefinitionNodeRef<'a> {
+    fn from(node: &'a ast::StmtTypeAlias) -> Self {
+        Self::TypeAlias(node)
+    }
+}
+
 impl<'a> From<&'a ast::ExprNamed> for DefinitionNodeRef<'a> {
     fn from(node: &'a ast::ExprNamed) -> Self {
         Self::NamedExpression(node)
@@ -116,6 +140,24 @@ impl<'a> From<&'a ast::Alias> for DefinitionNodeRef<'a> {
     }
 }
 
+impl<'a> From<&'a ast::TypeParamTypeVar> for DefinitionNodeRef<'a> {
+    fn from(value: &'a ast::TypeParamTypeVar) -> Self {
+        Self::TypeVar(value)
+    }
+}
+
+impl<'a> From<&'a ast::TypeParamParamSpec> for DefinitionNodeRef<'a> {
+    fn from(value: &'a ast::TypeParamParamSpec) -> Self {
+        Self::ParamSpec(value)
+    }
+}
+
+impl<'a> From<&'a ast::TypeParamTypeVarTuple> for DefinitionNodeRef<'a> {
+    fn from(value: &'a ast::TypeParamTypeVarTuple) -> Self {
+        Self::TypeVarTuple(value)
+    }
+}
+
 impl<'a> From<ImportFromDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
     fn from(node_ref: ImportFromDefinitionNodeRef<'a>) -> Self {
         Self::ImportFrom(node_ref)
@@ -166,10 +208,10 @@ pub(crate) struct ImportFromDefinitionNodeRef<'a> {
 
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct AssignmentDefinitionNodeRef<'a> {
-    pub(crate) assignment: &'a ast::StmtAssign,
-    pub(crate) target_index: usize,
+    pub(crate) unpack: Option<Unpack<'a>>,
+    pub(crate) value: &'a ast::Expr,
     pub(crate) name: &'a ast::ExprName,
-    pub(crate) kind: AssignmentKind,
+    pub(crate) first: bool,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -211,9 +253,9 @@ pub(crate) struct MatchPatternDefinitionNodeRef<'a> {
     pub(crate) index: u32,
 }
 
-impl DefinitionNodeRef<'_> {
+impl<'db> DefinitionNodeRef<'db> {
     #[allow(unsafe_code)]
-    pub(super) unsafe fn into_owned(self, parsed: ParsedModule) -> DefinitionKind {
+    pub(super) unsafe fn into_owned(self, parsed: ParsedModule) -> DefinitionKind<'db> {
         match self {
             DefinitionNodeRef::Import(alias) => {
                 DefinitionKind::Import(AstNodeRef::new(parsed, alias))
@@ -230,19 +272,22 @@ impl DefinitionNodeRef<'_> {
             DefinitionNodeRef::Class(class) => {
                 DefinitionKind::Class(AstNodeRef::new(parsed, class))
             }
+            DefinitionNodeRef::TypeAlias(type_alias) => {
+                DefinitionKind::TypeAlias(AstNodeRef::new(parsed, type_alias))
+            }
             DefinitionNodeRef::NamedExpression(named) => {
                 DefinitionKind::NamedExpression(AstNodeRef::new(parsed, named))
             }
             DefinitionNodeRef::Assignment(AssignmentDefinitionNodeRef {
-                assignment,
-                target_index,
+                unpack,
+                value,
                 name,
-                kind,
+                first,
             }) => DefinitionKind::Assignment(AssignmentDefinitionKind {
-                assignment: AstNodeRef::new(parsed.clone(), assignment),
-                target_index,
+                target: TargetKind::from(unpack),
+                value: AstNodeRef::new(parsed.clone(), value),
                 name: AstNodeRef::new(parsed, name),
-                kind,
+                first,
             }),
             DefinitionNodeRef::AnnotatedAssignment(assign) => {
                 DefinitionKind::AnnotatedAssignment(AstNodeRef::new(parsed, assign))
@@ -303,6 +348,15 @@ impl DefinitionNodeRef<'_> {
                 handler: AstNodeRef::new(parsed, handler),
                 is_star,
             }),
+            DefinitionNodeRef::TypeVar(node) => {
+                DefinitionKind::TypeVar(AstNodeRef::new(parsed, node))
+            }
+            DefinitionNodeRef::ParamSpec(node) => {
+                DefinitionKind::ParamSpec(AstNodeRef::new(parsed, node))
+            }
+            DefinitionNodeRef::TypeVarTuple(node) => {
+                DefinitionKind::TypeVarTuple(AstNodeRef::new(parsed, node))
+            }
         }
     }
 
@@ -314,12 +368,13 @@ impl DefinitionNodeRef<'_> {
             }
             Self::Function(node) => node.into(),
             Self::Class(node) => node.into(),
+            Self::TypeAlias(node) => node.into(),
             Self::NamedExpression(node) => node.into(),
             Self::Assignment(AssignmentDefinitionNodeRef {
-                assignment: _,
-                target_index: _,
+                value: _,
+                unpack: _,
                 name,
-                kind: _,
+                first: _,
             }) => name.into(),
             Self::AnnotatedAssignment(node) => node.into(),
             Self::AugmentedAssignment(node) => node.into(),
@@ -342,6 +397,9 @@ impl DefinitionNodeRef<'_> {
                 identifier.into()
             }
             Self::ExceptHandler(ExceptHandlerDefinitionNodeRef { handler, .. }) => handler.into(),
+            Self::TypeVar(node) => node.into(),
+            Self::ParamSpec(node) => node.into(),
+            Self::TypeVarTuple(node) => node.into(),
         }
     }
 }
@@ -382,13 +440,14 @@ impl DefinitionCategory {
 }
 
 #[derive(Clone, Debug)]
-pub enum DefinitionKind {
+pub enum DefinitionKind<'db> {
     Import(AstNodeRef<ast::Alias>),
     ImportFrom(ImportFromDefinitionKind),
     Function(AstNodeRef<ast::StmtFunctionDef>),
     Class(AstNodeRef<ast::StmtClassDef>),
+    TypeAlias(AstNodeRef<ast::StmtTypeAlias>),
     NamedExpression(AstNodeRef<ast::ExprNamed>),
-    Assignment(AssignmentDefinitionKind),
+    Assignment(AssignmentDefinitionKind<'db>),
     AnnotatedAssignment(AstNodeRef<ast::StmtAnnAssign>),
     AugmentedAssignment(AstNodeRef<ast::StmtAugAssign>),
     For(ForStmtDefinitionKind),
@@ -398,16 +457,23 @@ pub enum DefinitionKind {
     WithItem(WithItemDefinitionKind),
     MatchPattern(MatchPatternDefinitionKind),
     ExceptHandler(ExceptHandlerDefinitionKind),
+    TypeVar(AstNodeRef<ast::TypeParamTypeVar>),
+    ParamSpec(AstNodeRef<ast::TypeParamParamSpec>),
+    TypeVarTuple(AstNodeRef<ast::TypeParamTypeVarTuple>),
 }
 
-impl DefinitionKind {
+impl DefinitionKind<'_> {
     pub(crate) fn category(&self) -> DefinitionCategory {
         match self {
             // functions, classes, and imports always bind, and we consider them declarations
             DefinitionKind::Function(_)
             | DefinitionKind::Class(_)
+            | DefinitionKind::TypeAlias(_)
             | DefinitionKind::Import(_)
-            | DefinitionKind::ImportFrom(_) => DefinitionCategory::DeclarationAndBinding,
+            | DefinitionKind::ImportFrom(_)
+            | DefinitionKind::TypeVar(_)
+            | DefinitionKind::ParamSpec(_)
+            | DefinitionKind::TypeVarTuple(_) => DefinitionCategory::DeclarationAndBinding,
             // a parameter always binds a value, but is only a declaration if annotated
             DefinitionKind::Parameter(parameter) => {
                 if parameter.annotation.is_some() {
@@ -445,6 +511,21 @@ impl DefinitionKind {
     }
 }
 
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub(crate) enum TargetKind<'db> {
+    Sequence(Unpack<'db>),
+    Name,
+}
+
+impl<'db> From<Option<Unpack<'db>>> for TargetKind<'db> {
+    fn from(value: Option<Unpack<'db>>) -> Self {
+        match value {
+            Some(unpack) => TargetKind::Sequence(unpack),
+            None => TargetKind::Name,
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 #[allow(dead_code)]
 pub struct MatchPatternDefinitionKind {
@@ -506,38 +587,31 @@ impl ImportFromDefinitionKind {
 }
 
 #[derive(Clone, Debug)]
-pub struct AssignmentDefinitionKind {
-    assignment: AstNodeRef<ast::StmtAssign>,
-    target_index: usize,
+pub struct AssignmentDefinitionKind<'db> {
+    target: TargetKind<'db>,
+    value: AstNodeRef<ast::Expr>,
     name: AstNodeRef<ast::ExprName>,
-    kind: AssignmentKind,
+    first: bool,
 }
 
-impl AssignmentDefinitionKind {
-    pub(crate) fn value(&self) -> &ast::Expr {
-        &self.assignment.node().value
+impl<'db> AssignmentDefinitionKind<'db> {
+    pub(crate) fn target(&self) -> TargetKind<'db> {
+        self.target
     }
 
-    pub(crate) fn target(&self) -> &ast::Expr {
-        &self.assignment.node().targets[self.target_index]
+    pub(crate) fn value(&self) -> &ast::Expr {
+        self.value.node()
     }
 
     pub(crate) fn name(&self) -> &ast::ExprName {
         self.name.node()
     }
 
-    pub(crate) fn kind(&self) -> AssignmentKind {
-        self.kind
+    pub(crate) fn is_first(&self) -> bool {
+        self.first
     }
 }
 
-/// The kind of assignment target expression.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum AssignmentKind {
-    Sequence,
-    Name,
-}
-
 #[derive(Clone, Debug)]
 pub struct WithItemDefinitionKind {
     node: AstNodeRef<ast::WithItem>,
@@ -621,6 +695,12 @@ impl From<&ast::StmtClassDef> for DefinitionNodeKey {
     }
 }
 
+impl From<&ast::StmtTypeAlias> for DefinitionNodeKey {
+    fn from(node: &ast::StmtTypeAlias) -> Self {
+        Self(NodeKey::from_node(node))
+    }
+}
+
 impl From<&ast::ExprName> for DefinitionNodeKey {
     fn from(node: &ast::ExprName) -> Self {
         Self(NodeKey::from_node(node))
@@ -674,3 +754,21 @@ impl From<&ast::ExceptHandlerExceptHandler> for DefinitionNodeKey {
         Self(NodeKey::from_node(handler))
     }
 }
+
+impl From<&ast::TypeParamTypeVar> for DefinitionNodeKey {
+    fn from(value: &ast::TypeParamTypeVar) -> Self {
+        Self(NodeKey::from_node(value))
+    }
+}
+
+impl From<&ast::TypeParamParamSpec> for DefinitionNodeKey {
+    fn from(value: &ast::TypeParamParamSpec) -> Self {
+        Self(NodeKey::from_node(value))
+    }
+}
+
+impl From<&ast::TypeParamTypeVarTuple> for DefinitionNodeKey {
+    fn from(value: &ast::TypeParamTypeVarTuple) -> Self {
+        Self(NodeKey::from_node(value))
+    }
+}

crates/red_knot_python_semantic/src/semantic_index/expression.rs

@@ -8,6 +8,18 @@ use salsa;
 /// An independently type-inferable expression.
 ///
 /// Includes constraint expressions (e.g. if tests) and the RHS of an unpacking assignment.
+///
+/// ## Module-local type
+/// This type should not be used as part of any cross-module API because
+/// it holds a reference to the AST node. Range-offset changes
+/// then propagate through all usages, and deserialization requires
+/// reparsing the entire module.
+///
+/// E.g. don't use this type in:
+///
+/// * a return type of a cross-module query
+/// * a field of a type that is a return type of a cross-module query
+/// * an argument of a cross-module query
 #[salsa::tracked]
 pub(crate) struct Expression<'db> {
     /// The file in which the expression occurs.

crates/red_knot_python_semantic/src/semantic_index/symbol.rs

@@ -103,14 +103,10 @@ pub struct ScopedSymbolId;
 pub struct ScopeId<'db> {
     #[id]
     pub file: File,
+
     #[id]
     pub file_scope_id: FileScopeId,
 
-    /// The node that introduces this scope.
-    #[no_eq]
-    #[return_ref]
-    pub node: NodeWithScopeKind,
-
     #[no_eq]
     count: countme::Count<ScopeId<'static>>,
 }
@@ -120,17 +116,22 @@ impl<'db> ScopeId<'db> {
         // Type parameter scopes behave like function scopes in terms of name resolution; CPython
         // symbol table also uses the term "function-like" for these scopes.
         matches!(
-            self.node(db),
-            NodeWithScopeKind::ClassTypeParameters(_)
-                | NodeWithScopeKind::FunctionTypeParameters(_)
-                | NodeWithScopeKind::Function(_)
-                | NodeWithScopeKind::ListComprehension(_)
-                | NodeWithScopeKind::SetComprehension(_)
-                | NodeWithScopeKind::DictComprehension(_)
-                | NodeWithScopeKind::GeneratorExpression(_)
+            self.node(db).scope_kind(),
+            ScopeKind::Annotation
+                | ScopeKind::Function
+                | ScopeKind::TypeAlias
+                | ScopeKind::Comprehension
         )
     }
 
+    pub(crate) fn node(self, db: &dyn Db) -> &NodeWithScopeKind {
+        self.scope(db).node()
+    }
+
+    pub(crate) fn scope(self, db: &dyn Db) -> &Scope {
+        semantic_index(db, self.file(db)).scope(self.file_scope_id(db))
+    }
+
     #[cfg(test)]
     pub(crate) fn name(self, db: &'db dyn Db) -> &'db str {
         match self.node(db) {
@@ -140,6 +141,12 @@ impl<'db> ScopeId<'db> {
             }
             NodeWithScopeKind::Function(function)
             | NodeWithScopeKind::FunctionTypeParameters(function) => function.name.as_str(),
+            NodeWithScopeKind::TypeAlias(type_alias)
+            | NodeWithScopeKind::TypeAliasTypeParameters(type_alias) => type_alias
+                .name
+                .as_name_expr()
+                .map(|name| name.id.as_str())
+                .unwrap_or("<type alias>"),
             NodeWithScopeKind::Lambda(_) => "<lambda>",
             NodeWithScopeKind::ListComprehension(_) => "<listcomp>",
             NodeWithScopeKind::SetComprehension(_) => "<setcomp>",
@@ -169,10 +176,10 @@ impl FileScopeId {
     }
 }
 
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug)]
 pub struct Scope {
     pub(super) parent: Option<FileScopeId>,
-    pub(super) kind: ScopeKind,
+    pub(super) node: NodeWithScopeKind,
     pub(super) descendents: Range<FileScopeId>,
 }
 
@@ -181,8 +188,12 @@ impl Scope {
         self.parent
     }
 
+    pub fn node(&self) -> &NodeWithScopeKind {
+        &self.node
+    }
+
     pub fn kind(&self) -> ScopeKind {
-        self.kind
+        self.node().scope_kind()
     }
 }
 
@@ -193,6 +204,7 @@ pub enum ScopeKind {
     Class,
     Function,
     Comprehension,
+    TypeAlias,
 }
 
 impl ScopeKind {
@@ -202,7 +214,7 @@ impl ScopeKind {
 }
 
 /// Symbol table for a specific [`Scope`].
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct SymbolTable {
     /// The symbols in this scope.
     symbols: IndexVec<ScopedSymbolId, Symbol>,
@@ -212,13 +224,6 @@ pub struct SymbolTable {
 }
 
 impl SymbolTable {
-    fn new() -> Self {
-        Self {
-            symbols: IndexVec::new(),
-            symbols_by_name: SymbolMap::default(),
-        }
-    }
-
     fn shrink_to_fit(&mut self) {
         self.symbols.shrink_to_fit();
     }
@@ -270,18 +275,12 @@ impl PartialEq for SymbolTable {
 
 impl Eq for SymbolTable {}
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub(super) struct SymbolTableBuilder {
     table: SymbolTable,
 }
 
 impl SymbolTableBuilder {
-    pub(super) fn new() -> Self {
-        Self {
-            table: SymbolTable::new(),
-        }
-    }
-
     pub(super) fn add_symbol(&mut self, name: Name) -> (ScopedSymbolId, bool) {
         let hash = SymbolTable::hash_name(&name);
         let entry = self
@@ -331,6 +330,8 @@ pub(crate) enum NodeWithScopeRef<'a> {
     Lambda(&'a ast::ExprLambda),
     FunctionTypeParameters(&'a ast::StmtFunctionDef),
     ClassTypeParameters(&'a ast::StmtClassDef),
+    TypeAlias(&'a ast::StmtTypeAlias),
+    TypeAliasTypeParameters(&'a ast::StmtTypeAlias),
     ListComprehension(&'a ast::ExprListComp),
     SetComprehension(&'a ast::ExprSetComp),
     DictComprehension(&'a ast::ExprDictComp),
@@ -352,6 +353,12 @@ impl NodeWithScopeRef<'_> {
             NodeWithScopeRef::Function(function) => {
                 NodeWithScopeKind::Function(AstNodeRef::new(module, function))
             }
+            NodeWithScopeRef::TypeAlias(type_alias) => {
+                NodeWithScopeKind::TypeAlias(AstNodeRef::new(module, type_alias))
+            }
+            NodeWithScopeRef::TypeAliasTypeParameters(type_alias) => {
+                NodeWithScopeKind::TypeAliasTypeParameters(AstNodeRef::new(module, type_alias))
+            }
             NodeWithScopeRef::Lambda(lambda) => {
                 NodeWithScopeKind::Lambda(AstNodeRef::new(module, lambda))
             }
@@ -376,21 +383,6 @@ impl NodeWithScopeRef<'_> {
         }
     }
 
-    pub(super) fn scope_kind(self) -> ScopeKind {
-        match self {
-            NodeWithScopeRef::Module => ScopeKind::Module,
-            NodeWithScopeRef::Class(_) => ScopeKind::Class,
-            NodeWithScopeRef::Function(_) => ScopeKind::Function,
-            NodeWithScopeRef::Lambda(_) => ScopeKind::Function,
-            NodeWithScopeRef::FunctionTypeParameters(_)
-            | NodeWithScopeRef::ClassTypeParameters(_) => ScopeKind::Annotation,
-            NodeWithScopeRef::ListComprehension(_)
-            | NodeWithScopeRef::SetComprehension(_)
-            | NodeWithScopeRef::DictComprehension(_)
-            | NodeWithScopeRef::GeneratorExpression(_) => ScopeKind::Comprehension,
-        }
-    }
-
     pub(crate) fn node_key(self) -> NodeWithScopeKey {
         match self {
             NodeWithScopeRef::Module => NodeWithScopeKey::Module,
@@ -407,6 +399,12 @@ impl NodeWithScopeRef<'_> {
             NodeWithScopeRef::ClassTypeParameters(class) => {
                 NodeWithScopeKey::ClassTypeParameters(NodeKey::from_node(class))
             }
+            NodeWithScopeRef::TypeAlias(type_alias) => {
+                NodeWithScopeKey::TypeAlias(NodeKey::from_node(type_alias))
+            }
+            NodeWithScopeRef::TypeAliasTypeParameters(type_alias) => {
+                NodeWithScopeKey::TypeAliasTypeParameters(NodeKey::from_node(type_alias))
+            }
             NodeWithScopeRef::ListComprehension(comprehension) => {
                 NodeWithScopeKey::ListComprehension(NodeKey::from_node(comprehension))
             }
@@ -431,6 +429,8 @@ pub enum NodeWithScopeKind {
     ClassTypeParameters(AstNodeRef<ast::StmtClassDef>),
     Function(AstNodeRef<ast::StmtFunctionDef>),
     FunctionTypeParameters(AstNodeRef<ast::StmtFunctionDef>),
+    TypeAliasTypeParameters(AstNodeRef<ast::StmtTypeAlias>),
+    TypeAlias(AstNodeRef<ast::StmtTypeAlias>),
     Lambda(AstNodeRef<ast::ExprLambda>),
     ListComprehension(AstNodeRef<ast::ExprListComp>),
     SetComprehension(AstNodeRef<ast::ExprSetComp>),
@@ -438,6 +438,45 @@ pub enum NodeWithScopeKind {
     GeneratorExpression(AstNodeRef<ast::ExprGenerator>),
 }
 
+impl NodeWithScopeKind {
+    pub(super) const fn scope_kind(&self) -> ScopeKind {
+        match self {
+            Self::Module => ScopeKind::Module,
+            Self::Class(_) => ScopeKind::Class,
+            Self::Function(_) | Self::Lambda(_) => ScopeKind::Function,
+            Self::FunctionTypeParameters(_)
+            | Self::ClassTypeParameters(_)
+            | Self::TypeAliasTypeParameters(_) => ScopeKind::Annotation,
+            Self::TypeAlias(_) => ScopeKind::TypeAlias,
+            Self::ListComprehension(_)
+            | Self::SetComprehension(_)
+            | Self::DictComprehension(_)
+            | Self::GeneratorExpression(_) => ScopeKind::Comprehension,
+        }
+    }
+
+    pub fn expect_class(&self) -> &ast::StmtClassDef {
+        match self {
+            Self::Class(class) => class.node(),
+            _ => panic!("expected class"),
+        }
+    }
+
+    pub fn expect_function(&self) -> &ast::StmtFunctionDef {
+        match self {
+            Self::Function(function) => function.node(),
+            _ => panic!("expected function"),
+        }
+    }
+
+    pub fn expect_type_alias(&self) -> &ast::StmtTypeAlias {
+        match self {
+            Self::TypeAlias(type_alias) => type_alias.node(),
+            _ => panic!("expected type alias"),
+        }
+    }
+}
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
 pub(crate) enum NodeWithScopeKey {
     Module,
@@ -445,6 +484,8 @@ pub(crate) enum NodeWithScopeKey {
     ClassTypeParameters(NodeKey),
     Function(NodeKey),
     FunctionTypeParameters(NodeKey),
+    TypeAlias(NodeKey),
+    TypeAliasTypeParameters(NodeKey),
     Lambda(NodeKey),
     ListComprehension(NodeKey),
     SetComprehension(NodeKey),

crates/red_knot_python_semantic/src/semantic_index/use_def.rs

@@ -277,7 +277,7 @@ impl<'db> UseDefMap<'db> {
 
     pub(crate) fn use_boundness(&self, use_id: ScopedUseId) -> Boundness {
         if self.bindings_by_use[use_id].may_be_unbound() {
-            Boundness::MayBeUnbound
+            Boundness::PossiblyUnbound
         } else {
             Boundness::Bound
         }
@@ -292,7 +292,7 @@ impl<'db> UseDefMap<'db> {
 
     pub(crate) fn public_boundness(&self, symbol: ScopedSymbolId) -> Boundness {
         if self.public_symbols[symbol].may_be_unbound() {
-            Boundness::MayBeUnbound
+            Boundness::PossiblyUnbound
         } else {
             Boundness::Bound
         }
@@ -459,10 +459,6 @@ pub(super) struct UseDefMapBuilder<'db> {
 }
 
 impl<'db> UseDefMapBuilder<'db> {
-    pub(super) fn new() -> Self {
-        Self::default()
-    }
-
     pub(super) fn add_symbol(&mut self, symbol: ScopedSymbolId) {
         let new_symbol = self.symbol_states.push(SymbolState::undefined());
         debug_assert_eq!(symbol, new_symbol);

crates/red_knot_python_semantic/src/semantic_model.rs

@@ -6,7 +6,7 @@ use ruff_source_file::LineIndex;
 
 use crate::module_name::ModuleName;
 use crate::module_resolver::{resolve_module, Module};
-use crate::semantic_index::ast_ids::HasScopedAstId;
+use crate::semantic_index::ast_ids::HasScopedExpressionId;
 use crate::semantic_index::semantic_index;
 use crate::types::{binding_ty, infer_scope_types, Type};
 use crate::Db;
@@ -54,7 +54,7 @@ impl HasTy for ast::ExpressionRef<'_> {
         let file_scope = index.expression_scope_id(*self);
         let scope = file_scope.to_scope_id(model.db, model.file);
 
-        let expression_id = self.scoped_ast_id(model.db, scope);
+        let expression_id = self.scoped_expression_id(model.db, scope);
         infer_scope_types(model.db, scope).expression_ty(expression_id)
     }
 }

crates/red_knot_python_semantic/src/site_packages.rs

@@ -732,7 +732,20 @@ mod tests {
         let system = TestSystem::default();
         assert!(matches!(
             VirtualEnvironment::new("/.venv", &system),
-            Err(SitePackagesDiscoveryError::VenvDirIsNotADirectory(_))
+            Err(SitePackagesDiscoveryError::VenvDirCanonicalizationError(..))
+        ));
+    }
+
+    #[test]
+    fn reject_venv_that_is_not_a_directory() {
+        let system = TestSystem::default();
+        system
+            .memory_file_system()
+            .write_file("/.venv", "")
+            .unwrap();
+        assert!(matches!(
+            VirtualEnvironment::new("/.venv", &system),
+            Err(SitePackagesDiscoveryError::VenvDirIsNotADirectory(..))
         ));
     }
 

crates/red_knot_python_semantic/src/stdlib.rs

@@ -8,34 +8,38 @@ use crate::Db;
 
 /// Enumeration of various core stdlib modules, for which we have dedicated Salsa queries.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum CoreStdlibModule {
+pub(crate) enum CoreStdlibModule {
     Builtins,
     Types,
-    // the Typing enum is currently only used in tests
-    #[allow(dead_code)]
-    Typing,
     Typeshed,
     TypingExtensions,
+    Typing,
+    Sys,
 }
 
 impl CoreStdlibModule {
-    fn name(self) -> ModuleName {
-        let module_name = match self {
+    pub(crate) const fn as_str(self) -> &'static str {
+        match self {
             Self::Builtins => "builtins",
             Self::Types => "types",
             Self::Typing => "typing",
             Self::Typeshed => "_typeshed",
             Self::TypingExtensions => "typing_extensions",
-        };
-        ModuleName::new_static(module_name)
-            .unwrap_or_else(|| panic!("{module_name} should be a valid module name!"))
+            Self::Sys => "sys",
+        }
+    }
+
+    pub(crate) fn name(self) -> ModuleName {
+        let self_as_str = self.as_str();
+        ModuleName::new_static(self_as_str)
+            .unwrap_or_else(|| panic!("{self_as_str} should be a valid module name!"))
     }
 }
 
 /// Lookup the type of `symbol` in a given core module
 ///
 /// Returns `Symbol::Unbound` if the given core module cannot be resolved for some reason
-fn core_module_symbol<'db>(
+pub(crate) fn core_module_symbol<'db>(
     db: &'db dyn Db,
     core_module: CoreStdlibModule,
     symbol: &str,
@@ -53,29 +57,14 @@ pub(crate) fn builtins_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db>
     core_module_symbol(db, CoreStdlibModule::Builtins, symbol)
 }
 
-/// Lookup the type of `symbol` in the `types` module namespace.
-///
-/// Returns `Symbol::Unbound` if the `types` module isn't available for some reason.
-#[inline]
-pub(crate) fn types_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
-    core_module_symbol(db, CoreStdlibModule::Types, symbol)
-}
-
 /// Lookup the type of `symbol` in the `typing` module namespace.
 ///
 /// Returns `Symbol::Unbound` if the `typing` module isn't available for some reason.
 #[inline]
-#[allow(dead_code)] // currently only used in tests
+#[cfg(test)]
 pub(crate) fn typing_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
     core_module_symbol(db, CoreStdlibModule::Typing, symbol)
 }
-/// Lookup the type of `symbol` in the `_typeshed` module namespace.
-///
-/// Returns `Symbol::Unbound` if the `_typeshed` module isn't available for some reason.
-#[inline]
-pub(crate) fn typeshed_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
-    core_module_symbol(db, CoreStdlibModule::Typeshed, symbol)
-}
 
 /// Lookup the type of `symbol` in the `typing_extensions` module namespace.
 ///

crates/red_knot_python_semantic/src/symbol.rs

@@ -3,10 +3,19 @@ use crate::{
     Db,
 };
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum Boundness {
     Bound,
-    MayBeUnbound,
+    PossiblyUnbound,
+}
+
+impl Boundness {
+    pub(crate) fn or(self, other: Boundness) -> Boundness {
+        match (self, other) {
+            (Boundness::Bound, _) | (_, Boundness::Bound) => Boundness::Bound,
+            (Boundness::PossiblyUnbound, Boundness::PossiblyUnbound) => Boundness::PossiblyUnbound,
+        }
+    }
 }
 
 /// The result of a symbol lookup, which can either be a (possibly unbound) type
@@ -17,14 +26,14 @@ pub(crate) enum Boundness {
 /// bound = 1
 ///
 /// if flag:
-///     maybe_unbound = 2
+///     possibly_unbound = 2
 /// ```
 ///
 /// If we look up symbols in this scope, we would get the following results:
 /// ```rs
-/// bound:          Symbol::Type(Type::IntLiteral(1), Boundness::Bound),
-/// maybe_unbound:  Symbol::Type(Type::IntLiteral(2), Boundness::MayBeUnbound),
-/// non_existent:   Symbol::Unbound,
+/// bound:             Symbol::Type(Type::IntLiteral(1), Boundness::Bound),
+/// possibly_unbound:  Symbol::Type(Type::IntLiteral(2), Boundness::PossiblyUnbound),
+/// non_existent:      Symbol::Unbound,
 /// ```
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) enum Symbol<'db> {
@@ -37,25 +46,18 @@ impl<'db> Symbol<'db> {
         matches!(self, Symbol::Unbound)
     }
 
-    pub(crate) fn may_be_unbound(&self) -> bool {
+    pub(crate) fn possibly_unbound(&self) -> bool {
         match self {
-            Symbol::Type(_, Boundness::MayBeUnbound) | Symbol::Unbound => true,
+            Symbol::Type(_, Boundness::PossiblyUnbound) | Symbol::Unbound => true,
             Symbol::Type(_, Boundness::Bound) => false,
         }
     }
 
-    pub(crate) fn unwrap_or(&self, other: Type<'db>) -> Type<'db> {
-        match self {
-            Symbol::Type(ty, _) => *ty,
-            Symbol::Unbound => other,
-        }
-    }
-
-    pub(crate) fn unwrap_or_unknown(&self) -> Type<'db> {
-        self.unwrap_or(Type::Unknown)
-    }
-
-    pub(crate) fn as_type(&self) -> Option<Type<'db>> {
+    /// Returns the type of the symbol, ignoring possible unboundness.
+    ///
+    /// If the symbol is *definitely* unbound, this function will return `None`. Otherwise,
+    /// if there is at least one control-flow path where the symbol is bound, return the type.
+    pub(crate) fn ignore_possibly_unbound(&self) -> Option<Type<'db>> {
         match self {
             Symbol::Type(ty, _) => Some(*ty),
             Symbol::Unbound => None,
@@ -65,28 +67,80 @@ impl<'db> Symbol<'db> {
     #[cfg(test)]
     #[track_caller]
     pub(crate) fn expect_type(self) -> Type<'db> {
-        self.as_type()
+        self.ignore_possibly_unbound()
             .expect("Expected a (possibly unbound) type, not an unbound symbol")
     }
 
     #[must_use]
-    pub(crate) fn replace_unbound_with(
-        self,
-        db: &'db dyn Db,
-        replacement: &Symbol<'db>,
-    ) -> Symbol<'db> {
-        match replacement {
-            Symbol::Type(replacement, _) => Symbol::Type(
-                match self {
-                    Symbol::Type(ty, Boundness::Bound) => ty,
-                    Symbol::Type(ty, Boundness::MayBeUnbound) => {
-                        UnionType::from_elements(db, [*replacement, ty])
-                    }
-                    Symbol::Unbound => *replacement,
-                },
-                Boundness::Bound,
-            ),
+    pub(crate) fn or_fall_back_to(self, db: &'db dyn Db, fallback: &Symbol<'db>) -> Symbol<'db> {
+        match fallback {
+            Symbol::Type(fallback_ty, fallback_boundness) => match self {
+                Symbol::Type(_, Boundness::Bound) => self,
+                Symbol::Type(ty, boundness @ Boundness::PossiblyUnbound) => Symbol::Type(
+                    UnionType::from_elements(db, [*fallback_ty, ty]),
+                    fallback_boundness.or(boundness),
+                ),
+                Symbol::Unbound => fallback.clone(),
+            },
             Symbol::Unbound => self,
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::tests::setup_db;
+
+    #[test]
+    fn test_symbol_or_fall_back_to() {
+        use Boundness::{Bound, PossiblyUnbound};
+
+        let db = setup_db();
+        let ty1 = Type::IntLiteral(1);
+        let ty2 = Type::IntLiteral(2);
+
+        // Start from an unbound symbol
+        assert_eq!(
+            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Unbound
+        );
+        assert_eq!(
+            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Type(ty1, PossiblyUnbound)),
+            Symbol::Type(ty1, PossiblyUnbound)
+        );
+        assert_eq!(
+            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Type(ty1, Bound)),
+            Symbol::Type(ty1, Bound)
+        );
+
+        // Start from a possibly unbound symbol
+        assert_eq!(
+            Symbol::Type(ty1, PossiblyUnbound).or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Type(ty1, PossiblyUnbound)
+        );
+        assert_eq!(
+            Symbol::Type(ty1, PossiblyUnbound)
+                .or_fall_back_to(&db, &Symbol::Type(ty2, PossiblyUnbound)),
+            Symbol::Type(UnionType::from_elements(&db, [ty2, ty1]), PossiblyUnbound)
+        );
+        assert_eq!(
+            Symbol::Type(ty1, PossiblyUnbound).or_fall_back_to(&db, &Symbol::Type(ty2, Bound)),
+            Symbol::Type(UnionType::from_elements(&db, [ty2, ty1]), Bound)
+        );
+
+        // Start from a definitely bound symbol
+        assert_eq!(
+            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Type(ty1, Bound)
+        );
+        assert_eq!(
+            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Type(ty2, PossiblyUnbound)),
+            Symbol::Type(ty1, Bound)
+        );
+        assert_eq!(
+            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Type(ty2, Bound)),
+            Symbol::Type(ty1, Bound)
+        );
+    }
+}

crates/red_knot_python_semantic/src/types/builder.rs

@@ -25,12 +25,11 @@
 //!   * No type in an intersection can be a supertype of any other type in the intersection (just
 //!     eliminate the supertype from the intersection).
 //!   * An intersection containing two non-overlapping types should simplify to [`Type::Never`].
-use crate::types::{IntersectionType, Type, UnionType};
+
+use crate::types::{InstanceType, IntersectionType, KnownClass, Type, UnionType};
 use crate::{Db, FxOrderSet};
 use smallvec::SmallVec;
 
-use super::KnownClass;
-
 pub(crate) struct UnionBuilder<'db> {
     elements: Vec<Type<'db>>,
     db: &'db dyn Db,
@@ -80,7 +79,6 @@ impl<'db> UnionBuilder<'db> {
                         to_remove.push(index);
                     }
                 }
-
                 match to_remove[..] {
                     [] => self.elements.push(to_add),
                     [index] => self.elements[index] = to_add,
@@ -103,7 +101,6 @@ impl<'db> UnionBuilder<'db> {
                 }
             }
         }
-
         self
     }
 
@@ -131,7 +128,7 @@ impl<'db> IntersectionBuilder<'db> {
     pub(crate) fn new(db: &'db dyn Db) -> Self {
         Self {
             db,
-            intersections: vec![InnerIntersectionBuilder::new()],
+            intersections: vec![InnerIntersectionBuilder::default()],
         }
     }
 
@@ -234,10 +231,6 @@ struct InnerIntersectionBuilder<'db> {
 }
 
 impl<'db> InnerIntersectionBuilder<'db> {
-    fn new() -> Self {
-        Self::default()
-    }
-
     /// Adds a positive type to this intersection.
     fn add_positive(&mut self, db: &'db dyn Db, new_positive: Type<'db>) {
         if let Type::Intersection(other) = new_positive {
@@ -249,14 +242,14 @@ impl<'db> InnerIntersectionBuilder<'db> {
             }
         } else {
             // ~Literal[True] & bool = Literal[False]
-            if let Type::Instance(class_type) = new_positive {
-                if class_type.is_known(db, KnownClass::Bool) {
+            if let Type::Instance(InstanceType { class }) = new_positive {
+                if class.is_known(db, KnownClass::Bool) {
                     if let Some(&Type::BooleanLiteral(value)) = self
                         .negative
                         .iter()
                         .find(|element| element.is_boolean_literal())
                     {
-                        *self = Self::new();
+                        *self = Self::default();
                         self.positive.insert(Type::BooleanLiteral(!value));
                         return;
                     }
@@ -275,7 +268,7 @@ impl<'db> InnerIntersectionBuilder<'db> {
                 }
                 // A & B = Never    if A and B are disjoint
                 if new_positive.is_disjoint_from(db, *existing_positive) {
-                    *self = Self::new();
+                    *self = Self::default();
                     self.positive.insert(Type::Never);
                     return;
                 }
@@ -288,7 +281,7 @@ impl<'db> InnerIntersectionBuilder<'db> {
             for (index, existing_negative) in self.negative.iter().enumerate() {
                 // S & ~T = Never    if S <: T
                 if new_positive.is_subtype_of(db, *existing_negative) {
-                    *self = Self::new();
+                    *self = Self::default();
                     self.positive.insert(Type::Never);
                     return;
                 }
@@ -316,11 +309,11 @@ impl<'db> InnerIntersectionBuilder<'db> {
                     self.add_positive(db, *neg);
                 }
             }
-            ty @ (Type::Any | Type::Unknown | Type::Todo) => {
+            ty @ (Type::Any | Type::Unknown | Type::Todo(_)) => {
                 // Adding any of these types to the negative side of an intersection
                 // is equivalent to adding it to the positive side. We do this to
                 // simplify the representation.
-                self.positive.insert(ty);
+                self.add_positive(db, ty);
             }
             // ~Literal[True] & bool = Literal[False]
             Type::BooleanLiteral(bool)
@@ -329,7 +322,7 @@ impl<'db> InnerIntersectionBuilder<'db> {
                     .iter()
                     .any(|pos| *pos == KnownClass::Bool.to_instance(db)) =>
             {
-                *self = Self::new();
+                *self = Self::default();
                 self.positive.insert(Type::BooleanLiteral(!bool));
             }
             _ => {
@@ -351,7 +344,7 @@ impl<'db> InnerIntersectionBuilder<'db> {
                 for existing_positive in &self.positive {
                     // S & ~T = Never    if S <: T
                     if existing_positive.is_subtype_of(db, new_negative) {
-                        *self = Self::new();
+                        *self = Self::default();
                         self.positive.insert(Type::Never);
                         return;
                     }
@@ -386,8 +379,9 @@ mod tests {
     use crate::program::{Program, SearchPathSettings};
     use crate::python_version::PythonVersion;
     use crate::stdlib::typing_symbol;
-    use crate::types::{KnownClass, StringLiteralType, UnionBuilder};
+    use crate::types::{global_symbol, todo_type, KnownClass, UnionBuilder};
     use crate::ProgramSettings;
+    use ruff_db::files::system_path_to_file;
     use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
     use test_case::test_case;
 
@@ -594,6 +588,22 @@ mod tests {
         assert_eq!(ta_not_i0.display(&db).to_string(), "int & Any | Literal[1]");
     }
 
+    #[test]
+    fn build_intersection_simplify_negative_any() {
+        let db = setup_db();
+
+        let ty = IntersectionBuilder::new(&db)
+            .add_negative(Type::Any)
+            .build();
+        assert_eq!(ty, Type::Any);
+
+        let ty = IntersectionBuilder::new(&db)
+            .add_positive(Type::Never)
+            .add_negative(Type::Any)
+            .build();
+        assert_eq!(ty, Type::Never);
+    }
+
     #[test]
     fn intersection_distributes_over_union() {
         let db = setup_db();
@@ -675,8 +685,8 @@ mod tests {
     fn build_intersection_self_negation() {
         let db = setup_db();
         let ty = IntersectionBuilder::new(&db)
-            .add_positive(Type::None)
-            .add_negative(Type::None)
+            .add_positive(Type::none(&db))
+            .add_negative(Type::none(&db))
             .build();
 
         assert_eq!(ty, Type::Never);
@@ -686,18 +696,18 @@ mod tests {
     fn build_intersection_simplify_negative_never() {
         let db = setup_db();
         let ty = IntersectionBuilder::new(&db)
-            .add_positive(Type::None)
+            .add_positive(Type::none(&db))
             .add_negative(Type::Never)
             .build();
 
-        assert_eq!(ty, Type::None);
+        assert_eq!(ty, Type::none(&db));
     }
 
     #[test]
     fn build_intersection_simplify_positive_never() {
         let db = setup_db();
         let ty = IntersectionBuilder::new(&db)
-            .add_positive(Type::None)
+            .add_positive(Type::none(&db))
             .add_positive(Type::Never)
             .build();
 
@@ -709,14 +719,14 @@ mod tests {
         let db = setup_db();
 
         let ty = IntersectionBuilder::new(&db)
-            .add_negative(Type::None)
+            .add_negative(Type::none(&db))
             .add_positive(Type::IntLiteral(1))
             .build();
         assert_eq!(ty, Type::IntLiteral(1));
 
         let ty = IntersectionBuilder::new(&db)
             .add_positive(Type::IntLiteral(1))
-            .add_negative(Type::None)
+            .add_negative(Type::none(&db))
             .build();
         assert_eq!(ty, Type::IntLiteral(1));
     }
@@ -761,7 +771,7 @@ mod tests {
             .build();
         assert_eq!(ty, s);
 
-        let literal = Type::StringLiteral(StringLiteralType::new(&db, "a"));
+        let literal = Type::string_literal(&db, "a");
         let expected = IntersectionBuilder::new(&db)
             .add_positive(s)
             .add_negative(literal)
@@ -864,7 +874,7 @@ mod tests {
 
         let ty = IntersectionBuilder::new(&db)
             .add_positive(s)
-            .add_negative(Type::StringLiteral(StringLiteralType::new(&db, "a")))
+            .add_negative(Type::string_literal(&db, "a"))
             .add_negative(t)
             .build();
         assert_eq!(ty, Type::Never);
@@ -875,7 +885,7 @@ mod tests {
         let db = setup_db();
 
         let t1 = Type::IntLiteral(1);
-        let t2 = Type::None;
+        let t2 = Type::none(&db);
 
         let ty = IntersectionBuilder::new(&db)
             .add_positive(t1)
@@ -898,7 +908,7 @@ mod tests {
         let db = setup_db();
 
         let t_p = KnownClass::Int.to_instance(&db);
-        let t_n = Type::StringLiteral(StringLiteralType::new(&db, "t_n"));
+        let t_n = Type::string_literal(&db, "t_n");
 
         let ty = IntersectionBuilder::new(&db)
             .add_positive(t_p)
@@ -977,7 +987,7 @@ mod tests {
 
     #[test_case(Type::Any)]
     #[test_case(Type::Unknown)]
-    #[test_case(Type::Todo)]
+    #[test_case(todo_type!())]
     fn build_intersection_t_and_negative_t_does_not_simplify(ty: Type) {
         let db = setup_db();
 
@@ -993,4 +1003,66 @@ mod tests {
             .build();
         assert_eq!(result, ty);
     }
+
+    #[test]
+    fn build_intersection_of_two_unions_simplify() {
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/module.py",
+            "
+            class A: ...
+            class B: ...
+            a = A()
+            b = B()
+        ",
+        )
+        .unwrap();
+
+        let file = system_path_to_file(&db, "src/module.py").expect("file to exist");
+
+        let a = global_symbol(&db, file, "a").expect_type();
+        let b = global_symbol(&db, file, "b").expect_type();
+        let union = UnionBuilder::new(&db).add(a).add(b).build();
+        assert_eq!(union.display(&db).to_string(), "A | B");
+        let reversed_union = UnionBuilder::new(&db).add(b).add(a).build();
+        assert_eq!(reversed_union.display(&db).to_string(), "B | A");
+        let intersection = IntersectionBuilder::new(&db)
+            .add_positive(union)
+            .add_positive(reversed_union)
+            .build();
+        assert_eq!(intersection.display(&db).to_string(), "B | A");
+    }
+
+    #[test]
+    fn build_union_of_two_intersections_simplify() {
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/module.py",
+            "
+            class A: ...
+            class B: ...
+            a = A()
+            b = B()
+        ",
+        )
+        .unwrap();
+
+        let file = system_path_to_file(&db, "src/module.py").expect("file to exist");
+
+        let a = global_symbol(&db, file, "a").expect_type();
+        let b = global_symbol(&db, file, "b").expect_type();
+        let intersection = IntersectionBuilder::new(&db)
+            .add_positive(a)
+            .add_positive(b)
+            .build();
+        let reversed_intersection = IntersectionBuilder::new(&db)
+            .add_positive(b)
+            .add_positive(a)
+            .build();
+        let union = UnionBuilder::new(&db)
+            .add(intersection)
+            .add(reversed_intersection)
+            .build();
+        assert_eq!(union.display(&db).to_string(), "A & B");
+    }
 }

crates/red_knot_python_semantic/src/types/diagnostic.rs

@@ -1,14 +1,15 @@
+use crate::types::{ClassLiteralType, Type};
+use crate::Db;
+use ruff_db::diagnostic::{Diagnostic, Severity};
 use ruff_db::files::File;
 use ruff_python_ast::{self as ast, AnyNodeRef};
 use ruff_text_size::{Ranged, TextRange};
+use std::borrow::Cow;
 use std::fmt::Formatter;
 use std::ops::Deref;
 use std::sync::Arc;
 
-use crate::types::Type;
-use crate::Db;
-
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug, Eq, PartialEq, Clone)]
 pub struct TypeCheckDiagnostic {
     // TODO: Don't use string keys for rules
     pub(super) rule: String,
@@ -31,6 +32,28 @@ impl TypeCheckDiagnostic {
     }
 }
 
+impl Diagnostic for TypeCheckDiagnostic {
+    fn rule(&self) -> &str {
+        TypeCheckDiagnostic::rule(self)
+    }
+
+    fn message(&self) -> Cow<str> {
+        TypeCheckDiagnostic::message(self).into()
+    }
+
+    fn file(&self) -> File {
+        TypeCheckDiagnostic::file(self)
+    }
+
+    fn range(&self) -> Option<TextRange> {
+        Some(Ranged::range(self))
+    }
+
+    fn severity(&self) -> Severity {
+        Severity::Error
+    }
+}
+
 impl Ranged for TypeCheckDiagnostic {
     fn range(&self) -> TextRange {
         self.range
@@ -50,10 +73,6 @@ pub struct TypeCheckDiagnostics {
 }
 
 impl TypeCheckDiagnostics {
-    pub fn new() -> Self {
-        Self { inner: Vec::new() }
-    }
-
     pub(super) fn push(&mut self, diagnostic: TypeCheckDiagnostic) {
         self.inner.push(Arc::new(diagnostic));
     }
@@ -125,7 +144,7 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
         Self {
             db,
             file,
-            diagnostics: TypeCheckDiagnostics::new(),
+            diagnostics: TypeCheckDiagnostics::default(),
         }
     }
 
@@ -141,6 +160,23 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
         );
     }
 
+    /// Emit a diagnostic declaring that the object represented by `node` is not iterable
+    /// because its `__iter__` method is possibly unbound.
+    pub(super) fn add_not_iterable_possibly_unbound(
+        &mut self,
+        node: AnyNodeRef,
+        element_ty: Type<'db>,
+    ) {
+        self.add(
+            node,
+            "not-iterable",
+            format_args!(
+                "Object of type `{}` is not iterable because its `__iter__` method is possibly unbound",
+                element_ty.display(self.db)
+            ),
+        );
+    }
+
     /// Emit a diagnostic declaring that an index is out of bounds for a tuple.
     pub(super) fn add_index_out_of_bounds(
         &mut self,
@@ -209,7 +245,7 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
         assigned_ty: Type<'db>,
     ) {
         match declared_ty {
-            Type::ClassLiteral(class) => {
+            Type::ClassLiteral(ClassLiteralType { class }) => {
                 self.add(node, "invalid-assignment", format_args!(
                         "Implicit shadowing of class `{}`; annotate to make it explicit if this is intentional",
                         class.name(self.db)));

crates/red_knot_python_semantic/src/types/display.rs

@@ -1,12 +1,15 @@
 //! Display implementations for types.
 
-use std::fmt::{self, Display, Formatter};
+use std::fmt::{self, Display, Formatter, Write};
 
 use ruff_db::display::FormatterJoinExtension;
 use ruff_python_ast::str::Quote;
 use ruff_python_literal::escape::AsciiEscape;
 
-use crate::types::{IntersectionType, Type, UnionType};
+use crate::types::{
+    ClassLiteralType, InstanceType, IntersectionType, KnownClass, StringLiteralType,
+    SubclassOfType, Type, UnionType,
+};
 use crate::Db;
 use rustc_hash::FxHashMap;
 
@@ -64,24 +67,32 @@ impl Display for DisplayRepresentation<'_> {
             Type::Any => f.write_str("Any"),
             Type::Never => f.write_str("Never"),
             Type::Unknown => f.write_str("Unknown"),
-            Type::None => f.write_str("None"),
+            Type::Instance(InstanceType { class }) => {
+                let representation = match class.known(self.db) {
+                    Some(KnownClass::NoneType) => "None",
+                    Some(KnownClass::NoDefaultType) => "NoDefault",
+                    _ => class.name(self.db),
+                };
+                f.write_str(representation)
+            }
             // `[Type::Todo]`'s display should be explicit that is not a valid display of
             // any other type
-            Type::Todo => f.write_str("@Todo"),
+            Type::Todo(todo) => write!(f, "@Todo{todo}"),
             Type::ModuleLiteral(file) => {
                 write!(f, "<module '{:?}'>", file.path(self.db))
             }
             // TODO functions and classes should display using a fully qualified name
-            Type::ClassLiteral(class) => f.write_str(class.name(self.db)),
-            Type::Instance(class) => f.write_str(class.name(self.db)),
+            Type::ClassLiteral(ClassLiteralType { class }) => f.write_str(class.name(self.db)),
+            Type::SubclassOf(SubclassOfType { class }) => {
+                write!(f, "type[{}]", class.name(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),
             Type::Intersection(intersection) => intersection.display(self.db).fmt(f),
             Type::IntLiteral(n) => n.fmt(f),
             Type::BooleanLiteral(boolean) => f.write_str(if boolean { "True" } else { "False" }),
-            Type::StringLiteral(string) => {
-                write!(f, r#""{}""#, string.value(self.db).replace('"', r#"\""#))
-            }
+            Type::StringLiteral(string) => string.display(self.db).fmt(f),
             Type::LiteralString => f.write_str("LiteralString"),
             Type::BytesLiteral(bytes) => {
                 let escape =
@@ -316,15 +327,40 @@ impl<'db> Display for DisplayTypeArray<'_, 'db> {
     }
 }
 
+impl<'db> StringLiteralType<'db> {
+    fn display(&'db self, db: &'db dyn Db) -> DisplayStringLiteralType<'db> {
+        DisplayStringLiteralType { db, ty: self }
+    }
+}
+
+struct DisplayStringLiteralType<'db> {
+    ty: &'db StringLiteralType<'db>,
+    db: &'db dyn Db,
+}
+
+impl Display for DisplayStringLiteralType<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let value = self.ty.value(self.db);
+        f.write_char('"')?;
+        for ch in value.chars() {
+            match ch {
+                // `escape_debug` will escape even single quotes, which is not necessary for our
+                // use case as we are already using double quotes to wrap the string.
+                '\'' => f.write_char('\'')?,
+                _ => write!(f, "{}", ch.escape_debug())?,
+            }
+        }
+        f.write_char('"')
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use ruff_db::files::system_path_to_file;
     use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
 
     use crate::db::tests::TestDb;
-    use crate::types::{
-        global_symbol, BytesLiteralType, SliceLiteralType, StringLiteralType, Type, UnionType,
-    };
+    use crate::types::{global_symbol, SliceLiteralType, StringLiteralType, Type, UnionType};
     use crate::{Program, ProgramSettings, PythonVersion, SearchPathSettings};
 
     fn setup_db() -> TestDb {
@@ -370,17 +406,17 @@ mod tests {
             Type::Unknown,
             Type::IntLiteral(-1),
             global_symbol(&db, mod_file, "A").expect_type(),
-            Type::StringLiteral(StringLiteralType::new(&db, "A")),
-            Type::BytesLiteral(BytesLiteralType::new(&db, [0u8].as_slice())),
-            Type::BytesLiteral(BytesLiteralType::new(&db, [7u8].as_slice())),
+            Type::string_literal(&db, "A"),
+            Type::bytes_literal(&db, &[0u8]),
+            Type::bytes_literal(&db, &[7u8]),
             Type::IntLiteral(0),
             Type::IntLiteral(1),
-            Type::StringLiteral(StringLiteralType::new(&db, "B")),
+            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,
+            Type::none(&db),
         ];
         let union = UnionType::from_elements(&db, union_elements).expect_union();
         let display = format!("{}", union.display(&db));
@@ -441,4 +477,28 @@ mod tests {
             "slice[None, None, Literal[2]]"
         );
     }
+
+    #[test]
+    fn string_literal_display() {
+        let db = setup_db();
+
+        assert_eq!(
+            Type::StringLiteral(StringLiteralType::new(&db, r"\n"))
+                .display(&db)
+                .to_string(),
+            r#"Literal["\\n"]"#
+        );
+        assert_eq!(
+            Type::StringLiteral(StringLiteralType::new(&db, "'"))
+                .display(&db)
+                .to_string(),
+            r#"Literal["'"]"#
+        );
+        assert_eq!(
+            Type::StringLiteral(StringLiteralType::new(&db, r#"""#))
+                .display(&db)
+                .to_string(),
+            r#"Literal["\""]"#
+        );
+    }
 }

crates/red_knot_python_semantic/src/types/mro.rs

@@ -0,0 +1,459 @@
+use std::collections::VecDeque;
+use std::ops::Deref;
+
+use itertools::Either;
+use rustc_hash::FxHashSet;
+
+use super::{Class, ClassLiteralType, KnownClass, KnownInstanceType, Type};
+use crate::{types::todo_type, Db};
+
+/// The inferred method resolution order of a given class.
+///
+/// See [`Class::iter_mro`] for more details.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub(super) struct Mro<'db>(Box<[ClassBase<'db>]>);
+
+impl<'db> Mro<'db> {
+    /// Attempt to resolve the MRO of a given class
+    ///
+    /// In the event that a possible list of bases would (or could) lead to a
+    /// `TypeError` being raised at runtime due to an unresolvable MRO, we infer
+    /// the MRO of the class as being `[<the class in question>, Unknown, object]`.
+    /// This seems most likely to reduce the possibility of cascading errors
+    /// elsewhere.
+    ///
+    /// (We emit a diagnostic warning about the runtime `TypeError` in
+    /// [`super::infer::TypeInferenceBuilder::infer_region_scope`].)
+    pub(super) fn of_class(db: &'db dyn Db, class: Class<'db>) -> Result<Self, MroError<'db>> {
+        Self::of_class_impl(db, class).map_err(|error_kind| MroError {
+            kind: error_kind,
+            fallback_mro: Self::from_error(db, class),
+        })
+    }
+
+    pub(super) fn from_error(db: &'db dyn Db, class: Class<'db>) -> Self {
+        Self::from([
+            ClassBase::Class(class),
+            ClassBase::Unknown,
+            ClassBase::object(db),
+        ])
+    }
+
+    fn of_class_impl(db: &'db dyn Db, class: Class<'db>) -> Result<Self, MroErrorKind<'db>> {
+        let class_bases = class.explicit_bases(db);
+
+        if !class_bases.is_empty() && class.is_cyclically_defined(db) {
+            // We emit errors for cyclically defined classes elsewhere.
+            // It's important that we don't even try to infer the MRO for a cyclically defined class,
+            // or we'll end up in an infinite loop.
+            return Ok(Mro::from_error(db, class));
+        }
+
+        match class_bases {
+            // `builtins.object` is the special case:
+            // the only class in Python that has an MRO with length <2
+            [] if class.is_known(db, KnownClass::Object) => {
+                Ok(Self::from([ClassBase::Class(class)]))
+            }
+
+            // All other classes in Python have an MRO with length >=2.
+            // Even if a class has no explicit base classes,
+            // it will implicitly inherit from `object` at runtime;
+            // `object` will appear in the class's `__bases__` list and `__mro__`:
+            //
+            // ```pycon
+            // >>> class Foo: ...
+            // ...
+            // >>> Foo.__bases__
+            // (<class 'object'>,)
+            // >>> Foo.__mro__
+            // (<class '__main__.Foo'>, <class 'object'>)
+            // ```
+            [] => Ok(Self::from([ClassBase::Class(class), ClassBase::object(db)])),
+
+            // Fast path for a class that has only a single explicit base.
+            //
+            // This *could* theoretically be handled by the final branch below,
+            // but it's a common case (i.e., worth optimizing for),
+            // and the `c3_merge` function requires lots of allocations.
+            [single_base] => {
+                let single_base = ClassBase::try_from_ty(*single_base).ok_or(*single_base);
+                single_base.map_or_else(
+                    |invalid_base_ty| {
+                        let bases_info = Box::from([(0, invalid_base_ty)]);
+                        Err(MroErrorKind::InvalidBases(bases_info))
+                    },
+                    |single_base| {
+                        let mro = std::iter::once(ClassBase::Class(class))
+                            .chain(single_base.mro(db))
+                            .collect();
+                        Ok(mro)
+                    },
+                )
+            }
+
+            // The class has multiple explicit bases.
+            //
+            // We'll fallback to a full implementation of the C3-merge algorithm to determine
+            // what MRO Python will give this class at runtime
+            // (if an MRO is indeed resolvable at all!)
+            multiple_bases => {
+                let mut valid_bases = vec![];
+                let mut invalid_bases = vec![];
+
+                for (i, base) in multiple_bases.iter().enumerate() {
+                    match ClassBase::try_from_ty(*base).ok_or(*base) {
+                        Ok(valid_base) => valid_bases.push(valid_base),
+                        Err(invalid_base) => invalid_bases.push((i, invalid_base)),
+                    }
+                }
+
+                if !invalid_bases.is_empty() {
+                    return Err(MroErrorKind::InvalidBases(invalid_bases.into_boxed_slice()));
+                }
+
+                let mut seqs = vec![VecDeque::from([ClassBase::Class(class)])];
+                for base in &valid_bases {
+                    seqs.push(base.mro(db).collect());
+                }
+                seqs.push(valid_bases.iter().copied().collect());
+
+                c3_merge(seqs).ok_or_else(|| {
+                    let mut seen_bases = FxHashSet::default();
+                    let mut duplicate_bases = vec![];
+                    for (index, base) in valid_bases
+                        .iter()
+                        .enumerate()
+                        .filter_map(|(index, base)| Some((index, base.into_class_literal_type()?)))
+                    {
+                        if !seen_bases.insert(base) {
+                            duplicate_bases.push((index, base));
+                        }
+                    }
+
+                    if duplicate_bases.is_empty() {
+                        MroErrorKind::UnresolvableMro {
+                            bases_list: valid_bases.into_boxed_slice(),
+                        }
+                    } else {
+                        MroErrorKind::DuplicateBases(duplicate_bases.into_boxed_slice())
+                    }
+                })
+            }
+        }
+    }
+}
+
+impl<'db, const N: usize> From<[ClassBase<'db>; N]> for Mro<'db> {
+    fn from(value: [ClassBase<'db>; N]) -> Self {
+        Self(Box::from(value))
+    }
+}
+
+impl<'db> From<Vec<ClassBase<'db>>> for Mro<'db> {
+    fn from(value: Vec<ClassBase<'db>>) -> Self {
+        Self(value.into_boxed_slice())
+    }
+}
+
+impl<'db> Deref for Mro<'db> {
+    type Target = [ClassBase<'db>];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<'db> FromIterator<ClassBase<'db>> for Mro<'db> {
+    fn from_iter<T: IntoIterator<Item = ClassBase<'db>>>(iter: T) -> Self {
+        Self(iter.into_iter().collect())
+    }
+}
+
+/// Iterator that yields elements of a class's MRO.
+///
+/// We avoid materialising the *full* MRO unless it is actually necessary:
+/// - Materialising the full MRO is expensive
+/// - We need to do it for every class in the code that we're checking, as we need to make sure
+///   that there are no class definitions in the code we're checking that would cause an
+///   exception to be raised at runtime. But the same does *not* necessarily apply for every class
+///   in third-party and stdlib dependencies: we never emit diagnostics about non-first-party code.
+/// - However, we *do* need to resolve attribute accesses on classes/instances from
+///   third-party and stdlib dependencies. That requires iterating over the MRO of third-party/stdlib
+///   classes, but not necessarily the *whole* MRO: often just the first element is enough.
+///   Luckily we know that for any class `X`, the first element of `X`'s MRO will always be `X` itself.
+///   We can therefore avoid resolving the full MRO for many third-party/stdlib classes while still
+///   being faithful to the runtime semantics.
+///
+/// Even for first-party code, where we will have to resolve the MRO for every class we encounter,
+/// loading the cached MRO comes with a certain amount of overhead, so it's best to avoid calling the
+/// Salsa-tracked [`Class::try_mro`] method unless it's absolutely necessary.
+pub(super) struct MroIterator<'db> {
+    db: &'db dyn Db,
+
+    /// The class whose MRO we're iterating over
+    class: Class<'db>,
+
+    /// Whether or not we've already yielded the first element of the MRO
+    first_element_yielded: bool,
+
+    /// Iterator over all elements of the MRO except the first.
+    ///
+    /// The full MRO is expensive to materialize, so this field is `None`
+    /// unless we actually *need* to iterate past the first element of the MRO,
+    /// at which point it is lazily materialized.
+    subsequent_elements: Option<std::slice::Iter<'db, ClassBase<'db>>>,
+}
+
+impl<'db> MroIterator<'db> {
+    pub(super) fn new(db: &'db dyn Db, class: Class<'db>) -> Self {
+        Self {
+            db,
+            class,
+            first_element_yielded: false,
+            subsequent_elements: None,
+        }
+    }
+
+    /// Materialize the full MRO of the class.
+    /// Return an iterator over that MRO which skips the first element of the MRO.
+    fn full_mro_except_first_element(&mut self) -> impl Iterator<Item = ClassBase<'db>> + '_ {
+        self.subsequent_elements
+            .get_or_insert_with(|| {
+                let mut full_mro_iter = match self.class.try_mro(self.db) {
+                    Ok(mro) => mro.iter(),
+                    Err(error) => error.fallback_mro().iter(),
+                };
+                full_mro_iter.next();
+                full_mro_iter
+            })
+            .copied()
+    }
+}
+
+impl<'db> Iterator for MroIterator<'db> {
+    type Item = ClassBase<'db>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if !self.first_element_yielded {
+            self.first_element_yielded = true;
+            return Some(ClassBase::Class(self.class));
+        }
+        self.full_mro_except_first_element().next()
+    }
+}
+
+impl std::iter::FusedIterator for MroIterator<'_> {}
+
+#[derive(Debug, PartialEq, Eq)]
+pub(super) struct MroError<'db> {
+    kind: MroErrorKind<'db>,
+    fallback_mro: Mro<'db>,
+}
+
+impl<'db> MroError<'db> {
+    /// Return an [`MroErrorKind`] variant describing why we could not resolve the MRO for this class.
+    pub(super) fn reason(&self) -> &MroErrorKind<'db> {
+        &self.kind
+    }
+
+    /// Return the fallback MRO we should infer for this class during type inference
+    /// (since accurate resolution of its "true" MRO was impossible)
+    pub(super) fn fallback_mro(&self) -> &Mro<'db> {
+        &self.fallback_mro
+    }
+}
+
+/// Possible ways in which attempting to resolve the MRO of a class might fail.
+#[derive(Debug, PartialEq, Eq)]
+pub(super) enum MroErrorKind<'db> {
+    /// The class inherits from one or more invalid bases.
+    ///
+    /// To avoid excessive complexity in our implementation,
+    /// we only permit classes to inherit from class-literal types,
+    /// `Todo`, `Unknown` or `Any`. Anything else results in us
+    /// emitting a diagnostic.
+    ///
+    /// This variant records the indices and types of class bases
+    /// that we deem to be invalid. The indices are the indices of nodes
+    /// in the bases list of the class's [`StmtClassDef`](ruff_python_ast::StmtClassDef) node.
+    /// Each index is the index of a node representing an invalid base.
+    InvalidBases(Box<[(usize, Type<'db>)]>),
+
+    /// The class has one or more duplicate bases.
+    ///
+    /// This variant records the indices and [`Class`]es
+    /// of the duplicate bases. The indices are the indices of nodes
+    /// in the bases list of the class's [`StmtClassDef`](ruff_python_ast::StmtClassDef) node.
+    /// Each index is the index of a node representing a duplicate base.
+    DuplicateBases(Box<[(usize, Class<'db>)]>),
+
+    /// The MRO is otherwise unresolvable through the C3-merge algorithm.
+    ///
+    /// See [`c3_merge`] for more details.
+    UnresolvableMro { bases_list: Box<[ClassBase<'db>]> },
+}
+
+/// Enumeration of the possible kinds of types we allow in class bases.
+///
+/// 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`]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub(super) enum ClassBase<'db> {
+    Any,
+    Unknown,
+    Todo,
+    Class(Class<'db>),
+}
+
+impl<'db> ClassBase<'db> {
+    pub(super) fn display(self, db: &'db dyn Db) -> impl std::fmt::Display + 'db {
+        struct Display<'db> {
+            base: ClassBase<'db>,
+            db: &'db dyn Db,
+        }
+
+        impl std::fmt::Display for Display<'_> {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                match self.base {
+                    ClassBase::Any => f.write_str("Any"),
+                    ClassBase::Todo => f.write_str("Todo"),
+                    ClassBase::Unknown => f.write_str("Unknown"),
+                    ClassBase::Class(class) => write!(f, "<class '{}'>", class.name(self.db)),
+                }
+            }
+        }
+
+        Display { base: self, db }
+    }
+
+    #[cfg(test)]
+    #[track_caller]
+    pub(super) fn expect_class_base(self) -> Class<'db> {
+        match self {
+            ClassBase::Class(class) => class,
+            _ => panic!("Expected a `ClassBase::Class()` variant"),
+        }
+    }
+
+    /// Return a `ClassBase` representing the class `builtins.object`
+    fn object(db: &'db dyn Db) -> Self {
+        KnownClass::Object
+            .to_class_literal(db)
+            .into_class_literal()
+            .map_or(Self::Unknown, |ClassLiteralType { class }| {
+                Self::Class(class)
+            })
+    }
+
+    /// Attempt to resolve `ty` into a `ClassBase`.
+    ///
+    /// Return `None` if `ty` is not an acceptable type for a class base.
+    fn try_from_ty(ty: Type<'db>) -> Option<Self> {
+        match ty {
+            Type::Any => Some(Self::Any),
+            Type::Unknown => Some(Self::Unknown),
+            Type::Todo(_) => Some(Self::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?
+            Type::Instance(_) => None, // TODO -- handle `__mro_entries__`?
+            Type::Never
+            | Type::BooleanLiteral(_)
+            | Type::FunctionLiteral(_)
+            | Type::BytesLiteral(_)
+            | Type::IntLiteral(_)
+            | Type::StringLiteral(_)
+            | Type::LiteralString
+            | Type::Tuple(_)
+            | Type::SliceLiteral(_)
+            | Type::ModuleLiteral(_)
+            | Type::SubclassOf(_) => None,
+            Type::KnownInstance(known_instance) => match known_instance {
+                KnownInstanceType::TypeVar(_)
+                | KnownInstanceType::TypeAliasType(_)
+                | KnownInstanceType::Literal
+                | KnownInstanceType::Union
+                | KnownInstanceType::NoReturn
+                | KnownInstanceType::Never
+                | KnownInstanceType::Optional => None,
+            },
+        }
+    }
+
+    fn into_class_literal_type(self) -> Option<Class<'db>> {
+        match self {
+            Self::Class(class) => Some(class),
+            _ => None,
+        }
+    }
+
+    /// Iterate over the MRO of this base
+    fn mro(
+        self,
+        db: &'db dyn Db,
+    ) -> Either<impl Iterator<Item = ClassBase<'db>>, impl Iterator<Item = ClassBase<'db>>> {
+        match self {
+            ClassBase::Any => Either::Left([ClassBase::Any, ClassBase::object(db)].into_iter()),
+            ClassBase::Unknown => {
+                Either::Left([ClassBase::Unknown, ClassBase::object(db)].into_iter())
+            }
+            ClassBase::Todo => Either::Left([ClassBase::Todo, ClassBase::object(db)].into_iter()),
+            ClassBase::Class(class) => Either::Right(class.iter_mro(db)),
+        }
+    }
+}
+
+impl<'db> From<ClassBase<'db>> for Type<'db> {
+    fn from(value: ClassBase<'db>) -> Self {
+        match value {
+            ClassBase::Any => Type::Any,
+            ClassBase::Todo => todo_type!(),
+            ClassBase::Unknown => Type::Unknown,
+            ClassBase::Class(class) => Type::class_literal(class),
+        }
+    }
+}
+
+/// Implementation of the [C3-merge algorithm] for calculating a Python class's
+/// [method resolution order].
+///
+/// [C3-merge algorithm]: https://docs.python.org/3/howto/mro.html#python-2-3-mro
+/// [method resolution order]: https://docs.python.org/3/glossary.html#term-method-resolution-order
+fn c3_merge(mut sequences: Vec<VecDeque<ClassBase>>) -> Option<Mro> {
+    // Most MROs aren't that long...
+    let mut mro = Vec::with_capacity(8);
+
+    loop {
+        sequences.retain(|sequence| !sequence.is_empty());
+
+        if sequences.is_empty() {
+            return Some(Mro::from(mro));
+        }
+
+        // If the candidate exists "deeper down" in the inheritance hierarchy,
+        // we should refrain from adding it to the MRO for now. Add the first candidate
+        // for which this does not hold true. If this holds true for all candidates,
+        // return `None`; it will be impossible to find a consistent MRO for the class
+        // with the given bases.
+        let mro_entry = sequences.iter().find_map(|outer_sequence| {
+            let candidate = outer_sequence[0];
+
+            let not_head = sequences
+                .iter()
+                .all(|sequence| sequence.iter().skip(1).all(|base| base != &candidate));
+
+            not_head.then_some(candidate)
+        })?;
+
+        mro.push(mro_entry);
+
+        // Make sure we don't try to add the candidate to the MRO twice:
+        for sequence in &mut sequences {
+            if sequence[0] == mro_entry {
+                sequence.pop_front();
+            }
+        }
+    }
+}

crates/red_knot_python_semantic/src/types/narrow.rs

@@ -1,16 +1,19 @@
-use crate::semantic_index::ast_ids::HasScopedAstId;
+use crate::semantic_index::ast_ids::HasScopedExpressionId;
 use crate::semantic_index::constraint::{Constraint, ConstraintNode, PatternConstraint};
 use crate::semantic_index::definition::Definition;
 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, IntersectionBuilder, KnownFunction, Type, UnionBuilder,
+    infer_expression_types, ClassLiteralType, IntersectionBuilder, KnownClass,
+    KnownConstraintFunction, KnownFunction, Truthiness, Type, UnionBuilder,
 };
 use crate::Db;
 use itertools::Itertools;
 use ruff_python_ast as ast;
+use ruff_python_ast::{BoolOp, ExprBoolOp};
 use rustc_hash::FxHashMap;
+use std::collections::hash_map::Entry;
 use std::sync::Arc;
 
 /// Return the type constraint that `test` (if true) would place on `definition`, if any.
@@ -34,21 +37,20 @@ pub(crate) fn narrowing_constraint<'db>(
     constraint: Constraint<'db>,
     definition: Definition<'db>,
 ) -> Option<Type<'db>> {
-    match constraint.node {
+    let constraints = match constraint.node {
         ConstraintNode::Expression(expression) => {
             if constraint.is_positive {
                 all_narrowing_constraints_for_expression(db, expression)
-                    .get(&definition.symbol(db))
-                    .copied()
             } else {
                 all_negative_narrowing_constraints_for_expression(db, expression)
-                    .get(&definition.symbol(db))
-                    .copied()
             }
         }
-        ConstraintNode::Pattern(pattern) => all_narrowing_constraints_for_pattern(db, pattern)
-            .get(&definition.symbol(db))
-            .copied(),
+        ConstraintNode::Pattern(pattern) => all_narrowing_constraints_for_pattern(db, pattern),
+    };
+    if let Some(constraints) = constraints {
+        constraints.get(&definition.symbol(db)).copied()
+    } else {
+        None
     }
 }
 
@@ -56,7 +58,7 @@ pub(crate) fn narrowing_constraint<'db>(
 fn all_narrowing_constraints_for_pattern<'db>(
     db: &'db dyn Db,
     pattern: PatternConstraint<'db>,
-) -> NarrowingConstraints<'db> {
+) -> Option<NarrowingConstraints<'db>> {
     NarrowingConstraintsBuilder::new(db, ConstraintNode::Pattern(pattern), true).finish()
 }
 
@@ -64,7 +66,7 @@ fn all_narrowing_constraints_for_pattern<'db>(
 fn all_narrowing_constraints_for_expression<'db>(
     db: &'db dyn Db,
     expression: Expression<'db>,
-) -> NarrowingConstraints<'db> {
+) -> Option<NarrowingConstraints<'db>> {
     NarrowingConstraintsBuilder::new(db, ConstraintNode::Expression(expression), true).finish()
 }
 
@@ -72,39 +74,83 @@ fn all_narrowing_constraints_for_expression<'db>(
 fn all_negative_narrowing_constraints_for_expression<'db>(
     db: &'db dyn Db,
     expression: Expression<'db>,
-) -> NarrowingConstraints<'db> {
+) -> Option<NarrowingConstraints<'db>> {
     NarrowingConstraintsBuilder::new(db, ConstraintNode::Expression(expression), false).finish()
 }
 
-/// Generate a constraint from the *type* of the second argument of an `isinstance` call.
+/// Generate a constraint from the type of a `classinfo` argument to `isinstance` or `issubclass`.
 ///
-/// Example: for `isinstance(…, str)`, we would infer `Type::ClassLiteral(str)` from the
-/// second argument, but we need to generate a `Type::Instance(str)` constraint that can
-/// be used to narrow down the type of the first argument.
-fn generate_isinstance_constraint<'db>(
+/// 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>,
-) -> Option<Type<'db>> {
+    to_constraint: F,
+) -> Option<Type<'db>>
+where
+    F: Fn(ClassLiteralType<'db>) -> Type<'db> + Copy,
+{
     match classinfo {
-        Type::ClassLiteral(class) => Some(Type::Instance(*class)),
         Type::Tuple(tuple) => {
             let mut builder = UnionBuilder::new(db);
             for element in tuple.elements(db) {
-                builder = builder.add(generate_isinstance_constraint(db, element)?);
+                builder = builder.add(generate_classinfo_constraint(db, element, to_constraint)?);
             }
             Some(builder.build())
         }
+        Type::ClassLiteral(class_literal_type) => Some(to_constraint(*class_literal_type)),
         _ => None,
     }
 }
 
 type NarrowingConstraints<'db> = FxHashMap<ScopedSymbolId, Type<'db>>;
 
+fn merge_constraints_and<'db>(
+    into: &mut NarrowingConstraints<'db>,
+    from: NarrowingConstraints<'db>,
+    db: &'db dyn Db,
+) {
+    for (key, value) in from {
+        match into.entry(key) {
+            Entry::Occupied(mut entry) => {
+                *entry.get_mut() = IntersectionBuilder::new(db)
+                    .add_positive(*entry.get())
+                    .add_positive(value)
+                    .build();
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(value);
+            }
+        }
+    }
+}
+
+fn merge_constraints_or<'db>(
+    into: &mut NarrowingConstraints<'db>,
+    from: &NarrowingConstraints<'db>,
+    db: &'db dyn Db,
+) {
+    for (key, value) in from {
+        match into.entry(*key) {
+            Entry::Occupied(mut entry) => {
+                *entry.get_mut() = UnionBuilder::new(db).add(*entry.get()).add(*value).build();
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(KnownClass::Object.to_instance(db));
+            }
+        }
+    }
+    for (key, value) in into.iter_mut() {
+        if !from.contains_key(key) {
+            *value = KnownClass::Object.to_instance(db);
+        }
+    }
+}
+
 struct NarrowingConstraintsBuilder<'db> {
     db: &'db dyn Db,
     constraint: ConstraintNode<'db>,
     is_positive: bool,
-    constraints: NarrowingConstraints<'db>,
 }
 
 impl<'db> NarrowingConstraintsBuilder<'db> {
@@ -113,24 +159,31 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
             db,
             constraint,
             is_positive,
-            constraints: NarrowingConstraints::default(),
         }
     }
 
-    fn finish(mut self) -> NarrowingConstraints<'db> {
-        match self.constraint {
+    fn finish(mut self) -> Option<NarrowingConstraints<'db>> {
+        let constraints: Option<NarrowingConstraints<'db>> = match self.constraint {
             ConstraintNode::Expression(expression) => {
-                self.evaluate_expression_constraint(expression, self.is_positive);
+                self.evaluate_expression_constraint(expression, self.is_positive)
             }
             ConstraintNode::Pattern(pattern) => self.evaluate_pattern_constraint(pattern),
+        };
+        if let Some(mut constraints) = constraints {
+            constraints.shrink_to_fit();
+            Some(constraints)
+        } else {
+            None
         }
-        self.constraints.shrink_to_fit();
-        self.constraints
     }
 
-    fn evaluate_expression_constraint(&mut self, expression: Expression<'db>, is_positive: bool) {
+    fn evaluate_expression_constraint(
+        &mut self,
+        expression: Expression<'db>,
+        is_positive: bool,
+    ) -> Option<NarrowingConstraints<'db>> {
         let expression_node = expression.node_ref(self.db).node();
-        self.evaluate_expression_node_constraint(expression_node, expression, is_positive);
+        self.evaluate_expression_node_constraint(expression_node, expression, is_positive)
     }
 
     fn evaluate_expression_node_constraint(
@@ -138,52 +191,51 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
         expression_node: &ruff_python_ast::Expr,
         expression: Expression<'db>,
         is_positive: bool,
-    ) {
+    ) -> Option<NarrowingConstraints<'db>> {
         match expression_node {
             ast::Expr::Compare(expr_compare) => {
-                self.add_expr_compare(expr_compare, expression, is_positive);
+                self.evaluate_expr_compare(expr_compare, expression, is_positive)
             }
             ast::Expr::Call(expr_call) => {
-                self.add_expr_call(expr_call, expression, is_positive);
+                self.evaluate_expr_call(expr_call, expression, is_positive)
             }
-            ast::Expr::UnaryOp(unary_op) if unary_op.op == ast::UnaryOp::Not => {
-                self.evaluate_expression_node_constraint(
-                    &unary_op.operand,
-                    expression,
-                    !is_positive,
-                );
-            }
-            _ => {} // TODO other test expression kinds
+            ast::Expr::UnaryOp(unary_op) if unary_op.op == ast::UnaryOp::Not => self
+                .evaluate_expression_node_constraint(&unary_op.operand, expression, !is_positive),
+            ast::Expr::BoolOp(bool_op) => self.evaluate_bool_op(bool_op, expression, is_positive),
+            _ => None, // TODO other test expression kinds
         }
     }
 
-    fn evaluate_pattern_constraint(&mut self, pattern: PatternConstraint<'db>) {
+    fn evaluate_pattern_constraint(
+        &mut self,
+        pattern: PatternConstraint<'db>,
+    ) -> Option<NarrowingConstraints<'db>> {
         let subject = pattern.subject(self.db);
 
         match pattern.pattern(self.db).node() {
             ast::Pattern::MatchValue(_) => {
-                // TODO
+                None // TODO
             }
             ast::Pattern::MatchSingleton(singleton_pattern) => {
-                self.add_match_pattern_singleton(subject, singleton_pattern);
+                self.evaluate_match_pattern_singleton(subject, singleton_pattern)
             }
             ast::Pattern::MatchSequence(_) => {
-                // TODO
+                None // TODO
             }
             ast::Pattern::MatchMapping(_) => {
-                // TODO
+                None // TODO
             }
             ast::Pattern::MatchClass(_) => {
-                // TODO
+                None // TODO
             }
             ast::Pattern::MatchStar(_) => {
-                // TODO
+                None // TODO
             }
             ast::Pattern::MatchAs(_) => {
-                // TODO
+                None // TODO
             }
             ast::Pattern::MatchOr(_) => {
-                // TODO
+                None // TODO
             }
         }
     }
@@ -199,29 +251,38 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
         }
     }
 
-    fn add_expr_compare(
+    fn evaluate_expr_compare(
         &mut self,
         expr_compare: &ast::ExprCompare,
         expression: Expression<'db>,
         is_positive: bool,
-    ) {
+    ) -> Option<NarrowingConstraints<'db>> {
+        fn is_narrowing_target_candidate(expr: &ast::Expr) -> bool {
+            matches!(expr, ast::Expr::Name(_) | ast::Expr::Call(_))
+        }
+
         let ast::ExprCompare {
             range: _,
             left,
             ops,
             comparators,
         } = expr_compare;
-        if !left.is_name_expr() && comparators.iter().all(|c| !c.is_name_expr()) {
-            // If none of the comparators are name expressions,
-            // we have no symbol to narrow down the type of.
-            return;
+
+        // Performance optimization: early return if there are no potential narrowing targets.
+        if !is_narrowing_target_candidate(left)
+            && comparators
+                .iter()
+                .all(|c| !is_narrowing_target_candidate(c))
+        {
+            return None;
         }
+
         if !is_positive && comparators.len() > 1 {
             // We can't negate a constraint made by a multi-comparator expression, since we can't
             // know which comparison part is the one being negated.
             // For example, the negation of  `x is 1 is y is 2`, would be `(x is not 1) or (y is not 1) or (y is not 2)`
             // and that requires cross-symbol constraints, which we don't support yet.
-            return;
+            return None;
         }
         let scope = self.scope();
         let inference = infer_expression_types(self.db, expression);
@@ -229,98 +290,218 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
         let comparator_tuples = std::iter::once(&**left)
             .chain(comparators)
             .tuple_windows::<(&ruff_python_ast::Expr, &ruff_python_ast::Expr)>();
+        let mut constraints = NarrowingConstraints::default();
         for (op, (left, right)) in std::iter::zip(&**ops, comparator_tuples) {
-            if let ast::Expr::Name(ast::ExprName {
-                range: _,
-                id,
-                ctx: _,
-            }) = left
-            {
-                // SAFETY: we should always have a symbol for every Name node.
-                let symbol = self.symbols().symbol_id_by_name(id).unwrap();
-                let rhs_ty = inference.expression_ty(right.scoped_ast_id(self.db, scope));
+            let rhs_ty = inference.expression_ty(right.scoped_expression_id(self.db, scope));
 
-                match if is_positive { *op } else { op.negate() } {
-                    ast::CmpOp::IsNot => {
-                        if rhs_ty.is_singleton() {
-                            let ty = IntersectionBuilder::new(self.db)
-                                .add_negative(rhs_ty)
-                                .build();
-                            self.constraints.insert(symbol, ty);
-                        } else {
-                            // Non-singletons cannot be safely narrowed using `is not`
+            match left {
+                ast::Expr::Name(ast::ExprName {
+                    range: _,
+                    id,
+                    ctx: _,
+                }) => {
+                    let symbol = self
+                        .symbols()
+                        .symbol_id_by_name(id)
+                        .expect("Should always have a symbol for every Name node");
+
+                    match if is_positive { *op } else { op.negate() } {
+                        ast::CmpOp::IsNot => {
+                            if rhs_ty.is_singleton(self.db) {
+                                let ty = IntersectionBuilder::new(self.db)
+                                    .add_negative(rhs_ty)
+                                    .build();
+                                constraints.insert(symbol, ty);
+                            } else {
+                                // Non-singletons cannot be safely narrowed using `is not`
+                            }
                         }
-                    }
-                    ast::CmpOp::Is => {
-                        self.constraints.insert(symbol, rhs_ty);
-                    }
-                    ast::CmpOp::NotEq => {
-                        if rhs_ty.is_single_valued(self.db) {
-                            let ty = IntersectionBuilder::new(self.db)
-                                .add_negative(rhs_ty)
-                                .build();
-                            self.constraints.insert(symbol, ty);
+                        ast::CmpOp::Is => {
+                            constraints.insert(symbol, rhs_ty);
+                        }
+                        ast::CmpOp::NotEq => {
+                            if rhs_ty.is_single_valued(self.db) {
+                                let ty = IntersectionBuilder::new(self.db)
+                                    .add_negative(rhs_ty)
+                                    .build();
+                                constraints.insert(symbol, ty);
+                            }
+                        }
+                        _ => {
+                            // TODO other comparison types
                         }
-                    }
-                    _ => {
-                        // TODO other comparison types
                     }
                 }
+                ast::Expr::Call(ast::ExprCall {
+                    range: _,
+                    func: callable,
+                    arguments:
+                        ast::Arguments {
+                            args,
+                            keywords,
+                            range: _,
+                        },
+                }) if rhs_ty.is_class_literal() && keywords.is_empty() => {
+                    let [ast::Expr::Name(ast::ExprName { id, .. })] = &**args else {
+                        continue;
+                    };
+
+                    let is_valid_constraint = if is_positive {
+                        op == &ast::CmpOp::Is
+                    } else {
+                        op == &ast::CmpOp::IsNot
+                    };
+
+                    if !is_valid_constraint {
+                        continue;
+                    }
+
+                    let callable_ty =
+                        inference.expression_ty(callable.scoped_expression_id(self.db, scope));
+
+                    if callable_ty
+                        .into_class_literal()
+                        .is_some_and(|c| c.class.is_known(self.db, KnownClass::Type))
+                    {
+                        let symbol = self
+                            .symbols()
+                            .symbol_id_by_name(id)
+                            .expect("Should always have a symbol for every Name node");
+                        constraints.insert(symbol, rhs_ty.to_instance(self.db));
+                    }
+                }
+                _ => {}
             }
         }
+        Some(constraints)
     }
 
-    fn add_expr_call(
+    fn evaluate_expr_call(
         &mut self,
         expr_call: &ast::ExprCall,
         expression: Expression<'db>,
         is_positive: bool,
-    ) {
+    ) -> Option<NarrowingConstraints<'db>> {
         let scope = self.scope();
         let inference = infer_expression_types(self.db, expression);
 
-        if let Some(func_type) = inference
-            .expression_ty(expr_call.func.scoped_ast_id(self.db, scope))
-            .into_function_literal_type()
+        // TODO: add support for PEP 604 union types on the right hand side of `isinstance`
+        // and `issubclass`, for example `isinstance(x, str | (int | float))`.
+        match inference
+            .expression_ty(expr_call.func.scoped_expression_id(self.db, scope))
+            .into_function_literal()
+            .and_then(|f| f.known(self.db))
+            .and_then(KnownFunction::constraint_function)
         {
-            if func_type.is_known(self.db, KnownFunction::IsInstance)
-                && expr_call.arguments.keywords.is_empty()
-            {
-                if let [ast::Expr::Name(ast::ExprName { id, .. }), rhs] = &*expr_call.arguments.args
+            Some(function) if expr_call.arguments.keywords.is_empty() => {
+                if let [ast::Expr::Name(ast::ExprName { id, .. }), class_info] =
+                    &*expr_call.arguments.args
                 {
                     let symbol = self.symbols().symbol_id_by_name(id).unwrap();
 
-                    let rhs_type = inference.expression_ty(rhs.scoped_ast_id(self.db, scope));
+                    let class_info_ty =
+                        inference.expression_ty(class_info.scoped_expression_id(self.db, scope));
 
-                    // TODO: add support for PEP 604 union types on the right hand side:
-                    // isinstance(x, str | (int | float))
-                    if let Some(mut constraint) = generate_isinstance_constraint(self.db, &rhs_type)
-                    {
-                        if !is_positive {
-                            constraint = constraint.negate(self.db);
+                    let to_constraint = match function {
+                        KnownConstraintFunction::IsInstance => {
+                            |class_literal: ClassLiteralType<'db>| {
+                                Type::instance(class_literal.class)
+                            }
                         }
-                        self.constraints.insert(symbol, constraint);
-                    }
+                        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
+                        },
+                    )
+                } else {
+                    None
                 }
             }
+            _ => None,
         }
     }
 
-    fn add_match_pattern_singleton(
+    fn evaluate_match_pattern_singleton(
         &mut self,
         subject: &ast::Expr,
         pattern: &ast::PatternMatchSingleton,
-    ) {
+    ) -> Option<NarrowingConstraints<'db>> {
         if let Some(ast::ExprName { id, .. }) = subject.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 ty = match pattern.value {
-                ast::Singleton::None => Type::None,
+                ast::Singleton::None => Type::none(self.db),
                 ast::Singleton::True => Type::BooleanLiteral(true),
                 ast::Singleton::False => Type::BooleanLiteral(false),
             };
-            self.constraints.insert(symbol, ty);
+            let mut constraints = NarrowingConstraints::default();
+            constraints.insert(symbol, ty);
+            Some(constraints)
+        } else {
+            None
+        }
+    }
+
+    fn evaluate_bool_op(
+        &mut self,
+        expr_bool_op: &ExprBoolOp,
+        expression: Expression<'db>,
+        is_positive: bool,
+    ) -> Option<NarrowingConstraints<'db>> {
+        let inference = infer_expression_types(self.db, expression);
+        let scope = self.scope();
+        let mut sub_constraints = expr_bool_op
+            .values
+            .iter()
+            // filter our arms with statically known truthiness
+            .filter(|expr| {
+                inference
+                    .expression_ty(expr.scoped_expression_id(self.db, scope))
+                    .bool(self.db)
+                    != match expr_bool_op.op {
+                        BoolOp::And => Truthiness::AlwaysTrue,
+                        BoolOp::Or => Truthiness::AlwaysFalse,
+                    }
+            })
+            .map(|sub_expr| {
+                self.evaluate_expression_node_constraint(sub_expr, expression, is_positive)
+            })
+            .collect::<Vec<_>>();
+        match (expr_bool_op.op, is_positive) {
+            (BoolOp::And, true) | (BoolOp::Or, false) => {
+                let mut aggregation: Option<NarrowingConstraints> = None;
+                for sub_constraint in sub_constraints.into_iter().flatten() {
+                    if let Some(ref mut some_aggregation) = aggregation {
+                        merge_constraints_and(some_aggregation, sub_constraint, self.db);
+                    } else {
+                        aggregation = Some(sub_constraint);
+                    }
+                }
+                aggregation
+            }
+            (BoolOp::Or, true) | (BoolOp::And, false) => {
+                let (first, rest) = sub_constraints.split_first_mut()?;
+                if let Some(ref mut first) = first {
+                    for rest_constraint in rest {
+                        if let Some(rest_constraint) = rest_constraint {
+                            merge_constraints_or(first, rest_constraint, self.db);
+                        } else {
+                            return None;
+                        }
+                    }
+                }
+                first.clone()
+            }
         }
     }
 }

crates/red_knot_python_semantic/src/types/signatures.rs

@@ -0,0 +1,479 @@
+#![allow(dead_code)]
+use super::{definition_expression_ty, Type};
+use crate::Db;
+use crate::{semantic_index::definition::Definition, types::todo_type};
+use ruff_python_ast::{self as ast, name::Name};
+
+/// A typed callable signature.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct Signature<'db> {
+    parameters: Parameters<'db>,
+
+    /// Annotated return type (Unknown if no annotation.)
+    pub(crate) return_ty: Type<'db>,
+}
+
+impl<'db> Signature<'db> {
+    /// Return a todo signature: (*args: Todo, **kwargs: Todo) -> Todo
+    pub(crate) fn todo() -> Self {
+        Self {
+            parameters: Parameters::todo(),
+            return_ty: todo_type!("return type"),
+        }
+    }
+
+    /// Return a typed signature from a function definition.
+    pub(super) fn from_function(
+        db: &'db dyn 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())
+                }
+            })
+            .unwrap_or(Type::Unknown);
+
+        Self {
+            parameters: Parameters::from_parameters(
+                db,
+                definition,
+                function_node.parameters.as_ref(),
+            ),
+            return_ty,
+        }
+    }
+}
+
+/// 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 {
+            variadic: Some(Parameter {
+                name: Some(Name::new_static("args")),
+                annotated_ty: todo_type!(),
+            }),
+            keywords: Some(Parameter {
+                name: Some(Name::new_static("kwargs")),
+                annotated_ty: todo_type!(),
+            }),
+            ..Default::default()
+        }
+    }
+
+    fn from_parameters(
+        db: &'db dyn Db,
+        definition: Definition<'db>,
+        parameters: &'db ast::Parameters,
+    ) -> Self {
+        let ast::Parameters {
+            posonlyargs,
+            args,
+            vararg,
+            kwonlyargs,
+            kwarg,
+            range: _,
+        } = parameters;
+        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(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(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 (Unknown if no annotation.)
+    annotated_ty: Type<'db>,
+}
+
+impl<'db> Parameter<'db> {
+    fn from_node(
+        db: &'db dyn Db,
+        definition: Definition<'db>,
+        parameter: &'db ast::Parameter,
+    ) -> Self {
+        Parameter {
+            name: Some(parameter.name.id.clone()),
+            annotated_ty: parameter
+                .annotation
+                .as_deref()
+                .map(|annotation| definition_expression_ty(db, definition, annotation))
+                .unwrap_or(Type::Unknown),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::db::tests::TestDb;
+    use crate::program::{Program, SearchPathSettings};
+    use crate::python_version::PythonVersion;
+    use crate::types::{global_symbol, FunctionType};
+    use crate::ProgramSettings;
+    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
+
+    pub(crate) fn setup_db() -> TestDb {
+        let db = TestDb::new();
+
+        let src_root = SystemPathBuf::from("/src");
+        db.memory_file_system()
+            .create_directory_all(&src_root)
+            .unwrap();
+
+        Program::from_settings(
+            &db,
+            &ProgramSettings {
+                target_version: PythonVersion::default(),
+                search_paths: SearchPathSettings::new(src_root),
+            },
+        )
+        .expect("Valid search path settings");
+
+        db
+    }
+
+    #[track_caller]
+    fn get_function_f<'db>(db: &'db TestDb, file: &'static str) -> FunctionType<'db> {
+        let module = ruff_db::files::system_path_to_file(db, file).unwrap();
+        global_symbol(db, module, "f")
+            .expect_type()
+            .expect_function_literal()
+    }
+
+    #[track_caller]
+    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]
+    fn empty() {
+        let mut db = setup_db();
+        db.write_dedented("/src/a.py", "def f(): ...").unwrap();
+        let func = get_function_f(&db, "/src/a.py");
+
+        let sig = func.internal_signature(&db);
+
+        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]
+    #[allow(clippy::many_single_char_names)]
+    fn full() {
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/a.py",
+            "
+            def f(a, b: int, c = 1, d: int = 2, /,
+                  e = 3, f: Literal[4] = 4, *args: object,
+                  g = 5, h: Literal[6] = 6, **kwargs: str) -> bytes: ...
+            ",
+        )
+        .unwrap();
+        let func = get_function_f(&db, "/src/a.py");
+
+        let sig = func.internal_signature(&db);
+
+        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]
+    fn not_deferred() {
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/a.py",
+            "
+            class A: ...
+            class B: ...
+
+            alias = A
+
+            def f(a: alias): ...
+
+            alias = B
+            ",
+        )
+        .unwrap();
+        let func = get_function_f(&db, "/src/a.py");
+
+        let sig = func.internal_signature(&db);
+
+        let [a] = &sig.parameters.positional_or_keyword[..] else {
+            panic!("expected one positional-or-keyword parameter");
+        };
+        // Parameter resolution not deferred; we should see A not B
+        assert_param_with_default(&db, a, "a", "A", None);
+    }
+
+    #[test]
+    fn deferred_in_stub() {
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/a.pyi",
+            "
+            class A: ...
+            class B: ...
+
+            alias = A
+
+            def f(a: alias): ...
+
+            alias = B
+            ",
+        )
+        .unwrap();
+        let func = get_function_f(&db, "/src/a.pyi");
+
+        let sig = func.internal_signature(&db);
+
+        let [a] = &sig.parameters.positional_or_keyword[..] else {
+            panic!("expected one positional-or-keyword parameter");
+        };
+        // Parameter resolution deferred; we should see B
+        assert_param_with_default(&db, a, "a", "B", None);
+    }
+
+    #[test]
+    fn generic_not_deferred() {
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/a.py",
+            "
+            class A: ...
+            class B: ...
+
+            alias = A
+
+            def f[T](a: alias, b: T) -> T: ...
+
+            alias = B
+            ",
+        )
+        .unwrap();
+        let func = get_function_f(&db, "/src/a.py");
+
+        let sig = func.internal_signature(&db);
+
+        let [a, b] = &sig.parameters.positional_or_keyword[..] else {
+            panic!("expected two positional-or-keyword parameters");
+        };
+        // TODO resolution should not be deferred; we should see A not B
+        assert_param_with_default(&db, a, "a", "B", None);
+        assert_param_with_default(&db, b, "b", "T", None);
+    }
+
+    #[test]
+    fn generic_deferred_in_stub() {
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/a.pyi",
+            "
+            class A: ...
+            class B: ...
+
+            alias = A
+
+            def f[T](a: alias, b: T) -> T: ...
+
+            alias = B
+            ",
+        )
+        .unwrap();
+        let func = get_function_f(&db, "/src/a.pyi");
+
+        let sig = func.internal_signature(&db);
+
+        let [a, b] = &sig.parameters.positional_or_keyword[..] else {
+            panic!("expected two positional-or-keyword parameters");
+        };
+        // Parameter resolution deferred; we should see B
+        assert_param_with_default(&db, a, "a", "B", None);
+        assert_param_with_default(&db, b, "b", "T", None);
+    }
+
+    #[test]
+    fn external_signature_no_decorator() {
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/a.py",
+            "
+            def f(a: int) -> int: ...
+            ",
+        )
+        .unwrap();
+        let func = get_function_f(&db, "/src/a.py");
+
+        let expected_sig = func.internal_signature(&db);
+
+        // With no decorators, internal and external signature are the same
+        assert_eq!(func.signature(&db), &expected_sig);
+    }
+
+    #[test]
+    fn external_signature_decorated() {
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/a.py",
+            "
+            def deco(func): ...
+
+            @deco
+            def f(a: int) -> int: ...
+            ",
+        )
+        .unwrap();
+        let func = get_function_f(&db, "/src/a.py");
+
+        let expected_sig = Signature::todo();
+
+        // With no decorators, internal and external signature are the same
+        assert_eq!(func.signature(&db), &expected_sig);
+    }
+}

crates/red_knot_python_semantic/src/types/string_annotation.rs

@@ -0,0 +1,77 @@
+use ruff_db::files::File;
+use ruff_db::source::source_text;
+use ruff_python_ast::str::raw_contents;
+use ruff_python_ast::{self as ast, ModExpression, StringFlags};
+use ruff_python_parser::{parse_expression_range, Parsed};
+use ruff_text_size::Ranged;
+
+use crate::types::diagnostic::{TypeCheckDiagnostics, TypeCheckDiagnosticsBuilder};
+use crate::Db;
+
+type AnnotationParseResult = Result<Parsed<ModExpression>, TypeCheckDiagnostics>;
+
+/// Parses the given expression as a string annotation.
+pub(crate) fn parse_string_annotation(
+    db: &dyn Db,
+    file: File,
+    string_expr: &ast::ExprStringLiteral,
+) -> AnnotationParseResult {
+    let _span = tracing::trace_span!("parse_string_annotation", string=?string_expr.range(), file=%file.path(db)).entered();
+
+    let source = source_text(db.upcast(), file);
+    let node_text = &source[string_expr.range()];
+    let mut diagnostics = TypeCheckDiagnosticsBuilder::new(db, file);
+
+    if let [string_literal] = string_expr.value.as_slice() {
+        let prefix = string_literal.flags.prefix();
+        if prefix.is_raw() {
+            diagnostics.add(
+                string_literal.into(),
+                "annotation-raw-string",
+                format_args!("Type expressions cannot use raw string literal"),
+            );
+        // Compare the raw contents (without quotes) of the expression with the parsed contents
+        // contained in the string literal.
+        } else if raw_contents(node_text)
+            .is_some_and(|raw_contents| raw_contents == string_literal.as_str())
+        {
+            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 Ok(parsed),
+                Err(parse_error) => diagnostics.add(
+                    string_literal.into(),
+                    "forward-annotation-syntax-error",
+                    format_args!("Syntax error in forward annotation: {}", parse_error.error),
+                ),
+            }
+        } else {
+            // The raw contents of the string doesn't match the parsed content. This could be the
+            // case for annotations that contain escape sequences.
+            diagnostics.add(
+                string_expr.into(),
+                "annotation-escape-character",
+                format_args!("Type expressions cannot contain escape characters"),
+            );
+        }
+    } else {
+        // String is implicitly concatenated.
+        diagnostics.add(
+            string_expr.into(),
+            "annotation-implicit-concat",
+            format_args!("Type expressions cannot span multiple string literals"),
+        );
+    }
+
+    Err(diagnostics.finish())
+}

crates/red_knot_python_semantic/src/types/unpacker.rs

@@ -0,0 +1,142 @@
+use std::borrow::Cow;
+
+use ruff_db::files::File;
+use ruff_python_ast::{self as ast, AnyNodeRef};
+use rustc_hash::FxHashMap;
+
+use crate::semantic_index::ast_ids::{HasScopedExpressionId, ScopedExpressionId};
+use crate::semantic_index::symbol::ScopeId;
+use crate::types::{todo_type, Type, TypeCheckDiagnostics, TypeCheckDiagnosticsBuilder};
+use crate::Db;
+
+/// Unpacks the value expression type to their respective targets.
+pub(crate) struct Unpacker<'db> {
+    db: &'db dyn Db,
+    targets: FxHashMap<ScopedExpressionId, Type<'db>>,
+    diagnostics: TypeCheckDiagnosticsBuilder<'db>,
+}
+
+impl<'db> Unpacker<'db> {
+    pub(crate) fn new(db: &'db dyn Db, file: File) -> Self {
+        Self {
+            db,
+            targets: FxHashMap::default(),
+            diagnostics: TypeCheckDiagnosticsBuilder::new(db, file),
+        }
+    }
+
+    pub(crate) fn unpack(&mut self, target: &ast::Expr, value_ty: Type<'db>, scope: ScopeId<'db>) {
+        match target {
+            ast::Expr::Name(target_name) => {
+                self.targets
+                    .insert(target_name.scoped_expression_id(self.db, scope), value_ty);
+            }
+            ast::Expr::Starred(ast::ExprStarred { value, .. }) => {
+                self.unpack(value, value_ty, scope);
+            }
+            ast::Expr::List(ast::ExprList { elts, .. })
+            | ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => match value_ty {
+                Type::Tuple(tuple_ty) => {
+                    let starred_index = elts.iter().position(ast::Expr::is_starred_expr);
+
+                    let element_types = if let Some(starred_index) = starred_index {
+                        if tuple_ty.len(self.db) >= elts.len() - 1 {
+                            let mut element_types = Vec::with_capacity(elts.len());
+                            element_types.extend_from_slice(
+                                // SAFETY: Safe because of the length check above.
+                                &tuple_ty.elements(self.db)[..starred_index],
+                            );
+
+                            // E.g., in `(a, *b, c, d) = ...`, the index of starred element `b`
+                            // is 1 and the remaining elements after that are 2.
+                            let remaining = elts.len() - (starred_index + 1);
+                            // This index represents the type of the last element that belongs
+                            // to the starred expression, in an exclusive manner.
+                            let starred_end_index = tuple_ty.len(self.db) - remaining;
+                            // SAFETY: Safe because of the length check above.
+                            let _starred_element_types =
+                                &tuple_ty.elements(self.db)[starred_index..starred_end_index];
+                            // TODO: Combine the types into a list type. If the
+                            // starred_element_types is empty, then it should be `List[Any]`.
+                            // combine_types(starred_element_types);
+                            element_types.push(todo_type!("starred unpacking"));
+
+                            element_types.extend_from_slice(
+                                // SAFETY: Safe because of the length check above.
+                                &tuple_ty.elements(self.db)[starred_end_index..],
+                            );
+                            Cow::Owned(element_types)
+                        } else {
+                            let mut element_types = tuple_ty.elements(self.db).to_vec();
+                            // Subtract 1 to insert the starred expression type at the correct
+                            // index.
+                            element_types.resize(elts.len() - 1, Type::Unknown);
+                            // TODO: This should be `list[Unknown]`
+                            element_types.insert(starred_index, todo_type!("starred unpacking"));
+                            Cow::Owned(element_types)
+                        }
+                    } else {
+                        Cow::Borrowed(tuple_ty.elements(self.db).as_ref())
+                    };
+
+                    for (index, element) in elts.iter().enumerate() {
+                        self.unpack(
+                            element,
+                            element_types.get(index).copied().unwrap_or(Type::Unknown),
+                            scope,
+                        );
+                    }
+                }
+                Type::StringLiteral(string_literal_ty) => {
+                    // Deconstruct the string literal to delegate the inference back to the
+                    // tuple type for correct handling of starred expressions. We could go
+                    // further and deconstruct to an array of `StringLiteral` 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.
+                    let value_ty = Type::tuple(
+                        self.db,
+                        &vec![Type::LiteralString; string_literal_ty.len(self.db)],
+                    );
+                    self.unpack(target, value_ty, scope);
+                }
+                _ => {
+                    let value_ty = if value_ty.is_literal_string() {
+                        Type::LiteralString
+                    } else {
+                        value_ty
+                            .iterate(self.db)
+                            .unwrap_with_diagnostic(AnyNodeRef::from(target), &mut self.diagnostics)
+                    };
+                    for element in elts {
+                        self.unpack(element, value_ty, scope);
+                    }
+                }
+            },
+            _ => {}
+        }
+    }
+
+    pub(crate) fn finish(mut self) -> UnpackResult<'db> {
+        self.targets.shrink_to_fit();
+        UnpackResult {
+            diagnostics: self.diagnostics.finish(),
+            targets: self.targets,
+        }
+    }
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub(crate) struct UnpackResult<'db> {
+    targets: FxHashMap<ScopedExpressionId, Type<'db>>,
+    diagnostics: TypeCheckDiagnostics,
+}
+
+impl<'db> UnpackResult<'db> {
+    pub(crate) fn get(&self, expr_id: ScopedExpressionId) -> Option<Type<'db>> {
+        self.targets.get(&expr_id).copied()
+    }
+
+    pub(crate) fn diagnostics(&self) -> &TypeCheckDiagnostics {
+        &self.diagnostics
+    }
+}

crates/red_knot_python_semantic/src/unpack.rs

@@ -0,0 +1,55 @@
+use ruff_db::files::File;
+use ruff_python_ast::{self as ast};
+
+use crate::ast_node_ref::AstNodeRef;
+use crate::semantic_index::expression::Expression;
+use crate::semantic_index::symbol::{FileScopeId, ScopeId};
+use crate::Db;
+
+/// This ingredient represents a single unpacking.
+///
+/// This is required to make use of salsa to cache the complete unpacking of multiple variables
+/// involved. It allows us to:
+/// 1. Avoid doing structural match multiple times for each definition
+/// 2. Avoid highlighting the same error multiple times
+///
+/// ## Module-local type
+/// This type should not be used as part of any cross-module API because
+/// it holds a reference to the AST node. Range-offset changes
+/// then propagate through all usages, and deserialization requires
+/// reparsing the entire module.
+///
+/// E.g. don't use this type in:
+///
+/// * a return type of a cross-module query
+/// * a field of a type that is a return type of a cross-module query
+/// * an argument of a cross-module query
+#[salsa::tracked]
+pub(crate) struct Unpack<'db> {
+    #[id]
+    pub(crate) file: File,
+
+    #[id]
+    pub(crate) file_scope: FileScopeId,
+
+    /// The target expression that is being unpacked. For example, in `(a, b) = (1, 2)`, the target
+    /// expression is `(a, b)`.
+    #[no_eq]
+    #[return_ref]
+    pub(crate) target: AstNodeRef<ast::Expr>,
+
+    /// The ingredient representing the value expression of the unpacking. For example, in
+    /// `(a, b) = (1, 2)`, the value expression is `(1, 2)`.
+    #[no_eq]
+    pub(crate) value: Expression<'db>,
+
+    #[no_eq]
+    count: countme::Count<Unpack<'static>>,
+}
+
+impl<'db> Unpack<'db> {
+    /// Returns the scope where the unpacking is happening.
+    pub(crate) fn scope(self, db: &'db dyn Db) -> ScopeId<'db> {
+        self.file_scope(db).to_scope_id(db, self.file(db))
+    }
+}

crates/red_knot_python_semantic/tests/mdtest.rs

@@ -1,7 +1,8 @@
-use dir_test::{dir_test, Fixture};
-use red_knot_test::run;
+use std::ffi::OsStr;
 use std::path::Path;
 
+use dir_test::{dir_test, Fixture};
+
 /// See `crates/red_knot_test/README.md` for documentation on these tests.
 #[dir_test(
     dir: "$CARGO_MANIFEST_DIR/resources/mdtest",
@@ -9,16 +10,16 @@ use std::path::Path;
 )]
 #[allow(clippy::needless_pass_by_value)]
 fn mdtest(fixture: Fixture<&str>) {
-    let path = fixture.path();
+    let fixture_path = Path::new(fixture.path());
+    let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+    let workspace_root = crate_dir.parent().and_then(Path::parent).unwrap();
 
-    let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"))
-        .join("resources/mdtest")
-        .canonicalize()
+    let long_title = fixture_path
+        .strip_prefix(workspace_root)
+        .unwrap()
+        .to_str()
         .unwrap();
+    let short_title = fixture_path.file_name().and_then(OsStr::to_str).unwrap();
 
-    let relative_path = path
-        .strip_prefix(crate_dir.to_str().unwrap())
-        .unwrap_or(path);
-
-    run(Path::new(path), relative_path);
+    red_knot_test::run(fixture_path, long_title, short_title);
 }

crates/red_knot_server/src/edit.rs

@@ -6,7 +6,7 @@ mod text_document;
 
 use lsp_types::{PositionEncodingKind, Url};
 pub use notebook::NotebookDocument;
-pub(crate) use range::RangeExt;
+pub(crate) use range::{RangeExt, ToRangeExt};
 pub(crate) use text_document::DocumentVersion;
 pub use text_document::TextDocument;