Empty commit to test performance

.github/CODEOWNERS

@@ -13,10 +13,9 @@
 # flake8-pyi
 /crates/ruff_linter/src/rules/flake8_pyi/ @AlexWaygood
 
-# Script for fuzzing the parser/red-knot etc.
-/python/py-fuzzer/ @AlexWaygood
+# Script for fuzzing the parser
+/scripts/fuzz-parser/ @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/**
-              - python/py-fuzzer/**
+              - scripts/fuzz-parser/**
               - .github/workflows/ci.yaml
 
             linter:
@@ -82,7 +82,6 @@ jobs:
             code:
               - "**/*"
               - "!**/*.md"
-              - "crates/red_knot_python_semantic/resources/mdtest/**/*.md"
               - "!docs/**"
               - "!assets/**"
 
@@ -116,7 +115,7 @@ jobs:
 
   cargo-test-linux:
     name: "cargo test (linux)"
-    runs-on: depot-ubuntu-22.04-16
+    runs-on: ubuntu-latest
     needs: determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
@@ -158,36 +157,9 @@ 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-xlarge
+    runs-on: windows-latest
     needs: determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
@@ -225,8 +197,6 @@ 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: |
@@ -240,7 +210,8 @@ jobs:
   cargo-build-release:
     name: "cargo build (release)"
     runs-on: macos-latest
-    if: ${{ github.ref == 'refs/heads/main' }}
+    needs: determine_changes
+    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
@@ -284,11 +255,11 @@ jobs:
           NEXTEST_PROFILE: "ci"
         run: cargo +${{ steps.msrv.outputs.value }} insta test --all-features --unreferenced reject --test-runner nextest
 
-  cargo-fuzz-build:
-    name: "cargo fuzz build"
+  cargo-fuzz:
+    name: "cargo fuzz"
     runs-on: ubuntu-latest
     needs: determine_changes
-    if: ${{ github.ref == 'refs/heads/main' }}
+    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
@@ -297,6 +268,7 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with:
           workspaces: "fuzz -> target"
+          cache-all-crates: "true"
       - name: "Install cargo-binstall"
         uses: cargo-bins/cargo-binstall@main
         with:
@@ -307,7 +279,7 @@ jobs:
       - run: cargo fuzz build -s none
 
   fuzz-parser:
-    name: "fuzz parser"
+    name: "Fuzz the parser"
     runs-on: ubuntu-latest
     needs:
       - cargo-test-linux
@@ -318,7 +290,13 @@ jobs:
       FORCE_COLOR: 1
     steps:
       - uses: actions/checkout@v4
-      - uses: astral-sh/setup-uv@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: actions/download-artifact@v4
         name: Download Ruff binary to test
         id: download-cached-binary
@@ -330,15 +308,7 @@ jobs:
           # Make executable, since artifact download doesn't preserve this
           chmod +x ${{ 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
-          )
+          python scripts/fuzz-parser/fuzz.py 0-500 --test-executable ${{ steps.download-cached-binary.outputs.download-path }}/ruff
 
   scripts:
     name: "test scripts"
@@ -362,7 +332,7 @@ jobs:
 
   ecosystem:
     name: "ecosystem"
-    runs-on: depot-ubuntu-latest-8
+    runs-on: ubuntu-latest
     needs:
       - cargo-test-linux
       - determine_changes
@@ -383,7 +353,7 @@ jobs:
           name: ruff
           path: target/debug
 
-      - uses: dawidd6/action-download-artifact@v7
+      - uses: dawidd6/action-download-artifact@v6
         name: Download baseline Ruff binary
         with:
           name: ruff
@@ -559,7 +529,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: Install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v3
       - uses: Swatinem/rust-cache@v2
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
@@ -592,12 +562,12 @@ jobs:
         run: rustup show
       - name: "Cache rust"
         uses: Swatinem/rust-cache@v2
-      - name: "Run checks"
+      - name: "Formatter progress"
         run: scripts/formatter_ecosystem_checks.sh
       - name: "Github step summary"
-        run: cat target/formatter-ecosystem/stats.txt > $GITHUB_STEP_SUMMARY
+        run: cat target/progress_projects_stats.txt > $GITHUB_STEP_SUMMARY
       - name: "Remove checkouts from cache"
-        run: rm -r target/formatter-ecosystem
+        run: rm -r target/progress_projects
 
   check-ruff-lsp:
     name: "test ruff-lsp"

.github/workflows/daily_fuzz.yaml

@@ -32,7 +32,13 @@ jobs:
     if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
     steps:
       - uses: actions/checkout@v4
-      - uses: astral-sh/setup-uv@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
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
@@ -43,16 +49,7 @@ jobs:
         # but this is outweighed by the fact that a release build takes *much* longer to compile in CI
         run: cargo build --locked
       - name: Fuzz
-        run: |
-          (
-            uvx \
-            --python=3.12 \
-            --from=./python/py-fuzzer \
-            fuzz \
-            --test-executable=target/debug/ruff \
-            --bin=ruff \
-            $(shuf -i 0-9999999999999999999 -n 1000)
-          )
+        run: python scripts/fuzz-parser/fuzz.py $(shuf -i 0-9999999999999999999 -n 1000) --test-executable target/debug/ruff
 
   create-issue-on-failure:
     name: Create an issue if the daily fuzz surfaced any bugs

.github/workflows/pr-comment.yaml

@@ -17,7 +17,7 @@ jobs:
   comment:
     runs-on: ubuntu-latest
     steps:
-      - uses: dawidd6/action-download-artifact@v7
+      - uses: dawidd6/action-download-artifact@v6
         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@v7
+      - uses: dawidd6/action-download-artifact@v6
         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.13.0
+        uses: cloudflare/wrangler-action@v3.12.1
         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@v4
+        uses: astral-sh/setup-uv@v3
       - uses: actions/download-artifact@v4
         with:
           pattern: wheels-*

.github/workflows/release.yml

@@ -1,4 +1,4 @@
-# This file was autogenerated by dist: https://opensource.axo.dev/cargo-dist/
+# This file was autogenerated by cargo-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 dist (archives, installers, hashes)
+# * builds artifacts with cargo-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 dist-able).
+# package (erroring out if it doesn't have the given version or isn't cargo-dist-able).
 #
 # If PACKAGE_NAME isn't specified, then the announcement will be for all
-# (dist-able) packages in the workspace with that version (this mode is
+# (cargo-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 'dist plan' (or host) to determine what tasks we need to do
+  # Run 'cargo 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 dist
+      - name: Install cargo-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.25.2-prerelease.3/cargo-dist-installer.sh | sh"
-      - name: Cache dist
+        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
         uses: actions/upload-artifact@v4
         with:
           name: cargo-dist-cache
-          path: ~/.cargo/bin/dist
+          path: ~/.cargo/bin/cargo-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: |
-          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"
+          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"
           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 dist
+      - name: Install cached cargo-dist
         uses: actions/download-artifact@v4
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/dist
+      - run: chmod +x ~/.cargo/bin/cargo-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: |
-          dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
-          echo "dist ran successfully"
+          cargo dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
+          echo "cargo 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 dist
+      - name: Install cached cargo-dist
         uses: actions/download-artifact@v4
         with:
           name: cargo-dist-cache
           path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/dist
+      - run: chmod +x ~/.cargo/bin/cargo-dist
       # Fetch artifacts from scratch-storage
       - name: Fetch artifacts
         uses: actions/download-artifact@v4
@@ -191,7 +191,7 @@ jobs:
       - id: host
         shell: bash
         run: |
-          dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
+          cargo 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

@@ -22,7 +22,7 @@ repos:
       - id: validate-pyproject
 
   - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.19
+    rev: 0.7.18
     hooks:
       - id: mdformat
         additional_dependencies:
@@ -36,7 +36,7 @@ repos:
           )$
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.43.0
+    rev: v0.42.0
     hooks:
       - id: markdownlint-fix
         exclude: |
@@ -59,7 +59,7 @@ repos:
           - black==24.10.0
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.28.1
+    rev: v1.27.3
     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.8.1
+    rev: v0.7.4
     hooks:
       - id: ruff-format
       - id: ruff
@@ -83,7 +83,7 @@ repos:
 
   # Prettier
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.4.1
+    rev: v3.3.3
     hooks:
       - id: prettier
         types: [yaml]

BREAKING_CHANGES.md

@@ -1,30 +1,5 @@
 # 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
@@ -192,7 +167,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,145 +1,5 @@
 # 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
@@ -257,7 +117,7 @@ The following fixes have been stabilized:
 ### 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))
 
