Add rule registry and rule selection

## Summary

Upgrades to React 19. Closes
https://github.com/astral-sh/ruff/issues/14859

## Test Plan

I ran the playground locally and clicked through the different panels. I
didn't see any warning or error.

.github/CODEOWNERS

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

.github/workflows/build-binaries.yml

@@ -40,6 +40,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -68,6 +69,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -109,6 +111,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -164,6 +167,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -216,6 +220,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -290,6 +295,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -354,6 +360,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -419,6 +426,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}

.github/workflows/build-docker.yml

@@ -36,6 +36,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          persist-credentials: false
 
       - uses: docker/setup-buildx-action@v3
 

.github/workflows/ci.yaml

@@ -32,10 +32,13 @@ jobs:
       # Flag that is raised when any code is changed
       # This is superset of the linter and formatter
       code: ${{ steps.changed.outputs.code_any_changed }}
+      # Flag that is raised when any code that affects the fuzzer is changed
+      fuzz: ${{ steps.changed.outputs.fuzz_any_changed }}
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          persist-credentials: false
 
       - uses: tj-actions/changed-files@v45
         id: changed
@@ -49,7 +52,7 @@ jobs:
               - crates/ruff_text_size/**
               - crates/ruff_python_ast/**
               - crates/ruff_python_parser/**
-              - scripts/fuzz-parser/**
+              - python/py-fuzzer/**
               - .github/workflows/ci.yaml
 
             linter:
@@ -79,9 +82,15 @@ jobs:
               - python/**
               - .github/workflows/ci.yaml
 
+            fuzz:
+              - fuzz/Cargo.toml
+              - fuzz/Cargo.lock
+              - fuzz/fuzz_targets/**
+
             code:
               - "**/*"
               - "!**/*.md"
+              - "crates/red_knot_python_semantic/resources/mdtest/**/*.md"
               - "!docs/**"
               - "!assets/**"
 
@@ -91,6 +100,8 @@ jobs:
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup component add rustfmt
       - run: cargo fmt --all --check
@@ -103,6 +114,8 @@ jobs:
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: |
           rustup component add clippy
@@ -115,12 +128,14 @@ jobs:
 
   cargo-test-linux:
     name: "cargo test (linux)"
-    runs-on: ubuntu-latest
+    runs-on: depot-ubuntu-22.04-16
     needs: determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
@@ -157,14 +172,45 @@ jobs:
           name: ruff
           path: target/debug/ruff
 
-  cargo-test-windows:
-    name: "cargo test (windows)"
-    runs-on: windows-latest
+  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
+        with:
+          persist-credentials: false
+      - 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
+    needs: determine_changes
+    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install cargo nextest"
@@ -189,6 +235,8 @@ jobs:
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
       - uses: actions/setup-node@v4
@@ -197,6 +245,8 @@ jobs:
           cache: "npm"
           cache-dependency-path: playground/package-lock.json
       - uses: jetli/wasm-pack-action@v0.4.0
+        with:
+          version: v0.13.1
       - uses: Swatinem/rust-cache@v2
       - name: "Test ruff_wasm"
         run: |
@@ -210,11 +260,12 @@ jobs:
   cargo-build-release:
     name: "cargo build (release)"
     runs-on: macos-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
