Use Invalid context when keyword used as identifier

## Summary

Resolves #14648.

## Test Plan

Markdown tests.

---------

Co-authored-by: Carl Meyer <carl@astral.sh>

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

@@ -13,9 +13,10 @@
 # flake8-pyi
 /crates/ruff_linter/src/rules/flake8_pyi/ @AlexWaygood
 
-# Script for fuzzing the parser
-/scripts/fuzz-parser/ @AlexWaygood
+# Script for fuzzing the parser/red-knot etc.
+/python/py-fuzzer/ @AlexWaygood
 
 # red-knot
 /crates/red_knot* @carljm @MichaReiser @AlexWaygood @sharkdp
 /crates/ruff_db/ @carljm @MichaReiser @AlexWaygood @sharkdp
+/scripts/knot_benchmark/ @carljm @MichaReiser @AlexWaygood @sharkdp

.github/workflows/ci.yaml

@@ -49,7 +49,7 @@ jobs:
               - crates/ruff_text_size/**
               - crates/ruff_python_ast/**
               - crates/ruff_python_parser/**
-              - scripts/fuzz-parser/**
+              - python/py-fuzzer/**
               - .github/workflows/ci.yaml
 
             linter:
@@ -82,6 +82,7 @@ jobs:
             code:
               - "**/*"
               - "!**/*.md"
+              - "crates/red_knot_python_semantic/resources/mdtest/**/*.md"
               - "!docs/**"
               - "!assets/**"
 
@@ -115,7 +116,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 +158,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 +225,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 +240,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 +284,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 +307,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
@@ -289,13 +318,7 @@ jobs:
       FORCE_COLOR: 1
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Install uv
-        run: curl -LsSf https://astral.sh/uv/install.sh | sh
-      - name: Install Python requirements
-        run: uv pip install -r scripts/fuzz-parser/requirements.txt --system
+      - uses: astral-sh/setup-uv@v4
       - uses: actions/download-artifact@v4
         name: Download Ruff binary to test
         id: download-cached-binary
@@ -307,7 +330,15 @@ 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
+          (
+            uvx \
+            --python=${{ env.PYTHON_VERSION }} \
+            --from=./python/py-fuzzer \
+            fuzz \
+            --test-executable=${{ steps.download-cached-binary.outputs.download-path }}/ruff \
+            --bin=ruff \
+            0-500
+          )
 
   scripts:
     name: "test scripts"
@@ -331,7 +362,7 @@ jobs:
 
   ecosystem:
     name: "ecosystem"
-    runs-on: ubuntu-latest
+    runs-on: depot-ubuntu-latest-8
     needs:
       - cargo-test-linux
       - determine_changes
@@ -352,7 +383,7 @@ jobs:
           name: ruff
           path: target/debug
 
-      - uses: dawidd6/action-download-artifact@v6
+      - uses: dawidd6/action-download-artifact@v7
         name: Download baseline Ruff binary
         with:
           name: ruff
@@ -528,7 +559,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: Install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
       - uses: Swatinem/rust-cache@v2
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
@@ -561,12 +592,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

@@ -32,13 +32,7 @@ jobs:
     if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-      - name: Install uv
-        run: curl -LsSf https://astral.sh/uv/install.sh | sh
-      - name: Install Python requirements
-        run: uv pip install -r scripts/fuzz-parser/requirements.txt --system
+      - uses: astral-sh/setup-uv@v4
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
@@ -49,7 +43,16 @@ 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: |
+          (
+            uvx \
+            --python=3.12 \
+            --from=./python/py-fuzzer \
+            fuzz \
+            --test-executable=target/debug/ruff \
+            --bin=ruff \
+            $(shuf -i 0-9999999999999999999 -n 1000)
+          )
 
   create-issue-on-failure:
     name: Create an issue if the daily fuzz surfaced any bugs

.github/workflows/pr-comment.yaml

@@ -17,7 +17,7 @@ jobs:
   comment:
     runs-on: ubuntu-latest
     steps:
-      - uses: dawidd6/action-download-artifact@v6
+      - uses: dawidd6/action-download-artifact@v7
         name: Download pull request number
         with:
           name: pr-number
@@ -33,7 +33,7 @@ jobs:
             echo "pr-number=$(<pr-number)" >> $GITHUB_OUTPUT
           fi
 
-      - uses: dawidd6/action-download-artifact@v6
+      - uses: dawidd6/action-download-artifact@v7
         name: "Download ecosystem results"
         id: download-ecosystem-result
         if: steps.pr-number.outputs.pr-number

.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.12.1
+        uses: cloudflare/wrangler-action@v3.13.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/publish-pypi.yml

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

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

.pre-commit-config.yaml

@@ -17,12 +17,12 @@ exclude: |
 
 repos:
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.22
+    rev: v0.23
     hooks:
       - id: validate-pyproject
 
   - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.18
+    rev: 0.7.19
     hooks:
       - id: mdformat
         additional_dependencies:
@@ -36,7 +36,7 @@ repos:
           )$
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.42.0
+    rev: v0.43.0
     hooks:
       - id: markdownlint-fix
         exclude: |
@@ -59,7 +59,7 @@ repos:
           - black==24.10.0
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.27.3
+    rev: v1.28.1
     hooks:
       - id: typos
 
@@ -73,7 +73,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.3
+    rev: v0.8.1
     hooks:
       - id: ruff-format
       - id: ruff