@@ -1118,7 +978,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 `pep484-style-positional-only-parameter` (`PYI063`) ([#11699](https://github.com/astral-sh/ruff/pull/11699))
+- \[`flake8-pyi`\] Implement `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
@@ -1272,7 +1132,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))
 
@@ -1647,7 +1507,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
-    `#[derive(ViolationMetadata)]` to see examples.
+    `#[violation]` 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,7 @@ 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.4.0" }
+dir-test = { version = "0.3.0" }
 dunce = { version = "1.0.5" }
 drop_bomb = { version = "0.1.5" }
 env_logger = { version = "0.11.0" }
@@ -111,14 +111,14 @@ 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.13.4" }
+pyproject-toml = { version = "0.9.0" }
 quick-junit = { version = "0.5.0" }
 quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "e68679b3a9c2b5cfd8eab92de89edf4073b03601" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "254c749b02cde2fd29852a7463a33e800b771758" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -151,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.2.0" }
+unicode-width = { version = "0.1.11" }
 unicode_names2 = { version = "1.2.2" }
 unicode-normalization = { version = "0.1.23" }
 ureq = { version = "2.9.6" }
@@ -248,10 +248,10 @@ debug = 1
 [profile.dist]
 inherits = "release"
 
-# Config for 'dist'
+# Config for 'cargo dist'
 [workspace.metadata.dist]
-# The preferred dist version to use in CI (Cargo.toml SemVer syntax)
-cargo-dist-version = "0.25.2-prerelease.3"
+# The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax)
+cargo-dist-version = "0.22.1"
 # CI backends to support
 ci = "github"
 # The installers to generate for each app
@@ -282,13 +282,13 @@ targets = [
 ]
 # Whether to auto-include files like READMEs, LICENSEs, and CHANGELOGs (default true)
 auto-includes = false
-# Whether dist should create a Github Release or use an existing draft
+# Whether cargo-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 dist should use to create the GitHub release
+# Which phase cargo-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
@@ -297,10 +297,14 @@ 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 = ["$XDG_BIN_HOME/", "$XDG_DATA_HOME/../bin", "~/.local/bin"]
+install-path = "CARGO_HOME"

README.md

@@ -136,8 +136,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.8.1/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.8.1/install.ps1 | iex"
+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"
 ```
 
 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.8.1
+  rev: v0.7.4
   hooks:
     # Run the linter.
     - id: ruff
@@ -238,8 +238,8 @@ exclude = [
 line-length = 88
 indent-width = 4
 
-# Assume Python 3.9
-target-version = "py39"
+# Assume Python 3.8
+target-version = "py38"
 
 [lint]
 # Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.

clippy.toml

@@ -1,25 +1,21 @@
 doc-valid-idents = [
-    "..",
-    "CodeQL",
-    "FastAPI",
-    "IPython",
-    "LangChain",
-    "LibCST",
-    "McCabe",
-    "NumPy",
-    "SCREAMING_SNAKE_CASE",
-    "SQLAlchemy",
-    "StackOverflow",
-    "PyCharm",
-    "SNMPv1",
-    "SNMPv2",
-    "SNMPv3",
-    "PyFlakes"
+  "..",
+  "CodeQL",
+  "FastAPI",
+  "IPython",
+  "LangChain",
+  "LibCST",
+  "McCabe",
+  "NumPy",
+  "SCREAMING_SNAKE_CASE",
+  "SQLAlchemy",
+  "StackOverflow",
+  "PyCharm",
 ]
 
 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/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

@@ -12,7 +12,7 @@ use red_knot_workspace::watch;
 use red_knot_workspace::watch::WorkspaceWatcher;
 use red_knot_workspace::workspace::settings::Configuration;
 use red_knot_workspace::workspace::WorkspaceMetadata;
-use ruff_db::diagnostic::CompileDiagnostic;
+use ruff_db::diagnostic::Diagnostic;
 use ruff_db::system::{OsSystem, System, SystemPath, SystemPathBuf};
 use salsa::plumbing::ZalsaDatabase;
 use target_version::TargetVersion;
@@ -297,7 +297,7 @@ impl MainLoop {
         while let Ok(message) = self.receiver.recv() {
             match message {
                 MainLoopMessage::CheckWorkspace => {
-                    let db = db.clone();
+                    let db = db.snapshot();
                     let sender = self.sender.clone();
 
                     // Spawn a new task that checks the workspace. This needs to be done in a separate thread
@@ -380,7 +380,7 @@ impl MainLoopCancellationToken {
 enum MainLoopMessage {
     CheckWorkspace,
     CheckCompleted {
-        result: Vec<CompileDiagnostic>,
+        result: Vec<Box<dyn Diagnostic>>,
         revision: u64,
     },
     ApplyChanges(Vec<watch::ChangeEvent>),

crates/red_knot/tests/file_watching.rs

@@ -1,23 +1,26 @@
 #![allow(clippy::disallowed_names)]
 
 use std::io::Write;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 
 use anyhow::{anyhow, Context};
+
 use red_knot_python_semantic::{resolve_module, ModuleName, Program, PythonVersion, SitePackages};
 use red_knot_workspace::db::{Db, RootDatabase};
-use red_knot_workspace::watch::{directory_watcher, ChangeEvent, WorkspaceWatcher};
+use red_knot_workspace::watch;
+use red_knot_workspace::watch::{directory_watcher, WorkspaceWatcher};
 use red_knot_workspace::workspace::settings::{Configuration, SearchPathConfiguration};
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::files::{system_path_to_file, File, FileError};
 use ruff_db::source::source_text;
 use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
+use ruff_db::testing::setup_logging;
 use ruff_db::Upcast;
 
 struct TestCase {
     db: RootDatabase,
     watcher: Option<WorkspaceWatcher>,
-    changes_receiver: crossbeam::channel::Receiver<Vec<ChangeEvent>>,
+    changes_receiver: crossbeam::channel::Receiver<Vec<watch::ChangeEvent>>,
     /// The temporary directory that contains the test files.
     /// We need to hold on to it in the test case or the temp files get deleted.
     _temp_dir: tempfile::TempDir,
@@ -38,87 +41,44 @@ impl TestCase {
         &self.db
     }
 
-    #[track_caller]
-    fn stop_watch<M>(&mut self, matcher: M) -> Vec<ChangeEvent>
-    where
-        M: MatchEvent,
-    {
-        // track_caller is unstable for lambdas -> That's why this is a fn
-        #[track_caller]
-        fn panic_with_formatted_events(events: Vec<ChangeEvent>) -> Vec<ChangeEvent> {
-            panic!(
-                "Didn't observe expected change:\n{}",
-                events
-                    .into_iter()
-                    .map(|event| format!("  - {event:?}"))
-                    .collect::<Vec<_>>()
-                    .join("\n")
-            )
-        }
-
-        self.try_stop_watch(matcher, Duration::from_secs(10))
-            .unwrap_or_else(panic_with_formatted_events)
+    fn stop_watch(&mut self) -> Vec<watch::ChangeEvent> {
+        self.try_stop_watch(Duration::from_secs(10))
+            .expect("Expected watch changes but observed none")
     }
 
-    fn try_stop_watch<M>(
-        &mut self,
-        mut matcher: M,
-        timeout: Duration,
-    ) -> Result<Vec<ChangeEvent>, Vec<ChangeEvent>>
-    where
-        M: MatchEvent,
-    {
-        tracing::debug!("Try stopping watch with timeout {:?}", timeout);
-
+    fn try_stop_watch(&mut self, timeout: Duration) -> Option<Vec<watch::ChangeEvent>> {
         let watcher = self
             .watcher
             .take()
             .expect("Cannot call `stop_watch` more than once");
 
-        let start = Instant::now();
-        let mut all_events = Vec::new();
-
-        loop {
-            let events = self
-                .changes_receiver
-                .recv_timeout(Duration::from_millis(100))
-                .unwrap_or_default();
-
-            if events
-                .iter()
-                .any(|event| matcher.match_event(event) || event.is_rescan())
-            {
-                all_events.extend(events);
-                break;
-            }
-
-            all_events.extend(events);
-
-            if start.elapsed() > timeout {
-                return Err(all_events);
-            }
-        }
-
+        let mut all_events = self
+            .changes_receiver
+            .recv_timeout(timeout)
+            .unwrap_or_default();
         watcher.flush();
-        tracing::debug!("Flushed file watcher");
         watcher.stop();
-        tracing::debug!("Stopping file watcher");
 
-        // Consume remaining events
         for event in &self.changes_receiver {
             all_events.extend(event);
         }
 
-        Ok(all_events)
+        if all_events.is_empty() {
+            return None;
+        }
+
+        Some(all_events)
     }
 
-    fn take_watch_changes(&self) -> Vec<ChangeEvent> {
+    fn take_watch_changes(&self) -> Vec<watch::ChangeEvent> {
         self.try_take_watch_changes(Duration::from_secs(10))
             .expect("Expected watch changes but observed none")
     }
 
-    fn try_take_watch_changes(&self, timeout: Duration) -> Option<Vec<ChangeEvent>> {
-        let watcher = self.watcher.as_ref()?;
+    fn try_take_watch_changes(&self, timeout: Duration) -> Option<Vec<watch::ChangeEvent>> {
+        let Some(watcher) = &self.watcher else {
+            return None;
+        };
 
         let mut all_events = self
             .changes_receiver
@@ -140,7 +100,7 @@ impl TestCase {
         Some(all_events)
     }
 
-    fn apply_changes(&mut self, changes: Vec<ChangeEvent>) {
+    fn apply_changes(&mut self, changes: Vec<watch::ChangeEvent>) {
         self.db.apply_changes(changes, Some(&self.configuration));
     }
 
@@ -176,23 +136,6 @@ impl TestCase {
     }
 }
 
-trait MatchEvent {
-    fn match_event(&mut self, event: &ChangeEvent) -> bool;
-}
-
-fn event_for_file(name: &str) -> impl MatchEvent + '_ {
-    |event: &ChangeEvent| event.file_name() == Some(name)
-}
-
-impl<F> MatchEvent for F
-where
-    F: FnMut(&ChangeEvent) -> bool,
-{
-    fn match_event(&mut self, event: &ChangeEvent) -> bool {
-        (*self)(event)
-    }
-}
-
 trait SetupFiles {
     fn setup(self, root_path: &SystemPath, workspace_path: &SystemPath) -> anyhow::Result<()>;
 }
@@ -368,7 +311,7 @@ fn new_file() -> anyhow::Result<()> {
 
     std::fs::write(foo_path.as_std_path(), "print('Hello')")?;
 
-    let changes = case.stop_watch(event_for_file("foo.py"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -391,7 +334,7 @@ fn new_ignored_file() -> anyhow::Result<()> {
 
     std::fs::write(foo_path.as_std_path(), "print('Hello')")?;
 
-    let changes = case.stop_watch(event_for_file("foo.py"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -413,7 +356,7 @@ fn changed_file() -> anyhow::Result<()> {
 
     update_file(&foo_path, "print('Version 2')")?;
 
-    let changes = case.stop_watch(event_for_file("foo.py"));
+    let changes = case.stop_watch();
 
     assert!(!changes.is_empty());
 
@@ -438,7 +381,7 @@ fn deleted_file() -> anyhow::Result<()> {
 
     std::fs::remove_file(foo_path.as_std_path())?;
 
-    let changes = case.stop_watch(event_for_file("foo.py"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -470,7 +413,7 @@ fn move_file_to_trash() -> anyhow::Result<()> {
         trash_path.join("foo.py").as_std_path(),
     )?;
 
-    let changes = case.stop_watch(event_for_file("foo.py"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -502,7 +445,7 @@ fn move_file_to_workspace() -> anyhow::Result<()> {
 
     std::fs::rename(foo_path.as_std_path(), foo_in_workspace_path.as_std_path())?;
 
-    let changes = case.stop_watch(event_for_file("foo.py"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -530,7 +473,7 @@ fn rename_file() -> anyhow::Result<()> {
 
     std::fs::rename(foo_path.as_std_path(), bar_path.as_std_path())?;
 
-    let changes = case.stop_watch(event_for_file("bar.py"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -574,7 +517,7 @@ fn directory_moved_to_workspace() -> anyhow::Result<()> {
     std::fs::rename(sub_original_path.as_std_path(), sub_new_path.as_std_path())
         .with_context(|| "Failed to move sub directory")?;
 
-    let changes = case.stop_watch(event_for_file("sub"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -633,7 +576,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
     std::fs::rename(sub_path.as_std_path(), trashed_sub.as_std_path())
         .with_context(|| "Failed to move the sub directory to the trash")?;
 
-    let changes = case.stop_watch(event_for_file("sub"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -695,8 +638,7 @@ fn directory_renamed() -> anyhow::Result<()> {
     std::fs::rename(sub_path.as_std_path(), foo_baz.as_std_path())
         .with_context(|| "Failed to move the sub directory")?;
 
-    // Linux and windows only emit an event for the newly created root directory, but not for every new component.
-    let changes = case.stop_watch(event_for_file("sub"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -769,7 +711,7 @@ fn directory_deleted() -> anyhow::Result<()> {
     std::fs::remove_dir_all(sub_path.as_std_path())
         .with_context(|| "Failed to remove the sub directory")?;
 
-    let changes = case.stop_watch(event_for_file("sub"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -806,7 +748,7 @@ fn search_path() -> anyhow::Result<()> {
 
     std::fs::write(site_packages.join("a.py").as_std_path(), "class A: ...")?;
 
-    let changes = case.stop_watch(event_for_file("a.py"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -837,7 +779,7 @@ fn add_search_path() -> anyhow::Result<()> {
 
     std::fs::write(site_packages.join("a.py").as_std_path(), "class A: ...")?;
 
-    let changes = case.stop_watch(event_for_file("a.py"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -866,9 +808,9 @@ fn remove_search_path() -> anyhow::Result<()> {
 
     std::fs::write(site_packages.join("a.py").as_std_path(), "class A: ...")?;
 
-    let changes = case.try_stop_watch(|_: &ChangeEvent| true, Duration::from_millis(100));
+    let changes = case.try_stop_watch(Duration::from_millis(100));
 
-    assert_eq!(changes, Err(vec![]));
+    assert_eq!(changes, None);
 
     Ok(())
 }
@@ -906,7 +848,7 @@ fn changed_versions_file() -> anyhow::Result<()> {
         "os: 3.0-",
     )?;
 
-    let changes = case.stop_watch(event_for_file("VERSIONS"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -959,7 +901,7 @@ fn hard_links_in_workspace() -> anyhow::Result<()> {
     // Write to the hard link target.
     update_file(foo_path, "print('Version 2')").context("Failed to update foo.py")?;
 
-    let changes = case.stop_watch(event_for_file("foo.py"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -1030,7 +972,7 @@ fn hard_links_to_target_outside_workspace() -> anyhow::Result<()> {
     // Write to the hard link target.
     update_file(foo_path, "print('Version 2')").context("Failed to update foo.py")?;
 
-    let changes = case.stop_watch(ChangeEvent::is_changed);
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -1069,7 +1011,7 @@ mod unix {
         )
         .with_context(|| "Failed to set file permissions.")?;
 
-        let changes = case.stop_watch(event_for_file("foo.py"));
+        let changes = case.stop_watch();
 
         case.apply_changes(changes);
 
@@ -1167,7 +1109,7 @@ mod unix {
         update_file(baz_workspace, "def baz(): print('Version 3')")
             .context("Failed to update bar/baz.py")?;
 
-        let changes = case.stop_watch(event_for_file("baz.py"));
+        let changes = case.stop_watch();
 
         case.apply_changes(changes);
 
@@ -1238,7 +1180,7 @@ mod unix {
         update_file(&patched_bar_baz, "def baz(): print('Version 2')")
             .context("Failed to update bar/baz.py")?;
 
-        let changes = case.stop_watch(event_for_file("baz.py"));
+        let changes = case.stop_watch();
 
         case.apply_changes(changes);
 
@@ -1346,7 +1288,7 @@ mod unix {
         update_file(&baz_original, "def baz(): print('Version 2')")
             .context("Failed to update bar/baz.py")?;
 
-        let changes = case.stop_watch(event_for_file("baz.py"));
+        let changes = case.stop_watch();
 
         case.apply_changes(changes);
 
@@ -1400,7 +1342,7 @@ fn nested_packages_delete_root() -> anyhow::Result<()> {
 
     std::fs::remove_file(case.workspace_path("pyproject.toml").as_std_path())?;
 
-    let changes = case.stop_watch(ChangeEvent::is_deleted);
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -1412,6 +1354,7 @@ fn nested_packages_delete_root() -> anyhow::Result<()> {
 
 #[test]
 fn added_package() -> anyhow::Result<()> {
+    let _ = setup_logging();
     let mut case = setup([
         (
             "pyproject.toml",
@@ -1453,7 +1396,7 @@ fn added_package() -> anyhow::Result<()> {
     )
     .context("failed to write pyproject.toml for package b")?;
 
-    let changes = case.stop_watch(event_for_file("pyproject.toml"));
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 
@@ -1496,7 +1439,7 @@ fn removed_package() -> anyhow::Result<()> {
     std::fs::remove_dir_all(case.workspace_path("packages/b").as_std_path())
         .context("failed to remove package 'b'")?;
 
-    let changes = case.stop_watch(ChangeEvent::is_deleted);
+    let changes = case.stop_watch();
 
     case.apply_changes(changes);
 

crates/red_knot_python_semantic/Cargo.toml

@@ -49,8 +49,6 @@ anyhow = { workspace = true }
 dir-test = { workspace = true }
 insta = { workspace = true }
 tempfile = { workspace = true }
-quickcheck = { version = "1.0.3", default-features = false }
-quickcheck_macros = { version = "1.0.0" }
 
 [lints]
 workspace = true

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

@@ -1,128 +0,0 @@
-# `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

@@ -1,62 +0,0 @@
-# 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/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(function parameter type)
+    reveal_type(args)  # revealed: @Todo
 
     return (*args, 1)
 
 # TODO should be tuple[Literal[True], Literal["a"], int]
-reveal_type(append_int(True, "a"))  # revealed: @Todo(full tuple[...] support)
+reveal_type(append_int(True, "a"))  # revealed: @Todo
 ```

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

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

@@ -1,61 +0,0 @@
-# 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(full tuple[...] support)
-reveal_type(f)  # revealed: @Todo(full tuple[...] support)
-reveal_type(g)  # revealed: @Todo(full tuple[...] support)
+reveal_type(e)  # revealed: @Todo
+reveal_type(f)  # revealed: @Todo
+reveal_type(g)  # revealed: @Todo
 
 # TODO: support more kinds of type expressions in annotations
-reveal_type(h)  # revealed: @Todo(full tuple[...] support)
+reveal_type(h)  # revealed: @Todo
 
 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(return type)
+reveal_type("foo" + A())  # revealed: @Todo
 
 reveal_type(A() + b"foo")  # revealed: A
 # TODO should be `A` since `bytes.__add__` doesn't support `A` instances
@@ -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(return type)
+reveal_type(() + A())  # revealed: @Todo
 
 literal_string_instance = "foo" * 1_000_000_000
 # the test is not testing what it's meant to be testing if this isn't a `LiteralString`:
@@ -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(return type)
+reveal_type(literal_string_instance + A())  # revealed: @Todo
 ```
 
 ## 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(generic types.CoroutineType)
+reveal_type(get_int_async())  # revealed: @Todo
 ```
 
 ## 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(return type)
+reveal_type(bar())  # revealed: @Todo
 ```
 
 ## Invalid callable

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

@@ -58,9 +58,7 @@ reveal_type(c >= d)  # revealed: Literal[True]
 #### Results with Ambiguity
 
 ```py
-def bool_instance() -> bool:
-    return True
-
+def bool_instance() -> bool: ...
 def int_instance() -> int:
     return 42
 
@@ -136,158 +134,23 @@ 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: 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]
+    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: ...
 
 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,8 +4,6 @@
 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
 
@@ -35,8 +33,4 @@ 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(exception type)
+        reveal_type(e)  # revealed: @Todo
     except y as f:
         # TODO: should be `OSError | RuntimeError`
-        reveal_type(f)  # revealed: @Todo(exception type)
+        reveal_type(f)  # revealed: @Todo
     except z as g:
         # TODO: should be `BaseException`
-        reveal_type(g)  # revealed: @Todo(exception type)
+        reveal_type(g)  # revealed: @Todo
 ```

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

@@ -22,22 +22,3 @@ 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(instance attributes)
+reveal_type(box.data)  # revealed: @Todo
 
 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(instance attributes)
+reveal_type(secure_box.data)  # revealed: @Todo
 ```
 
 ## Cyclical class definition
@@ -60,20 +60,52 @@ reveal_type(S)  # revealed: Literal[S]
 
 ## Type params
 
-A PEP695 type variable defines a value of type `typing.TypeVar`.
+A PEP695 type variable defines a value of type `typing.TypeVar` with attributes `__name__`,
+`__bounds__`, `__constraints__`, and `__default__` (the latter three all lazily evaluated):
 
 ```py
-def f[T]():
+def f[T, U: A, V: (A, B), W = A, X: A = A1]():
     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:
+A typevar with less than two constraints emits a diagnostic and is treated as unconstrained:
 
 ```py
 # error: [invalid-typevar-constraints] "TypeVar must have at least two constrained types"
 def f[T: (int,)]():
-    pass
+    reveal_type(T.__constraints__)  # revealed: tuple[()]
 ```

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

@@ -78,7 +78,7 @@ from other import Literal
 a1: Literal[26]
 
 def f():
-    reveal_type(a1)  # revealed: @Todo(generics)
+    reveal_type(a1)  # revealed: @Todo
 ```
 
 ## 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(async iterables/iterators)
+    # revealed: @Todo
     # error: [possibly-unresolved-reference]
     reveal_type(x)
 ```
@@ -40,6 +40,6 @@ async def foo():
         pass
 
     # error: [possibly-unresolved-reference]
-    # revealed: @Todo(async iterables/iterators)
+    # revealed: @Todo
     reveal_type(x)
 ```

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

@@ -52,29 +52,3 @@ 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(metaclass not a class)
+reveal_type(A.__class__)  # revealed: @Todo
 ```
 
 ## Cyclic

crates/red_knot_python_semantic/resources/mdtest/mro.md

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

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

@@ -1,32 +0,0 @@
-## 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

@@ -1,64 +0,0 @@
-# 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/scopes/moduletype_attrs.md

@@ -17,7 +17,8 @@ reveal_type(__doc__)  # revealed: str | None
 # (needs support for `*` imports)
 reveal_type(__spec__)  # revealed: Unknown | None
 
-reveal_type(__path__)  # revealed: @Todo(generics)
+# TODO: generics
+reveal_type(__path__)  # revealed: @Todo
 
 class X:
     reveal_type(__name__)  # revealed: str
@@ -63,7 +64,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(instance attributes)
+reveal_type(typing.__dict__)  # revealed: @Todo
 ```
 
 Typeshed includes a fake `__getattr__` method in the stub for `types.ModuleType` to help out with
@@ -95,8 +96,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(instance attributes)
-reveal_type(foo_dict)  # revealed: @Todo(instance attributes)
+reveal_type(foo.__dict__)  # revealed: @Todo
+reveal_type(foo_dict)  # revealed: @Todo
 ```
 
 ## 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(return type)
+reveal_type(a)  # revealed: @Todo
 ```
 
 ## 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(return type)
+reveal_type(byte_slice1)  # revealed: @Todo
 
 def bytes_instance() -> bytes: ...
 
 byte_slice2 = bytes_instance()[0:5]
 # TODO: Support overloads... Should be `bytes`
-reveal_type(byte_slice2)  # revealed: @Todo(return type)
+reveal_type(byte_slice2)  # revealed: @Todo
 ```

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

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

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

@@ -30,11 +30,10 @@ reveal_type(Identity()[0])  # revealed: int
 ## Getitem union
 
 ```py
-def bool_instance() -> bool:
-    return True
+flag = True
 
 class Identity:
-    if bool_instance():
+    if flag:
 
         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(return type)
+reveal_type(x[0])  # revealed: @Todo
 
 # TODO reveal list
-reveal_type(x[0:1])  # revealed: @Todo(return type)
+reveal_type(x[0:1])  # revealed: @Todo
 
 # TODO error
-reveal_type(x["a"])  # revealed: @Todo(return type)
+reveal_type(x["a"])  # revealed: @Todo
 ```
 
 ## 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(return type)
+reveal_type(a)  # revealed: @Todo
 ```
 
 ## 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(return type)
+reveal_type(substring1)  # revealed: @Todo
 
 def str_instance() -> str: ...
 
 substring2 = str_instance()[0:5]
 # TODO: Support overloads... Should be `str`
-reveal_type(substring2)  # revealed: @Todo(return type)
+reveal_type(substring2)  # revealed: @Todo
 ```
 
 ## 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(return type)
+reveal_type(tuple_slice)  # revealed: @Todo
 ```

crates/red_knot_python_semantic/resources/mdtest/sys_version_info.md

@@ -58,7 +58,8 @@ reveal_type(sys.version_info >= (3, 9, 1, "final", 0))  # revealed: bool
 # emitting a lint diagnostic of some kind warning them about the probable error?
 reveal_type(sys.version_info >= (3, 9, 1, "final", 0, 5))  # revealed: bool
 
-reveal_type(sys.version_info == (3, 8, 1, "finallllll", 0))  # revealed: Literal[False]
+# TODO: this should be `Literal[False]`; see #14279
+reveal_type(sys.version_info == (3, 9, 1, "finallllll", 0))  # revealed: bool
 ```
 
 ## Imports and aliases
@@ -112,9 +113,9 @@ properties on instance types:
 ```py path=b.py
 import sys
 
-reveal_type(sys.version_info.micro)  # revealed: @Todo(instance attributes)
-reveal_type(sys.version_info.releaselevel)  # revealed: @Todo(instance attributes)
-reveal_type(sys.version_info.serial)  # revealed: @Todo(instance attributes)
+reveal_type(sys.version_info.micro)  # revealed: @Todo
+reveal_type(sys.version_info.releaselevel)  # revealed: @Todo
+reveal_type(sys.version_info.serial)  # revealed: @Todo
 ```
 
 ## Accessing fields by index/slice

crates/red_knot_python_semantic/resources/mdtest/type_alias.md

@@ -1,71 +0,0 @@
-# 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(starred unpacking)
+reveal_type(b)  # revealed: @Todo
 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(starred unpacking)
+reveal_type(b)  # revealed: @Todo
 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(starred unpacking)
+reveal_type(b)  # revealed: @Todo
 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(starred unpacking)
+reveal_type(b)  # revealed: @Todo
 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(starred unpacking)
+reveal_type(c)  # revealed: @Todo
 ```
 
 ### Starred expression (6)
@@ -138,7 +138,7 @@ reveal_type(c)  # revealed: @Todo(starred unpacking)
 reveal_type(a)  # revealed: Literal[1]
 reveal_type(b)  # revealed: Unknown
 reveal_type(c)  # revealed: Unknown
-reveal_type(d)  # revealed: @Todo(starred unpacking)
+reveal_type(d)  # revealed: @Todo
 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(starred unpacking)
+reveal_type(b)  # revealed: @Todo
 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(starred unpacking)
+reveal_type(b)  # revealed: @Todo
 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(starred unpacking)
+reveal_type(b)  # revealed: @Todo
 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(starred unpacking)
+reveal_type(b)  # revealed: @Todo
 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(starred unpacking)
+reveal_type(c)  # revealed: @Todo
 ```

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

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

crates/red_knot_python_semantic/src/db.rs

@@ -19,7 +19,6 @@ pub(crate) mod tests {
     use super::Db;
 
     #[salsa::db]
-    #[derive(Clone)]
     pub(crate) struct TestDb {
         storage: salsa::Storage<Self>,
         files: Files,

crates/red_knot_python_semantic/src/module_resolver/resolver.rs

@@ -416,7 +416,7 @@ impl<'db> Iterator for SearchPathIterator<'db> {
     }
 }
 
-impl FusedIterator for SearchPathIterator<'_> {}
+impl<'db> FusedIterator for SearchPathIterator<'db> {}
 
 /// 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/semantic_index/builder.rs

@@ -36,25 +36,12 @@ 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, LoopState)>,
+    scope_stack: Vec<FileScopeId>,
     /// The assignments we're currently visiting, with
     /// the most recent visit at the end of the Vec
     current_assignments: Vec<CurrentAssignment<'db>>,
@@ -116,24 +103,9 @@ 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));
@@ -159,16 +131,15 @@ impl<'db> SemanticIndexBuilder<'db> {
         let scope_id = ScopeId::new(self.db, self.file, file_scope_id, countme::Count::default());
 
         self.scope_ids_by_scope.push(scope_id);
-        let previous = self.scopes_by_node.insert(node.node_key(), file_scope_id);
-        debug_assert_eq!(previous, None);
+        self.scopes_by_node.insert(node.node_key(), file_scope_id);
 
         debug_assert_eq!(ast_id_scope, file_scope_id);
 
-        self.scope_stack.push((file_scope_id, LoopState::NotInLoop));
+        self.scope_stack.push(file_scope_id);
     }
 
     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;