+    if: ${{ github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"
@@ -231,6 +282,8 @@ jobs:
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: SebRollen/toml-action@v1.2.0
         id: msrv
         with:
@@ -255,14 +308,16 @@ jobs:
           NEXTEST_PROFILE: "ci"
         run: cargo +${{ steps.msrv.outputs.value }} insta test --all-features --unreferenced reject --test-runner nextest
 
-  cargo-fuzz:
-    name: "cargo fuzz"
+  cargo-fuzz-build:
+    name: "cargo fuzz build"
     runs-on: ubuntu-latest
     needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
+    if: ${{ github.ref == 'refs/heads/main' || needs.determine_changes.outputs.fuzz == 'true' }}
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup show
       - uses: Swatinem/rust-cache@v2
@@ -278,7 +333,7 @@ jobs:
       - run: cargo fuzz build -s none
 
   fuzz-parser:
-    name: "Fuzz the parser"
+    name: "fuzz parser"
     runs-on: ubuntu-latest
     needs:
       - cargo-test-linux
@@ -289,13 +344,9 @@ jobs:
       FORCE_COLOR: 1
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
         with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Install uv
-        run: curl -LsSf https://astral.sh/uv/install.sh | sh
-      - name: Install Python requirements
-        run: uv pip install -r scripts/fuzz-parser/requirements.txt --system
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@v4
       - uses: actions/download-artifact@v4
         name: Download Ruff binary to test
         id: download-cached-binary
@@ -307,7 +358,15 @@ jobs:
           # Make executable, since artifact download doesn't preserve this
           chmod +x ${{ steps.download-cached-binary.outputs.download-path }}/ruff
 
-          python scripts/fuzz-parser/fuzz.py 0-500 --test-executable ${{ steps.download-cached-binary.outputs.download-path }}/ruff
+          (
+            uvx \
+            --python=${{ env.PYTHON_VERSION }} \
+            --from=./python/py-fuzzer \
+            fuzz \
+            --test-executable=${{ steps.download-cached-binary.outputs.download-path }}/ruff \
+            --bin=ruff \
+            0-500
+          )
 
   scripts:
     name: "test scripts"
@@ -317,6 +376,8 @@ jobs:
     timeout-minutes: 5
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup component add rustfmt
       - uses: Swatinem/rust-cache@v2
@@ -331,7 +392,7 @@ jobs:
 
   ecosystem:
     name: "ecosystem"
-    runs-on: ubuntu-latest
+    runs-on: depot-ubuntu-latest-8
     needs:
       - cargo-test-linux
       - determine_changes
@@ -341,6 +402,8 @@ jobs:
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -352,7 +415,7 @@ jobs:
           name: ruff
           path: target/debug
 
-      - uses: dawidd6/action-download-artifact@v6
+      - uses: dawidd6/action-download-artifact@v7
         name: Download baseline Ruff binary
         with:
           name: ruff
@@ -451,6 +514,8 @@ jobs:
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: cargo-bins/cargo-binstall@main
       - run: cargo binstall --no-confirm cargo-shear
       - run: cargo shear
@@ -461,6 +526,8 @@ jobs:
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -486,6 +553,8 @@ jobs:
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -517,6 +586,8 @@ jobs:
       MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: actions/setup-python@v5
         with:
           python-version: "3.13"
@@ -528,7 +599,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: Install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
       - uses: Swatinem/rust-cache@v2
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
@@ -557,16 +628,18 @@ jobs:
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Cache rust"
         uses: Swatinem/rust-cache@v2
-      - name: "Formatter progress"
+      - name: "Run checks"
         run: scripts/formatter_ecosystem_checks.sh
       - name: "Github step summary"
-        run: cat target/progress_projects_stats.txt > $GITHUB_STEP_SUMMARY
+        run: cat target/formatter-ecosystem/stats.txt > $GITHUB_STEP_SUMMARY
       - name: "Remove checkouts from cache"
-        run: rm -r target/progress_projects
+        run: rm -r target/formatter-ecosystem
 
   check-ruff-lsp:
     name: "test ruff-lsp"
@@ -584,6 +657,7 @@ jobs:
       - uses: actions/checkout@v4
         name: "Download ruff-lsp source"
         with:
+          persist-credentials: false
           repository: "astral-sh/ruff-lsp"
 
       - uses: actions/setup-python@v5
@@ -619,6 +693,8 @@ jobs:
     steps:
       - name: "Checkout Branch"
         uses: actions/checkout@v4
+        with:
+          persist-credentials: false
 
       - name: "Install Rust toolchain"
         run: rustup show

.github/workflows/daily_fuzz.yaml

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

.github/workflows/pr-comment.yaml

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

.github/workflows/publish-docs.yml

@@ -26,6 +26,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           ref: ${{ inputs.ref }}
+          persist-credentials: true
 
       - uses: actions/setup-python@v5
         with:

.github/workflows/publish-playground.yml

@@ -25,6 +25,8 @@ jobs:
       CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
       - uses: actions/setup-node@v4
@@ -47,7 +49,7 @@ jobs:
         working-directory: playground
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.12.1
+        uses: cloudflare/wrangler-action@v3.13.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/publish-pypi.yml

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

.github/workflows/publish-wasm.yml

@@ -30,6 +30,8 @@ jobs:
       fail-fast: false
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: "Install Rust toolchain"
         run: rustup target add wasm32-unknown-unknown
       - uses: jetli/wasm-pack-action@v0.4.0

.github/workflows/release.yml

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

.github/workflows/sync_typeshed.yaml

@@ -25,11 +25,13 @@ jobs:
         name: Checkout Ruff
         with:
           path: ruff
+          persist-credentials: true
       - uses: actions/checkout@v4
         name: Checkout typeshed
         with:
           repository: python/typeshed
           path: typeshed
+          persist-credentials: true
       - name: Setup git
         run: |
           git config --global user.name typeshedbot

.pre-commit-config.yaml

@@ -22,7 +22,7 @@ repos:
       - id: validate-pyproject
 
   - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.18
+    rev: 0.7.19
     hooks:
       - id: mdformat
         additional_dependencies:
@@ -36,7 +36,7 @@ repos:
           )$
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.42.0
+    rev: v0.43.0
     hooks:
       - id: markdownlint-fix
         exclude: |
@@ -59,7 +59,7 @@ repos:
           - black==24.10.0
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.27.3
+    rev: v1.28.2
     hooks:
       - id: typos
 
@@ -73,7 +73,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.4
+    rev: v0.8.2
     hooks:
       - id: ruff-format
       - id: ruff
@@ -83,10 +83,25 @@ repos:
 
   # Prettier
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.3.3
+    rev: v3.4.2
     hooks:
       - id: prettier
         types: [yaml]
 
+  - repo: https://github.com/woodruffw/zizmor-pre-commit
+    rev: v0.8.0
+    hooks:
+      - id: zizmor
+        # `release.yml` is autogenerated by `dist`; security issues need to be fixed there
+        # (https://opensource.axo.dev/cargo-dist/)
+        exclude: .github/workflows/release.yml
+        # We could consider enabling the low-severity warnings, but they're noisy
+        args: [--min-severity=medium]
+
+  - repo: https://github.com/python-jsonschema/check-jsonschema
+    rev: 0.30.0
+    hooks:
+      - id: check-github-workflows
+
 ci:
   skip: [cargo-fmt, dev-generate-all]

BREAKING_CHANGES.md

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

CHANGELOG.md

@@ -1,5 +1,182 @@
 # Changelog
 
+## 0.8.2
+
+### Preview features
+
+- \[`airflow`\] Avoid deprecated values (`AIR302`) ([#14582](https://github.com/astral-sh/ruff/pull/14582))
+- \[`airflow`\] Extend removed names for `AIR302` ([#14734](https://github.com/astral-sh/ruff/pull/14734))
+- \[`ruff`\] Extend `unnecessary-regular-expression` to non-literal strings (`RUF055`) ([#14679](https://github.com/astral-sh/ruff/pull/14679))
+- \[`ruff`\] Implement `used-dummy-variable` (`RUF052`) ([#14611](https://github.com/astral-sh/ruff/pull/14611))
+- \[`ruff`\] Implement `unnecessary-cast-to-int` (`RUF046`) ([#14697](https://github.com/astral-sh/ruff/pull/14697))
+
+### Rule changes
+
+- \[`airflow`\] Check `AIR001` from builtin or providers `operators` module ([#14631](https://github.com/astral-sh/ruff/pull/14631))
+- \[`flake8-pytest-style`\] Remove `@` in `pytest.mark.parametrize` rule messages ([#14770](https://github.com/astral-sh/ruff/pull/14770))
+- \[`pandas-vet`\] Skip rules if the `panda` module hasn't been seen ([#14671](https://github.com/astral-sh/ruff/pull/14671))
+- \[`pylint`\] Fix false negatives for `ascii` and `sorted` in `len-as-condition` (`PLC1802`) ([#14692](https://github.com/astral-sh/ruff/pull/14692))
+- \[`refurb`\] Guard `hashlib` imports and mark `hashlib-digest-hex` fix as safe (`FURB181`) ([#14694](https://github.com/astral-sh/ruff/pull/14694))
+
+### Configuration
+
+- \[`flake8-import-conventions`\] Improve syntax check for aliases supplied in configuration for `unconventional-import-alias` (`ICN001`) ([#14745](https://github.com/astral-sh/ruff/pull/14745))
+
+### Bug fixes
+
+- Revert: [pyflakes] Avoid false positives in `@no_type_check` contexts (`F821`, `F722`) (#14615) ([#14726](https://github.com/astral-sh/ruff/pull/14726))
+- \[`pep8-naming`\] Avoid false positive for `class Bar(type(foo))` (`N804`) ([#14683](https://github.com/astral-sh/ruff/pull/14683))
+- \[`pycodestyle`\] Handle f-strings properly for `invalid-escape-sequence` (`W605`) ([#14748](https://github.com/astral-sh/ruff/pull/14748))
+- \[`pylint`\] Ignore `@overload` in `PLR0904` ([#14730](https://github.com/astral-sh/ruff/pull/14730))
+- \[`refurb`\] Handle non-finite decimals in `verbose-decimal-constructor` (`FURB157`) ([#14596](https://github.com/astral-sh/ruff/pull/14596))
+- \[`ruff`\] Avoid emitting `assignment-in-assert` when all references to the assigned variable are themselves inside `assert`s (`RUF018`) ([#14661](https://github.com/astral-sh/ruff/pull/14661))
+
+### Documentation
+
+- Improve docs for `flake8-use-pathlib` rules ([#14741](https://github.com/astral-sh/ruff/pull/14741))
+- Improve error messages and docs for `flake8-comprehensions` rules ([#14729](https://github.com/astral-sh/ruff/pull/14729))
+- \[`flake8-type-checking`\] Expands `TC006` docs to better explain itself ([#14749](https://github.com/astral-sh/ruff/pull/14749))
+
+## 0.8.1
+
+### Preview features
+
+- Formatter: Avoid invalid syntax for format-spec with quotes for all Python versions ([#14625](https://github.com/astral-sh/ruff/pull/14625))
+- Formatter: Consider quotes inside format-specs when choosing the quotes for an f-string ([#14493](https://github.com/astral-sh/ruff/pull/14493))
+- Formatter: Do not consider f-strings with escaped newlines as multiline ([#14624](https://github.com/astral-sh/ruff/pull/14624))
+- Formatter: Fix f-string formatting in assignment statement ([#14454](https://github.com/astral-sh/ruff/pull/14454))
+- Formatter: Fix unnecessary space around power operator (`**`) in overlong f-string expressions ([#14489](https://github.com/astral-sh/ruff/pull/14489))
+- \[`airflow`\] Avoid implicit `schedule` argument to `DAG` and `@dag` (`AIR301`) ([#14581](https://github.com/astral-sh/ruff/pull/14581))
+- \[`flake8-builtins`\] Exempt private built-in modules (`A005`) ([#14505](https://github.com/astral-sh/ruff/pull/14505))
+- \[`flake8-pytest-style`\] Fix `pytest.mark.parametrize` rules to check calls instead of decorators ([#14515](https://github.com/astral-sh/ruff/pull/14515))
+- \[`flake8-type-checking`\] Implement `runtime-cast-value` (`TC006`) ([#14511](https://github.com/astral-sh/ruff/pull/14511))
+- \[`flake8-type-checking`\] Implement `unquoted-type-alias` (`TC007`) and `quoted-type-alias` (`TC008`) ([#12927](https://github.com/astral-sh/ruff/pull/12927))
+- \[`flake8-use-pathlib`\] Recommend `Path.iterdir()` over `os.listdir()` (`PTH208`) ([#14509](https://github.com/astral-sh/ruff/pull/14509))
+- \[`pylint`\] Extend `invalid-envvar-default` to detect `os.environ.get` (`PLW1508`) ([#14512](https://github.com/astral-sh/ruff/pull/14512))
+- \[`pylint`\] Implement `len-test` (`PLC1802`) ([#14309](https://github.com/astral-sh/ruff/pull/14309))
+- \[`refurb`\] Fix bug where methods defined using lambdas were flagged by `FURB118` ([#14639](https://github.com/astral-sh/ruff/pull/14639))
+- \[`ruff`\] Auto-add `r` prefix when string has no backslashes for `unraw-re-pattern` (`RUF039`) ([#14536](https://github.com/astral-sh/ruff/pull/14536))
+- \[`ruff`\] Implement `invalid-assert-message-literal-argument` (`RUF040`) ([#14488](https://github.com/astral-sh/ruff/pull/14488))
+- \[`ruff`\] Implement `unnecessary-nested-literal` (`RUF041`) ([#14323](https://github.com/astral-sh/ruff/pull/14323))
+- \[`ruff`\] Implement `unnecessary-regular-expression` (`RUF055`) ([#14659](https://github.com/astral-sh/ruff/pull/14659))
+
+### Rule changes
+
+- Ignore more rules for stub files ([#14541](https://github.com/astral-sh/ruff/pull/14541))
+- \[`pep8-naming`\] Eliminate false positives for single-letter names (`N811`, `N814`) ([#14584](https://github.com/astral-sh/ruff/pull/14584))
+- \[`pyflakes`\] Avoid false positives in `@no_type_check` contexts (`F821`, `F722`) ([#14615](https://github.com/astral-sh/ruff/pull/14615))
+- \[`ruff`\] Detect redirected-noqa in file-level comments (`RUF101`) ([#14635](https://github.com/astral-sh/ruff/pull/14635))
+- \[`ruff`\] Mark fixes for `unsorted-dunder-all` and `unsorted-dunder-slots` as unsafe when there are complex comments in the sequence (`RUF022`, `RUF023`) ([#14560](https://github.com/astral-sh/ruff/pull/14560))
+
+### Bug fixes
+
+- Avoid fixing code to `None | None` for `redundant-none-literal` (`PYI061`) and `never-union` (`RUF020`) ([#14583](https://github.com/astral-sh/ruff/pull/14583), [#14589](https://github.com/astral-sh/ruff/pull/14589))
+- \[`flake8-bugbear`\] Fix `mutable-contextvar-default` to resolve annotated function calls properly (`B039`) ([#14532](https://github.com/astral-sh/ruff/pull/14532))
+- \[`flake8-pyi`, `ruff`\] Fix traversal of nested literals and unions (`PYI016`, `PYI051`, `PYI055`, `PYI062`, `RUF041`) ([#14641](https://github.com/astral-sh/ruff/pull/14641))
+- \[`flake8-pyi`\] Avoid rewriting invalid type expressions in `unnecessary-type-union` (`PYI055`) ([#14660](https://github.com/astral-sh/ruff/pull/14660))
+- \[`flake8-type-checking`\] Avoid syntax errors and type checking problem for quoted annotations autofix (`TC003`, `TC006`) ([#14634](https://github.com/astral-sh/ruff/pull/14634))
+- \[`pylint`\] Do not wrap function calls in parentheses in the fix for unnecessary-dunder-call (`PLC2801`) ([#14601](https://github.com/astral-sh/ruff/pull/14601))
+- \[`ruff`\] Handle `attrs`'s `auto_attribs` correctly (`RUF009`) ([#14520](https://github.com/astral-sh/ruff/pull/14520))
+
+## 0.8.0
+
+Check out the [blog post](https://astral.sh/blog/ruff-v0.8.0) for a migration guide and overview of the changes!
+
+### Breaking changes
+
+See also, the "Remapped rules" section which may result in disabled rules.
+
+- **Default to Python 3.9**
+
+    Ruff now defaults to Python 3.9 instead of 3.8 if no explicit Python version is configured using [`ruff.target-version`](https://docs.astral.sh/ruff/settings/#target-version) or [`project.requires-python`](https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#python-requires) ([#13896](https://github.com/astral-sh/ruff/pull/13896))
+
+- **Changed location of `pydoclint` diagnostics**
+
+    [`pydoclint`](https://docs.astral.sh/ruff/rules/#pydoclint-doc) diagnostics now point to the first-line of the problematic docstring. Previously, this was not the case.
+
+    If you've opted into these preview rules but have them suppressed using
+    [`noqa`](https://docs.astral.sh/ruff/linter/#error-suppression) comments in
+    some places, this change may mean that you need to move the `noqa` suppression
+    comments. Most users should be unaffected by this change.
+
+- **Use XDG (i.e. `~/.local/bin`) instead of the Cargo home directory in the standalone installer**
+
+    Previously, Ruff's installer used `$CARGO_HOME` or `~/.cargo/bin` for its target install directory. Now, Ruff will be installed into `$XDG_BIN_HOME`, `$XDG_DATA_HOME/../bin`, or `~/.local/bin` (in that order).
+
+    This change is only relevant to users of the standalone Ruff installer (using the shell or PowerShell script). If you installed Ruff using uv or pip, you should be unaffected.
+
+- **Changes to the line width calculation**
+
+    Ruff now uses a new version of the [unicode-width](https://github.com/unicode-rs/unicode-width) Rust crate to calculate the line width. In very rare cases, this may lead to lines containing Unicode characters being reformatted, or being considered too long when they were not before ([`E501`](https://docs.astral.sh/ruff/rules/line-too-long/)).
+
+### Removed Rules
+
+The following deprecated rules have been removed:
+
+- [`missing-type-self`](https://docs.astral.sh/ruff/rules/missing-type-self/) (`ANN101`)
+- [`missing-type-cls`](https://docs.astral.sh/ruff/rules/missing-type-cls/) (`ANN102`)
+- [`syntax-error`](https://docs.astral.sh/ruff/rules/syntax-error/) (`E999`)
+- [`pytest-missing-fixture-name-underscore`](https://docs.astral.sh/ruff/rules/pytest-missing-fixture-name-underscore/) (`PT004`)
+- [`pytest-incorrect-fixture-name-underscore`](https://docs.astral.sh/ruff/rules/pytest-incorrect-fixture-name-underscore/) (`PT005`)
+- [`unpacked-list-comprehension`](https://docs.astral.sh/ruff/rules/unpacked-list-comprehension/) (`UP027`)
+
+### Remapped rules
+
+The following rules have been remapped to new rule codes:
+
+- [`flake8-type-checking`](https://docs.astral.sh/ruff/rules/#flake8-type-checking-tc): `TCH` to `TC`
+
+### Stabilization
+
+The following rules have been stabilized and are no longer in preview:
+
+- [`builtin-import-shadowing`](https://docs.astral.sh/ruff/rules/builtin-import-shadowing/) (`A004`)
+- [`mutable-contextvar-default`](https://docs.astral.sh/ruff/rules/mutable-contextvar-default/) (`B039`)
+- [`fast-api-redundant-response-model`](https://docs.astral.sh/ruff/rules/fast-api-redundant-response-model/) (`FAST001`)
+- [`fast-api-non-annotated-dependency`](https://docs.astral.sh/ruff/rules/fast-api-non-annotated-dependency/) (`FAST002`)
+- [`dict-index-missing-items`](https://docs.astral.sh/ruff/rules/dict-index-missing-items/) (`PLC0206`)
+- [`pep484-style-positional-only-parameter`](https://docs.astral.sh/ruff/rules/pep484-style-positional-only-parameter/) (`PYI063`)
+- [`redundant-final-literal`](https://docs.astral.sh/ruff/rules/redundant-final-literal/) (`PYI064`)
+- [`bad-version-info-order`](https://docs.astral.sh/ruff/rules/bad-version-info-order/) (`PYI066`)
+- [`parenthesize-chained-operators`](https://docs.astral.sh/ruff/rules/parenthesize-chained-operators/) (`RUF021`)
+- [`unsorted-dunder-all`](https://docs.astral.sh/ruff/rules/unsorted-dunder-all/) (`RUF022`)
+- [`unsorted-dunder-slots`](https://docs.astral.sh/ruff/rules/unsorted-dunder-slots/) (`RUF023`)
+- [`assert-with-print-message`](https://docs.astral.sh/ruff/rules/assert-with-print-message/) (`RUF030`)
+- [`unnecessary-default-type-args`](https://docs.astral.sh/ruff/rules/unnecessary-default-type-args/) (`UP043`)
+
+The following behaviors have been stabilized:
+
+- [`ambiguous-variable-name`](https://docs.astral.sh/ruff/rules/ambiguous-variable-name/) (`E741`): Violations in stub files are now ignored. Stub authors typically don't control variable names.
+- [`printf-string-formatting`](https://docs.astral.sh/ruff/rules/printf-string-formatting/) (`UP031`): Report all `printf`-like usages even if no autofix is available
+
+The following fixes have been stabilized:
+
+- [`zip-instead-of-pairwise`](https://docs.astral.sh/ruff/rules/zip-instead-of-pairwise/) (`RUF007`)
+
+### Preview features
+
+- \[`flake8-datetimez`\] Exempt `min.time()` and `max.time()` (`DTZ901`) ([#14394](https://github.com/astral-sh/ruff/pull/14394))
+- \[`flake8-pie`\] Mark fix as unsafe if the following statement is a string literal (`PIE790`) ([#14393](https://github.com/astral-sh/ruff/pull/14393))
+- \[`flake8-pyi`\] New rule `redundant-none-literal` (`PYI061`) ([#14316](https://github.com/astral-sh/ruff/pull/14316))
+- \[`flake8-pyi`\] Add autofix for `redundant-numeric-union` (`PYI041`) ([#14273](https://github.com/astral-sh/ruff/pull/14273))
+- \[`ruff`\] New rule `map-int-version-parsing` (`RUF048`) ([#14373](https://github.com/astral-sh/ruff/pull/14373))
+- \[`ruff`\] New rule `redundant-bool-literal` (`RUF038`) ([#14319](https://github.com/astral-sh/ruff/pull/14319))
+- \[`ruff`\] New rule `unraw-re-pattern` (`RUF039`) ([#14446](https://github.com/astral-sh/ruff/pull/14446))
+- \[`pycodestyle`\] Exempt `pytest.importorskip()` calls (`E402`) ([#14474](https://github.com/astral-sh/ruff/pull/14474))
+- \[`pylint`\] Autofix suggests using sets when possible (`PLR1714`) ([#14372](https://github.com/astral-sh/ruff/pull/14372))
+
+### Rule changes
+
+- [`invalid-pyproject-toml`](https://docs.astral.sh/ruff/rules/invalid-pyproject-toml/) (`RUF200`): Updated to reflect the provisionally accepted [PEP 639](https://peps.python.org/pep-0639/).
+- \[`flake8-pyi`\] Avoid panic in unfixable case (`PYI041`) ([#14402](https://github.com/astral-sh/ruff/pull/14402))
+- \[`flake8-type-checking`\] Correctly handle quotes in subscript expression when generating an autofix ([#14371](https://github.com/astral-sh/ruff/pull/14371))
+- \[`pylint`\] Suggest correct autofix for `__contains__` (`PLC2801`) ([#14424](https://github.com/astral-sh/ruff/pull/14424))
+
+### Configuration
+
+- Ruff now emits a warning instead of an error when a configuration [`ignore`](https://docs.astral.sh/ruff/settings/#lint_ignore)s a rule that has been removed ([#14435](https://github.com/astral-sh/ruff/pull/14435))
+- Ruff now validates that `lint.flake8-import-conventions.aliases` only uses valid module names and aliases ([#14477](https://github.com/astral-sh/ruff/pull/14477))
+
 ## 0.7.4
 
 ### Preview features
@@ -117,7 +294,7 @@
 ### Preview features
 
 - Fix `E221` and `E222` to flag missing or extra whitespace around `==` operator ([#13890](https://github.com/astral-sh/ruff/pull/13890))
-- Formatter: Alternate quotes for strings inside f-strings in preview  ([#13860](https://github.com/astral-sh/ruff/pull/13860))
+- Formatter: Alternate quotes for strings inside f-strings in preview ([#13860](https://github.com/astral-sh/ruff/pull/13860))
 - Formatter: Join implicit concatenated strings when they fit on a line ([#13663](https://github.com/astral-sh/ruff/pull/13663))
 - \[`pylint`\] Restrict `iteration-over-set` to only work on sets of literals (`PLC0208`) ([#13731](https://github.com/astral-sh/ruff/pull/13731))
 
@@ -978,7 +1155,7 @@ The following deprecated CLI commands have been removed:
 ### Preview features
 
 - \[`flake8-bugbear`\] Implement `return-in-generator` (`B901`) ([#11644](https://github.com/astral-sh/ruff/pull/11644))
-- \[`flake8-pyi`\] Implement `PYI063` ([#11699](https://github.com/astral-sh/ruff/pull/11699))
+- \[`flake8-pyi`\] Implement `pep484-style-positional-only-parameter` (`PYI063`) ([#11699](https://github.com/astral-sh/ruff/pull/11699))
 - \[`pygrep_hooks`\] Check blanket ignores via file-level pragmas (`PGH004`) ([#11540](https://github.com/astral-sh/ruff/pull/11540))
 
 ### Rule changes
@@ -1132,7 +1309,7 @@ To read more about this exciting milestone, check out our [blog post](https://as
 ### Preview features
 
 - \[`pycodestyle`\] Ignore end-of-line comments when determining blank line rules ([#11342](https://github.com/astral-sh/ruff/pull/11342))
-- \[`pylint`\] Detect `pathlib.Path.open` calls in `unspecified-encoding` (`PLW1514`)  ([#11288](https://github.com/astral-sh/ruff/pull/11288))
+- \[`pylint`\] Detect `pathlib.Path.open` calls in `unspecified-encoding` (`PLW1514`) ([#11288](https://github.com/astral-sh/ruff/pull/11288))
 - \[`flake8-pyi`\] Implement `PYI059` (`generic-not-last-base-class`) ([#11233](https://github.com/astral-sh/ruff/pull/11233))
 - \[`flake8-pyi`\] Implement `PYI062` (`duplicate-literal-member`) ([#11269](https://github.com/astral-sh/ruff/pull/11269))
 
@@ -1507,7 +1684,7 @@ To setup `ruff server` with your editor, refer to the [README.md](https://github
 - \[`pycodestyle`\] Do not ignore lines before the first logical line in blank lines rules. ([#10382](https://github.com/astral-sh/ruff/pull/10382))
 - \[`pycodestyle`\] Do not trigger `E225` and `E275` when the next token is a ')' ([#10315](https://github.com/astral-sh/ruff/pull/10315))
 - \[`pylint`\] Avoid false-positive slot non-assignment for `__dict__` (`PLE0237`) ([#10348](https://github.com/astral-sh/ruff/pull/10348))
-- Gate f-string struct size test for Rustc \< 1.76 ([#10371](https://github.com/astral-sh/ruff/pull/10371))
+- Gate f-string struct size test for Rustc < 1.76 ([#10371](https://github.com/astral-sh/ruff/pull/10371))
 
 ### Documentation
 

CONTRIBUTING.md

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

Cargo.toml

@@ -65,7 +65,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.3.0" }
+dir-test = { version = "0.4.0" }
 dunce = { version = "1.0.5" }
 drop_bomb = { version = "0.1.5" }
 env_logger = { version = "0.11.0" }
@@ -111,7 +111,7 @@ pathdiff = { version = "0.2.1" }
 pep440_rs = { version = "0.7.1" }
 pretty_assertions = "1.3.0"
 proc-macro2 = { version = "1.0.79" }
-pyproject-toml = { version = "0.9.0" }
+pyproject-toml = { version = "0.13.4" }
 quick-junit = { version = "0.5.0" }
 quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }
@@ -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.1.11" }
+unicode-width = { version = "0.2.0" }
 unicode_names2 = { version = "1.2.2" }
 unicode-normalization = { version = "0.1.23" }
 ureq = { version = "2.9.6" }
@@ -248,10 +248,10 @@ debug = 1
 [profile.dist]
 inherits = "release"
 
-# Config for 'cargo dist'
+# Config for 'dist'
 [workspace.metadata.dist]
-# The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax)
-cargo-dist-version = "0.22.1"
+# The preferred dist version to use in CI (Cargo.toml SemVer syntax)
+cargo-dist-version = "0.25.2-prerelease.3"
 # CI backends to support
 ci = "github"
 # The installers to generate for each app
@@ -282,13 +282,13 @@ targets = [
 ]
 # Whether to auto-include files like READMEs, LICENSEs, and CHANGELOGs (default true)
 auto-includes = false
-# Whether cargo-dist should create a GitHub Release or use an existing draft
+# Whether dist should create a Github Release or use an existing draft
 create-release = true
 # Which actions to run on pull requests
 pr-run-mode = "skip"
 # Whether CI should trigger releases with dispatches instead of tag pushes
 dispatch-releases = true
-# Which phase cargo-dist should use to create the GitHub release
+# Which phase dist should use to create the GitHub release
 github-release = "announce"
 # Whether CI should include auto-generated code to build local artifacts
 build-local-artifacts = false
@@ -297,14 +297,10 @@ local-artifacts-jobs = ["./build-binaries", "./build-docker"]
 # Publish jobs to run in CI
 publish-jobs = ["./publish-pypi", "./publish-wasm"]
 # Post-announce jobs to run in CI
-post-announce-jobs = [
-    "./notify-dependents",
-    "./publish-docs",
-    "./publish-playground",
-]
+post-announce-jobs = ["./notify-dependents", "./publish-docs", "./publish-playground"]
 # Custom permissions for GitHub Jobs
 github-custom-job-permissions = { "build-docker" = { packages = "write", contents = "read" }, "publish-wasm" = { contents = "read", id-token = "write", packages = "write" } }
 # Whether to install an updater program
 install-updater = false
 # Path that installers should place binaries in
-install-path = "CARGO_HOME"
+install-path = ["$XDG_BIN_HOME/", "$XDG_DATA_HOME/../bin", "~/.local/bin"]

README.md

@@ -119,6 +119,10 @@ For more, see the [documentation](https://docs.astral.sh/ruff/).
 Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 
 ```shell
+# With uv.
+uv add --dev ruff     # to add ruff to your project
+uv tool install ruff  # to install ruff globally
+
 # With pip.
 pip install ruff
 
@@ -136,8 +140,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.7.4/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.7.4/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.8.2/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.8.2/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 +174,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.7.4
+  rev: v0.8.2
   hooks:
     # Run the linter.
     - id: ruff
@@ -238,8 +242,8 @@ exclude = [
 line-length = 88
 indent-width = 4
 
-# Assume Python 3.8
-target-version = "py38"
+# Assume Python 3.9
+target-version = "py39"
 
 [lint]
 # Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.

clippy.toml

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

crates/red_knot/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/tests/file_watching.rs

@@ -1,26 +1,23 @@
 #![allow(clippy::disallowed_names)]
 
 use std::io::Write;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use anyhow::{anyhow, Context};
-
 use red_knot_python_semantic::{resolve_module, ModuleName, Program, PythonVersion, SitePackages};
 use red_knot_workspace::db::{Db, RootDatabase};
-use red_knot_workspace::watch;
-use red_knot_workspace::watch::{directory_watcher, WorkspaceWatcher};
+use red_knot_workspace::watch::{directory_watcher, ChangeEvent, WorkspaceWatcher};
 use red_knot_workspace::workspace::settings::{Configuration, SearchPathConfiguration};
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::files::{system_path_to_file, File, FileError};
 use ruff_db::source::source_text;
 use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
-use ruff_db::testing::setup_logging;
 use ruff_db::Upcast;
 
 struct TestCase {
     db: RootDatabase,
     watcher: Option<WorkspaceWatcher>,
-    changes_receiver: crossbeam::channel::Receiver<Vec<watch::ChangeEvent>>,
+    changes_receiver: crossbeam::channel::Receiver<Vec<ChangeEvent>>,
     /// The temporary directory that contains the test files.
     /// We need to hold on to it in the test case or the temp files get deleted.
     _temp_dir: tempfile::TempDir,
@@ -41,44 +38,87 @@ impl TestCase {
         &self.db
     }
 
-    fn stop_watch(&mut self) -> Vec<watch::ChangeEvent> {
-        self.try_stop_watch(Duration::from_secs(10))
-            .expect("Expected watch changes but observed none")
+    #[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 try_stop_watch(&mut self, timeout: Duration) -> Option<Vec<watch::ChangeEvent>> {
+    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);
+
         let watcher = self
             .watcher
             .take()
             .expect("Cannot call `stop_watch` more than once");
 
-        let mut all_events = self
-            .changes_receiver
-            .recv_timeout(timeout)
-            .unwrap_or_default();
-        watcher.flush();
-        watcher.stop();
+        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);
+            }
+        }
+
+        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);
         }
 
-        if all_events.is_empty() {
-            return None;
-        }
-
-        Some(all_events)
+        Ok(all_events)
     }
 
-    fn take_watch_changes(&self) -> Vec<watch::ChangeEvent> {
+    fn take_watch_changes(&self) -> Vec<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<watch::ChangeEvent>> {
-        let Some(watcher) = &self.watcher else {
-            return None;
-        };
+    fn try_take_watch_changes(&self, timeout: Duration) -> Option<Vec<ChangeEvent>> {
+        let watcher = self.watcher.as_ref()?;
 
         let mut all_events = self
             .changes_receiver
@@ -100,7 +140,7 @@ impl TestCase {
         Some(all_events)
     }
 
-    fn apply_changes(&mut self, changes: Vec<watch::ChangeEvent>) {
+    fn apply_changes(&mut self, changes: Vec<ChangeEvent>) {
         self.db.apply_changes(changes, Some(&self.configuration));
     }
 
@@ -136,6 +176,23 @@ 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<()>;
 }
@@ -311,7 +368,7 @@ fn new_file() -> anyhow::Result<()> {
 
     std::fs::write(foo_path.as_std_path(), "print('Hello')")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -334,7 +391,7 @@ fn new_ignored_file() -> anyhow::Result<()> {
 
     std::fs::write(foo_path.as_std_path(), "print('Hello')")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -356,7 +413,7 @@ fn changed_file() -> anyhow::Result<()> {
 
     update_file(&foo_path, "print('Version 2')")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     assert!(!changes.is_empty());
 
@@ -381,7 +438,7 @@ fn deleted_file() -> anyhow::Result<()> {
 
     std::fs::remove_file(foo_path.as_std_path())?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -413,7 +470,7 @@ fn move_file_to_trash() -> anyhow::Result<()> {
         trash_path.join("foo.py").as_std_path(),
     )?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -445,7 +502,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();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -473,7 +530,7 @@ fn rename_file() -> anyhow::Result<()> {
 
     std::fs::rename(foo_path.as_std_path(), bar_path.as_std_path())?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("bar.py"));
 
     case.apply_changes(changes);
 
@@ -517,7 +574,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();
+    let changes = case.stop_watch(event_for_file("sub"));
 
     case.apply_changes(changes);
 
@@ -576,7 +633,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();
+    let changes = case.stop_watch(event_for_file("sub"));
 
     case.apply_changes(changes);
 
@@ -638,7 +695,8 @@ 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")?;
 
-    let changes = case.stop_watch();
+    // 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"));
 
     case.apply_changes(changes);
 
@@ -711,7 +769,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();
+    let changes = case.stop_watch(event_for_file("sub"));
 
     case.apply_changes(changes);
 
@@ -748,7 +806,7 @@ fn search_path() -> anyhow::Result<()> {
 
     std::fs::write(site_packages.join("a.py").as_std_path(), "class A: ...")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("a.py"));
 
     case.apply_changes(changes);
 
@@ -779,7 +837,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();
+    let changes = case.stop_watch(event_for_file("a.py"));
 
     case.apply_changes(changes);
 
@@ -808,9 +866,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(Duration::from_millis(100));
+    let changes = case.try_stop_watch(|_: &ChangeEvent| true, Duration::from_millis(100));
 
-    assert_eq!(changes, None);
+    assert_eq!(changes, Err(vec![]));
 
     Ok(())
 }
@@ -848,7 +906,7 @@ fn changed_versions_file() -> anyhow::Result<()> {
         "os: 3.0-",
     )?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("VERSIONS"));
 
     case.apply_changes(changes);
 
@@ -901,7 +959,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();
+    let changes = case.stop_watch(event_for_file("foo.py"));
 
     case.apply_changes(changes);
 
@@ -972,7 +1030,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();
+    let changes = case.stop_watch(ChangeEvent::is_changed);
 
     case.apply_changes(changes);
 
@@ -1011,7 +1069,7 @@ mod unix {
         )
         .with_context(|| "Failed to set file permissions.")?;
 
-        let changes = case.stop_watch();
+        let changes = case.stop_watch(event_for_file("foo.py"));
 
         case.apply_changes(changes);
 
@@ -1109,7 +1167,7 @@ mod unix {
         update_file(baz_workspace, "def baz(): print('Version 3')")
             .context("Failed to update bar/baz.py")?;
 
-        let changes = case.stop_watch();
+        let changes = case.stop_watch(event_for_file("baz.py"));
 
         case.apply_changes(changes);
 
@@ -1180,7 +1238,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();
+        let changes = case.stop_watch(event_for_file("baz.py"));
 
         case.apply_changes(changes);
 
@@ -1288,7 +1346,7 @@ mod unix {
         update_file(&baz_original, "def baz(): print('Version 2')")
             .context("Failed to update bar/baz.py")?;
 
-        let changes = case.stop_watch();
+        let changes = case.stop_watch(event_for_file("baz.py"));
 
         case.apply_changes(changes);
 
@@ -1342,7 +1400,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();
+    let changes = case.stop_watch(ChangeEvent::is_deleted);
 
     case.apply_changes(changes);
 
@@ -1354,7 +1412,6 @@ fn nested_packages_delete_root() -> anyhow::Result<()> {
 
 #[test]
 fn added_package() -> anyhow::Result<()> {
-    let _ = setup_logging();
     let mut case = setup([
         (
             "pyproject.toml",
@@ -1396,7 +1453,7 @@ fn added_package() -> anyhow::Result<()> {
     )
     .context("failed to write pyproject.toml for package b")?;
 
-    let changes = case.stop_watch();
+    let changes = case.stop_watch(event_for_file("pyproject.toml"));
 
     case.apply_changes(changes);
 
@@ -1439,7 +1496,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();
+    let changes = case.stop_watch(ChangeEvent::is_deleted);
 
     case.apply_changes(changes);
 

crates/red_knot_python_semantic/Cargo.toml

@@ -13,6 +13,7 @@ license = { workspace = true }
 [dependencies]
 ruff_db = { workspace = true }
 ruff_index = { workspace = true }
+ruff_macros = { workspace = true }
 ruff_python_ast = { workspace = true }
 ruff_python_parser = { workspace = true }
 ruff_python_stdlib = { workspace = true }
@@ -49,6 +50,8 @@ 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/any.md

@@ -0,0 +1,75 @@
+# Any
+
+## Annotation
+
+`typing.Any` is a way to name the Any type.
+
+```py
+from typing import Any
+
+x: Any = 1
+x = "foo"
+
+def f():
+    reveal_type(x)  # revealed: Any
+```
+
+## Aliased to a different name
+
+If you alias `typing.Any` to another name, we still recognize that as a spelling of the Any type.
+
+```py
+from typing import Any as RenamedAny
+
+x: RenamedAny = 1
+x = "foo"
+
+def f():
+    reveal_type(x)  # revealed: Any
+```
+
+## Shadowed class
+
+If you define your own class named `Any`, using that in a type expression refers to your class, and
+isn't a spelling of the Any type.
+
+```py
+class Any:
+    pass
+
+x: Any
+
+def f():
+    reveal_type(x)  # revealed: Any
+
+# This verifies that we're not accidentally seeing typing.Any, since str is assignable
+# to that but not to our locally defined class.
+y: Any = "not an Any"  # error: [invalid-assignment]
+```
+
+## Subclass
+
+The spec allows you to define subclasses of `Any`.
+
+TODO: Handle assignments correctly. `Subclass` has an unknown superclass, which might be `int`. The
+assignment to `x` should not be allowed, even when the unknown superclass is `int`. The assignment
+to `y` should be allowed, since `Subclass` might have `int` as a superclass, and is therefore
+assignable to `int`.
+
+```py
+from typing import Any
+
+class Subclass(Any):
+    pass
+
+reveal_type(Subclass.__mro__)  # revealed: tuple[Literal[Subclass], Any, Literal[object]]
+
+x: Subclass = 1  # error: [invalid-assignment]
+# TODO: no diagnostic
+y: int = Subclass()  # error: [invalid-assignment]
+
+def f() -> Subclass:
+    pass
+
+reveal_type(f())  # revealed: Subclass
+```

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

@@ -0,0 +1,152 @@
+# `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_extensions import LiteralString
+
+x: LiteralString
+
+def f():
+    reveal_type(x)  # revealed: LiteralString
+```
+
+### Within `Literal`
+
+`LiteralString` cannot be used within `Literal`:
+
+```py
+from typing_extensions 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_extensions 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_extensions import LiteralString
+
+class C(LiteralString): ...  # error: [invalid-base]
+```
+
+## Inference
+
+### Common operations
+
+```py
+from typing_extensions import LiteralString
+
+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
+from typing_extensions import Literal, LiteralString
+
+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
+from typing_extensions import LiteralString
+
+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"]
+```
+
+## `typing.LiteralString`
+
+`typing.LiteralString` is only available in Python 3.11 and later:
+
+```toml
+[environment]
+target-version = "3.11"
+```
+
+```py
+from typing import LiteralString
+
+x: LiteralString = "foo"
+
+def f():
+    reveal_type(x)  # revealed: LiteralString
+```
+
+[1]: https://typing.readthedocs.io/en/latest/spec/literal.html#literalstring

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

@@ -0,0 +1,64 @@
+# 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_extensions import NoReturn, Never, Any
+
+# error: [invalid-type-parameter] "Type `typing.Never` expected no type parameter"
+x: Never[int]
+a1: NoReturn
+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.Never`
+
+`typing.Never` is only available in Python 3.11 and later:
+
+```toml
+[environment]
+target-version = "3.11"
+```
+
+```py
+from typing import Never
+
+x: Never
+
+def f():
+    reveal_type(x)  # revealed: Never
+```

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

@@ -8,11 +8,11 @@ from typing_extensions import TypeVarTuple
 Ts = TypeVarTuple("Ts")
 
 def append_int(*args: *Ts) -> tuple[*Ts, int]:
-    # TODO: should show some representation of the variadic generic type
-    reveal_type(args)  # revealed: @Todo
+    # TODO: tuple[*Ts]
+    reveal_type(args)  # revealed: tuple
 
     return (*args, 1)
 
 # TODO should be tuple[Literal[True], Literal["a"], int]
-reveal_type(append_int(True, "a"))  # revealed: @Todo
+reveal_type(append_int(True, "a"))  # revealed: @Todo(full tuple[...] support)
 ```

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

@@ -95,37 +95,37 @@ reveal_type(f2())  # revealed: Literal["Foo", "Bar"]
 ## Various string kinds
 
 ```py
-# error: [annotation-raw-string] "Type expressions cannot use raw string literal"
+# error: [raw-string-type-annotation] "Type expressions cannot use raw string literal"
 def f1() -> r"int":
     return 1
 
-# error: [annotation-f-string] "Type expressions cannot use f-strings"
+# error: [fstring-type-annotation] "Type expressions cannot use f-strings"
 def f2() -> f"int":
     return 1
 
-# error: [annotation-byte-string] "Type expressions cannot use bytes literal"
+# error: [byte-string-type-annotation] "Type expressions cannot use bytes literal"
 def f3() -> b"int":
     return 1
 
 def f4() -> "int":
     return 1
 
-# error: [annotation-implicit-concat] "Type expressions cannot span multiple string literals"
+# error: [implicit-concatenated-string-type-annotation] "Type expressions cannot span multiple string literals"
 def f5() -> "in" "t":
     return 1
 
-# error: [annotation-escape-character] "Type expressions cannot contain escape characters"
+# error: [escape-character-in-forward-annotation] "Type expressions cannot contain escape characters"
 def f6() -> "\N{LATIN SMALL LETTER I}nt":
     return 1
 
-# error: [annotation-escape-character] "Type expressions cannot contain escape characters"
+# error: [escape-character-in-forward-annotation] "Type expressions cannot contain escape characters"
 def f7() -> "\x69nt":
     return 1
 
 def f8() -> """int""":
     return 1
 
-# error: [annotation-byte-string] "Type expressions cannot use bytes literal"
+# error: [byte-string-type-annotation] "Type expressions cannot use bytes literal"
 def f9() -> "b'int'":
     return 1
 
@@ -189,3 +189,31 @@ reveal_type(d)  # revealed: Foo
 ## Parameter
 
 TODO: Add tests once parameter inference is supported
+
+## Invalid expressions
+
+The expressions in these string annotations aren't valid expressions in this context but we
+shouldn't panic.
+
+```py
+a: "1 or 2"
+b: "(x := 1)"
+c: "1 + 2"
+d: "lambda x: x"
+e: "x if True else y"
+f: "{'a': 1, 'b': 2}"
+g: "{1, 2}"
+h: "[i for i in range(5)]"
+i: "{i for i in range(5)}"
+j: "{i: i for i in range(5)}"
+k: "(i for i in range(5))"
+l: "await 1"
+# error: [invalid-syntax-in-forward-annotation]
+m: "yield 1"
+# error: [invalid-syntax-in-forward-annotation]
+n: "yield from 1"
+o: "1 < 2"
+p: "call()"
+r: "[1, 2]"
+s: "(1, 2)"
+```

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

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

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

@@ -50,13 +50,13 @@ reveal_type(b)  # revealed: tuple[int]
 reveal_type(c)  # revealed: tuple[str, int]
 reveal_type(d)  # revealed: tuple[tuple[str, str], tuple[int, int]]
 
-# TODO: homogenous tuples, PEP-646 tuples
-reveal_type(e)  # revealed: @Todo
-reveal_type(f)  # revealed: @Todo
-reveal_type(g)  # revealed: @Todo
+# TODO: homogeneous 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)
 
 # TODO: support more kinds of type expressions in annotations
-reveal_type(h)  # revealed: @Todo
+reveal_type(h)  # revealed: @Todo(full tuple[...] support)
 
 reveal_type(i)  # revealed: tuple[str | int, str | int]
 reveal_type(j)  # revealed: tuple[str | int]

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

@@ -18,43 +18,3 @@ Note: in this particular example, one could argue that the most likely error wou
 of the `x`/`foo` definitions, and so it could be desirable to infer `Literal[1]` for the type of
 `x`. On the other hand, there might be a variable `fob` a little higher up in this file, and the
 actual error might have been just a typo. Inferring `Unknown` thus seems like the safest option.
-
-## Unbound class variable
-
-Name lookups within a class scope fall back to globals, but lookups of class attributes don't.
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-x = 1
-
-class C:
-    y = x
-    if flag:
-        x = 2
-
-# error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C]` is possibly unbound"
-reveal_type(C.x)  # revealed: Literal[2]
-reveal_type(C.y)  # revealed: Literal[1]
-```
-
-## Possibly unbound in class and global scope
-
-```py
-def bool_instance() -> bool:
-    return True
-
-if bool_instance():
-    x = "abc"
-
-class C:
-    if bool_instance():
-        x = 1
-
-    # error: [possibly-unresolved-reference]
-    y = x
-
-reveal_type(C.y)  # revealed: Literal[1] | Literal["abc"]
-```

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

@@ -317,7 +317,7 @@ reveal_type(1 + A())  # revealed: int
 reveal_type(A() + "foo")  # revealed: A
 # TODO should be `A` since `str.__add__` doesn't support `A` instances
 # TODO overloads
-reveal_type("foo" + A())  # revealed: @Todo
+reveal_type("foo" + A())  # revealed: @Todo(return type)
 
 reveal_type(A() + b"foo")  # revealed: A
 # TODO should be `A` since `bytes.__add__` doesn't support `A` instances
@@ -325,7 +325,7 @@ reveal_type(b"foo" + A())  # revealed: bytes
 
 reveal_type(A() + ())  # revealed: A
 # TODO this should be `A`, since `tuple.__add__` doesn't support `A` instances
-reveal_type(() + A())  # revealed: @Todo
+reveal_type(() + A())  # revealed: @Todo(return type)
 
 literal_string_instance = "foo" * 1_000_000_000
 # the test is not testing what it's meant to be testing if this isn't a `LiteralString`:
@@ -334,7 +334,7 @@ reveal_type(literal_string_instance)  # revealed: LiteralString
 reveal_type(A() + literal_string_instance)  # revealed: A
 # TODO should be `A` since `str.__add__` doesn't support `A` instances
 # TODO overloads
-reveal_type(literal_string_instance + A())  # revealed: @Todo
+reveal_type(literal_string_instance + A())  # revealed: @Todo(return type)
 ```
 
 ## Operations involving instances of classes inheriting from `Any`

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

@@ -16,7 +16,7 @@ async def get_int_async() -> int:
     return 42
 
 # TODO: we don't yet support `types.CoroutineType`, should be generic `Coroutine[Any, Any, int]`
-reveal_type(get_int_async())  # revealed: @Todo
+reveal_type(get_int_async())  # revealed: @Todo(generic types.CoroutineType)
 ```
 
 ## Generic
@@ -44,7 +44,7 @@ def bar() -> str:
     return "bar"
 
 # TODO: should reveal `int`, as the decorator replaces `bar` with `foo`
-reveal_type(bar())  # revealed: @Todo
+reveal_type(bar())  # revealed: @Todo(return type)
 ```
 
 ## Invalid callable

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

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

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

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

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

@@ -50,11 +50,11 @@ def foo(
         help()
     except x as e:
         # TODO: should be `AttributeError`
-        reveal_type(e)  # revealed: @Todo
+        reveal_type(e)  # revealed: @Todo(exception type)
     except y as f:
         # TODO: should be `OSError | RuntimeError`
-        reveal_type(f)  # revealed: @Todo
+        reveal_type(f)  # revealed: @Todo(exception type)
     except z as g:
         # TODO: should be `BaseException`
-        reveal_type(g)  # revealed: @Todo
+        reveal_type(g)  # revealed: @Todo(exception type)
 ```

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

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

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

@@ -0,0 +1,219 @@
+# Length (`len()`)
+
+## Literal and constructed iterables
+
+### Strings and bytes literals
+
+```py
+reveal_type(len("no\rmal"))  # revealed: Literal[6]
+reveal_type(len(r"aw stri\ng"))  # revealed: Literal[10]
+reveal_type(len(r"conca\t" "ena\tion"))  # revealed: Literal[14]
+reveal_type(len(b"ytes lite" rb"al"))  # revealed: Literal[11]
+reveal_type(len("𝒰𝕹🄸©🕲𝕕ℇ"))  # revealed: Literal[7]
+
+reveal_type(  # revealed: Literal[7]
+    len(
+        """foo
+bar"""
+    )
+)
+reveal_type(  # revealed: Literal[9]
+    len(
+        r"""foo\r
+bar"""
+    )
+)
+reveal_type(  # revealed: Literal[7]
+    len(
+        b"""foo
+bar"""
+    )
+)
+reveal_type(  # revealed: Literal[9]
+    len(
+        rb"""foo\r
+bar"""
+    )
+)
+```
+
+### Tuples
+
+```py
+reveal_type(len(()))  # revealed: Literal[0]
+reveal_type(len((1,)))  # revealed: Literal[1]
+reveal_type(len((1, 2)))  # revealed: Literal[2]
+
+# TODO: Handle constructor calls
+reveal_type(len(tuple()))  # revealed: int
+
+# TODO: Handle star unpacks; Should be: Literal[0]
+reveal_type(len((*[],)))  # revealed: Literal[1]
+
+# TODO: Handle star unpacks; Should be: Literal[1]
+reveal_type(  # revealed: Literal[2]
+    len(
+        (
+            *[],
+            1,
+        )
+    )
+)
+
+# TODO: Handle star unpacks; Should be: Literal[2]
+reveal_type(len((*[], 1, 2)))  # revealed: Literal[3]
+
+# TODO: Handle star unpacks; Should be: Literal[0]
+reveal_type(len((*[], *{})))  # revealed: Literal[2]
+```
+
+### Lists, sets and dictionaries
+
+```py
+reveal_type(len([]))  # revealed: int
+reveal_type(len([1]))  # revealed: int
+reveal_type(len([1, 2]))  # revealed: int
+reveal_type(len([*{}, *dict()]))  # revealed: int
+
+reveal_type(len({}))  # revealed: int
+reveal_type(len({**{}}))  # revealed: int
+reveal_type(len({**{}, **{}}))  # revealed: int
+
+reveal_type(len({1}))  # revealed: int
+reveal_type(len({1, 2}))  # revealed: int
+reveal_type(len({*[], 2}))  # revealed: int
+
+reveal_type(len(list()))  # revealed: int
+reveal_type(len(set()))  # revealed: int
+reveal_type(len(dict()))  # revealed: int
+reveal_type(len(frozenset()))  # revealed: int
+```
+
+## `__len__`
+
+The returned value of `__len__` is implicitly and recursively converted to `int`.
+
+### Literal integers
+
+```py
+from typing import Literal
+
+class Zero:
+    def __len__(self) -> Literal[0]: ...
+
+class ZeroOrOne:
+    def __len__(self) -> Literal[0, 1]: ...
+
+class ZeroOrTrue:
+    def __len__(self) -> Literal[0, True]: ...
+
+class OneOrFalse:
+    def __len__(self) -> Literal[1] | Literal[False]: ...
+
+class OneOrFoo:
+    def __len__(self) -> Literal[1, "foo"]: ...
+
+class ZeroOrStr:
+    def __len__(self) -> Literal[0] | str: ...
+
+reveal_type(len(Zero()))  # revealed: Literal[0]
+reveal_type(len(ZeroOrOne()))  # revealed: Literal[0, 1]
+reveal_type(len(ZeroOrTrue()))  # revealed: Literal[0, 1]
+reveal_type(len(OneOrFalse()))  # revealed: Literal[0, 1]
+
+# TODO: Emit a diagnostic
+reveal_type(len(OneOrFoo()))  # revealed: int
+
+# TODO: Emit a diagnostic
+reveal_type(len(ZeroOrStr()))  # revealed: int
+```
+
+### Literal booleans
+
+```py
+from typing import Literal
+
+class LiteralTrue:
+    def __len__(self) -> Literal[True]: ...
+
+class LiteralFalse:
+    def __len__(self) -> Literal[False]: ...
+
+reveal_type(len(LiteralTrue()))  # revealed: Literal[1]
+reveal_type(len(LiteralFalse()))  # revealed: Literal[0]
+```
+
+### Enums
+
+```py
+from enum import Enum, auto
+from typing import Literal
+
+class SomeEnum(Enum):
+    AUTO = auto()
+    INT = 2
+    STR = "4"
+    TUPLE = (8, "16")
+    INT_2 = 3_2
+
+class Auto:
+    def __len__(self) -> Literal[SomeEnum.AUTO]: ...
+
+class Int:
+    def __len__(self) -> Literal[SomeEnum.INT]: ...
+
+class Str:
+    def __len__(self) -> Literal[SomeEnum.STR]: ...
+
+class Tuple:
+    def __len__(self) -> Literal[SomeEnum.TUPLE]: ...
+
+class IntUnion:
+    def __len__(self) -> Literal[SomeEnum.INT, SomeEnum.INT_2]: ...
+
+reveal_type(len(Auto()))  # revealed: int
+reveal_type(len(Int()))  # revealed: Literal[2]
+reveal_type(len(Str()))  # revealed: int
+reveal_type(len(Tuple()))  # revealed: int
+reveal_type(len(IntUnion()))  # revealed: Literal[2, 32]
+```
+
+### Negative integers
+
+```py
+from typing import Literal
+
+class Negative:
+    def __len__(self) -> Literal[-1]: ...
+
+# TODO: Emit a diagnostic
+reveal_type(len(Negative()))  # revealed: int
+```
+
+### Wrong signature
+
+```py
+from typing import Literal
+
+class SecondOptionalArgument:
+    def __len__(self, v: int = 0) -> Literal[0]: ...
+
+class SecondRequiredArgument:
+    def __len__(self, v: int) -> Literal[1]: ...
+
+# TODO: Emit a diagnostic
+reveal_type(len(SecondOptionalArgument()))  # revealed: Literal[0]
+
+# TODO: Emit a diagnostic
+reveal_type(len(SecondRequiredArgument()))  # revealed: Literal[1]
+```
+
+### No `__len__`
+
+```py
+class NoDunderLen:
+    pass
+
+# TODO: Emit a diagnostic
+reveal_type(len(NoDunderLen()))  # revealed: int
+```

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

@@ -0,0 +1,75 @@
+# Function parameter types
+
+Within a function scope, the declared type of each parameter is its annotated type (or Unknown if
+not annotated). The initial inferred type is the union of the declared type with the type of the
+default value expression (if any). If both are fully static types, this union should simplify to the
+annotated type (since the default value type must be assignable to the annotated type, and for fully
+static types this means subtype-of, which simplifies in unions). But if the annotated type is
+Unknown or another non-fully-static type, the default value type may still be relevant as lower
+bound.
+
+The variadic parameter is a variadic tuple of its annotated type; the variadic-keywords parameter is
+a dictionary from strings to its annotated type.
+
+## Parameter kinds
+
+```py
+from typing import Literal
+
+def f(a, b: int, c=1, d: int = 2, /, e=3, f: Literal[4] = 4, *args: object, g=5, h: Literal[6] = 6, **kwargs: str):
+    reveal_type(a)  # revealed: Unknown
+    reveal_type(b)  # revealed: int
+    reveal_type(c)  # revealed: Unknown | Literal[1]
+    reveal_type(d)  # revealed: int
+    reveal_type(e)  # revealed: Unknown | Literal[3]
+    reveal_type(f)  # revealed: Literal[4]
+    reveal_type(g)  # revealed: Unknown | Literal[5]
+    reveal_type(h)  # revealed: Literal[6]
+
+    # TODO: should be `tuple[object, ...]` (needs generics)
+    reveal_type(args)  # revealed: tuple
+
+    # TODO: should be `dict[str, str]` (needs generics)
+    reveal_type(kwargs)  # revealed: dict
+```
+
+## Unannotated variadic parameters
+
+...are inferred as tuple of Unknown or dict from string to Unknown.
+
+```py
+def g(*args, **kwargs):
+    # TODO: should be `tuple[Unknown, ...]` (needs generics)
+    reveal_type(args)  # revealed: tuple
+
+    # TODO: should be `dict[str, Unknown]` (needs generics)
+    reveal_type(kwargs)  # revealed: dict
+```
+
+## Annotation is present but not a fully static type
+
+The default value type should be a lower bound on the inferred type.
+
+```py
+from typing import Any
+
+def f(x: Any = 1):
+    reveal_type(x)  # revealed: Any | Literal[1]
+```
+
+## Default value type must be assignable to annotated type
+
+The default value type must be assignable to the annotated type. If not, we emit a diagnostic, and
+fall back to inferring the annotated type, ignoring the default value type.
+
+```py
+# error: [invalid-parameter-default]
+def f(x: int = "foo"):
+    reveal_type(x)  # revealed: int
+
+# The check is assignable-to, not subtype-of, so this is fine:
+from typing import Any
+
+def g(x: Any = "foo"):
+    reveal_type(x)  # revealed: Any | Literal["foo"]
+```

crates/red_knot_python_semantic/resources/mdtest/generics.md

@@ -18,7 +18,7 @@ box: MyBox[int] = MyBox(5)
 wrong_innards: MyBox[int] = MyBox("five")
 
 # TODO reveal int
-reveal_type(box.data)  # revealed: @Todo
+reveal_type(box.data)  # revealed: @Todo(instance attributes)
 
 reveal_type(MyBox.box_model_number)  # revealed: Literal[695]
 ```
@@ -39,7 +39,7 @@ class MySecureBox[T](MyBox[T]): ...
 secure_box: MySecureBox[int] = MySecureBox(5)
 reveal_type(secure_box)  # revealed: MySecureBox
 # TODO reveal int
-reveal_type(secure_box.data)  # revealed: @Todo
+reveal_type(secure_box.data)  # revealed: @Todo(instance attributes)
 ```
 
 ## Cyclical class definition
@@ -60,52 +60,20 @@ reveal_type(S)  # revealed: Literal[S]
 
 ## Type params
 
-A PEP695 type variable defines a value of type `typing.TypeVar` with attributes `__name__`,
-`__bounds__`, `__constraints__`, and `__default__` (the latter three all lazily evaluated):
+A PEP695 type variable defines a value of type `typing.TypeVar`.
 
 ```py
-def f[T, U: A, V: (A, B), W = A, X: A = A1]():
+def f[T]():
     reveal_type(T)  # revealed: T
     reveal_type(T.__name__)  # revealed: Literal["T"]
-    reveal_type(T.__bound__)  # revealed: None
-    reveal_type(T.__constraints__)  # revealed: tuple[()]
-    reveal_type(T.__default__)  # revealed: NoDefault
-
-    reveal_type(U)  # revealed: U
-    reveal_type(U.__name__)  # revealed: Literal["U"]
-    reveal_type(U.__bound__)  # revealed: type[A]
-    reveal_type(U.__constraints__)  # revealed: tuple[()]
-    reveal_type(U.__default__)  # revealed: NoDefault
-
-    reveal_type(V)  # revealed: V
-    reveal_type(V.__name__)  # revealed: Literal["V"]
-    reveal_type(V.__bound__)  # revealed: None
-    reveal_type(V.__constraints__)  # revealed: tuple[type[A], type[B]]
-    reveal_type(V.__default__)  # revealed: NoDefault
-
-    reveal_type(W)  # revealed: W
-    reveal_type(W.__name__)  # revealed: Literal["W"]
-    reveal_type(W.__bound__)  # revealed: None
-    reveal_type(W.__constraints__)  # revealed: tuple[()]
-    reveal_type(W.__default__)  # revealed: type[A]
-
-    reveal_type(X)  # revealed: X
-    reveal_type(X.__name__)  # revealed: Literal["X"]
-    reveal_type(X.__bound__)  # revealed: type[A]
-    reveal_type(X.__constraints__)  # revealed: tuple[()]
-    reveal_type(X.__default__)  # revealed: type[A1]
-
-class A: ...
-class B: ...
-class A1(A): ...
 ```
 
 ## Minimum two constraints
 
-A typevar with less than two constraints emits a diagnostic and is treated as unconstrained:
+A typevar with less than two constraints emits a diagnostic:
 
 ```py
-# error: [invalid-typevar-constraints] "TypeVar must have at least two constrained types"
+# error: [invalid-type-variable-constraints] "TypeVar must have at least two constrained types"
 def f[T: (int,)]():
-    reveal_type(T.__constraints__)  # revealed: tuple[()]
+    pass
 ```

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

@@ -55,3 +55,24 @@ from b import x
 
 x = "foo"  # error: [invalid-assignment] "Object of type `Literal["foo"]"
 ```
+
+## Import cycle
+
+```py path=a.py
+class A: ...
+
+reveal_type(A.__mro__)  # revealed: tuple[Literal[A], Literal[object]]
+import b
+
+class C(b.B): ...
+
+reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[B], Literal[A], Literal[object]]
+```
+
+```py path=b.py
+from a import A
+
+class B(A): ...
+
+reveal_type(B.__mro__)  # revealed: tuple[Literal[B], Literal[A], Literal[object]]
+```

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

@@ -0,0 +1,9 @@
+# Invalid syntax
+
+## Missing module name
+
+```py
+from import bar  # error: [invalid-syntax]
+
+reveal_type(bar)  # revealed: Unknown
+```

crates/red_knot_python_semantic/resources/mdtest/invalid_syntax.md

@@ -0,0 +1,93 @@
+# Syntax errors
+
+Test cases to ensure that red knot does not panic if there are syntax errors in the source code.
+
+The parser cannot recover from certain syntax errors completely which is why the number of syntax
+errors could be more than expected in the following examples. For instance, if there's a keyword
+(like `for`) in the middle of another statement (like function definition), then it's more likely
+that the rest of the tokens are going to be part of the `for` statement and not the function
+definition. But, it's not necessary that the remaining tokens are valid in the context of a `for`
+statement.
+
+## Keyword as identifiers
+
+When keywords are used as identifiers, the parser recovers from this syntax error by emitting an
+error and including the text value of the keyword to create the `Identifier` node.
+
+### Name expression
+
+#### Assignment
+
+```py
+# error: [invalid-syntax]
+pass = 1
+```
+
+#### Type alias
+
+```py
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+type pass = 1
+```
+
+#### Function definition
+
+```py
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+def True(for):
+    # error: [invalid-syntax]
+    # error: [invalid-syntax]
+    pass
+```
+
+#### For
+
+```py
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+# error: [unresolved-reference] "Name `pass` used when not defined"
+for while in pass:
+    pass
+```
+
+#### While
+
+```py
+# error: [invalid-syntax]
+# error: [unresolved-reference] "Name `in` used when not defined"
+while in:
+    pass
+```
+
+#### Match
+
+```py
+# error: [invalid-syntax]
+# error: [invalid-syntax]
+# error: [unresolved-reference] "Name `match` used when not defined"
+match while:
+    # error: [invalid-syntax]
+    # error: [invalid-syntax]
+    # error: [invalid-syntax]
+    # error: [unresolved-reference] "Name `case` used when not defined"
+    case in:
+        # error: [invalid-syntax]
+        # error: [invalid-syntax]
+        pass
+```
+
+### Attribute expression
+
+```py
+# TODO: Check when support for attribute expressions is added
+
+# error: [invalid-syntax]
+# error: [unresolved-reference] "Name `foo` used when not defined"
+for x in foo.pass:
+    pass
+```

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

@@ -0,0 +1,7 @@
+# Ellipsis literals
+
+## Simple
+
+```py
+reveal_type(...)  # revealed: EllipsisType | ellipsis
+```

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
+    reveal_type(a1)  # revealed: @Todo(generics)
 ```
 
 ## Detecting typing_extensions.Literal

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

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

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

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

crates/red_knot_python_semantic/resources/mdtest/mdtest_config.md

@@ -0,0 +1,67 @@
+This test makes sure that `red_knot_test` correctly parses the TOML configuration blocks and applies
+the correct settings hierarchically.
+
+The following configuration will be attached to the *root* section (without any heading):
+
+```toml
+[environment]
+target-version = "3.10"
+```
+
+# Basic
+
+Here, we simply make sure that we pick up the global configuration from the root section:
+
+```py
+reveal_type(sys.version_info[:2] == (3, 10))  # revealed: Literal[True]
+```
+
+# Inheritance
+
+## Child
+
+### Grandchild
+
+The same should work for arbitrarily nested sections:
+
+```py
+reveal_type(sys.version_info[:2] == (3, 10))  # revealed: Literal[True]
+```
+
+# Overwriting
+
+Here, we make sure that we can overwrite the global configuration in a child section:
+
+```toml
+[environment]
+target-version = "3.11"
+```
+
+```py
+reveal_type(sys.version_info[:2] == (3, 11))  # revealed: Literal[True]
+```
+
+# No global state
+
+There is no global state. This section should again use the root configuration:
+
+```py
+reveal_type(sys.version_info[:2] == (3, 10))  # revealed: Literal[True]
+```
+
+# Overwriting affects children
+
+Children in this section should all use the section configuration:
+
+```toml
+[environment]
+target-version = "3.12"
+```
+
+## Child
+
+### Grandchild
+
+```py
+reveal_type(sys.version_info[:2] == (3, 12))  # revealed: Literal[True]
+```

crates/red_knot_python_semantic/resources/mdtest/metaclass.md

@@ -171,7 +171,7 @@ def f(*args, **kwargs) -> int: ...
 class A(metaclass=f): ...
 
 # TODO should be `type[int]`
-reveal_type(A.__class__)  # revealed: @Todo
+reveal_type(A.__class__)  # revealed: @Todo(metaclass not a class)
 ```
 
 ## Cyclic
@@ -179,9 +179,9 @@ reveal_type(A.__class__)  # revealed: @Todo
 Retrieving the metaclass of a cyclically defined class should not cause an infinite loop.
 
 ```py path=a.pyi
-class A(B): ...  # error: [cyclic-class-def]
-class B(C): ...  # error: [cyclic-class-def]
-class C(A): ...  # error: [cyclic-class-def]
+class A(B): ...  # error: [cyclic-class-definition]
+class B(C): ...  # error: [cyclic-class-definition]
+class C(A): ...  # error: [cyclic-class-definition]
 
 reveal_type(A.__class__)  # revealed: Unknown
 ```

crates/red_knot_python_semantic/resources/mdtest/mro.md

@@ -256,7 +256,7 @@ class O: ...
 class X(O): ...
 class Y(O): ...
 
-if bool():
+if returns_bool():
     foo = Y
 else:
     foo = object
@@ -348,14 +348,14 @@ reveal_type(unknown_object.__mro__)  # revealed: Unknown
 These are invalid, but we need to be able to handle them gracefully without panicking.
 
 ```py path=a.pyi
-class Foo(Foo): ...  # error: [cyclic-class-def]
+class Foo(Foo): ...  # error: [cyclic-class-definition]
 
 reveal_type(Foo)  # revealed: Literal[Foo]
 reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
 
 class Bar: ...
 class Baz: ...
-class Boz(Bar, Baz, Boz): ...  # error: [cyclic-class-def]
+class Boz(Bar, Baz, Boz): ...  # error: [cyclic-class-definition]
 
 reveal_type(Boz)  # revealed: Literal[Boz]
 reveal_type(Boz.__mro__)  # revealed: tuple[Literal[Boz], Unknown, Literal[object]]
@@ -366,9 +366,9 @@ reveal_type(Boz.__mro__)  # revealed: tuple[Literal[Boz], Unknown, Literal[objec
 These are similarly unlikely, but we still shouldn't crash:
 
 ```py path=a.pyi
-class Foo(Bar): ...  # error: [cyclic-class-def]
-class Bar(Baz): ...  # error: [cyclic-class-def]
-class Baz(Foo): ...  # error: [cyclic-class-def]
+class Foo(Bar): ...  # error: [cyclic-class-definition]
+class Bar(Baz): ...  # error: [cyclic-class-definition]
+class Baz(Foo): ...  # error: [cyclic-class-definition]
 
 reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
 reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Unknown, Literal[object]]
@@ -379,9 +379,9 @@ reveal_type(Baz.__mro__)  # revealed: tuple[Literal[Baz], Unknown, Literal[objec
 
 ```py path=a.pyi
 class Spam: ...
-class Foo(Bar): ...  # error: [cyclic-class-def]
-class Bar(Baz): ...  # error: [cyclic-class-def]
-class Baz(Foo, Spam): ...  # error: [cyclic-class-def]
+class Foo(Bar): ...  # error: [cyclic-class-definition]
+class Bar(Baz): ...  # error: [cyclic-class-definition]
+class Baz(Foo, Spam): ...  # error: [cyclic-class-definition]
 
 reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
 reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Unknown, Literal[object]]
@@ -391,16 +391,16 @@ reveal_type(Baz.__mro__)  # revealed: tuple[Literal[Baz], Unknown, Literal[objec
 ## Classes with cycles in their MRO, and a sub-graph
 
 ```py path=a.pyi
-class FooCycle(BarCycle): ...  # error: [cyclic-class-def]
+class FooCycle(BarCycle): ...  # error: [cyclic-class-definition]
 class Foo: ...
-class BarCycle(FooCycle): ...  # error: [cyclic-class-def]
+class BarCycle(FooCycle): ...  # error: [cyclic-class-definition]
 class Bar(Foo): ...
 
 # TODO: can we avoid emitting the errors for these?
 # The classes have cyclic superclasses,
 # but are not themselves cyclic...
-class Baz(Bar, BarCycle): ...  # error: [cyclic-class-def]
-class Spam(Baz): ...  # error: [cyclic-class-def]
+class Baz(Bar, BarCycle): ...  # error: [cyclic-class-definition]
+class Spam(Baz): ...  # error: [cyclic-class-definition]
 
 reveal_type(FooCycle.__mro__)  # revealed: tuple[Literal[FooCycle], Unknown, Literal[object]]
 reveal_type(BarCycle.__mro__)  # revealed: tuple[Literal[BarCycle], Unknown, Literal[object]]

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

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

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

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

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

@@ -17,8 +17,7 @@ reveal_type(__doc__)  # revealed: str | None
 # (needs support for `*` imports)
 reveal_type(__spec__)  # revealed: Unknown | None
 
-# TODO: generics
-reveal_type(__path__)  # revealed: @Todo
+reveal_type(__path__)  # revealed: @Todo(generics)
 
 class X:
     reveal_type(__name__)  # revealed: str
@@ -64,7 +63,7 @@ reveal_type(typing.__class__)  # revealed: Literal[type]
 
 # TODO: needs support for attribute access on instances, properties and generics;
 # should be `dict[str, Any]`
-reveal_type(typing.__dict__)  # revealed: @Todo
+reveal_type(typing.__dict__)  # revealed: @Todo(instance attributes)
 ```
 
 Typeshed includes a fake `__getattr__` method in the stub for `types.ModuleType` to help out with
@@ -96,8 +95,8 @@ from foo import __dict__ as foo_dict
 
 # TODO: needs support for attribute access on instances, properties, and generics;
 # should be `dict[str, Any]` for both of these:
-reveal_type(foo.__dict__)  # revealed: @Todo
-reveal_type(foo_dict)  # revealed: @Todo
+reveal_type(foo.__dict__)  # revealed: @Todo(instance attributes)
+reveal_type(foo_dict)  # revealed: @Todo(instance attributes)
 ```
 
 ## Conditionally global or `ModuleType` attribute

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

@@ -0,0 +1,45 @@
+# Nonlocal references
+
+## One level up
+
+```py
+def f():
+    x = 1
+    def g():
+        reveal_type(x)  # revealed: Literal[1]
+```
+
+## Two levels up
+
+```py
+def f():
+    x = 1
+    def g():
+        def h():
+            reveal_type(x)  # revealed: Literal[1]
+```
+
+## Skips class scope
+
+```py
+def f():
+    x = 1
+
+    class C:
+        x = 2
+        def g():
+            reveal_type(x)  # revealed: Literal[1]
+```
+
+## Skips annotation-only assignment
+
+```py
+def f():
+    x = 1
+    def g():
+        # it's pretty weird to have an annotated assignment in a function where the
+        # name is otherwise not defined; maybe should be an error?
+        x: int
+        def h():
+            reveal_type(x)  # revealed: Literal[1]
+```

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

@@ -0,0 +1,57 @@
+# Unbound
+
+## Unbound class variable
+
+Name lookups within a class scope fall back to globals, but lookups of class attributes don't.
+
+```py
+def bool_instance() -> bool:
+    return True
+
+flag = bool_instance()
+x = 1
+
+class C:
+    y = x
+    if flag:
+        x = 2
+
+# error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C]` is possibly unbound"
+reveal_type(C.x)  # revealed: Literal[2]
+reveal_type(C.y)  # revealed: Literal[1]
+```
+
+## Possibly unbound in class and global scope
+
+```py
+def bool_instance() -> bool:
+    return True
+
+if bool_instance():
+    x = "abc"
+
+class C:
+    if bool_instance():
+        x = 1
+
+    # error: [possibly-unresolved-reference]
+    y = x
+
+reveal_type(C.y)  # revealed: Literal[1] | Literal["abc"]
+```
+
+## Unbound function local
+
+An unbound function local that has definitions in the scope does not fall back to globals.
+
+```py
+x = 1
+
+def f():
+    # error: [unresolved-reference]
+    # revealed: Unknown
+    reveal_type(x)
+    x = 2
+    # revealed: Literal[2]
+    reveal_type(x)
+```

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

@@ -1,4 +1,4 @@
-# Class defenitions in stubs
+# Class definitions in stubs
 
 ## Cyclical class definition
 

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

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

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

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

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

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

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

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

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

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

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

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

crates/red_knot_python_semantic/resources/mdtest/sys_version_info.md

@@ -1,5 +1,10 @@
 # `sys.version_info`
 
+```toml
+[environment]
+target-version = "3.9"
+```
+
 ## The type of `sys.version_info`
 
 The type of `sys.version_info` is `sys._version_info`, at least according to typeshed's stubs (which
@@ -58,8 +63,7 @@ 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
 
-# TODO: this should be `Literal[False]`; see #14279
-reveal_type(sys.version_info == (3, 9, 1, "finallllll", 0))  # revealed: bool
+reveal_type(sys.version_info == (3, 8, 1, "finallllll", 0))  # revealed: Literal[False]
 ```
 
 ## Imports and aliases
@@ -113,9 +117,9 @@ properties on instance types:
 ```py path=b.py
 import sys
 
-reveal_type(sys.version_info.micro)  # revealed: @Todo
-reveal_type(sys.version_info.releaselevel)  # revealed: @Todo
-reveal_type(sys.version_info.serial)  # revealed: @Todo
+reveal_type(sys.version_info.micro)  # revealed: @Todo(instance attributes)
+reveal_type(sys.version_info.releaselevel)  # revealed: @Todo(instance attributes)
+reveal_type(sys.version_info.serial)  # revealed: @Todo(instance attributes)
 ```
 
 ## Accessing fields by index/slice

crates/red_knot_python_semantic/resources/mdtest/type_alias.md

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

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

@@ -0,0 +1,117 @@
+# type special form
+
+## Class literal
+
+```py
+class A: ...
+
+def f() -> type[A]:
+    return A
+
+reveal_type(f())  # revealed: type[A]
+```
+
+## Nested class literal
+
+```py
+class A:
+    class B: ...
+
+def f() -> type[A.B]:
+    return A.B
+
+reveal_type(f())  # revealed: type[B]
+```
+
+## Deeply nested class literal
+
+```py
+class A:
+    class B:
+        class C: ...
+
+def f() -> type[A.B.C]:
+    return A.B.C
+
+reveal_type(f())  # revealed: type[C]
+```
+
+## Class literal from another module
+
+```py
+from a import A
+
+def f() -> type[A]:
+    return A
+
+reveal_type(f())  # revealed: type[A]
+```
+
+```py path=a.py
+class A: ...
+```
+
+## Qualified class literal from another module
+
+```py
+import a
+
+def f() -> type[a.B]:
+    return a.B
+
+reveal_type(f())  # revealed: type[B]
+```
+
+```py path=a.py
+class B: ...
+```
+
+## Deeply qualified class literal from another module
+
+```py path=a/test.py
+import a.b
+
+# TODO: no diagnostic
+# error: [unresolved-attribute]
+def f() -> type[a.b.C]:
+    # TODO: no diagnostic
+    # error: [unresolved-attribute]
+    return a.b.C
+
+reveal_type(f())  # revealed: @Todo(unsupported type[X] special form)
+```
+
+```py path=a/__init__.py
+```
+
+```py path=a/b.py
+class C: ...
+```
+
+## Union of classes
+
+```py
+class BasicUser: ...
+class ProUser: ...
+
+class A:
+    class B:
+        class C: ...
+
+def get_user() -> type[BasicUser | ProUser | A.B.C]:
+    return BasicUser
+
+# revealed: type[BasicUser] | type[ProUser] | type[C]
+reveal_type(get_user())
+```
+
+## Illegal parameters
+
+```py
+class A: ...
+class B: ...
+
+# error: [invalid-type-form]
+def get_user() -> type[A, B]:
+    return A
+```

crates/red_knot_python_semantic/resources/mdtest/unpacking.md

@@ -84,7 +84,7 @@ reveal_type(b)  # revealed: Literal[2]
 [a, *b, c, d] = (1, 2)
 reveal_type(a)  # revealed: Literal[1]
 # TODO: Should be list[Any] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: Literal[2]
 reveal_type(d)  # revealed: Unknown
 ```
@@ -95,7 +95,7 @@ reveal_type(d)  # revealed: Unknown
 [a, *b, c] = (1, 2)
 reveal_type(a)  # revealed: Literal[1]
 # TODO: Should be list[Any] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: Literal[2]
 ```
 
@@ -105,7 +105,7 @@ reveal_type(c)  # revealed: Literal[2]
 [a, *b, c] = (1, 2, 3)
 reveal_type(a)  # revealed: Literal[1]
 # TODO: Should be list[int] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: Literal[3]
 ```
 
@@ -115,7 +115,7 @@ reveal_type(c)  # revealed: Literal[3]
 [a, *b, c, d] = (1, 2, 3, 4, 5, 6)
 reveal_type(a)  # revealed: Literal[1]
 # TODO: Should be list[int] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: Literal[5]
 reveal_type(d)  # revealed: Literal[6]
 ```
@@ -127,7 +127,7 @@ reveal_type(d)  # revealed: Literal[6]
 reveal_type(a)  # revealed: Literal[1]
 reveal_type(b)  # revealed: Literal[2]
 # TODO: Should be list[int] once support for assigning to starred expression is added
-reveal_type(c)  # revealed: @Todo
+reveal_type(c)  # revealed: @Todo(starred unpacking)
 ```
 
 ### Starred expression (6)
@@ -138,7 +138,7 @@ reveal_type(c)  # revealed: @Todo
 reveal_type(a)  # revealed: Literal[1]
 reveal_type(b)  # revealed: Unknown
 reveal_type(c)  # revealed: Unknown
-reveal_type(d)  # revealed: @Todo
+reveal_type(d)  # revealed: @Todo(starred unpacking)
 reveal_type(e)  # revealed: Unknown
 reveal_type(f)  # revealed: Unknown
 ```
@@ -222,7 +222,7 @@ reveal_type(b)  # revealed: LiteralString
 (a, *b, c, d) = "ab"
 reveal_type(a)  # revealed: LiteralString
 # TODO: Should be list[LiteralString] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: LiteralString
 reveal_type(d)  # revealed: Unknown
 ```
@@ -233,7 +233,7 @@ reveal_type(d)  # revealed: Unknown
 (a, *b, c) = "ab"
 reveal_type(a)  # revealed: LiteralString
 # TODO: Should be list[Any] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: LiteralString
 ```
 
@@ -243,7 +243,7 @@ reveal_type(c)  # revealed: LiteralString
 (a, *b, c) = "abc"
 reveal_type(a)  # revealed: LiteralString
 # TODO: Should be list[LiteralString] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: LiteralString
 ```
 
@@ -253,7 +253,7 @@ reveal_type(c)  # revealed: LiteralString
 (a, *b, c, d) = "abcdef"
 reveal_type(a)  # revealed: LiteralString
 # TODO: Should be list[LiteralString] once support for assigning to starred expression is added
-reveal_type(b)  # revealed: @Todo
+reveal_type(b)  # revealed: @Todo(starred unpacking)
 reveal_type(c)  # revealed: LiteralString
 reveal_type(d)  # revealed: LiteralString
 ```
@@ -265,5 +265,44 @@ reveal_type(d)  # revealed: LiteralString
 reveal_type(a)  # revealed: LiteralString
 reveal_type(b)  # revealed: LiteralString
 # TODO: Should be list[int] once support for assigning to starred expression is added
-reveal_type(c)  # revealed: @Todo
+reveal_type(c)  # revealed: @Todo(starred unpacking)
+```
+
+### Unicode
+
+```py
+# TODO: Add diagnostic (need more values to unpack)
+(a, b) = "é"
+
+reveal_type(a)  # revealed: LiteralString
+reveal_type(b)  # revealed: Unknown
+```
+
+### Unicode escape (1)
+
+```py
+# TODO: Add diagnostic (need more values to unpack)
+(a, b) = "\u9E6C"
+
+reveal_type(a)  # revealed: LiteralString
+reveal_type(b)  # revealed: Unknown
+```
+
+### Unicode escape (2)
+
+```py
+# TODO: Add diagnostic (need more values to unpack)
+(a, b) = "\U0010FFFF"
+
+reveal_type(a)  # revealed: LiteralString
+reveal_type(b)  # revealed: Unknown
+```
+
+### Surrogates
+
+```py
+(a, b) = "\uD800\uDFFF"
+
+reveal_type(a)  # revealed: LiteralString
+reveal_type(b)  # revealed: LiteralString
 ```

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

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

crates/red_knot_python_semantic/src/db.rs

@@ -1,3 +1,4 @@
+use crate::lint::RuleSelection;
 use ruff_db::files::File;
 use ruff_db::{Db as SourceDb, Upcast};
 
@@ -5,18 +6,25 @@ use ruff_db::{Db as SourceDb, Upcast};
 #[salsa::db]
 pub trait Db: SourceDb + Upcast<dyn SourceDb> {
     fn is_file_open(&self, file: File) -> bool;
+
+    fn rule_selection(&self) -> &RuleSelection;
 }
 
 #[cfg(test)]
 pub(crate) mod tests {
     use std::sync::Arc;
 
-    use ruff_db::files::{File, Files};
-    use ruff_db::system::{DbWithTestSystem, System, TestSystem};
-    use ruff_db::vendored::VendoredFileSystem;
-    use ruff_db::{Db as SourceDb, Upcast};
+    use crate::program::{Program, SearchPathSettings};
+    use crate::python_version::PythonVersion;
+    use crate::{default_lint_registry, ProgramSettings};
 
     use super::Db;
+    use crate::lint::RuleSelection;
+    use anyhow::Context;
+    use ruff_db::files::{File, Files};
+    use ruff_db::system::{DbWithTestSystem, System, SystemPathBuf, TestSystem};
+    use ruff_db::vendored::VendoredFileSystem;
+    use ruff_db::{Db as SourceDb, Upcast};
 
     #[salsa::db]
     pub(crate) struct TestDb {
@@ -24,7 +32,8 @@ pub(crate) mod tests {
         files: Files,
         system: TestSystem,
         vendored: VendoredFileSystem,
-        events: std::sync::Arc<std::sync::Mutex<Vec<salsa::Event>>>,
+        events: Arc<std::sync::Mutex<Vec<salsa::Event>>>,
+        rule_selection: Arc<RuleSelection>,
     }
 
     impl TestDb {
@@ -33,8 +42,9 @@ pub(crate) mod tests {
                 storage: salsa::Storage::default(),
                 system: TestSystem::default(),
                 vendored: red_knot_vendored::file_system().clone(),
-                events: std::sync::Arc::default(),
+                events: Arc::default(),
                 files: Files::default(),
+                rule_selection: Arc::new(RuleSelection::from_registry(&default_lint_registry())),
             }
         }
 
@@ -97,6 +107,10 @@ pub(crate) mod tests {
         fn is_file_open(&self, file: File) -> bool {
             !file.path(self).is_vendored_path()
         }
+
+        fn rule_selection(&self) -> &RuleSelection {
+            &self.rule_selection
+        }
     }
 
     #[salsa::db]
@@ -108,4 +122,66 @@ pub(crate) mod tests {
             events.push(event);
         }
     }
+
+    pub(crate) struct TestDbBuilder<'a> {
+        /// Target Python version
+        python_version: PythonVersion,
+        /// Path to a custom typeshed directory
+        custom_typeshed: Option<SystemPathBuf>,
+        /// Path and content pairs for files that should be present
+        files: Vec<(&'a str, &'a str)>,
+    }
+
+    impl<'a> TestDbBuilder<'a> {
+        pub(crate) fn new() -> Self {
+            Self {
+                python_version: PythonVersion::default(),
+                custom_typeshed: None,
+                files: vec![],
+            }
+        }
+
+        pub(crate) fn with_python_version(mut self, version: PythonVersion) -> Self {
+            self.python_version = version;
+            self
+        }
+
+        pub(crate) fn with_custom_typeshed(mut self, path: &str) -> Self {
+            self.custom_typeshed = Some(SystemPathBuf::from(path));
+            self
+        }
+
+        pub(crate) fn with_file(mut self, path: &'a str, content: &'a str) -> Self {
+            self.files.push((path, content));
+            self
+        }
+
+        pub(crate) fn build(self) -> anyhow::Result<TestDb> {
+            let mut db = TestDb::new();
+
+            let src_root = SystemPathBuf::from("/src");
+            db.memory_file_system().create_directory_all(&src_root)?;
+
+            db.write_files(self.files)
+                .context("Failed to write test files")?;
+
+            let mut search_paths = SearchPathSettings::new(src_root);
+            search_paths.custom_typeshed = self.custom_typeshed;
+
+            Program::from_settings(
+                &db,
+                &ProgramSettings {
+                    target_version: self.python_version,
+                    search_paths,
+                },
+            )
+            .context("Failed to configure Program settings")?;
+
+            Ok(db)
+        }
+    }
+
+    pub(crate) fn setup_db() -> TestDb {
+        TestDbBuilder::new().build().expect("valid TestDb setup")
+    }
 }

crates/red_knot_python_semantic/src/lib.rs

@@ -2,6 +2,7 @@ use std::hash::BuildHasherDefault;
 
 use rustc_hash::FxHasher;
 
+use crate::lint::{LintRegistry, LintRegistryBuilder};
 pub use db::Db;
 pub use module_name::ModuleName;
 pub use module_resolver::{resolve_module, system_module_search_paths, Module};
@@ -11,6 +12,7 @@ pub use semantic_model::{HasTy, SemanticModel};
 
 pub mod ast_node_ref;
 mod db;
+pub mod lint;
 mod module_name;
 mod module_resolver;
 mod node_key;
@@ -26,3 +28,13 @@ mod unpack;
 mod util;
 
 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;
+
+pub fn default_lint_registry() -> LintRegistry {
+    let mut registry = LintRegistryBuilder::default();
+    register_semantic_lints(&mut registry);
+    registry.build()
+}
+
+pub fn register_semantic_lints(registry: &mut LintRegistryBuilder) {
+    types::register_type_lints(registry);
+}

crates/red_knot_python_semantic/src/lint.rs

@@ -0,0 +1,419 @@
+use itertools::Itertools;
+use ruff_db::diagnostic::{LintName, Severity};
+use rustc_hash::FxHashMap;
+use std::hash::Hasher;
+use thiserror::Error;
+
+#[derive(Debug, Clone)]
+pub struct LintMetadata {
+    /// The unique identifier for the lint.
+    pub name: LintName,
+
+    /// A one-sentence summary of what the lint catches.
+    pub summary: &'static str,
+
+    /// An in depth explanation of the lint in markdown. Covers what the lint does, why it's bad and possible fixes.
+    ///
+    /// The documentation may require post-processing to be rendered correctly. For example, lines
+    /// might have leading or trailing whitespace that should be removed.
+    pub raw_documentation: &'static str,
+
+    /// The default level of the lint if the user doesn't specify one.
+    pub default_level: Level,
+
+    pub status: LintStatus,
+
+    /// Location where this lint is declared: `file_name:line`
+    pub source: &'static str,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub enum Level {
+    /// The lint is disabled and should not run.
+    Ignore,
+
+    /// The lint is enabled and diagnostic should have a warning severity.
+    Warn,
+
+    /// The lint is enabled and diagnostics have an error severity.
+    Error,
+}
+
+impl Level {
+    pub const fn is_error(self) -> bool {
+        matches!(self, Level::Error)
+    }
+
+    pub const fn is_warn(self) -> bool {
+        matches!(self, Level::Warn)
+    }
+
+    pub const fn is_ignore(self) -> bool {
+        matches!(self, Level::Ignore)
+    }
+}
+
+impl TryFrom<Level> for Severity {
+    type Error = ();
+
+    fn try_from(level: Level) -> Result<Self, ()> {
+        match level {
+            Level::Ignore => Err(()),
+            Level::Warn => Ok(Severity::Warning),
+            Level::Error => Ok(Severity::Error),
+        }
+    }
+}
+
+impl LintMetadata {
+    pub fn name(&self) -> LintName {
+        self.name
+    }
+
+    pub fn summary(&self) -> &str {
+        self.summary
+    }
+
+    /// Returns the documentation line by line with leading and trailing whitespace removed.
+    pub fn documentation_lines(&self) -> impl Iterator<Item = &str> {
+        self.raw_documentation
+            .lines()
+            .map(|line| line.strip_prefix(' ').unwrap_or(line).trim_end())
+    }
+
+    /// Returns the documentation as a single string.
+    pub fn documentation(&self) -> String {
+        self.documentation_lines().join("\n")
+    }
+
+    pub fn default_level(&self) -> Level {
+        self.default_level
+    }
+
+    pub fn status(&self) -> &LintStatus {
+        &self.status
+    }
+
+    pub fn source(&self) -> &str {
+        self.source
+    }
+}
+
+#[doc(hidden)]
+pub const fn lint_metadata_defaults() -> LintMetadata {
+    LintMetadata {
+        name: LintName::of(""),
+        summary: "",
+        raw_documentation: "",
+        default_level: Level::Error,
+        status: LintStatus::preview("0.0.0"),
+        source: "",
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum LintStatus {
+    /// The rule has been added to the linter, but is not yet stable.
+    Preview {
+        /// When the rule was added to preview
+        since: &'static str,
+    },
+
+    /// Stable rule that was added in the version defined by `since`.
+    Stable { since: &'static str },
+
+    /// The rule has been deprecated [`since`] (version) and will be removed in the future.
+    Deprecated {
+        since: &'static str,
+        reason: &'static str,
+    },
+
+    /// The rule has been removed [`since`] (version) and using it will result in an error.
+    Removed {
+        since: &'static str,
+        reason: &'static str,
+    },
+}
+
+impl LintStatus {
+    pub const fn preview(since: &'static str) -> Self {
+        LintStatus::Preview { since }
+    }
+
+    pub const fn stable(since: &'static str) -> Self {
+        LintStatus::Stable { since }
+    }
+
+    pub const fn deprecated(since: &'static str, reason: &'static str) -> Self {
+        LintStatus::Deprecated { since, reason }
+    }
+
+    pub const fn removed(since: &'static str, reason: &'static str) -> Self {
+        LintStatus::Removed { since, reason }
+    }
+
+    pub const fn is_removed(&self) -> bool {
+        matches!(self, LintStatus::Removed { .. })
+    }
+}
+
+#[macro_export]
+macro_rules! declare_lint {
+    (
+        $(#[doc = $doc:literal])+
+        $vis: vis static $name: ident = {
+            summary: $summary: literal,
+            status: $status: expr,
+            // Optional properties
+            $( $key:ident: $value:expr, )*
+        }
+    ) => {
+        $( #[doc = $doc] )+
+        #[allow(clippy::needless_update)]
+        $vis static $name: $crate::lint::LintMetadata = $crate::lint::LintMetadata {
+            name: ruff_db::diagnostic::LintName::of(ruff_macros::kebab_case!($name)),
+            summary: $summary,
+            raw_documentation: concat!($($doc,)+ "\n"),
+            status: $status,
+            source: concat!(file!(), ":", line!()),
+            $( $key: $value, )*
+            ..$crate::lint::lint_metadata_defaults()
+        };
+    };
+}
+
+/// A unique identifier for a lint rule.
+///
+/// Implements `PartialEq`, `Eq`, and `Hash` based on the `LintMetadata` pointer
+/// for fast comparison and lookup.
+#[derive(Debug, Clone, Copy)]
+pub struct LintId {
+    definition: &'static LintMetadata,
+}
+
+impl LintId {
+    pub const fn of(definition: &'static LintMetadata) -> Self {
+        LintId { definition }
+    }
+}
+
+impl PartialEq for LintId {
+    fn eq(&self, other: &Self) -> bool {
+        std::ptr::eq(self.definition, other.definition)
+    }
+}
+
+impl Eq for LintId {}
+
+impl std::hash::Hash for LintId {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        std::ptr::hash(self.definition, state);
+    }
+}
+
+impl std::ops::Deref for LintId {
+    type Target = LintMetadata;
+
+    fn deref(&self) -> &Self::Target {
+        self.definition
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct LintRegistryBuilder {
+    /// Registered lints that haven't been removed.
+    lints: Vec<LintId>,
+
+    /// Lints indexed by name, including aliases and removed rules.
+    by_name: FxHashMap<&'static str, LintEntry>,
+}
+
+impl LintRegistryBuilder {
+    #[track_caller]
+    pub fn register_lint(&mut self, lint: &'static LintMetadata) {
+        assert_eq!(
+            self.by_name.insert(&*lint.name, lint.into()),
+            None,
+            "duplicate lint registration for '{name}'",
+            name = lint.name
+        );
+
+        if !lint.status.is_removed() {
+            self.lints.push(LintId::of(lint));
+        }
+    }
+
+    #[track_caller]
+    pub fn register_alias(&mut self, from: LintName, to: &'static LintMetadata) {
+        let target = match self.by_name.get(to.name.as_str()) {
+            Some(LintEntry::Lint(target) | LintEntry::Removed(target)) => target,
+            Some(LintEntry::Alias(target)) => {
+                panic!(
+                    "lint alias {from} -> {to:?} points to another alias {target:?}",
+                    target = target.name()
+                )
+            }
+            None => panic!(
+                "lint alias {from} -> {to} points to non-registered lint",
+                to = to.name
+            ),
+        };
+
+        assert_eq!(
+            self.by_name
+                .insert(from.as_str(), LintEntry::Alias(*target)),
+            None,
+            "duplicate lint registration for '{from}'",
+        );
+    }
+
+    pub fn build(self) -> LintRegistry {
+        LintRegistry {
+            lints: self.lints,
+            by_name: self.by_name,
+        }
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct LintRegistry {
+    lints: Vec<LintId>,
+    by_name: FxHashMap<&'static str, LintEntry>,
+}
+
+impl LintRegistry {
+    /// Looks up a lint by its name.
+    pub fn get(&self, code: &str) -> Result<LintId, GetLintError> {
+        match self.by_name.get(code) {
+            Some(LintEntry::Lint(metadata)) => Ok(*metadata),
+            Some(LintEntry::Alias(lint)) => {
+                if lint.status.is_removed() {
+                    Err(GetLintError::Removed(lint.name()))
+                } else {
+                    Ok(*lint)
+                }
+            }
+            Some(LintEntry::Removed(lint)) => Err(GetLintError::Removed(lint.name())),
+            None => Err(GetLintError::Unknown(code.to_string())),
+        }
+    }
+
+    /// Returns all registered, non-removed lints.
+    pub fn lints(&self) -> &[LintId] {
+        &self.lints
+    }
+
+    /// Returns an iterator over all known aliases and to their target lints.
+    ///
+    /// This iterator includes aliases that point to removed lints.
+    pub fn aliases(&self) -> impl Iterator<Item = (LintName, LintId)> + use<'_> {
+        self.by_name.iter().filter_map(|(key, value)| {
+            if let LintEntry::Alias(alias) = value {
+                Some((LintName::of(key), *alias))
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Iterates over all removed lints.
+    pub fn removed(&self) -> impl Iterator<Item = LintId> + use<'_> {
+        self.by_name.iter().filter_map(|(_, value)| {
+            if let LintEntry::Removed(metadata) = value {
+                Some(*metadata)
+            } else {
+                None
+            }
+        })
+    }
+}
+
+#[derive(Error, Debug, Clone)]
+pub enum GetLintError {
+    /// The name maps to this removed lint.
+    #[error("lint {0} has been removed")]
+    Removed(LintName),
+
+    /// No lint with the given name is known.
+    #[error("unknown lint {0}")]
+    Unknown(String),
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum LintEntry {
+    /// An existing lint rule. Can be in preview, stable or deprecated.
+    Lint(LintId),
+    /// A lint rule that has been removed.
+    Removed(LintId),
+    Alias(LintId),
+}
+
+impl From<&'static LintMetadata> for LintEntry {
+    fn from(metadata: &'static LintMetadata) -> Self {
+        if metadata.status.is_removed() {
+            LintEntry::Removed(LintId::of(metadata))
+        } else {
+            LintEntry::Lint(LintId::of(metadata))
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct RuleSelection {
+    /// Map with the severity for each enabled lint rule.
+    ///
+    /// If a rule isn't present in this map, then it should be considered disabled.
+    lints: FxHashMap<LintId, Severity>,
+}
+
+impl RuleSelection {
+    /// Creates a new rule selection from all known lints in the registry that are enabled
+    /// according to their default severity.
+    pub fn from_registry(registry: &LintRegistry) -> Self {
+        let lints = registry
+            .lints()
+            .iter()
+            .filter_map(|lint| {
+                Severity::try_from(lint.default_level())
+                    .ok()
+                    .map(|severity| (*lint, severity))
+            })
+            .collect();
+
+        RuleSelection { lints }
+    }
+
+    /// Returns an iterator over all enabled lints.
+    pub fn enabled(&self) -> impl Iterator<Item = LintId> + use<'_> {
+        self.lints.keys().copied()
+    }
+
+    /// Returns an iterator over all enabled lints and their severity.
+    pub fn iter(&self) -> impl ExactSizeIterator<Item = (LintId, Severity)> + use<'_> {
+        self.lints.iter().map(|(&lint, &severity)| (lint, severity))
+    }
+
+    /// Returns the configured severity for the lint with the given id or `None` if the lint is disabled.
+    pub fn severity(&self, lint: LintId) -> Option<Severity> {
+        self.lints.get(&lint).copied()
+    }
+
+    /// Enables `lint` and configures with the given `severity`.
+    ///
+    /// Overrides any previous configuration for the lint.
+    pub fn enable(&mut self, lint: LintId, severity: Severity) {
+        self.lints.insert(lint, severity);
+    }
+
+    /// Disables `lint` if it was previously enabled.
+    pub fn disable(&mut self, lint: LintId) {
+        self.lints.remove(&lint);
+    }
+
+    /// Merges the enabled lints from `other` into this selection.
+    ///
+    /// Lints from `other` will override any existing configuration.
+    pub fn merge(&mut self, other: &RuleSelection) {
+        self.lints.extend(other.iter());
+    }
+}

crates/red_knot_python_semantic/src/module_resolver/resolver.rs

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

crates/red_knot_python_semantic/src/semantic_index.rs

@@ -606,24 +606,11 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
         let function_table = index.symbol_table(function_scope_id);
         assert_eq!(
             names(&function_table),
-            vec!["a", "b", "c", "args", "d", "kwargs"],
+            vec!["a", "b", "c", "d", "args", "kwargs"],
         );
 
         let use_def = index.use_def_map(function_scope_id);
         for name in ["a", "b", "c", "d"] {
-            let binding = use_def
-                .first_public_binding(
-                    function_table
-                        .symbol_id_by_name(name)
-                        .expect("symbol exists"),
-                )
-                .unwrap();
-            assert!(matches!(
-                binding.kind(&db),
-                DefinitionKind::ParameterWithDefault(_)
-            ));
-        }
-        for name in ["args", "kwargs"] {
             let binding = use_def
                 .first_public_binding(
                     function_table
@@ -633,6 +620,28 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
                 .unwrap();
             assert!(matches!(binding.kind(&db), DefinitionKind::Parameter(_)));
         }
+        let args_binding = use_def
+            .first_public_binding(
+                function_table
+                    .symbol_id_by_name("args")
+                    .expect("symbol exists"),
+            )
+            .unwrap();
+        assert!(matches!(
+            args_binding.kind(&db),
+            DefinitionKind::VariadicPositionalParameter(_)
+        ));
+        let kwargs_binding = use_def
+            .first_public_binding(
+                function_table
+                    .symbol_id_by_name("kwargs")
+                    .expect("symbol exists"),
+            )
+            .unwrap();
+        assert!(matches!(
+            kwargs_binding.kind(&db),
+            DefinitionKind::VariadicKeywordParameter(_)
+        ));
     }
 
     #[test]
@@ -654,25 +663,38 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
         let lambda_table = index.symbol_table(lambda_scope_id);
         assert_eq!(
             names(&lambda_table),
-            vec!["a", "b", "c", "args", "d", "kwargs"],
+            vec!["a", "b", "c", "d", "args", "kwargs"],
         );
 
         let use_def = index.use_def_map(lambda_scope_id);
         for name in ["a", "b", "c", "d"] {
-            let binding = use_def
-                .first_public_binding(lambda_table.symbol_id_by_name(name).expect("symbol exists"))
-                .unwrap();
-            assert!(matches!(
-                binding.kind(&db),
-                DefinitionKind::ParameterWithDefault(_)
-            ));
-        }
-        for name in ["args", "kwargs"] {
             let binding = use_def
                 .first_public_binding(lambda_table.symbol_id_by_name(name).expect("symbol exists"))
                 .unwrap();
             assert!(matches!(binding.kind(&db), DefinitionKind::Parameter(_)));
         }
+        let args_binding = use_def
+            .first_public_binding(
+                lambda_table
+                    .symbol_id_by_name("args")
+                    .expect("symbol exists"),
+            )
+            .unwrap();
+        assert!(matches!(
+            args_binding.kind(&db),
+            DefinitionKind::VariadicPositionalParameter(_)
+        ));
+        let kwargs_binding = use_def
+            .first_public_binding(
+                lambda_table
+                    .symbol_id_by_name("kwargs")
+                    .expect("symbol exists"),
+            )
+            .unwrap();
+        assert!(matches!(
+            kwargs_binding.kind(&db),
+            DefinitionKind::VariadicKeywordParameter(_)
+        ));
     }
 
     /// Test case to validate that the comprehension scope is correctly identified and that the target

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -9,7 +9,7 @@ use ruff_index::IndexVec;
 use ruff_python_ast as ast;
 use ruff_python_ast::name::Name;
 use ruff_python_ast::visitor::{walk_expr, walk_pattern, walk_stmt, Visitor};
-use ruff_python_ast::{AnyParameterRef, BoolOp, Expr};
+use ruff_python_ast::{BoolOp, Expr};
 
 use crate::ast_node_ref::AstNodeRef;
 use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey;
@@ -36,12 +36,25 @@ use super::definition::{
 
 mod except_handlers;
 
+/// Are we in a state where a `break` statement is allowed?
+#[derive(Clone, Copy, Debug)]
+enum LoopState {
+    InLoop,
+    NotInLoop,
+}
+
+impl LoopState {
+    fn is_inside(self) -> bool {
+        matches!(self, LoopState::InLoop)
+    }
+}
+
 pub(super) struct SemanticIndexBuilder<'db> {
     // Builder state
     db: &'db dyn Db,
     file: File,
     module: &'db ParsedModule,
-    scope_stack: Vec<FileScopeId>,
+    scope_stack: Vec<(FileScopeId, LoopState)>,
     /// The assignments we're currently visiting, with
     /// the most recent visit at the end of the Vec
     current_assignments: Vec<CurrentAssignment<'db>>,
@@ -103,9 +116,24 @@ impl<'db> SemanticIndexBuilder<'db> {
         *self
             .scope_stack
             .last()
+            .map(|(scope, _)| scope)
             .expect("Always to have a root scope")
     }
 
+    fn loop_state(&self) -> LoopState {
+        self.scope_stack
+            .last()
+            .expect("Always to have a root scope")
+            .1
+    }
+
+    fn set_inside_loop(&mut self, state: LoopState) {
+        self.scope_stack
+            .last_mut()
+            .expect("Always to have a root scope")
+            .1 = state;
+    }
+
     fn push_scope(&mut self, node: NodeWithScopeRef) {
         let parent = self.current_scope();
         self.push_scope_with_parent(node, Some(parent));
@@ -131,15 +159,16 @@ 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);
-        self.scopes_by_node.insert(node.node_key(), file_scope_id);
+        let previous = self.scopes_by_node.insert(node.node_key(), file_scope_id);
+        debug_assert_eq!(previous, None);
 
         debug_assert_eq!(ast_id_scope, file_scope_id);
 
-        self.scope_stack.push(file_scope_id);
+        self.scope_stack.push((file_scope_id, LoopState::NotInLoop));
     }
 
     fn pop_scope(&mut self) -> FileScopeId {
-        let id = self.scope_stack.pop().expect("Root scope to be present");
+        let (id, _) = self.scope_stack.pop().expect("Root scope to be present");
         let children_end = self.scopes.next_index();
         let scope = &mut self.scopes[id];
         scope.descendents = scope.descendents.start..children_end;
@@ -450,21 +479,35 @@ impl<'db> SemanticIndexBuilder<'db> {
         self.pop_scope();
     }
 
-    fn declare_parameter(&mut self, parameter: AnyParameterRef<'db>) {
-        let symbol = self.add_symbol(parameter.name().id().clone());
+    fn declare_parameters(&mut self, parameters: &'db ast::Parameters) {
+        for parameter in parameters.iter_non_variadic_params() {
+            self.declare_parameter(parameter);
+        }
+        if let Some(vararg) = parameters.vararg.as_ref() {
+            let symbol = self.add_symbol(vararg.name.id().clone());
+            self.add_definition(
+                symbol,
+                DefinitionNodeRef::VariadicPositionalParameter(vararg),
+            );
+        }
+        if let Some(kwarg) = parameters.kwarg.as_ref() {
+            let symbol = self.add_symbol(kwarg.name.id().clone());
+            self.add_definition(symbol, DefinitionNodeRef::VariadicKeywordParameter(kwarg));
+        }
+    }
+
+    fn declare_parameter(&mut self, parameter: &'db ast::ParameterWithDefault) {
+        let symbol = self.add_symbol(parameter.parameter.name.id().clone());
 
         let definition = self.add_definition(symbol, parameter);
 
-        if let AnyParameterRef::NonVariadic(with_default) = parameter {
-            // Insert a mapping from the parameter to the same definition.
-            // This ensures that calling `HasTy::ty` on the inner parameter returns
-            // a valid type (and doesn't panic)
-            let existing_definition = self.definitions_by_node.insert(
-                DefinitionNodeRef::from(AnyParameterRef::Variadic(&with_default.parameter)).key(),
-                definition,
-            );
-            debug_assert_eq!(existing_definition, None);
-        }
+        // Insert a mapping from the inner Parameter node to the same definition.
+        // This ensures that calling `HasTy::ty` on the inner parameter returns
+        // a valid type (and doesn't panic)
+        let existing_definition = self
+            .definitions_by_node
+            .insert((&parameter.parameter).into(), definition);
+        debug_assert_eq!(existing_definition, None);
     }
 
     pub(super) fn build(mut self) -> SemanticIndex<'db> {
@@ -527,34 +570,40 @@ where
     fn visit_stmt(&mut self, stmt: &'ast ast::Stmt) {
         match stmt {
             ast::Stmt::FunctionDef(function_def) => {
-                for decorator in &function_def.decorator_list {
+                let ast::StmtFunctionDef {
+                    decorator_list,
+                    parameters,
+                    type_params,
+                    name,
+                    returns,
+                    body,
+                    is_async: _,
+                    range: _,
+                } = function_def;
+                for decorator in decorator_list {
                     self.visit_decorator(decorator);
                 }
 
                 self.with_type_params(
                     NodeWithScopeRef::FunctionTypeParameters(function_def),
-                    function_def.type_params.as_deref(),
+                    type_params.as_deref(),
                     |builder| {
-                        builder.visit_parameters(&function_def.parameters);
-                        if let Some(expr) = &function_def.returns {
-                            builder.visit_annotation(expr);
+                        builder.visit_parameters(parameters);
+                        if let Some(returns) = returns {
+                            builder.visit_annotation(returns);
                         }
 
                         builder.push_scope(NodeWithScopeRef::Function(function_def));
 
-                        // Add symbols and definitions for the parameters to the function scope.
-                        for parameter in &*function_def.parameters {
-                            builder.declare_parameter(parameter);
-                        }
+                        builder.declare_parameters(parameters);
 
-                        builder.visit_body(&function_def.body);
+                        builder.visit_body(body);
                         builder.pop_scope()
                     },
                 );
                 // The default value of the parameters needs to be evaluated in the
                 // enclosing scope.
-                for default in function_def
-                    .parameters
+                for default in parameters
                     .iter_non_variadic_params()
                     .filter_map(|param| param.default.as_deref())
                 {
@@ -563,7 +612,7 @@ where
                 // The symbol for the function name itself has to be evaluated
                 // at the end to match the runtime evaluation of parameter defaults
                 // and return-type annotations.
-                let symbol = self.add_symbol(function_def.name.id.clone());
+                let symbol = self.add_symbol(name.id.clone());
                 self.add_definition(symbol, function_def);
             }
             ast::Stmt::ClassDef(class) => {
@@ -589,6 +638,27 @@ where
                     },
                 );
             }
+            ast::Stmt::TypeAlias(type_alias) => {
+                let symbol = self.add_symbol(
+                    type_alias
+                        .name
+                        .as_name_expr()
+                        .map(|name| name.id.clone())
+                        .unwrap_or("<unknown>".into()),
+                );
+                self.add_definition(symbol, type_alias);
+                self.visit_expr(&type_alias.name);
+
+                self.with_type_params(
+                    NodeWithScopeRef::TypeAliasTypeParameters(type_alias),
+                    type_alias.type_params.as_ref(),
+                    |builder| {
+                        builder.push_scope(NodeWithScopeRef::TypeAlias(type_alias));
+                        builder.visit_expr(&type_alias.value);
+                        builder.pop_scope()
+                    },
+                );
+            }
             ast::Stmt::Import(node) => {
                 for alias in &node.names {
                     let symbol_name = if let Some(asname) = &alias.asname {
@@ -719,7 +789,22 @@ where
                 let mut constraints = vec![constraint];
                 self.visit_body(&node.body);
                 let mut post_clauses: Vec<FlowSnapshot> = vec![];
-                for clause in &node.elif_else_clauses {
+                let elif_else_clauses = node
+                    .elif_else_clauses
+                    .iter()
+                    .map(|clause| (clause.test.as_ref(), clause.body.as_slice()));
+                let has_else = node
+                    .elif_else_clauses
+                    .last()
+                    .is_some_and(|clause| clause.test.is_none());
+                let elif_else_clauses = elif_else_clauses.chain(if has_else {
+                    // if there's an `else` clause already, we don't need to add another
+                    None
+                } else {
+                    // if there's no `else` branch, we should add a no-op `else` branch
+                    Some((None, Default::default()))
+                });
+                for (clause_test, clause_body) in elif_else_clauses {
                     // snapshot after every block except the last; the last one will just become
                     // the state that we merge the other snapshots into
                     post_clauses.push(self.flow_snapshot());
@@ -729,24 +814,15 @@ where
                     for constraint in &constraints {
                         self.record_negated_constraint(*constraint);
                     }
-                    if let Some(elif_test) = &clause.test {
+                    if let Some(elif_test) = clause_test {
                         self.visit_expr(elif_test);
                         constraints.push(self.record_expression_constraint(elif_test));
                     }
-                    self.visit_body(&clause.body);
+                    self.visit_body(clause_body);
                 }
                 for post_clause_state in post_clauses {
                     self.flow_merge(post_clause_state);
                 }
-                let has_else = node
-                    .elif_else_clauses
-                    .last()
-                    .is_some_and(|clause| clause.test.is_none());
-                if !has_else {
-                    // if there's no else clause, then it's possible we took none of the branches,
-                    // and the pre_if state can reach here
-                    self.flow_merge(pre_if);
-                }
             }
             ast::Stmt::While(ast::StmtWhile {
                 test,
@@ -763,7 +839,10 @@ where
 
                 // TODO: definitions created inside the body should be fully visible
                 // to other statements/expressions inside the body --Alex/Carl
+                let outer_loop_state = self.loop_state();
+                self.set_inside_loop(LoopState::InLoop);
                 self.visit_body(body);
+                self.set_inside_loop(outer_loop_state);
 
                 // Get the break states from the body of this loop, and restore the saved outer
                 // ones.
@@ -802,7 +881,9 @@ where
                 self.visit_body(body);
             }
             ast::Stmt::Break(_) => {
-                self.loop_break_states.push(self.flow_snapshot());
+                if self.loop_state().is_inside() {
+                    self.loop_break_states.push(self.flow_snapshot());
+                }
             }
 
             ast::Stmt::For(
@@ -829,7 +910,10 @@ where
                 // TODO: Definitions created by loop variables
                 // (and definitions created inside the body)
                 // are fully visible to other statements/expressions inside the body --Alex/Carl
+                let outer_loop_state = self.loop_state();
+                self.set_inside_loop(LoopState::InLoop);
                 self.visit_body(body);
+                self.set_inside_loop(outer_loop_state);
 
                 let break_states =
                     std::mem::replace(&mut self.loop_break_states, saved_break_states);
@@ -1115,10 +1199,8 @@ where
                 self.push_scope(NodeWithScopeRef::Lambda(lambda));
 
                 // Add symbols and definitions for the parameters to the lambda scope.
-                if let Some(parameters) = &lambda.parameters {
-                    for parameter in parameters {
-                        self.declare_parameter(parameter);
-                    }
+                if let Some(parameters) = lambda.parameters.as_ref() {
+                    self.declare_parameters(parameters);
                 }
 
                 self.visit_expr(lambda.body.as_ref());
@@ -1131,8 +1213,8 @@ where
                 // AST inspection, so we can't simplify here, need to record test expression for
                 // later checking)
                 self.visit_expr(test);
-                let constraint = self.record_expression_constraint(test);
                 let pre_if = self.flow_snapshot();
+                let constraint = self.record_expression_constraint(test);
                 self.visit_expr(body);
                 let post_body = self.flow_snapshot();
                 self.flow_restore(pre_if);

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -83,12 +83,15 @@ 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),
     AugmentedAssignment(&'a ast::StmtAugAssign),
     Comprehension(ComprehensionDefinitionNodeRef<'a>),
-    Parameter(ast::AnyParameterRef<'a>),
+    VariadicPositionalParameter(&'a ast::Parameter),
+    VariadicKeywordParameter(&'a ast::Parameter),
+    Parameter(&'a ast::ParameterWithDefault),
     WithItem(WithItemDefinitionNodeRef<'a>),
     MatchPattern(MatchPatternDefinitionNodeRef<'a>),
     ExceptHandler(ExceptHandlerDefinitionNodeRef<'a>),
@@ -109,6 +112,12 @@ impl<'a> From<&'a ast::StmtClassDef> for DefinitionNodeRef<'a> {
     }
 }
 
+impl<'a> From<&'a ast::StmtTypeAlias> for DefinitionNodeRef<'a> {
+    fn from(node: &'a ast::StmtTypeAlias) -> Self {
+        Self::TypeAlias(node)
+    }
+}
+
 impl<'a> From<&'a ast::ExprNamed> for DefinitionNodeRef<'a> {
     fn from(node: &'a ast::ExprNamed) -> Self {
         Self::NamedExpression(node)
@@ -181,8 +190,8 @@ impl<'a> From<ComprehensionDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
     }
 }
 
-impl<'a> From<ast::AnyParameterRef<'a>> for DefinitionNodeRef<'a> {
-    fn from(node: ast::AnyParameterRef<'a>) -> Self {
+impl<'a> From<&'a ast::ParameterWithDefault> for DefinitionNodeRef<'a> {
+    fn from(node: &'a ast::ParameterWithDefault) -> Self {
         Self::Parameter(node)
     }
 }
@@ -265,6 +274,9 @@ impl<'db> DefinitionNodeRef<'db> {
             DefinitionNodeRef::Class(class) => {
                 DefinitionKind::Class(AstNodeRef::new(parsed, class))
             }
+            DefinitionNodeRef::TypeAlias(type_alias) => {
+                DefinitionKind::TypeAlias(AstNodeRef::new(parsed, type_alias))
+            }
             DefinitionNodeRef::NamedExpression(named) => {
                 DefinitionKind::NamedExpression(AstNodeRef::new(parsed, named))
             }
@@ -305,14 +317,15 @@ impl<'db> DefinitionNodeRef<'db> {
                 first,
                 is_async,
             }),
-            DefinitionNodeRef::Parameter(parameter) => match parameter {
-                ast::AnyParameterRef::Variadic(parameter) => {
-                    DefinitionKind::Parameter(AstNodeRef::new(parsed, parameter))
-                }
-                ast::AnyParameterRef::NonVariadic(parameter) => {
-                    DefinitionKind::ParameterWithDefault(AstNodeRef::new(parsed, parameter))
-                }
-            },
+            DefinitionNodeRef::VariadicPositionalParameter(parameter) => {
+                DefinitionKind::VariadicPositionalParameter(AstNodeRef::new(parsed, parameter))
+            }
+            DefinitionNodeRef::VariadicKeywordParameter(parameter) => {
+                DefinitionKind::VariadicKeywordParameter(AstNodeRef::new(parsed, parameter))
+            }
+            DefinitionNodeRef::Parameter(parameter) => {
+                DefinitionKind::Parameter(AstNodeRef::new(parsed, parameter))
+            }
             DefinitionNodeRef::WithItem(WithItemDefinitionNodeRef {
                 node,
                 target,
@@ -358,6 +371,7 @@ impl<'db> DefinitionNodeRef<'db> {
             }
             Self::Function(node) => node.into(),
             Self::Class(node) => node.into(),
+            Self::TypeAlias(node) => node.into(),
             Self::NamedExpression(node) => node.into(),
             Self::Assignment(AssignmentDefinitionNodeRef {
                 value: _,
@@ -373,10 +387,9 @@ impl<'db> DefinitionNodeRef<'db> {
                 is_async: _,
             }) => target.into(),
             Self::Comprehension(ComprehensionDefinitionNodeRef { target, .. }) => target.into(),
-            Self::Parameter(node) => match node {
-                ast::AnyParameterRef::Variadic(parameter) => parameter.into(),
-                ast::AnyParameterRef::NonVariadic(parameter) => parameter.into(),
-            },
+            Self::VariadicPositionalParameter(node) => node.into(),
+            Self::VariadicKeywordParameter(node) => node.into(),
+            Self::Parameter(node) => node.into(),
             Self::WithItem(WithItemDefinitionNodeRef {
                 node: _,
                 target,
@@ -434,14 +447,16 @@ 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>),
     AugmentedAssignment(AstNodeRef<ast::StmtAugAssign>),
     For(ForStmtDefinitionKind),
     Comprehension(ComprehensionDefinitionKind),
-    Parameter(AstNodeRef<ast::Parameter>),
-    ParameterWithDefault(AstNodeRef<ast::ParameterWithDefault>),
+    VariadicPositionalParameter(AstNodeRef<ast::Parameter>),
+    VariadicKeywordParameter(AstNodeRef<ast::Parameter>),
+    Parameter(AstNodeRef<ast::ParameterWithDefault>),
     WithItem(WithItemDefinitionKind),
     MatchPattern(MatchPatternDefinitionKind),
     ExceptHandler(ExceptHandlerDefinitionKind),
@@ -456,13 +471,15 @@ 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(_)
             | DefinitionKind::ParamSpec(_)
             | DefinitionKind::TypeVarTuple(_) => DefinitionCategory::DeclarationAndBinding,
             // a parameter always binds a value, but is only a declaration if annotated
-            DefinitionKind::Parameter(parameter) => {
+            DefinitionKind::VariadicPositionalParameter(parameter)
+            | DefinitionKind::VariadicKeywordParameter(parameter) => {
                 if parameter.annotation.is_some() {
                     DefinitionCategory::DeclarationAndBinding
                 } else {
@@ -470,7 +487,7 @@ impl DefinitionKind<'_> {
                 }
             }
             // presence of a default is irrelevant, same logic as for a no-default parameter
-            DefinitionKind::ParameterWithDefault(parameter_with_default) => {
+            DefinitionKind::Parameter(parameter_with_default) => {
                 if parameter_with_default.parameter.annotation.is_some() {
                     DefinitionCategory::DeclarationAndBinding
                 } else {
@@ -682,6 +699,12 @@ impl From<&ast::StmtClassDef> for DefinitionNodeKey {
     }
 }
 
+impl From<&ast::StmtTypeAlias> for DefinitionNodeKey {
+    fn from(node: &ast::StmtTypeAlias) -> Self {
+        Self(NodeKey::from_node(node))
+    }
+}
+
 impl From<&ast::ExprName> for DefinitionNodeKey {
     fn from(node: &ast::ExprName) -> Self {
         Self(NodeKey::from_node(node))
@@ -724,6 +747,15 @@ impl From<&ast::ParameterWithDefault> for DefinitionNodeKey {
     }
 }
 
+impl From<ast::AnyParameterRef<'_>> for DefinitionNodeKey {
+    fn from(value: ast::AnyParameterRef) -> Self {
+        Self(match value {
+            ast::AnyParameterRef::Variadic(node) => NodeKey::from_node(node),
+            ast::AnyParameterRef::NonVariadic(node) => NodeKey::from_node(node),
+        })
+    }
+}
+
 impl From<&ast::Identifier> for DefinitionNodeKey {
     fn from(identifier: &ast::Identifier) -> Self {
         Self(NodeKey::from_node(identifier))

crates/red_knot_python_semantic/src/semantic_index/symbol.rs

@@ -116,14 +116,11 @@ impl<'db> ScopeId<'db> {
         // Type parameter scopes behave like function scopes in terms of name resolution; CPython
         // symbol table also uses the term "function-like" for these scopes.
         matches!(
-            self.node(db),
-            NodeWithScopeKind::ClassTypeParameters(_)
-                | NodeWithScopeKind::FunctionTypeParameters(_)
-                | NodeWithScopeKind::Function(_)
-                | NodeWithScopeKind::ListComprehension(_)
-                | NodeWithScopeKind::SetComprehension(_)
-                | NodeWithScopeKind::DictComprehension(_)
-                | NodeWithScopeKind::GeneratorExpression(_)
+            self.node(db).scope_kind(),
+            ScopeKind::Annotation
+                | ScopeKind::Function
+                | ScopeKind::TypeAlias
+                | ScopeKind::Comprehension
         )
     }
 
@@ -144,6 +141,12 @@ impl<'db> ScopeId<'db> {
             }
             NodeWithScopeKind::Function(function)
             | NodeWithScopeKind::FunctionTypeParameters(function) => function.name.as_str(),
+            NodeWithScopeKind::TypeAlias(type_alias)
+            | NodeWithScopeKind::TypeAliasTypeParameters(type_alias) => type_alias
+                .name
+                .as_name_expr()
+                .map(|name| name.id.as_str())
+                .unwrap_or("<type alias>"),
             NodeWithScopeKind::Lambda(_) => "<lambda>",
             NodeWithScopeKind::ListComprehension(_) => "<listcomp>",
             NodeWithScopeKind::SetComprehension(_) => "<setcomp>",
@@ -201,6 +204,7 @@ pub enum ScopeKind {
     Class,
     Function,
     Comprehension,
+    TypeAlias,
 }
 
 impl ScopeKind {
@@ -326,6 +330,8 @@ pub(crate) enum NodeWithScopeRef<'a> {
     Lambda(&'a ast::ExprLambda),
     FunctionTypeParameters(&'a ast::StmtFunctionDef),
     ClassTypeParameters(&'a ast::StmtClassDef),
+    TypeAlias(&'a ast::StmtTypeAlias),
+    TypeAliasTypeParameters(&'a ast::StmtTypeAlias),
     ListComprehension(&'a ast::ExprListComp),
     SetComprehension(&'a ast::ExprSetComp),
     DictComprehension(&'a ast::ExprDictComp),
@@ -347,6 +353,12 @@ impl NodeWithScopeRef<'_> {
             NodeWithScopeRef::Function(function) => {
                 NodeWithScopeKind::Function(AstNodeRef::new(module, function))
             }
+            NodeWithScopeRef::TypeAlias(type_alias) => {
+                NodeWithScopeKind::TypeAlias(AstNodeRef::new(module, type_alias))
+            }
+            NodeWithScopeRef::TypeAliasTypeParameters(type_alias) => {
+                NodeWithScopeKind::TypeAliasTypeParameters(AstNodeRef::new(module, type_alias))
+            }
             NodeWithScopeRef::Lambda(lambda) => {
                 NodeWithScopeKind::Lambda(AstNodeRef::new(module, lambda))
             }
@@ -387,6 +399,12 @@ impl NodeWithScopeRef<'_> {
             NodeWithScopeRef::ClassTypeParameters(class) => {
                 NodeWithScopeKey::ClassTypeParameters(NodeKey::from_node(class))
             }
+            NodeWithScopeRef::TypeAlias(type_alias) => {
+                NodeWithScopeKey::TypeAlias(NodeKey::from_node(type_alias))
+            }
+            NodeWithScopeRef::TypeAliasTypeParameters(type_alias) => {
+                NodeWithScopeKey::TypeAliasTypeParameters(NodeKey::from_node(type_alias))
+            }
             NodeWithScopeRef::ListComprehension(comprehension) => {
                 NodeWithScopeKey::ListComprehension(NodeKey::from_node(comprehension))
             }
@@ -411,6 +429,8 @@ pub enum NodeWithScopeKind {
     ClassTypeParameters(AstNodeRef<ast::StmtClassDef>),
     Function(AstNodeRef<ast::StmtFunctionDef>),
     FunctionTypeParameters(AstNodeRef<ast::StmtFunctionDef>),
+    TypeAliasTypeParameters(AstNodeRef<ast::StmtTypeAlias>),
+    TypeAlias(AstNodeRef<ast::StmtTypeAlias>),
     Lambda(AstNodeRef<ast::ExprLambda>),
     ListComprehension(AstNodeRef<ast::ExprListComp>),
     SetComprehension(AstNodeRef<ast::ExprSetComp>),
@@ -423,9 +443,11 @@ impl NodeWithScopeKind {
         match self {
             Self::Module => ScopeKind::Module,
             Self::Class(_) => ScopeKind::Class,
-            Self::Function(_) => ScopeKind::Function,
-            Self::Lambda(_) => ScopeKind::Function,
-            Self::FunctionTypeParameters(_) | Self::ClassTypeParameters(_) => ScopeKind::Annotation,
+            Self::Function(_) | Self::Lambda(_) => ScopeKind::Function,
+            Self::FunctionTypeParameters(_)
+            | Self::ClassTypeParameters(_)
+            | Self::TypeAliasTypeParameters(_) => ScopeKind::Annotation,
+            Self::TypeAlias(_) => ScopeKind::TypeAlias,
             Self::ListComprehension(_)
             | Self::SetComprehension(_)
             | Self::DictComprehension(_)
@@ -446,6 +468,13 @@ impl NodeWithScopeKind {
             _ => panic!("expected function"),
         }
     }
+
+    pub fn expect_type_alias(&self) -> &ast::StmtTypeAlias {
+        match self {
+            Self::TypeAlias(type_alias) => type_alias.node(),
+            _ => panic!("expected type alias"),
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
@@ -455,6 +484,8 @@ pub(crate) enum NodeWithScopeKey {
     ClassTypeParameters(NodeKey),
     Function(NodeKey),
     FunctionTypeParameters(NodeKey),
+    TypeAlias(NodeKey),
+    TypeAliasTypeParameters(NodeKey),
     Lambda(NodeKey),
     ListComprehension(NodeKey),
     SetComprehension(NodeKey),

crates/red_knot_python_semantic/src/semantic_index/use_def.rs

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

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

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

crates/red_knot_python_semantic/src/semantic_model.rs

@@ -166,31 +166,15 @@ impl_binding_has_ty!(ast::ParameterWithDefault);
 mod tests {
     use ruff_db::files::system_path_to_file;
     use ruff_db::parsed::parsed_module;
-    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
 
-    use crate::db::tests::TestDb;
-    use crate::program::{Program, SearchPathSettings};
-    use crate::python_version::PythonVersion;
-    use crate::{HasTy, ProgramSettings, SemanticModel};
-
-    fn setup_db<'a>(files: impl IntoIterator<Item = (&'a str, &'a str)>) -> anyhow::Result<TestDb> {
-        let mut db = TestDb::new();
-        db.write_files(files)?;
-
-        Program::from_settings(
-            &db,
-            &ProgramSettings {
-                target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(SystemPathBuf::from("/src")),
-            },
-        )?;
-
-        Ok(db)
-    }
+    use crate::db::tests::TestDbBuilder;
+    use crate::{HasTy, SemanticModel};
 
     #[test]
     fn function_ty() -> anyhow::Result<()> {
-        let db = setup_db([("/src/foo.py", "def test(): pass")])?;
+        let db = TestDbBuilder::new()
+            .with_file("/src/foo.py", "def test(): pass")
+            .build()?;
 
         let foo = system_path_to_file(&db, "/src/foo.py").unwrap();
 
@@ -207,7 +191,9 @@ mod tests {
 
     #[test]
     fn class_ty() -> anyhow::Result<()> {
-        let db = setup_db([("/src/foo.py", "class Test: pass")])?;
+        let db = TestDbBuilder::new()
+            .with_file("/src/foo.py", "class Test: pass")
+            .build()?;
 
         let foo = system_path_to_file(&db, "/src/foo.py").unwrap();
 
@@ -224,10 +210,10 @@ mod tests {
 
     #[test]
     fn alias_ty() -> anyhow::Result<()> {
-        let db = setup_db([
-            ("/src/foo.py", "class Test: pass"),
-            ("/src/bar.py", "from foo import Test"),
-        ])?;
+        let db = TestDbBuilder::new()
+            .with_file("/src/foo.py", "class Test: pass")
+            .with_file("/src/bar.py", "from foo import Test")
+            .build()?;
 
         let bar = system_path_to_file(&db, "/src/bar.py").unwrap();
 

crates/red_knot_python_semantic/src/symbol.rs

@@ -90,7 +90,7 @@ impl<'db> Symbol<'db> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::tests::setup_db;
+    use crate::db::tests::setup_db;
 
     #[test]
     fn test_symbol_or_fall_back_to() {

crates/red_knot_python_semantic/src/types/builder.rs

@@ -73,7 +73,8 @@ impl<'db> UnionBuilder<'db> {
                         // supertype of bool. Therefore, we are done.
                         break;
                     }
-                    if ty.is_subtype_of(self.db, *element) {
+
+                    if ty.is_same_gradual_form(*element) || ty.is_subtype_of(self.db, *element) {
                         return self;
                     } else if element.is_subtype_of(self.db, ty) {
                         to_remove.push(index);
@@ -259,7 +260,9 @@ impl<'db> InnerIntersectionBuilder<'db> {
             let mut to_remove = SmallVec::<[usize; 1]>::new();
             for (index, existing_positive) in self.positive.iter().enumerate() {
                 // S & T = S    if S <: T
-                if existing_positive.is_subtype_of(db, new_positive) {
+                if existing_positive.is_subtype_of(db, new_positive)
+                    || existing_positive.is_same_gradual_form(new_positive)
+                {
                     return;
                 }
                 // same rule, reverse order
@@ -309,7 +312,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.
@@ -375,36 +378,14 @@ impl<'db> InnerIntersectionBuilder<'db> {
 #[cfg(test)]
 mod tests {
     use super::{IntersectionBuilder, IntersectionType, Type, UnionType};
-    use crate::db::tests::TestDb;
-    use crate::program::{Program, SearchPathSettings};
-    use crate::python_version::PythonVersion;
-    use crate::stdlib::typing_symbol;
-    use crate::types::{global_symbol, KnownClass, UnionBuilder};
-    use crate::ProgramSettings;
+
+    use crate::db::tests::{setup_db, TestDb};
+    use crate::types::{global_symbol, todo_type, KnownClass, UnionBuilder};
+
     use ruff_db::files::system_path_to_file;
-    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
+    use ruff_db::system::DbWithTestSystem;
     use test_case::test_case;
 
-    fn setup_db() -> TestDb {
-        let db = TestDb::new();
-
-        let src_root = SystemPathBuf::from("/src");
-        db.memory_file_system()
-            .create_directory_all(&src_root)
-            .unwrap();
-
-        Program::from_settings(
-            &db,
-            &ProgramSettings {
-                target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(src_root),
-            },
-        )
-        .expect("Valid search path settings");
-
-        db
-    }
-
     #[test]
     fn build_union() {
         let db = setup_db();
@@ -497,6 +478,17 @@ mod tests {
         assert_eq!(u1.expect_union().elements(&db), &[t1, t0]);
     }
 
+    #[test]
+    fn build_union_simplify_multiple_unknown() {
+        let db = setup_db();
+        let t0 = KnownClass::Str.to_instance(&db);
+        let t1 = Type::Unknown;
+
+        let u = UnionType::from_elements(&db, [t0, t1, t1]);
+
+        assert_eq!(u.expect_union().elements(&db), &[t0, t1]);
+    }
+
     #[test]
     fn build_union_subsume_multiple() {
         let db = setup_db();
@@ -604,6 +596,42 @@ mod tests {
         assert_eq!(ty, Type::Never);
     }
 
+    #[test]
+    fn build_intersection_simplify_multiple_unknown() {
+        let db = setup_db();
+
+        let ty = IntersectionBuilder::new(&db)
+            .add_positive(Type::Unknown)
+            .add_positive(Type::Unknown)
+            .build();
+        assert_eq!(ty, Type::Unknown);
+
+        let ty = IntersectionBuilder::new(&db)
+            .add_positive(Type::Unknown)
+            .add_negative(Type::Unknown)
+            .build();
+        assert_eq!(ty, Type::Unknown);
+
+        let ty = IntersectionBuilder::new(&db)
+            .add_negative(Type::Unknown)
+            .add_negative(Type::Unknown)
+            .build();
+        assert_eq!(ty, Type::Unknown);
+
+        let ty = IntersectionBuilder::new(&db)
+            .add_positive(Type::Unknown)
+            .add_positive(Type::IntLiteral(0))
+            .add_negative(Type::Unknown)
+            .build();
+        assert_eq!(
+            ty,
+            IntersectionBuilder::new(&db)
+                .add_positive(Type::Unknown)
+                .add_positive(Type::IntLiteral(0))
+                .build()
+        );
+    }
+
     #[test]
     fn intersection_distributes_over_union() {
         let db = setup_db();
@@ -626,59 +654,85 @@ mod tests {
 
     #[test]
     fn intersection_negation_distributes_over_union() {
-        let db = setup_db();
-        let st = typing_symbol(&db, "Sized").expect_type().to_instance(&db);
-        let ht = typing_symbol(&db, "Hashable")
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/module.py",
+            r#"
+            class A: ...
+            class B: ...
+            "#,
+        )
+        .unwrap();
+        let module = ruff_db::files::system_path_to_file(&db, "/src/module.py").unwrap();
+
+        let a = global_symbol(&db, module, "A")
             .expect_type()
             .to_instance(&db);
-        // sh_t: Sized & Hashable
-        let sh_t = IntersectionBuilder::new(&db)
-            .add_positive(st)
-            .add_positive(ht)
+        let b = global_symbol(&db, module, "B")
+            .expect_type()
+            .to_instance(&db);
+
+        // intersection: A & B
+        let intersection = IntersectionBuilder::new(&db)
+            .add_positive(a)
+            .add_positive(b)
             .build()
             .expect_intersection();
-        assert_eq!(sh_t.pos_vec(&db), &[st, ht]);
-        assert_eq!(sh_t.neg_vec(&db), &[]);
+        assert_eq!(intersection.pos_vec(&db), &[a, b]);
+        assert_eq!(intersection.neg_vec(&db), &[]);
 
-        // ~sh_t => ~Sized | ~Hashable
-        let not_s_h_t = IntersectionBuilder::new(&db)
-            .add_negative(Type::Intersection(sh_t))
+        // ~intersection => ~A | ~B
+        let negated_intersection = IntersectionBuilder::new(&db)
+            .add_negative(Type::Intersection(intersection))
             .build()
             .expect_union();
 
-        // should have as elements: (~Sized),(~Hashable)
-        let not_st = st.negate(&db);
-        let not_ht = ht.negate(&db);
-        assert_eq!(not_s_h_t.elements(&db), &[not_st, not_ht]);
+        // should have as elements ~A and ~B
+        let not_a = a.negate(&db);
+        let not_b = b.negate(&db);
+        assert_eq!(negated_intersection.elements(&db), &[not_a, not_b]);
     }
 
     #[test]
     fn mixed_intersection_negation_distributes_over_union() {
-        let db = setup_db();
-        let it = KnownClass::Int.to_instance(&db);
-        let st = typing_symbol(&db, "Sized").expect_type().to_instance(&db);
-        let ht = typing_symbol(&db, "Hashable")
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/module.py",
+            r#"
+            class A: ...
+            class B: ...
+            "#,
+        )
+        .unwrap();
+        let module = ruff_db::files::system_path_to_file(&db, "/src/module.py").unwrap();
+
+        let a = global_symbol(&db, module, "A")
             .expect_type()
             .to_instance(&db);
-        // s_not_h_t: Sized & ~Hashable
-        let s_not_h_t = IntersectionBuilder::new(&db)
-            .add_positive(st)
-            .add_negative(ht)
+        let b = global_symbol(&db, module, "B")
+            .expect_type()
+            .to_instance(&db);
+        let int = KnownClass::Int.to_instance(&db);
+
+        // a_not_b: A & ~B
+        let a_not_b = IntersectionBuilder::new(&db)
+            .add_positive(a)
+            .add_negative(b)
             .build()
             .expect_intersection();
-        assert_eq!(s_not_h_t.pos_vec(&db), &[st]);
-        assert_eq!(s_not_h_t.neg_vec(&db), &[ht]);
+        assert_eq!(a_not_b.pos_vec(&db), &[a]);
+        assert_eq!(a_not_b.neg_vec(&db), &[b]);
 
-        // let's build int & ~(Sized & ~Hashable)
-        let tt = IntersectionBuilder::new(&db)
-            .add_positive(it)
-            .add_negative(Type::Intersection(s_not_h_t))
+        // let's build
+        //         int & ~(A & ~B)
+        //       = int & ~(A & ~B)
+        //       = int & (~A | B)
+        //       = (int & ~A) | (int & B)
+        let t = IntersectionBuilder::new(&db)
+            .add_positive(int)
+            .add_negative(Type::Intersection(a_not_b))
             .build();
-
-        // int & ~(Sized & ~Hashable)
-        // -> int & (~Sized | Hashable)
-        // -> (int & ~Sized) | (int & Hashable)
-        assert_eq!(tt.display(&db).to_string(), "int & ~Sized | int & Hashable");
+        assert_eq!(t.display(&db).to_string(), "int & ~A | int & B");
     }
 
     #[test]
@@ -987,7 +1041,7 @@ mod tests {
 
     #[test_case(Type::Any)]
     #[test_case(Type::Unknown)]
-    #[test_case(Type::Todo)]
+    #[test_case(todo_type!())]
     fn build_intersection_t_and_negative_t_does_not_simplify(ty: Type) {
         let db = setup_db();
 

crates/red_knot_python_semantic/src/types/diagnostic.rs

@@ -1,6 +1,12 @@
+use crate::lint::{Level, LintId, LintMetadata, LintRegistryBuilder, LintStatus};
+use crate::types::string_annotation::{
+    BYTE_STRING_TYPE_ANNOTATION, ESCAPE_CHARACTER_IN_FORWARD_ANNOTATION, FSTRING_TYPE_ANNOTATION,
+    IMPLICIT_CONCATENATED_STRING_TYPE_ANNOTATION, INVALID_SYNTAX_IN_FORWARD_ANNOTATION,
+    RAW_STRING_TYPE_ANNOTATION,
+};
 use crate::types::{ClassLiteralType, Type};
-use crate::Db;
-use ruff_db::diagnostic::{Diagnostic, Severity};
+use crate::{declare_lint, Db};
+use ruff_db::diagnostic::{Diagnostic, DiagnosticId, Severity};
 use ruff_db::files::File;
 use ruff_python_ast::{self as ast, AnyNodeRef};
 use ruff_text_size::{Ranged, TextRange};
@@ -9,18 +15,411 @@ use std::fmt::Formatter;
 use std::ops::Deref;
 use std::sync::Arc;
 
+/// Registers all known type check lints.
+pub(crate) fn register_type_lints(registry: &mut LintRegistryBuilder) {
+    registry.register_lint(&UNRESOLVED_REFERENCE);
+    registry.register_lint(&POSSIBLY_UNRESOLVED_REFERENCE);
+    registry.register_lint(&NOT_ITERABLE);
+    registry.register_lint(&INDEX_OUT_OF_BOUNDS);
+    registry.register_lint(&NON_SUBSCRIPTABLE);
+    registry.register_lint(&UNRESOLVED_IMPORT);
+    registry.register_lint(&POSSIBLY_UNBOUND_IMPORT);
+    registry.register_lint(&ZERO_STEPSIZE_IN_SLICE);
+    registry.register_lint(&INVALID_ASSIGNMENT);
+    registry.register_lint(&INVALID_DECLARATION);
+    registry.register_lint(&CONFLICTING_DECLARATIONS);
+    registry.register_lint(&DIVISION_BY_ZERO);
+    registry.register_lint(&CALL_NON_CALLABLE);
+    registry.register_lint(&INVALID_TYPE_PARAMETER);
+    registry.register_lint(&INVALID_TYPE_VARIABLE_CONSTRAINTS);
+    registry.register_lint(&CYCLIC_CLASS_DEFINITION);
+    registry.register_lint(&DUPLICATE_BASE);
+    registry.register_lint(&INVALID_BASE);
+    registry.register_lint(&INCONSISTENT_MRO);
+    registry.register_lint(&INVALID_LITERAL_PARAMETER);
+    registry.register_lint(&CALL_POSSIBLY_UNBOUND_METHOD);
+    registry.register_lint(&POSSIBLY_UNBOUND_ATTRIBUTE);
+    registry.register_lint(&UNRESOLVED_ATTRIBUTE);
+    registry.register_lint(&CONFLICTING_METACLASS);
+    registry.register_lint(&UNSUPPORTED_OPERATOR);
+    registry.register_lint(&INVALID_CONTEXT_MANAGER);
+    registry.register_lint(&UNDEFINED_REVEAL);
+    registry.register_lint(&INVALID_PARAMETER_DEFAULT);
+    registry.register_lint(&INVALID_TYPE_FORM);
+
+    // String annotations
+    registry.register_lint(&FSTRING_TYPE_ANNOTATION);
+    registry.register_lint(&BYTE_STRING_TYPE_ANNOTATION);
+    registry.register_lint(&RAW_STRING_TYPE_ANNOTATION);
+    registry.register_lint(&IMPLICIT_CONCATENATED_STRING_TYPE_ANNOTATION);
+    registry.register_lint(&INVALID_SYNTAX_IN_FORWARD_ANNOTATION);
+    registry.register_lint(&ESCAPE_CHARACTER_IN_FORWARD_ANNOTATION);
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for references to names that are not defined.
+    ///
+    /// ## Why is this bad?
+    /// Using an undefined variable will raise a `NameError` at runtime.
+    ///
+    /// ## Example
+    ///
+    /// ```python
+    /// print(x)  # NameError: name 'x' is not defined
+    /// ```
+    pub(crate) static UNRESOLVED_REFERENCE = {
+        summary: "detects references to names that are not defined",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Warn,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for references to names that are possibly not defined..
+    ///
+    /// ## Why is this bad?
+    /// Using an undefined variable will raise a `NameError` at runtime.
+    ///
+    /// ## Example
+    ///
+    /// ```python
+    /// for i in range(0):
+    ///     x = i
+    ///
+    /// print(x)  # NameError: name 'x' is not defined
+    /// ```
+    pub(crate) static POSSIBLY_UNRESOLVED_REFERENCE = {
+        summary: "detects references to possibly unresolved references",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Warn,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for objects that are not iterable but are used in a context that requires them to be.
+    ///
+    /// ## Why is this bad?
+    /// Iterating over an object that is not iterable will raise a `TypeError` at runtime.
+    ///
+    /// ## Examples
+    ///
+    /// ```python
+    /// for i in 34:  # TypeError: 'int' object is not iterable
+    ///     pass
+    /// ```
+    pub(crate) static NOT_ITERABLE = {
+        summary: "detects objects that are not iterable",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// TODO
+    pub(crate) static INDEX_OUT_OF_BOUNDS = {
+        summary: "detects index out of bounds errors",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for objects that do not support subscripting but are used in a context that requires them to be.
+    ///
+    /// ## Why is this bad?
+    /// Subscripting an object that does not support it will raise a `TypeError` at runtime.
+    ///
+    /// ## Examples
+    /// ```python
+    /// 4[1]  # TypeError: 'int' object is not subscriptable
+    /// ```
+    pub(crate) static NON_SUBSCRIPTABLE = {
+        summary: "detects objects that do not support subscripting",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for import statements for which the module cannot be resolved.
+    ///
+    /// ## Why is this bad?
+    /// Importing a module that cannot be resolved will raise an `ImportError` at runtime.
+    pub(crate) static UNRESOLVED_IMPORT = {
+        summary: "detects unresolved imports",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static POSSIBLY_UNBOUND_IMPORT = {
+        summary: "detects possibly unbound imports",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Warn,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for step size 0 in slices.
+    ///
+    /// ## Why is this bad?
+    /// A slice with a step size of zero will raise a `ValueError` at runtime.
+    ///
+    /// ## Examples
+    /// ```python
+    ///  l = list(range(10))
+    /// l[1:10:0]  # ValueError: slice step cannot be zero
+    pub(crate) static ZERO_STEPSIZE_IN_SLICE = {
+        summary: "detects a slice step size of zero",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static INVALID_ASSIGNMENT = {
+        summary: "detects invalid assignments",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static INVALID_DECLARATION = {
+        summary: "detects invalid declarations",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static CONFLICTING_DECLARATIONS = {
+        summary: "detects conflicting declarations",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// It detects division by zero.
+    ///
+    /// ## Why is this bad?
+    /// Dividing by zero raises a `ZeroDivisionError` at runtime.
+    ///
+    /// ## Examples
+    /// ```python
+    /// 5 / 0
+    /// ```
+    pub(crate) static DIVISION_BY_ZERO = {
+        summary: "detects division by zero",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for calls to non-callable objects.
+    ///
+    /// ## Why is this bad?
+    /// Calling a non-callable object will raise a `TypeError` at runtime.
+    ///
+    /// ## Examples
+    /// ```python
+    /// 4()  # TypeError: 'int' object is not callable
+    /// ```
+    pub(crate) static CALL_NON_CALLABLE = {
+        summary: "detects calls to non-callable objects",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// TODO
+    pub(crate) static INVALID_TYPE_PARAMETER = {
+        summary: "detects invalid type parameters",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static INVALID_TYPE_VARIABLE_CONSTRAINTS = {
+        summary: "detects invalid type variable constraints",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for class definitions with a cyclic inheritance chain.
+    ///
+    /// ## Why is it bad?
+    /// TODO
+    pub(crate) static CYCLIC_CLASS_DEFINITION = {
+        summary: "detects cyclic class definitions",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static DUPLICATE_BASE = {
+        summary: "detects class definitions with duplicate bases",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static INVALID_BASE = {
+        summary: "detects class definitions with an invalid base",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static INCONSISTENT_MRO = {
+        summary: "detects class definitions with an inconsistent MRO",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for invalid parameters to `typing.Literal`.
+    pub(crate) static INVALID_LITERAL_PARAMETER = {
+        summary: "detects invalid literal parameters",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for calls to possibly unbound methods.
+    pub(crate) static CALL_POSSIBLY_UNBOUND_METHOD = {
+        summary: "detects calls to possibly unbound methods",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Warn,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for possibly unbound attributes.
+    pub(crate) static POSSIBLY_UNBOUND_ATTRIBUTE = {
+        summary: "detects references to possibly unbound attributes",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Warn,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for unresolved attributes.
+    pub(crate) static UNRESOLVED_ATTRIBUTE = {
+        summary: "detects references to unresolved attributes",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static CONFLICTING_METACLASS = {
+        summary: "detects conflicting metaclasses",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for binary expressions, comparisons, and unary expressions where the operands don't support the operator.
+    pub(crate) static UNSUPPORTED_OPERATOR = {
+        summary: "detects binary expressions where the operands don't support the operator",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static INVALID_CONTEXT_MANAGER = {
+        summary: "detects expressions used in with statements that don't implement the context manager protocol",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for calls to `reveal_type` without importing it.
+    ///
+    /// ## Why is this bad?
+    /// Using `reveal_type` without importing it will raise a `NameError` at runtime.
+    pub(crate) static UNDEFINED_REVEAL = {
+        summary: "detects usages of `reveal_type` without importing it",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Warn,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for default values that can't be assigned to the parameter's annotated type.
+    pub(crate) static INVALID_PARAMETER_DEFAULT = {
+        summary: "detects default values that can't be assigned to the parameter's annotated type",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for `type[]` usages that have too many or too few type arguments.
+    pub(crate) static INVALID_TYPE_FORM = {
+        summary: "detects invalid type forms",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub struct TypeCheckDiagnostic {
-    // TODO: Don't use string keys for rules
-    pub(super) rule: String,
+    pub(super) id: DiagnosticId,
     pub(super) message: String,
     pub(super) range: TextRange,
+    pub(super) severity: Severity,
     pub(super) file: File,
 }
 
 impl TypeCheckDiagnostic {
-    pub fn rule(&self) -> &str {
-        &self.rule
+    pub fn id(&self) -> DiagnosticId {
+        self.id
     }
 
     pub fn message(&self) -> &str {
@@ -33,8 +432,8 @@ impl TypeCheckDiagnostic {
 }
 
 impl Diagnostic for TypeCheckDiagnostic {
-    fn rule(&self) -> &str {
-        TypeCheckDiagnostic::rule(self)
+    fn id(&self) -> DiagnosticId {
+        self.id
     }
 
     fn message(&self) -> Cow<str> {
@@ -50,7 +449,7 @@ impl Diagnostic for TypeCheckDiagnostic {
     }
 
     fn severity(&self) -> Severity {
-        Severity::Error
+        self.severity
     }
 }
 
@@ -150,9 +549,9 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
 
     /// 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(
+        self.add_lint(
+            &NOT_ITERABLE,
             node,
-            "not-iterable",
             format_args!(
                 "Object of type `{}` is not iterable",
                 not_iterable_ty.display(self.db)
@@ -167,9 +566,9 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
         node: AnyNodeRef,
         element_ty: Type<'db>,
     ) {
-        self.add(
+        self.add_lint(
+            &NOT_ITERABLE,
             node,
-            "not-iterable",
             format_args!(
                 "Object of type `{}` is not iterable because its `__iter__` method is possibly unbound",
                 element_ty.display(self.db)
@@ -186,9 +585,9 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
         length: usize,
         index: i64,
     ) {
-        self.add(
+        self.add_lint(
+            &INDEX_OUT_OF_BOUNDS,
             node,
-            "index-out-of-bounds",
             format_args!(
                 "Index {index} is out of bounds for {kind} `{}` with length {length}",
                 tuple_ty.display(self.db)
@@ -203,9 +602,9 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
         non_subscriptable_ty: Type<'db>,
         method: &str,
     ) {
-        self.add(
+        self.add_lint(
+            &NON_SUBSCRIPTABLE,
             node,
-            "non-subscriptable",
             format_args!(
                 "Cannot subscript object of type `{}` with no `{method}` method",
                 non_subscriptable_ty.display(self.db)
@@ -219,9 +618,9 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
         level: u32,
         module: Option<&str>,
     ) {
-        self.add(
+        self.add_lint(
+            &UNRESOLVED_IMPORT,
             import_node.into(),
-            "unresolved-import",
             format_args!(
                 "Cannot resolve import `{}{}`",
                 ".".repeat(level as usize),
@@ -231,9 +630,9 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
     }
 
     pub(super) fn add_slice_step_size_zero(&mut self, node: AnyNodeRef) {
-        self.add(
+        self.add_lint(
+            &ZERO_STEPSIZE_IN_SLICE,
             node,
-            "zero-stepsize-in-slice",
             format_args!("Slice step size can not be zero"),
         );
     }
@@ -246,19 +645,19 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
     ) {
         match declared_ty {
             Type::ClassLiteral(ClassLiteralType { class }) => {
-                self.add(node, "invalid-assignment", format_args!(
+                self.add_lint(&INVALID_ASSIGNMENT, node, format_args!(
                         "Implicit shadowing of class `{}`; annotate to make it explicit if this is intentional",
                         class.name(self.db)));
             }
             Type::FunctionLiteral(function) => {
-                self.add(node, "invalid-assignment", format_args!(
+                self.add_lint(&INVALID_ASSIGNMENT, node, format_args!(
                         "Implicit shadowing of function `{}`; annotate to make it explicit if this is intentional",
                         function.name(self.db)));
             }
             _ => {
-                self.add(
+                self.add_lint(
+                    &INVALID_ASSIGNMENT,
                     node,
-                    "invalid-assignment",
                     format_args!(
                         "Object of type `{}` is not assignable to `{}`",
                         assigned_ty.display(self.db),
@@ -272,9 +671,9 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
     pub(super) fn add_possibly_unresolved_reference(&mut self, expr_name_node: &ast::ExprName) {
         let ast::ExprName { id, .. } = expr_name_node;
 
-        self.add(
+        self.add_lint(
+            &POSSIBLY_UNRESOLVED_REFERENCE,
             expr_name_node.into(),
-            "possibly-unresolved-reference",
             format_args!("Name `{id}` used when possibly not defined"),
         );
     }
@@ -282,17 +681,37 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
     pub(super) fn add_unresolved_reference(&mut self, expr_name_node: &ast::ExprName) {
         let ast::ExprName { id, .. } = expr_name_node;
 
-        self.add(
+        self.add_lint(
+            &UNRESOLVED_REFERENCE,
             expr_name_node.into(),
-            "unresolved-reference",
             format_args!("Name `{id}` used when not defined"),
         );
     }
 
+    pub(super) fn add_lint(
+        &mut self,
+        lint: &'static LintMetadata,
+        node: AnyNodeRef,
+        message: std::fmt::Arguments,
+    ) {
+        // Skip over diagnostics if the rule is disabled.
+        let Some(severity) = self.db.rule_selection().severity(LintId::of(lint)) else {
+            return;
+        };
+
+        self.add(node, DiagnosticId::Lint(lint.name()), severity, message);
+    }
+
     /// Adds a new diagnostic.
     ///
     /// The diagnostic does not get added if the rule isn't enabled for this file.
-    pub(super) fn add(&mut self, node: AnyNodeRef, rule: &str, message: std::fmt::Arguments) {
+    pub(super) fn add(
+        &mut self,
+        node: AnyNodeRef,
+        id: DiagnosticId,
+        severity: Severity,
+        message: std::fmt::Arguments,
+    ) {
         if !self.db.is_file_open(self.file) {
             return;
         }
@@ -305,9 +724,10 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
 
         self.diagnostics.push(TypeCheckDiagnostic {
             file: self.file,
-            rule: rule.to_string(),
+            id,
             message: message.to_string(),
             range: node.range(),
+            severity,
         });
     }
 

crates/red_knot_python_semantic/src/types/display.rs

@@ -77,7 +77,7 @@ impl Display for DisplayRepresentation<'_> {
             }
             // `[Type::Todo]`'s display should be explicit that is not a valid display of
             // any other type
-            Type::Todo => f.write_str("@Todo"),
+            Type::Todo(todo) => write!(f, "@Todo{todo}"),
             Type::ModuleLiteral(file) => {
                 write!(f, "<module '{:?}'>", file.path(self.db))
             }
@@ -289,7 +289,7 @@ struct DisplayMaybeNegatedType<'db> {
     negated: bool,
 }
 
-impl<'db> Display for DisplayMaybeNegatedType<'db> {
+impl Display for DisplayMaybeNegatedType<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         if self.negated {
             f.write_str("~")?;
@@ -319,7 +319,7 @@ pub(crate) struct DisplayTypeArray<'b, 'db> {
     db: &'db dyn Db,
 }
 
-impl<'db> Display for DisplayTypeArray<'_, 'db> {
+impl Display for DisplayTypeArray<'_, '_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.join(", ")
             .entries(self.types.iter().map(|ty| ty.display(self.db)))
@@ -357,31 +357,10 @@ impl Display for DisplayStringLiteralType<'_> {
 #[cfg(test)]
 mod tests {
     use ruff_db::files::system_path_to_file;
-    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
+    use ruff_db::system::DbWithTestSystem;
 
-    use crate::db::tests::TestDb;
+    use crate::db::tests::setup_db;
     use crate::types::{global_symbol, SliceLiteralType, StringLiteralType, Type, UnionType};
-    use crate::{Program, ProgramSettings, PythonVersion, SearchPathSettings};
-
-    fn setup_db() -> TestDb {
-        let db = TestDb::new();
-
-        let src_root = SystemPathBuf::from("/src");
-        db.memory_file_system()
-            .create_directory_all(&src_root)
-            .unwrap();
-
-        Program::from_settings(
-            &db,
-            &ProgramSettings {
-                target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(src_root),
-            },
-        )
-        .expect("Valid search path settings");
-
-        db
-    }
 
     #[test]
     fn test_condense_literal_display_by_type() -> anyhow::Result<()> {

crates/red_knot_python_semantic/src/types/mro.rs

@@ -5,7 +5,7 @@ use itertools::Either;
 use rustc_hash::FxHashSet;
 
 use super::{Class, ClassLiteralType, KnownClass, KnownInstanceType, Type};
-use crate::Db;
+use crate::{types::todo_type, Db};
 
 /// The inferred method resolution order of a given class.
 ///
@@ -328,15 +328,6 @@ impl<'db> ClassBase<'db> {
         Display { base: self, db }
     }
 
-    #[cfg(test)]
-    #[track_caller]
-    pub(super) fn expect_class_base(self) -> Class<'db> {
-        match self {
-            ClassBase::Class(class) => class,
-            _ => panic!("Expected a `ClassBase::Class()` variant"),
-        }
-    }
-
     /// Return a `ClassBase` representing the class `builtins.object`
     fn object(db: &'db dyn Db) -> Self {
         KnownClass::Object
@@ -354,7 +345,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,8 +363,14 @@ 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,
+                KnownInstanceType::Any => Some(Self::Any),
             },
         }
     }
@@ -401,11 +398,17 @@ impl<'db> ClassBase<'db> {
     }
 }
 
+impl<'db> From<Class<'db>> for ClassBase<'db> {
+    fn from(value: Class<'db>) -> Self {
+        ClassBase::Class(value)
+    }
+}
+
 impl<'db> From<ClassBase<'db>> for Type<'db> {
     fn from(value: ClassBase<'db>) -> Self {
         match value {
             ClassBase::Any => Type::Any,
-            ClassBase::Todo => Type::Todo,
+            ClassBase::Todo => todo_type!(),
             ClassBase::Unknown => Type::Unknown,
             ClassBase::Class(class) => Type::class_literal(class),
         }

crates/red_knot_python_semantic/src/types/narrow.rs

@@ -54,6 +54,7 @@ pub(crate) fn narrowing_constraint<'db>(
     }
 }
 
+#[allow(clippy::ref_option)]
 #[salsa::tracked(return_ref)]
 fn all_narrowing_constraints_for_pattern<'db>(
     db: &'db dyn Db,
@@ -62,6 +63,7 @@ fn all_narrowing_constraints_for_pattern<'db>(
     NarrowingConstraintsBuilder::new(db, ConstraintNode::Pattern(pattern), true).finish()
 }
 
+#[allow(clippy::ref_option)]
 #[salsa::tracked(return_ref)]
 fn all_narrowing_constraints_for_expression<'db>(
     db: &'db dyn Db,
@@ -70,6 +72,7 @@ fn all_narrowing_constraints_for_expression<'db>(
     NarrowingConstraintsBuilder::new(db, ConstraintNode::Expression(expression), true).finish()
 }
 
+#[allow(clippy::ref_option)]
 #[salsa::tracked(return_ref)]
 fn all_negative_narrowing_constraints_for_expression<'db>(
     db: &'db dyn Db,
@@ -291,8 +294,15 @@ 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 {
@@ -327,6 +337,9 @@ 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
                         }
@@ -385,46 +398,58 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
         let scope = self.scope();
         let inference = infer_expression_types(self.db, expression);
 
+        let callable_ty =
+            inference.expression_ty(expr_call.func.scoped_expression_id(self.db, scope));
+
         // TODO: add support for PEP 604 union types on the right hand side of `isinstance`
         // and `issubclass`, for example `isinstance(x, str | (int | float))`.
-        match inference
-            .expression_ty(expr_call.func.scoped_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] =
+        match callable_ty {
+            Type::FunctionLiteral(function_type) if expr_call.arguments.keywords.is_empty() => {
+                let function = function_type
+                    .known(self.db)
+                    .and_then(KnownFunction::constraint_function)?;
+
+                let [ast::Expr::Name(ast::ExprName { id, .. }), class_info] =
                     &*expr_call.arguments.args
-                {
-                    let symbol = self.symbols().symbol_id_by_name(id).unwrap();
+                else {
+                    return None;
+                };
 
-                    let class_info_ty =
-                        inference.expression_ty(class_info.scoped_expression_id(self.db, scope));
+                let symbol = self.symbols().symbol_id_by_name(id).unwrap();
 
-                    let to_constraint = match function {
-                        KnownConstraintFunction::IsInstance => {
-                            |class_literal: ClassLiteralType<'db>| {
-                                Type::instance(class_literal.class)
-                            }
+                let class_info_ty =
+                    inference.expression_ty(class_info.scoped_expression_id(self.db, scope));
+
+                let to_constraint = match function {
+                    KnownConstraintFunction::IsInstance => {
+                        |class_literal: ClassLiteralType<'db>| Type::instance(class_literal.class)
+                    }
+                    KnownConstraintFunction::IsSubclass => {
+                        |class_literal: ClassLiteralType<'db>| {
+                            Type::subclass_of(class_literal.class)
                         }
-                        KnownConstraintFunction::IsSubclass => {
-                            |class_literal: ClassLiteralType<'db>| {
-                                Type::subclass_of(class_literal.class)
-                            }
-                        }
-                    };
+                    }
+                };
 
-                    generate_classinfo_constraint(self.db, &class_info_ty, to_constraint).map(
-                        |constraint| {
-                            let mut constraints = NarrowingConstraints::default();
-                            constraints.insert(symbol, constraint.negate_if(self.db, !is_positive));
-                            constraints
-                        },
-                    )
-                } else {
-                    None
-                }
+                generate_classinfo_constraint(self.db, &class_info_ty, to_constraint).map(
+                    |constraint| {
+                        let mut constraints = NarrowingConstraints::default();
+                        constraints.insert(symbol, constraint.negate_if(self.db, !is_positive));
+                        constraints
+                    },
+                )
+            }
+            // for the expression `bool(E)`, we further narrow the type based on `E`
+            Type::ClassLiteral(class_type)
+                if expr_call.arguments.args.len() == 1
+                    && expr_call.arguments.keywords.is_empty()
+                    && class_type.class.is_known(self.db, KnownClass::Bool) =>
+            {
+                self.evaluate_expression_node_constraint(
+                    &expr_call.arguments.args[0],
+                    expression,
+                    is_positive,
+                )
             }
             _ => None,
         }

crates/red_knot_python_semantic/src/types/property_tests.rs

@@ -0,0 +1,243 @@
+//! 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::Ty;
+use crate::db::tests::{setup_db, 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)
+    );
+
+    // If `T` contains a gradual form, it should not participate in subtyping
+    type_property_test!(
+        non_fully_static_types_do_not_participate_in_subtyping, db,
+        forall types s, t. !s.is_fully_static(db) => !s.is_subtype_of(db, t) && !t.is_subtype_of(db, s)
+    );
+}
+
+/// 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: Type::Todo,
+            return_ty: todo_type!("return type"),
         }
     }
 
@@ -33,8 +33,7 @@ impl<'db> Signature<'db> {
             .as_ref()
             .map(|returns| {
                 if function_node.is_async {
-                    // TODO: generic `types.CoroutineType`!
-                    Type::Todo
+                    todo_type!("generic types.CoroutineType")
                 } else {
                     definition_expression_ty(db, definition, returns.as_ref())
                 }
@@ -81,11 +80,11 @@ impl<'db> Parameters<'db> {
         Self {
             variadic: Some(Parameter {
                 name: Some(Name::new_static("args")),
-                annotated_ty: Type::Todo,
+                annotated_ty: todo_type!(),
             }),
             keywords: Some(Parameter {
                 name: Some(Name::new_static("kwargs")),
-                annotated_ty: Type::Todo,
+                annotated_ty: todo_type!(),
             }),
             ..Default::default()
         }
@@ -190,32 +189,9 @@ impl<'db> Parameter<'db> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::db::tests::TestDb;
-    use crate::program::{Program, SearchPathSettings};
-    use crate::python_version::PythonVersion;
+    use crate::db::tests::{setup_db, TestDb};
     use crate::types::{global_symbol, FunctionType};
-    use crate::ProgramSettings;
-    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
-
-    pub(crate) fn setup_db() -> TestDb {
-        let db = TestDb::new();
-
-        let src_root = SystemPathBuf::from("/src");
-        db.memory_file_system()
-            .create_directory_all(&src_root)
-            .unwrap();
-
-        Program::from_settings(
-            &db,
-            &ProgramSettings {
-                target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(src_root),
-            },
-        )
-        .expect("Valid search path settings");
-
-        db
-    }
+    use ruff_db::system::DbWithTestSystem;
 
     #[track_caller]
     fn get_function_f<'db>(db: &'db TestDb, file: &'static str) -> FunctionType<'db> {

crates/red_knot_python_semantic/src/types/string_annotation.rs

@@ -5,8 +5,127 @@ use ruff_python_ast::{self as ast, ModExpression, StringFlags};
 use ruff_python_parser::{parse_expression_range, Parsed};
 use ruff_text_size::Ranged;
 
+use crate::lint::{Level, LintStatus};
 use crate::types::diagnostic::{TypeCheckDiagnostics, TypeCheckDiagnosticsBuilder};
-use crate::Db;
+use crate::{declare_lint, Db};
+
+declare_lint! {
+    /// ## What it does
+    /// Checks for f-strings in type annotation positions.
+    ///
+    /// ## Why is this bad?
+    /// Static analysis tools like Red Knot can't analyse type annotations that use f-string notation.
+    ///
+    /// ## Examples
+    /// ```python
+    /// def test(): -> f"int":
+    ///     ...
+    /// ```
+    ///
+    /// Use instead:
+    /// ```python
+    /// def test(): -> "int":
+    ///     ...
+    /// ```
+    pub(crate) static FSTRING_TYPE_ANNOTATION = {
+        summary: "detects F-strings in type annotation positions",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+        /// ## What it does
+        /// Checks for byte-strings in type annotation positions.
+        ///
+        /// ## Why is this bad?
+        /// Static analysis tools like Red Knot can't analyse type annotations that use byte-string notation.
+        ///
+        /// ## Examples
+        /// ```python
+        /// def test(): -> b"int":
+        ///     ...
+        /// ```
+        ///
+        /// Use instead:
+        /// ```python
+        /// def test(): -> "int":
+        ///     ...
+        /// ```
+    pub(crate) static BYTE_STRING_TYPE_ANNOTATION = {
+        summary: "detects byte strings in type annotation positions",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+        /// ## What it does
+        /// Checks for raw-strings in type annotation positions.
+        ///
+        /// ## Why is this bad?
+        /// Static analysis tools like Red Knot can't analyse type annotations that use raw-string notation.
+        ///
+        /// ## Examples
+        /// ```python
+        /// def test(): -> r"int":
+        ///     ...
+        /// ```
+        ///
+        /// Use instead:
+        /// ```python
+        /// def test(): -> "int":
+        ///     ...
+        /// ```
+    pub(crate) static RAW_STRING_TYPE_ANNOTATION = {
+        summary: "detects raw strings in type annotation positions",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+        /// ## What it does
+        /// Checks for implicit concatenated strings in type annotation positions.
+        ///
+        /// ## Why is this bad?
+        /// Static analysis tools like Red Knot can't analyse type annotations that use implicit concatenated strings.
+        ///
+        /// ## Examples
+        /// ```python
+        /// def test(): -> "Literal[" "5" "]":
+        ///     ...
+        /// ```
+        ///
+        /// Use instead:
+        /// ```python
+        /// def test(): -> "Literal[5]":
+        ///     ...
+        /// ```
+    pub(crate) static IMPLICIT_CONCATENATED_STRING_TYPE_ANNOTATION = {
+        summary: "detects implicit concatenated strings in type annotations",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static INVALID_SYNTAX_IN_FORWARD_ANNOTATION = {
+        summary: "detects invalid syntax in forward annotations",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
+declare_lint! {
+    /// TODO
+    pub(crate) static ESCAPE_CHARACTER_IN_FORWARD_ANNOTATION = {
+        summary: "detects forward type annotations with escape characters",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
 
 type AnnotationParseResult = Result<Parsed<ModExpression>, TypeCheckDiagnostics>;
 
@@ -25,9 +144,9 @@ pub(crate) fn parse_string_annotation(
     if let [string_literal] = string_expr.value.as_slice() {
         let prefix = string_literal.flags.prefix();
         if prefix.is_raw() {
-            diagnostics.add(
+            diagnostics.add_lint(
+                &RAW_STRING_TYPE_ANNOTATION,
                 string_literal.into(),
-                "annotation-raw-string",
                 format_args!("Type expressions cannot use raw string literal"),
             );
         // Compare the raw contents (without quotes) of the expression with the parsed contents
@@ -49,26 +168,26 @@ pub(crate) fn parse_string_annotation(
             // ```
             match parse_expression_range(source.as_str(), range_excluding_quotes) {
                 Ok(parsed) => return Ok(parsed),
-                Err(parse_error) => diagnostics.add(
+                Err(parse_error) => diagnostics.add_lint(
+                    &INVALID_SYNTAX_IN_FORWARD_ANNOTATION,
                     string_literal.into(),
-                    "forward-annotation-syntax-error",
                     format_args!("Syntax error in forward annotation: {}", parse_error.error),
                 ),
             }
         } else {
             // The raw contents of the string doesn't match the parsed content. This could be the
             // case for annotations that contain escape sequences.
-            diagnostics.add(
+            diagnostics.add_lint(
+                &ESCAPE_CHARACTER_IN_FORWARD_ANNOTATION,
                 string_expr.into(),
-                "annotation-escape-character",
                 format_args!("Type expressions cannot contain escape characters"),
             );
         }
     } else {
         // String is implicitly concatenated.
-        diagnostics.add(
+        diagnostics.add_lint(
+            &IMPLICIT_CONCATENATED_STRING_TYPE_ANNOTATION,
             string_expr.into(),
-            "annotation-implicit-concat",
             format_args!("Type expressions cannot span multiple string literals"),
         );
     }

crates/red_knot_python_semantic/src/types/unpacker.rs

@@ -6,7 +6,7 @@ use rustc_hash::FxHashMap;
 
 use crate::semantic_index::ast_ids::{HasScopedExpressionId, ScopedExpressionId};
 use crate::semantic_index::symbol::ScopeId;
-use crate::types::{Type, TypeCheckDiagnostics, TypeCheckDiagnosticsBuilder};
+use crate::types::{todo_type, Type, TypeCheckDiagnostics, TypeCheckDiagnosticsBuilder};
 use crate::Db;
 
 /// Unpacks the value expression type to their respective targets.
@@ -59,7 +59,7 @@ impl<'db> Unpacker<'db> {
                             // TODO: Combine the types into a list type. If the
                             // starred_element_types is empty, then it should be `List[Any]`.
                             // combine_types(starred_element_types);
-                            element_types.push(Type::Todo);
+                            element_types.push(todo_type!("starred unpacking"));
 
                             element_types.extend_from_slice(
                                 // SAFETY: Safe because of the length check above.
@@ -72,7 +72,7 @@ impl<'db> Unpacker<'db> {
                             // index.
                             element_types.resize(elts.len() - 1, Type::Unknown);
                             // TODO: This should be `list[Unknown]`
-                            element_types.insert(starred_index, Type::Todo);
+                            element_types.insert(starred_index, todo_type!("starred unpacking"));
                             Cow::Owned(element_types)
                         }
                     } else {
@@ -95,7 +95,8 @@ 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,
-                        &vec![Type::LiteralString; string_literal_ty.len(self.db)],
+                        std::iter::repeat(Type::LiteralString)
+                            .take(string_literal_ty.python_len(self.db)),
                     );
                     self.unpack(target, value_ty, scope);
                 }

crates/red_knot_python_semantic/tests/mdtest.rs

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

crates/red_knot_server/src/server/api/notifications/did_change.rs

@@ -48,7 +48,7 @@ impl SyncNotificationHandler for DidChangeTextDocumentHandler {
             }
         }
 
-        // TODO(dhruvmanila): Publish diagnostics if the client doesnt support pull diagnostics
+        // TODO(dhruvmanila): Publish diagnostics if the client doesn't support pull diagnostics
 
         Ok(())
     }

crates/red_knot_server/src/server/api/requests/diagnostic.rs

@@ -86,14 +86,15 @@ fn to_lsp_diagnostic(
 
     let severity = match diagnostic.severity() {
         Severity::Info => DiagnosticSeverity::INFORMATION,
-        Severity::Error => DiagnosticSeverity::ERROR,
+        Severity::Warning => DiagnosticSeverity::WARNING,
+        Severity::Error | Severity::Fatal => DiagnosticSeverity::ERROR,
     };
 
     Diagnostic {
         range,
         severity: Some(severity),
         tags: None,
-        code: Some(NumberOrString::String(diagnostic.rule().to_string())),
+        code: Some(NumberOrString::String(diagnostic.id().to_string())),
         code_description: None,
         source: Some("red-knot".into()),
         message: diagnostic.message().into_owned(),

crates/red_knot_server/src/server/client.rs

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

crates/red_knot_test/Cargo.toml

@@ -20,12 +20,15 @@ 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 }
 rustc-hash = { workspace = true }
 salsa = { workspace = true }
 smallvec = { workspace = true }
+serde = { workspace = true }
+toml = { workspace = true }
 
 [dev-dependencies]
 

crates/red_knot_test/README.md

@@ -184,8 +184,11 @@ The tests are run independently, in independent in-memory file systems and with
 [Salsa](https://github.com/salsa-rs/salsa) databases. This means that each is a from-scratch run of
 the type checker, with no data persisting from any previous test.
 
-Due to `cargo test` limitations, an entire test suite (Markdown file) is run as a single Rust test,
-so it's not possible to select individual tests within it to run.
+It is possible to filter to individual tests within a single markdown file using the
+`MDTEST_TEST_FILTER` environment variable. This variable will match any tests which contain the
+value as a case-sensitive substring in its name. An example test name is
+`unpacking.md - Unpacking - Tuple - Multiple assignment`, which contains the name of the markdown
+file and its parent headers joined together with hyphens.
 
 ## Structured test suites
 
@@ -222,6 +225,22 @@ A header-demarcated section must either be a test or a grouping header; it canno
 a header section can either contain embedded files (making it a test), or it can contain more
 deeply-nested headers (headers with more `#`), but it cannot contain both.
 
+## Configuration
+
+The test framework supports a TOML-based configuration format, which is a subset of the full red-knot
+configuration format. This configuration can be specified in fenced code blocks with `toml` as the
+language tag:
+
+````markdown
+```toml
+[environment]
+target-version = "3.10"
+```
+````
+
+This configuration will apply to all tests in the same section, and all nested sections within that
+section. Nested sections can override configurations from their parent sections.
+
 ## Documentation of tests
 
 Arbitrary Markdown syntax (including of course normal prose paragraphs) is permitted (and ignored by
@@ -279,30 +298,6 @@ possible in these files.
 
 A fenced code block with no language will always be an error.
 
-### Configuration
-
-We will add the ability to specify non-default red-knot configurations to use in tests, by including
-a TOML code block:
-
-````markdown
-```toml
-[tool.knot]
-warn-on-any = true
-```
-
-```py
-from typing import Any
-
-def f(x: Any):  # error: [use-of-any]
-    pass
-```
-````
-
-It should be possible to include a TOML code block in a single test (as shown), or in a grouping
-section, in which case it applies to all nested tests within that grouping section. Configurations
-at multiple level are allowed and merged, with the most-nested (closest to the test) taking
-precedence.
-
 ### Running just a single test from a suite
 
 Having each test in a suite always run as a distinct Rust test would require writing our own test
@@ -314,11 +309,11 @@ variable.
 
 ### Configuring search paths and kinds
 
-The red-knot TOML configuration format hasn't been designed yet, and we may want to implement
+The red-knot TOML configuration format hasn't been finalized, and we may want to implement
 support in the test framework for configuring search paths before it is designed. If so, we can
-define some configuration options for now under the `[tool.knot.tests]` namespace. In the future,
-perhaps some of these can be replaced by real red-knot configuration options; some or all may also
-be kept long-term as test-specific options.
+define some configuration options for now under the `[tests]` namespace. In the future, perhaps
+some of these can be replaced by real red-knot configuration options; some or all may also be
+kept long-term as test-specific options.
 
 Some configuration options we will want to provide:
 
@@ -336,13 +331,13 @@ non-default value using the `workspace-root` config.
 
 ### Specifying a custom typeshed
 
-Some tests will need to override the default typeshed with custom files. The `[tool.knot.tests]`
-configuration option `typeshed-root` should be usable for this:
+Some tests will need to override the default typeshed with custom files. The `[environment]`
+configuration option `typeshed-path` can be used to do this:
 
 ````markdown
 ```toml
-[tool.knot.tests]
-typeshed-root = "/typeshed"
+[environment]
+typeshed-path = "/typeshed"
 ```
 
 This file is importable as part of our custom typeshed, because it is within `/typeshed`, which we

crates/red_knot_test/src/config.rs

@@ -0,0 +1,28 @@
+//! TOML-deserializable Red Knot configuration, similar to `knot.toml`, to be able to
+//! control some configuration options from Markdown files. For now, this supports the
+//! following limited structure:
+//!
+//! ```toml
+//! [environment]
+//! target-version = "3.10"
+//! ```
+
+use anyhow::Context;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub(crate) struct MarkdownTestConfig {
+    pub(crate) environment: Environment,
+}
+
+impl MarkdownTestConfig {
+    pub(crate) fn from_str(s: &str) -> anyhow::Result<Self> {
+        toml::from_str(s).context("Error while parsing Markdown TOML config")
+    }
+}
+
+#[derive(Deserialize)]
+pub(crate) struct Environment {
+    #[serde(rename = "target-version")]
+    pub(crate) target_version: String,
+}

crates/red_knot_test/src/db.rs

@@ -1,5 +1,7 @@
+use red_knot_python_semantic::lint::RuleSelection;
 use red_knot_python_semantic::{
-    Db as SemanticDb, Program, ProgramSettings, PythonVersion, SearchPathSettings,
+    default_lint_registry, Db as SemanticDb, Program, ProgramSettings, PythonVersion,
+    SearchPathSettings,
 };
 use ruff_db::files::{File, Files};
 use ruff_db::system::{DbWithTestSystem, System, SystemPath, SystemPathBuf, TestSystem};
@@ -13,16 +15,20 @@ pub(crate) struct Db {
     files: Files,
     system: TestSystem,
     vendored: VendoredFileSystem,
+    rule_selection: RuleSelection,
 }
 
 impl Db {
     pub(crate) fn setup(workspace_root: SystemPathBuf) -> Self {
+        let rule_selection = RuleSelection::from_registry(&default_lint_registry());
+
         let db = Self {
             workspace_root,
             storage: salsa::Storage::default(),
             system: TestSystem::default(),
             vendored: red_knot_vendored::file_system().clone(),
             files: Files::default(),
+            rule_selection,
         };
 
         db.memory_file_system()
@@ -85,6 +91,10 @@ impl SemanticDb for Db {
     fn is_file_open(&self, file: File) -> bool {
         !file.path(self).is_vendored_path()
     }
+
+    fn rule_selection(&self) -> &RuleSelection {
+        &self.rule_selection
+    }
 }
 
 #[salsa::db]

crates/red_knot_test/src/diagnostic.rs

@@ -144,7 +144,7 @@ struct DiagnosticWithLine<T> {
 mod tests {
     use crate::db::Db;
     use crate::diagnostic::Diagnostic;
-    use ruff_db::diagnostic::Severity;
+    use ruff_db::diagnostic::{DiagnosticId, LintName, Severity};
     use ruff_db::files::{system_path_to_file, File};
     use ruff_db::source::line_index;
     use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
@@ -190,8 +190,8 @@ mod tests {
     }
 
     impl Diagnostic for DummyDiagnostic {
-        fn rule(&self) -> &str {
-            "dummy"
+        fn id(&self) -> DiagnosticId {
+            DiagnosticId::Lint(LintName::of("dummy"))
         }
 
         fn message(&self) -> Cow<str> {

crates/red_knot_test/src/lib.rs

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