@@ -83,7 +83,7 @@ repos:
 
   # Prettier
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.3.3
+    rev: v3.4.1
     hooks:
       - id: prettier
         types: [yaml]

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
@@ -167,7 +192,7 @@ flag or `unsafe-fixes` configuration option can be used to enable unsafe fixes.
 
 See the [docs](https://docs.astral.sh/ruff/configuration/#fix-safety) for details.
 
-### Remove formatter-conflicting rules from the default rule set  ([#7900](https://github.com/astral-sh/ruff/pull/7900))
+### Remove formatter-conflicting rules from the default rule set ([#7900](https://github.com/astral-sh/ruff/pull/7900))
 
 Previously, Ruff enabled all implemented rules in Pycodestyle (`E`) by default. Ruff now only includes the
 Pycodestyle prefixes `E4`, `E7`, and `E9` to exclude rules that conflict with automatic formatters. Consequently,

CHANGELOG.md

@@ -1,5 +1,145 @@
 # Changelog
 
+## 0.8.1
+
+### Preview features
+
+- Formatter: Avoid invalid syntax for format-spec with quotes for all Python versions ([#14625](https://github.com/astral-sh/ruff/pull/14625))
+- Formatter: Consider quotes inside format-specs when choosing the quotes for an f-string ([#14493](https://github.com/astral-sh/ruff/pull/14493))
+- Formatter: Do not consider f-strings with escaped newlines as multiline ([#14624](https://github.com/astral-sh/ruff/pull/14624))
+- Formatter: Fix f-string formatting in assignment statement ([#14454](https://github.com/astral-sh/ruff/pull/14454))
+- Formatter: Fix unnecessary space around power operator (`**`) in overlong f-string expressions ([#14489](https://github.com/astral-sh/ruff/pull/14489))
+- \[`airflow`\] Avoid implicit `schedule` argument to `DAG` and `@dag` (`AIR301`) ([#14581](https://github.com/astral-sh/ruff/pull/14581))
+- \[`flake8-builtins`\] Exempt private built-in modules (`A005`) ([#14505](https://github.com/astral-sh/ruff/pull/14505))
+- \[`flake8-pytest-style`\] Fix `pytest.mark.parametrize` rules to check calls instead of decorators ([#14515](https://github.com/astral-sh/ruff/pull/14515))
+- \[`flake8-type-checking`\] Implement `runtime-cast-value` (`TC006`) ([#14511](https://github.com/astral-sh/ruff/pull/14511))
+- \[`flake8-type-checking`\] Implement `unquoted-type-alias` (`TC007`) and `quoted-type-alias` (`TC008`) ([#12927](https://github.com/astral-sh/ruff/pull/12927))
+- \[`flake8-use-pathlib`\] Recommend `Path.iterdir()` over `os.listdir()` (`PTH208`) ([#14509](https://github.com/astral-sh/ruff/pull/14509))
+- \[`pylint`\] Extend `invalid-envvar-default` to detect `os.environ.get` (`PLW1508`) ([#14512](https://github.com/astral-sh/ruff/pull/14512))
+- \[`pylint`\] Implement `len-test` (`PLC1802`) ([#14309](https://github.com/astral-sh/ruff/pull/14309))
+- \[`refurb`\] Fix bug where methods defined using lambdas were flagged by `FURB118` ([#14639](https://github.com/astral-sh/ruff/pull/14639))
+- \[`ruff`\] Auto-add `r` prefix when string has no backslashes for `unraw-re-pattern` (`RUF039`) ([#14536](https://github.com/astral-sh/ruff/pull/14536))
+- \[`ruff`\] Implement `invalid-assert-message-literal-argument` (`RUF040`) ([#14488](https://github.com/astral-sh/ruff/pull/14488))
+- \[`ruff`\] Implement `unnecessary-nested-literal` (`RUF041`) ([#14323](https://github.com/astral-sh/ruff/pull/14323))
+- \[`ruff`\] Implement `unnecessary-regular-expression` (`RUF055`) ([#14659](https://github.com/astral-sh/ruff/pull/14659))
+
+### Rule changes
+
+- Ignore more rules for stub files ([#14541](https://github.com/astral-sh/ruff/pull/14541))
+- \[`pep8-naming`\] Eliminate false positives for single-letter names (`N811`, `N814`) ([#14584](https://github.com/astral-sh/ruff/pull/14584))
+- \[`pyflakes`\] Avoid false positives in `@no_type_check` contexts (`F821`, `F722`) ([#14615](https://github.com/astral-sh/ruff/pull/14615))
+- \[`ruff`\] Detect redirected-noqa in file-level comments (`RUF101`) ([#14635](https://github.com/astral-sh/ruff/pull/14635))
+- \[`ruff`\] Mark fixes for `unsorted-dunder-all` and `unsorted-dunder-slots` as unsafe when there are complex comments in the sequence (`RUF022`, `RUF023`) ([#14560](https://github.com/astral-sh/ruff/pull/14560))
+
+### Bug fixes
+
+- Avoid fixing code to `None | None` for `redundant-none-literal` (`PYI061`) and `never-union` (`RUF020`) ([#14583](https://github.com/astral-sh/ruff/pull/14583), [#14589](https://github.com/astral-sh/ruff/pull/14589))
+- \[`flake8-bugbear`\] Fix `mutable-contextvar-default` to resolve annotated function calls properly (`B039`) ([#14532](https://github.com/astral-sh/ruff/pull/14532))
+- \[`flake8-pyi`, `ruff`\] Fix traversal of nested literals and unions (`PYI016`, `PYI051`, `PYI055`, `PYI062`, `RUF041`) ([#14641](https://github.com/astral-sh/ruff/pull/14641))
+- \[`flake8-pyi`\] Avoid rewriting invalid type expressions in `unnecessary-type-union` (`PYI055`) ([#14660](https://github.com/astral-sh/ruff/pull/14660))
+- \[`flake8-type-checking`\] Avoid syntax errors and type checking problem for quoted annotations autofix (`TC003`, `TC006`) ([#14634](https://github.com/astral-sh/ruff/pull/14634))
+- \[`pylint`\] Do not wrap function calls in parentheses in the fix for unnecessary-dunder-call (`PLC2801`) ([#14601](https://github.com/astral-sh/ruff/pull/14601))
+- \[`ruff`\] Handle `attrs`'s `auto_attribs` correctly (`RUF009`) ([#14520](https://github.com/astral-sh/ruff/pull/14520))
+
+## 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
@@ -117,7 +257,7 @@
 ### Preview features
 
 - Fix `E221` and `E222` to flag missing or extra whitespace around `==` operator ([#13890](https://github.com/astral-sh/ruff/pull/13890))
-- Formatter: Alternate quotes for strings inside f-strings in preview  ([#13860](https://github.com/astral-sh/ruff/pull/13860))
+- Formatter: Alternate quotes for strings inside f-strings in preview ([#13860](https://github.com/astral-sh/ruff/pull/13860))
 - Formatter: Join implicit concatenated strings when they fit on a line ([#13663](https://github.com/astral-sh/ruff/pull/13663))
 - \[`pylint`\] Restrict `iteration-over-set` to only work on sets of literals (`PLC0208`) ([#13731](https://github.com/astral-sh/ruff/pull/13731))
 
@@ -978,7 +1118,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
@@ -1132,7 +1272,7 @@ To read more about this exciting milestone, check out our [blog post](https://as
 ### Preview features
 
 - \[`pycodestyle`\] Ignore end-of-line comments when determining blank line rules ([#11342](https://github.com/astral-sh/ruff/pull/11342))
-- \[`pylint`\] Detect `pathlib.Path.open` calls in `unspecified-encoding` (`PLW1514`)  ([#11288](https://github.com/astral-sh/ruff/pull/11288))
+- \[`pylint`\] Detect `pathlib.Path.open` calls in `unspecified-encoding` (`PLW1514`) ([#11288](https://github.com/astral-sh/ruff/pull/11288))
 - \[`flake8-pyi`\] Implement `PYI059` (`generic-not-last-base-class`) ([#11233](https://github.com/astral-sh/ruff/pull/11233))
 - \[`flake8-pyi`\] Implement `PYI062` (`duplicate-literal-member`) ([#11269](https://github.com/astral-sh/ruff/pull/11269))
 
@@ -1507,7 +1647,7 @@ To setup `ruff server` with your editor, refer to the [README.md](https://github
 - \[`pycodestyle`\] Do not ignore lines before the first logical line in blank lines rules. ([#10382](https://github.com/astral-sh/ruff/pull/10382))
 - \[`pycodestyle`\] Do not trigger `E225` and `E275` when the next token is a ')' ([#10315](https://github.com/astral-sh/ruff/pull/10315))
 - \[`pylint`\] Avoid false-positive slot non-assignment for `__dict__` (`PLE0237`) ([#10348](https://github.com/astral-sh/ruff/pull/10348))
-- Gate f-string struct size test for Rustc \< 1.76 ([#10371](https://github.com/astral-sh/ruff/pull/10371))
+- Gate f-string struct size test for Rustc < 1.76 ([#10371](https://github.com/astral-sh/ruff/pull/10371))
 
 ### Documentation
 

CONTRIBUTING.md

@@ -139,7 +139,7 @@ At a high level, the steps involved in adding a new lint rule are as follows:
 1. Create a file for your rule (e.g., `crates/ruff_linter/src/rules/flake8_bugbear/rules/assert_false.rs`).
 
 1. In that file, define a violation struct (e.g., `pub struct AssertFalse`). You can grep for
-    `#[violation]` to see examples.
+    `#[derive(ViolationMetadata)]` to see examples.
 
 1. In that file, define a function that adds the violation to the diagnostic list as appropriate
     (e.g., `pub(crate) fn assert_false`) based on whatever inputs are required for the rule (e.g.,
@@ -863,7 +863,7 @@ each configuration file.
 
 The package root is used to determine a file's "module path". Consider, again, `baz.py`. In that
 case, `./my_project/src/foo` was identified as the package root, so the module path for `baz.py`
-would resolve to  `foo.bar.baz` — as computed by taking the relative path from the package root
+would resolve to `foo.bar.baz` — as computed by taking the relative path from the package root
 (inclusive of the root itself). The module path can be thought of as "the path you would use to
 import the module" (e.g., `import foo.bar.baz`).
 

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,7 +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" }
+indexmap = { version = "2.6.0" }
 indicatif = { version = "0.17.8" }
 indoc = { version = "2.0.4" }
 insta = { version = "1.35.1" }
@@ -110,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" }
@@ -150,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" }
@@ -247,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
@@ -281,13 +282,13 @@ 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
@@ -296,14 +297,10 @@ local-artifacts-jobs = ["./build-binaries", "./build-docker"]
 # Publish jobs to run in CI
 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.4/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.7.4/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.8.1/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.8.1/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.4
+  rev: v0.8.1
   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`

clippy.toml

@@ -1,21 +1,25 @@
 doc-valid-idents = [
-  "..",
-  "CodeQL",
-  "FastAPI",
-  "IPython",
-  "LangChain",
-  "LibCST",
-  "McCabe",
-  "NumPy",
-  "SCREAMING_SNAKE_CASE",
-  "SQLAlchemy",
-  "StackOverflow",
-  "PyCharm",
+    "..",
+    "CodeQL",
+    "FastAPI",
+    "IPython",
+    "LangChain",
+    "LibCST",
+    "McCabe",
+    "NumPy",
+    "SCREAMING_SNAKE_CASE",
+    "SQLAlchemy",
+    "StackOverflow",
+    "PyCharm",
+    "SNMPv1",
+    "SNMPv2",
+    "SNMPv3",
+    "PyFlakes"
 ]
 
 ignore-interior-mutability = [
-  # Interned is read-only. The wrapped `Rc` never gets updated.
-  "ruff_formatter::format_element::Interned",
-  # The expression is read-only.
-  "ruff_python_ast::hashable::HashableExpr",
+    # Interned is read-only. The wrapped `Rc` never gets updated.
+    "ruff_formatter::format_element::Interned",
+    # The expression is read-only.
+    "ruff_python_ast::hashable::HashableExpr",
 ]

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/docs/tracing.md

@@ -103,7 +103,7 @@ called **once**.
 
 ## Profiling
 
-Red Knot generates a folded stack trace  to the current directory named `tracing.folded` when setting the environment variable `RED_KNOT_LOG_PROFILE` to `1` or `true`.
+Red Knot generates a folded stack trace to the current directory named `tracing.folded` when setting the environment variable `RED_KNOT_LOG_PROFILE` to `1` or `true`.
 
 ```bash
 RED_KNOT_LOG_PROFILE=1 red_knot -- --current-directory=../test -vvv

crates/red_knot/src/main.rs

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

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

@@ -13,7 +13,7 @@ license = { workspace = true }
 [dependencies]
 ruff_db = { workspace = true }
 ruff_index = { workspace = true }
-ruff_python_ast = { workspace = true, features = ["salsa"] }
+ruff_python_ast = { workspace = true }
 ruff_python_parser = { workspace = true }
 ruff_python_stdlib = { workspace = true }
 ruff_source_file = { workspace = true }
@@ -33,6 +33,7 @@ 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 }

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

@@ -0,0 +1,128 @@
+# `LiteralString`
+
+`LiteralString` represents a string that is either defined directly within the source code or is
+made up of such components.
+
+Parts of the testcases defined here were adapted from [the specification's examples][1].
+
+## Usages
+
+### Valid places
+
+It can be used anywhere a type is accepted:
+
+```py
+from typing import LiteralString
+
+x: LiteralString
+
+def f():
+    reveal_type(x)  # revealed: LiteralString
+```
+
+### Within `Literal`
+
+`LiteralString` cannot be used within `Literal`:
+
+```py
+from typing import Literal, LiteralString
+
+bad_union: Literal["hello", LiteralString]  # error: [invalid-literal-parameter]
+bad_nesting: Literal[LiteralString]  # error: [invalid-literal-parameter]
+```
+
+### Parametrized
+
+`LiteralString` cannot be parametrized.
+
+```py
+from typing import LiteralString
+
+a: LiteralString[str]  # error: [invalid-type-parameter]
+b: LiteralString["foo"]  # error: [invalid-type-parameter]
+```
+
+### As a base class
+
+Subclassing `LiteralString` leads to a runtime error.
+
+```py
+from typing import LiteralString
+
+class C(LiteralString): ...  # error: [invalid-base]
+```
+
+## Inference
+
+### Common operations
+
+```py
+foo: LiteralString = "foo"
+reveal_type(foo)  # revealed: Literal["foo"]
+
+bar: LiteralString = "bar"
+reveal_type(foo + bar)  # revealed: Literal["foobar"]
+
+baz: LiteralString = "baz"
+baz += foo
+reveal_type(baz)  # revealed: Literal["bazfoo"]
+
+qux = (foo, bar)
+reveal_type(qux)  # revealed: tuple[Literal["foo"], Literal["bar"]]
+
+# TODO: Infer "LiteralString"
+reveal_type(foo.join(qux))  # revealed: @Todo(call todo)
+
+template: LiteralString = "{}, {}"
+reveal_type(template)  # revealed: Literal["{}, {}"]
+# TODO: Infer `LiteralString`
+reveal_type(template.format(foo, bar))  # revealed: @Todo(call todo)
+```
+
+### Assignability
+
+`Literal[""]` is assignable to `LiteralString`, and `LiteralString` is assignable to `str`, but not
+vice versa.
+
+```py
+def coinflip() -> bool:
+    return True
+
+foo_1: Literal["foo"] = "foo"
+bar_1: LiteralString = foo_1  # fine
+
+foo_2 = "foo" if coinflip() else "bar"
+reveal_type(foo_2)  # revealed: Literal["foo", "bar"]
+bar_2: LiteralString = foo_2  # fine
+
+foo_3: LiteralString = "foo" * 1_000_000_000
+bar_3: str = foo_2  # fine
+
+baz_1: str = str()
+qux_1: LiteralString = baz_1  # error: [invalid-assignment]
+
+baz_2: LiteralString = "baz" * 1_000_000_000
+qux_2: Literal["qux"] = baz_2  # error: [invalid-assignment]
+
+baz_3 = "foo" if coinflip() else 1
+reveal_type(baz_3)  # revealed: Literal["foo"] | Literal[1]
+qux_3: LiteralString = baz_3  # error: [invalid-assignment]
+```
+
+### Narrowing
+
+```py
+lorem: LiteralString = "lorem" * 1_000_000_000
+
+reveal_type(lorem)  # revealed: LiteralString
+
+if lorem == "ipsum":
+    reveal_type(lorem)  # revealed: Literal["ipsum"]
+
+reveal_type(lorem)  # revealed: LiteralString
+
+if "" < lorem == "ipsum":
+    reveal_type(lorem)  # revealed: Literal["ipsum"]
+```
+
+[1]: https://typing.readthedocs.io/en/latest/spec/literal.html#literalstring

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

@@ -9,10 +9,10 @@ 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
+    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
+reveal_type(append_int(True, "a"))  # revealed: @Todo(full tuple[...] support)
 ```

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

@@ -189,3 +189,31 @@ 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]

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

@@ -317,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
@@ -325,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`:
@@ -334,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/function.md

@@ -16,7 +16,7 @@ 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
@@ -44,7 +44,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

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

@@ -50,11 +50,11 @@ def foo(
         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/expression/if.md

@@ -22,3 +22,22 @@ 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

@@ -18,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]
 ```
@@ -39,7 +39,7 @@ 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
@@ -60,52 +60,20 @@ reveal_type(S)  # revealed: Literal[S]
 
 ## Type params
 
-A PEP695 type variable defines a value of type `typing.TypeVar` with attributes `__name__`,
-`__bounds__`, `__constraints__`, and `__default__` (the latter three all lazily evaluated):
+A PEP695 type variable defines a value of type `typing.TypeVar`.
 
 ```py
-def f[T, U: A, V: (A, B), W = A, X: A = A1]():
+def f[T]():
     reveal_type(T)  # revealed: T
     reveal_type(T.__name__)  # revealed: Literal["T"]
-    reveal_type(T.__bound__)  # revealed: None
-    reveal_type(T.__constraints__)  # revealed: tuple[()]
-    reveal_type(T.__default__)  # revealed: NoDefault
-
-    reveal_type(U)  # revealed: U
-    reveal_type(U.__name__)  # revealed: Literal["U"]
-    reveal_type(U.__bound__)  # revealed: type[A]
-    reveal_type(U.__constraints__)  # revealed: tuple[()]
-    reveal_type(U.__default__)  # revealed: NoDefault
-
-    reveal_type(V)  # revealed: V
-    reveal_type(V.__name__)  # revealed: Literal["V"]
-    reveal_type(V.__bound__)  # revealed: None
-    reveal_type(V.__constraints__)  # revealed: tuple[type[A], type[B]]
-    reveal_type(V.__default__)  # revealed: NoDefault
-
-    reveal_type(W)  # revealed: W
-    reveal_type(W.__name__)  # revealed: Literal["W"]
-    reveal_type(W.__bound__)  # revealed: None
-    reveal_type(W.__constraints__)  # revealed: tuple[()]
-    reveal_type(W.__default__)  # revealed: type[A]
-
-    reveal_type(X)  # revealed: X
-    reveal_type(X.__name__)  # revealed: Literal["X"]
-    reveal_type(X.__bound__)  # revealed: type[A]
-    reveal_type(X.__constraints__)  # revealed: tuple[()]
-    reveal_type(X.__default__)  # revealed: type[A1]
-
-class A: ...
-class B: ...
-class A1(A): ...
 ```
 
 ## Minimum two constraints
 
-A typevar with less than two constraints emits a diagnostic and is treated as unconstrained:
+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,)]():
-    reveal_type(T.__constraints__)  # revealed: tuple[()]
+    pass
 ```

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

@@ -51,6 +51,8 @@ invalid1: Literal[3 + 4]
 invalid2: Literal[4 + 3j]
 # error: [invalid-literal-parameter]
 invalid3: Literal[(3, 4)]
+
+hello = "hello"
 invalid4: Literal[
     1 + 2,  # error: [invalid-literal-parameter]
     "foo",
@@ -76,7 +78,7 @@ from other import Literal
 a1: Literal[26]
 
 def f():
-    reveal_type(a1)  # revealed: @Todo
+    reveal_type(a1)  # revealed: @Todo(generics)
 ```
 
 ## Detecting typing_extensions.Literal

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

@@ -171,7 +171,7 @@ def f(*args, **kwargs) -> int: ...
 class A(metaclass=f): ...
 
 # TODO should be `type[int]`
-reveal_type(A.__class__)  # revealed: @Todo
+reveal_type(A.__class__)  # revealed: @Todo(metaclass not a class)
 ```
 
 ## Cyclic

crates/red_knot_python_semantic/resources/mdtest/mro.md

@@ -256,7 +256,7 @@ class O: ...
 class X(O): ...
 class Y(O): ...
 
-if bool():
+if returns_bool():
     foo = Y
 else:
     foo = object

crates/red_knot_python_semantic/resources/mdtest/narrow/bool-call.md

@@ -0,0 +1,32 @@
+## Narrowing for `bool(..)` checks
+
+```py
+def flag() -> bool: ...
+
+x = 1 if flag() else None
+
+# valid invocation, positive
+reveal_type(x)  # revealed: Literal[1] | None
+if bool(x is not None):
+    reveal_type(x)  # revealed: Literal[1]
+
+# valid invocation, negative
+reveal_type(x)  # revealed: Literal[1] | None
+if not bool(x is not None):
+    reveal_type(x)  # revealed: None
+
+# no args/narrowing
+reveal_type(x)  # revealed: Literal[1] | None
+if not bool():
+    reveal_type(x)  # revealed: Literal[1] | None
+
+# invalid invocation, too many positional args
+reveal_type(x)  # revealed: Literal[1] | None
+if bool(x is not None, 5):  # TODO diagnostic
+    reveal_type(x)  # revealed: Literal[1] | None
+
+# invalid invocation, too many kwargs
+reveal_type(x)  # revealed: Literal[1] | None
+if bool(x is not None, y=5):  # TODO diagnostic
+    reveal_type(x)  # revealed: Literal[1] | None
+```

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

@@ -0,0 +1,64 @@
+# Consolidating narrowed types after if statement
+
+## After if-else statements, narrowing has no effect if the variable is not mutated in any branch
+
+```py
+def optional_int() -> int | None: ...
+
+x = optional_int()
+
+if x is None:
+    pass
+else:
+    pass
+
+reveal_type(x)  # revealed: int | None
+```
+
+## Narrowing can have a persistent effect if the variable is mutated in one branch
+
+```py
+def optional_int() -> int | None: ...
+
+x = optional_int()
+
+if x is None:
+    x = 10
+else:
+    pass
+
+reveal_type(x)  # revealed: int
+```
+
+## An if statement without an explicit `else` branch is equivalent to one with a no-op `else` branch
+
+```py
+def optional_int() -> int | None: ...
+
+x = optional_int()
+y = optional_int()
+
+if x is None:
+    x = 0
+
+if y is None:
+    pass
+
+reveal_type(x)  # revealed: int
+reveal_type(y)  # revealed: int | None
+```
+
+## An if-elif without an explicit else branch is equivalent to one with an empty else branch
+
+```py
+def optional_int() -> int | None: ...
+
+x = optional_int()
+
+if x is None:
+    x = 0
+elif x > 50:
+    x = 50
+
+reveal_type(x)  # revealed: int
+```

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/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
@@ -64,7 +63,7 @@ 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
@@ -96,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/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

@@ -21,10 +21,11 @@ reveal_type(Identity[0])  # revealed: str
 ## Class getitem union
 
 ```py
-flag = True
+def bool_instance() -> bool:
+    return True
 
 class UnionClassGetItem:
-    if flag:
+    if bool_instance():
 
         def __class_getitem__(cls, item: int) -> str:
             return item
@@ -59,9 +60,10 @@ reveal_type(x[0])  # revealed: str | int
 ## Class getitem with unbound method union
 
 ```py
-flag = True
+def bool_instance() -> bool:
+    return True
 
-if flag:
+if bool_instance():
     class Spam:
         def __class_getitem__(self, x: int) -> str:
             return "foo"
@@ -77,9 +79,10 @@ reveal_type(Spam[42])
 ## TODO: Class getitem non-class union
 
 ```py
-flag = True
+def bool_instance() -> bool:
+    return True
 
-if flag:
+if bool_instance():
     class Eggs:
         def __class_getitem__(self, x: int) -> str:
             return "foo"

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

@@ -30,10 +30,11 @@ reveal_type(Identity()[0])  # revealed: int
 ## Getitem union
 
 ```py
-flag = True
+def bool_instance() -> bool:
+    return True
 
 class Identity:
-    if flag:
+    if bool_instance():
 
         def __getitem__(self, index: int) -> int:
             return index

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

@@ -22,23 +22,23 @@ type:
 ```py
 import sys
 
-reveal_type(sys.version_info >= (3, 8))  # revealed: Literal[True]
-reveal_type((3, 8) <= 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, 8))  # revealed: Literal[True]
-reveal_type((3, 8) < 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, 8))  # revealed: Literal[False]
-reveal_type((3, 8) > 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, 8))  # revealed: Literal[False]
-reveal_type((3, 8) >= 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, 8))  # revealed: Literal[False]
-reveal_type((3, 8) == 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, 8))  # revealed: Literal[True]
-reveal_type((3, 8) != 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]
 ```
 
 ## Non-literal types from comparisons
@@ -49,17 +49,16 @@ sometimes not:
 ```py
 import sys
 
-reveal_type(sys.version_info >= (3, 8, 1))  # revealed: bool
-reveal_type(sys.version_info >= (3, 8, 1, "final", 0))  # revealed: bool
+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, 8, 1, "final", 0, 5))  # revealed: bool
+reveal_type(sys.version_info >= (3, 9, 1, "final", 0, 5))  # revealed: bool
 
-# TODO: this should be `Literal[False]`; see #14279
-reveal_type(sys.version_info == (3, 8, 1, "finallllll", 0))  # revealed: bool
+reveal_type(sys.version_info == (3, 8, 1, "finallllll", 0))  # revealed: Literal[False]
 ```
 
 ## Imports and aliases
@@ -71,11 +70,11 @@ another name:
 from sys import version_info
 from sys import version_info as foo
 
-reveal_type(version_info >= (3, 8))  # revealed: Literal[True]
-reveal_type(foo >= (3, 8))  # revealed: Literal[True]
+reveal_type(version_info >= (3, 9))  # revealed: Literal[True]
+reveal_type(foo >= (3, 9))  # revealed: Literal[True]
 
 bar = version_info
-reveal_type(bar >= (3, 8))  # revealed: Literal[True]
+reveal_type(bar >= (3, 9))  # revealed: Literal[True]
 ```
 
 ## Non-stdlib modules named `sys`
@@ -92,7 +91,7 @@ version_info: tuple[int, int] = (4, 2)
 ```py path=package/script.py
 from .sys import version_info
 
-reveal_type(version_info >= (3, 8))  # revealed: bool
+reveal_type(version_info >= (3, 9))  # revealed: bool
 ```
 
 ## Accessing fields by name
@@ -103,8 +102,8 @@ The fields of `sys.version_info` can be accessed by name:
 import sys
 
 reveal_type(sys.version_info.major >= 3)  # revealed: Literal[True]
-reveal_type(sys.version_info.minor >= 8)  # revealed: Literal[True]
-reveal_type(sys.version_info.minor >= 9)  # revealed: Literal[False]
+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
@@ -113,9 +112,9 @@ properties on instance types:
 ```py path=b.py
 import sys
 
-reveal_type(sys.version_info.micro)  # revealed: @Todo
-reveal_type(sys.version_info.releaselevel)  # revealed: @Todo
-reveal_type(sys.version_info.serial)  # revealed: @Todo
+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
@@ -126,14 +125,14 @@ The fields of `sys.version_info` can be accessed by index or by slice:
 import sys
 
 reveal_type(sys.version_info[0] < 3)  # revealed: Literal[False]
-reveal_type(sys.version_info[1] > 8)  # revealed: Literal[False]
+reveal_type(sys.version_info[1] > 9)  # revealed: Literal[False]
 
-# revealed: tuple[Literal[3], Literal[8], int, Literal["alpha", "beta", "candidate", "final"], int]
+# 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, 8))  # revealed: Literal[True]
-reveal_type(sys.version_info[0:2] >= (3, 9))  # revealed: Literal[False]
-reveal_type(sys.version_info[:3] >= (3, 9, 1))  # revealed: Literal[False]
+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/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,7 +138,7 @@ 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
 ```
@@ -222,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
 ```
@@ -233,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
 ```
 
@@ -243,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
 ```
 
@@ -253,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
 ```
@@ -265,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/module_resolver/resolver.rs

@@ -416,7 +416,7 @@ impl<'db> Iterator for SearchPathIterator<'db> {
     }
 }
 
-impl<'db> FusedIterator for SearchPathIterator<'db> {}
+impl FusedIterator for SearchPathIterator<'_> {}
 
 /// Represents a single `.pth` file in a `site-packages` directory.
 /// One or more lines in a `.pth` file may be a (relative or absolute)

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/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/ast_ids.rs

@@ -49,64 +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;
-}
-
-impl<T: HasScopedAstId> HasScopedAstId for Box<T> {
-    type Id = <T as HasScopedAstId>::Id;
-
-    fn scoped_ast_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id {
-        self.as_ref().scoped_ast_id(db, scope)
-    }
-}
-
 /// 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)
             }
         }
     };
@@ -146,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

@@ -36,12 +36,25 @@ use super::definition::{
 
 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>>,
@@ -103,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));
@@ -124,22 +152,23 @@ impl<'db> SemanticIndexBuilder<'db> {
         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());
 
         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;
@@ -589,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 {
@@ -719,7 +769,22 @@ where
                 let mut constraints = vec![constraint];
                 self.visit_body(&node.body);
                 let mut post_clauses: Vec<FlowSnapshot> = vec![];
-                for clause in &node.elif_else_clauses {
+                let elif_else_clauses = node
+                    .elif_else_clauses
+                    .iter()
+                    .map(|clause| (clause.test.as_ref(), clause.body.as_slice()));
+                let has_else = node
+                    .elif_else_clauses
+                    .last()
+                    .is_some_and(|clause| clause.test.is_none());
+                let elif_else_clauses = elif_else_clauses.chain(if has_else {
+                    // if there's an `else` clause already, we don't need to add another
+                    None
+                } else {
+                    // if there's no `else` branch, we should add a no-op `else` branch
+                    Some((None, Default::default()))
+                });
+                for (clause_test, clause_body) in elif_else_clauses {
                     // snapshot after every block except the last; the last one will just become
                     // the state that we merge the other snapshots into
                     post_clauses.push(self.flow_snapshot());
@@ -729,24 +794,15 @@ where
                     for constraint in &constraints {
                         self.record_negated_constraint(*constraint);
                     }
-                    if let Some(elif_test) = &clause.test {
+                    if let Some(elif_test) = clause_test {
                         self.visit_expr(elif_test);
                         constraints.push(self.record_expression_constraint(elif_test));
                     }
-                    self.visit_body(&clause.body);
+                    self.visit_body(clause_body);
                 }
                 for post_clause_state in post_clauses {
                     self.flow_merge(post_clause_state);
                 }
-                let has_else = node
-                    .elif_else_clauses
-                    .last()
-                    .is_some_and(|clause| clause.test.is_none());
-                if !has_else {
-                    // if there's no else clause, then it's possible we took none of the branches,
-                    // and the pre_if state can reach here
-                    self.flow_merge(pre_if);
-                }
             }
             ast::Stmt::While(ast::StmtWhile {
                 test,
@@ -763,7 +819,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.
@@ -802,7 +861,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(
@@ -829,7 +890,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);
@@ -1131,8 +1195,8 @@ where
                 // AST inspection, so we can't simplify here, need to record test expression for
                 // later checking)
                 self.visit_expr(test);
-                let constraint = self.record_expression_constraint(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);

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -83,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),
@@ -109,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)
@@ -265,6 +272,9 @@ impl<'db> DefinitionNodeRef<'db> {
             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))
             }
@@ -358,6 +368,7 @@ impl<'db> DefinitionNodeRef<'db> {
             }
             Self::Function(node) => node.into(),
             Self::Class(node) => node.into(),
+            Self::TypeAlias(node) => node.into(),
             Self::NamedExpression(node) => node.into(),
             Self::Assignment(AssignmentDefinitionNodeRef {
                 value: _,
@@ -434,6 +445,7 @@ pub enum DefinitionKind<'db> {
     ImportFrom(ImportFromDefinitionKind),
     Function(AstNodeRef<ast::StmtFunctionDef>),
     Class(AstNodeRef<ast::StmtClassDef>),
+    TypeAlias(AstNodeRef<ast::StmtTypeAlias>),
     NamedExpression(AstNodeRef<ast::ExprNamed>),
     Assignment(AssignmentDefinitionKind<'db>),
     AnnotatedAssignment(AstNodeRef<ast::StmtAnnAssign>),
@@ -456,6 +468,7 @@ impl DefinitionKind<'_> {
             // functions, classes, and imports always bind, and we consider them declarations
             DefinitionKind::Function(_)
             | DefinitionKind::Class(_)
+            | DefinitionKind::TypeAlias(_)
             | DefinitionKind::Import(_)
             | DefinitionKind::ImportFrom(_)
             | DefinitionKind::TypeVar(_)
@@ -682,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))

crates/red_knot_python_semantic/src/semantic_index/symbol.rs

@@ -116,14 +116,11 @@ 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
         )
     }
 
@@ -144,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>",
@@ -201,6 +204,7 @@ pub enum ScopeKind {
     Class,
     Function,
     Comprehension,
+    TypeAlias,
 }
 
 impl ScopeKind {
@@ -210,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>,
@@ -220,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();
     }
@@ -278,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
@@ -339,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),
@@ -360,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))
             }
@@ -400,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))
             }
@@ -424,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>),
@@ -436,9 +443,11 @@ impl NodeWithScopeKind {
         match self {
             Self::Module => ScopeKind::Module,
             Self::Class(_) => ScopeKind::Class,
-            Self::Function(_) => ScopeKind::Function,
-            Self::Lambda(_) => ScopeKind::Function,
-            Self::FunctionTypeParameters(_) | Self::ClassTypeParameters(_) => ScopeKind::Annotation,
+            Self::Function(_) | Self::Lambda(_) => ScopeKind::Function,
+            Self::FunctionTypeParameters(_)
+            | Self::ClassTypeParameters(_)
+            | Self::TypeAliasTypeParameters(_) => ScopeKind::Annotation,
+            Self::TypeAlias(_) => ScopeKind::TypeAlias,
             Self::ListComprehension(_)
             | Self::SetComprehension(_)
             | Self::DictComprehension(_)
@@ -459,6 +468,13 @@ impl NodeWithScopeKind {
             _ => 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)]
@@ -468,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

@@ -400,7 +400,7 @@ pub(crate) struct ConstraintsIterator<'map, 'db> {
     constraint_ids: ConstraintIdIterator<'map>,
 }
 
-impl<'map, 'db> Iterator for ConstraintsIterator<'map, 'db> {
+impl<'db> Iterator for ConstraintsIterator<'_, 'db> {
     type Item = Constraint<'db>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -424,7 +424,7 @@ impl DeclarationsIterator<'_, '_> {
     }
 }
 
-impl<'map, 'db> Iterator for DeclarationsIterator<'map, 'db> {
+impl<'db> Iterator for DeclarationsIterator<'_, 'db> {
     type Item = Definition<'db>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -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_index/use_def/symbol_state.rs

@@ -401,7 +401,7 @@ pub(super) struct DeclarationIdIterator<'a> {
     inner: DeclarationsIterator<'a>,
 }
 
-impl<'a> Iterator for DeclarationIdIterator<'a> {
+impl Iterator for DeclarationIdIterator<'_> {
     type Item = ScopedDefinitionId;
 
     fn next(&mut self) -> Option<Self::Item> {

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/types.rs

@@ -14,7 +14,7 @@ pub(crate) use self::infer::{
 };
 pub(crate) use self::signatures::Signature;
 use crate::module_resolver::file_to_module;
-use crate::semantic_index::ast_ids::HasScopedAstId;
+use crate::semantic_index::ast_ids::HasScopedExpressionId;
 use crate::semantic_index::definition::Definition;
 use crate::semantic_index::symbol::{self as symbol, ScopeId, ScopedSymbolId};
 use crate::semantic_index::{
@@ -47,7 +47,7 @@ pub fn check_types(db: &dyn Db, file: File) -> TypeCheckDiagnostics {
     tracing::debug!("Checking file '{path}'", path = file.path(db));
 
     let index = semantic_index(db, file);
-    let mut diagnostics = TypeCheckDiagnostics::new();
+    let mut diagnostics = TypeCheckDiagnostics::default();
 
     for scope_id in index.scope_ids() {
         let result = infer_scope_types(db, scope_id);
@@ -207,7 +207,7 @@ fn definition_expression_ty<'db>(
     let index = semantic_index(db, file);
     let file_scope = index.expression_scope_id(expression);
     let scope = file_scope.to_scope_id(db, file);
-    let expr_id = expression.scoped_ast_id(db, scope);
+    let expr_id = expression.scoped_expression_id(db, scope);
     if scope == definition.scope(db) {
         // expression is in the definition scope
         let inference = infer_definition_types(db, definition);
@@ -324,6 +324,61 @@ fn declarations_ty<'db>(
     }
 }
 
+/// Meta data for `Type::Todo`, which represents a known limitation in red-knot.
+#[cfg(debug_assertions)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum TodoType {
+    FileAndLine(&'static str, u32),
+    Message(&'static str),
+}
+
+#[cfg(debug_assertions)]
+impl std::fmt::Display for TodoType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TodoType::FileAndLine(file, line) => write!(f, "[{file}:{line}]"),
+            TodoType::Message(msg) => write!(f, "({msg})"),
+        }
+    }
+}
+
+#[cfg(not(debug_assertions))]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct TodoType;
+
+#[cfg(not(debug_assertions))]
+impl std::fmt::Display for TodoType {
+    fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
+}
+
+/// Create a `Type::Todo` variant to represent a known limitation in the type system.
+///
+/// It can be used with a custom message (preferred): `todo_type!("PEP 604 not supported")`,
+/// or simply using `todo_type!()`, which will include information about the file and line.
+#[cfg(debug_assertions)]
+macro_rules! todo_type {
+    () => {
+        Type::Todo(crate::types::TodoType::FileAndLine(file!(), line!()))
+    };
+    ($message:literal) => {
+        Type::Todo(crate::types::TodoType::Message($message))
+    };
+}
+
+#[cfg(not(debug_assertions))]
+macro_rules! todo_type {
+    () => {
+        Type::Todo(crate::types::TodoType)
+    };
+    ($message:literal) => {
+        Type::Todo(crate::types::TodoType)
+    };
+}
+
+pub(crate) use todo_type;
+
 /// Representation of a type: a set of possible values at runtime.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, salsa::Update)]
 pub enum Type<'db> {
@@ -340,7 +395,9 @@ pub enum Type<'db> {
     /// General rule: `Todo` should only propagate when the presence of the input `Todo` caused the
     /// output to be unknown. An output should only be `Todo` if fixing all `Todo` inputs to be not
     /// `Todo` would change the output type.
-    Todo,
+    ///
+    /// This variant should be created with the `todo_type!` macro.
+    Todo(TodoType),
     /// The empty set of values
     Never,
     /// A specific function object
@@ -384,7 +441,7 @@ impl<'db> Type<'db> {
     }
 
     pub const fn is_todo(&self) -> bool {
-        matches!(self, Type::Todo)
+        matches!(self, Type::Todo(_))
     }
 
     pub const fn class_literal(class: Class<'db>) -> Self {
@@ -480,6 +537,19 @@ impl<'db> Type<'db> {
             .expect("Expected a Type::IntLiteral variant")
     }
 
+    pub const fn into_known_instance(self) -> Option<KnownInstanceType<'db>> {
+        match self {
+            Type::KnownInstance(known_instance) => Some(known_instance),
+            _ => None,
+        }
+    }
+
+    #[track_caller]
+    pub fn expect_known_instance(self) -> KnownInstanceType<'db> {
+        self.into_known_instance()
+            .expect("Expected a Type::KnownInstance variant")
+    }
+
     pub const fn is_boolean_literal(&self) -> bool {
         matches!(self, Type::BooleanLiteral(..))
     }
@@ -530,8 +600,8 @@ impl<'db> Type<'db> {
             return true;
         }
         match (self, target) {
-            (Type::Unknown | Type::Any | Type::Todo, _) => false,
-            (_, Type::Unknown | Type::Any | Type::Todo) => false,
+            (Type::Unknown | Type::Any | Type::Todo(_), _) => false,
+            (_, Type::Unknown | Type::Any | Type::Todo(_)) => false,
             (Type::Never, _) => true,
             (_, Type::Never) => false,
             (_, Type::Instance(InstanceType { class }))
@@ -666,8 +736,8 @@ impl<'db> Type<'db> {
             return true;
         }
         match (self, target) {
-            (Type::Unknown | Type::Any | Type::Todo, _) => true,
-            (_, Type::Unknown | Type::Any | Type::Todo) => true,
+            (Type::Unknown | Type::Any | Type::Todo(_), _) => true,
+            (_, Type::Unknown | Type::Any | Type::Todo(_)) => true,
             (Type::Union(union), ty) => union
                 .elements(db)
                 .iter()
@@ -703,6 +773,7 @@ impl<'db> Type<'db> {
         // of `NoneType` and `NoDefaultType` in typeshed. This should not be required anymore once
         // we understand `sys.version_info` branches.
         self == other
+            || matches!((self, other), (Type::Todo(_), Type::Todo(_)))
             || matches!((self, other),
                 (
                     Type::Instance(InstanceType { class: self_class }),
@@ -726,7 +797,7 @@ impl<'db> Type<'db> {
 
             (Type::Any, _) | (_, Type::Any) => false,
             (Type::Unknown, _) | (_, Type::Unknown) => false,
-            (Type::Todo, _) | (_, Type::Todo) => false,
+            (Type::Todo(_), _) | (_, Type::Todo(_)) => false,
 
             (Type::Union(union), other) | (other, Type::Union(union)) => union
                 .elements(db)
@@ -931,7 +1002,7 @@ impl<'db> Type<'db> {
             Type::Any
             | Type::Never
             | Type::Unknown
-            | Type::Todo
+            | Type::Todo(_)
             | Type::IntLiteral(..)
             | Type::StringLiteral(..)
             | Type::BytesLiteral(..)
@@ -1007,7 +1078,10 @@ impl<'db> Type<'db> {
 
             Type::Instance(InstanceType { class }) => match class.known(db) {
                 Some(
-                    KnownClass::NoneType | KnownClass::NoDefaultType | KnownClass::VersionInfo,
+                    KnownClass::NoneType
+                    | KnownClass::NoDefaultType
+                    | KnownClass::VersionInfo
+                    | KnownClass::TypeAliasType,
                 ) => true,
                 Some(
                     KnownClass::Bool
@@ -1034,7 +1108,7 @@ impl<'db> Type<'db> {
             Type::Any
             | Type::Never
             | Type::Unknown
-            | Type::Todo
+            | Type::Todo(_)
             | Type::Union(..)
             | Type::Intersection(..)
             | Type::LiteralString => false,
@@ -1052,12 +1126,12 @@ impl<'db> Type<'db> {
             Type::Any => Type::Any.into(),
             Type::Never => {
                 // TODO: attribute lookup on Never type
-                Type::Todo.into()
+                todo_type!().into()
             }
             Type::Unknown => Type::Unknown.into(),
             Type::FunctionLiteral(_) => {
                 // TODO: attribute lookup on function type
-                Type::Todo.into()
+                todo_type!().into()
             }
             Type::ModuleLiteral(file) => {
                 // `__dict__` is a very special member that is never overridden by module globals;
@@ -1107,7 +1181,7 @@ impl<'db> Type<'db> {
                         Type::IntLiteral(Program::get(db).target_version(db).minor.into())
                     }
                     // TODO MRO? get_own_instance_member, get_instance_member
-                    _ => Type::Todo,
+                    _ => todo_type!("instance attributes"),
                 };
                 ty.into()
             }
@@ -1149,36 +1223,36 @@ impl<'db> Type<'db> {
             Type::Intersection(_) => {
                 // TODO perform the get_member on each type in the intersection
                 // TODO return the intersection of those results
-                Type::Todo.into()
+                todo_type!().into()
             }
             Type::IntLiteral(_) => {
                 // TODO raise error
-                Type::Todo.into()
+                todo_type!().into()
             }
-            Type::BooleanLiteral(_) => Type::Todo.into(),
+            Type::BooleanLiteral(_) => todo_type!().into(),
             Type::StringLiteral(_) => {
                 // TODO defer to `typing.LiteralString`/`builtins.str` methods
                 // from typeshed's stubs
-                Type::Todo.into()
+                todo_type!().into()
             }
             Type::LiteralString => {
                 // TODO defer to `typing.LiteralString`/`builtins.str` methods
                 // from typeshed's stubs
-                Type::Todo.into()
+                todo_type!().into()
             }
             Type::BytesLiteral(_) => {
                 // TODO defer to Type::Instance(<bytes from typeshed>).member
-                Type::Todo.into()
+                todo_type!().into()
             }
             Type::SliceLiteral(_) => {
                 // TODO defer to `builtins.slice` methods
-                Type::Todo.into()
+                todo_type!().into()
             }
             Type::Tuple(_) => {
                 // TODO: implement tuple methods
-                Type::Todo.into()
+                todo_type!().into()
             }
-            Type::Todo => Type::Todo.into(),
+            &todo @ Type::Todo(_) => todo.into(),
         }
     }
 
@@ -1188,7 +1262,7 @@ impl<'db> Type<'db> {
     /// when `bool(x)` is called on an object `x`.
     fn bool(&self, db: &'db dyn Db) -> Truthiness {
         match self {
-            Type::Any | Type::Todo | Type::Never | Type::Unknown => Truthiness::Ambiguous,
+            Type::Any | Type::Todo(_) | Type::Never | Type::Unknown => Truthiness::Ambiguous,
             Type::FunctionLiteral(_) => Truthiness::AlwaysTrue,
             Type::ModuleLiteral(_) => Truthiness::AlwaysTrue,
             Type::ClassLiteral(_) => {
@@ -1329,7 +1403,7 @@ impl<'db> Type<'db> {
             // `Any` is callable, and its return type is also `Any`.
             Type::Any => CallOutcome::callable(Type::Any),
 
-            Type::Todo => CallOutcome::callable(Type::Todo),
+            Type::Todo(_) => CallOutcome::callable(todo_type!("call todo")),
 
             Type::Unknown => CallOutcome::callable(Type::Unknown),
 
@@ -1342,7 +1416,7 @@ impl<'db> Type<'db> {
             ),
 
             // TODO: intersection types
-            Type::Intersection(_) => CallOutcome::callable(Type::Todo),
+            Type::Intersection(_) => CallOutcome::callable(todo_type!()),
 
             _ => CallOutcome::not_callable(self),
         }
@@ -1381,7 +1455,7 @@ impl<'db> Type<'db> {
             };
         }
 
-        if matches!(self, Type::Unknown | Type::Any | Type::Todo) {
+        if matches!(self, Type::Unknown | Type::Any | Type::Todo(_)) {
             // Explicit handling of `Unknown` and `Any` necessary until `type[Unknown]` and
             // `type[Any]` are not defined as `Todo` anymore.
             return IterationOutcome::Iterable { element_ty: self };
@@ -1440,14 +1514,14 @@ impl<'db> Type<'db> {
     pub fn to_instance(&self, db: &'db dyn Db) -> Type<'db> {
         match self {
             Type::Any => Type::Any,
-            Type::Todo => Type::Todo,
+            todo @ Type::Todo(_) => *todo,
             Type::Unknown => Type::Unknown,
             Type::Never => Type::Never,
             Type::ClassLiteral(ClassLiteralType { class }) => Type::instance(*class),
             Type::SubclassOf(SubclassOfType { class }) => Type::instance(*class),
             Type::Union(union) => union.map(db, |element| element.to_instance(db)),
             // TODO: we can probably do better here: --Alex
-            Type::Intersection(_) => Type::Todo,
+            Type::Intersection(_) => todo_type!(),
             // TODO: calling `.to_instance()` on any of these should result in a diagnostic,
             // since they already indicate that the object is an instance of some kind:
             Type::BooleanLiteral(_)
@@ -1478,7 +1552,12 @@ impl<'db> Type<'db> {
             Type::Unknown => Type::Unknown,
             // TODO map this to a new `Type::TypeVar` variant
             Type::KnownInstance(KnownInstanceType::TypeVar(_)) => *self,
-            _ => Type::Todo,
+            Type::KnownInstance(KnownInstanceType::TypeAliasType(alias)) => alias.value_ty(db),
+            Type::KnownInstance(KnownInstanceType::Never | KnownInstanceType::NoReturn) => {
+                Type::Never
+            }
+            Type::KnownInstance(KnownInstanceType::LiteralString) => Type::LiteralString,
+            _ => todo_type!(),
         }
     }
 
@@ -1553,8 +1632,8 @@ impl<'db> Type<'db> {
             // TODO: `type[Unknown]`?
             Type::Unknown => Type::Unknown,
             // TODO intersections
-            Type::Intersection(_) => Type::Todo,
-            Type::Todo => Type::Todo,
+            Type::Intersection(_) => todo_type!(),
+            todo @ Type::Todo(_) => *todo,
         }
     }
 
@@ -1642,6 +1721,7 @@ pub enum KnownClass {
     // Typing
     SpecialForm,
     TypeVar,
+    TypeAliasType,
     NoDefaultType,
     // sys
     VersionInfo,
@@ -1668,6 +1748,7 @@ impl<'db> KnownClass {
             Self::NoneType => "NoneType",
             Self::SpecialForm => "_SpecialForm",
             Self::TypeVar => "TypeVar",
+            Self::TypeAliasType => "TypeAliasType",
             Self::NoDefaultType => "_NoDefaultType",
             // This is the name the type of `sys.version_info` has in typeshed,
             // which is different to what `type(sys.version_info).__name__` is at runtime.
@@ -1706,7 +1787,7 @@ impl<'db> KnownClass {
             Self::VersionInfo => CoreStdlibModule::Sys,
             Self::GenericAlias | Self::ModuleType | Self::FunctionType => CoreStdlibModule::Types,
             Self::NoneType => CoreStdlibModule::Typeshed,
-            Self::SpecialForm | Self::TypeVar => CoreStdlibModule::Typing,
+            Self::SpecialForm | Self::TypeVar | Self::TypeAliasType => CoreStdlibModule::Typing,
             // TODO when we understand sys.version_info, we will need an explicit fallback here,
             // because typing_extensions has a 3.13+ re-export for the `typing.NoDefault`
             // singleton, but not for `typing._NoDefaultType`
@@ -1720,7 +1801,7 @@ impl<'db> KnownClass {
     const fn is_singleton(self) -> bool {
         // TODO there are other singleton types (EllipsisType, NotImplementedType)
         match self {
-            Self::NoneType | Self::NoDefaultType | Self::VersionInfo => true,
+            Self::NoneType | Self::NoDefaultType | Self::VersionInfo | Self::TypeAliasType => true,
             Self::Bool
             | Self::Object
             | Self::Bytes
@@ -1762,6 +1843,7 @@ impl<'db> KnownClass {
             "NoneType" => Self::NoneType,
             "ModuleType" => Self::ModuleType,
             "FunctionType" => Self::FunctionType,
+            "TypeAliasType" => Self::TypeAliasType,
             "_SpecialForm" => Self::SpecialForm,
             "_NoDefaultType" => Self::NoDefaultType,
             "_version_info" => Self::VersionInfo,
@@ -1795,7 +1877,7 @@ impl<'db> KnownClass {
             | Self::VersionInfo
             | Self::FunctionType => module.name() == self.canonical_module().as_str(),
             Self::NoneType => matches!(module.name().as_str(), "_typeshed" | "types"),
-            Self::SpecialForm | Self::TypeVar | Self::NoDefaultType => {
+            Self::SpecialForm | Self::TypeVar | Self::TypeAliasType | Self::NoDefaultType => {
                 matches!(module.name().as_str(), "typing" | "typing_extensions")
             }
         }
@@ -1807,24 +1889,48 @@ impl<'db> KnownClass {
 pub enum KnownInstanceType<'db> {
     /// The symbol `typing.Literal` (which can also be found as `typing_extensions.Literal`)
     Literal,
+    /// The symbol `typing.LiteralString` (which can also be found as `typing_extensions.LiteralString`)
+    LiteralString,
+    /// The symbol `typing.Optional` (which can also be found as `typing_extensions.Optional`)
+    Optional,
+    /// The symbol `typing.Union` (which can also be found as `typing_extensions.Union`)
+    Union,
+    /// The symbol `typing.NoReturn` (which can also be found as `typing_extensions.NoReturn`)
+    NoReturn,
+    /// The symbol `typing.Never` available since 3.11 (which can also be found as `typing_extensions.Never`)
+    Never,
     /// A single instance of `typing.TypeVar`
     TypeVar(TypeVarInstance<'db>),
+    /// A single instance of `typing.TypeAliasType` (PEP 695 type alias)
+    TypeAliasType(TypeAliasType<'db>),
     // TODO: fill this enum out with more special forms, etc.
 }
 
 impl<'db> KnownInstanceType<'db> {
     pub const fn as_str(self) -> &'static str {
         match self {
-            KnownInstanceType::Literal => "Literal",
-            KnownInstanceType::TypeVar(_) => "TypeVar",
+            Self::Literal => "Literal",
+            Self::LiteralString => "LiteralString",
+            Self::Optional => "Optional",
+            Self::Union => "Union",
+            Self::TypeVar(_) => "TypeVar",
+            Self::NoReturn => "NoReturn",
+            Self::Never => "Never",
+            Self::TypeAliasType(_) => "TypeAliasType",
         }
     }
 
     /// Evaluate the known instance in boolean context
     pub const fn bool(self) -> Truthiness {
         match self {
-            Self::Literal => Truthiness::AlwaysTrue,
-            Self::TypeVar(_) => Truthiness::AlwaysTrue,
+            Self::Literal
+            | Self::LiteralString
+            | Self::Optional
+            | Self::TypeVar(_)
+            | Self::Union
+            | Self::NoReturn
+            | Self::Never
+            | Self::TypeAliasType(_) => Truthiness::AlwaysTrue,
         }
     }
 
@@ -1832,7 +1938,13 @@ impl<'db> KnownInstanceType<'db> {
     pub fn repr(self, db: &'db dyn Db) -> &'db str {
         match self {
             Self::Literal => "typing.Literal",
+            Self::LiteralString => "typing.LiteralString",
+            Self::Optional => "typing.Optional",
+            Self::Union => "typing.Union",
+            Self::NoReturn => "typing.NoReturn",
+            Self::Never => "typing.Never",
             Self::TypeVar(typevar) => typevar.name(db),
+            Self::TypeAliasType(_) => "typing.TypeAliasType",
         }
     }
 
@@ -1840,7 +1952,13 @@ impl<'db> KnownInstanceType<'db> {
     pub const fn class(self) -> KnownClass {
         match self {
             Self::Literal => KnownClass::SpecialForm,
+            Self::LiteralString => KnownClass::SpecialForm,
+            Self::Optional => KnownClass::SpecialForm,
+            Self::Union => KnownClass::SpecialForm,
+            Self::NoReturn => KnownClass::SpecialForm,
+            Self::Never => KnownClass::SpecialForm,
             Self::TypeVar(_) => KnownClass::TypeVar,
+            Self::TypeAliasType(_) => KnownClass::TypeAliasType,
         }
     }
 
@@ -1859,6 +1977,11 @@ impl<'db> KnownInstanceType<'db> {
         }
         match (module.name().as_str(), instance_name) {
             ("typing" | "typing_extensions", "Literal") => Some(Self::Literal),
+            ("typing" | "typing_extensions", "LiteralString") => Some(Self::LiteralString),
+            ("typing" | "typing_extensions", "Optional") => Some(Self::Optional),
+            ("typing" | "typing_extensions", "Union") => Some(Self::Union),
+            ("typing" | "typing_extensions", "NoReturn") => Some(Self::NoReturn),
+            ("typing" | "typing_extensions", "Never") => Some(Self::Never),
             _ => None,
         }
     }
@@ -1866,23 +1989,7 @@ impl<'db> KnownInstanceType<'db> {
     fn member(self, db: &'db dyn Db, name: &str) -> Symbol<'db> {
         let ty = match (self, name) {
             (Self::TypeVar(typevar), "__name__") => Type::string_literal(db, typevar.name(db)),
-            (Self::TypeVar(typevar), "__bound__") => typevar
-                .upper_bound(db)
-                .map(|ty| ty.to_meta_type(db))
-                .unwrap_or_else(|| KnownClass::NoneType.to_instance(db)),
-            (Self::TypeVar(typevar), "__constraints__") => {
-                let tuple_elements: Vec<Type<'db>> = typevar
-                    .constraints(db)
-                    .unwrap_or_default()
-                    .iter()
-                    .map(|ty| ty.to_meta_type(db))
-                    .collect();
-                Type::tuple(db, &tuple_elements)
-            }
-            (Self::TypeVar(typevar), "__default__") => typevar
-                .default_ty(db)
-                .map(|ty| ty.to_meta_type(db))
-                .unwrap_or_else(|| KnownClass::NoDefaultType.to_instance(db)),
+            (Self::TypeAliasType(alias), "__name__") => Type::string_literal(db, alias.name(db)),
             _ => return self.instance_fallback(db).member(db, name),
         };
         ty.into()
@@ -1914,6 +2021,7 @@ pub struct TypeVarInstance<'db> {
 }
 
 impl<'db> TypeVarInstance<'db> {
+    #[allow(unused)]
     pub(crate) fn upper_bound(self, db: &'db dyn Db) -> Option<Type<'db>> {
         if let Some(TypeVarBoundOrConstraints::UpperBound(ty)) = self.bound_or_constraints(db) {
             Some(ty)
@@ -1922,7 +2030,8 @@ impl<'db> TypeVarInstance<'db> {
         }
     }
 
-    pub(crate) fn constraints(self, db: &'db dyn Db) -> Option<&[Type<'db>]> {
+    #[allow(unused)]
+    pub(crate) fn constraints(self, db: &'db dyn Db) -> Option<&'db [Type<'db>]> {
         if let Some(TypeVarBoundOrConstraints::Constraints(tuple)) = self.bound_or_constraints(db) {
             Some(tuple.elements(db))
         } else {
@@ -2466,7 +2575,7 @@ impl<'db> Class<'db> {
     ///
     /// Were this not a salsa query, then the calling query
     /// would depend on the class's AST and rerun for every change in that file.
-    fn explicit_bases(self, db: &'db dyn Db) -> &[Type<'db>] {
+    fn explicit_bases(self, db: &'db dyn Db) -> &'db [Type<'db>] {
         self.explicit_bases_query(db)
     }
 
@@ -2594,7 +2703,7 @@ impl<'db> Class<'db> {
             // TODO: If the metaclass is not a class, we should verify that it's a callable
             // which accepts the same arguments as `type.__new__` (otherwise error), and return
             // the meta-type of its return type. (And validate that is a class type?)
-            return Ok(Type::Todo);
+            return Ok(todo_type!("metaclass not a class"));
         };
 
         // Reconcile all base classes' metaclasses with the candidate metaclass.
@@ -2708,6 +2817,27 @@ impl<'db> Class<'db> {
     }
 }
 
+#[salsa::interned]
+pub struct TypeAliasType<'db> {
+    #[return_ref]
+    pub name: ast::name::Name,
+
+    rhs_scope: ScopeId<'db>,
+}
+
+#[salsa::tracked]
+impl<'db> TypeAliasType<'db> {
+    #[salsa::tracked]
+    pub fn value_ty(self, db: &'db dyn Db) -> Type<'db> {
+        let scope = self.rhs_scope(db);
+
+        let type_alias_stmt_node = scope.node(db).expect_type_alias();
+        let definition = semantic_index(db, scope.file(db)).definition(type_alias_stmt_node);
+
+        definition_expression_ty(db, definition, &type_alias_stmt_node.value)
+    }
+}
+
 /// Either the explicit `metaclass=` keyword of the class, or the inferred metaclass of one of its base classes.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(super) struct MetaclassCandidate<'db> {
@@ -2873,7 +3003,7 @@ pub struct SliceLiteralType<'db> {
     step: Option<i32>,
 }
 
-impl<'db> SliceLiteralType<'db> {
+impl SliceLiteralType<'_> {
     fn as_tuple(self, db: &dyn Db) -> (Option<i32>, Option<i32>, Option<i32>) {
         (self.start(db), self.stop(db), self.step(db))
     }
@@ -2894,6 +3024,11 @@ impl<'db> TupleType<'db> {
     }
 }
 
+// Make sure that the `Type` enum does not grow unexpectedly.
+#[cfg(not(debug_assertions))]
+#[cfg(target_pointer_width = "64")]
+static_assertions::assert_eq_size!(Type, [u8; 16]);
+
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;
@@ -2909,13 +3044,6 @@ pub(crate) mod tests {
     use ruff_python_ast as ast;
     use test_case::test_case;
 
-    #[cfg(target_pointer_width = "64")]
-    #[test]
-    fn no_bloat_enum_sizes() {
-        use std::mem::size_of;
-        assert_eq!(size_of::<Type>(), 16);
-    }
-
     pub(crate) fn setup_db() -> TestDb {
         let db = TestDb::new();
 
@@ -2969,7 +3097,7 @@ pub(crate) mod tests {
                 Ty::Unknown => Type::Unknown,
                 Ty::None => Type::none(db),
                 Ty::Any => Type::Any,
-                Ty::Todo => Type::Todo,
+                Ty::Todo => todo_type!("Ty::Todo"),
                 Ty::IntLiteral(n) => Type::IntLiteral(n),
                 Ty::StringLiteral(s) => Type::string_literal(db, s),
                 Ty::BooleanLiteral(b) => Type::BooleanLiteral(b),
@@ -3560,4 +3688,95 @@ pub(crate) mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn type_alias_types() -> anyhow::Result<()> {
+        let mut db = setup_db();
+
+        db.write_dedented(
+            "src/mod.py",
+            r#"
+            type Alias1 = int
+            type Alias2 = int
+        "#,
+        )?;
+
+        let mod_py = system_path_to_file(&db, "src/mod.py")?;
+        let ty_alias1 = global_symbol(&db, mod_py, "Alias1").expect_type();
+        let ty_alias2 = global_symbol(&db, mod_py, "Alias2").expect_type();
+
+        let Type::KnownInstance(KnownInstanceType::TypeAliasType(alias1)) = ty_alias1 else {
+            panic!("Expected TypeAliasType, got {ty_alias1:?}");
+        };
+        assert_eq!(alias1.name(&db), "Alias1");
+        assert_eq!(alias1.value_ty(&db), KnownClass::Int.to_instance(&db));
+
+        // Two type aliases are distinct and disjoint, even if they refer to the same type
+        assert!(!ty_alias1.is_equivalent_to(&db, ty_alias2));
+        assert!(ty_alias1.is_disjoint_from(&db, ty_alias2));
+
+        Ok(())
+    }
+
+    /// All other tests also make sure that `Type::Todo` works as expected. This particular
+    /// test makes sure that we handle `Todo` types correctly, even if they originate from
+    /// different sources.
+    #[test]
+    fn todo_types() {
+        let db = setup_db();
+
+        let todo1 = todo_type!("1");
+        let todo2 = todo_type!("2");
+        let todo3 = todo_type!();
+        let todo4 = todo_type!();
+
+        assert!(todo1.is_equivalent_to(&db, todo2));
+        assert!(todo3.is_equivalent_to(&db, todo4));
+        assert!(todo1.is_equivalent_to(&db, todo3));
+
+        assert!(todo1.is_subtype_of(&db, todo2));
+        assert!(todo2.is_subtype_of(&db, todo1));
+
+        assert!(todo3.is_subtype_of(&db, todo4));
+        assert!(todo4.is_subtype_of(&db, todo3));
+
+        assert!(todo1.is_subtype_of(&db, todo3));
+        assert!(todo3.is_subtype_of(&db, todo1));
+
+        let int = KnownClass::Int.to_instance(&db);
+
+        assert!(int.is_assignable_to(&db, todo1));
+        assert!(int.is_assignable_to(&db, todo3));
+
+        assert!(todo1.is_assignable_to(&db, int));
+        assert!(todo3.is_assignable_to(&db, int));
+
+        // We lose information when combining several `Todo` types. This is an
+        // acknowledged limitation of the current implementation. We can not
+        // easily store the meta information of several `Todo`s in a single
+        // variant, as `TodoType` needs to implement `Copy`, meaning it can't
+        // contain `Vec`/`Box`/etc., and can't be boxed itself.
+        //
+        // Lifting this restriction would require us to intern `TodoType` in
+        // salsa, but that would mean we would have to pass in `db` everywhere.
+
+        // A union of several `Todo` types collapses to a single `Todo` type:
+        assert!(UnionType::from_elements(&db, vec![todo1, todo2, todo3, todo4]).is_todo());
+
+        // And similar for intersection types:
+        assert!(IntersectionBuilder::new(&db)
+            .add_positive(todo1)
+            .add_positive(todo2)
+            .add_positive(todo3)
+            .add_positive(todo4)
+            .build()
+            .is_todo());
+        assert!(IntersectionBuilder::new(&db)
+            .add_positive(todo1)
+            .add_negative(todo2)
+            .add_positive(todo3)
+            .add_negative(todo4)
+            .build()
+            .is_todo());
+    }
 }

crates/red_knot_python_semantic/src/types/builder.rs

@@ -128,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()],
         }
     }
 
@@ -231,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 {
@@ -253,7 +249,7 @@ impl<'db> InnerIntersectionBuilder<'db> {
                         .iter()
                         .find(|element| element.is_boolean_literal())
                     {
-                        *self = Self::new();
+                        *self = Self::default();
                         self.positive.insert(Type::BooleanLiteral(!value));
                         return;
                     }
@@ -272,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;
                 }
@@ -285,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;
                 }
@@ -313,7 +309,7 @@ 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.
@@ -326,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));
             }
             _ => {
@@ -348,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;
                     }
@@ -383,7 +379,7 @@ mod tests {
     use crate::program::{Program, SearchPathSettings};
     use crate::python_version::PythonVersion;
     use crate::stdlib::typing_symbol;
-    use crate::types::{global_symbol, KnownClass, 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};
@@ -991,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();
 

crates/red_knot_python_semantic/src/types/diagnostic.rs

@@ -73,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));
     }
@@ -148,7 +144,7 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
         Self {
             db,
             file,
-            diagnostics: TypeCheckDiagnostics::new(),
+            diagnostics: TypeCheckDiagnostics::default(),
         }
     }
 

crates/red_knot_python_semantic/src/types/display.rs

@@ -77,7 +77,7 @@ impl Display for DisplayRepresentation<'_> {
             }
             // `[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))
             }
@@ -289,7 +289,7 @@ struct DisplayMaybeNegatedType<'db> {
     negated: bool,
 }
 
-impl<'db> Display for DisplayMaybeNegatedType<'db> {
+impl Display for DisplayMaybeNegatedType<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         if self.negated {
             f.write_str("~")?;
@@ -319,7 +319,7 @@ pub(crate) struct DisplayTypeArray<'b, 'db> {
     db: &'db dyn Db,
 }
 
-impl<'db> Display for DisplayTypeArray<'_, 'db> {
+impl Display for DisplayTypeArray<'_, '_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.join(", ")
             .entries(self.types.iter().map(|ty| ty.display(self.db)))

crates/red_knot_python_semantic/src/types/infer.rs

@@ -38,7 +38,7 @@ use salsa::plumbing::AsId;
 
 use crate::module_name::ModuleName;
 use crate::module_resolver::{file_to_module, resolve_module};
-use crate::semantic_index::ast_ids::{HasScopedAstId, HasScopedUseId, ScopedExpressionId};
+use crate::semantic_index::ast_ids::{HasScopedExpressionId, HasScopedUseId, ScopedExpressionId};
 use crate::semantic_index::definition::{
     AssignmentDefinitionKind, Definition, DefinitionKind, DefinitionNodeKey,
     ExceptHandlerDefinitionKind, TargetKind,
@@ -52,11 +52,12 @@ use crate::types::diagnostic::{TypeCheckDiagnostics, TypeCheckDiagnosticsBuilder
 use crate::types::mro::MroErrorKind;
 use crate::types::unpacker::{UnpackResult, Unpacker};
 use crate::types::{
-    bindings_ty, builtins_symbol, declarations_ty, global_symbol, symbol, typing_extensions_symbol,
-    Boundness, Class, ClassLiteralType, FunctionType, InstanceType, IntersectionBuilder,
-    IntersectionType, IterationOutcome, KnownClass, KnownFunction, KnownInstanceType,
-    MetaclassCandidate, MetaclassErrorKind, SliceLiteralType, Symbol, Truthiness, TupleType, Type,
-    TypeArrayDisplay, TypeVarBoundOrConstraints, TypeVarInstance, UnionBuilder, UnionType,
+    bindings_ty, builtins_symbol, declarations_ty, global_symbol, symbol, todo_type,
+    typing_extensions_symbol, Boundness, Class, ClassLiteralType, FunctionType, InstanceType,
+    IntersectionBuilder, IntersectionType, IterationOutcome, KnownClass, KnownFunction,
+    KnownInstanceType, MetaclassCandidate, MetaclassErrorKind, SliceLiteralType, Symbol,
+    Truthiness, TupleType, Type, TypeAliasType, TypeArrayDisplay, TypeVarBoundOrConstraints,
+    TypeVarInstance, UnionBuilder, UnionType,
 };
 use crate::unpack::Unpack;
 use crate::util::subscript::{PyIndex, PySlice};
@@ -181,7 +182,7 @@ fn infer_unpack_types<'db>(db: &'db dyn Db, unpack: Unpack<'db>) -> UnpackResult
     let scope = unpack.scope(db);
 
     let result = infer_expression_types(db, value);
-    let value_ty = result.expression_ty(value.node_ref(db).scoped_ast_id(db, scope));
+    let value_ty = result.expression_ty(value.node_ref(db).scoped_expression_id(db, scope));
 
     let mut unpacker = Unpacker::new(db, file);
     unpacker.unpack(unpack.target(db), value_ty, scope);
@@ -409,7 +410,7 @@ impl<'db> TypeInferenceBuilder<'db> {
     #[track_caller]
     fn expression_ty(&self, expr: &ast::Expr) -> Type<'db> {
         self.types
-            .expression_ty(expr.scoped_ast_id(self.db, self.scope()))
+            .expression_ty(expr.scoped_expression_id(self.db, self.scope()))
     }
 
     /// Infers types in the given [`InferenceRegion`].
@@ -438,6 +439,12 @@ impl<'db> TypeInferenceBuilder<'db> {
             NodeWithScopeKind::FunctionTypeParameters(function) => {
                 self.infer_function_type_params(function.node());
             }
+            NodeWithScopeKind::TypeAliasTypeParameters(type_alias) => {
+                self.infer_type_alias_type_params(type_alias.node());
+            }
+            NodeWithScopeKind::TypeAlias(type_alias) => {
+                self.infer_type_alias(type_alias.node());
+            }
             NodeWithScopeKind::ListComprehension(comprehension) => {
                 self.infer_list_comprehension_expression_scope(comprehension.node());
             }
@@ -605,6 +612,9 @@ impl<'db> TypeInferenceBuilder<'db> {
                 self.infer_function_definition(function.node(), definition);
             }
             DefinitionKind::Class(class) => self.infer_class_definition(class.node(), definition),
+            DefinitionKind::TypeAlias(type_alias) => {
+                self.infer_type_alias_definition(type_alias.node(), definition);
+            }
             DefinitionKind::Import(import) => {
                 self.infer_import_definition(import.node(), definition);
             }
@@ -847,6 +857,19 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.infer_parameters(&function.parameters);
     }
 
+    fn infer_type_alias_type_params(&mut self, type_alias: &ast::StmtTypeAlias) {
+        let type_params = type_alias
+            .type_params
+            .as_ref()
+            .expect("type alias type params scope without type params");
+
+        self.infer_type_parameters(type_params);
+    }
+
+    fn infer_type_alias(&mut self, type_alias: &ast::StmtTypeAlias) {
+        self.infer_annotation_expression(&type_alias.value, DeferredExpressionState::Deferred);
+    }
+
     fn infer_function_body(&mut self, function: &ast::StmtFunctionDef) {
         self.infer_body(&function.body);
     }
@@ -954,7 +977,7 @@ impl<'db> TypeInferenceBuilder<'db> {
 
         let function_ty = Type::FunctionLiteral(FunctionType::new(
             self.db,
-            &*name.id,
+            &name.id,
             function_kind,
             body_scope,
             decorator_tys,
@@ -1027,7 +1050,7 @@ impl<'db> TypeInferenceBuilder<'db> {
     ) {
         // TODO(dhruvmanila): Annotation expression is resolved at the enclosing scope, infer the
         // parameter type from there
-        let annotated_ty = Type::Todo;
+        let annotated_ty = todo_type!("function parameter type");
         if parameter.annotation.is_some() {
             self.add_declaration_with_binding(
                 parameter.into(),
@@ -1069,7 +1092,7 @@ impl<'db> TypeInferenceBuilder<'db> {
 
         let maybe_known_class = KnownClass::try_from_file(self.db, self.file, name);
 
-        let class = Class::new(self.db, &*name.id, body_scope, maybe_known_class);
+        let class = Class::new(self.db, &name.id, body_scope, maybe_known_class);
         let class_ty = Type::class_literal(class);
 
         self.add_declaration_with_binding(class_node.into(), definition, class_ty, class_ty);
@@ -1107,6 +1130,33 @@ impl<'db> TypeInferenceBuilder<'db> {
         }
     }
 
+    fn infer_type_alias_definition(
+        &mut self,
+        type_alias: &ast::StmtTypeAlias,
+        definition: Definition<'db>,
+    ) {
+        self.infer_expression(&type_alias.name);
+
+        let rhs_scope = self
+            .index
+            .node_scope(NodeWithScopeRef::TypeAlias(type_alias))
+            .to_scope_id(self.db, self.file);
+
+        let type_alias_ty =
+            Type::KnownInstance(KnownInstanceType::TypeAliasType(TypeAliasType::new(
+                self.db,
+                &type_alias.name.as_name_expr().unwrap().id,
+                rhs_scope,
+            )));
+
+        self.add_declaration_with_binding(
+            type_alias.into(),
+            definition,
+            type_alias_ty,
+            type_alias_ty,
+        );
+    }
+
     fn infer_if_statement(&mut self, if_statement: &ast::StmtIf) {
         let ast::StmtIf {
             range: _,
@@ -1215,9 +1265,10 @@ impl<'db> TypeInferenceBuilder<'db> {
             is_async,
         );
 
-        self.types
-            .expressions
-            .insert(target.scoped_ast_id(self.db, self.scope()), target_ty);
+        self.types.expressions.insert(
+            target.scoped_expression_id(self.db, self.scope()),
+            target_ty,
+        );
         self.add_binding(target.into(), definition, target_ty);
     }
 
@@ -1235,7 +1286,7 @@ impl<'db> TypeInferenceBuilder<'db> {
     ) -> Type<'db> {
         // TODO: Handle async with statements (they use `aenter` and `aexit`)
         if is_async {
-            return Type::Todo;
+            return todo_type!("async with statement");
         }
 
         let context_manager_ty = context_expression_ty.to_meta_type(self.db);
@@ -1385,12 +1436,12 @@ impl<'db> TypeInferenceBuilder<'db> {
                     self.db,
                     tuple.elements(self.db).iter().map(|ty| {
                         ty.into_class_literal()
-                            .map_or(Type::Todo, |ClassLiteralType { class }| {
+                            .map_or(todo_type!(), |ClassLiteralType { class }| {
                                 Type::instance(class)
                             })
                     }),
                 ),
-                _ => Type::Todo,
+                _ => todo_type!("exception type"),
             }
         };
 
@@ -1460,7 +1511,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             default,
         } = node;
         self.infer_optional_expression(default.as_deref());
-        self.add_declaration_with_binding(node.into(), definition, Type::Todo, Type::Todo);
+        self.add_declaration_with_binding(node.into(), definition, todo_type!(), todo_type!());
     }
 
     fn infer_typevartuple_definition(
@@ -1474,7 +1525,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             default,
         } = node;
         self.infer_optional_expression(default.as_deref());
-        self.add_declaration_with_binding(node.into(), definition, Type::Todo, Type::Todo);
+        self.add_declaration_with_binding(node.into(), definition, todo_type!(), todo_type!());
     }
 
     fn infer_match_statement(&mut self, match_statement: &ast::StmtMatch) {
@@ -1509,7 +1560,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         // against the subject expression type (which we can query via `infer_expression_types`)
         // and extract the type at the `index` position if the pattern matches. This will be
         // similar to the logic in `self.infer_assignment_definition`.
-        self.add_binding(pattern.into(), definition, Type::Todo);
+        self.add_binding(pattern.into(), definition, todo_type!());
     }
 
     fn infer_match_pattern(&mut self, pattern: &ast::Pattern) {
@@ -1607,7 +1658,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.infer_standalone_expression(value);
 
         let value_ty = self.expression_ty(value);
-        let name_ast_id = name.scoped_ast_id(self.db, self.scope());
+        let name_ast_id = name.scoped_expression_id(self.db, self.scope());
 
         let target_ty = match assignment.target() {
             TargetKind::Sequence(unpack) => {
@@ -1828,17 +1879,8 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.infer_augmented_op(assignment, target_type, value_type)
     }
 
-    fn infer_type_alias_statement(&mut self, type_alias_statement: &ast::StmtTypeAlias) {
-        let ast::StmtTypeAlias {
-            range: _,
-            name,
-            type_params: _,
-            value,
-        } = type_alias_statement;
-        self.infer_expression(value);
-        self.infer_expression(name);
-
-        // TODO: properly handle generic type aliases, which need their own annotation scope
+    fn infer_type_alias_statement(&mut self, node: &ast::StmtTypeAlias) {
+        self.infer_definition(node);
     }
 
     fn infer_for_statement(&mut self, for_statement: &ast::StmtFor) {
@@ -1873,8 +1915,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         let iterable_ty = self.infer_standalone_expression(iterable);
 
         let loop_var_value_ty = if is_async {
-            // TODO(Alex): async iterables/iterators!
-            Type::Todo
+            todo_type!("async iterables/iterators")
         } else {
             iterable_ty
                 .iterate(self.db)
@@ -2202,7 +2243,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             ast::Expr::Await(await_expression) => self.infer_await_expression(await_expression),
             ast::Expr::IpyEscapeCommand(_) => {
                 // TODO Implement Ipy escape command support
-                Type::Todo
+                todo_type!()
             }
         };
 
@@ -2211,18 +2252,14 @@ impl<'db> TypeInferenceBuilder<'db> {
         ty
     }
 
-    fn store_expression_type(
-        &mut self,
-        expression: &impl HasScopedAstId<Id = ScopedExpressionId>,
-        ty: Type<'db>,
-    ) {
+    fn store_expression_type(&mut self, expression: &impl HasScopedExpressionId, ty: Type<'db>) {
         if self.deferred_state.in_string_annotation() {
             // Avoid storing the type of expressions that are part of a string annotation because
             // the expression ids don't exists in the semantic index. Instead, we'll store the type
             // on the string expression itself that represents the annotation.
             return;
         }
-        let expr_id = expression.scoped_ast_id(self.db, self.scope());
+        let expr_id = expression.scoped_expression_id(self.db, self.scope());
         let previous = self.types.expressions.insert(expr_id, ty);
         assert_eq!(previous, None);
     }
@@ -2288,6 +2325,12 @@ impl<'db> TypeInferenceBuilder<'db> {
                                 } = expression;
                                 let ty = self.infer_expression(expression);
 
+                                if let Some(ref format_spec) = format_spec {
+                                    for element in format_spec.elements.expressions() {
+                                        self.infer_expression(&element.expression);
+                                    }
+                                }
+
                                 // TODO: handle format specifiers by calling a method
                                 // (`Type::format`?) that handles the `__format__` method.
                                 // Conversion flags should be handled before calling `__format__`.
@@ -2394,7 +2437,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.infer_first_comprehension_iter(generators);
 
         // TODO generator type
-        Type::Todo
+        todo_type!()
     }
 
     fn infer_list_comprehension_expression(&mut self, listcomp: &ast::ExprListComp) -> Type<'db> {
@@ -2407,7 +2450,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.infer_first_comprehension_iter(generators);
 
         // TODO list type
-        Type::Todo
+        todo_type!()
     }
 
     fn infer_dict_comprehension_expression(&mut self, dictcomp: &ast::ExprDictComp) -> Type<'db> {
@@ -2421,7 +2464,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.infer_first_comprehension_iter(generators);
 
         // TODO dict type
-        Type::Todo
+        todo_type!()
     }
 
     fn infer_set_comprehension_expression(&mut self, setcomp: &ast::ExprSetComp) -> Type<'db> {
@@ -2434,7 +2477,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.infer_first_comprehension_iter(generators);
 
         // TODO set type
-        Type::Todo
+        todo_type!()
     }
 
     fn infer_generator_expression_scope(&mut self, generator: &ast::ExprGenerator) {
@@ -2541,24 +2584,25 @@ impl<'db> TypeInferenceBuilder<'db> {
                 .parent_scope_id(self.scope().file_scope_id(self.db))
                 .expect("A comprehension should never be the top-level scope")
                 .to_scope_id(self.db, self.file);
-            result.expression_ty(iterable.scoped_ast_id(self.db, lookup_scope))
+            result.expression_ty(iterable.scoped_expression_id(self.db, lookup_scope))
         } else {
             self.extend(result);
-            result.expression_ty(iterable.scoped_ast_id(self.db, self.scope()))
+            result.expression_ty(iterable.scoped_expression_id(self.db, self.scope()))
         };
 
         let target_ty = if is_async {
             // TODO: async iterables/iterators! -- Alex
-            Type::Todo
+            todo_type!("async iterables/iterators")
         } else {
             iterable_ty
                 .iterate(self.db)
                 .unwrap_with_diagnostic(iterable.into(), &mut self.diagnostics)
         };
 
-        self.types
-            .expressions
-            .insert(target.scoped_ast_id(self.db, self.scope()), target_ty);
+        self.types.expressions.insert(
+            target.scoped_expression_id(self.db, self.scope()),
+            target_ty,
+        );
         self.add_binding(target.into(), definition, target_ty);
     }
 
@@ -2638,7 +2682,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         }
 
         // TODO function type
-        Type::Todo
+        todo_type!()
     }
 
     fn infer_call_expression(&mut self, call_expression: &ast::ExprCall) -> Type<'db> {
@@ -2669,7 +2713,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             .unwrap_with_diagnostic(value.as_ref().into(), &mut self.diagnostics);
 
         // TODO
-        Type::Todo
+        todo_type!()
     }
 
     fn infer_yield_expression(&mut self, yield_expression: &ast::ExprYield) -> Type<'db> {
@@ -2678,7 +2722,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.infer_optional_expression(value.as_deref());
 
         // TODO awaitable type
-        Type::Todo
+        todo_type!()
     }
 
     fn infer_yield_from_expression(&mut self, yield_from: &ast::ExprYieldFrom) -> Type<'db> {
@@ -2690,7 +2734,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             .unwrap_with_diagnostic(value.as_ref().into(), &mut self.diagnostics);
 
         // TODO get type from `ReturnType` of generator
-        Type::Todo
+        todo_type!()
     }
 
     fn infer_await_expression(&mut self, await_expression: &ast::ExprAwait) -> Type<'db> {
@@ -2699,7 +2743,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.infer_expression(value);
 
         // TODO awaitable type
-        Type::Todo
+        todo_type!()
     }
 
     /// Look up a name reference that isn't bound in the local scope.
@@ -2975,7 +3019,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     Type::Unknown
                 }
             }
-            _ => Type::Todo, // TODO other unary op types
+            _ => todo_type!(), // TODO other unary op types
         }
     }
 
@@ -3223,7 +3267,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             (left, Type::BooleanLiteral(bool_value), op) => {
                 self.infer_binary_expression_type(left, Type::IntLiteral(i64::from(bool_value)), op)
             }
-            _ => Some(Type::Todo), // TODO
+            _ => Some(todo_type!()), // TODO
         }
     }
 
@@ -3639,16 +3683,16 @@ impl<'db> TypeInferenceBuilder<'db> {
                 let lhs_elements = lhs.elements(self.db);
                 let rhs_elements = rhs.elements(self.db);
 
-                let mut lexicographic_type_comparison =
-                    |op| self.infer_lexicographic_type_comparison(lhs_elements, op, rhs_elements);
+                let mut tuple_rich_comparison =
+                    |op| self.infer_tuple_rich_comparison(lhs_elements, op, rhs_elements);
 
                 match op {
-                    ast::CmpOp::Eq => lexicographic_type_comparison(RichCompareOperator::Eq),
-                    ast::CmpOp::NotEq => lexicographic_type_comparison(RichCompareOperator::Ne),
-                    ast::CmpOp::Lt => lexicographic_type_comparison(RichCompareOperator::Lt),
-                    ast::CmpOp::LtE => lexicographic_type_comparison(RichCompareOperator::Le),
-                    ast::CmpOp::Gt => lexicographic_type_comparison(RichCompareOperator::Gt),
-                    ast::CmpOp::GtE => lexicographic_type_comparison(RichCompareOperator::Ge),
+                    ast::CmpOp::Eq => tuple_rich_comparison(RichCompareOperator::Eq),
+                    ast::CmpOp::NotEq => tuple_rich_comparison(RichCompareOperator::Ne),
+                    ast::CmpOp::Lt => tuple_rich_comparison(RichCompareOperator::Lt),
+                    ast::CmpOp::LtE => tuple_rich_comparison(RichCompareOperator::Le),
+                    ast::CmpOp::Gt => tuple_rich_comparison(RichCompareOperator::Gt),
+                    ast::CmpOp::GtE => tuple_rich_comparison(RichCompareOperator::Ge),
                     ast::CmpOp::In | ast::CmpOp::NotIn => {
                         let mut eq_count = 0usize;
                         let mut not_eq_count = 0usize;
@@ -3661,7 +3705,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                             ).expect("infer_binary_type_comparison should never return None for `CmpOp::Eq`");
 
                             match eq_result {
-                                Type::Todo => return Ok(Type::Todo),
+                                todo @ Type::Todo(_) => return Ok(todo),
                                 ty => match ty.bool(self.db) {
                                     Truthiness::AlwaysTrue => eq_count += 1,
                                     Truthiness::AlwaysFalse => not_eq_count += 1,
@@ -3681,13 +3725,12 @@ impl<'db> TypeInferenceBuilder<'db> {
                     ast::CmpOp::Is | ast::CmpOp::IsNot => {
                         // - `[ast::CmpOp::Is]`: returns `false` if the elements are definitely unequal, otherwise `bool`
                         // - `[ast::CmpOp::IsNot]`: returns `true` if the elements are definitely unequal, otherwise `bool`
-                        let eq_result = lexicographic_type_comparison(RichCompareOperator::Eq)
-                            .expect(
+                        let eq_result = tuple_rich_comparison(RichCompareOperator::Eq).expect(
                             "infer_binary_type_comparison should never return None for `CmpOp::Eq`",
                         );
 
                         Ok(match eq_result {
-                            Type::Todo => Type::Todo,
+                            todo @ Type::Todo(_) => todo,
                             ty => match ty.bool(self.db) {
                                 Truthiness::AlwaysFalse => Type::BooleanLiteral(op.is_is_not()),
                                 _ => KnownClass::Bool.to_instance(self.db),
@@ -3742,58 +3785,85 @@ impl<'db> TypeInferenceBuilder<'db> {
             // TODO: handle more types
             _ => match op {
                 ast::CmpOp::Is | ast::CmpOp::IsNot => Ok(KnownClass::Bool.to_instance(self.db)),
-                _ => Ok(Type::Todo),
+                _ => Ok(todo_type!()),
             },
         }
     }
 
-    /// Performs lexicographic comparison between two slices of types.
+    /// Simulates rich comparison between tuples and returns the inferred result.
+    /// This performs a lexicographic comparison, returning a union of all possible return types that could result from the comparison.
     ///
-    /// For lexicographic comparison, elements from both slices are compared pairwise using
-    /// `infer_binary_type_comparison`. If a conclusive result cannot be determined as a `BooleanLiteral`,
-    /// it returns `bool`. Returns `None` if the comparison is not supported.
-    fn infer_lexicographic_type_comparison(
+    /// basically it's based on cpython's `tuple_richcompare`
+    /// see `<https://github.com/python/cpython/blob/9d6366b60d01305fc5e45100e0cd13e358aa397d/Objects/tupleobject.c#L637>`
+    fn infer_tuple_rich_comparison(
         &mut self,
         left: &[Type<'db>],
         op: RichCompareOperator,
         right: &[Type<'db>],
     ) -> Result<Type<'db>, CompareUnsupportedError<'db>> {
-        // Compare paired elements from left and right slices
-        for (l_ty, r_ty) in left.iter().copied().zip(right.iter().copied()) {
-            let eq_result = self
+        let left_iter = left.iter().copied();
+        let right_iter = right.iter().copied();
+
+        let mut builder = UnionBuilder::new(self.db);
+
+        for (l_ty, r_ty) in left_iter.zip(right_iter) {
+            let pairwise_eq_result = self
                 .infer_binary_type_comparison(l_ty, ast::CmpOp::Eq, r_ty)
                 .expect("infer_binary_type_comparison should never return None for `CmpOp::Eq`");
 
-            match eq_result {
+            match pairwise_eq_result {
                 // If propagation is required, return the result as is
-                Type::Todo => return Ok(Type::Todo),
+                todo @ Type::Todo(_) => return Ok(todo),
                 ty => match ty.bool(self.db) {
-                    // Types are equal, continue to the next pair
+                    // - AlwaysTrue : Continue to the next pair for lexicographic comparison
                     Truthiness::AlwaysTrue => continue,
-                    // Types are not equal, perform the specified comparison and return the result
-                    Truthiness::AlwaysFalse => {
-                        return self.infer_binary_type_comparison(l_ty, op.into(), r_ty)
+                    // - AlwaysFalse:
+                    // Lexicographic comparisons will always terminate with this pair.
+                    // Complete the comparison and return the result.
+                    // - Ambiguous:
+                    // Lexicographic comparisons might continue to the next pair (if eq_result is true),
+                    // or terminate here (if eq_result is false).
+                    // To account for cases where the comparison terminates here, add the pairwise comparison result to the union builder.
+                    eq_truthiness @ (Truthiness::AlwaysFalse | Truthiness::Ambiguous) => {
+                        let pairwise_compare_result = match op {
+                            RichCompareOperator::Lt
+                            | RichCompareOperator::Le
+                            | RichCompareOperator::Gt
+                            | RichCompareOperator::Ge => {
+                                self.infer_binary_type_comparison(l_ty, op.into(), r_ty)?
+                            }
+                            // For `==` and `!=`, we already figure out the result from `pairwise_eq_result`
+                            // NOTE: The CPython implementation does not account for non-boolean return types
+                            // or cases where `!=` is not the negation of `==`, we also do not consider these cases.
+                            RichCompareOperator::Eq => Type::BooleanLiteral(false),
+                            RichCompareOperator::Ne => Type::BooleanLiteral(true),
+                        };
+
+                        builder = builder.add(pairwise_compare_result);
+
+                        if eq_truthiness.is_ambiguous() {
+                            continue;
+                        }
+
+                        return Ok(builder.build());
                     }
-                    // If the intermediate result is ambiguous, we cannot determine the final result as BooleanLiteral.
-                    // In this case, we simply return a bool instance.
-                    Truthiness::Ambiguous => return Ok(KnownClass::Bool.to_instance(self.db)),
                 },
             }
         }
 
-        // At this point, the lengths of the two slices may be different, but the prefix of
-        // left and right slices is entirely identical.
-        // We return a comparison of the slice lengths based on the operator.
+        // if no more items to compare, we just compare sizes
         let (left_len, right_len) = (left.len(), right.len());
 
-        Ok(Type::BooleanLiteral(match op {
+        builder = builder.add(Type::BooleanLiteral(match op {
             RichCompareOperator::Eq => left_len == right_len,
             RichCompareOperator::Ne => left_len != right_len,
             RichCompareOperator::Lt => left_len < right_len,
             RichCompareOperator::Le => left_len <= right_len,
             RichCompareOperator::Gt => left_len > right_len,
             RichCompareOperator::Ge => left_len >= right_len,
-        }))
+        }));
+
+        Ok(builder.build())
     }
 
     fn infer_subscript_expression(&mut self, subscript: &ast::ExprSubscript) -> Type<'db> {
@@ -4159,6 +4229,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     "annotation-f-string",
                     format_args!("Type expressions cannot use f-strings"),
                 );
+                self.infer_fstring_expression(fstring);
                 Type::Unknown
             }
 
@@ -4233,7 +4304,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     self.infer_name_expression(name).in_type_expression(self.db)
                 }
                 ast::ExprContext::Invalid => Type::Unknown,
-                ast::ExprContext::Store | ast::ExprContext::Del => Type::Todo,
+                ast::ExprContext::Store | ast::ExprContext::Del => todo_type!(),
             },
 
             ast::Expr::Attribute(attribute_expression) => match attribute_expression.ctx {
@@ -4241,7 +4312,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     .infer_attribute_expression(attribute_expression)
                     .in_type_expression(self.db),
                 ast::ExprContext::Invalid => Type::Unknown,
-                ast::ExprContext::Store | ast::ExprContext::Del => Type::Todo,
+                ast::ExprContext::Store | ast::ExprContext::Del => todo_type!(),
             },
 
             ast::Expr::NoneLiteral(_literal) => Type::none(self.db),
@@ -4251,14 +4322,14 @@ impl<'db> TypeInferenceBuilder<'db> {
 
             // TODO: an Ellipsis literal *on its own* does not have any meaning in annotation
             // expressions, but is meaningful in the context of a number of special forms.
-            ast::Expr::EllipsisLiteral(_literal) => Type::Todo,
+            ast::Expr::EllipsisLiteral(_literal) => todo_type!(),
 
             // Other literals do not have meaningful values in the annotation expression context.
             // However, we will we want to handle these differently when working with special forms,
             // since (e.g.) `123` is not valid in an annotation expression but `Literal[123]` is.
-            ast::Expr::BytesLiteral(_literal) => Type::Todo,
-            ast::Expr::NumberLiteral(_literal) => Type::Todo,
-            ast::Expr::BooleanLiteral(_literal) => Type::Todo,
+            ast::Expr::BytesLiteral(_literal) => todo_type!(),
+            ast::Expr::NumberLiteral(_literal) => todo_type!(),
+            ast::Expr::BooleanLiteral(_literal) => todo_type!(),
 
             ast::Expr::Subscript(subscript) => {
                 let ast::ExprSubscript {
@@ -4301,9 +4372,13 @@ impl<'db> TypeInferenceBuilder<'db> {
             // TODO PEP 646
             ast::Expr::Starred(starred) => {
                 self.infer_starred_expression(starred);
-                Type::Todo
+                todo_type!()
             }
 
+            // Avoid inferring the types of invalid type expressions that have been parsed from a
+            // string annotation, as they are not present in the semantic index.
+            _ if self.deferred_state.in_string_annotation() => Type::Unknown,
+
             // Forms which are invalid in the context of annotation expressions: we infer their
             // nested expressions as normal expressions, but the type of the top-level expression is
             // always `Type::Unknown` in these cases.
@@ -4387,7 +4462,6 @@ impl<'db> TypeInferenceBuilder<'db> {
                 self.infer_slice_expression(slice);
                 Type::Unknown
             }
-
             ast::Expr::IpyEscapeCommand(_) => todo!("Implement Ipy escape command support"),
         }
     }
@@ -4445,16 +4519,23 @@ impl<'db> TypeInferenceBuilder<'db> {
                     element_types.push(element_ty);
                 }
 
-                if return_todo {
-                    Type::Todo
+                let ty = if return_todo {
+                    todo_type!("full tuple[...] support")
                 } else {
                     Type::tuple(self.db, &element_types)
-                }
+                };
+
+                // Here, we store the type for the inner `int, str` tuple-expression,
+                // while the type for the outer `tuple[int, str]` slice-expression is
+                // stored in the surrounding `infer_type_expression` call:
+                self.store_expression_type(tuple_slice, ty);
+
+                ty
             }
             single_element => {
                 let single_element_ty = self.infer_type_expression(single_element);
                 if element_could_alter_type_of_whole_tuple(single_element, single_element_ty) {
-                    Type::Todo
+                    todo_type!()
                 } else {
                     Type::tuple(self.db, &[single_element_ty])
                 }
@@ -4465,18 +4546,18 @@ impl<'db> TypeInferenceBuilder<'db> {
     /// Given the slice of a `type[]` annotation, return the type that the annotation represents
     fn infer_subclass_of_type_expression(&mut self, slice: &ast::Expr) -> Type<'db> {
         match slice {
-            ast::Expr::Name(name) => {
-                let name_ty = self.infer_name_expression(name);
+            ast::Expr::Name(_) => {
+                let name_ty = self.infer_expression(slice);
                 if let Some(ClassLiteralType { class }) = name_ty.into_class_literal() {
                     Type::subclass_of(class)
                 } else {
-                    Type::Todo
+                    todo_type!()
                 }
             }
             // TODO: attributes, unions, subscripts, etc.
             _ => {
                 self.infer_type_expression(slice);
-                Type::Todo
+                todo_type!()
             }
         }
     }
@@ -4495,20 +4576,21 @@ impl<'db> TypeInferenceBuilder<'db> {
 
         match value_ty {
             Type::KnownInstance(known_instance) => {
-                self.infer_parameterized_known_instance_type_expression(known_instance, slice)
+                self.infer_parameterized_known_instance_type_expression(subscript, known_instance)
             }
             _ => {
                 self.infer_type_expression(slice);
-                Type::Todo // TODO: generics
+                todo_type!("generics")
             }
         }
     }
 
     fn infer_parameterized_known_instance_type_expression(
         &mut self,
+        subscript: &ast::ExprSubscript,
         known_instance: KnownInstanceType,
-        parameters: &ast::Expr,
     ) -> Type<'db> {
+        let parameters = &*subscript.slice;
         match known_instance {
             KnownInstanceType::Literal => match self.infer_literal_parameter_type(parameters) {
                 Ok(ty) => ty,
@@ -4526,7 +4608,51 @@ impl<'db> TypeInferenceBuilder<'db> {
                     Type::Unknown
                 }
             },
-            KnownInstanceType::TypeVar(_) => Type::Todo,
+            KnownInstanceType::Optional => {
+                let param_type = self.infer_type_expression(parameters);
+                UnionType::from_elements(self.db, [param_type, Type::none(self.db)])
+            }
+            KnownInstanceType::Union => match parameters {
+                ast::Expr::Tuple(t) => {
+                    let union_ty = UnionType::from_elements(
+                        self.db,
+                        t.iter().map(|elt| self.infer_type_expression(elt)),
+                    );
+                    self.store_expression_type(parameters, union_ty);
+                    union_ty
+                }
+                _ => self.infer_type_expression(parameters),
+            },
+            KnownInstanceType::TypeVar(_) => {
+                self.infer_type_expression(parameters);
+                todo_type!()
+            }
+            KnownInstanceType::TypeAliasType(_) => {
+                self.infer_type_expression(parameters);
+                todo_type!("generic type alias")
+            }
+            KnownInstanceType::NoReturn | KnownInstanceType::Never => {
+                self.diagnostics.add(
+                    subscript.into(),
+                    "invalid-type-parameter",
+                    format_args!(
+                        "Type `{}` expected no type parameter",
+                        known_instance.repr(self.db)
+                    ),
+                );
+                Type::Unknown
+            }
+            KnownInstanceType::LiteralString => {
+                self.diagnostics.add(
+                    subscript.into(),
+                    "invalid-type-parameter",
+                    format_args!(
+                        "Type `{}` expected no type parameter. Did you mean to use `Literal[...]` instead?",
+                        known_instance.repr(self.db)
+                    ),
+                );
+                Type::Unknown
+            }
         }
     }
 
@@ -4539,8 +4665,15 @@ impl<'db> TypeInferenceBuilder<'db> {
             ast::Expr::Subscript(ast::ExprSubscript { value, slice, .. }) => {
                 let value_ty = self.infer_expression(value);
                 if matches!(value_ty, Type::KnownInstance(KnownInstanceType::Literal)) {
-                    self.infer_literal_parameter_type(slice)?
+                    let ty = self.infer_literal_parameter_type(slice)?;
+
+                    // This branch deals with annotations such as `Literal[Literal[1]]`.
+                    // Here, we store the type for the inner `Literal[1]` expression:
+                    self.store_expression_type(parameters, ty);
+                    ty
                 } else {
+                    self.store_expression_type(parameters, Type::Unknown);
+
                     return Err(vec![parameters]);
                 }
             }
@@ -4558,15 +4691,27 @@ impl<'db> TypeInferenceBuilder<'db> {
                     }
                 }
                 if errors.is_empty() {
-                    builder.build()
+                    let union_type = builder.build();
+
+                    // This branch deals with annotations such as `Literal[1, 2]`. Here, we
+                    // store the type for the inner `1, 2` tuple-expression:
+                    self.store_expression_type(parameters, union_type);
+
+                    union_type
                 } else {
+                    self.store_expression_type(parameters, Type::Unknown);
+
                     return Err(errors);
                 }
             }
 
-            ast::Expr::StringLiteral(literal) => self.infer_string_literal_expression(literal),
-            ast::Expr::BytesLiteral(literal) => self.infer_bytes_literal_expression(literal),
-            ast::Expr::BooleanLiteral(literal) => self.infer_boolean_literal_expression(literal),
+            literal @ (ast::Expr::StringLiteral(_)
+            | ast::Expr::BytesLiteral(_)
+            | ast::Expr::BooleanLiteral(_)
+            | ast::Expr::NoneLiteral(_)) => self.infer_expression(literal),
+            literal @ ast::Expr::NumberLiteral(ref number) if number.value.is_int() => {
+                self.infer_expression(literal)
+            }
             // For enum values
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 let value_ty = self.infer_expression(value);
@@ -4576,7 +4721,6 @@ impl<'db> TypeInferenceBuilder<'db> {
                     .ignore_possibly_unbound()
                     .unwrap_or(Type::Unknown)
             }
-            ast::Expr::NoneLiteral(_) => Type::none(self.db),
             // for negative and positive numbers
             ast::Expr::UnaryOp(ref u)
                 if matches!(u.op, UnaryOp::USub | UnaryOp::UAdd)
@@ -4584,10 +4728,8 @@ impl<'db> TypeInferenceBuilder<'db> {
             {
                 self.infer_unary_expression(u)
             }
-            ast::Expr::NumberLiteral(ref number) if number.value.is_int() => {
-                self.infer_number_literal_expression(number)
-            }
             _ => {
+                self.infer_expression(parameters);
                 return Err(vec![parameters]);
             }
         })
@@ -4755,6 +4897,7 @@ enum ModuleNameResolutionError {
 ///
 /// If the formatted string contains an expression (with a representation unknown at compile time),
 /// infers an instance of `builtins.str`.
+#[derive(Debug)]
 struct StringPartsCollector {
     concatenated: Option<String>,
     expression: bool,
@@ -4877,8 +5020,8 @@ fn perform_membership_test_comparison<'db>(
 
     compare_result_opt
         .map(|ty| {
-            if matches!(ty, Type::Todo) {
-                return Type::Todo;
+            if matches!(ty, Type::Todo(_)) {
+                return ty;
             }
 
             match op {
@@ -5849,7 +5992,17 @@ mod tests {
 
         // We currently return `Todo` for all async comprehensions,
         // including comprehensions that have invalid syntax
-        assert_scope_ty(&db, "src/a.py", &["foo", "<listcomp>"], "x", "@Todo");
+        assert_scope_ty(
+            &db,
+            "src/a.py",
+            &["foo", "<listcomp>"],
+            "x",
+            if cfg!(debug_assertions) {
+                "@Todo(async iterables/iterators)"
+            } else {
+                "@Todo"
+            },
+        );
 
         Ok(())
     }
@@ -5873,7 +6026,17 @@ mod tests {
         )?;
 
         // TODO async iterables/iterators! --Alex
-        assert_scope_ty(&db, "src/a.py", &["foo", "<listcomp>"], "x", "@Todo");
+        assert_scope_ty(
+            &db,
+            "src/a.py",
+            &["foo", "<listcomp>"],
+            "x",
+            if cfg!(debug_assertions) {
+                "@Todo(async iterables/iterators)"
+            } else {
+                "@Todo"
+            },
+        );
 
         Ok(())
     }
@@ -5907,6 +6070,72 @@ mod tests {
         );
     }
 
+    #[test]
+    fn pep695_type_params() {
+        let mut db = setup_db();
+
+        db.write_dedented(
+            "src/a.py",
+            "
+            def f[T, U: A, V: (A, B), W = A, X: A = A1, Y: (int,)]():
+                pass
+
+            class A: ...
+            class B: ...
+            class A1(A): ...
+            ",
+        )
+        .unwrap();
+
+        let check_typevar = |var: &'static str,
+                             upper_bound: Option<&'static str>,
+                             constraints: Option<&[&'static str]>,
+                             default: Option<&'static str>| {
+            let var_ty = get_symbol(&db, "src/a.py", &["f"], var).expect_type();
+            assert_eq!(var_ty.display(&db).to_string(), var);
+
+            let expected_name_ty = format!(r#"Literal["{var}"]"#);
+            let name_ty = var_ty.member(&db, "__name__").expect_type();
+            assert_eq!(name_ty.display(&db).to_string(), expected_name_ty);
+
+            let KnownInstanceType::TypeVar(typevar) = var_ty.expect_known_instance() else {
+                panic!("expected TypeVar");
+            };
+
+            assert_eq!(
+                typevar
+                    .upper_bound(&db)
+                    .map(|ty| ty.display(&db).to_string()),
+                upper_bound.map(std::borrow::ToOwned::to_owned)
+            );
+            assert_eq!(
+                typevar.constraints(&db).map(|tys| tys
+                    .iter()
+                    .map(|ty| ty.display(&db).to_string())
+                    .collect::<Vec<_>>()),
+                constraints.map(|strings| strings
+                    .iter()
+                    .map(std::string::ToString::to_string)
+                    .collect::<Vec<_>>())
+            );
+            assert_eq!(
+                typevar
+                    .default_ty(&db)
+                    .map(|ty| ty.display(&db).to_string()),
+                default.map(std::borrow::ToOwned::to_owned)
+            );
+        };
+
+        check_typevar("T", None, None, None);
+        check_typevar("U", Some("A"), None, None);
+        check_typevar("V", None, Some(&["A", "B"]), None);
+        check_typevar("W", None, None, Some("A"));
+        check_typevar("X", Some("A"), None, Some("A1"));
+
+        // a typevar with less than two constraints is treated as unconstrained
+        check_typevar("Y", None, None, None);
+    }
+
     // Incremental inference tests
 
     fn first_public_binding<'db>(db: &'db TestDb, file: File, name: &str) -> Definition<'db> {

crates/red_knot_python_semantic/src/types/mro.rs

@@ -5,7 +5,7 @@ use itertools::Either;
 use rustc_hash::FxHashSet;
 
 use super::{Class, ClassLiteralType, KnownClass, KnownInstanceType, Type};
-use crate::Db;
+use crate::{types::todo_type, Db};
 
 /// The inferred method resolution order of a given class.
 ///
@@ -354,7 +354,7 @@ impl<'db> ClassBase<'db> {
         match ty {
             Type::Any => Some(Self::Any),
             Type::Unknown => Some(Self::Unknown),
-            Type::Todo => Some(Self::Todo),
+            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?
@@ -371,8 +371,14 @@ impl<'db> ClassBase<'db> {
             | Type::ModuleLiteral(_)
             | Type::SubclassOf(_) => None,
             Type::KnownInstance(known_instance) => match known_instance {
-                KnownInstanceType::Literal => None,
-                KnownInstanceType::TypeVar(_) => None,
+                KnownInstanceType::TypeVar(_)
+                | KnownInstanceType::TypeAliasType(_)
+                | KnownInstanceType::Literal
+                | KnownInstanceType::LiteralString
+                | KnownInstanceType::Union
+                | KnownInstanceType::NoReturn
+                | KnownInstanceType::Never
+                | KnownInstanceType::Optional => None,
             },
         }
     }
@@ -404,7 +410,7 @@ impl<'db> From<ClassBase<'db>> for Type<'db> {
     fn from(value: ClassBase<'db>) -> Self {
         match value {
             ClassBase::Any => Type::Any,
-            ClassBase::Todo => Type::Todo,
+            ClassBase::Todo => todo_type!(),
             ClassBase::Unknown => Type::Unknown,
             ClassBase::Class(class) => Type::class_literal(class),
         }

crates/red_knot_python_semantic/src/types/narrow.rs

@@ -1,4 +1,4 @@
-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;
@@ -54,6 +54,7 @@ pub(crate) fn narrowing_constraint<'db>(
     }
 }
 
+#[allow(clippy::ref_option)]
 #[salsa::tracked(return_ref)]
 fn all_narrowing_constraints_for_pattern<'db>(
     db: &'db dyn Db,
@@ -62,6 +63,7 @@ fn all_narrowing_constraints_for_pattern<'db>(
     NarrowingConstraintsBuilder::new(db, ConstraintNode::Pattern(pattern), true).finish()
 }
 
+#[allow(clippy::ref_option)]
 #[salsa::tracked(return_ref)]
 fn all_narrowing_constraints_for_expression<'db>(
     db: &'db dyn Db,
@@ -70,6 +72,7 @@ fn all_narrowing_constraints_for_expression<'db>(
     NarrowingConstraintsBuilder::new(db, ConstraintNode::Expression(expression), true).finish()
 }
 
+#[allow(clippy::ref_option)]
 #[salsa::tracked(return_ref)]
 fn all_negative_narrowing_constraints_for_expression<'db>(
     db: &'db dyn Db,
@@ -257,17 +260,26 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
         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.
+
+        // 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.
@@ -282,43 +294,96 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
             .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));
 
-                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`
+        let mut last_rhs_ty: Option<Type> = None;
+
+        for (op, (left, right)) in std::iter::zip(&**ops, comparator_tuples) {
+            let lhs_ty = last_rhs_ty.unwrap_or_else(|| {
+                inference.expression_ty(left.scoped_expression_id(self.db, scope))
+            });
+            let rhs_ty = inference.expression_ty(right.scoped_expression_id(self.db, scope));
+            last_rhs_ty = Some(rhs_ty);
+
+            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 => {
-                        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);
+                        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);
+                            }
+                        }
+                        ast::CmpOp::Eq if lhs_ty.is_literal_string() => {
+                            constraints.insert(symbol, rhs_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)
@@ -333,46 +398,58 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
         let scope = self.scope();
         let inference = infer_expression_types(self.db, expression);
 
+        let callable_ty =
+            inference.expression_ty(expr_call.func.scoped_expression_id(self.db, scope));
+
         // 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_ast_id(self.db, scope))
-            .into_function_literal()
-            .and_then(|f| f.known(self.db))
-            .and_then(KnownFunction::constraint_function)
-        {
-            Some(function) if expr_call.arguments.keywords.is_empty() => {
-                if let [ast::Expr::Name(ast::ExprName { id, .. }), class_info] =
+        match callable_ty {
+            Type::FunctionLiteral(function_type) if expr_call.arguments.keywords.is_empty() => {
+                let function = function_type
+                    .known(self.db)
+                    .and_then(KnownFunction::constraint_function)?;
+
+                let [ast::Expr::Name(ast::ExprName { id, .. }), class_info] =
                     &*expr_call.arguments.args
-                {
-                    let symbol = self.symbols().symbol_id_by_name(id).unwrap();
+                else {
+                    return None;
+                };
 
-                    let class_info_ty =
-                        inference.expression_ty(class_info.scoped_ast_id(self.db, scope));
+                let symbol = self.symbols().symbol_id_by_name(id).unwrap();
 
-                    let to_constraint = match function {
-                        KnownConstraintFunction::IsInstance => {
-                            |class_literal: ClassLiteralType<'db>| {
-                                Type::instance(class_literal.class)
-                            }
+                let class_info_ty =
+                    inference.expression_ty(class_info.scoped_expression_id(self.db, scope));
+
+                let to_constraint = match function {
+                    KnownConstraintFunction::IsInstance => {
+                        |class_literal: ClassLiteralType<'db>| Type::instance(class_literal.class)
+                    }
+                    KnownConstraintFunction::IsSubclass => {
+                        |class_literal: ClassLiteralType<'db>| {
+                            Type::subclass_of(class_literal.class)
                         }
-                        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
-                }
+                generate_classinfo_constraint(self.db, &class_info_ty, to_constraint).map(
+                    |constraint| {
+                        let mut constraints = NarrowingConstraints::default();
+                        constraints.insert(symbol, constraint.negate_if(self.db, !is_positive));
+                        constraints
+                    },
+                )
+            }
+            // for the expression `bool(E)`, we further narrow the type based on `E`
+            Type::ClassLiteral(class_type)
+                if expr_call.arguments.args.len() == 1
+                    && expr_call.arguments.keywords.is_empty()
+                    && class_type.class.is_known(self.db, KnownClass::Bool) =>
+            {
+                self.evaluate_expression_node_constraint(
+                    &expr_call.arguments.args[0],
+                    expression,
+                    is_positive,
+                )
             }
             _ => None,
         }
@@ -414,7 +491,7 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
             // filter our arms with statically known truthiness
             .filter(|expr| {
                 inference
-                    .expression_ty(expr.scoped_ast_id(self.db, scope))
+                    .expression_ty(expr.scoped_expression_id(self.db, scope))
                     .bool(self.db)
                     != match expr_bool_op.op {
                         BoolOp::And => Truthiness::AlwaysTrue,

crates/red_knot_python_semantic/src/types/signatures.rs

@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 use super::{definition_expression_ty, Type};
-use crate::semantic_index::definition::Definition;
 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.
@@ -18,7 +18,7 @@ impl<'db> Signature<'db> {
     pub(crate) fn todo() -> Self {
         Self {
             parameters: Parameters::todo(),
-            return_ty: Type::Todo,
+            return_ty: todo_type!("return type"),
         }
     }
 
@@ -33,8 +33,7 @@ impl<'db> Signature<'db> {
             .as_ref()
             .map(|returns| {
                 if function_node.is_async {
-                    // TODO: generic `types.CoroutineType`!
-                    Type::Todo
+                    todo_type!("generic types.CoroutineType")
                 } else {
                     definition_expression_ty(db, definition, returns.as_ref())
                 }
@@ -81,11 +80,11 @@ impl<'db> Parameters<'db> {
         Self {
             variadic: Some(Parameter {
                 name: Some(Name::new_static("args")),
-                annotated_ty: Type::Todo,
+                annotated_ty: todo_type!(),
             }),
             keywords: Some(Parameter {
                 name: Some(Name::new_static("kwargs")),
-                annotated_ty: Type::Todo,
+                annotated_ty: todo_type!(),
             }),
             ..Default::default()
         }

crates/red_knot_python_semantic/src/types/unpacker.rs

@@ -4,9 +4,9 @@ use ruff_db::files::File;
 use ruff_python_ast::{self as ast, AnyNodeRef};
 use rustc_hash::FxHashMap;
 
-use crate::semantic_index::ast_ids::{HasScopedAstId, ScopedExpressionId};
+use crate::semantic_index::ast_ids::{HasScopedExpressionId, ScopedExpressionId};
 use crate::semantic_index::symbol::ScopeId;
-use crate::types::{Type, TypeCheckDiagnostics, TypeCheckDiagnosticsBuilder};
+use crate::types::{todo_type, Type, TypeCheckDiagnostics, TypeCheckDiagnosticsBuilder};
 use crate::Db;
 
 /// Unpacks the value expression type to their respective targets.
@@ -29,7 +29,7 @@ impl<'db> Unpacker<'db> {
         match target {
             ast::Expr::Name(target_name) => {
                 self.targets
-                    .insert(target_name.scoped_ast_id(self.db, scope), value_ty);
+                    .insert(target_name.scoped_expression_id(self.db, scope), value_ty);
             }
             ast::Expr::Starred(ast::ExprStarred { value, .. }) => {
                 self.unpack(value, value_ty, scope);
@@ -59,7 +59,7 @@ impl<'db> Unpacker<'db> {
                             // 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(Type::Todo);
+                            element_types.push(todo_type!("starred unpacking"));
 
                             element_types.extend_from_slice(
                                 // SAFETY: Safe because of the length check above.
@@ -72,7 +72,7 @@ impl<'db> Unpacker<'db> {
                             // index.
                             element_types.resize(elts.len() - 1, Type::Unknown);
                             // TODO: This should be `list[Unknown]`
-                            element_types.insert(starred_index, Type::Todo);
+                            element_types.insert(starred_index, todo_type!("starred unpacking"));
                             Cow::Owned(element_types)
                         }
                     } else {

crates/red_knot_python_semantic/tests/mdtest.rs

@@ -1,7 +1,6 @@
-use std::ffi::OsStr;
-use std::path::Path;
-
+use camino::Utf8Path;
 use dir_test::{dir_test, Fixture};
+use std::path::Path;
 
 /// See `crates/red_knot_test/README.md` for documentation on these tests.
 #[dir_test(
@@ -10,16 +9,46 @@ use dir_test::{dir_test, Fixture};
 )]
 #[allow(clippy::needless_pass_by_value)]
 fn mdtest(fixture: Fixture<&str>) {
-    let fixture_path = Path::new(fixture.path());
+    let fixture_path = Utf8Path::new(fixture.path());
     let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
-    let workspace_root = crate_dir.parent().and_then(Path::parent).unwrap();
+    let workspace_root = crate_dir.ancestors().nth(2).unwrap();
 
-    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 long_title = fixture_path.strip_prefix(workspace_root).unwrap();
+    let short_title = fixture_path.file_name().unwrap();
 
-    red_knot_test::run(fixture_path, long_title, short_title);
+    let test_name = test_name("mdtest", fixture_path);
+
+    red_knot_test::run(fixture_path, long_title.as_str(), short_title, &test_name);
+}
+
+/// Constructs the test name used for individual markdown files
+///
+/// This code is copied from <https://github.com/fe-lang/dir-test/blob/1c0f41c480a3490bc2653a043ff6e3f8085a1f47/macros/src/lib.rs#L104-L138>
+/// and should be updated if they diverge
+fn test_name(test_func_name: &str, fixture_path: &Utf8Path) -> String {
+    assert!(fixture_path.is_file());
+
+    let dir_path = format!("{}/resources/mdtest", std::env!("CARGO_MANIFEST_DIR"));
+    let rel_path = fixture_path.strip_prefix(dir_path).unwrap();
+    assert!(rel_path.is_relative());
+
+    let mut test_name = test_func_name.to_owned();
+    test_name.push_str("__");
+
+    for component in rel_path.parent().unwrap().components() {
+        let component = component
+            .as_str()
+            .replace(|c: char| c.is_ascii_punctuation(), "_");
+        test_name.push_str(&component);
+        test_name.push('_');
+    }
+
+    test_name.push_str(
+        &rel_path
+            .file_stem()
+            .unwrap()
+            .replace(|c: char| c.is_ascii_punctuation(), "_"),
+    );
+
+    test_name
 }

crates/red_knot_server/src/server/client.rs

@@ -26,7 +26,7 @@ pub(crate) struct Requester<'s> {
     response_handlers: FxHashMap<lsp_server::RequestId, ResponseBuilder<'s>>,
 }
 
-impl<'s> Client<'s> {
+impl Client<'_> {
     pub(super) fn new(sender: ClientSender) -> Self {
         Self {
             notifier: Notifier(sender.clone()),

crates/red_knot_server/src/session.rs

@@ -68,7 +68,7 @@ impl Session {
             let system = LSPSystem::new(index.clone());
 
             // TODO(dhruvmanila): Get the values from the client settings
-            let metadata = WorkspaceMetadata::from_path(system_path, &system, None)?;
+            let metadata = WorkspaceMetadata::discover(system_path, &system, None)?;
             // TODO(micha): Handle the case where the program settings are incorrect more gracefully.
             workspaces.insert(path, RootDatabase::new(metadata, system)?);
         }

crates/red_knot_server/src/system.rs

@@ -7,8 +7,8 @@ use lsp_types::Url;
 use ruff_db::file_revision::FileRevision;
 use ruff_db::system::walk_directory::WalkDirectoryBuilder;
 use ruff_db::system::{
-    DirectoryEntry, FileType, Metadata, OsSystem, Result, System, SystemPath, SystemPathBuf,
-    SystemVirtualPath, SystemVirtualPathBuf,
+    DirectoryEntry, FileType, GlobError, Metadata, OsSystem, PatternError, Result, System,
+    SystemPath, SystemPathBuf, SystemVirtualPath, SystemVirtualPathBuf,
 };
 use ruff_notebook::{Notebook, NotebookError};
 
@@ -198,6 +198,16 @@ impl System for LSPSystem {
         self.os_system.walk_directory(path)
     }
 
+    fn glob(
+        &self,
+        pattern: &str,
+    ) -> std::result::Result<
+        Box<dyn Iterator<Item = std::result::Result<SystemPathBuf, GlobError>>>,
+        PatternError,
+    > {
+        self.os_system.glob(pattern)
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

crates/red_knot_test/Cargo.toml

@@ -20,6 +20,7 @@ ruff_source_file = { workspace = true }
 ruff_text_size = { workspace = true }
 
 anyhow = { workspace = true }
+camino = { workspace = true }
 colored = { workspace = true }
 memchr = { workspace = true }
 regex = { workspace = true }

crates/red_knot_test/README.md

@@ -184,8 +184,11 @@ The tests are run independently, in independent in-memory file systems and with
 [Salsa](https://github.com/salsa-rs/salsa) databases. This means that each is a from-scratch run of
 the type checker, with no data persisting from any previous test.
 
-Due to `cargo test` limitations, an entire test suite (Markdown file) is run as a single Rust test,
-so it's not possible to select individual tests within it to run.
+It is possible to filter to individual tests within a single markdown file using the
+`MDTEST_TEST_FILTER` environment variable. This variable will match any tests which contain the
+value as a case-sensitive substring in its name. An example test name is
+`unpacking.md - Unpacking - Tuple - Multiple assignment`, which contains the name of the markdown
+file and its parent headers joined together with hyphens.
 
 ## Structured test suites
 

crates/red_knot_test/src/lib.rs

@@ -1,3 +1,4 @@
+use camino::Utf8Path;
 use colored::Colorize;
 use parser as test_parser;
 use red_knot_python_semantic::types::check_types;
@@ -7,7 +8,6 @@ use ruff_db::parsed::parsed_module;
 use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
 use ruff_source_file::LineIndex;
 use ruff_text_size::TextSize;
-use std::path::Path;
 
 mod assertion;
 mod db;
@@ -15,23 +15,30 @@ mod diagnostic;
 mod matcher;
 mod parser;
 
+const MDTEST_TEST_FILTER: &str = "MDTEST_TEST_FILTER";
+
 /// Run `path` as a markdown test suite with given `title`.
 ///
 /// Panic on test failure, and print failure details.
 #[allow(clippy::print_stdout)]
-pub fn run(path: &Path, long_title: &str, short_title: &str) {
+pub fn run(path: &Utf8Path, long_title: &str, short_title: &str, test_name: &str) {
     let source = std::fs::read_to_string(path).unwrap();
     let suite = match test_parser::parse(short_title, &source) {
         Ok(suite) => suite,
         Err(err) => {
-            panic!("Error parsing `{}`: {err}", path.to_str().unwrap())
+            panic!("Error parsing `{path}`: {err}")
         }
     };
 
     let mut db = db::Db::setup(SystemPathBuf::from("/src"));
 
+    let filter = std::env::var(MDTEST_TEST_FILTER).ok();
     let mut any_failures = false;
     for test in suite.tests() {
+        if filter.as_ref().is_some_and(|f| !test.name().contains(f)) {
+            continue;
+        }
+
         // Remove all files so that the db is in a "fresh" state.
         db.memory_file_system().remove_all();
         Files::sync_all(&mut db);
@@ -54,6 +61,15 @@ pub fn run(path: &Path, long_title: &str, short_title: &str) {
                     }
                 }
             }
+
+            println!(
+                "\nTo rerun this specific test, set the environment variable: {MDTEST_TEST_FILTER}=\"{}\"",
+                test.name()
+            );
+            println!(
+                "{MDTEST_TEST_FILTER}=\"{}\" cargo test -p red_knot_python_semantic --test mdtest -- {test_name}",
+                test.name()
+            );
         }
     }
 

crates/red_knot_test/src/matcher.rs

@@ -180,6 +180,16 @@ where
     }
 }
 
+/// Discard `@Todo`-type metadata from expected types, which is not available
+/// when running in release mode.
+#[cfg(not(debug_assertions))]
+fn discard_todo_metadata(ty: &str) -> std::borrow::Cow<'_, str> {
+    static TODO_METADATA_REGEX: std::sync::LazyLock<regex::Regex> =
+        std::sync::LazyLock::new(|| regex::Regex::new(r"@Todo\([^)]*\)").unwrap());
+
+    TODO_METADATA_REGEX.replace_all(ty, "@Todo")
+}
+
 struct Matcher {
     line_index: LineIndex,
     source: SourceText,
@@ -276,6 +286,9 @@ impl Matcher {
                 }
             }
             Assertion::Revealed(expected_type) => {
+                #[cfg(not(debug_assertions))]
+                let expected_type = discard_todo_metadata(&expected_type);
+
                 let mut matched_revealed_type = None;
                 let mut matched_undefined_reveal = None;
                 let expected_reveal_type_message = format!("Revealed type is `{expected_type}`");

crates/red_knot_vendored/vendor/typeshed/source_commit.txt

@@ -1 +1 @@
-5052fa2f18db4493892e0f2775030683c9d06531
+0a2da01946a406ede42e9c66f416a7e7758991d6

crates/red_knot_vendored/vendor/typeshed/stdlib/VERSIONS

@@ -33,6 +33,7 @@ _contextvars: 3.7-
 _csv: 3.0-
 _ctypes: 3.0-
 _curses: 3.0-
+_curses_panel: 3.0-
 _dbm: 3.0-
 _decimal: 3.3-
 _dummy_thread: 3.0-3.8
@@ -40,6 +41,7 @@ _dummy_threading: 3.0-3.8
 _frozen_importlib: 3.0-
 _frozen_importlib_external: 3.5-
 _gdbm: 3.0-
+_hashlib: 3.0-
 _heapq: 3.0-
 _imp: 3.0-
 _interpchannels: 3.13-
@@ -52,6 +54,7 @@ _lsprof: 3.0-
 _lzma: 3.3-
 _markupbase: 3.0-
 _msi: 3.0-3.12
+_multibytecodec: 3.0-
 _operator: 3.4-
 _osx_support: 3.0-
 _posixsubprocess: 3.2-
@@ -139,6 +142,12 @@ doctest: 3.0-
 dummy_threading: 3.0-3.8
 email: 3.0-
 encodings: 3.0-
+encodings.cp1125: 3.4-
+encodings.cp273: 3.4-
+encodings.cp858: 3.2-
+encodings.koi8_t: 3.5-
+encodings.kz1048: 3.5-
+encodings.mac_centeuro: 3.0-3.8
 ensurepip: 3.0-
 enum: 3.4-
 errno: 3.0-

crates/red_knot_vendored/vendor/typeshed/stdlib/_codecs.pyi

@@ -2,10 +2,13 @@ import codecs
 import sys
 from _typeshed import ReadableBuffer
 from collections.abc import Callable
-from typing import Literal, overload
+from typing import Literal, final, overload, type_check_only
 from typing_extensions import TypeAlias
 
 # This type is not exposed; it is defined in unicodeobject.c
+# At runtime it calls itself builtins.EncodingMap
+@final
+@type_check_only
 class _EncodingMap:
     def size(self) -> int: ...
 

crates/red_knot_vendored/vendor/typeshed/stdlib/_collections_abc.pyi

@@ -73,6 +73,7 @@ _VT_co = TypeVar("_VT_co", covariant=True)  # Value type covariant containers.
 @final
 class dict_keys(KeysView[_KT_co], Generic[_KT_co, _VT_co]):  # undocumented
     def __eq__(self, value: object, /) -> bool: ...
+    def __reversed__(self) -> Iterator[_KT_co]: ...
     if sys.version_info >= (3, 13):
         def isdisjoint(self, other: Iterable[_KT_co], /) -> bool: ...
     if sys.version_info >= (3, 10):
@@ -81,6 +82,7 @@ class dict_keys(KeysView[_KT_co], Generic[_KT_co, _VT_co]):  # undocumented
 
 @final
 class dict_values(ValuesView[_VT_co], Generic[_KT_co, _VT_co]):  # undocumented
+    def __reversed__(self) -> Iterator[_VT_co]: ...
     if sys.version_info >= (3, 10):
         @property
         def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
@@ -88,6 +90,7 @@ class dict_values(ValuesView[_VT_co], Generic[_KT_co, _VT_co]):  # undocumented
 @final
 class dict_items(ItemsView[_KT_co, _VT_co]):  # undocumented
     def __eq__(self, value: object, /) -> bool: ...
+    def __reversed__(self) -> Iterator[tuple[_KT_co, _VT_co]]: ...
     if sys.version_info >= (3, 13):
         def isdisjoint(self, other: Iterable[tuple[_KT_co, _VT_co]], /) -> bool: ...
     if sys.version_info >= (3, 10):

crates/red_knot_vendored/vendor/typeshed/stdlib/_csv.pyi

@@ -1,9 +1,9 @@
 import csv
 import sys
 from _typeshed import SupportsWrite
-from collections.abc import Iterable, Iterator
-from typing import Any, Final
-from typing_extensions import TypeAlias
+from collections.abc import Iterable
+from typing import Any, Final, type_check_only
+from typing_extensions import Self, TypeAlias
 
 __version__: Final[str]
 
@@ -45,17 +45,47 @@ class Dialect:
         strict: bool = False,
     ) -> None: ...
 
-class _reader(Iterator[list[str]]):
-    @property
-    def dialect(self) -> Dialect: ...
-    line_num: int
-    def __next__(self) -> list[str]: ...
+if sys.version_info >= (3, 10):
+    # This class calls itself _csv.reader.
+    class Reader:
+        @property
+        def dialect(self) -> Dialect: ...
+        line_num: int
+        def __iter__(self) -> Self: ...
+        def __next__(self) -> list[str]: ...
 
-class _writer:
-    @property
-    def dialect(self) -> Dialect: ...
-    def writerow(self, row: Iterable[Any]) -> Any: ...
-    def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ...
+    # This class calls itself _csv.writer.
+    class Writer:
+        @property
+        def dialect(self) -> Dialect: ...
+        if sys.version_info >= (3, 13):
+            def writerow(self, row: Iterable[Any], /) -> Any: ...
+            def writerows(self, rows: Iterable[Iterable[Any]], /) -> None: ...
+        else:
+            def writerow(self, row: Iterable[Any]) -> Any: ...
+            def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ...
+
+    # For the return types below.
+    # These aliases can be removed when typeshed drops support for 3.9.
+    _reader = Reader
+    _writer = Writer
+else:
+    # This class is not exposed. It calls itself _csv.reader.
+    @type_check_only
+    class _reader:
+        @property
+        def dialect(self) -> Dialect: ...
+        line_num: int
+        def __iter__(self) -> Self: ...
+        def __next__(self) -> list[str]: ...
+
+    # This class is not exposed. It calls itself _csv.writer.
+    @type_check_only
+    class _writer:
+        @property
+        def dialect(self) -> Dialect: ...
+        def writerow(self, row: Iterable[Any]) -> Any: ...
+        def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ...
 
 def writer(
     csvfile: SupportsWrite[str],

crates/red_knot_vendored/vendor/typeshed/stdlib/_ctypes.pyi

@@ -1,9 +1,10 @@
+import _typeshed
 import sys
-from _typeshed import ReadableBuffer, WriteableBuffer
+from _typeshed import ReadableBuffer, StrOrBytesPath, WriteableBuffer
 from abc import abstractmethod
 from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
 from ctypes import CDLL, ArgumentError as ArgumentError, c_void_p
-from typing import Any, ClassVar, Generic, TypeVar, overload
+from typing import Any, ClassVar, Generic, TypeVar, final, overload, type_check_only
 from typing_extensions import Self, TypeAlias
 
 if sys.version_info >= (3, 9):
@@ -47,46 +48,79 @@ if sys.platform == "win32":
     def LoadLibrary(name: str, load_flags: int = 0, /) -> int: ...
     def FreeLibrary(handle: int, /) -> None: ...
 
-class _CDataMeta(type):
-    # By default mypy complains about the following two methods, because strictly speaking cls
-    # might not be a Type[_CT]. However this can never actually happen, because the only class that
-    # uses _CDataMeta as its metaclass is _CData. So it's safe to ignore the errors here.
-    def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
-    def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+else:
+    def dlclose(handle: int, /) -> None: ...
+    # The default for flag is RTLD_GLOBAL|RTLD_LOCAL, which is platform dependent.
+    def dlopen(name: StrOrBytesPath, flag: int = ..., /) -> int: ...
+    def dlsym(handle: int, name: str, /) -> int: ...
 
-class _CData(metaclass=_CDataMeta):
+if sys.version_info >= (3, 13):
+    # This class is not exposed. It calls itself _ctypes.CType_Type.
+    @type_check_only
+    class _CType_Type(type):
+        # By default mypy complains about the following two methods, because strictly speaking cls
+        # might not be a Type[_CT]. However this doesn't happen because this is only a
+        # metaclass for subclasses of _CData.
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+
+    _CTypeBaseType = _CType_Type
+
+else:
+    _CTypeBaseType = type
+
+# This class is not exposed.
+@type_check_only
+class _CData:
     _b_base_: int
     _b_needsfree_: bool
     _objects: Mapping[Any, int] | None
-    # At runtime the following classmethods are available only on classes, not
-    # on instances. This can't be reflected properly in the type system:
-    #
-    # Structure.from_buffer(...)  # valid at runtime
-    # Structure(...).from_buffer(...)  # invalid at runtime
-    #
-    @classmethod
-    def from_buffer(cls, source: WriteableBuffer, offset: int = ...) -> Self: ...
-    @classmethod
-    def from_buffer_copy(cls, source: ReadableBuffer, offset: int = ...) -> Self: ...
-    @classmethod
-    def from_address(cls, address: int) -> Self: ...
-    @classmethod
-    def from_param(cls, value: Any, /) -> Self | _CArgObject: ...
-    @classmethod
-    def in_dll(cls, library: CDLL, name: str) -> Self: ...
     def __buffer__(self, flags: int, /) -> memoryview: ...
-    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
+    def __ctypes_from_outparam__(self, /) -> Self: ...
 
-class _SimpleCData(_CData, Generic[_T]):
+# this is a union of all the subclasses of _CData, which is useful because of
+# the methods that are present on each of those subclasses which are not present
+# on _CData itself.
+_CDataType: TypeAlias = _SimpleCData[Any] | _Pointer[Any] | CFuncPtr | Union | Structure | Array[Any]
+
+# This class is not exposed. It calls itself _ctypes.PyCSimpleType.
+@type_check_only
+class _PyCSimpleType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(self: type[_CT], value: int, /) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(self: type[_CT], value: int, /) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+
+class _SimpleCData(_CData, Generic[_T], metaclass=_PyCSimpleType):
     value: _T
     # The TypeVar can be unsolved here,
     # but we can't use overloads without creating many, many mypy false-positive errors
     def __init__(self, value: _T = ...) -> None: ...  # pyright: ignore[reportInvalidTypeVarUse]
+    def __ctypes_from_outparam__(self, /) -> _T: ...  # type: ignore[override]
 
 class _CanCastTo(_CData): ...
 class _PointerLike(_CanCastTo): ...
 
-class _Pointer(_PointerLike, _CData, Generic[_CT]):
+# This type is not exposed. It calls itself _ctypes.PyCPointerType.
+@type_check_only
+class _PyCPointerType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    def set_type(self, type: Any, /) -> None: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+
+class _Pointer(_PointerLike, _CData, Generic[_CT], metaclass=_PyCPointerType):
     _type_: type[_CT]
     contents: _CT
     @overload
@@ -105,16 +139,32 @@ def POINTER(type: None, /) -> type[c_void_p]: ...
 def POINTER(type: type[_CT], /) -> type[_Pointer[_CT]]: ...
 def pointer(obj: _CT, /) -> _Pointer[_CT]: ...
 
+# This class is not exposed. It calls itself _ctypes.CArgObject.
+@final
+@type_check_only
 class _CArgObject: ...
 
-def byref(obj: _CData, offset: int = ...) -> _CArgObject: ...
+def byref(obj: _CData | _CDataType, offset: int = ...) -> _CArgObject: ...
 
-_ECT: TypeAlias = Callable[[_CData | None, CFuncPtr, tuple[_CData, ...]], _CData]
+_ECT: TypeAlias = Callable[[_CData | _CDataType | None, CFuncPtr, tuple[_CData | _CDataType, ...]], _CDataType]
 _PF: TypeAlias = tuple[int] | tuple[int, str | None] | tuple[int, str | None, Any]
 
-class CFuncPtr(_PointerLike, _CData):
-    restype: type[_CData] | Callable[[int], Any] | None
-    argtypes: Sequence[type[_CData]]
+# This class is not exposed. It calls itself _ctypes.PyCFuncPtrType.
+@type_check_only
+class _PyCFuncPtrType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+
+class CFuncPtr(_PointerLike, _CData, metaclass=_PyCFuncPtrType):
+    restype: type[_CDataType] | Callable[[int], Any] | None
+    argtypes: Sequence[type[_CDataType]]
     errcheck: _ECT
     # Abstract attribute that must be defined on subclasses
     _flags_: ClassVar[int]
@@ -129,7 +179,7 @@ class CFuncPtr(_PointerLike, _CData):
     if sys.platform == "win32":
         @overload
         def __init__(
-            self, vtbl_index: int, name: str, paramflags: tuple[_PF, ...] | None = ..., iid: _CData | None = ..., /
+            self, vtbl_index: int, name: str, paramflags: tuple[_PF, ...] | None = ..., iid: _CData | _CDataType | None = ..., /
         ) -> None: ...
 
     def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
@@ -137,30 +187,95 @@ class CFuncPtr(_PointerLike, _CData):
 _GetT = TypeVar("_GetT")
 _SetT = TypeVar("_SetT")
 
+# This class is not exposed. It calls itself _ctypes.CField.
+@final
+@type_check_only
 class _CField(Generic[_CT, _GetT, _SetT]):
     offset: int
     size: int
-    @overload
-    def __get__(self, instance: None, owner: type[Any] | None, /) -> Self: ...
-    @overload
-    def __get__(self, instance: Any, owner: type[Any] | None, /) -> _GetT: ...
+    if sys.version_info >= (3, 10):
+        @overload
+        def __get__(self, instance: None, owner: type[Any] | None = None, /) -> Self: ...
+        @overload
+        def __get__(self, instance: Any, owner: type[Any] | None = None, /) -> _GetT: ...
+    else:
+        @overload
+        def __get__(self, instance: None, owner: type[Any] | None, /) -> Self: ...
+        @overload
+        def __get__(self, instance: Any, owner: type[Any] | None, /) -> _GetT: ...
+
     def __set__(self, instance: Any, value: _SetT, /) -> None: ...
 
-class _StructUnionMeta(_CDataMeta):
-    _fields_: Sequence[tuple[str, type[_CData]] | tuple[str, type[_CData], int]]
-    _pack_: int
-    _anonymous_: Sequence[str]
+# This class is not exposed. It calls itself _ctypes.UnionType.
+@type_check_only
+class _UnionType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    # At runtime, various attributes are created on a Union subclass based
+    # on its _fields_. This method doesn't exist, but represents those
+    # dynamically created attributes.
     def __getattr__(self, name: str) -> _CField[Any, Any, Any]: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+
+class Union(_CData, metaclass=_UnionType):
+    _fields_: ClassVar[Sequence[tuple[str, type[_CDataType]] | tuple[str, type[_CDataType], int]]]
+    _pack_: ClassVar[int]
+    _anonymous_: ClassVar[Sequence[str]]
+    if sys.version_info >= (3, 13):
+        _align_: ClassVar[int]
 
-class _StructUnionBase(_CData, metaclass=_StructUnionMeta):
     def __init__(self, *args: Any, **kw: Any) -> None: ...
     def __getattr__(self, name: str) -> Any: ...
     def __setattr__(self, name: str, value: Any) -> None: ...
 
-class Union(_StructUnionBase): ...
-class Structure(_StructUnionBase): ...
+# This class is not exposed. It calls itself _ctypes.PyCStructType.
+@type_check_only
+class _PyCStructType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    # At runtime, various attributes are created on a Structure subclass based
+    # on its _fields_. This method doesn't exist, but represents those
+    # dynamically created attributes.
+    def __getattr__(self, name: str) -> _CField[Any, Any, Any]: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
 
-class Array(_CData, Generic[_CT]):
+class Structure(_CData, metaclass=_PyCStructType):
+    _fields_: ClassVar[Sequence[tuple[str, type[_CDataType]] | tuple[str, type[_CDataType], int]]]
+    _pack_: ClassVar[int]
+    _anonymous_: ClassVar[Sequence[str]]
+    if sys.version_info >= (3, 13):
+        _align_: ClassVar[int]
+
+    def __init__(self, *args: Any, **kw: Any) -> None: ...
+    def __getattr__(self, name: str) -> Any: ...
+    def __setattr__(self, name: str, value: Any) -> None: ...
+
+# This class is not exposed. It calls itself _ctypes.PyCArrayType.
+@type_check_only
+class _PyCArrayType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+
+class Array(_CData, Generic[_CT], metaclass=_PyCArrayType):
     @property
     @abstractmethod
     def _length_(self) -> int: ...
@@ -205,9 +320,15 @@ class Array(_CData, Generic[_CT]):
     if sys.version_info >= (3, 9):
         def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-def addressof(obj: _CData, /) -> int: ...
-def alignment(obj_or_type: _CData | type[_CData], /) -> int: ...
+def addressof(obj: _CData | _CDataType, /) -> int: ...
+def alignment(obj_or_type: _CData | _CDataType | type[_CData | _CDataType], /) -> int: ...
 def get_errno() -> int: ...
-def resize(obj: _CData, size: int, /) -> None: ...
+def resize(obj: _CData | _CDataType, size: int, /) -> None: ...
 def set_errno(value: int, /) -> int: ...
-def sizeof(obj_or_type: _CData | type[_CData], /) -> int: ...
+def sizeof(obj_or_type: _CData | _CDataType | type[_CData | _CDataType], /) -> int: ...
+def PyObj_FromPtr(address: int, /) -> Any: ...
+def Py_DECREF(o: _T, /) -> _T: ...
+def Py_INCREF(o: _T, /) -> _T: ...
+def buffer_info(o: _CData | _CDataType | type[_CData | _CDataType], /) -> tuple[str, int, tuple[int, ...]]: ...
+def call_cdeclfunction(address: int, arguments: tuple[Any, ...], /) -> Any: ...
+def call_function(address: int, arguments: tuple[Any, ...], /) -> Any: ...

crates/red_knot_vendored/vendor/typeshed/stdlib/_curses.pyi

@@ -1,6 +1,7 @@
 import sys
 from _typeshed import ReadOnlyBuffer, SupportsRead
-from typing import IO, Any, NamedTuple, final, overload
+from curses import _ncurses_version
+from typing import IO, Any, final, overload
 from typing_extensions import TypeAlias
 
 # NOTE: This module is ordinarily only available on Unix, but the windows-curses
@@ -549,9 +550,4 @@ class window:  # undocumented
     @overload
     def vline(self, y: int, x: int, ch: _ChType, n: int) -> None: ...
 
-class _ncurses_version(NamedTuple):
-    major: int
-    minor: int
-    patch: int
-
 ncurses_version: _ncurses_version

crates/red_knot_vendored/vendor/typeshed/stdlib/_curses_panel.pyi

@@ -0,0 +1,27 @@
+from _curses import window
+from typing import final
+
+__version__: str
+version: str
+
+class error(Exception): ...
+
+@final
+class panel:
+    def above(self) -> panel: ...
+    def below(self) -> panel: ...
+    def bottom(self) -> None: ...
+    def hidden(self) -> bool: ...
+    def hide(self) -> None: ...
+    def move(self, y: int, x: int, /) -> None: ...
+    def replace(self, win: window, /) -> None: ...
+    def set_userptr(self, obj: object, /) -> None: ...
+    def show(self) -> None: ...
+    def top(self) -> None: ...
+    def userptr(self) -> object: ...
+    def window(self) -> window: ...
+
+def bottom_panel() -> panel: ...
+def new_panel(win: window, /) -> panel: ...
+def top_panel() -> panel: ...
+def update_panels() -> panel: ...

crates/red_knot_vendored/vendor/typeshed/stdlib/_dbm.pyi

@@ -1,7 +1,7 @@
 import sys
 from _typeshed import ReadOnlyBuffer, StrOrBytesPath
 from types import TracebackType
-from typing import TypeVar, overload
+from typing import TypeVar, final, overload, type_check_only
 from typing_extensions import Self, TypeAlias
 
 if sys.platform != "win32":
@@ -13,6 +13,8 @@ if sys.platform != "win32":
     library: str
 
     # Actual typename dbm, not exposed by the implementation
+    @final
+    @type_check_only
     class _dbm:
         def close(self) -> None: ...
         if sys.version_info >= (3, 13):
@@ -22,18 +24,17 @@ if sys.platform != "win32":
         def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
         def __delitem__(self, key: _KeyType) -> None: ...
         def __len__(self) -> int: ...
-        def __del__(self) -> None: ...
         def __enter__(self) -> Self: ...
         def __exit__(
             self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
         ) -> None: ...
         @overload
-        def get(self, k: _KeyType) -> bytes | None: ...
+        def get(self, k: _KeyType, /) -> bytes | None: ...
         @overload
-        def get(self, k: _KeyType, default: _T) -> bytes | _T: ...
+        def get(self, k: _KeyType, default: _T, /) -> bytes | _T: ...
         def keys(self) -> list[bytes]: ...
-        def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ...
-        # Don't exist at runtime
+        def setdefault(self, k: _KeyType, default: _ValueType = ..., /) -> bytes: ...
+        # This isn't true, but the class can't be instantiated. See #13024
         __new__: None  # type: ignore[assignment]
         __init__: None  # type: ignore[assignment]
 

crates/red_knot_vendored/vendor/typeshed/stdlib/_decimal.pyi

@@ -17,20 +17,13 @@ from decimal import (
     Rounded as Rounded,
     Subnormal as Subnormal,
     Underflow as Underflow,
+    _ContextManager,
 )
-from types import TracebackType
 from typing import Final
 from typing_extensions import TypeAlias
 
 _TrapType: TypeAlias = type[DecimalException]
 
-class _ContextManager:
-    new_context: Context
-    saved_context: Context
-    def __init__(self, new_context: Context) -> None: ...
-    def __enter__(self) -> Context: ...
-    def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
-
 __version__: Final[str]
 __libmpdec_version__: Final[str]
 

crates/red_knot_vendored/vendor/typeshed/stdlib/_hashlib.pyi

@@ -0,0 +1,80 @@
+import sys
+from _typeshed import ReadableBuffer
+from collections.abc import Callable
+from types import ModuleType
+from typing import AnyStr, final, overload
+from typing_extensions import Self, TypeAlias
+
+_DigestMod: TypeAlias = str | Callable[[], HASH] | ModuleType | None
+
+openssl_md_meth_names: frozenset[str]
+
+class HASH:
+    @property
+    def digest_size(self) -> int: ...
+    @property
+    def block_size(self) -> int: ...
+    @property
+    def name(self) -> str: ...
+    def copy(self) -> Self: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def update(self, obj: ReadableBuffer, /) -> None: ...
+
+if sys.version_info >= (3, 10):
+    class UnsupportedDigestmodError(ValueError): ...
+
+if sys.version_info >= (3, 9):
+    class HASHXOF(HASH):
+        def digest(self, length: int) -> bytes: ...  # type: ignore[override]
+        def hexdigest(self, length: int) -> str: ...  # type: ignore[override]
+
+    @final
+    class HMAC:
+        @property
+        def digest_size(self) -> int: ...
+        @property
+        def block_size(self) -> int: ...
+        @property
+        def name(self) -> str: ...
+        def copy(self) -> Self: ...
+        def digest(self) -> bytes: ...
+        def hexdigest(self) -> str: ...
+        def update(self, msg: ReadableBuffer) -> None: ...
+
+    @overload
+    def compare_digest(a: ReadableBuffer, b: ReadableBuffer, /) -> bool: ...
+    @overload
+    def compare_digest(a: AnyStr, b: AnyStr, /) -> bool: ...
+    def get_fips_mode() -> int: ...
+    def hmac_new(key: bytes | bytearray, msg: ReadableBuffer = b"", digestmod: _DigestMod = None) -> HMAC: ...
+    def new(name: str, string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_md5(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha1(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha3_224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha3_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha3_384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha3_512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_shake_128(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF: ...
+    def openssl_shake_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF: ...
+
+else:
+    def new(name: str, string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_md5(string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_sha1(string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_sha224(string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_sha256(string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_sha384(string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_sha512(string: ReadableBuffer = b"") -> HASH: ...
+
+def hmac_digest(key: bytes | bytearray, msg: ReadableBuffer, digest: str) -> bytes: ...
+def pbkdf2_hmac(
+    hash_name: str, password: ReadableBuffer, salt: ReadableBuffer, iterations: int, dklen: int | None = None
+) -> bytes: ...
+def scrypt(
+    password: ReadableBuffer, *, salt: ReadableBuffer, n: int, r: int, p: int, maxmem: int = 0, dklen: int = 64
+) -> bytes: ...

crates/red_knot_vendored/vendor/typeshed/stdlib/_json.pyi

@@ -45,5 +45,6 @@ class make_scanner:
     def __init__(self, context: make_scanner) -> None: ...
     def __call__(self, string: str, index: int) -> tuple[Any, int]: ...
 
+def encode_basestring(s: str, /) -> str: ...
 def encode_basestring_ascii(s: str, /) -> str: ...
 def scanstring(string: str, end: int, strict: bool = ...) -> tuple[str, int]: ...

crates/red_knot_vendored/vendor/typeshed/stdlib/_multibytecodec.pyi

@@ -0,0 +1,44 @@
+from _typeshed import ReadableBuffer
+from codecs import _ReadableStream, _WritableStream
+from collections.abc import Iterable
+from typing import final, type_check_only
+
+# This class is not exposed. It calls itself _multibytecodec.MultibyteCodec.
+@final
+@type_check_only
+class _MultibyteCodec:
+    def decode(self, input: ReadableBuffer, errors: str | None = None) -> str: ...
+    def encode(self, input: str, errors: str | None = None) -> bytes: ...
+
+class MultibyteIncrementalDecoder:
+    errors: str
+    def __init__(self, errors: str = "strict") -> None: ...
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+    def getstate(self) -> tuple[bytes, int]: ...
+    def reset(self) -> None: ...
+    def setstate(self, state: tuple[bytes, int], /) -> None: ...
+
+class MultibyteIncrementalEncoder:
+    errors: str
+    def __init__(self, errors: str = "strict") -> None: ...
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+    def getstate(self) -> int: ...
+    def reset(self) -> None: ...
+    def setstate(self, state: int, /) -> None: ...
+
+class MultibyteStreamReader:
+    errors: str
+    stream: _ReadableStream
+    def __init__(self, stream: _ReadableStream, errors: str = "strict") -> None: ...
+    def read(self, sizeobj: int | None = None, /) -> str: ...
+    def readline(self, sizeobj: int | None = None, /) -> str: ...
+    def readlines(self, sizehintobj: int | None = None, /) -> list[str]: ...
+    def reset(self) -> None: ...
+
+class MultibyteStreamWriter:
+    errors: str
+    stream: _WritableStream
+    def __init__(self, stream: _WritableStream, errors: str = "strict") -> None: ...
+    def reset(self) -> None: ...
+    def write(self, strobj: str, /) -> None: ...
+    def writelines(self, lines: Iterable[str], /) -> None: ...

crates/red_knot_vendored/vendor/typeshed/stdlib/_posixsubprocess.pyi

@@ -4,7 +4,6 @@ from collections.abc import Callable, Sequence
 from typing import SupportsIndex
 
 if sys.platform != "win32":
-    def cloexec_pipe() -> tuple[int, int]: ...
     def fork_exec(
         args: Sequence[StrOrBytesPath] | None,
         executable_list: Sequence[bytes],

crates/red_knot_vendored/vendor/typeshed/stdlib/_socket.pyi

@@ -3,7 +3,7 @@ from _typeshed import ReadableBuffer, WriteableBuffer
 from collections.abc import Iterable
 from socket import error as error, gaierror as gaierror, herror as herror, timeout as timeout
 from typing import Any, SupportsIndex, overload
-from typing_extensions import TypeAlias
+from typing_extensions import CapsuleType, TypeAlias
 
 _CMSG: TypeAlias = tuple[int, int, bytes]
 _CMSGArg: TypeAlias = tuple[int, int, ReadableBuffer]
@@ -72,7 +72,8 @@ SO_SNDBUF: int
 SO_SNDLOWAT: int
 SO_SNDTIMEO: int
 SO_TYPE: int
-SO_USELOOPBACK: int
+if sys.platform != "linux":
+    SO_USELOOPBACK: int
 if sys.platform == "win32":
     SO_EXCLUSIVEADDRUSE: int
 if sys.platform != "win32":
@@ -87,7 +88,10 @@ if sys.platform != "win32" and sys.platform != "darwin":
     SO_PEERSEC: int
     SO_PRIORITY: int
     SO_PROTOCOL: int
+if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
     SO_SETFIB: int
+if sys.platform == "linux" and sys.version_info >= (3, 13):
+    SO_BINDTOIFINDEX: int
 
 SOMAXCONN: int
 
@@ -99,27 +103,32 @@ MSG_TRUNC: int
 MSG_WAITALL: int
 if sys.platform != "win32":
     MSG_DONTWAIT: int
-    MSG_EOF: int
     MSG_EOR: int
     MSG_NOSIGNAL: int  # Sometimes this exists on darwin, sometimes not
 if sys.platform != "darwin":
-    MSG_BCAST: int
     MSG_ERRQUEUE: int
+if sys.platform == "win32":
+    MSG_BCAST: int
     MSG_MCAST: int
 if sys.platform != "win32" and sys.platform != "darwin":
-    MSG_BTAG: int
     MSG_CMSG_CLOEXEC: int
     MSG_CONFIRM: int
-    MSG_ETAG: int
     MSG_FASTOPEN: int
     MSG_MORE: int
+if sys.platform != "win32" and sys.platform != "linux":
+    MSG_EOF: int
+if sys.platform != "win32" and sys.platform != "linux" and sys.platform != "darwin":
     MSG_NOTIFICATION: int
+    MSG_BTAG: int  # Not FreeBSD either
+    MSG_ETAG: int  # Not FreeBSD either
 
 SOL_IP: int
 SOL_SOCKET: int
 SOL_TCP: int
 SOL_UDP: int
 if sys.platform != "win32" and sys.platform != "darwin":
+    # Defined in socket.h for Linux, but these aren't always present for
+    # some reason.
     SOL_ATALK: int
     SOL_AX25: int
     SOL_HCI: int
@@ -128,10 +137,11 @@ if sys.platform != "win32" and sys.platform != "darwin":
     SOL_ROSE: int
 
 if sys.platform != "win32":
-    SCM_CREDS: int
     SCM_RIGHTS: int
 if sys.platform != "win32" and sys.platform != "darwin":
     SCM_CREDENTIALS: int
+if sys.platform != "win32" and sys.platform != "linux":
+    SCM_CREDS: int
 
 IPPROTO_ICMP: int
 IPPROTO_IP: int
@@ -143,21 +153,22 @@ IPPROTO_DSTOPTS: int
 IPPROTO_EGP: int
 IPPROTO_ESP: int
 IPPROTO_FRAGMENT: int
-IPPROTO_GGP: int
 IPPROTO_HOPOPTS: int
 IPPROTO_ICMPV6: int
 IPPROTO_IDP: int
 IPPROTO_IGMP: int
-IPPROTO_IPV4: int
 IPPROTO_IPV6: int
-IPPROTO_MAX: int
-IPPROTO_ND: int
 IPPROTO_NONE: int
 IPPROTO_PIM: int
 IPPROTO_PUP: int
 IPPROTO_ROUTING: int
 IPPROTO_SCTP: int
-if sys.platform != "darwin":
+if sys.platform != "linux":
+    IPPROTO_GGP: int
+    IPPROTO_IPV4: int
+    IPPROTO_MAX: int
+    IPPROTO_ND: int
+if sys.platform == "win32":
     IPPROTO_CBT: int
     IPPROTO_ICLFXBM: int
     IPPROTO_IGP: int
@@ -166,18 +177,19 @@ if sys.platform != "darwin":
     IPPROTO_RDP: int
     IPPROTO_ST: int
 if sys.platform != "win32":
-    IPPROTO_EON: int
     IPPROTO_GRE: int
-    IPPROTO_HELLO: int
-    IPPROTO_IPCOMP: int
     IPPROTO_IPIP: int
     IPPROTO_RSVP: int
     IPPROTO_TP: int
+if sys.platform != "win32" and sys.platform != "linux":
+    IPPROTO_EON: int
+    IPPROTO_HELLO: int
+    IPPROTO_IPCOMP: int
     IPPROTO_XTP: int
-if sys.platform != "win32" and sys.platform != "darwin":
-    IPPROTO_BIP: int
-    IPPROTO_MOBILE: int
-    IPPROTO_VRRP: int
+if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
+    IPPROTO_BIP: int  # Not FreeBSD either
+    IPPROTO_MOBILE: int  # Not FreeBSD either
+    IPPROTO_VRRP: int  # Not FreeBSD either
 if sys.version_info >= (3, 9) and sys.platform == "linux":
     # Availability: Linux >= 2.6.20, FreeBSD >= 10.1
     IPPROTO_UDPLITE: int
@@ -202,11 +214,10 @@ IP_MULTICAST_IF: int
 IP_MULTICAST_LOOP: int
 IP_MULTICAST_TTL: int
 IP_OPTIONS: int
-IP_RECVDSTADDR: int
+if sys.platform != "linux":
+    IP_RECVDSTADDR: int
 if sys.version_info >= (3, 10):
     IP_RECVTOS: int
-elif sys.platform != "win32" and sys.platform != "darwin":
-    IP_RECVTOS: int
 IP_TOS: int
 IP_TTL: int
 if sys.platform != "win32":
@@ -218,6 +229,7 @@ if sys.platform != "win32":
     IP_RETOPTS: int
 if sys.platform != "win32" and sys.platform != "darwin":
     IP_TRANSPARENT: int
+if sys.platform != "win32" and sys.platform != "darwin" and sys.version_info >= (3, 11):
     IP_BIND_ADDRESS_NO_PORT: int
 if sys.version_info >= (3, 12):
     IP_ADD_SOURCE_MEMBERSHIP: int
@@ -255,6 +267,9 @@ if sys.platform != "win32":
         IPV6_RECVPATHMTU: int
         IPV6_RECVPKTINFO: int
         IPV6_RTHDRDSTOPTS: int
+
+if sys.platform != "win32" and sys.platform != "linux":
+    if sys.version_info >= (3, 9) or sys.platform != "darwin":
         IPV6_USE_MIN_MTU: int
 
 EAI_AGAIN: int
@@ -268,11 +283,12 @@ EAI_SERVICE: int
 EAI_SOCKTYPE: int
 if sys.platform != "win32":
     EAI_ADDRFAMILY: int
+    EAI_OVERFLOW: int
+    EAI_SYSTEM: int
+if sys.platform != "win32" and sys.platform != "linux":
     EAI_BADHINTS: int
     EAI_MAX: int
-    EAI_OVERFLOW: int
     EAI_PROTOCOL: int
-    EAI_SYSTEM: int
 
 AI_ADDRCONFIG: int
 AI_ALL: int
@@ -281,7 +297,7 @@ AI_NUMERICHOST: int
 AI_NUMERICSERV: int
 AI_PASSIVE: int
 AI_V4MAPPED: int
-if sys.platform != "win32":
+if sys.platform != "win32" and sys.platform != "linux":
     AI_DEFAULT: int
     AI_MASK: int
     AI_V4MAPPED_CFG: int
@@ -293,6 +309,8 @@ NI_NAMEREQD: int
 NI_NOFQDN: int
 NI_NUMERICHOST: int
 NI_NUMERICSERV: int
+if sys.platform == "linux" and sys.version_info >= (3, 13):
+    NI_IDN: int
 
 TCP_FASTOPEN: int
 TCP_KEEPCNT: int
@@ -318,6 +336,27 @@ if sys.platform != "win32" and sys.platform != "darwin":
     TCP_SYNCNT: int
     TCP_USER_TIMEOUT: int
     TCP_WINDOW_CLAMP: int
+if sys.platform == "linux" and sys.version_info >= (3, 12):
+    TCP_CC_INFO: int
+    TCP_FASTOPEN_CONNECT: int
+    TCP_FASTOPEN_KEY: int
+    TCP_FASTOPEN_NO_COOKIE: int
+    TCP_INQ: int
+    TCP_MD5SIG: int
+    TCP_MD5SIG_EXT: int
+    TCP_QUEUE_SEQ: int
+    TCP_REPAIR: int
+    TCP_REPAIR_OPTIONS: int
+    TCP_REPAIR_QUEUE: int
+    TCP_REPAIR_WINDOW: int
+    TCP_SAVED_SYN: int
+    TCP_SAVE_SYN: int
+    TCP_THIN_DUPACK: int
+    TCP_THIN_LINEAR_TIMEOUTS: int
+    TCP_TIMESTAMP: int
+    TCP_TX_DELAY: int
+    TCP_ULP: int
+    TCP_ZEROCOPY_RECEIVE: int
 
 # --------------------
 # Specifically documented constants
@@ -334,12 +373,13 @@ if sys.platform == "linux":
     CAN_ERR_FLAG: int
     CAN_ERR_MASK: int
     CAN_RAW: int
-    CAN_RAW_ERR_FILTER: int
     CAN_RAW_FILTER: int
     CAN_RAW_LOOPBACK: int
     CAN_RAW_RECV_OWN_MSGS: int
     CAN_RTR_FLAG: int
     CAN_SFF_MASK: int
+    if sys.version_info < (3, 11):
+        CAN_RAW_ERR_FILTER: int
 
 if sys.platform == "linux":
     # Availability: Linux >= 2.6.25
@@ -437,12 +477,13 @@ if sys.platform == "linux":
     AF_RDS: int
     PF_RDS: int
     SOL_RDS: int
+    # These are present in include/linux/rds.h but don't always show up
+    # here.
     RDS_CANCEL_SENT_TO: int
     RDS_CMSG_RDMA_ARGS: int
     RDS_CMSG_RDMA_DEST: int
     RDS_CMSG_RDMA_MAP: int
     RDS_CMSG_RDMA_STATUS: int
-    RDS_CMSG_RDMA_UPDATE: int
     RDS_CONG_MONITOR: int
     RDS_FREE_MR: int
     RDS_GET_MR: int
@@ -456,6 +497,10 @@ if sys.platform == "linux":
     RDS_RDMA_USE_ONCE: int
     RDS_RECVERR: int
 
+    # This is supported by CPython but doesn't seem to be a real thing.
+    # The closest existing constant in rds.h is RDS_CMSG_CONG_UPDATE
+    # RDS_CMSG_RDMA_UPDATE: int
+
 if sys.platform == "win32":
     SIO_RCVALL: int
     SIO_KEEPALIVE_VALS: int
@@ -522,16 +567,17 @@ if sys.platform == "linux":
 if sys.platform != "win32" or sys.version_info >= (3, 9):
     # Documented as only available on BSD, macOS, but empirically sometimes
     # available on Windows
-    AF_LINK: int
+    if sys.platform != "linux":
+        AF_LINK: int
 
 has_ipv6: bool
 
-if sys.platform != "darwin":
+if sys.platform != "darwin" and sys.platform != "linux":
     if sys.platform != "win32" or sys.version_info >= (3, 9):
         BDADDR_ANY: str
         BDADDR_LOCAL: str
 
-if sys.platform != "win32" and sys.platform != "darwin":
+if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
     HCI_FILTER: int  # not in NetBSD or DragonFlyBSD
     HCI_TIME_STAMP: int  # not in FreeBSD, NetBSD, or DragonFlyBSD
     HCI_DATA_DIR: int  # not in FreeBSD, NetBSD, or DragonFlyBSD
@@ -580,36 +626,37 @@ if sys.version_info >= (3, 12):
 if sys.platform == "linux":
     # Netlink is defined by Linux
     AF_NETLINK: int
-    NETLINK_ARPD: int
     NETLINK_CRYPTO: int
     NETLINK_DNRTMSG: int
     NETLINK_FIREWALL: int
     NETLINK_IP6_FW: int
     NETLINK_NFLOG: int
-    NETLINK_ROUTE6: int
     NETLINK_ROUTE: int
-    NETLINK_SKIP: int
-    NETLINK_TAPBASE: int
-    NETLINK_TCPDIAG: int
     NETLINK_USERSOCK: int
-    NETLINK_W1: int
     NETLINK_XFRM: int
+    # Technically still supported by CPython
+    # NETLINK_ARPD: int  # linux 2.0 to 2.6.12 (EOL August 2005)
+    # NETLINK_ROUTE6: int  # linux 2.2 to 2.6.12 (EOL August 2005)
+    # NETLINK_SKIP: int  # linux 2.0 to 2.6.12 (EOL August 2005)
+    # NETLINK_TAPBASE: int  # linux 2.2 to 2.6.12 (EOL August 2005)
+    # NETLINK_TCPDIAG: int  # linux 2.6.0 to 2.6.13 (EOL December 2005)
+    # NETLINK_W1: int  # linux 2.6.13 to 2.6.17 (EOL October 2006)
 
 if sys.platform == "darwin":
     PF_SYSTEM: int
     SYSPROTO_CONTROL: int
 
-if sys.platform != "darwin":
+if sys.platform != "darwin" and sys.platform != "linux":
     if sys.version_info >= (3, 9) or sys.platform != "win32":
         AF_BLUETOOTH: int
 
-if sys.platform != "win32" and sys.platform != "darwin":
+if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
     # Linux and some BSD support is explicit in the docs
     # Windows and macOS do not support in practice
     BTPROTO_HCI: int
     BTPROTO_L2CAP: int
     BTPROTO_SCO: int  # not in FreeBSD
-if sys.platform != "darwin":
+if sys.platform != "darwin" and sys.platform != "linux":
     if sys.version_info >= (3, 9) or sys.platform != "win32":
         BTPROTO_RFCOMM: int
 
@@ -636,13 +683,14 @@ AF_SNA: int
 
 if sys.platform != "win32":
     AF_ROUTE: int
+
+if sys.platform == "darwin":
     AF_SYSTEM: int
 
 if sys.platform != "darwin":
     AF_IRDA: int
 
 if sys.platform != "win32" and sys.platform != "darwin":
-    AF_AAL5: int
     AF_ASH: int
     AF_ATMPVC: int
     AF_ATMSVC: int
@@ -661,10 +709,12 @@ if sys.platform != "win32" and sys.platform != "darwin":
 
 # Miscellaneous undocumented
 
-if sys.platform != "win32":
+if sys.platform != "win32" and sys.platform != "linux":
     LOCAL_PEERCRED: int
 
 if sys.platform != "win32" and sys.platform != "darwin":
+    # Defined in linux socket.h, but this isn't always present for
+    # some reason.
     IPX_TYPE: int
 
 # ===== Classes =====
@@ -792,4 +842,4 @@ def if_nameindex() -> list[tuple[int, str]]: ...
 def if_nametoindex(oname: str, /) -> int: ...
 def if_indextoname(index: int, /) -> str: ...
 
-CAPI: object
+CAPI: CapsuleType