@@ -314,6 +285,10 @@ impl<'db> SemanticIndexBuilder<'db> {
         self.current_assignments.last().copied()
     }
 
+    fn current_assignment_mut(&mut self) -> Option<&mut CurrentAssignment<'db>> {
+        self.current_assignments.last_mut()
+    }
+
     fn add_pattern_constraint(
         &mut self,
         subject: &ast::Expr,
@@ -614,27 +589,6 @@ 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 {
@@ -682,7 +636,7 @@ where
                         ast::Expr::List(_) | ast::Expr::Tuple(_) => {
                             Some(CurrentAssignment::Assign {
                                 node,
-
+                                first: true,
                                 unpack: Some(Unpack::new(
                                     self.db,
                                     self.file,
@@ -696,9 +650,11 @@ where
                                 )),
                             })
                         }
-                        ast::Expr::Name(_) => {
-                            Some(CurrentAssignment::Assign { node, unpack: None })
-                        }
+                        ast::Expr::Name(_) => Some(CurrentAssignment::Assign {
+                            node,
+                            unpack: None,
+                            first: false,
+                        }),
                         _ => None,
                     };
 
@@ -763,22 +719,7 @@ where
                 let mut constraints = vec![constraint];
                 self.visit_body(&node.body);
                 let mut post_clauses: Vec<FlowSnapshot> = vec![];
-                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 {
+                for clause in &node.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());
@@ -788,15 +729,24 @@ 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,
@@ -813,10 +763,7 @@ 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.
@@ -855,9 +802,7 @@ where
                 self.visit_body(body);
             }
             ast::Stmt::Break(_) => {
-                if self.loop_state().is_inside() {
-                    self.loop_break_states.push(self.flow_snapshot());
-                }
+                self.loop_break_states.push(self.flow_snapshot());
             }
 
             ast::Stmt::For(
@@ -884,10 +829,7 @@ 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);
@@ -1076,13 +1018,18 @@ where
 
                 if is_definition {
                     match self.current_assignment() {
-                        Some(CurrentAssignment::Assign { node, unpack }) => {
+                        Some(CurrentAssignment::Assign {
+                            node,
+                            first,
+                            unpack,
+                        }) => {
                             self.add_definition(
                                 symbol,
                                 AssignmentDefinitionNodeRef {
                                     unpack,
                                     value: &node.value,
                                     name: name_node,
+                                    first,
                                 },
                             );
                         }
@@ -1133,6 +1080,11 @@ where
                     }
                 }
 
+                if let Some(CurrentAssignment::Assign { first, .. }) = self.current_assignment_mut()
+                {
+                    *first = false;
+                }
+
                 walk_expr(self, expr);
             }
             ast::Expr::Named(node) => {
@@ -1179,8 +1131,8 @@ where
                 // AST inspection, so we can't simplify here, need to record test expression for
                 // later checking)
                 self.visit_expr(test);
-                let pre_if = self.flow_snapshot();
                 let constraint = self.record_expression_constraint(test);
+                let pre_if = self.flow_snapshot();
                 self.visit_expr(body);
                 let post_body = self.flow_snapshot();
                 self.flow_restore(pre_if);
@@ -1339,6 +1291,7 @@ where
 enum CurrentAssignment<'a> {
     Assign {
         node: &'a ast::StmtAssign,
+        first: bool,
         unpack: Option<Unpack<'a>>,
     },
     AnnAssign(&'a ast::StmtAnnAssign),

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -83,7 +83,6 @@ 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),
@@ -110,12 +109,6 @@ 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)
@@ -211,6 +204,7 @@ pub(crate) struct AssignmentDefinitionNodeRef<'a> {
     pub(crate) unpack: Option<Unpack<'a>>,
     pub(crate) value: &'a ast::Expr,
     pub(crate) name: &'a ast::ExprName,
+    pub(crate) first: bool,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -271,9 +265,6 @@ 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))
             }
@@ -281,10 +272,12 @@ impl<'db> DefinitionNodeRef<'db> {
                 unpack,
                 value,
                 name,
+                first,
             }) => DefinitionKind::Assignment(AssignmentDefinitionKind {
                 target: TargetKind::from(unpack),
                 value: AstNodeRef::new(parsed.clone(), value),
                 name: AstNodeRef::new(parsed, name),
+                first,
             }),
             DefinitionNodeRef::AnnotatedAssignment(assign) => {
                 DefinitionKind::AnnotatedAssignment(AstNodeRef::new(parsed, assign))
@@ -365,12 +358,12 @@ 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: _,
                 unpack: _,
                 name,
+                first: _,
             }) => name.into(),
             Self::AnnotatedAssignment(node) => node.into(),
             Self::AugmentedAssignment(node) => node.into(),
@@ -441,7 +434,6 @@ 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>),
@@ -464,7 +456,6 @@ 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(_)
@@ -587,6 +578,7 @@ pub struct AssignmentDefinitionKind<'db> {
     target: TargetKind<'db>,
     value: AstNodeRef<ast::Expr>,
     name: AstNodeRef<ast::ExprName>,
+    first: bool,
 }
 
 impl<'db> AssignmentDefinitionKind<'db> {
@@ -601,6 +593,10 @@ impl<'db> AssignmentDefinitionKind<'db> {
     pub(crate) fn name(&self) -> &ast::ExprName {
         self.name.node()
     }
+
+    pub(crate) fn is_first(&self) -> bool {
+        self.first
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -686,12 +682,6 @@ 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,11 +116,14 @@ 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).scope_kind(),
-            ScopeKind::Annotation
-                | ScopeKind::Function
-                | ScopeKind::TypeAlias
-                | ScopeKind::Comprehension
+            self.node(db),
+            NodeWithScopeKind::ClassTypeParameters(_)
+                | NodeWithScopeKind::FunctionTypeParameters(_)
+                | NodeWithScopeKind::Function(_)
+                | NodeWithScopeKind::ListComprehension(_)
+                | NodeWithScopeKind::SetComprehension(_)
+                | NodeWithScopeKind::DictComprehension(_)
+                | NodeWithScopeKind::GeneratorExpression(_)
         )
     }
 
@@ -141,12 +144,6 @@ 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>",
@@ -204,7 +201,6 @@ pub enum ScopeKind {
     Class,
     Function,
     Comprehension,
-    TypeAlias,
 }
 
 impl ScopeKind {
@@ -330,8 +326,6 @@ 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),
@@ -353,12 +347,6 @@ 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))
             }
@@ -399,12 +387,6 @@ 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))
             }
@@ -429,8 +411,6 @@ 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>),
@@ -443,11 +423,9 @@ impl NodeWithScopeKind {
         match self {
             Self::Module => ScopeKind::Module,
             Self::Class(_) => ScopeKind::Class,
-            Self::Function(_) | Self::Lambda(_) => ScopeKind::Function,
-            Self::FunctionTypeParameters(_)
-            | Self::ClassTypeParameters(_)
-            | Self::TypeAliasTypeParameters(_) => ScopeKind::Annotation,
-            Self::TypeAlias(_) => ScopeKind::TypeAlias,
+            Self::Function(_) => ScopeKind::Function,
+            Self::Lambda(_) => ScopeKind::Function,
+            Self::FunctionTypeParameters(_) | Self::ClassTypeParameters(_) => ScopeKind::Annotation,
             Self::ListComprehension(_)
             | Self::SetComprehension(_)
             | Self::DictComprehension(_)
@@ -468,13 +446,6 @@ 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)]
@@ -484,8 +455,6 @@ 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<'db> Iterator for ConstraintsIterator<'_, 'db> {
+impl<'map, 'db> Iterator for ConstraintsIterator<'map, 'db> {
     type Item = Constraint<'db>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -424,7 +424,7 @@ impl DeclarationsIterator<'_, '_> {
     }
 }
 
-impl<'db> Iterator for DeclarationsIterator<'_, 'db> {
+impl<'map, 'db> Iterator for DeclarationsIterator<'map, 'db> {
     type Item = Definition<'db>;
 
     fn next(&mut self) -> Option<Self::Item> {

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 Iterator for DeclarationIdIterator<'_> {
+impl<'a> Iterator for DeclarationIdIterator<'a> {
     type Item = ScopedDefinitionId;
 
     fn next(&mut self) -> Option<Self::Item> {

crates/red_knot_python_semantic/src/types.rs

@@ -7,6 +7,7 @@ use ruff_db::files::File;
 use ruff_python_ast as ast;
 
 pub(crate) use self::builder::{IntersectionBuilder, UnionBuilder};
+pub use self::diagnostic::{TypeCheckDiagnostic, TypeCheckDiagnostics};
 pub(crate) use self::display::TypeArrayDisplay;
 pub(crate) use self::infer::{
     infer_deferred_types, infer_definition_types, infer_expression_types, infer_scope_types,
@@ -24,9 +25,7 @@ use crate::stdlib::{
     builtins_symbol, core_module_symbol, typing_extensions_symbol, CoreStdlibModule,
 };
 use crate::symbol::{Boundness, Symbol};
-use crate::types::diagnostic::{
-    report_not_iterable, report_not_iterable_possibly_unbound, report_type_diagnostic,
-};
+use crate::types::diagnostic::TypeCheckDiagnosticsBuilder;
 use crate::types::mro::{ClassBase, Mro, MroError, MroIterator};
 use crate::types::narrow::narrowing_constraint;
 use crate::{Db, FxOrderSet, Module, Program};
@@ -41,20 +40,21 @@ mod signatures;
 mod string_annotation;
 mod unpacker;
 
-#[cfg(test)]
-mod property_tests;
-
-#[salsa::tracked]
-pub fn check_types(db: &dyn Db, file: File) {
+#[salsa::tracked(return_ref)]
+pub fn check_types(db: &dyn Db, file: File) -> TypeCheckDiagnostics {
     let _span = tracing::trace_span!("check_types", file=?file.path(db)).entered();
 
     tracing::debug!("Checking file '{path}'", path = file.path(db));
 
     let index = semantic_index(db, file);
+    let mut diagnostics = TypeCheckDiagnostics::default();
 
     for scope_id in index.scope_ids() {
-        let _ = infer_scope_types(db, scope_id);
+        let result = infer_scope_types(db, scope_id);
+        diagnostics.extend(result.diagnostics());
     }
+
+    diagnostics
 }
 
 /// Infer the public type of a symbol (its type as seen from outside its scope).
@@ -324,61 +324,6 @@ 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> {
@@ -395,9 +340,7 @@ 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.
-    ///
-    /// This variant should be created with the `todo_type!` macro.
-    Todo(TodoType),
+    Todo,
     /// The empty set of values
     Never,
     /// A specific function object
@@ -441,7 +384,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 {
@@ -537,19 +480,6 @@ 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(..))
     }
@@ -574,11 +504,8 @@ impl<'db> Type<'db> {
         Self::BytesLiteral(BytesLiteralType::new(db, bytes))
     }
 
-    pub fn tuple<T: Into<Type<'db>>>(
-        db: &'db dyn Db,
-        elements: impl IntoIterator<Item = T>,
-    ) -> Self {
-        TupleType::from_elements(db, elements)
+    pub fn tuple(db: &'db dyn Db, elements: &[Type<'db>]) -> Self {
+        Self::Tuple(TupleType::new(db, elements))
     }
 
     #[must_use]
@@ -603,8 +530,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 }))
@@ -722,6 +649,9 @@ impl<'db> Type<'db> {
             (Type::KnownInstance(left), right) => {
                 left.instance_fallback(db).is_subtype_of(db, right)
             }
+            (left, Type::KnownInstance(right)) => {
+                left.is_subtype_of(db, right.instance_fallback(db))
+            }
             (Type::Instance(left), Type::Instance(right)) => left.is_instance_of(db, right.class),
             // TODO
             _ => false,
@@ -736,8 +666,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()
@@ -773,7 +703,6 @@ 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 }),
@@ -797,7 +726,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)
@@ -1002,7 +931,7 @@ impl<'db> Type<'db> {
             Type::Any
             | Type::Never
             | Type::Unknown
-            | Type::Todo(_)
+            | Type::Todo
             | Type::IntLiteral(..)
             | Type::StringLiteral(..)
             | Type::BytesLiteral(..)
@@ -1078,10 +1007,7 @@ impl<'db> Type<'db> {
 
             Type::Instance(InstanceType { class }) => match class.known(db) {
                 Some(
-                    KnownClass::NoneType
-                    | KnownClass::NoDefaultType
-                    | KnownClass::VersionInfo
-                    | KnownClass::TypeAliasType,
+                    KnownClass::NoneType | KnownClass::NoDefaultType | KnownClass::VersionInfo,
                 ) => true,
                 Some(
                     KnownClass::Bool
@@ -1108,7 +1034,7 @@ impl<'db> Type<'db> {
             Type::Any
             | Type::Never
             | Type::Unknown
-            | Type::Todo(_)
+            | Type::Todo
             | Type::Union(..)
             | Type::Intersection(..)
             | Type::LiteralString => false,
@@ -1126,12 +1052,12 @@ impl<'db> Type<'db> {
             Type::Any => Type::Any.into(),
             Type::Never => {
                 // TODO: attribute lookup on Never type
-                todo_type!().into()
+                Type::Todo.into()
             }
             Type::Unknown => Type::Unknown.into(),
             Type::FunctionLiteral(_) => {
                 // TODO: attribute lookup on function type
-                todo_type!().into()
+                Type::Todo.into()
             }
             Type::ModuleLiteral(file) => {
                 // `__dict__` is a very special member that is never overridden by module globals;
@@ -1181,7 +1107,7 @@ impl<'db> Type<'db> {
                         Type::IntLiteral(Program::get(db).target_version(db).minor.into())
                     }
                     // TODO MRO? get_own_instance_member, get_instance_member
-                    _ => todo_type!("instance attributes"),
+                    _ => Type::Todo,
                 };
                 ty.into()
             }
@@ -1223,36 +1149,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
-                todo_type!().into()
+                Type::Todo.into()
             }
             Type::IntLiteral(_) => {
                 // TODO raise error
-                todo_type!().into()
+                Type::Todo.into()
             }
-            Type::BooleanLiteral(_) => todo_type!().into(),
+            Type::BooleanLiteral(_) => Type::Todo.into(),
             Type::StringLiteral(_) => {
                 // TODO defer to `typing.LiteralString`/`builtins.str` methods
                 // from typeshed's stubs
-                todo_type!().into()
+                Type::Todo.into()
             }
             Type::LiteralString => {
                 // TODO defer to `typing.LiteralString`/`builtins.str` methods
                 // from typeshed's stubs
-                todo_type!().into()
+                Type::Todo.into()
             }
             Type::BytesLiteral(_) => {
                 // TODO defer to Type::Instance(<bytes from typeshed>).member
-                todo_type!().into()
+                Type::Todo.into()
             }
             Type::SliceLiteral(_) => {
                 // TODO defer to `builtins.slice` methods
-                todo_type!().into()
+                Type::Todo.into()
             }
             Type::Tuple(_) => {
                 // TODO: implement tuple methods
-                todo_type!().into()
+                Type::Todo.into()
             }
-            &todo @ Type::Todo(_) => todo.into(),
+            Type::Todo => Type::Todo.into(),
         }
     }
 
@@ -1262,7 +1188,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(_) => {
@@ -1403,7 +1329,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(todo_type!("call todo")),
+            Type::Todo => CallOutcome::callable(Type::Todo),
 
             Type::Unknown => CallOutcome::callable(Type::Unknown),
 
@@ -1416,7 +1342,7 @@ impl<'db> Type<'db> {
             ),
 
             // TODO: intersection types
-            Type::Intersection(_) => CallOutcome::callable(todo_type!()),
+            Type::Intersection(_) => CallOutcome::callable(Type::Todo),
 
             _ => CallOutcome::not_callable(self),
         }
@@ -1455,7 +1381,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 };
@@ -1514,14 +1440,14 @@ impl<'db> Type<'db> {
     pub fn to_instance(&self, db: &'db dyn Db) -> Type<'db> {
         match self {
             Type::Any => Type::Any,
-            todo @ Type::Todo(_) => *todo,
+            Type::Todo => Type::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(_) => todo_type!(),
+            Type::Intersection(_) => Type::Todo,
             // 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(_)
@@ -1552,12 +1478,7 @@ impl<'db> Type<'db> {
             Type::Unknown => Type::Unknown,
             // TODO map this to a new `Type::TypeVar` variant
             Type::KnownInstance(KnownInstanceType::TypeVar(_)) => *self,
-            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!(),
+            _ => Type::Todo,
         }
     }
 
@@ -1632,8 +1553,8 @@ impl<'db> Type<'db> {
             // TODO: `type[Unknown]`?
             Type::Unknown => Type::Unknown,
             // TODO intersections
-            Type::Intersection(_) => todo_type!(),
-            todo @ Type::Todo(_) => *todo,
+            Type::Intersection(_) => Type::Todo,
+            Type::Todo => Type::Todo,
         }
     }
 
@@ -1721,7 +1642,6 @@ pub enum KnownClass {
     // Typing
     SpecialForm,
     TypeVar,
-    TypeAliasType,
     NoDefaultType,
     // sys
     VersionInfo,
@@ -1748,7 +1668,6 @@ 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.
@@ -1787,7 +1706,7 @@ impl<'db> KnownClass {
             Self::VersionInfo => CoreStdlibModule::Sys,
             Self::GenericAlias | Self::ModuleType | Self::FunctionType => CoreStdlibModule::Types,
             Self::NoneType => CoreStdlibModule::Typeshed,
-            Self::SpecialForm | Self::TypeVar | Self::TypeAliasType => CoreStdlibModule::Typing,
+            Self::SpecialForm | Self::TypeVar => 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`
@@ -1801,7 +1720,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 | Self::TypeAliasType => true,
+            Self::NoneType | Self::NoDefaultType | Self::VersionInfo => true,
             Self::Bool
             | Self::Object
             | Self::Bytes
@@ -1843,7 +1762,6 @@ 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,
@@ -1877,7 +1795,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::TypeAliasType | Self::NoDefaultType => {
+            Self::SpecialForm | Self::TypeVar | Self::NoDefaultType => {
                 matches!(module.name().as_str(), "typing" | "typing_extensions")
             }
         }
@@ -1889,48 +1807,26 @@ 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 {
-            Self::Literal => "Literal",
-            Self::LiteralString => "LiteralString",
-            Self::Optional => "Optional",
-            Self::Union => "Union",
-            Self::TypeVar(_) => "TypeVar",
-            Self::NoReturn => "NoReturn",
-            Self::Never => "Never",
-            Self::TypeAliasType(_) => "TypeAliasType",
+            KnownInstanceType::Literal => "Literal",
+            KnownInstanceType::Optional => "Optional",
+            KnownInstanceType::TypeVar(_) => "TypeVar",
         }
     }
 
     /// Evaluate the known instance in boolean context
     pub const fn bool(self) -> Truthiness {
         match self {
-            Self::Literal
-            | Self::LiteralString
-            | Self::Optional
-            | Self::TypeVar(_)
-            | Self::Union
-            | Self::NoReturn
-            | Self::Never
-            | Self::TypeAliasType(_) => Truthiness::AlwaysTrue,
+            Self::Literal | Self::Optional | Self::TypeVar(_) => Truthiness::AlwaysTrue,
         }
     }
 
@@ -1938,13 +1834,8 @@ 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",
         }
     }
 
@@ -1952,13 +1843,8 @@ 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,
         }
     }
 
@@ -1977,11 +1863,7 @@ 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,
         }
     }
@@ -1989,7 +1871,23 @@ 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::TypeAliasType(alias), "__name__") => Type::string_literal(db, alias.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)),
             _ => return self.instance_fallback(db).member(db, name),
         };
         ty.into()
@@ -2021,7 +1919,6 @@ 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)
@@ -2030,8 +1927,7 @@ impl<'db> TypeVarInstance<'db> {
         }
     }
 
-    #[allow(unused)]
-    pub(crate) fn constraints(self, db: &'db dyn Db) -> Option<&'db [Type<'db>]> {
+    pub(crate) fn constraints(self, db: &'db dyn Db) -> Option<&[Type<'db>]> {
         if let Some(TypeVarBoundOrConstraints::Constraints(tuple)) = self.bound_or_constraints(db) {
             Some(tuple.elements(db))
         } else {
@@ -2128,21 +2024,19 @@ impl<'db> CallOutcome<'db> {
     }
 
     /// Get the return type of the call, emitting default diagnostics if needed.
-    fn unwrap_with_diagnostic(
+    fn unwrap_with_diagnostic<'a>(
         &self,
         db: &'db dyn Db,
-        file: File,
         node: ast::AnyNodeRef,
+        diagnostics: &'a mut TypeCheckDiagnosticsBuilder<'db>,
     ) -> Type<'db> {
-        match self.return_ty_result(db, file, node) {
+        match self.return_ty_result(db, node, diagnostics) {
             Ok(return_ty) => return_ty,
             Err(NotCallableError::Type {
                 not_callable_ty,
                 return_ty,
             }) => {
-                report_type_diagnostic(
-                    db,
-                    file,
+                diagnostics.add(
                     node,
                     "call-non-callable",
                     format_args!(
@@ -2157,9 +2051,7 @@ impl<'db> CallOutcome<'db> {
                 called_ty,
                 return_ty,
             }) => {
-                report_type_diagnostic(
-                    db,
-                    file,
+                diagnostics.add(
                     node,
                     "call-non-callable",
                     format_args!(
@@ -2175,9 +2067,7 @@ impl<'db> CallOutcome<'db> {
                 called_ty,
                 return_ty,
             }) => {
-                report_type_diagnostic(
-                    db,
-                    file,
+                diagnostics.add(
                     node,
                     "call-non-callable",
                     format_args!(
@@ -2192,9 +2082,7 @@ impl<'db> CallOutcome<'db> {
                 callable_ty: called_ty,
                 return_ty,
             }) => {
-                report_type_diagnostic(
-                    db,
-                    file,
+                diagnostics.add(
                     node,
                     "call-non-callable",
                     format_args!(
@@ -2208,11 +2096,11 @@ impl<'db> CallOutcome<'db> {
     }
 
     /// Get the return type of the call as a result.
-    fn return_ty_result(
+    fn return_ty_result<'a>(
         &self,
         db: &'db dyn Db,
-        file: File,
         node: ast::AnyNodeRef,
+        diagnostics: &'a mut TypeCheckDiagnosticsBuilder<'db>,
     ) -> Result<Type<'db>, NotCallableError<'db>> {
         match self {
             Self::Callable { return_ty } => Ok(*return_ty),
@@ -2220,9 +2108,7 @@ impl<'db> CallOutcome<'db> {
                 return_ty,
                 revealed_ty,
             } => {
-                report_type_diagnostic(
-                    db,
-                    file,
+                diagnostics.add(
                     node,
                     "revealed-type",
                     format_args!("Revealed type is `{}`", revealed_ty.display(db)),
@@ -2261,10 +2147,10 @@ impl<'db> CallOutcome<'db> {
                                 *return_ty
                             } else {
                                 revealed = true;
-                                outcome.unwrap_with_diagnostic(db, file, node)
+                                outcome.unwrap_with_diagnostic(db, node, diagnostics)
                             }
                         }
-                        _ => outcome.unwrap_with_diagnostic(db, file, node),
+                        _ => outcome.unwrap_with_diagnostic(db, node, diagnostics),
                     };
                     union_builder = union_builder.add(return_ty);
                 }
@@ -2379,21 +2265,20 @@ enum IterationOutcome<'db> {
 impl<'db> IterationOutcome<'db> {
     fn unwrap_with_diagnostic(
         self,
-        db: &dyn Db,
-        file: File,
         iterable_node: ast::AnyNodeRef,
+        diagnostics: &mut TypeCheckDiagnosticsBuilder<'db>,
     ) -> Type<'db> {
         match self {
             Self::Iterable { element_ty } => element_ty,
             Self::NotIterable { not_iterable_ty } => {
-                report_not_iterable(db, file, iterable_node, not_iterable_ty);
+                diagnostics.add_not_iterable(iterable_node, not_iterable_ty);
                 Type::Unknown
             }
             Self::PossiblyUnboundDunderIter {
                 iterable_ty,
                 element_ty,
             } => {
-                report_not_iterable_possibly_unbound(db, file, iterable_node, iterable_ty);
+                diagnostics.add_not_iterable_possibly_unbound(iterable_node, iterable_ty);
                 element_ty
             }
         }
@@ -2586,7 +2471,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) -> &'db [Type<'db>] {
+    fn explicit_bases(self, db: &'db dyn Db) -> &[Type<'db>] {
         self.explicit_bases_query(db)
     }
 
@@ -2714,7 +2599,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(todo_type!("metaclass not a class"));
+            return Ok(Type::Todo);
         };
 
         // Reconcile all base classes' metaclasses with the candidate metaclass.
@@ -2828,27 +2713,6 @@ 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> {
@@ -3014,7 +2878,7 @@ pub struct SliceLiteralType<'db> {
     step: Option<i32>,
 }
 
-impl SliceLiteralType<'_> {
+impl<'db> SliceLiteralType<'db> {
     fn as_tuple(self, db: &dyn Db) -> (Option<i32>, Option<i32>, Option<i32>) {
         (self.start(db), self.stop(db), self.step(db))
     }
@@ -3026,23 +2890,6 @@ pub struct TupleType<'db> {
 }
 
 impl<'db> TupleType<'db> {
-    pub fn from_elements<T: Into<Type<'db>>>(
-        db: &'db dyn Db,
-        types: impl IntoIterator<Item = T>,
-    ) -> Type<'db> {
-        let mut elements = vec![];
-
-        for ty in types {
-            let ty = ty.into();
-            if ty.is_never() {
-                return Type::Never;
-            }
-            elements.push(ty);
-        }
-
-        Type::Tuple(Self::new(db, elements.into_boxed_slice()))
-    }
-
     pub fn get(&self, db: &'db dyn Db, index: usize) -> Option<Type<'db>> {
         self.elements(db).get(index).copied()
     }
@@ -3052,11 +2899,6 @@ 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::*;
@@ -3072,6 +2914,13 @@ 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();
 
@@ -3094,8 +2943,8 @@ pub(crate) mod tests {
 
     /// A test representation of a type that can be transformed unambiguously into a real Type,
     /// given a db.
-    #[derive(Debug, Clone, PartialEq)]
-    pub(crate) enum Ty {
+    #[derive(Debug, Clone)]
+    enum Ty {
         Never,
         Unknown,
         None,
@@ -3119,13 +2968,13 @@ pub(crate) mod tests {
     }
 
     impl Ty {
-        pub(crate) fn into_type(self, db: &TestDb) -> Type<'_> {
+        fn into_type(self, db: &TestDb) -> Type<'_> {
             match self {
                 Ty::Never => Type::Never,
                 Ty::Unknown => Type::Unknown,
                 Ty::None => Type::none(db),
                 Ty::Any => Type::Any,
-                Ty::Todo => todo_type!("Ty::Todo"),
+                Ty::Todo => Type::Todo,
                 Ty::IntLiteral(n) => Type::IntLiteral(n),
                 Ty::StringLiteral(s) => Type::string_literal(db, s),
                 Ty::BooleanLiteral(b) => Type::BooleanLiteral(b),
@@ -3150,21 +2999,13 @@ pub(crate) mod tests {
                     builder.build()
                 }
                 Ty::Tuple(tys) => {
-                    let elements = tys.into_iter().map(|ty| ty.into_type(db));
-                    Type::tuple(db, elements)
+                    let elements: Vec<Type> = tys.into_iter().map(|ty| ty.into_type(db)).collect();
+                    Type::tuple(db, &elements)
                 }
             }
         }
     }
 
-    #[test_case(Ty::Tuple(vec![Ty::Never]))]
-    #[test_case(Ty::Tuple(vec![Ty::BuiltinInstance("str"), Ty::Never, Ty::BuiltinInstance("int")]))]
-    #[test_case(Ty::Tuple(vec![Ty::Tuple(vec![Ty::Never])]))]
-    fn tuple_containing_never_simplifies_to_never(ty: Ty) {
-        let db = setup_db();
-        assert_eq!(ty.into_type(&db), Type::Never);
-    }
-
     #[test_case(Ty::BuiltinInstance("str"), Ty::BuiltinInstance("object"))]
     #[test_case(Ty::BuiltinInstance("int"), Ty::BuiltinInstance("object"))]
     #[test_case(Ty::Unknown, Ty::IntLiteral(1))]
@@ -3278,7 +3119,6 @@ pub(crate) mod tests {
     #[test_case(Ty::IntLiteral(1), Ty::Intersection{pos: vec![Ty::BuiltinInstance("int")], neg: vec![Ty::IntLiteral(1)]})]
     #[test_case(Ty::BuiltinClassLiteral("int"), Ty::BuiltinClassLiteral("object"))]
     #[test_case(Ty::BuiltinInstance("int"), Ty::BuiltinClassLiteral("int"))]
-    #[test_case(Ty::TypingInstance("_SpecialForm"), Ty::TypingLiteral)]
     fn is_not_subtype_of(from: Ty, to: Ty) {
         let db = setup_db();
         assert!(!from.into_type(&db).is_subtype_of(&db, to.into_type(&db)));
@@ -3725,95 +3565,4 @@ 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

@@ -309,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.
@@ -379,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, todo_type, KnownClass, UnionBuilder};
+    use crate::types::{global_symbol, KnownClass, UnionBuilder};
     use crate::ProgramSettings;
     use ruff_db::files::system_path_to_file;
     use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
@@ -987,7 +987,7 @@ mod tests {
 
     #[test_case(Type::Any)]
     #[test_case(Type::Unknown)]
-    #[test_case(todo_type!())]
+    #[test_case(Type::Todo)]
     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

@@ -1,12 +1,16 @@
 use crate::types::{ClassLiteralType, Type};
 use crate::Db;
-use ruff_db::diagnostic::{CompileDiagnostic, Diagnostic, Severity};
+use ruff_db::diagnostic::{Diagnostic, Severity};
 use ruff_db::files::File;
 use ruff_python_ast::{self as ast, AnyNodeRef};
 use ruff_text_size::{Ranged, TextRange};
 use std::borrow::Cow;
+use std::fmt::Formatter;
+use std::ops::Deref;
+use std::sync::Arc;
+
 #[derive(Debug, Eq, PartialEq, Clone)]
-pub(crate) struct TypeCheckDiagnostic {
+pub struct TypeCheckDiagnostic {
     // TODO: Don't use string keys for rules
     pub(super) rule: String,
     pub(super) message: String,
@@ -15,15 +19,15 @@ pub(crate) struct TypeCheckDiagnostic {
 }
 
 impl TypeCheckDiagnostic {
-    pub(crate) fn rule(&self) -> &str {
+    pub fn rule(&self) -> &str {
         &self.rule
     }
 
-    pub(crate) fn message(&self) -> &str {
+    pub fn message(&self) -> &str {
         &self.message
     }
 
-    pub(crate) fn file(&self) -> File {
+    pub fn file(&self) -> File {
         self.file
     }
 }
@@ -56,209 +60,263 @@ impl Ranged for TypeCheckDiagnostic {
     }
 }
 
-/// Emit a diagnostic declaring that the object represented by `node` is not iterable
-pub(super) fn report_not_iterable(
-    db: &dyn Db,
-    file: File,
-    node: AnyNodeRef,
-    not_iterable_ty: Type,
-) {
-    report_type_diagnostic(
-        db,
-        file,
-        node,
-        "not-iterable",
-        format_args!(
-            "Object of type `{}` is not iterable",
-            not_iterable_ty.display(db)
-        ),
-    );
+/// A collection of type check diagnostics.
+///
+/// The diagnostics are wrapped in an `Arc` because they need to be cloned multiple times
+/// when going from `infer_expression` to `check_file`. We could consider
+/// making [`TypeCheckDiagnostic`] a Salsa struct to have them Arena-allocated (once the Tables refactor is done).
+/// Using Salsa struct does have the downside that it leaks the Salsa dependency into diagnostics and
+/// each Salsa-struct comes with an overhead.
+#[derive(Default, Eq, PartialEq)]
+pub struct TypeCheckDiagnostics {
+    inner: Vec<std::sync::Arc<TypeCheckDiagnostic>>,
 }
 
-/// Emit a diagnostic declaring that the object represented by `node` is not iterable
-/// because its `__iter__` method is possibly unbound.
-pub(super) fn report_not_iterable_possibly_unbound(
-    db: &dyn Db,
-    file: File,
-    node: AnyNodeRef,
-    element_ty: Type,
-) {
-    report_type_diagnostic(
-        db,
-        file,
-        node,
-        "not-iterable",
-        format_args!(
-            "Object of type `{}` is not iterable because its `__iter__` method is possibly unbound",
-            element_ty.display(db)
-        ),
-    );
-}
+impl TypeCheckDiagnostics {
+    pub(super) fn push(&mut self, diagnostic: TypeCheckDiagnostic) {
+        self.inner.push(Arc::new(diagnostic));
+    }
 
-/// Emit a diagnostic declaring that an index is out of bounds for a tuple.
-pub(super) fn report_index_out_of_bounds(
-    db: &dyn Db,
-    file: File,
-    kind: &'static str,
-    node: AnyNodeRef,
-    tuple_ty: Type,
-    length: usize,
-    index: i64,
-) {
-    report_type_diagnostic(
-        db,
-        file,
-        node,
-        "index-out-of-bounds",
-        format_args!(
-            "Index {index} is out of bounds for {kind} `{}` with length {length}",
-            tuple_ty.display(db)
-        ),
-    );
-}
-
-/// Emit a diagnostic declaring that a type does not support subscripting.
-pub(super) fn report_non_subscriptable(
-    db: &dyn Db,
-    file: File,
-    node: AnyNodeRef,
-    non_subscriptable_ty: Type,
-    method: &str,
-) {
-    report_type_diagnostic(
-        db,
-        file,
-        node,
-        "non-subscriptable",
-        format_args!(
-            "Cannot subscript object of type `{}` with no `{method}` method",
-            non_subscriptable_ty.display(db)
-        ),
-    );
-}
-
-pub(super) fn report_unresolved_module<'a>(
-    db: &dyn Db,
-    file: File,
-    import_node: impl Into<AnyNodeRef<'a>>,
-    level: u32,
-    module: Option<&str>,
-) {
-    report_type_diagnostic(
-        db,
-        file,
-        import_node.into(),
-        "unresolved-import",
-        format_args!(
-            "Cannot resolve import `{}{}`",
-            ".".repeat(level as usize),
-            module.unwrap_or_default()
-        ),
-    );
-}
-
-pub(super) fn report_slice_step_size_zero(db: &dyn Db, file: File, node: AnyNodeRef) {
-    report_type_diagnostic(
-        db,
-        file,
-        node,
-        "zero-stepsize-in-slice",
-        format_args!("Slice step size can not be zero"),
-    );
-}
-
-pub(super) fn report_invalid_assignment(
-    db: &dyn Db,
-    file: File,
-    node: AnyNodeRef,
-    declared_ty: Type,
-    assigned_ty: Type,
-) {
-    match declared_ty {
-        Type::ClassLiteral(ClassLiteralType { class }) => {
-            report_type_diagnostic(db, file, node, "invalid-assignment", format_args!(
-                "Implicit shadowing of class `{}`; annotate to make it explicit if this is intentional",
-                class.name(db)));
-        }
-        Type::FunctionLiteral(function) => {
-            report_type_diagnostic(db, file, node, "invalid-assignment", format_args!(
-                "Implicit shadowing of function `{}`; annotate to make it explicit if this is intentional",
-                function.name(db)));
-        }
-        _ => {
-            report_type_diagnostic(
-                db,
-                file,
-                node,
-                "invalid-assignment",
-                format_args!(
-                    "Object of type `{}` is not assignable to `{}`",
-                    assigned_ty.display(db),
-                    declared_ty.display(db),
-                ),
-            );
-        }
+    pub(crate) fn shrink_to_fit(&mut self) {
+        self.inner.shrink_to_fit();
     }
 }
 
-pub(super) fn report_possibly_unresolved_reference(
-    db: &dyn Db,
-    file: File,
-    expr_name_node: &ast::ExprName,
-) {
-    let ast::ExprName { id, .. } = expr_name_node;
-
-    report_type_diagnostic(
-        db,
-        file,
-        expr_name_node.into(),
-        "possibly-unresolved-reference",
-        format_args!("Name `{id}` used when possibly not defined"),
-    );
-}
-
-pub(super) fn report_unresolved_reference(db: &dyn Db, file: File, expr_name_node: &ast::ExprName) {
-    let ast::ExprName { id, .. } = expr_name_node;
-
-    report_type_diagnostic(
-        db,
-        file,
-        expr_name_node.into(),
-        "unresolved-reference",
-        format_args!("Name `{id}` used when not defined"),
-    );
-}
-
-/// Returns `true` if any diagnostic is enabled for this file.
-pub(crate) fn is_any_diagnostic_enabled(db: &dyn Db, file: File) -> bool {
-    db.is_file_open(file)
-}
-
-/// Reports a diagnostic for the given node and file if diagnostic reporting is enabled for this file.
-pub(crate) fn report_type_diagnostic(
-    db: &dyn Db,
-    file: File,
-    node: AnyNodeRef,
-    rule: &str,
-    message: std::fmt::Arguments,
-) {
-    if !is_any_diagnostic_enabled(db, file) {
-        return;
+impl Extend<TypeCheckDiagnostic> for TypeCheckDiagnostics {
+    fn extend<T: IntoIterator<Item = TypeCheckDiagnostic>>(&mut self, iter: T) {
+        self.inner.extend(iter.into_iter().map(std::sync::Arc::new));
     }
+}
 
-    // TODO: Don't emit the diagnostic if:
-    // * The enclosing node contains any syntax errors
-    // * The rule is disabled for this file. We probably want to introduce a new query that
-    //   returns a rule selector for a given file that respects the package's settings,
-    //   any global pragma comments in the file, and any per-file-ignores.
+impl Extend<std::sync::Arc<TypeCheckDiagnostic>> for TypeCheckDiagnostics {
+    fn extend<T: IntoIterator<Item = Arc<TypeCheckDiagnostic>>>(&mut self, iter: T) {
+        self.inner.extend(iter);
+    }
+}
 
-    CompileDiagnostic::report(
-        db.upcast(),
-        TypeCheckDiagnostic {
+impl<'a> Extend<&'a std::sync::Arc<TypeCheckDiagnostic>> for TypeCheckDiagnostics {
+    fn extend<T: IntoIterator<Item = &'a Arc<TypeCheckDiagnostic>>>(&mut self, iter: T) {
+        self.inner
+            .extend(iter.into_iter().map(std::sync::Arc::clone));
+    }
+}
+
+impl std::fmt::Debug for TypeCheckDiagnostics {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
+impl Deref for TypeCheckDiagnostics {
+    type Target = [std::sync::Arc<TypeCheckDiagnostic>];
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl IntoIterator for TypeCheckDiagnostics {
+    type Item = Arc<TypeCheckDiagnostic>;
+    type IntoIter = std::vec::IntoIter<std::sync::Arc<TypeCheckDiagnostic>>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.inner.into_iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a TypeCheckDiagnostics {
+    type Item = &'a Arc<TypeCheckDiagnostic>;
+    type IntoIter = std::slice::Iter<'a, std::sync::Arc<TypeCheckDiagnostic>>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.inner.iter()
+    }
+}
+
+pub(super) struct TypeCheckDiagnosticsBuilder<'db> {
+    db: &'db dyn Db,
+    file: File,
+    diagnostics: TypeCheckDiagnostics,
+}
+
+impl<'db> TypeCheckDiagnosticsBuilder<'db> {
+    pub(super) fn new(db: &'db dyn Db, file: File) -> Self {
+        Self {
+            db,
             file,
+            diagnostics: TypeCheckDiagnostics::default(),
+        }
+    }
+
+    /// Emit a diagnostic declaring that the object represented by `node` is not iterable
+    pub(super) fn add_not_iterable(&mut self, node: AnyNodeRef, not_iterable_ty: Type<'db>) {
+        self.add(
+            node,
+            "not-iterable",
+            format_args!(
+                "Object of type `{}` is not iterable",
+                not_iterable_ty.display(self.db)
+            ),
+        );
+    }
+
+    /// Emit a diagnostic declaring that the object represented by `node` is not iterable
+    /// because its `__iter__` method is possibly unbound.
+    pub(super) fn add_not_iterable_possibly_unbound(
+        &mut self,
+        node: AnyNodeRef,
+        element_ty: Type<'db>,
+    ) {
+        self.add(
+            node,
+            "not-iterable",
+            format_args!(
+                "Object of type `{}` is not iterable because its `__iter__` method is possibly unbound",
+                element_ty.display(self.db)
+            ),
+        );
+    }
+
+    /// Emit a diagnostic declaring that an index is out of bounds for a tuple.
+    pub(super) fn add_index_out_of_bounds(
+        &mut self,
+        kind: &'static str,
+        node: AnyNodeRef,
+        tuple_ty: Type<'db>,
+        length: usize,
+        index: i64,
+    ) {
+        self.add(
+            node,
+            "index-out-of-bounds",
+            format_args!(
+                "Index {index} is out of bounds for {kind} `{}` with length {length}",
+                tuple_ty.display(self.db)
+            ),
+        );
+    }
+
+    /// Emit a diagnostic declaring that a type does not support subscripting.
+    pub(super) fn add_non_subscriptable(
+        &mut self,
+        node: AnyNodeRef,
+        non_subscriptable_ty: Type<'db>,
+        method: &str,
+    ) {
+        self.add(
+            node,
+            "non-subscriptable",
+            format_args!(
+                "Cannot subscript object of type `{}` with no `{method}` method",
+                non_subscriptable_ty.display(self.db)
+            ),
+        );
+    }
+
+    pub(super) fn add_unresolved_module(
+        &mut self,
+        import_node: impl Into<AnyNodeRef<'db>>,
+        level: u32,
+        module: Option<&str>,
+    ) {
+        self.add(
+            import_node.into(),
+            "unresolved-import",
+            format_args!(
+                "Cannot resolve import `{}{}`",
+                ".".repeat(level as usize),
+                module.unwrap_or_default()
+            ),
+        );
+    }
+
+    pub(super) fn add_slice_step_size_zero(&mut self, node: AnyNodeRef) {
+        self.add(
+            node,
+            "zero-stepsize-in-slice",
+            format_args!("Slice step size can not be zero"),
+        );
+    }
+
+    pub(super) fn add_invalid_assignment(
+        &mut self,
+        node: AnyNodeRef,
+        declared_ty: Type<'db>,
+        assigned_ty: Type<'db>,
+    ) {
+        match declared_ty {
+            Type::ClassLiteral(ClassLiteralType { class }) => {
+                self.add(node, "invalid-assignment", format_args!(
+                        "Implicit shadowing of class `{}`; annotate to make it explicit if this is intentional",
+                        class.name(self.db)));
+            }
+            Type::FunctionLiteral(function) => {
+                self.add(node, "invalid-assignment", format_args!(
+                        "Implicit shadowing of function `{}`; annotate to make it explicit if this is intentional",
+                        function.name(self.db)));
+            }
+            _ => {
+                self.add(
+                    node,
+                    "invalid-assignment",
+                    format_args!(
+                        "Object of type `{}` is not assignable to `{}`",
+                        assigned_ty.display(self.db),
+                        declared_ty.display(self.db),
+                    ),
+                );
+            }
+        }
+    }
+
+    pub(super) fn add_possibly_unresolved_reference(&mut self, expr_name_node: &ast::ExprName) {
+        let ast::ExprName { id, .. } = expr_name_node;
+
+        self.add(
+            expr_name_node.into(),
+            "possibly-unresolved-reference",
+            format_args!("Name `{id}` used when possibly not defined"),
+        );
+    }
+
+    pub(super) fn add_unresolved_reference(&mut self, expr_name_node: &ast::ExprName) {
+        let ast::ExprName { id, .. } = expr_name_node;
+
+        self.add(
+            expr_name_node.into(),
+            "unresolved-reference",
+            format_args!("Name `{id}` used when not defined"),
+        );
+    }
+
+    /// Adds a new diagnostic.
+    ///
+    /// The diagnostic does not get added if the rule isn't enabled for this file.
+    pub(super) fn add(&mut self, node: AnyNodeRef, rule: &str, message: std::fmt::Arguments) {
+        if !self.db.is_file_open(self.file) {
+            return;
+        }
+
+        // TODO: Don't emit the diagnostic if:
+        // * The enclosing node contains any syntax errors
+        // * The rule is disabled for this file. We probably want to introduce a new query that
+        //   returns a rule selector for a given file that respects the package's settings,
+        //   any global pragma comments in the file, and any per-file-ignores.
+
+        self.diagnostics.push(TypeCheckDiagnostic {
+            file: self.file,
             rule: rule.to_string(),
             message: message.to_string(),
             range: node.range(),
-        },
-    );
+        });
+    }
+
+    pub(super) fn extend(&mut self, diagnostics: &TypeCheckDiagnostics) {
+        self.diagnostics.extend(diagnostics);
+    }
+
+    pub(super) fn finish(mut self) -> TypeCheckDiagnostics {
+        self.diagnostics.shrink_to_fit();
+        self.diagnostics
+    }
 }

crates/red_knot_python_semantic/src/types/display.rs

@@ -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(todo) => write!(f, "@Todo{todo}"),
+            Type::Todo => f.write_str("@Todo"),
             Type::ModuleLiteral(file) => {
                 write!(f, "<module '{:?}'>", file.path(self.db))
             }
@@ -289,7 +289,7 @@ struct DisplayMaybeNegatedType<'db> {
     negated: bool,
 }
 
-impl Display for DisplayMaybeNegatedType<'_> {
+impl<'db> Display for DisplayMaybeNegatedType<'db> {
     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 Display for DisplayTypeArray<'_, '_> {
+impl<'db> Display for DisplayTypeArray<'_, 'db> {
     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/mro.rs

@@ -5,7 +5,7 @@ use itertools::Either;
 use rustc_hash::FxHashSet;
 
 use super::{Class, ClassLiteralType, KnownClass, KnownInstanceType, Type};
-use crate::{types::todo_type, Db};
+use crate::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?
@@ -372,12 +372,7 @@ impl<'db> ClassBase<'db> {
             | Type::SubclassOf(_) => None,
             Type::KnownInstance(known_instance) => match known_instance {
                 KnownInstanceType::TypeVar(_)
-                | KnownInstanceType::TypeAliasType(_)
                 | KnownInstanceType::Literal
-                | KnownInstanceType::LiteralString
-                | KnownInstanceType::Union
-                | KnownInstanceType::NoReturn
-                | KnownInstanceType::Never
                 | KnownInstanceType::Optional => None,
             },
         }
@@ -410,7 +405,7 @@ impl<'db> From<ClassBase<'db>> for Type<'db> {
     fn from(value: ClassBase<'db>) -> Self {
         match value {
             ClassBase::Any => Type::Any,
-            ClassBase::Todo => todo_type!(),
+            ClassBase::Todo => Type::Todo,
             ClassBase::Unknown => Type::Unknown,
             ClassBase::Class(class) => Type::class_literal(class),
         }

crates/red_knot_python_semantic/src/types/narrow.rs

@@ -54,7 +54,6 @@ 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,
@@ -63,7 +62,6 @@ 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,
@@ -72,7 +70,6 @@ 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,
@@ -294,15 +291,8 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
             .chain(comparators)
             .tuple_windows::<(&ruff_python_ast::Expr, &ruff_python_ast::Expr)>();
         let mut constraints = NarrowingConstraints::default();
-
-        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 {
@@ -337,9 +327,6 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
                                 constraints.insert(symbol, ty);
                             }
                         }
-                        ast::CmpOp::Eq if lhs_ty.is_literal_string() => {
-                            constraints.insert(symbol, rhs_ty);
-                        }
                         _ => {
                             // TODO other comparison types
                         }
@@ -398,58 +385,46 @@ 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 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] =
+        match inference
+            .expression_ty(expr_call.func.scoped_expression_id(self.db, scope))
+            .into_function_literal()
+            .and_then(|f| f.known(self.db))
+            .and_then(KnownFunction::constraint_function)
+        {
+            Some(function) if expr_call.arguments.keywords.is_empty() => {
+                if let [ast::Expr::Name(ast::ExprName { id, .. }), class_info] =
                     &*expr_call.arguments.args
-                else {
-                    return None;
-                };
+                {
+                    let symbol = self.symbols().symbol_id_by_name(id).unwrap();
 
-                let symbol = self.symbols().symbol_id_by_name(id).unwrap();
+                    let class_info_ty =
+                        inference.expression_ty(class_info.scoped_expression_id(self.db, scope));
 
-                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)
+                    let to_constraint = match function {
+                        KnownConstraintFunction::IsInstance => {
+                            |class_literal: ClassLiteralType<'db>| {
+                                Type::instance(class_literal.class)
+                            }
                         }
-                    }
-                };
+                        KnownConstraintFunction::IsSubclass => {
+                            |class_literal: ClassLiteralType<'db>| {
+                                Type::subclass_of(class_literal.class)
+                            }
+                        }
+                    };
 
-                generate_classinfo_constraint(self.db, &class_info_ty, to_constraint).map(
-                    |constraint| {
-                        let mut constraints = NarrowingConstraints::default();
-                        constraints.insert(symbol, constraint.negate_if(self.db, !is_positive));
-                        constraints
-                    },
-                )
-            }
-            // for the expression `bool(E)`, we further narrow the type based on `E`
-            Type::ClassLiteral(class_type)
-                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,
-                )
+                    generate_classinfo_constraint(self.db, &class_info_ty, to_constraint).map(
+                        |constraint| {
+                            let mut constraints = NarrowingConstraints::default();
+                            constraints.insert(symbol, constraint.negate_if(self.db, !is_positive));
+                            constraints
+                        },
+                    )
+                } else {
+                    None
+                }
             }
             _ => None,
         }

crates/red_knot_python_semantic/src/types/property_tests.rs

@@ -1,237 +0,0 @@
-//! This module contains quickcheck-based property tests for `Type`s.
-//!
-//! These tests are disabled by default, as they are non-deterministic and slow. You can
-//! run them explicitly using:
-//!
-//! ```sh
-//! cargo test -p red_knot_python_semantic -- --ignored types::property_tests::stable
-//! ```
-//!
-//! The number of tests (default: 100) can be controlled by setting the `QUICKCHECK_TESTS`
-//! environment variable. For example:
-//!
-//! ```sh
-//! QUICKCHECK_TESTS=10000 cargo test …
-//! ```
-//!
-//! If you want to run these tests for a longer period of time, it's advisable to run them
-//! in release mode. As some tests are slower than others, it's advisable to run them in a
-//! loop until they fail:
-//!
-//! ```sh
-//! export QUICKCHECK_TESTS=100000
-//! while cargo test --release -p red_knot_python_semantic -- \
-//!   --ignored types::property_tests::stable; do :; done
-//! ```
-
-use std::sync::{Arc, Mutex, MutexGuard, OnceLock};
-
-use super::tests::{setup_db, Ty};
-use crate::db::tests::TestDb;
-use crate::types::KnownClass;
-use quickcheck::{Arbitrary, Gen};
-
-fn arbitrary_core_type(g: &mut Gen) -> Ty {
-    // We could select a random integer here, but this would make it much less
-    // likely to explore interesting edge cases:
-    let int_lit = Ty::IntLiteral(*g.choose(&[-2, -1, 0, 1, 2]).unwrap());
-    let bool_lit = Ty::BooleanLiteral(bool::arbitrary(g));
-    g.choose(&[
-        Ty::Never,
-        Ty::Unknown,
-        Ty::None,
-        Ty::Any,
-        int_lit,
-        bool_lit,
-        Ty::StringLiteral(""),
-        Ty::StringLiteral("a"),
-        Ty::LiteralString,
-        Ty::BytesLiteral(""),
-        Ty::BytesLiteral("\x00"),
-        Ty::KnownClassInstance(KnownClass::Object),
-        Ty::KnownClassInstance(KnownClass::Str),
-        Ty::KnownClassInstance(KnownClass::Int),
-        Ty::KnownClassInstance(KnownClass::Bool),
-        Ty::KnownClassInstance(KnownClass::List),
-        Ty::KnownClassInstance(KnownClass::Tuple),
-        Ty::KnownClassInstance(KnownClass::FunctionType),
-        Ty::KnownClassInstance(KnownClass::SpecialForm),
-        Ty::KnownClassInstance(KnownClass::TypeVar),
-        Ty::KnownClassInstance(KnownClass::TypeAliasType),
-        Ty::KnownClassInstance(KnownClass::NoDefaultType),
-        Ty::TypingLiteral,
-        Ty::BuiltinClassLiteral("str"),
-        Ty::BuiltinClassLiteral("int"),
-        Ty::BuiltinClassLiteral("bool"),
-        Ty::BuiltinClassLiteral("object"),
-    ])
-    .unwrap()
-    .clone()
-}
-
-/// Constructs an arbitrary type.
-///
-/// The `size` parameter controls the depth of the type tree. For example,
-/// a simple type like `int` has a size of 0, `Union[int, str]` has a size
-/// of 1, `tuple[int, Union[str, bytes]]` has a size of 2, etc.
-fn arbitrary_type(g: &mut Gen, size: u32) -> Ty {
-    if size == 0 {
-        arbitrary_core_type(g)
-    } else {
-        match u32::arbitrary(g) % 4 {
-            0 => arbitrary_core_type(g),
-            1 => Ty::Union(
-                (0..*g.choose(&[2, 3]).unwrap())
-                    .map(|_| arbitrary_type(g, size - 1))
-                    .collect(),
-            ),
-            2 => Ty::Tuple(
-                (0..*g.choose(&[0, 1, 2]).unwrap())
-                    .map(|_| arbitrary_type(g, size - 1))
-                    .collect(),
-            ),
-            3 => Ty::Intersection {
-                pos: (0..*g.choose(&[0, 1, 2]).unwrap())
-                    .map(|_| arbitrary_type(g, size - 1))
-                    .collect(),
-                neg: (0..*g.choose(&[0, 1, 2]).unwrap())
-                    .map(|_| arbitrary_type(g, size - 1))
-                    .collect(),
-            },
-            _ => unreachable!(),
-        }
-    }
-}
-
-impl Arbitrary for Ty {
-    fn arbitrary(g: &mut Gen) -> Ty {
-        const MAX_SIZE: u32 = 2;
-        arbitrary_type(g, MAX_SIZE)
-    }
-
-    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
-        // This is incredibly naive. We can do much better here by
-        // trying various subsets of the elements in unions, tuples,
-        // and intersections. For now, we only try to shrink by
-        // reducing unions/tuples/intersections to a single element.
-        match self.clone() {
-            Ty::Union(types) => Box::new(types.into_iter()),
-            Ty::Tuple(types) => Box::new(types.into_iter()),
-            Ty::Intersection { pos, neg } => Box::new(pos.into_iter().chain(neg)),
-            _ => Box::new(std::iter::empty()),
-        }
-    }
-}
-
-static CACHED_DB: OnceLock<Arc<Mutex<TestDb>>> = OnceLock::new();
-
-fn get_cached_db() -> MutexGuard<'static, TestDb> {
-    let db = CACHED_DB.get_or_init(|| Arc::new(Mutex::new(setup_db())));
-    db.lock().unwrap()
-}
-
-/// A macro to define a property test for types.
-///
-/// The `$test_name` identifier specifies the name of the test function. The `$db` identifier
-/// is used to refer to the salsa database in the property to be tested. The actual property is
-/// specified using the syntax:
-///
-///     forall types t1, t2, ..., tn . <property>`
-///
-/// where `t1`, `t2`, ..., `tn` are identifiers that represent arbitrary types, and `<property>`
-/// is an expression using these identifiers.
-///
-macro_rules! type_property_test {
-    ($test_name:ident, $db:ident, forall types $($types:ident),+ . $property:expr) => {
-        #[quickcheck_macros::quickcheck]
-        #[ignore]
-        fn $test_name($($types: crate::types::tests::Ty),+) -> bool {
-            let db_cached = super::get_cached_db();
-            let $db = &*db_cached;
-            $(let $types = $types.into_type($db);)+
-
-            $property
-        }
-    };
-    // A property test with a logical implication.
-    ($name:ident, $db:ident, forall types $($types:ident),+ . $premise:expr => $conclusion:expr) => {
-        type_property_test!($name, $db, forall types $($types),+ . !($premise) || ($conclusion));
-    };
-}
-
-mod stable {
-    // `T` is equivalent to itself.
-    type_property_test!(
-        equivalent_to_is_reflexive, db,
-        forall types t. t.is_equivalent_to(db, t)
-    );
-
-    // `T` is a subtype of itself.
-    type_property_test!(
-        subtype_of_is_reflexive, db,
-        forall types t. t.is_subtype_of(db, t)
-    );
-
-    // `S <: T` and `T <: U` implies that `S <: U`.
-    type_property_test!(
-        subtype_of_is_transitive, db,
-        forall types s, t, u. s.is_subtype_of(db, t) && t.is_subtype_of(db, u) => s.is_subtype_of(db, u)
-    );
-
-    // `T` is not disjoint from itself, unless `T` is `Never`.
-    type_property_test!(
-        disjoint_from_is_irreflexive, db,
-        forall types t. t.is_disjoint_from(db, t) => t.is_never()
-    );
-
-    // `S` is disjoint from `T` implies that `T` is disjoint from `S`.
-    type_property_test!(
-        disjoint_from_is_symmetric, db,
-        forall types s, t. s.is_disjoint_from(db, t) == t.is_disjoint_from(db, s)
-    );
-
-    // `S <: T` implies that `S` is not disjoint from `T`, unless `S` is `Never`.
-    type_property_test!(
-        subtype_of_implies_not_disjoint_from, db,
-        forall types s, t. s.is_subtype_of(db, t) => !s.is_disjoint_from(db, t) || s.is_never()
-    );
-
-    // `T` can be assigned to itself.
-    type_property_test!(
-        assignable_to_is_reflexive, db,
-        forall types t. t.is_assignable_to(db, t)
-    );
-
-    // `S <: T` implies that `S` can be assigned to `T`.
-    type_property_test!(
-        subtype_of_implies_assignable_to, db,
-        forall types s, t. s.is_subtype_of(db, t) => s.is_assignable_to(db, t)
-    );
-
-    // If `T` is a singleton, it is also single-valued.
-    type_property_test!(
-        singleton_implies_single_valued, db,
-        forall types t. t.is_singleton(db) => t.is_single_valued(db)
-    );
-}
-
-/// This module contains property tests that currently lead to many false positives.
-///
-/// The reason for this is our insufficient understanding of equivalence of types. For
-/// example, we currently consider `int | str` and `str | int` to be different types.
-/// Similar issues exist for intersection types. Once this is resolved, we can move these
-/// tests to the `stable` section. In the meantime, it can still be useful to run these
-/// tests (using [`types::property_tests::flaky`]), to see if there are any new obvious bugs.
-mod flaky {
-    // `S <: T` and `T <: S` implies that `S` is equivalent to `T`.
-    type_property_test!(
-        subtype_of_is_antisymmetric, db,
-        forall types s, t. s.is_subtype_of(db, t) && t.is_subtype_of(db, s) => s.is_equivalent_to(db, t)
-    );
-
-    // Negating `T` twice is equivalent to `T`.
-    type_property_test!(
-        double_negation_is_identity, db,
-        forall types t. t.negate(db).negate(db).is_equivalent_to(db, t)
-    );
-}

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: todo_type!("return type"),
+            return_ty: Type::Todo,
         }
     }
 
@@ -33,7 +33,8 @@ impl<'db> Signature<'db> {
             .as_ref()
             .map(|returns| {
                 if function_node.is_async {
-                    todo_type!("generic types.CoroutineType")
+                    // TODO: generic `types.CoroutineType`!
+                    Type::Todo
                 } else {
                     definition_expression_ty(db, definition, returns.as_ref())
                 }
@@ -80,11 +81,11 @@ impl<'db> Parameters<'db> {
         Self {
             variadic: Some(Parameter {
                 name: Some(Name::new_static("args")),
-                annotated_ty: todo_type!(),
+                annotated_ty: Type::Todo,
             }),
             keywords: Some(Parameter {
                 name: Some(Name::new_static("kwargs")),
-                annotated_ty: todo_type!(),
+                annotated_ty: Type::Todo,
             }),
             ..Default::default()
         }

crates/red_knot_python_semantic/src/types/string_annotation.rs

@@ -5,10 +5,10 @@ use ruff_python_ast::{self as ast, ModExpression, StringFlags};
 use ruff_python_parser::{parse_expression_range, Parsed};
 use ruff_text_size::Ranged;
 
-use crate::types::diagnostic::report_type_diagnostic;
+use crate::types::diagnostic::{TypeCheckDiagnostics, TypeCheckDiagnosticsBuilder};
 use crate::Db;
 
-type AnnotationParseResult = Result<Parsed<ModExpression>, ()>;
+type AnnotationParseResult = Result<Parsed<ModExpression>, TypeCheckDiagnostics>;
 
 /// Parses the given expression as a string annotation.
 pub(crate) fn parse_string_annotation(
@@ -20,13 +20,12 @@ pub(crate) fn parse_string_annotation(
 
     let source = source_text(db.upcast(), file);
     let node_text = &source[string_expr.range()];
+    let mut diagnostics = TypeCheckDiagnosticsBuilder::new(db, file);
 
     if let [string_literal] = string_expr.value.as_slice() {
         let prefix = string_literal.flags.prefix();
         if prefix.is_raw() {
-            report_type_diagnostic(
-                db,
-                file,
+            diagnostics.add(
                 string_literal.into(),
                 "annotation-raw-string",
                 format_args!("Type expressions cannot use raw string literal"),
@@ -50,9 +49,7 @@ pub(crate) fn parse_string_annotation(
             // ```
             match parse_expression_range(source.as_str(), range_excluding_quotes) {
                 Ok(parsed) => return Ok(parsed),
-                Err(parse_error) => report_type_diagnostic(
-                    db,
-                    file,
+                Err(parse_error) => diagnostics.add(
                     string_literal.into(),
                     "forward-annotation-syntax-error",
                     format_args!("Syntax error in forward annotation: {}", parse_error.error),
@@ -61,9 +58,7 @@ pub(crate) fn parse_string_annotation(
         } else {
             // The raw contents of the string doesn't match the parsed content. This could be the
             // case for annotations that contain escape sequences.
-            report_type_diagnostic(
-                db,
-                file,
+            diagnostics.add(
                 string_expr.into(),
                 "annotation-escape-character",
                 format_args!("Type expressions cannot contain escape characters"),
@@ -71,14 +66,12 @@ pub(crate) fn parse_string_annotation(
         }
     } else {
         // String is implicitly concatenated.
-        report_type_diagnostic(
-            db,
-            file,
+        diagnostics.add(
             string_expr.into(),
             "annotation-implicit-concat",
             format_args!("Type expressions cannot span multiple string literals"),
         );
     }
 
-    Err(())
+    Err(diagnostics.finish())
 }

crates/red_knot_python_semantic/src/types/unpacker.rs

@@ -6,22 +6,22 @@ use rustc_hash::FxHashMap;
 
 use crate::semantic_index::ast_ids::{HasScopedExpressionId, ScopedExpressionId};
 use crate::semantic_index::symbol::ScopeId;
-use crate::types::{todo_type, Type};
+use crate::types::{Type, TypeCheckDiagnostics, TypeCheckDiagnosticsBuilder};
 use crate::Db;
 
 /// Unpacks the value expression type to their respective targets.
 pub(crate) struct Unpacker<'db> {
     db: &'db dyn Db,
-    file: File,
     targets: FxHashMap<ScopedExpressionId, Type<'db>>,
+    diagnostics: TypeCheckDiagnosticsBuilder<'db>,
 }
 
 impl<'db> Unpacker<'db> {
     pub(crate) fn new(db: &'db dyn Db, file: File) -> Self {
         Self {
             db,
-            file,
             targets: FxHashMap::default(),
+            diagnostics: TypeCheckDiagnosticsBuilder::new(db, file),
         }
     }
 
@@ -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(todo_type!("starred unpacking"));
+                            element_types.push(Type::Todo);
 
                             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, todo_type!("starred unpacking"));
+                            element_types.insert(starred_index, Type::Todo);
                             Cow::Owned(element_types)
                         }
                     } else {
@@ -95,7 +95,7 @@ impl<'db> Unpacker<'db> {
                     // there would be a cost and it's not clear that it's worth it.
                     let value_ty = Type::tuple(
                         self.db,
-                        std::iter::repeat(Type::LiteralString).take(string_literal_ty.len(self.db)),
+                        &vec![Type::LiteralString; string_literal_ty.len(self.db)],
                     );
                     self.unpack(target, value_ty, scope);
                 }
@@ -103,11 +103,9 @@ impl<'db> Unpacker<'db> {
                     let value_ty = if value_ty.is_literal_string() {
                         Type::LiteralString
                     } else {
-                        value_ty.iterate(self.db).unwrap_with_diagnostic(
-                            self.db,
-                            self.file,
-                            AnyNodeRef::from(target),
-                        )
+                        value_ty
+                            .iterate(self.db)
+                            .unwrap_with_diagnostic(AnyNodeRef::from(target), &mut self.diagnostics)
                     };
                     for element in elts {
                         self.unpack(element, value_ty, scope);
@@ -121,6 +119,7 @@ impl<'db> Unpacker<'db> {
     pub(crate) fn finish(mut self) -> UnpackResult<'db> {
         self.targets.shrink_to_fit();
         UnpackResult {
+            diagnostics: self.diagnostics.finish(),
             targets: self.targets,
         }
     }
@@ -129,10 +128,15 @@ impl<'db> Unpacker<'db> {
 #[derive(Debug, Default, PartialEq, Eq)]
 pub(crate) struct UnpackResult<'db> {
     targets: FxHashMap<ScopedExpressionId, Type<'db>>,
+    diagnostics: TypeCheckDiagnostics,
 }
 
 impl<'db> UnpackResult<'db> {
     pub(crate) fn get(&self, expr_id: ScopedExpressionId) -> Option<Type<'db>> {
         self.targets.get(&expr_id).copied()
     }
+
+    pub(crate) fn diagnostics(&self) -> &TypeCheckDiagnostics {
+        &self.diagnostics
+    }
 }

crates/red_knot_python_semantic/tests/mdtest.rs

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

crates/red_knot_server/src/server/api.rs

@@ -91,11 +91,11 @@ fn background_request_task<'a, R: traits::BackgroundDocumentRequestHandler>(
         let db = match path {
             AnySystemPath::System(path) => {
                 match session.workspace_db_for_path(path.as_std_path()) {
-                    Some(db) => db.clone(),
-                    None => session.default_workspace_db().clone(),
+                    Some(db) => db.snapshot(),
+                    None => session.default_workspace_db().snapshot(),
                 }
             }
-            AnySystemPath::SystemVirtual(_) => session.default_workspace_db().clone(),
+            AnySystemPath::SystemVirtual(_) => session.default_workspace_db().snapshot(),
         };
 
         let Some(snapshot) = session.take_snapshot(url) else {

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 Client<'_> {
+impl<'s> Client<'s> {
     pub(super) fn new(sender: ClientSender) -> Self {
         Self {
             notifier: Notifier(sender.clone()),

crates/red_knot_test/Cargo.toml

@@ -20,7 +20,6 @@ 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,11 +184,8 @@ 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.
 
-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.
+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.
 
 ## Structured test suites
 

crates/red_knot_test/src/db.rs

@@ -7,7 +7,6 @@ use ruff_db::vendored::VendoredFileSystem;
 use ruff_db::{Db as SourceDb, Upcast};
 
 #[salsa::db]
-#[derive(Clone)]
 pub(crate) struct Db {
     workspace_root: SystemPathBuf,
     storage: salsa::Storage<Self>,

crates/red_knot_test/src/lib.rs

@@ -1,12 +1,13 @@
-use camino::Utf8Path;
 use colored::Colorize;
 use parser as test_parser;
 use red_knot_python_semantic::types::check_types;
-use ruff_db::diagnostic::{CompileDiagnostic, Diagnostic};
+use ruff_db::diagnostic::{Diagnostic, ParseDiagnostic};
 use ruff_db::files::{system_path_to_file, File, Files};
+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;
@@ -14,30 +15,23 @@ 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: &Utf8Path, long_title: &str, short_title: &str, test_name: &str) {
+pub fn run(path: &Path, long_title: &str, short_title: &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 `{path}`: {err}")
+            panic!("Error parsing `{}`: {err}", path.to_str().unwrap())
         }
     };
 
     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);
@@ -60,15 +54,6 @@ pub fn run(path: &Utf8Path, long_title: &str, short_title: &str, test_name: &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()
-            );
         }
     }
 
@@ -101,9 +86,24 @@ fn run_test(db: &mut db::Db, test: &parser::MarkdownTest) -> Result<(), Failures
     let failures: Failures = test_files
         .into_iter()
         .filter_map(|test_file| {
-            let mut diagnostics = check_types::accumulated::<CompileDiagnostic>(db, test_file.file);
-            // Filter out diagnostics that are not related to the current file.
-            diagnostics.retain(|diagnostic| diagnostic.file() == test_file.file);
+            let parsed = parsed_module(db, test_file.file);
+
+            let mut diagnostics: Vec<Box<_>> = parsed
+                .errors()
+                .iter()
+                .cloned()
+                .map(|error| {
+                    let diagnostic: Box<dyn Diagnostic> =
+                        Box::new(ParseDiagnostic::new(test_file.file, error));
+                    diagnostic
+                })
+                .collect();
+
+            let type_diagnostics = check_types(db, test_file.file);
+            diagnostics.extend(type_diagnostics.into_iter().map(|diagnostic| {
+                let diagnostic: Box<dyn Diagnostic> = Box::new((*diagnostic).clone());
+                diagnostic
+            }));
 
             match matcher::match_file(db, test_file.file, diagnostics) {
                 Ok(()) => None,

crates/red_knot_test/src/matcher.rs

@@ -180,16 +180,6 @@ 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,
@@ -286,9 +276,6 @@ 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 @@
-0a2da01946a406ede42e9c66f416a7e7758991d6
+5052fa2f18db4493892e0f2775030683c9d06531

crates/red_knot_vendored/vendor/typeshed/stdlib/VERSIONS

@@ -33,7 +33,6 @@ _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
@@ -41,7 +40,6 @@ _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-
@@ -54,7 +52,6 @@ _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-
@@ -142,12 +139,6 @@ 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,13 +2,10 @@ import codecs
 import sys
 from _typeshed import ReadableBuffer
 from collections.abc import Callable
-from typing import Literal, final, overload, type_check_only
+from typing import Literal, overload
 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,7 +73,6 @@ _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):
@@ -82,7 +81,6 @@ 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]: ...
@@ -90,7 +88,6 @@ 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
-from typing import Any, Final, type_check_only
-from typing_extensions import Self, TypeAlias
+from collections.abc import Iterable, Iterator
+from typing import Any, Final
+from typing_extensions import TypeAlias
 
 __version__: Final[str]
 
@@ -45,47 +45,17 @@ class Dialect:
         strict: bool = False,
     ) -> None: ...
 
-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 _reader(Iterator[list[str]]):
+    @property
+    def dialect(self) -> Dialect: ...
+    line_num: int
+    def __next__(self) -> list[str]: ...
 
-    # 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: ...
+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,10 +1,9 @@
-import _typeshed
 import sys
-from _typeshed import ReadableBuffer, StrOrBytesPath, WriteableBuffer
+from _typeshed import ReadableBuffer, 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, final, overload, type_check_only
+from typing import Any, ClassVar, Generic, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
 if sys.version_info >= (3, 9):
@@ -48,79 +47,46 @@ if sys.platform == "win32":
     def LoadLibrary(name: str, load_flags: int = 0, /) -> int: ...
     def FreeLibrary(handle: int, /) -> None: ...
 
-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 _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]
 
-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:
+class _CData(metaclass=_CDataMeta):
     _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 __ctypes_from_outparam__(self, /) -> Self: ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
 
-# 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):
+class _SimpleCData(_CData, Generic[_T]):
     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): ...
 
-# 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):
+class _Pointer(_PointerLike, _CData, Generic[_CT]):
     _type_: type[_CT]
     contents: _CT
     @overload
@@ -139,32 +105,16 @@ 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 | _CDataType, offset: int = ...) -> _CArgObject: ...
+def byref(obj: _CData, offset: int = ...) -> _CArgObject: ...
 
-_ECT: TypeAlias = Callable[[_CData | _CDataType | None, CFuncPtr, tuple[_CData | _CDataType, ...]], _CDataType]
+_ECT: TypeAlias = Callable[[_CData | None, CFuncPtr, tuple[_CData, ...]], _CData]
 _PF: TypeAlias = tuple[int] | tuple[int, str | None] | tuple[int, str | None, Any]
 
-# 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]]
+class CFuncPtr(_PointerLike, _CData):
+    restype: type[_CData] | Callable[[int], Any] | None
+    argtypes: Sequence[type[_CData]]
     errcheck: _ECT
     # Abstract attribute that must be defined on subclasses
     _flags_: ClassVar[int]
@@ -179,7 +129,7 @@ class CFuncPtr(_PointerLike, _CData, metaclass=_PyCFuncPtrType):
     if sys.platform == "win32":
         @overload
         def __init__(
-            self, vtbl_index: int, name: str, paramflags: tuple[_PF, ...] | None = ..., iid: _CData | _CDataType | None = ..., /
+            self, vtbl_index: int, name: str, paramflags: tuple[_PF, ...] | None = ..., iid: _CData | None = ..., /
         ) -> None: ...
 
     def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
@@ -187,95 +137,30 @@ class CFuncPtr(_PointerLike, _CData, metaclass=_PyCFuncPtrType):
 _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
-    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: ...
-
+    @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: ...
 
-# 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.
+class _StructUnionMeta(_CDataMeta):
+    _fields_: Sequence[tuple[str, type[_CData]] | tuple[str, type[_CData], int]]
+    _pack_: int
+    _anonymous_: Sequence[str]
     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: ...
 
-# 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 Union(_StructUnionBase): ...
+class Structure(_StructUnionBase): ...
 
-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):
+class Array(_CData, Generic[_CT]):
     @property
     @abstractmethod
     def _length_(self) -> int: ...
@@ -320,15 +205,9 @@ class Array(_CData, Generic[_CT], metaclass=_PyCArrayType):
     if sys.version_info >= (3, 9):
         def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-def addressof(obj: _CData | _CDataType, /) -> int: ...
-def alignment(obj_or_type: _CData | _CDataType | type[_CData | _CDataType], /) -> int: ...
+def addressof(obj: _CData, /) -> int: ...
+def alignment(obj_or_type: _CData | type[_CData], /) -> int: ...
 def get_errno() -> int: ...
-def resize(obj: _CData | _CDataType, size: int, /) -> None: ...
+def resize(obj: _CData, size: int, /) -> None: ...
 def set_errno(value: int, /) -> 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: ...
+def sizeof(obj_or_type: _CData | type[_CData], /) -> int: ...

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

@@ -1,7 +1,6 @@
 import sys
 from _typeshed import ReadOnlyBuffer, SupportsRead
-from curses import _ncurses_version
-from typing import IO, Any, final, overload
+from typing import IO, Any, NamedTuple, final, overload
 from typing_extensions import TypeAlias
 
 # NOTE: This module is ordinarily only available on Unix, but the windows-curses
@@ -550,4 +549,9 @@ 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

@@ -1,27 +0,0 @@
-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, final, overload, type_check_only
+from typing import TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
 if sys.platform != "win32":
@@ -13,8 +13,6 @@ 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):
@@ -24,17 +22,18 @@ 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: ...
-        # This isn't true, but the class can't be instantiated. See #13024
+        def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ...
+        # Don't exist at runtime
         __new__: None  # type: ignore[assignment]
         __init__: None  # type: ignore[assignment]
 

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

@@ -17,13 +17,20 @@ 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

@@ -1,80 +0,0 @@
-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,6 +45,5 @@ 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

@@ -1,44 +0,0 @@
-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,6 +4,7 @@ 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 CapsuleType, TypeAlias
+from typing_extensions import TypeAlias
 
 _CMSG: TypeAlias = tuple[int, int, bytes]
 _CMSGArg: TypeAlias = tuple[int, int, ReadableBuffer]
@@ -72,8 +72,7 @@ SO_SNDBUF: int
 SO_SNDLOWAT: int
 SO_SNDTIMEO: int
 SO_TYPE: int
-if sys.platform != "linux":
-    SO_USELOOPBACK: int
+SO_USELOOPBACK: int
 if sys.platform == "win32":
     SO_EXCLUSIVEADDRUSE: int
 if sys.platform != "win32":
@@ -88,10 +87,7 @@ 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
 
@@ -103,32 +99,27 @@ 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_ERRQUEUE: int
-if sys.platform == "win32":
     MSG_BCAST: int
+    MSG_ERRQUEUE: 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
@@ -137,11 +128,10 @@ 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
@@ -153,22 +143,21 @@ 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 != "linux":
-    IPPROTO_GGP: int
-    IPPROTO_IPV4: int
-    IPPROTO_MAX: int
-    IPPROTO_ND: int
-if sys.platform == "win32":
+if sys.platform != "darwin":
     IPPROTO_CBT: int
     IPPROTO_ICLFXBM: int
     IPPROTO_IGP: int
@@ -177,19 +166,18 @@ if sys.platform == "win32":
     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" and sys.platform != "linux":
-    IPPROTO_BIP: int  # Not FreeBSD either
-    IPPROTO_MOBILE: int  # Not FreeBSD either
-    IPPROTO_VRRP: int  # Not FreeBSD either
+if sys.platform != "win32" and sys.platform != "darwin":
+    IPPROTO_BIP: int
+    IPPROTO_MOBILE: int
+    IPPROTO_VRRP: int
 if sys.version_info >= (3, 9) and sys.platform == "linux":
     # Availability: Linux >= 2.6.20, FreeBSD >= 10.1
     IPPROTO_UDPLITE: int
@@ -214,10 +202,11 @@ IP_MULTICAST_IF: int
 IP_MULTICAST_LOOP: int
 IP_MULTICAST_TTL: int
 IP_OPTIONS: int
-if sys.platform != "linux":
-    IP_RECVDSTADDR: int
+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":
@@ -229,7 +218,6 @@ 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
@@ -267,9 +255,6 @@ 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
@@ -283,12 +268,11 @@ 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
@@ -297,7 +281,7 @@ AI_NUMERICHOST: int
 AI_NUMERICSERV: int
 AI_PASSIVE: int
 AI_V4MAPPED: int
-if sys.platform != "win32" and sys.platform != "linux":
+if sys.platform != "win32":
     AI_DEFAULT: int
     AI_MASK: int
     AI_V4MAPPED_CFG: int
@@ -309,8 +293,6 @@ 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
@@ -336,27 +318,6 @@ 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
@@ -373,13 +334,12 @@ 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
@@ -477,13 +437,12 @@ 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
@@ -497,10 +456,6 @@ 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
@@ -567,17 +522,16 @@ 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
-    if sys.platform != "linux":
-        AF_LINK: int
+    AF_LINK: int
 
 has_ipv6: bool
 
-if sys.platform != "darwin" and sys.platform != "linux":
+if sys.platform != "darwin":
     if sys.platform != "win32" or sys.version_info >= (3, 9):
         BDADDR_ANY: str
         BDADDR_LOCAL: str
 
-if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
+if sys.platform != "win32" and sys.platform != "darwin":
     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
@@ -626,37 +580,36 @@ 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" and sys.platform != "linux":
+if sys.platform != "darwin":
     if sys.version_info >= (3, 9) or sys.platform != "win32":
         AF_BLUETOOTH: int
 
-if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
+if sys.platform != "win32" and sys.platform != "darwin":
     # 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" and sys.platform != "linux":
+if sys.platform != "darwin":
     if sys.version_info >= (3, 9) or sys.platform != "win32":
         BTPROTO_RFCOMM: int
 
@@ -683,14 +636,13 @@ 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
@@ -709,12 +661,10 @@ if sys.platform != "win32" and sys.platform != "darwin":
 
 # Miscellaneous undocumented
 
-if sys.platform != "win32" and sys.platform != "linux":
+if sys.platform != "win32":
     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 =====
@@ -842,4 +792,4 @@ def if_nameindex() -> list[tuple[int, str]]: ...
 def if_nametoindex(oname: str, /) -> int: ...
 def if_indextoname(index: int, /) -> str: ...
 
-CAPI: CapsuleType
+CAPI: object

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

@@ -44,12 +44,6 @@ def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpa
 @overload
 def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any], /) -> int: ...
 
-# Obsolete synonym for start_new_thread()
-@overload
-def start_new(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int: ...
-@overload
-def start_new(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any], /) -> int: ...
-
 if sys.version_info >= (3, 10):
     def interrupt_main(signum: signal.Signals = ..., /) -> None: ...
 
@@ -57,9 +51,7 @@ else:
     def interrupt_main() -> None: ...
 
 def exit() -> NoReturn: ...
-def exit_thread() -> NoReturn: ...  # Obsolete synonym for exit()
 def allocate_lock() -> LockType: ...
-def allocate() -> LockType: ...  # Obsolete synonym for allocate_lock()
 def get_ident() -> int: ...
 def stack_size(size: int = 0, /) -> int: ...
 

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

@@ -1,4 +1,3 @@
-from threading import RLock
 from typing import Any
 from typing_extensions import Self, TypeAlias
 from weakref import ReferenceType
@@ -9,9 +8,6 @@ _LocalDict: TypeAlias = dict[Any, Any]
 class _localimpl:
     key: str
     dicts: dict[int, tuple[ReferenceType[Any], _LocalDict]]
-    # Keep localargs in sync with the *args, **kwargs annotation on local.__new__
-    localargs: tuple[list[Any], dict[str, Any]]
-    locallock: RLock
     def get_dict(self) -> _LocalDict: ...
     def create_dict(self) -> _LocalDict: ...
 

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

@@ -107,7 +107,7 @@ class object:
     @property
     def __class__(self) -> type[Self]: ...
     @__class__.setter
-    def __class__(self, type: type[Self], /) -> None: ...
+    def __class__(self, type: type[object], /) -> None: ...
     def __init__(self) -> None: ...
     def __new__(cls) -> Self: ...
     # N.B. `object.__setattr__` and `object.__delattr__` are heavily special-cased by type checkers.
@@ -1963,33 +1963,14 @@ class StopAsyncIteration(Exception):
 
 class SyntaxError(Exception):
     msg: str
-    filename: str | None
     lineno: int | None
     offset: int | None
     text: str | None
-    # Errors are displayed differently if this attribute exists on the exception.
-    # The value is always None.
-    print_file_and_line: None
+    filename: str | None
     if sys.version_info >= (3, 10):
         end_lineno: int | None
         end_offset: int | None
 
-    @overload
-    def __init__(self) -> None: ...
-    @overload
-    def __init__(self, msg: object, /) -> None: ...
-    # Second argument is the tuple (filename, lineno, offset, text)
-    @overload
-    def __init__(self, msg: str, info: tuple[str | None, int | None, int | None, str | None], /) -> None: ...
-    if sys.version_info >= (3, 10):
-        # end_lineno and end_offset must both be provided if one is.
-        @overload
-        def __init__(
-            self, msg: str, info: tuple[str | None, int | None, int | None, str | None, int | None, int | None], /
-        ) -> None: ...
-    # If you provide more than two arguments, it still creates the SyntaxError, but
-    # the arguments from the info tuple are not parsed. This form is omitted.
-
 class SystemError(Exception): ...
 class TypeError(Exception): ...
 class ValueError(Exception): ...

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

@@ -126,7 +126,6 @@ class BZ2File(BaseStream, IO[bytes]):
     def readline(self, size: SupportsIndex = -1) -> bytes: ...  # type: ignore[override]
     def readinto(self, b: WriteableBuffer) -> int: ...
     def readlines(self, size: SupportsIndex = -1) -> list[bytes]: ...
-    def peek(self, n: int = 0) -> bytes: ...
     def seek(self, offset: int, whence: int = 0) -> int: ...
     def write(self, data: ReadableBuffer) -> int: ...
     def writelines(self, seq: Iterable[ReadableBuffer]) -> None: ...

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

@@ -3,7 +3,7 @@ from _codecs import *
 from _typeshed import ReadableBuffer
 from abc import abstractmethod
 from collections.abc import Callable, Generator, Iterable
-from typing import Any, BinaryIO, ClassVar, Final, Literal, Protocol, TextIO
+from typing import Any, BinaryIO, Final, Literal, Protocol, TextIO
 from typing_extensions import Self
 
 __all__ = [
@@ -202,7 +202,6 @@ class StreamWriter(Codec):
     def write(self, object: str) -> None: ...
     def writelines(self, list: Iterable[str]) -> None: ...
     def reset(self) -> None: ...
-    def seek(self, offset: int, whence: int = 0) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(self, type: type[BaseException] | None, value: BaseException | None, tb: types.TracebackType | None) -> None: ...
     def __getattr__(self, name: str, getattr: Callable[[Any, str], Any] = ...) -> Any: ...
@@ -210,14 +209,11 @@ class StreamWriter(Codec):
 class StreamReader(Codec):
     stream: _ReadableStream
     errors: str
-    # This is set to str, but some subclasses set to bytes instead.
-    charbuffertype: ClassVar[type] = ...
     def __init__(self, stream: _ReadableStream, errors: str = "strict") -> None: ...
     def read(self, size: int = -1, chars: int = -1, firstline: bool = False) -> str: ...
     def readline(self, size: int | None = None, keepends: bool = True) -> str: ...
     def readlines(self, sizehint: int | None = None, keepends: bool = True) -> list[str]: ...
     def reset(self) -> None: ...
-    def seek(self, offset: int, whence: int = 0) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(self, type: type[BaseException] | None, value: BaseException | None, tb: types.TracebackType | None) -> None: ...
     def __iter__(self) -> Self: ...

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

@@ -1,5 +1,5 @@
 import sys
-from _typeshed import MaybeNone, StrOrBytesPath, SupportsWrite
+from _typeshed import StrOrBytesPath, SupportsWrite
 from collections.abc import Callable, ItemsView, Iterable, Iterator, Mapping, MutableMapping, Sequence
 from re import Pattern
 from typing import Any, ClassVar, Final, Literal, TypeVar, overload
@@ -263,11 +263,11 @@ class RawConfigParser(_Parser):
     ) -> _T: ...
     # This is incompatible with MutableMapping so we ignore the type
     @overload  # type: ignore[override]
-    def get(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> str | MaybeNone: ...
+    def get(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> str | Any: ...
     @overload
     def get(
         self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T
-    ) -> str | _T | MaybeNone: ...
+    ) -> str | _T | Any: ...
     @overload
     def items(self, *, raw: bool = False, vars: _Section | None = None) -> ItemsView[str, SectionProxy]: ...
     @overload
@@ -277,8 +277,6 @@ class RawConfigParser(_Parser):
     def remove_option(self, section: str, option: str) -> bool: ...
     def remove_section(self, section: str) -> bool: ...
     def optionxform(self, optionstr: str) -> str: ...
-    @property
-    def converters(self) -> ConverterMapping: ...
 
 class ConfigParser(RawConfigParser):
     # This is incompatible with MutableMapping so we ignore the type
@@ -302,34 +300,28 @@ class SectionProxy(MutableMapping[str, str]):
     def parser(self) -> RawConfigParser: ...
     @property
     def name(self) -> str: ...
-    # This is incompatible with MutableMapping so we ignore the type
-    @overload  # type: ignore[override]
-    def get(
-        self, option: str, *, raw: bool = False, vars: _Section | None = None, _impl: Any | None = None, **kwargs: Any
-    ) -> str | None: ...
-    @overload
-    def get(
+    def get(  # type: ignore[override]
         self,
         option: str,
-        fallback: _T,
+        fallback: str | None = None,
         *,
         raw: bool = False,
         vars: _Section | None = None,
         _impl: Any | None = None,
         **kwargs: Any,
-    ) -> str | _T: ...
+    ) -> str | Any: ...  # can be None in RawConfigParser's sections
     # These are partially-applied version of the methods with the same names in
     # RawConfigParser; the stubs should be kept updated together
     @overload
-    def getint(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> int | None: ...
+    def getint(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> int: ...
     @overload
     def getint(self, option: str, fallback: _T = ..., *, raw: bool = ..., vars: _Section | None = ...) -> int | _T: ...
     @overload
-    def getfloat(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> float | None: ...
+    def getfloat(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> float: ...
     @overload
     def getfloat(self, option: str, fallback: _T = ..., *, raw: bool = ..., vars: _Section | None = ...) -> float | _T: ...
     @overload
-    def getboolean(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> bool | None: ...
+    def getboolean(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> bool: ...
     @overload
     def getboolean(self, option: str, fallback: _T = ..., *, raw: bool = ..., vars: _Section | None = ...) -> bool | _T: ...
     # SectionProxy can have arbitrary attributes when custom converters are used

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

@@ -1,7 +1,7 @@
 import abc
 import sys
 from _typeshed import FileDescriptorOrPath, Unused
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable, Generator, Iterator
 from types import TracebackType
 from typing import IO, Any, Generic, Protocol, TypeVar, overload, runtime_checkable
@@ -38,22 +38,16 @@ _P = ParamSpec("_P")
 _ExitFunc: TypeAlias = Callable[[type[BaseException] | None, BaseException | None, TracebackType | None], bool | None]
 _CM_EF = TypeVar("_CM_EF", bound=AbstractContextManager[Any, Any] | _ExitFunc)
 
-# mypy and pyright object to this being both ABC and Protocol.
-# At runtime it inherits from ABC and is not a Protocol, but it is on the
-# allowlist for use as a Protocol.
 @runtime_checkable
-class AbstractContextManager(ABC, Protocol[_T_co, _ExitT_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+class AbstractContextManager(Protocol[_T_co, _ExitT_co]):
     def __enter__(self) -> _T_co: ...
     @abstractmethod
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
     ) -> _ExitT_co: ...
 
-# mypy and pyright object to this being both ABC and Protocol.
-# At runtime it inherits from ABC and is not a Protocol, but it is on the
-# allowlist for use as a Protocol.
 @runtime_checkable
-class AbstractAsyncContextManager(ABC, Protocol[_T_co, _ExitT_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+class AbstractAsyncContextManager(Protocol[_T_co, _ExitT_co]):
     async def __aenter__(self) -> _T_co: ...
     @abstractmethod
     async def __aexit__(

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

@@ -1,15 +1,8 @@
 import sys
-from typing import Final, NamedTuple, type_check_only
+from typing import Final
 
 if sys.platform != "win32":
-    @type_check_only
-    class _MethodBase(NamedTuple):
-        name: str
-        ident: str | None
-        salt_chars: int
-        total_size: int
-
-    class _Method(_MethodBase): ...
+    class _Method: ...
     METHOD_CRYPT: Final[_Method]
     METHOD_MD5: Final[_Method]
     METHOD_SHA256: Final[_Method]

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

@@ -8,6 +8,8 @@ from _csv import (
     __version__ as __version__,
     _DialectLike,
     _QuotingType,
+    _reader,
+    _writer,
     field_size_limit as field_size_limit,
     get_dialect as get_dialect,
     list_dialects as list_dialects,
@@ -19,10 +21,6 @@ from _csv import (
 
 if sys.version_info >= (3, 12):
     from _csv import QUOTE_NOTNULL as QUOTE_NOTNULL, QUOTE_STRINGS as QUOTE_STRINGS
-if sys.version_info >= (3, 10):
-    from _csv import Reader, Writer
-else:
-    from _csv import _reader as Reader, _writer as Writer
 
 from _typeshed import SupportsWrite
 from collections.abc import Collection, Iterable, Mapping, Sequence
@@ -79,7 +77,7 @@ class DictReader(Generic[_T]):
     fieldnames: Sequence[_T] | None
     restkey: _T | None
     restval: str | Any | None
-    reader: Reader
+    reader: _reader
     dialect: _DialectLike
     line_num: int
     @overload
@@ -127,7 +125,7 @@ class DictWriter(Generic[_T]):
     fieldnames: Collection[_T]
     restval: Any | None
     extrasaction: Literal["raise", "ignore"]
-    writer: Writer
+    writer: _writer
     def __init__(
         self,
         f: SupportsWrite[str],