[red-knot] track declared types and issue diagnostics

.github/workflows/ci.yaml

@@ -148,7 +148,7 @@ jobs:
       # sync, not just public items. Eventually we should do this for all
       # crates; for now add crates here as they are warning-clean to prevent
       # regression.
-      - run: cargo doc --no-deps -p red_knot_python_semantic -p red_knot -p red_knot_test -p ruff_db --document-private-items
+      - run: cargo doc --no-deps -p red_knot_python_semantic -p red_knot -p ruff_db --document-private-items
         env:
           # Setting RUSTDOCFLAGS because `cargo doc --check` isn't yet implemented (https://github.com/rust-lang/cargo/issues/10025).
           RUSTDOCFLAGS: "-D warnings"
@@ -518,8 +518,6 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
-        with:
-          python-version: "3.13"
       - name: "Add SSH key"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
         uses: webfactory/ssh-agent@v0.9.0
@@ -527,15 +525,13 @@ jobs:
           ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
       - name: "Install Rust toolchain"
         run: rustup show
-      - name: Install uv
-        uses: astral-sh/setup-uv@v3
       - uses: Swatinem/rust-cache@v2
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        run: uv pip install -r docs/requirements-insiders.txt --system
+        run: pip install -r docs/requirements-insiders.txt
       - name: "Install dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
-        run: uv pip install -r docs/requirements.txt --system
+        run: pip install -r docs/requirements.txt
       - name: "Update README File"
         run: python scripts/transform_readme.py --target mkdocs
       - name: "Generate docs"
@@ -612,7 +608,7 @@ jobs:
           just test
 
   benchmarks:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     needs: determine_changes
     if: ${{ github.repository == 'astral-sh/ruff' && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 20

.github/workflows/macos-12.yml

@@ -1,76 +0,0 @@
-name: "Test macOS 12 (x86_64)"
-
-on:
-  pull_request
-
-env:
-  PACKAGE_NAME: ruff
-  MODULE_NAME: ruff
-  PYTHON_VERSION: "3.11"
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-
-jobs:
-  macos-x86_64:
-    runs-on: macos-14
-#    env:
-#      MACOSX_DEPLOYMENT_TARGET: 13.7
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels - x86_64"
-        uses: PyO3/maturin-action@v1
-        with:
-          target: x86_64
-          args: --release --locked --out dist
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-macos-x86_64
-          path: dist
-      - name: "Archive binary"
-        run: |
-          TARGET=x86_64-apple-darwin
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-macos-x86_64
-          path: |
-            *.tar.gz
-            *.sha256
-
-  test:
-    needs: macos-x86_64
-    runs-on: macos-12
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
-      - name: "Download binaries"
-        uses: actions/download-artifact@v4
-        with:
-          name: artifacts-macos-x86_64
-      - name: "Extract"
-        run: tar xzvf ruff-x86_64-apple-darwin.tar.gz
-      - name: "Run Ruff"
-        run: ./ruff-x86_64-apple-darwin/ruff --help

.github/workflows/release.yml

@@ -1,5 +1,3 @@
-# This file was autogenerated by cargo-dist: https://opensource.axo.dev/cargo-dist/
-#
 # Copyright 2022-2024, axodotdev
 # SPDX-License-Identifier: MIT or Apache-2.0
 #
@@ -66,7 +64,7 @@ jobs:
         # 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"
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.18.0/cargo-dist-installer.sh | sh"
       - name: Cache cargo-dist
         uses: actions/upload-artifact@v4
         with:

.github/workflows/sync_typeshed.yaml

@@ -37,13 +37,13 @@ jobs:
       - name: Sync typeshed
         id: sync
         run: |
-          rm -rf ruff/crates/red_knot_vendored/vendor/typeshed
-          mkdir ruff/crates/red_knot_vendored/vendor/typeshed
-          cp typeshed/README.md ruff/crates/red_knot_vendored/vendor/typeshed
-          cp typeshed/LICENSE ruff/crates/red_knot_vendored/vendor/typeshed
-          cp -r typeshed/stdlib ruff/crates/red_knot_vendored/vendor/typeshed/stdlib
-          rm -rf ruff/crates/red_knot_vendored/vendor/typeshed/stdlib/@tests
-          git -C typeshed rev-parse HEAD > ruff/crates/red_knot_vendored/vendor/typeshed/source_commit.txt
+          rm -rf ruff/crates/red_knot_python_semantic/vendor/typeshed
+          mkdir ruff/crates/red_knot_python_semantic/vendor/typeshed
+          cp typeshed/README.md ruff/crates/red_knot_python_semantic/vendor/typeshed
+          cp typeshed/LICENSE ruff/crates/red_knot_python_semantic/vendor/typeshed
+          cp -r typeshed/stdlib ruff/crates/red_knot_python_semantic/vendor/typeshed/stdlib
+          rm -rf ruff/crates/red_knot_python_semantic/vendor/typeshed/stdlib/@tests
+          git -C typeshed rev-parse HEAD > ruff/crates/red_knot_python_semantic/vendor/typeshed/source_commit.txt
       - name: Commit the changes
         id: commit
         if: ${{ steps.sync.outcome == 'success' }}

.pre-commit-config.yaml

@@ -2,7 +2,7 @@ fail_fast: true
 
 exclude: |
   (?x)^(
-    crates/red_knot_vendored/vendor/.*|
+    crates/red_knot_python_semantic/vendor/.*|
     crates/red_knot_workspace/resources/.*|
     crates/ruff_linter/resources/.*|
     crates/ruff_linter/src/rules/.*/snapshots/.*|
@@ -17,7 +17,7 @@ exclude: |
 
 repos:
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.20.2
+    rev: v0.19
     hooks:
       - id: validate-pyproject
 
@@ -28,7 +28,6 @@ repos:
         additional_dependencies:
           - mdformat-mkdocs
           - mdformat-admon
-          - mdformat-footnote
         exclude: |
           (?x)^(
             docs/formatter/black\.md
@@ -36,7 +35,7 @@ repos:
           )$
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.42.0
+    rev: v0.41.0
     hooks:
       - id: markdownlint-fix
         exclude: |
@@ -46,7 +45,7 @@ repos:
           )$
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.25.0
+    rev: v1.24.5
     hooks:
       - id: typos
 
@@ -60,7 +59,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.9
+    rev: v0.6.4
     hooks:
       - id: ruff-format
       - id: ruff
@@ -69,8 +68,8 @@ repos:
         require_serial: true
 
   # Prettier
-  - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.3.3
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v3.1.0
     hooks:
       - id: prettier
         types: [yaml]

CHANGELOG.md

@@ -1,135 +1,5 @@
 # Changelog
 
-## 0.6.9
-
-### Preview features
-
-- Fix codeblock dynamic line length calculation for indented docstring examples ([#13523](https://github.com/astral-sh/ruff/pull/13523))
-- \[`refurb`\] Mark `FURB118` fix as unsafe ([#13613](https://github.com/astral-sh/ruff/pull/13613))
-
-### Rule changes
-
-- \[`pydocstyle`\] Don't raise `D208` when last line is non-empty ([#13372](https://github.com/astral-sh/ruff/pull/13372))
-- \[`pylint`\] Preserve trivia (i.e. comments) in `PLR5501` autofix ([#13573](https://github.com/astral-sh/ruff/pull/13573))
-
-### Configuration
-
-- \[`pyflakes`\] Add `allow-unused-imports` setting for `unused-import` rule (`F401`) ([#13601](https://github.com/astral-sh/ruff/pull/13601))
-
-### Bug fixes
-
-- Support ruff discovery in pip build environments ([#13591](https://github.com/astral-sh/ruff/pull/13591))
-- \[`flake8-bugbear`\] Avoid short circuiting `B017` for multiple context managers ([#13609](https://github.com/astral-sh/ruff/pull/13609))
-- \[`pylint`\] Do not offer an invalid fix for `PLR1716` when the comparisons contain parenthesis ([#13527](https://github.com/astral-sh/ruff/pull/13527))
-- \[`pyupgrade`\] Fix `UP043` to apply to `collections.abc.Generator` and `collections.abc.AsyncGenerator` ([#13611](https://github.com/astral-sh/ruff/pull/13611))
-- \[`refurb`\] Fix handling of slices in tuples for `FURB118`, e.g., `x[:, 1]` ([#13518](https://github.com/astral-sh/ruff/pull/13518))
-
-### Documentation
-
-- Update GitHub Action link to `astral-sh/ruff-action` ([#13551](https://github.com/astral-sh/ruff/pull/13551))
-
-## 0.6.8
-
-### Preview features
-
-- Remove unnecessary parentheses around `match case` clauses ([#13510](https://github.com/astral-sh/ruff/pull/13510))
-- Parenthesize overlong `if` guards in `match..case` clauses ([#13513](https://github.com/astral-sh/ruff/pull/13513))
-- Detect basic wildcard imports in `ruff analyze graph` ([#13486](https://github.com/astral-sh/ruff/pull/13486))
-- \[`pylint`\] Implement `boolean-chained-comparison` (`R1716`) ([#13435](https://github.com/astral-sh/ruff/pull/13435))
-
-### Rule changes
-
-- \[`lake8-simplify`\] Detect `SIM910` when using variadic keyword arguments, i.e., `**kwargs` ([#13503](https://github.com/astral-sh/ruff/pull/13503))
-- \[`pyupgrade`\] Avoid false negatives with non-reference shadowed bindings of loop variables (`UP028`) ([#13504](https://github.com/astral-sh/ruff/pull/13504))
-
-### Bug fixes
-
-- Detect tuples bound to variadic positional arguments i.e. `*args` ([#13512](https://github.com/astral-sh/ruff/pull/13512))
-- Exit gracefully on broken pipe errors ([#13485](https://github.com/astral-sh/ruff/pull/13485))
-- Avoid panic when analyze graph hits broken pipe ([#13484](https://github.com/astral-sh/ruff/pull/13484))
-
-### Performance
-
-- Reuse `BTreeSets` in module resolver ([#13440](https://github.com/astral-sh/ruff/pull/13440))
-- Skip traversal for non-compound statements ([#13441](https://github.com/astral-sh/ruff/pull/13441))
-
-## 0.6.7
-
-### Preview features
-
-- Add Python version support to ruff analyze CLI ([#13426](https://github.com/astral-sh/ruff/pull/13426))
-- Add `exclude` support to `ruff analyze` ([#13425](https://github.com/astral-sh/ruff/pull/13425))
-- Fix parentheses around return type annotations ([#13381](https://github.com/astral-sh/ruff/pull/13381))
-
-### Rule changes
-
-- \[`pycodestyle`\] Fix: Don't autofix if the first line ends in a question mark? (D400) ([#13399](https://github.com/astral-sh/ruff/pull/13399))
-
-### Bug fixes
-
-- Respect `lint.exclude` in ruff check `--add-noqa` ([#13427](https://github.com/astral-sh/ruff/pull/13427))
-
-### Performance
-
-- Avoid tracking module resolver files in Salsa ([#13437](https://github.com/astral-sh/ruff/pull/13437))
-- Use `forget` for module resolver database ([#13438](https://github.com/astral-sh/ruff/pull/13438))
-
-## 0.6.6
-
-### Preview features
-
-- \[`refurb`\] Skip `slice-to-remove-prefix-or-suffix` (`FURB188`) when non-trivial slice steps are present ([#13405](https://github.com/astral-sh/ruff/pull/13405))
-- Add a subcommand to generate dependency graphs ([#13402](https://github.com/astral-sh/ruff/pull/13402))
-
-### Formatter
-
-- Fix placement of inline parameter comments ([#13379](https://github.com/astral-sh/ruff/pull/13379))
-
-### Server
-
-- Fix off-by one error in the `LineIndex::offset` calculation ([#13407](https://github.com/astral-sh/ruff/pull/13407))
-
-### Bug fixes
-
-- \[`fastapi`\] Respect FastAPI aliases in route definitions ([#13394](https://github.com/astral-sh/ruff/pull/13394))
-- \[`pydocstyle`\] Respect word boundaries when detecting function signature in docs ([#13388](https://github.com/astral-sh/ruff/pull/13388))
-
-### Documentation
-
-- Add backlinks to rule overview linter ([#13368](https://github.com/astral-sh/ruff/pull/13368))
-- Fix documentation for editor vim plugin ALE ([#13348](https://github.com/astral-sh/ruff/pull/13348))
-- Fix rendering of `FURB188` docs ([#13406](https://github.com/astral-sh/ruff/pull/13406))
-
-## 0.6.5
-
-### Preview features
-
-- \[`pydoclint`\] Ignore `DOC201` when function name is "**new**" ([#13300](https://github.com/astral-sh/ruff/pull/13300))
-- \[`refurb`\] Implement `slice-to-remove-prefix-or-suffix` (`FURB188`) ([#13256](https://github.com/astral-sh/ruff/pull/13256))
-
-### Rule changes
-
-- \[`eradicate`\] Ignore script-comments with multiple end-tags (`ERA001`) ([#13283](https://github.com/astral-sh/ruff/pull/13283))
-- \[`pyflakes`\] Improve error message for `UndefinedName` when a builtin was added in a newer version than specified in Ruff config (`F821`) ([#13293](https://github.com/astral-sh/ruff/pull/13293))
-
-### Server
-
-- Add support for extensionless Python files for server ([#13326](https://github.com/astral-sh/ruff/pull/13326))
-- Fix configuration inheritance for configurations specified in the LSP settings ([#13285](https://github.com/astral-sh/ruff/pull/13285))
-
-### Bug fixes
-
-- \[`ruff`\] Handle unary operators in `decimal-from-float-literal` (`RUF032`) ([#13275](https://github.com/astral-sh/ruff/pull/13275))
-
-### CLI
-
-- Only include rules with diagnostics in SARIF metadata ([#13268](https://github.com/astral-sh/ruff/pull/13268))
-
-### Playground
-
-- Add "Copy as pyproject.toml/ruff.toml" and "Paste from TOML" ([#13328](https://github.com/astral-sh/ruff/pull/13328))
-- Fix errors not shown for restored snippet on page load ([#13262](https://github.com/astral-sh/ruff/pull/13262))
-
 ## 0.6.4
 
 ### Preview features

CONTRIBUTING.md

@@ -29,14 +29,16 @@ You'll also need [Insta](https://insta.rs/docs/) to update snapshot tests:
 cargo install cargo-insta
 ```
 
-You'll need [uv](https://docs.astral.sh/uv/getting-started/installation/) (or `pipx` and `pip`) to
-run Python utility commands.
+And you'll need pre-commit to run some validation checks:
+
+```shell
+pipx install pre-commit  # or `pip install pre-commit` if you have a virtualenv
+```
 
 You can optionally install pre-commit hooks to automatically run the validation checks
 when making a commit:
 
 ```shell
-uv tool install pre-commit
 pre-commit install
 ```
 
@@ -64,7 +66,7 @@ and that it passes both the lint and test validation checks:
 ```shell
 cargo clippy --workspace --all-targets --all-features -- -D warnings  # Rust linting
 RUFF_UPDATE_SCHEMA=1 cargo test  # Rust testing and updating ruff.schema.json
-uvx pre-commit run --all-files --show-diff-on-failure  # Rust and Python formatting, Markdown and Python linting, etc.
+pre-commit run --all-files --show-diff-on-failure  # Rust and Python formatting, Markdown and Python linting, etc.
 ```
 
 These checks will run on GitHub Actions when you open your pull request, but running them locally
@@ -265,20 +267,26 @@ To preview any changes to the documentation locally:
 
 1. Install the [Rust toolchain](https://www.rust-lang.org/tools/install).
 
+1. Install MkDocs and Material for MkDocs with:
+
+    ```shell
+    pip install -r docs/requirements.txt
+    ```
+
 1. Generate the MkDocs site with:
 
     ```shell
-    uv run --no-project --isolated --with-requirements docs/requirements.txt scripts/generate_mkdocs.py
+    python scripts/generate_mkdocs.py
     ```
 
 1. Run the development server with:
 
     ```shell
     # For contributors.
-    uvx --with-requirements docs/requirements.txt -- mkdocs serve -f mkdocs.public.yml
+    mkdocs serve -f mkdocs.public.yml
 
     # For members of the Astral org, which has access to MkDocs Insiders via sponsorship.
-    uvx --with-requirements docs/requirements-insiders.txt -- mkdocs serve -f mkdocs.insiders.yml
+    mkdocs serve -f mkdocs.insiders.yml
     ```
 
 The documentation should then be available locally at
@@ -360,8 +368,9 @@ GitHub Actions will run your changes against a number of real-world projects fro
 report on any linter or formatter differences. You can also run those checks locally via:
 
 ```shell
-uvx --from ./python/ruff-ecosystem ruff-ecosystem check ruff "./target/debug/ruff"
-uvx --from ./python/ruff-ecosystem ruff-ecosystem format ruff "./target/debug/ruff"
+pip install -e ./python/ruff-ecosystem
+ruff-ecosystem check ruff "./target/debug/ruff"
+ruff-ecosystem format ruff "./target/debug/ruff"
 ```
 
 See the [ruff-ecosystem package](https://github.com/astral-sh/ruff/tree/main/python/ruff-ecosystem) for more details.

Cargo.toml

@@ -14,10 +14,9 @@ license = "MIT"
 [workspace.dependencies]
 ruff = { path = "crates/ruff" }
 ruff_cache = { path = "crates/ruff_cache" }
-ruff_db = { path = "crates/ruff_db", default-features = false }
+ruff_db = { path = "crates/ruff_db" }
 ruff_diagnostics = { path = "crates/ruff_diagnostics" }
 ruff_formatter = { path = "crates/ruff_formatter" }
-ruff_graph = { path = "crates/ruff_graph" }
 ruff_index = { path = "crates/ruff_index" }
 ruff_linter = { path = "crates/ruff_linter" }
 ruff_macros = { path = "crates/ruff_macros" }
@@ -34,18 +33,15 @@ ruff_python_trivia = { path = "crates/ruff_python_trivia" }
 ruff_server = { path = "crates/ruff_server" }
 ruff_source_file = { path = "crates/ruff_source_file" }
 ruff_text_size = { path = "crates/ruff_text_size" }
-red_knot_vendored = { path = "crates/red_knot_vendored" }
 ruff_workspace = { path = "crates/ruff_workspace" }
 
 red_knot_python_semantic = { path = "crates/red_knot_python_semantic" }
 red_knot_server = { path = "crates/red_knot_server" }
-red_knot_test = { path = "crates/red_knot_test" }
-red_knot_workspace = { path = "crates/red_knot_workspace", default-features = false }
+red_knot_workspace = { path = "crates/red_knot_workspace" }
 
 aho-corasick = { version = "1.1.3" }
 annotate-snippets = { version = "0.9.2", features = ["color"] }
 anyhow = { version = "1.0.80" }
-assert_fs = { version = "1.1.0" }
 argfile = { version = "0.2.0" }
 bincode = { version = "1.3.3" }
 bitflags = { version = "2.5.0" }
@@ -72,11 +68,7 @@ fern = { version = "0.6.1" }
 filetime = { version = "0.2.23" }
 glob = { version = "0.3.1" }
 globset = { version = "0.4.14" }
-globwalk = { version = "0.9.1" }
-hashbrown = { version = "0.15.0", default-features = false, features = [
-    "raw-entry",
-    "inline-more",
-] }
+hashbrown = "0.14.3"
 ignore = { version = "0.4.22" }
 imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
@@ -94,7 +86,7 @@ libcst = { version = "1.1.0", default-features = false }
 log = { version = "0.4.17" }
 lsp-server = { version = "0.7.6" }
 lsp-types = { git = "https://github.com/astral-sh/lsp-types.git", rev = "3512a9f", features = [
-    "proposed",
+  "proposed",
 ] }
 matchit = { version = "0.8.1" }
 memchr = { version = "2.7.1" }
@@ -115,9 +107,8 @@ quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
-rstest = { version = "0.22.0", default-features = false }
 rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "b14be5c0392f4c55eca60b92e457a35549372382" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "f608ff8b24f07706492027199f51132244034f29" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -125,7 +116,7 @@ serde-wasm-bindgen = { version = "0.6.4" }
 serde_json = { version = "1.0.113" }
 serde_test = { version = "1.0.152" }
 serde_with = { version = "3.6.0", default-features = false, features = [
-    "macros",
+  "macros",
 ] }
 shellexpand = { version = "3.0.0" }
 similar = { version = "2.4.0", features = ["inline"] }
@@ -142,10 +133,7 @@ toml = { version = "0.8.11" }
 tracing = { version = "0.1.40" }
 tracing-flame = { version = "0.2.0" }
 tracing-indicatif = { version = "0.3.6" }
-tracing-subscriber = { version = "0.3.18", default-features = false, features = [
-    "env-filter",
-    "fmt",
-] }
+tracing-subscriber = { version = "0.3.18", default-features = false, features = ["env-filter", "fmt"] }
 tracing-tree = { version = "0.4.0" }
 typed-arena = { version = "2.0.2" }
 unic-ucd-category = { version = "0.9" }
@@ -156,10 +144,10 @@ unicode-normalization = { version = "0.1.23" }
 ureq = { version = "2.9.6" }
 url = { version = "2.5.0" }
 uuid = { version = "1.6.1", features = [
-    "v4",
-    "fast-rng",
-    "macro-diagnostics",
-    "js",
+  "v4",
+  "fast-rng",
+  "macro-diagnostics",
+  "js",
 ] }
 walkdir = { version = "2.3.2" }
 wasm-bindgen = { version = "0.2.92" }
@@ -170,10 +158,7 @@ zip = { version = "0.6.6", default-features = false }
 [workspace.lints.rust]
 unsafe_code = "warn"
 unreachable_pub = "warn"
-unexpected_cfgs = { level = "warn", check-cfg = [
-    "cfg(fuzzing)",
-    "cfg(codspeed)",
-] }
+unexpected_cfgs = { level = "warn", check-cfg = ["cfg(fuzzing)", "cfg(codspeed)"] }
 
 [workspace.lints.clippy]
 pedantic = { level = "warn", priority = -2 }
@@ -245,9 +230,9 @@ inherits = "release"
 # Config for 'cargo dist'
 [workspace.metadata.dist]
 # The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax)
-cargo-dist-version = "0.22.1"
+cargo-dist-version = "0.18.0"
 # CI backends to support
-ci = "github"
+ci = ["github"]
 # The installers to generate for each app
 installers = ["shell", "powershell"]
 # The archive format to use for windows builds (defaults .zip)
@@ -256,33 +241,33 @@ windows-archive = ".zip"
 unix-archive = ".tar.gz"
 # Target platforms to build apps for (Rust target-triple syntax)
 targets = [
-    "aarch64-apple-darwin",
-    "aarch64-pc-windows-msvc",
-    "aarch64-unknown-linux-gnu",
-    "aarch64-unknown-linux-musl",
-    "arm-unknown-linux-musleabihf",
-    "armv7-unknown-linux-gnueabihf",
-    "armv7-unknown-linux-musleabihf",
-    "i686-pc-windows-msvc",
-    "i686-unknown-linux-gnu",
-    "i686-unknown-linux-musl",
-    "powerpc64-unknown-linux-gnu",
-    "powerpc64le-unknown-linux-gnu",
-    "s390x-unknown-linux-gnu",
-    "x86_64-apple-darwin",
-    "x86_64-pc-windows-msvc",
-    "x86_64-unknown-linux-gnu",
-    "x86_64-unknown-linux-musl",
+  "aarch64-apple-darwin",
+  "aarch64-pc-windows-msvc",
+  "aarch64-unknown-linux-gnu",
+  "aarch64-unknown-linux-musl",
+  "arm-unknown-linux-musleabihf",
+  "armv7-unknown-linux-gnueabihf",
+  "armv7-unknown-linux-musleabihf",
+  "i686-pc-windows-msvc",
+  "i686-unknown-linux-gnu",
+  "i686-unknown-linux-musl",
+  "powerpc64-unknown-linux-gnu",
+  "powerpc64le-unknown-linux-gnu",
+  "s390x-unknown-linux-gnu",
+  "x86_64-apple-darwin",
+  "x86_64-pc-windows-msvc",
+  "x86_64-unknown-linux-gnu",
+  "x86_64-unknown-linux-musl",
 ]
 # 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
 create-release = true
-# Which actions to run on pull requests
+# Publish jobs to run in CI
 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
+# The stage during which the GitHub Release should be created
 github-release = "announce"
 # Whether CI should include auto-generated code to build local artifacts
 build-local-artifacts = false
@@ -290,15 +275,9 @@ build-local-artifacts = false
 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",
-]
+# Announcement jobs to run in CI
+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"

README.md

@@ -136,8 +136,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.6.9/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.6.9/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.6.4/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.6.4/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -170,7 +170,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.6.9
+  rev: v0.6.4
   hooks:
     # Run the linter.
     - id: ruff
@@ -182,7 +182,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 Ruff can also be used as a [VS Code extension](https://github.com/astral-sh/ruff-vscode) or with [various other editors](https://docs.astral.sh/ruff/editors/setup).
 
 Ruff can also be used as a [GitHub Action](https://github.com/features/actions) via
-[`ruff-action`](https://github.com/astral-sh/ruff-action):
+[`ruff-action`](https://github.com/chartboost/ruff-action):
 
 ```yaml
 name: Ruff
@@ -192,7 +192,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: astral-sh/ruff-action@v1
+      - uses: chartboost/ruff-action@v1
 ```
 
 ### Configuration<a id="configuration"></a>

_typos.toml

@@ -1,6 +1,6 @@
 [files]
 # https://github.com/crate-ci/typos/issues/868
-extend-exclude = ["crates/red_knot_vendored/vendor/**/*", "**/resources/**/*", "**/snapshots/**/*"]
+extend-exclude = ["crates/red_knot_python_semantic/vendor/**/*", "**/resources/**/*", "**/snapshots/**/*"]
 
 [default.extend-words]
 "arange" = "arange"  # e.g. `numpy.arange`
@@ -8,7 +8,7 @@ hel = "hel"
 whos = "whos"
 spawnve = "spawnve"
 ned = "ned"
-pn = "pn"  # `import panel as pn` is a thing
+pn = "pn"  # `import panel as pd` is a thing
 poit = "poit"
 BA = "BA" # acronym for "Bad Allowed", used in testing.
 jod = "jod" # e.g., `jod-thread`

crates/red_knot/Cargo.toml

@@ -13,8 +13,9 @@ license.workspace = true
 
 [dependencies]
 red_knot_python_semantic = { workspace = true }
-red_knot_workspace = { workspace = true, features = ["zstd"] }
+red_knot_workspace = { workspace = true }
 red_knot_server = { workspace = true }
+
 ruff_db = { workspace = true, features = ["os", "cache"] }
 
 anyhow = { workspace = true }

crates/red_knot/src/main.rs

@@ -160,7 +160,7 @@ fn run() -> anyhow::Result<ExitStatus> {
         SystemPathBuf::from_path_buf(cwd)
             .map_err(|path| {
                 anyhow!(
-                    "The current working directory `{}` contains non-Unicode characters. Red Knot only supports Unicode paths.",
+                    "The current working directory '{}' contains non-unicode characters. Red Knot only supports unicode paths.",
                     path.display()
                 )
             })?
@@ -174,7 +174,7 @@ fn run() -> anyhow::Result<ExitStatus> {
                 Ok(SystemPath::absolute(cwd, &cli_base_path))
             } else {
                 Err(anyhow!(
-                    "Provided current-directory path `{cwd}` is not a directory"
+                    "Provided current-directory path '{cwd}' is not a directory."
                 ))
             }
         })

crates/red_knot/tests/file_watching.rs

@@ -42,14 +42,14 @@ impl TestCase {
 
     fn stop_watch(&mut self) -> Vec<watch::ChangeEvent> {
         self.try_stop_watch(Duration::from_secs(10))
-            .expect("Expected watch changes but observed none")
+            .expect("Expected watch changes but observed none.")
     }
 
     fn try_stop_watch(&mut self, timeout: Duration) -> Option<Vec<watch::ChangeEvent>> {
         let watcher = self
             .watcher
             .take()
-            .expect("Cannot call `stop_watch` more than once");
+            .expect("Cannot call `stop_watch` more than once.");
 
         let mut all_events = self
             .changes_receiver
@@ -72,7 +72,7 @@ impl TestCase {
     #[cfg(unix)]
     fn take_watch_changes(&self) -> Vec<watch::ChangeEvent> {
         self.try_take_watch_changes(Duration::from_secs(10))
-            .expect("Expected watch changes but observed none")
+            .expect("Expected watch changes but observed none.")
     }
 
     fn try_take_watch_changes(&self, timeout: Duration) -> Option<Vec<watch::ChangeEvent>> {
@@ -150,14 +150,14 @@ where
             let absolute_path = workspace_path.join(relative_path);
             if let Some(parent) = absolute_path.parent() {
                 std::fs::create_dir_all(parent).with_context(|| {
-                    format!("Failed to create parent directory for file `{relative_path}`")
+                    format!("Failed to create parent directory for file '{relative_path}'.",)
                 })?;
             }
 
             let mut file = std::fs::File::create(absolute_path.as_std_path())
-                .with_context(|| format!("Failed to open file `{relative_path}`"))?;
+                .with_context(|| format!("Failed to open file '{relative_path}'"))?;
             file.write_all(content.as_bytes())
-                .with_context(|| format!("Failed to write to file `{relative_path}`"))?;
+                .with_context(|| format!("Failed to write to file '{relative_path}'"))?;
             file.sync_data()?;
         }
 
@@ -194,7 +194,7 @@ where
 
     let root_path = SystemPath::from_std_path(temp_dir.path()).ok_or_else(|| {
         anyhow!(
-            "Temporary directory `{}` is not a valid UTF-8 path.",
+            "Temp directory '{}' is not a valid UTF-8 path.",
             temp_dir.path().display()
         )
     })?;
@@ -209,7 +209,7 @@ where
     let workspace_path = root_path.join("workspace");
 
     std::fs::create_dir_all(workspace_path.as_std_path())
-        .with_context(|| format!("Failed to create workspace directory `{workspace_path}`"))?;
+        .with_context(|| format!("Failed to create workspace directory '{workspace_path}'",))?;
 
     setup_files
         .setup(&root_path, &workspace_path)
@@ -233,7 +233,7 @@ where
         }))
     {
         std::fs::create_dir_all(path.as_std_path())
-            .with_context(|| format!("Failed to create search path `{path}`"))?;
+            .with_context(|| format!("Failed to create search path '{path}'"))?;
     }
 
     let configuration = Configuration {
@@ -501,10 +501,7 @@ fn directory_moved_to_workspace() -> anyhow::Result<()> {
         .with_context(|| "Failed to create __init__.py")?;
     std::fs::write(a_original_path.as_std_path(), "").with_context(|| "Failed to create a.py")?;
 
-    let sub_a_module = resolve_module(
-        case.db().upcast(),
-        &ModuleName::new_static("sub.a").unwrap(),
-    );
+    let sub_a_module = resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap());
 
     assert_eq!(sub_a_module, None);
     assert_eq!(
@@ -528,11 +525,7 @@ fn directory_moved_to_workspace() -> anyhow::Result<()> {
         .expect("a.py to exist");
 
     // `import sub.a` should now resolve
-    assert!(resolve_module(
-        case.db().upcast(),
-        &ModuleName::new_static("sub.a").unwrap()
-    )
-    .is_some());
+    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_some());
 
     assert_eq!(
         case.collect_package_files(&case.workspace_path("bar.py")),
@@ -551,11 +544,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
     ])?;
     let bar = case.system_file(case.workspace_path("bar.py")).unwrap();
 
-    assert!(resolve_module(
-        case.db().upcast(),
-        &ModuleName::new_static("sub.a").unwrap()
-    )
-    .is_some());
+    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_some());
 
     let sub_path = case.workspace_path("sub");
     let init_file = case
@@ -580,11 +569,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
     case.apply_changes(changes);
 
     // `import sub.a` should no longer resolve
-    assert!(resolve_module(
-        case.db().upcast(),
-        &ModuleName::new_static("sub.a").unwrap()
-    )
-    .is_none());
+    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_none());
 
     assert!(!init_file.exists(case.db()));
     assert!(!a_file.exists(case.db()));
@@ -607,14 +592,10 @@ fn directory_renamed() -> anyhow::Result<()> {
 
     let bar = case.system_file(case.workspace_path("bar.py")).unwrap();
 
+    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_some());
     assert!(resolve_module(
         case.db().upcast(),
-        &ModuleName::new_static("sub.a").unwrap()
-    )
-    .is_some());
-    assert!(resolve_module(
-        case.db().upcast(),
-        &ModuleName::new_static("foo.baz").unwrap()
+        ModuleName::new_static("foo.baz").unwrap()
     )
     .is_none());
 
@@ -642,15 +623,11 @@ fn directory_renamed() -> anyhow::Result<()> {
     case.apply_changes(changes);
 
     // `import sub.a` should no longer resolve
-    assert!(resolve_module(
-        case.db().upcast(),
-        &ModuleName::new_static("sub.a").unwrap()
-    )
-    .is_none());
+    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_none());
     // `import foo.baz` should now resolve
     assert!(resolve_module(
         case.db().upcast(),
-        &ModuleName::new_static("foo.baz").unwrap()
+        ModuleName::new_static("foo.baz").unwrap()
     )
     .is_some());
 
@@ -688,11 +665,7 @@ fn directory_deleted() -> anyhow::Result<()> {
 
     let bar = case.system_file(case.workspace_path("bar.py")).unwrap();
 
-    assert!(resolve_module(
-        case.db().upcast(),
-        &ModuleName::new_static("sub.a").unwrap()
-    )
-    .is_some());
+    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_some(),);
 
     let sub_path = case.workspace_path("sub");
 
@@ -715,11 +688,7 @@ fn directory_deleted() -> anyhow::Result<()> {
     case.apply_changes(changes);
 
     // `import sub.a` should no longer resolve
-    assert!(resolve_module(
-        case.db().upcast(),
-        &ModuleName::new_static("sub.a").unwrap()
-    )
-    .is_none());
+    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_none());
 
     assert!(!init_file.exists(case.db()));
     assert!(!a_file.exists(case.db()));
@@ -741,7 +710,7 @@ fn search_path() -> anyhow::Result<()> {
     let site_packages = case.root_path().join("site_packages");
 
     assert_eq!(
-        resolve_module(case.db(), &ModuleName::new("a").unwrap()),
+        resolve_module(case.db(), ModuleName::new("a").unwrap()),
         None
     );
 
@@ -751,7 +720,7 @@ fn search_path() -> anyhow::Result<()> {
 
     case.apply_changes(changes);
 
-    assert!(resolve_module(case.db().upcast(), &ModuleName::new_static("a").unwrap()).is_some());
+    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("a").unwrap()).is_some());
     assert_eq!(
         case.collect_package_files(&case.workspace_path("bar.py")),
         &[case.system_file(case.workspace_path("bar.py")).unwrap()]
@@ -767,7 +736,7 @@ fn add_search_path() -> anyhow::Result<()> {
     let site_packages = case.workspace_path("site_packages");
     std::fs::create_dir_all(site_packages.as_std_path())?;
 
-    assert!(resolve_module(case.db().upcast(), &ModuleName::new_static("a").unwrap()).is_none());
+    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("a").unwrap()).is_none());
 
     // Register site-packages as a search path.
     case.update_search_path_settings(SearchPathConfiguration {
@@ -782,7 +751,7 @@ fn add_search_path() -> anyhow::Result<()> {
 
     case.apply_changes(changes);
 
-    assert!(resolve_module(case.db().upcast(), &ModuleName::new_static("a").unwrap()).is_some());
+    assert!(resolve_module(case.db().upcast(), ModuleName::new_static("a").unwrap()).is_some());
 
     Ok(())
 }
@@ -836,7 +805,7 @@ fn changed_versions_file() -> anyhow::Result<()> {
 
     // Unset the custom typeshed directory.
     assert_eq!(
-        resolve_module(case.db(), &ModuleName::new("os").unwrap()),
+        resolve_module(case.db(), ModuleName::new("os").unwrap()),
         None
     );
 
@@ -851,7 +820,7 @@ fn changed_versions_file() -> anyhow::Result<()> {
 
     case.apply_changes(changes);
 
-    assert!(resolve_module(case.db(), &ModuleName::new("os").unwrap()).is_some());
+    assert!(resolve_module(case.db(), ModuleName::new("os").unwrap()).is_some());
 
     Ok(())
 }
@@ -1075,7 +1044,7 @@ mod unix {
 
         let baz = resolve_module(
             case.db().upcast(),
-            &ModuleName::new_static("bar.baz").unwrap(),
+            ModuleName::new_static("bar.baz").unwrap(),
         )
         .expect("Expected bar.baz to exist in site-packages.");
         let baz_workspace = case.workspace_path("bar/baz.py");
@@ -1156,7 +1125,7 @@ mod unix {
 
         let baz = resolve_module(
             case.db().upcast(),
-            &ModuleName::new_static("bar.baz").unwrap(),
+            ModuleName::new_static("bar.baz").unwrap(),
         )
         .expect("Expected bar.baz to exist in site-packages.");
         let bar_baz = case.workspace_path("bar/baz.py");
@@ -1260,7 +1229,7 @@ mod unix {
 
         let baz = resolve_module(
             case.db().upcast(),
-            &ModuleName::new_static("bar.baz").unwrap(),
+            ModuleName::new_static("bar.baz").unwrap(),
         )
         .expect("Expected bar.baz to exist in site-packages.");
         let baz_site_packages_path =

crates/red_knot_python_semantic/Cargo.toml

@@ -24,7 +24,7 @@ bitflags = { workspace = true }
 camino = { workspace = true }
 compact_str = { workspace = true }
 countme = { workspace = true }
-itertools = { workspace = true}
+once_cell = { workspace = true }
 ordermap = { workspace = true }
 salsa = { workspace = true }
 thiserror = { workspace = true }
@@ -34,18 +34,21 @@ hashbrown = { workspace = true }
 smallvec = { workspace = true }
 static_assertions = { workspace = true }
 test-case = { workspace = true }
-memchr = { workspace = true }
+
+[build-dependencies]
+path-slash = { workspace = true }
+walkdir = { workspace = true }
+zip = { workspace = true, features = ["zstd", "deflate"] }
 
 [dev-dependencies]
 ruff_db = { workspace = true, features = ["os", "testing"] }
 ruff_python_parser = { workspace = true }
-red_knot_test = { workspace = true }
-red_knot_vendored = { workspace = true }
 
 anyhow = { workspace = true }
 insta = { workspace = true }
-rstest = { workspace = true }
 tempfile = { workspace = true }
+walkdir = { workspace = true }
+zip = { workspace = true }
 
 [lints]
 workspace = true

crates/red_knot_python_semantic/README.md

@@ -1,5 +1,9 @@
-# Vendored types for the stdlib
+# Red Knot
 
-This crate vendors [typeshed](https://github.com/python/typeshed)'s stubs for the standard library. The vendored stubs can be found in `crates/red_knot_vendored/vendor/typeshed`. The file `crates/red_knot_vendored/vendor/typeshed/source_commit.txt` tells you the typeshed commit that our vendored stdlib stubs currently correspond to.
+Semantic analysis for the red-knot project.
+
+## Vendored types for the stdlib
+
+This crate vendors [typeshed](https://github.com/python/typeshed)'s stubs for the standard library. The vendored stubs can be found in `crates/red_knot_python_semantic/vendor/typeshed`. The file `crates/red_knot_python_semantic/vendor/typeshed/source_commit.txt` tells you the typeshed commit that our vendored stdlib stubs currently correspond to.
 
 The typeshed stubs are updated every two weeks via an automated PR using the `sync_typeshed.yaml` workflow in the `.github/workflows` directory. This workflow can also be triggered at any time via [workflow dispatch](https://docs.github.com/en/actions/using-workflows/manually-running-a-workflow#running-a-workflow).

crates/red_knot_python_semantic/build.rs

@@ -1,4 +1,87 @@
-/// Rebuild the crate if a test file is added or removed from
-pub fn main() {
-    println!("cargo:rerun-if-changed=resources/mdtest");
+//! Build script to package our vendored typeshed files
+//! into a zip archive that can be included in the Ruff binary.
+//!
+//! This script should be automatically run at build time
+//! whenever the script itself changes, or whenever any files
+//! in `crates/red_knot_python_semantic/vendor/typeshed` change.
+
+use std::fs::File;
+use std::path::Path;
+
+use path_slash::PathExt;
+use zip::result::ZipResult;
+use zip::write::{FileOptions, ZipWriter};
+use zip::CompressionMethod;
+
+const TYPESHED_SOURCE_DIR: &str = "vendor/typeshed";
+const TYPESHED_ZIP_LOCATION: &str = "/zipped_typeshed.zip";
+
+/// Recursively zip the contents of an entire directory.
+///
+/// This routine is adapted from a recipe at
+/// <https://github.com/zip-rs/zip-old/blob/5d0f198124946b7be4e5969719a7f29f363118cd/examples/write_dir.rs>
+fn zip_dir(directory_path: &str, writer: File) -> ZipResult<File> {
+    let mut zip = ZipWriter::new(writer);
+
+    // Use deflated compression for WASM builds because compiling `zstd-sys` requires clang
+    // [source](https://github.com/gyscos/zstd-rs/wiki/Compile-for-WASM) which complicates the build
+    // by a lot. Deflated compression is slower but it shouldn't matter much for the WASM use case
+    // (WASM itself is already slower than a native build for a specific platform).
+    // We can't use `#[cfg(...)]` here because the target-arch in a build script is the
+    // architecture of the system running the build script and not the architecture of the build-target.
+    // That's why we use the `TARGET` environment variable here.
+    let method = if std::env::var("TARGET").unwrap().contains("wasm32") {
+        CompressionMethod::Deflated
+    } else {
+        CompressionMethod::Zstd
+    };
+
+    let options = FileOptions::default()
+        .compression_method(method)
+        .unix_permissions(0o644);
+
+    for entry in walkdir::WalkDir::new(directory_path) {
+        let dir_entry = entry.unwrap();
+        let absolute_path = dir_entry.path();
+        let normalized_relative_path = absolute_path
+            .strip_prefix(Path::new(directory_path))
+            .unwrap()
+            .to_slash()
+            .expect("Unexpected non-utf8 typeshed path!");
+
+        // Write file or directory explicitly
+        // Some unzip tools unzip files with directory paths correctly, some do not!
+        if absolute_path.is_file() {
+            println!("adding file {absolute_path:?} as {normalized_relative_path:?} ...");
+            zip.start_file(normalized_relative_path, options)?;
+            let mut f = File::open(absolute_path)?;
+            std::io::copy(&mut f, &mut zip).unwrap();
+        } else if !normalized_relative_path.is_empty() {
+            // Only if not root! Avoids path spec / warning
+            // and mapname conversion failed error on unzip
+            println!("adding dir {absolute_path:?} as {normalized_relative_path:?} ...");
+            zip.add_directory(normalized_relative_path, options)?;
+        }
+    }
+    zip.finish()
+}
+
+fn main() {
+    println!("cargo:rerun-if-changed={TYPESHED_SOURCE_DIR}");
+    assert!(
+        Path::new(TYPESHED_SOURCE_DIR).is_dir(),
+        "Where is typeshed?"
+    );
+    let out_dir = std::env::var("OUT_DIR").unwrap();
+
+    // N.B. Deliberately using `format!()` instead of `Path::join()` here,
+    // so that we use `/` as a path separator on all platforms.
+    // That enables us to load the typeshed zip at compile time in `module.rs`
+    // (otherwise we'd have to dynamically determine the exact path to the typeshed zip
+    // based on the default path separator for the specific platform we're on,
+    // which can't be done at compile time.)
+    let zipped_typeshed_location = format!("{out_dir}{TYPESHED_ZIP_LOCATION}");
+
+    let zipped_typeshed = File::create(zipped_typeshed_location).unwrap();
+    zip_dir(TYPESHED_SOURCE_DIR, zipped_typeshed).unwrap();
 }

crates/red_knot_python_semantic/resources/README.md

@@ -1,4 +0,0 @@
-Markdown files within the `mdtest/` subdirectory are tests of type inference and type checking;
-executed by the `tests/mdtest.rs` integration test.
-
-See `crates/red_knot_test/README.md` for documentation of this test format.

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

@@ -1,25 +0,0 @@
-# Assignment with annotations
-
-## Annotation only transparent to local inference
-
-```py
-x = 1
-x: int
-y = x
-
-reveal_type(y)  # revealed: Literal[1]
-```
-
-## Violates own annotation
-
-```py
-x: int = 'foo' # error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `int`"
-
-```
-
-## Violates previous annotation
-
-```py
-x: int
-x = 'foo'  # error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `int`"
-```

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

@@ -1,9 +0,0 @@
-# Multi-target assignment
-
-## Basic
-
-```py
-x = y = 1
-reveal_type(x)  # revealed: Literal[1]
-reveal_type(y)  # revealed: Literal[1]
-```

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

@@ -1,24 +0,0 @@
-# Unbound
-
-## Unbound
-
-```py
-x = foo
-foo = 1
-reveal_type(x)  # revealed: Unbound
-```
-
-## Unbound class variable
-
-Name lookups within a class scope fall back to globals, but lookups of class attributes don't.
-
-```py
-x = 1
-class C:
-    y = x
-    if flag:
-        x = 2
-
-reveal_type(C.x) # revealed: Literal[2]
-reveal_type(C.y) # revealed: Literal[1]
-```

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

@@ -1,17 +0,0 @@
-# Walrus operator
-
-## Basic
-
-```py
-x = (y := 1) + 1
-reveal_type(x)  # revealed: Literal[2]
-reveal_type(y)  # revealed: Literal[1]
-```
-
-## Walrus self-addition
-
-```py
-x = 0
-(x := x + 1)
-reveal_type(x)  # revealed: Literal[1]
-```

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -1,15 +0,0 @@
-# Class attributes
-
-## Union of attributes
-
-```py
-if flag:
-    class C:
-        x = 1
-else:
-    class C:
-        x = 2
-
-y = C.x
-reveal_type(y)  # revealed: Literal[1, 2]
-```

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

@@ -1,36 +0,0 @@
-## Binary operations on integers
-
-## Basic Arithmetic
-
-```py
-a = 2 + 1
-b = a - 4
-c = a * b
-d = c // 3
-e = c / 3
-f = 5 % 3
-
-reveal_type(a)  # revealed: Literal[3]
-reveal_type(b)  # revealed: Literal[-1]
-reveal_type(c)  # revealed: Literal[-3]
-reveal_type(d)  # revealed: Literal[-1]
-reveal_type(e)  # revealed: float
-reveal_type(f)  # revealed: Literal[2]
-```
-
-## Division by Zero
-
-```py
-# TODO: `a` should be `int` and `e` should be `float` once we support inference.
-a = 1 / 0  # error: "Cannot divide object of type `Literal[1]` by zero"
-b = 2 // 0  # error: "Cannot floor divide object of type `Literal[2]` by zero"
-c = 3 % 0  # error: "Cannot reduce object of type `Literal[3]` modulo zero"
-d = int() / 0  # error: "Cannot divide object of type `int` by zero"
-e = 1.0 / 0  # error: "Cannot divide object of type `float` by zero"
-
-reveal_type(a)  # revealed: float
-reveal_type(b)  # revealed: int
-reveal_type(c)  # revealed: int
-reveal_type(d)  # revealed: @Todo
-reveal_type(e)  # revealed: @Todo
-```

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

@@ -1,21 +0,0 @@
-# Callable instance
-
-## Dunder call
-
-```py
-class Multiplier:
-    def __init__(self, factor: float):
-        self.factor = factor
-
-    def __call__(self, number: float) -> float:
-        return number * self.factor
-
-a = Multiplier(2.0)(3.0)
-
-class Unit: ...
-
-b = Unit()(3.0) # error: "Object of type `Unit` is not callable"
-
-reveal_type(a) # revealed: float
-reveal_type(b) # revealed: Unknown
-```

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

@@ -1,8 +0,0 @@
-# Constructor
-
-```py
-class Foo: ...
-
-x = Foo()
-reveal_type(x)  # revealed: Foo
-```

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

@@ -1,51 +0,0 @@
-# Call expression
-
-## Simple
-
-```py
-def get_int() -> int:
-    return 42
-
-x = get_int()
-reveal_type(x)  # revealed: int
-```
-
-## Async
-
-```py
-async def get_int_async() -> int:
-    return 42
-
-x = get_int_async()
-
-# TODO: we don't yet support `types.CoroutineType`, should be generic `Coroutine[Any, Any, int]`
-reveal_type(x)  # revealed: @Todo
-```
-
-## Decorated
-
-```py
-from typing import Callable
-
-def foo() -> int:
-    return 42
-
-def decorator(func) -> Callable[[], int]:
-    return foo
-
-@decorator
-def bar() -> str:
-    return 'bar'
-
-x = bar()
-
-# TODO: should reveal `int`, as the decorator replaces `bar` with `foo`
-reveal_type(x)  # revealed: @Todo
-```
-
-## Invalid callable
-
-```py
-nonsense = 123
-x = nonsense()  # error: "Object of type `Literal[123]` is not callable"
-```

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

@@ -1,74 +0,0 @@
-# Unions in calls
-
-## Union of return types
-
-```py
-if flag:
-    def f() -> int:
-        return 1
-else:
-    def f() -> str:
-        return 'foo'
-
-x = f()
-reveal_type(x)  # revealed: int | str
-```
-
-## Calling with an unknown union
-
-```py
-from nonexistent import f # error: [unresolved-import] "Cannot resolve import `nonexistent`"
-
-if flag:
-    def f() -> int:
-        return 1
-
-x = f()
-reveal_type(x)  # revealed: Unknown | int
-```
-
-## Non-callable elements in a union
-
-Calling a union with a non-callable element should emit a diagnostic.
-
-```py
-if flag:
-    f = 1
-else:
-    def f() -> int:
-        return 1
-
-x = f()  # error: "Object of type `Literal[1] | Literal[f]` is not callable (due to union element `Literal[1]`)"
-reveal_type(x)  # revealed: Unknown | int
-```
-
-## Multiple non-callable elements in a union
-
-Calling a union with multiple non-callable elements should mention all of them in the diagnostic.
-
-```py
-if flag:
-    f = 1
-elif flag2:
-    f = 'foo'
-else:
-    def f() -> int:
-        return 1
-
-x = f()  # error: "Object of type `Literal[1] | Literal["foo"] | Literal[f]` is not callable (due to union elements Literal[1], Literal["foo"])"
-reveal_type(x)  # revealed: Unknown | int
-```
-
-## All non-callable union elements
-
-Calling a union with no callable elements can emit a simpler diagnostic.
-
-```py
-if flag:
-    f = 1
-else:
-    f = 'foo'
-
-x = f()  # error: "Object of type `Literal[1] | Literal["foo"]` is not callable"
-reveal_type(x)  # revealed: Unknown
-```

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

@@ -1,43 +0,0 @@
-### Comparison: Byte literals
-
-These tests assert that we infer precise `Literal` types for comparisons between objects
-inferred as having `Literal` bytes types:
-
-```py
-reveal_type(b"abc" == b"abc")  # revealed: Literal[True]
-reveal_type(b"abc" == b"ab")   # revealed: Literal[False]
-
-reveal_type(b"abc" != b"abc")  # revealed: Literal[False]
-reveal_type(b"abc" != b"ab")   # revealed: Literal[True]
-
-reveal_type(b"abc" < b"abd")   # revealed: Literal[True]
-reveal_type(b"abc" < b"abb")   # revealed: Literal[False]
-
-reveal_type(b"abc" <= b"abc")  # revealed: Literal[True]
-reveal_type(b"abc" <= b"abb")  # revealed: Literal[False]
-
-reveal_type(b"abc" > b"abd")   # revealed: Literal[False]
-reveal_type(b"abc" > b"abb")   # revealed: Literal[True]
-
-reveal_type(b"abc" >= b"abc")  # revealed: Literal[True]
-reveal_type(b"abc" >= b"abd")  # revealed: Literal[False]
-
-reveal_type(b"" in b"")                      # revealed: Literal[True]
-reveal_type(b"" in b"abc")                   # revealed: Literal[True]
-reveal_type(b"abc" in b"")                   # revealed: Literal[False]
-reveal_type(b"ab" in b"abc")                 # revealed: Literal[True]
-reveal_type(b"abc" in b"abc")                # revealed: Literal[True]
-reveal_type(b"d" in b"abc")                  # revealed: Literal[False]
-reveal_type(b"ac" in b"abc")                 # revealed: Literal[False]
-reveal_type(b"\x81\x82" in b"\x80\x81\x82")  # revealed: Literal[True]
-reveal_type(b"\x82\x83" in b"\x80\x81\x82")  # revealed: Literal[False]
-
-reveal_type(b"ab" not in b"abc")             # revealed: Literal[False]
-reveal_type(b"ac" not in b"abc")             # revealed: Literal[True]
-
-reveal_type(b"abc" is b"abc")      # revealed: bool
-reveal_type(b"abc" is b"ab")       # revealed: Literal[False]
-
-reveal_type(b"abc" is not b"abc")  # revealed: bool
-reveal_type(b"abc" is not b"ab")   # revealed: Literal[True]
-```

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

@@ -1,41 +0,0 @@
-# Comparing integers
-
-## Integer literals
-
-```py
-a = 1 == 1 == True
-b = 1 == 1 == 2 == 4
-c = False < True <= 2 < 3 != 6
-d = 1 < 1
-e = 1 > 1
-f = 1 is 1
-g = 1 is not 1
-h = 1 is 2
-i = 1 is not 7
-j = 1 <= "" and 0 < 1
-
-reveal_type(a)  # revealed: Literal[True]
-reveal_type(b)  # revealed: Literal[False]
-reveal_type(c)  # revealed: Literal[True]
-reveal_type(d)  # revealed: Literal[False]
-reveal_type(e)  # revealed: Literal[False]
-reveal_type(f)  # revealed: bool
-reveal_type(g)  # revealed: bool
-reveal_type(h)  # revealed: Literal[False]
-reveal_type(i)  # revealed: Literal[True]
-reveal_type(j)  # revealed: @Todo | Literal[True]
-```
-
-## Integer instance
-
-```py
-# TODO: implement lookup of `__eq__` on typeshed `int` stub.
-def int_instance() -> int: ...
-a = 1 == int_instance()
-b = 9 < int_instance()
-c = int_instance() < int_instance()
-
-reveal_type(a)  # revealed: @Todo
-reveal_type(b)  # revealed: bool
-reveal_type(c)  # revealed: bool
-```

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

@@ -1,37 +0,0 @@
-# Non boolean returns
-
-Walking through examples:
-
-- `a = A() < B() < C()`
-
-    1. `A() < B() and B() < C()` - split in N comparison
-    1. `A()` and `B()`              - evaluate outcome types
-    1. `bool` and `bool`            - evaluate truthiness
-    1. `A | B`                    - union of "first true" types
-
-- `b = 0 < 1 < A() < 3`
-
-    1. `0 < 1 and 1 < A() and A() < 3` - split in N comparison
-    1. `True` and `bool` and `A` - evaluate outcome types
-    1. `True` and `bool` and `bool` - evaluate truthiness
-    1. `bool | A` - union of "true" types
-
-- `c = 10 < 0 < A() < B() < C()` short-circuit to False
-
-```py
-from __future__ import annotations
-class A:
-    def __lt__(self, other) -> A: ...
-class B:
-    def __lt__(self, other) -> B: ...
-class C:
-    def __lt__(self, other) -> C: ...
-
-a = A() < B() < C()
-b = 0 < 1 < A() < 3
-c = 10 < 0 < A() < B() < C()
-
-reveal_type(a)  # revealed: A | B
-reveal_type(b)  # revealed: bool | A
-reveal_type(c)  # revealed: Literal[False]
-```

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

@@ -1,29 +0,0 @@
-# Comparing strings
-
-## String literals
-
-```py
-def str_instance() -> str: ...
-a = "abc" == "abc"
-b = "ab_cd" <= "ab_ce"
-c = "abc" in "ab cd"
-d = "" not in "hello"
-e = "--" is "--"
-f = "A" is "B"
-g = "--" is not "--"
-h = "A" is not "B"
-i = str_instance() < "..."
-# ensure we're not comparing the interned salsa symbols, which compare by order of declaration.
-j = "ab" < "ab_cd"
-
-reveal_type(a)  # revealed: Literal[True]
-reveal_type(b)  # revealed: Literal[True]
-reveal_type(c)  # revealed: Literal[False]
-reveal_type(d)  # revealed: Literal[False]
-reveal_type(e)  # revealed: bool
-reveal_type(f)  # revealed: Literal[False]
-reveal_type(g)  # revealed: bool
-reveal_type(h)  # revealed: Literal[True]
-reveal_type(i)  # revealed: bool
-reveal_type(j)  # revealed: Literal[True]
-```

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

@@ -1,205 +0,0 @@
-# Comparison - Tuples
-
-## Heterogeneous
-
-For tuples like `tuple[int, str, Literal[1]]`
-
-### Value Comparisons
-
-"Value Comparisons" refers to the operators: `==`, `!=`, `<`, `<=`, `>`, `>=`
-
-#### Results without Ambiguity
-
-Cases where the result can be definitively inferred as a `BooleanLiteral`.
-
-```py
-a = (1, "test", (3, 13), True)
-b = (1, "test", (3, 14), False)
-
-reveal_type(a == a)  # revealed: Literal[True]
-reveal_type(a != a)  # revealed: Literal[False]
-reveal_type(a < a)   # revealed: Literal[False]
-reveal_type(a <= a)  # revealed: Literal[True]
-reveal_type(a > a)   # revealed: Literal[False]
-reveal_type(a >= a)  # revealed: Literal[True]
-
-reveal_type(a == b)  # revealed: Literal[False]
-reveal_type(a != b)  # revealed: Literal[True]
-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]
-```
-
-Even when tuples have different lengths, comparisons should be handled appropriately.
-
-```py path=different_length.py
-a = (1, 2, 3)
-b = (1, 2, 3, 4)
-
-reveal_type(a == b)  # revealed: Literal[False]
-reveal_type(a != b)  # revealed: Literal[True]
-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]
-
-c = ("a", "b", "c", "d")
-d = ("a", "b", "c")
-
-reveal_type(c == d)  # revealed: Literal[False]
-reveal_type(c != d)  # revealed: Literal[True]
-reveal_type(c < d)   # revealed: Literal[False]
-reveal_type(c <= d)  # revealed: Literal[False]
-reveal_type(c > d)   # revealed: Literal[True]
-reveal_type(c >= d)  # revealed: Literal[True]
-```
-
-#### Results with Ambiguity
-
-```py
-def bool_instance() -> bool: ...
-def int_instance() -> int: ...
-
-a = (bool_instance(),)
-b = (int_instance(),)
-
-# TODO: All @Todo should be `bool`
-reveal_type(a == a)  # revealed: @Todo
-reveal_type(a != a)  # revealed: @Todo
-reveal_type(a < a)   # revealed: @Todo
-reveal_type(a <= a)  # revealed: @Todo
-reveal_type(a > a)   # revealed: @Todo
-reveal_type(a >= a)  # revealed: @Todo
-
-reveal_type(a == b)  # revealed: @Todo
-reveal_type(a != b)  # revealed: @Todo
-reveal_type(a < b)   # revealed: @Todo
-reveal_type(a <= b)  # revealed: @Todo
-reveal_type(a > b)   # revealed: @Todo
-reveal_type(a >= b)  # revealed: @Todo
-```
-
-#### Comparison Unsupported
-
-If two tuples contain types that do not support comparison, the result may be `Unknown`.
-However, `==` and `!=` are exceptions and can still provide definite results.
-
-```py
-a = (1, 2)
-b = (1, "hello")
-
-# TODO: should be Literal[False]
-reveal_type(a == b)  # revealed: @Todo
-
-# TODO: should be Literal[True]
-reveal_type(a != b)  # revealed: @Todo
-
-# TODO: should be Unknown and add more informative diagnostics
-reveal_type(a < b)   # revealed: @Todo
-reveal_type(a <= b)  # revealed: @Todo
-reveal_type(a > b)   # revealed: @Todo
-reveal_type(a >= b)  # revealed: @Todo
-```
-
-However, if the lexicographic comparison completes without reaching a point where str and int are compared,
-Python will still produce a result based on the prior elements.
-
-```py path=short_circuit.py
-a = (1, 2)
-b = (999999, "hello")
-
-reveal_type(a == b)  # revealed: Literal[False]
-reveal_type(a != b)  # revealed: Literal[True]
-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]
-```
-
-#### Matryoshka Tuples
-
-```py
-a = (1, True, "Hello")
-b = (a, a, a)
-c = (b, b, b)
-
-reveal_type(c == c)  # revealed: Literal[True]
-reveal_type(c != c)  # revealed: Literal[False]
-reveal_type(c < c)   # revealed: Literal[False]
-reveal_type(c <= c)  # revealed: Literal[True]
-reveal_type(c > c)   # revealed: Literal[False]
-reveal_type(c >= c)  # revealed: Literal[True]
-```
-
-#### Non Boolean Rich Comparisons
-
-```py
-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: ...
-
-a = (A(), A())
-
-# TODO: All @Todo should be bool
-reveal_type(a == a)  # revealed: @Todo
-reveal_type(a != a)  # revealed: @Todo
-reveal_type(a < a)   # revealed: @Todo
-reveal_type(a <= a)  # revealed: @Todo
-reveal_type(a > a)   # revealed: @Todo
-reveal_type(a >= a)  # revealed: @Todo
-```
-
-### Membership Test Comparisons
-
-"Membership Test Comparisons" refers to the operators `in` and `not in`.
-
-```py
-def int_instance() -> int: ...
-
-a = (1, 2)
-b = ((3, 4), (1, 2))
-c = ((1, 2, 3), (4, 5, 6))
-d = ((int_instance(), int_instance()), (int_instance(), int_instance()))
-
-reveal_type(a in b)  # revealed: Literal[True]
-reveal_type(a not in b)  # revealed: Literal[False]
-
-reveal_type(a in c)  # revealed: Literal[False]
-reveal_type(a not in c)  # revealed: Literal[True]
-
-# TODO: All @Todo should be bool
-reveal_type(a in d)  # revealed: @Todo
-reveal_type(a not in d)  # revealed: @Todo
-```
-
-### Identity Comparisons
-
-"Identity Comparisons" refers to `is` and `is not`.
-
-```py
-a = (1, 2)
-b = ("a", "b")
-c = (1, 2, 3)
-
-reveal_type(a is (1, 2))  # revealed: bool
-reveal_type(a is not (1, 2))  # revealed: bool
-
-# TODO: Update to Literal[False] once str == int comparison is implemented
-reveal_type(a is b)  # revealed: @Todo
-# TODO: Update to Literal[True] once str == int comparison is implemented
-reveal_type(a is not b)  # revealed: @Todo
-
-reveal_type(a is c)  # revealed: Literal[False]
-reveal_type(a is not c)  # revealed: Literal[True]
-```
-
-## Homogeneous
-
-For tuples like `tuple[int, ...]`, `tuple[Any, ...]`
-
-// TODO

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

@@ -1,15 +0,0 @@
-# Unsupported operators
-
-```py
-a = 1 in 7      # error: "Operator `in` is not supported for types `Literal[1]` and `Literal[7]`"
-b = 0 not in 10 # error: "Operator `not in` is not supported for types `Literal[0]` and `Literal[10]`"
-c = object() < 5 # error: "Operator `<` is not supported for types `object` and `Literal[5]`"
-# TODO should error, need to check if __lt__ signature is valid for right operand
-d = 5 < object()
-
-reveal_type(a)  # revealed: bool
-reveal_type(b)  # revealed: bool
-reveal_type(c)  # revealed: Unknown
-# TODO: should be `Unknown`
-reveal_type(d)  # revealed: bool
-```

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

@@ -1,35 +0,0 @@
-# If expressions
-
-## Simple if-expression
-
-```py
-x = 1 if flag else 2
-reveal_type(x)  # revealed: Literal[1, 2]
-```
-
-## If-expression with walrus operator
-
-```py
-y = 0
-z = 0
-x = (y := 1) if flag else (z := 2)
-a = y
-b = z
-reveal_type(x)  # revealed: Literal[1, 2]
-reveal_type(a)  # revealed: Literal[0, 1]
-reveal_type(b)  # revealed: Literal[0, 2]
-```
-
-## Nested if-expression
-
-```py
-x = 1 if flag else 2 if flag2 else 3
-reveal_type(x)  # revealed: Literal[1, 2, 3]
-```
-
-## None
-
-```py
-x = 1 if flag else None
-reveal_type(x)  # revealed: Literal[1] | None
-```

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

@@ -1,98 +0,0 @@
-# If statements
-
-## Simple if
-
-```py
-y = 1
-y = 2
-
-if flag:
-    y = 3
-
-x = y
-
-reveal_type(x)  # revealed: Literal[2, 3]
-```
-
-## Simple if-elif-else
-
-```py
-y = 1
-y = 2
-if flag:
-    y = 3
-elif flag2:
-    y = 4
-else:
-    r = y
-    y = 5
-    s = y
-x = y
-
-reveal_type(x)  # revealed: Literal[3, 4, 5]
-reveal_type(r)  # revealed: Unbound | Literal[2]
-reveal_type(s)  # revealed: Unbound | Literal[5]
-```
-
-## Single symbol across if-elif-else
-
-```py
-if flag:
-    y = 1
-elif flag2:
-    y = 2
-else:
-    y = 3
-reveal_type(y)  # revealed: Literal[1, 2, 3]
-```
-
-## if-elif-else without else assignment
-
-```py
-y = 0
-if flag:
-    y = 1
-elif flag2:
-    y = 2
-else:
-    pass
-reveal_type(y)  # revealed: Literal[0, 1, 2]
-```
-
-## if-elif-else with intervening assignment
-
-```py
-y = 0
-if flag:
-    y = 1
-    z = 3
-elif flag2:
-    y = 2
-else:
-    pass
-reveal_type(y)  # revealed: Literal[0, 1, 2]
-```
-
-## Nested if statement
-
-```py
-y = 0
-if flag:
-    if flag2:
-        y = 1
-reveal_type(y)  # revealed: Literal[0, 1]
-```
-
-## if-elif without else
-
-```py
-y = 1
-y = 2
-if flag:
-    y = 3
-elif flag2:
-    y = 4
-x = y
-
-reveal_type(x)  # revealed: Literal[2, 3, 4]
-```

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

@@ -1,39 +0,0 @@
-# Pattern matching
-
-## With wildcard
-
-```py
-match 0:
-    case 1:
-        y = 2
-    case _:
-        y = 3
-
-reveal_type(y)  # revealed: Literal[2, 3]
-```
-
-## Without wildcard
-
-```py
-match 0:
-    case 1:
-        y = 2
-    case 2:
-        y = 3
-
-reveal_type(y)  # revealed: Unbound | Literal[2, 3]
-```
-
-## Basic match
-
-```py
-y = 1
-y = 2
-match 0:
-    case 1:
-        y = 3
-    case 2:
-        y = 4
-
-reveal_type(y)  # revealed: Literal[2, 3, 4]
-```

crates/red_knot_python_semantic/resources/mdtest/declaration/error.md

@@ -1,39 +0,0 @@
-# Errors while declaring
-
-## Violates previous assignment
-
-```py
-x = 1
-x: str  # error: [invalid-declaration] "Cannot declare type `str` for inferred type `Literal[1]`"
-```
-
-## Incompatible declarations
-
-```py
-if flag:
-    x: str
-else:
-    x: int
-x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: str, int"
-```
-
-## Partial declarations
-
-```py
-if flag:
-    x: int
-x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: Unknown, int"
-```
-
-## Incompatible declarations with bad assignment
-
-```py
-if flag:
-    x: str
-else:
-    x: int
-
-# error: [conflicting-declarations]
-# error: [invalid-assignment]
-x = b'foo'
-```

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

@@ -1,55 +0,0 @@
-# Exception Handling
-
-## Single Exception
-
-```py
-import re
-try:
-    x
-except NameError as e:
-    reveal_type(e)  # revealed: NameError
-except re.error as f:
-    reveal_type(f)  # revealed: error
-```
-
-## Unknown type in except handler does not cause spurious diagnostic
-
-```py
-from nonexistent_module import foo # error: [unresolved-import]
-
-try:
-    x
-except foo as e:
-    reveal_type(foo)  # revealed: Unknown
-    reveal_type(e)  # revealed: Unknown
-```
-
-## Multiple Exceptions in a Tuple
-
-```py
-EXCEPTIONS = (AttributeError, TypeError)
-
-try:
-    x
-except (RuntimeError, OSError) as e:
-    reveal_type(e)  # revealed: RuntimeError | OSError
-except EXCEPTIONS as f:
-    reveal_type(f)  # revealed: AttributeError | TypeError
-```
-
-## Dynamic exception types
-
-```py
-def foo(x: type[AttributeError], y: tuple[type[OSError], type[RuntimeError]], z: tuple[type[BaseException], ...]):
-    try:
-        w
-    except x as e:
-        # TODO: should be `AttributeError`
-        reveal_type(e)  # revealed: @Todo
-    except y as f:
-        # TODO: should be `OSError | RuntimeError`
-        reveal_type(f)  # revealed: @Todo
-    except z as g:
-        # TODO: should be `BaseException`
-        reveal_type(g)  # revealed: @Todo
-```

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

@@ -1,641 +0,0 @@
-# Control flow for exception handlers
-
-These tests assert that we understand the possible "definition states" (which
-symbols might or might not be defined) in the various branches of a
-`try`/`except`/`else`/`finally` block.
-
-For a full writeup on the semantics of exception handlers,
-see [this document][1].
-
-The tests throughout this Markdown document use functions with names starting
-with `could_raise_*` to mark definitions that might or might not succeed
-(as the function could raise an exception). A type checker must assume that any
-arbitrary function call could raise an exception in Python; this is just a
-naming convention used in these tests for clarity, and to future-proof the
-tests against possible future improvements whereby certain statements or
-expressions could potentially be inferred as being incapable of causing an
-exception to be raised.
-
-## A single bare `except`
-
-Consider the following `try`/`except` block, with a single bare `except:`.
-There are different types for the variable `x` in the two branches of this
-block, and we can't determine which branch might have been taken from the
-perspective of code following this block. The inferred type after the block's
-conclusion is therefore the union of the type at the end of the `try` suite
-(`str`) and the type at the end of the `except` suite (`Literal[2]`).
-
-*Within* the `except` suite, we must infer a union of all possible "definition
-states" we could have been in at any point during the `try` suite. This is
-because control flow could have jumped to the `except` suite without any of the
-`try`-suite definitions successfully completing, with only *some* of the
-`try`-suite definitions successfully completing, or indeed with *all* of them
-successfully completing. The type of `x` at the beginning of the `except` suite
-in this example is therefore `Literal[1] | str`, taking into account that we
-might have jumped to the `except` suite before the
-`x = could_raise_returns_str()` redefinition, but we *also* could have jumped
-to the `except` suite *after* that redefinition.
-
-```py path=union_type_inferred.py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-
-reveal_type(x)  # revealed: str | Literal[2]
-```
-
-If `x` has the same type at the end of both branches, however, the branches
-unify and `x` is not inferred as having a union type following the
-`try`/`except` block:
-
-```py path=branches_unify_to_non_union_type.py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-x = 1
-
-try:
-    x = could_raise_returns_str()
-except:
-    x = could_raise_returns_str()
-
-reveal_type(x)  # revealed: str
-```
-
-## A non-bare `except`
-
-For simple `try`/`except` blocks, an `except TypeError:` handler has the same
-control flow semantics as an `except:` handler. An `except TypeError:` handler
-will not catch *all* exceptions: if this is the only handler, it opens up the
-possibility that an exception might occur that would not be handled. However,
-as described in [the document on exception-handling semantics][1], that would
-lead to termination of the scope. It's therefore irrelevant to consider this
-possibility when it comes to control-flow analysis.
-
-```py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-
-reveal_type(x)  # revealed: str | Literal[2]
-```
-
-## Multiple `except` branches
-
-If the scope reaches the final `reveal_type` call in this example,
-either the `try`-block suite of statements was executed in its entirety,
-or exactly one `except` suite was executed in its entirety.
-The inferred type of `x` at this point is the union of the types at the end of
-the three suites:
-
-- At the end of `try`, `type(x) == str`
-- At the end of `except TypeError`, `x == 2`
-- At the end of `except ValueError`, `x == 3`
-
-```py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-except ValueError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 3
-    reveal_type(x)  # revealed: Literal[3]
-
-reveal_type(x)  # revealed: str | Literal[2, 3]
-```
-
-## Exception handlers with `else` branches (but no `finally`)
-
-If we reach the `reveal_type` call at the end of this scope,
-either the `try` and `else` suites were both executed in their entireties,
-or the `except` suite was executed in its entirety. The type of `x` at this
-point is the union of the type at the end of the `else` suite and the type at
-the end of the `except` suite:
-
-- At the end of `else`, `x == 3`
-- At the end of `except`, `x == 2`
-
-```py path=single_except.py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-else:
-    reveal_type(x)  # revealed: str
-    x = 3
-    reveal_type(x)  # revealed: Literal[3]
-
-reveal_type(x)  # revealed: Literal[2, 3]
-```
-
-For a block that has multiple `except` branches and an `else` branch, the same
-principle applies. In order to reach the final `reveal_type` call,
-either exactly one of the `except` suites must have been executed in its
-entirety, or the `try` suite and the `else` suite must both have been executed
-in their entireties:
-
-```py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-except ValueError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 3
-    reveal_type(x)  # revealed: Literal[3]
-else:
-    reveal_type(x)  # revealed: str
-    x = 4
-    reveal_type(x)  # revealed: Literal[4]
-
-reveal_type(x)  # revealed: Literal[2, 3, 4]
-```
-
-## Exception handlers with `finally` branches (but no `except` branches)
-
-A `finally` suite is *always* executed. As such, if we reach the `reveal_type`
-call at the end of this example, we know that `x` *must* have been reassigned
-to `2` during the `finally` suite. The type of `x` at the end of the example is
-therefore `Literal[2]`:
-
-```py path=redef_in_finally.py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-finally:
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-
-reveal_type(x)  # revealed: Literal[2]
-```
-
-If `x` was *not* redefined in the `finally` suite, however, things are somewhat
-more complicated. If we reach the final `reveal_type` call,
-unlike the state when we're visiting the `finally` suite,
-we know that the `try`-block suite ran to completion.
-This means that there are fewer possible states at this point than there were
-when we were inside the `finally` block.
-
-(Our current model does *not* correctly infer the types *inside* `finally`
-suites, however; this is still a TODO item for us.)
-
-```py path=no_redef_in_finally.py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-finally:
-    # TODO: should be Literal[1] | str
-    reveal_type(x)  # revealed: str
-
-reveal_type(x)  # revealed: str
-```
-
-## Combining an `except` branch with a `finally` branch
-
-As previously stated, we do not yet have accurate inference for types *inside*
-`finally` suites. When we do, however, we will have to take account of the
-following possibilities inside `finally` suites:
-
-- The `try` suite could have run to completion
-- Or we could have jumped from halfway through the `try` suite to an `except`
-    suite, and the `except` suite ran to completion
-- Or we could have jumped from halfway through the `try` suite straight to the
-    `finally` suite due to an unhandled exception
-- Or we could have jumped from halfway through the `try` suite to an
-    `except` suite, only for an exception raised in the `except` suite to cause
-    us to jump to the `finally` suite before the `except` suite ran to completion
-
-```py path=redef_in_finally.py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-def could_raise_returns_bytes() -> bytes:
-    return b'foo'
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_bytes()
-    reveal_type(x)  # revealed: bytes
-    x = could_raise_returns_bool()
-    reveal_type(x)  # revealed: bool
-finally:
-    # TODO: should be `Literal[1] | str | bytes | bool`
-    reveal_type(x)  # revealed: str | bool
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-
-reveal_type(x)  # revealed: Literal[2]
-```
-
-Now for an example without a redefinition in the `finally` suite.
-As before, there *should* be fewer possibilities after completion of the
-`finally` suite than there were during the `finally` suite itself.
-(In some control-flow possibilities, some exceptions were merely *suspended*
-during the `finally` suite; these lead to the scope's termination following the
-conclusion of the `finally` suite.)
-
-```py path=no_redef_in_finally.py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-def could_raise_returns_bytes() -> bytes:
-    return b'foo'
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_bytes()
-    reveal_type(x)  # revealed: bytes
-    x = could_raise_returns_bool()
-    reveal_type(x)  # revealed: bool
-finally:
-    # TODO: should be `Literal[1] | str | bytes | bool`
-    reveal_type(x)  # revealed: str | bool
-
-reveal_type(x)  # revealed: str | bool
-```
-
-An example with multiple `except` branches and a `finally` branch:
-
-```py path=multiple_except_branches.py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-def could_raise_returns_bytes() -> bytes:
-    return b'foo'
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-def could_raise_returns_memoryview() -> memoryview:
-    return memoryview(b"")
-
-def could_raise_returns_float() -> float:
-    return 3.14
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_bytes()
-    reveal_type(x)  # revealed: bytes
-    x = could_raise_returns_bool()
-    reveal_type(x)  # revealed: bool
-except ValueError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_memoryview()
-    reveal_type(x)  # revealed: memoryview
-    x = could_raise_returns_float()
-    reveal_type(x)  # revealed: float
-finally:
-    # TODO: should be `Literal[1] | str | bytes | bool | memoryview | float`
-    reveal_type(x)  # revealed: str | bool | float
-
-reveal_type(x)  # revealed: str | bool | float
-```
-
-## Combining `except`, `else` and `finally` branches
-
-If the exception handler has an `else` branch, we must also take into account
-the possibility that control flow could have jumped to the `finally` suite from
-partway through the `else` suite due to an exception raised *there*.
-
-```py path=single_except_branch.py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-def could_raise_returns_bytes() -> bytes:
-    return b'foo'
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-def could_raise_returns_memoryview() -> memoryview:
-    return memoryview(b"")
-
-def could_raise_returns_float() -> float:
-    return 3.14
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_bytes()
-    reveal_type(x)  # revealed: bytes
-    x = could_raise_returns_bool()
-    reveal_type(x)  # revealed: bool
-else:
-    reveal_type(x)  # revealed: str
-    x = could_raise_returns_memoryview()
-    reveal_type(x)  # revealed: memoryview
-    x = could_raise_returns_float()
-    reveal_type(x)  # revealed: float
-finally:
-    # TODO: should be `Literal[1] | str | bytes | bool | memoryview | float`
-    reveal_type(x)  # revealed: bool | float
-
-reveal_type(x)  # revealed: bool | float
-```
-
-The same again, this time with multiple `except` branches:
-
-```py path=multiple_except_branches.py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-def could_raise_returns_bytes() -> bytes:
-    return b'foo'
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-def could_raise_returns_memoryview() -> memoryview:
-    return memoryview(b"")
-
-def could_raise_returns_float() -> float:
-    return 3.14
-
-def could_raise_returns_range() -> range:
-    return range(42)
-
-def could_raise_returns_slice() -> slice:
-    return slice(None)
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_bytes()
-    reveal_type(x)  # revealed: bytes
-    x = could_raise_returns_bool()
-    reveal_type(x)  # revealed: bool
-except ValueError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_memoryview()
-    reveal_type(x)  # revealed: memoryview
-    x = could_raise_returns_float()
-    reveal_type(x)  # revealed: float
-else:
-    reveal_type(x)  # revealed: str
-    x = could_raise_returns_range()
-    reveal_type(x)  # revealed: range
-    x = could_raise_returns_slice()
-    reveal_type(x)  # revealed: slice
-finally:
-    # TODO: should be `Literal[1] | str | bytes | bool | memoryview | float | range | slice`
-    reveal_type(x)  # revealed: bool | float | slice
-
-reveal_type(x)  # revealed: bool | float | slice
-```
-
-## Nested `try`/`except` blocks
-
-It would take advanced analysis, which we are not yet capable of, to be able
-to determine that an exception handler always suppresses all exceptions. This
-is partly because it is possible for statements in `except`, `else` and
-`finally` suites to raise exceptions as well as statements in `try` suites.
-This means that if an exception handler is nested inside the `try` statement of
-an enclosing exception handler, it should (at least for now) be treated the
-same as any other node: as a suite containing statements that could possibly
-raise exceptions, which would lead to control flow jumping out of that suite
-prior to the suite running to completion.
-
-```py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-def could_raise_returns_bytes() -> bytes:
-    return b'foo'
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-def could_raise_returns_memoryview() -> memoryview:
-    return memoryview(b"")
-
-def could_raise_returns_float() -> float:
-    return 3.14
-
-def could_raise_returns_range() -> range:
-    return range(42)
-
-def could_raise_returns_slice() -> slice:
-    return slice(None)
-
-def could_raise_returns_complex() -> complex:
-    return 3j
-
-def could_raise_returns_bytearray() -> bytearray:
-    return bytearray()
-
-class Foo: ...
-class Bar: ...
-
-def could_raise_returns_Foo() -> Foo:
-    return Foo()
-
-def could_raise_returns_Bar() -> Bar:
-    return Bar()
-
-x = 1
-
-try:
-    try:
-        reveal_type(x)  # revealed: Literal[1]
-        x = could_raise_returns_str()
-        reveal_type(x)  # revealed: str
-    except TypeError:
-        reveal_type(x)  # revealed: Literal[1] | str
-        x = could_raise_returns_bytes()
-        reveal_type(x)  # revealed: bytes
-        x = could_raise_returns_bool()
-        reveal_type(x)  # revealed: bool
-    except ValueError:
-        reveal_type(x)  # revealed: Literal[1] | str
-        x = could_raise_returns_memoryview()
-        reveal_type(x)  # revealed: memoryview
-        x = could_raise_returns_float()
-        reveal_type(x)  # revealed: float
-    else:
-        reveal_type(x)  # revealed: str
-        x = could_raise_returns_range()
-        reveal_type(x)  # revealed: range
-        x = could_raise_returns_slice()
-        reveal_type(x)  # revealed: slice
-    finally:
-        # TODO: should be `Literal[1] | str | bytes | bool | memoryview | float | range | slice`
-        reveal_type(x)  # revealed: bool | float | slice
-        x = 2
-        reveal_type(x)  # revealed: Literal[2]
-    reveal_type(x)  # revealed: Literal[2]
-except:
-    reveal_type(x)  # revealed: Literal[1, 2] | str | bytes | bool | memoryview | float | range | slice
-    x = could_raise_returns_complex()
-    reveal_type(x)  # revealed: complex
-    x = could_raise_returns_bytearray()
-    reveal_type(x)  # revealed: bytearray
-else:
-    reveal_type(x)  # revealed: Literal[2]
-    x = could_raise_returns_Foo()
-    reveal_type(x)  # revealed: Foo
-    x = could_raise_returns_Bar()
-    reveal_type(x)  # revealed: Bar
-finally:
-    # TODO: should be `Literal[1, 2] | str | bytes | bool | memoryview | float | range | slice | complex | bytearray | Foo | Bar`
-    reveal_type(x)  # revealed: bytearray | Bar
-
-# Either one `except` branch or the `else`
-# must have been taken and completed to get here:
-reveal_type(x)  # revealed: bytearray | Bar
-```
-
-## Nested scopes inside `try` blocks
-
-Shadowing a variable in an inner scope has no effect on type inference of the
-variable by that name in the outer scope:
-
-```py
-def could_raise_returns_str() -> str:
-    return 'foo'
-
-def could_raise_returns_bytes() -> bytes:
-    return b'foo'
-
-def could_raise_returns_range() -> range:
-    return range(42)
-
-def could_raise_returns_bytearray() -> bytearray:
-    return bytearray()
-
-def could_raise_returns_float() -> float:
-    return 3.14
-
-x = 1
-
-try:
-    def foo(param=could_raise_returns_str()):
-        x = could_raise_returns_str()
-
-        try:
-            reveal_type(x)  # revealed: str
-            x = could_raise_returns_bytes()
-            reveal_type(x)  # revealed: bytes
-        except:
-            reveal_type(x)  # revealed: str | bytes
-            x = could_raise_returns_bytearray()
-            reveal_type(x)  # revealed: bytearray
-            x = could_raise_returns_float()
-            reveal_type(x)  # revealed: float
-        finally:
-            # TODO: should be `str | bytes | bytearray | float`
-            reveal_type(x)  # revealed: bytes | float
-        reveal_type(x)  # revealed: bytes | float
-
-    x = foo
-    reveal_type(x)  # revealed: Literal[foo]
-except:
-    reveal_type(x)  # revealed: Literal[1] | Literal[foo]
-
-    class Bar:
-        x = could_raise_returns_range()
-        reveal_type(x)  # revealed: range
-
-    x = Bar
-    reveal_type(x)  # revealed: Literal[Bar]
-finally:
-    # TODO: should be `Literal[1] | Literal[foo] | Literal[Bar]`
-    reveal_type(x)  # revealed: Literal[foo] | Literal[Bar]
-
-reveal_type(x)  # revealed: Literal[foo] | Literal[Bar]
-```
-
-[1]: https://astral-sh.notion.site/Exception-handler-control-flow-11348797e1ca80bb8ce1e9aedbbe439d

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

@@ -1,30 +0,0 @@
-# Except star
-
-## Except\* with BaseException
-
-```py
-try:
-    x
-except* BaseException as e:
-    reveal_type(e)  # revealed: BaseExceptionGroup
-```
-
-## Except\* with specific exception
-
-```py
-try:
-    x
-except* OSError as e:
-    # TODO(Alex): more precise would be `ExceptionGroup[OSError]`
-    reveal_type(e)  # revealed: BaseExceptionGroup
-```
-
-## Except\* with multiple exceptions
-
-```py
-try:
-    x
-except* (TypeError, AttributeError) as e:
-    #TODO(Alex): more precise would be `ExceptionGroup[TypeError | AttributeError]`.
-    reveal_type(e)  # revealed: BaseExceptionGroup
-```

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

@@ -1,151 +0,0 @@
-# Expressions
-
-## OR
-
-```py
-def foo() -> str:
-    pass
-
-a = True or False
-b = 'x' or 'y' or 'z'
-c = '' or 'y' or 'z'
-d = False or 'z'
-e = False or True
-f = False or False
-g = foo() or False
-h = foo() or True
-
-reveal_type(a)  # revealed: Literal[True]
-reveal_type(b)  # revealed: Literal["x"]
-reveal_type(c)  # revealed: Literal["y"]
-reveal_type(d)  # revealed: Literal["z"]
-reveal_type(e)  # revealed: Literal[True]
-reveal_type(f)  # revealed: Literal[False]
-reveal_type(g)  # revealed: str | Literal[False]
-reveal_type(h)  # revealed: str | Literal[True]
-```
-
-## AND
-
-```py
-def foo() -> str:
-    pass
-
-a = True and False
-b = False and True
-c = foo() and False
-d = foo() and True
-e = 'x' and 'y' and 'z'
-f = 'x' and 'y' and ''
-g = '' and 'y'
-
-reveal_type(a)  # revealed: Literal[False]
-reveal_type(b)  # revealed: Literal[False]
-reveal_type(c)  # revealed: str | Literal[False]
-reveal_type(d)  # revealed: str | Literal[True]
-reveal_type(e)  # revealed: Literal["z"]
-reveal_type(f)  # revealed: Literal[""]
-reveal_type(g)  # revealed: Literal[""]
-```
-
-## Simple function calls to bool
-
-```py
-def returns_bool() -> bool:
-    return True
-
-if returns_bool():
-    x = True
-else:
-    x = False
-
-reveal_type(x)  # revealed: bool
-```
-
-## Complex
-
-```py
-def foo() -> str:
-    pass
-
-a = "x" and "y" or "z"
-b = "x" or "y" and "z"
-c = "" and "y" or "z"
-d = "" or "y" and "z"
-e = "x" and "y" or ""
-f = "x" or "y" and ""
-
-reveal_type(a)  # revealed: Literal["y"]
-reveal_type(b)  # revealed: Literal["x"]
-reveal_type(c)  # revealed: Literal["z"]
-reveal_type(d)  # revealed: Literal["z"]
-reveal_type(e)  # revealed: Literal["y"]
-reveal_type(f)  # revealed: Literal["x"]
-```
-
-## `bool()` function
-
-## Evaluates to builtin
-
-```py path=a.py
-redefined_builtin_bool = bool
-
-def my_bool(x)-> bool: pass
-```
-
-```py
-from a import redefined_builtin_bool, my_bool
-a = redefined_builtin_bool(0)
-b = my_bool(0)
-
-reveal_type(a)  # revealed: Literal[False]
-reveal_type(b)  # revealed: bool
-```
-
-## Truthy values
-
-```py
-a = bool(1)
-b = bool((0,))
-c = bool("NON EMPTY")
-d = bool(True)
-
-def foo(): pass
-e = bool(foo)
-
-reveal_type(a)  # revealed: Literal[True]
-reveal_type(b)  # revealed: Literal[True]
-reveal_type(c)  # revealed: Literal[True]
-reveal_type(d)  # revealed: Literal[True]
-reveal_type(e)  # revealed: Literal[True]
-```
-
-## Falsy values
-
-```py
-a = bool(0)
-b = bool(())
-c = bool(None)
-d = bool("")
-e = bool(False)
-f = bool()
-
-reveal_type(a)  # revealed: Literal[False]
-reveal_type(b)  # revealed: Literal[False]
-reveal_type(c)  # revealed: Literal[False]
-reveal_type(d)  # revealed: Literal[False]
-reveal_type(e)  # revealed: Literal[False]
-reveal_type(f)  # revealed: Literal[False]
-```
-
-## Ambiguous values
-
-```py
-a = bool([])
-b = bool({})
-c = bool(set())
-
-reveal_type(a)  # revealed: bool
-reveal_type(b)  # revealed: bool
-reveal_type(c)  # revealed: bool
-```

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

@@ -1,23 +0,0 @@
-# Structures
-
-## Class import following
-
-```py
-from b import C as D; E = D
-reveal_type(E) # revealed: Literal[C]
-```
-
-```py path=b.py
-class C: pass
-```
-
-## Module member resolution
-
-```py
-import b; D = b.C
-reveal_type(D) # revealed: Literal[C]
-```
-
-```py path=b.py
-class C: pass
-```

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

@@ -1,6 +0,0 @@
-# Importing builtin module
-
-```py
-import builtins; x = builtins.copyright
-reveal_type(x) # revealed: Literal[copyright]
-```

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

@@ -1,75 +0,0 @@
-# Conditional imports
-
-## Maybe unbound
-
-```py path=maybe_unbound.py
-if flag:
-    y = 3
-x = y
-reveal_type(x)  # revealed: Unbound | Literal[3]
-reveal_type(y)  # revealed: Unbound | Literal[3]
-```
-
-```py
-from maybe_unbound import x, y
-reveal_type(x)  # revealed: Literal[3]
-reveal_type(y)  # revealed: Literal[3]
-```
-
-## Maybe unbound annotated
-
-```py path=maybe_unbound_annotated.py
-if flag:
-    y: int = 3
-x = y
-reveal_type(x)  # revealed: Unbound | Literal[3]
-reveal_type(y)  # revealed: Unbound | Literal[3]
-```
-
-Importing an annotated name prefers the declared type over the inferred type:
-
-```py
-from maybe_unbound_annotated import x, y
-reveal_type(x)  # revealed: Literal[3]
-reveal_type(y)  # revealed: int
-```
-
-## Reimport
-
-```py path=c.py
-def f(): ...
-```
-
-```py path=b.py
-if flag:
-    from c import f
-else:
-    def f(): ...
-```
-
-```py
-from b import f
-# TODO: We should disambiguate in such cases, showing `Literal[b.f, c.f]`.
-reveal_type(f)  # revealed: Literal[f, f]
-```
-
-## Reimport with stub declaration
-
-When we have a declared type in one path and only an inferred-from-definition type in the other, we
-should still be able to unify those:
-
-```py path=c.pyi
-x: int
-```
-
-```py path=b.py
-if flag:
-    from c import x
-else:
-    x = 1
-```
-
-```py
-from b import x
-reveal_type(x)  # revealed: int
-```

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

@@ -1,52 +0,0 @@
-# Unresolved Imports
-
-## Unresolved import statement
-
-```py
-import bar # error: "Cannot resolve import `bar`"
-reveal_type(bar)  # revealed: Unknown
-```
-
-## Unresolved import from statement
-
-```py
-from bar import baz # error: "Cannot resolve import `bar`"
-reveal_type(baz)  # revealed: Unknown
-```
-
-## Unresolved import from resolved module
-
-```py path=a.py
-```
-
-```py
-from a import thing # error: "Module `a` has no member `thing`"
-reveal_type(thing)  # revealed: Unknown
-```
-
-## Resolved import of symbol from unresolved import
-
-```py path=a.py
-import foo as foo # error: "Cannot resolve import `foo`"
-reveal_type(foo)  # revealed: Unknown
-```
-
-Importing the unresolved import into a second file should not trigger an additional "unresolved
-import" violation:
-
-```py
-from a import foo
-reveal_type(foo)  # revealed: Unknown
-```
-
-## No implicit shadowing
-
-```py path=b.py
-x: int
-```
-
-```py
-from b import x
-
-x = 'foo'  # error: [invalid-assignment] "Object of type `Literal["foo"]"
-```

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

@@ -1,133 +0,0 @@
-# Relative
-
-## Non-existent
-
-```py path=package/__init__.py
-```
-
-```py path=package/bar.py
-from .foo import X # error: [unresolved-import]
-reveal_type(X)  # revealed: Unknown
-```
-
-## Simple
-
-```py path=package/__init__.py
-```
-
-```py path=package/foo.py
-X = 42
-```
-
-```py path=package/bar.py
-from .foo import X
-reveal_type(X)  # revealed: Literal[42]
-```
-
-## Dotted
-
-```py path=package/__init__.py
-```
-
-```py path=package/foo/bar/baz.py
-X = 42
-```
-
-```py path=package/bar.py
-from .foo.bar.baz import X
-reveal_type(X)  # revealed: Literal[42]
-```
-
-## Bare to package
-
-```py path=package/__init__.py
-X = 42
-```
-
-```py path=package/bar.py
-from . import X
-reveal_type(X)  # revealed: Literal[42]
-```
-
-## Non-existent + bare to package
-
-```py path=package/bar.py
-from . import X # error: [unresolved-import]
-reveal_type(X)  # revealed: Unknown
-```
-
-## Dunder init
-
-```py path=package/__init__.py
-from .foo import X
-reveal_type(X)  # revealed: Literal[42]
-```
-
-```py path=package/foo.py
-X = 42
-```
-
-## Non-existent + dunder init
-
-```py path=package/__init__.py
-from .foo import X # error: [unresolved-import]
-reveal_type(X)     # revealed: Unknown
-```
-
-## Long relative import
-
-```py path=package/__init__.py
-```
-
-```py path=package/foo.py
-X = 42
-```
-
-```py path=package/subpackage/subsubpackage/bar.py
-from ...foo import X
-reveal_type(X)  # revealed: Literal[42]
-```
-
-## Unbound symbol
-
-```py path=package/__init__.py
-```
-
-```py path=package/foo.py
-x
-```
-
-```py path=package/bar.py
-from .foo import x # error: [unresolved-import]
-reveal_type(x)     # revealed: Unknown
-```
-
-## Bare to module
-
-```py path=package/__init__.py
-```
-
-```py path=package/foo.py
-X = 42
-```
-
-```py path=package/bar.py
-# TODO: support submodule imports
-from . import foo  # error: [unresolved-import]
-y = foo.X
-
-# TODO: should be `Literal[42]`
-reveal_type(y)     # revealed: Unknown
-```
-
-## Non-existent + bare to module
-
-```py path=package/__init__.py
-```
-
-```py path=package/bar.py
-# TODO: support submodule imports
-from . import foo  # error: [unresolved-import]
-
-reveal_type(foo)   # revealed: Unknown
-```

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

@@ -1,25 +0,0 @@
-# Stubs
-
-## Import from stub declaration
-
-```py
-from b import x
-y = x
-reveal_type(y)  # revealed: int
-```
-
-```py path=b.pyi
-x: int
-```
-
-## Import from non-stub with declaration and definition
-
-```py
-from b import x
-y = x
-reveal_type(y)  # revealed: int
-```
-
-```py path=b.py
-x: int = 1
-```

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

@@ -1,8 +0,0 @@
-# Boolean literals
-
-```py
-x = True
-y = False
-reveal_type(x)  # revealed: Literal[True]
-reveal_type(y)  # revealed: Literal[False]
-```

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

@@ -1,8 +0,0 @@
-# Dictionaries
-
-## Empty dictionary
-
-```py
-x = {}
-reveal_type(x)  # revealed: dict
-```

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

@@ -1,8 +0,0 @@
-# Lists
-
-## Empty list
-
-```py
-x = []
-reveal_type(x)  # revealed: list
-```

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

@@ -1,8 +0,0 @@
-# Sets
-
-## Basic set
-
-```py
-x = {1, 2}
-reveal_type(x)  # revealed: set
-```

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

@@ -1,20 +0,0 @@
-# Tuples
-
-## Empty tuple
-
-```py
-x = ()
-reveal_type(x)  # revealed: tuple[()]
-```
-
-## Heterogeneous tuple
-
-```py
-x = (1, 'a')
-y = (1, (2, 3))
-z = (x, 2)
-
-reveal_type(x)  # revealed: tuple[Literal[1], Literal["a"]]
-reveal_type(y)  # revealed: tuple[Literal[1], tuple[Literal[2], Literal[3]]]
-reveal_type(z)  # revealed: tuple[tuple[Literal[1], Literal["a"]], Literal[2]]
-```

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

@@ -1,7 +0,0 @@
-# Complex literals
-
-## Complex numbers
-
-```py
-reveal_type(2j)  # revealed: complex
-```

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

@@ -1,44 +0,0 @@
-# f-strings
-
-## Expression
-
-```py
-x = 0
-y = str()
-z = False
-
-a = f'hello'
-b = f'h {x}'
-c = 'one ' f'single ' f'literal'
-d = 'first ' f'second({b})' f' third'
-e = f'-{y}-'
-f = f'-{y}-' f'--' '--'
-g = f'{z} == {False} is {True}'
-
-reveal_type(a)  # revealed: Literal["hello"]
-reveal_type(b)  # revealed: Literal["h 0"]
-reveal_type(c)  # revealed: Literal["one single literal"]
-reveal_type(d)  # revealed: Literal["first second(h 0) third"]
-reveal_type(e)  # revealed: str
-reveal_type(f)  # revealed: str
-reveal_type(g)  # revealed: Literal["False == False is True"]
-```
-
-## Conversion Flags
-
-```py
-string = 'hello'
-a = f'{string!r}'
-
-# TODO: should be `Literal["'hello'"]`
-reveal_type(a)  # revealed: str
-```
-
-## Format Specifiers
-
-```py
-a = f'{1:02}'
-
-# TODO: should be `Literal["01"]`
-reveal_type(a)  # revealed: str
-```

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

@@ -1,7 +0,0 @@
-# Float literals
-
-## Basic
-
-```py
-reveal_type(1.0)  # revealed: float
-```

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

@@ -1,56 +0,0 @@
-# Integer literals
-
-## Literals
-
-We can infer an integer literal type:
-
-```py
-reveal_type(1)  # revealed: Literal[1]
-```
-
-## Variable
-
-```py
-x = 1
-reveal_type(x)  # revealed: Literal[1]
-```
-
-## Overflow
-
-We only track integer literals within the range of an i64:
-
-```py
-reveal_type(9223372036854775808)  # revealed: int
-```
-
-## Big int
-
-We don't support big integer literals; we just infer `int` type instead:
-
-```py
-x = 10_000_000_000_000_000_000
-reveal_type(x)  # revealed: int
-```
-
-## Negated
-
-```py
-x = -1
-y = -1234567890987654321
-z = --987
-reveal_type(x)  # revealed: Literal[-1]
-reveal_type(y)  # revealed: Literal[-1234567890987654321]
-reveal_type(z)  # revealed: Literal[987]
-```
-
-## Floats
-
-```py
-reveal_type(1.0)  # revealed: float
-```
-
-## Complex
-
-```py
-reveal_type(2j)  # revealed: complex
-```

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

@@ -1,26 +0,0 @@
-# String literals
-
-## Simple
-
-```py
-w = "Hello"
-x = 'world'
-y = "Guten " + 'tag'
-z = 'bon ' + "jour"
-
-reveal_type(w)  # revealed: Literal["Hello"]
-reveal_type(x)  # revealed: Literal["world"]
-reveal_type(y)  # revealed: Literal["Guten tag"]
-reveal_type(z)  # revealed: Literal["bon jour"]
-```
-
-## Nested Quotes
-
-```py
-x = 'I say "hello" to you'
-y = "You say \"hey\" back"
-z = 'No "closure here'
-reveal_type(x)  # revealed: Literal["I say \"hello\" to you"]
-reveal_type(y)  # revealed: Literal["You say \"hey\" back"]
-reveal_type(z)  # revealed: Literal["No \"closure here"]
-```

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

@@ -1,41 +0,0 @@
-# Async
-
-Async `for` loops do not work according to the synchronous iteration protocol.
-
-## Invalid async for loop
-
-```py
-async def foo():
-    class Iterator:
-        def __next__(self) -> int:
-            return 42
-
-    class Iterable:
-        def __iter__(self) -> Iterator:
-            return Iterator()
-
-    async for x in Iterator():
-        pass
-
-    # TODO
-    reveal_type(x)  # revealed: Unbound | @Todo
-```
-
-## Basic async for loop
-
-```py
-async def foo():
-    class IntAsyncIterator:
-        async def __anext__(self) -> int:
-            return 42
-
-    class IntAsyncIterable:
-        def __aiter__(self) -> IntAsyncIterator:
-            return IntAsyncIterator()
-
-    #TODO(Alex): async iterables/iterators!
-    async for x in IntAsyncIterable():
-        pass
-
-    reveal_type(x)  # revealed: Unbound | @Todo
-```

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

@@ -1,134 +0,0 @@
-# For loops
-
-## Basic `for` loop
-
-```py
-class IntIterator:
-    def __next__(self) -> int:
-        return 42
-
-class IntIterable:
-    def __iter__(self) -> IntIterator:
-        return IntIterator()
-
-for x in IntIterable():
-    pass
-
-reveal_type(x)  # revealed: Unbound | int
-```
-
-## With previous definition
-
-```py
-class IntIterator:
-    def __next__(self) -> int:
-        return 42
-
-class IntIterable:
-    def __iter__(self) -> IntIterator:
-        return IntIterator()
-
-x = 'foo'
-
-for x in IntIterable():
-    pass
-
-reveal_type(x)  # revealed: Literal["foo"] | int
-```
-
-## With `else` (no break)
-
-```py
-class IntIterator:
-    def __next__(self) -> int:
-        return 42
-
-class IntIterable:
-    def __iter__(self) -> IntIterator:
-        return IntIterator()
-
-for x in IntIterable():
-    pass
-else:
-    x = 'foo'
-
-reveal_type(x)  # revealed: Literal["foo"]
-```
-
-## May `break`
-
-```py
-class IntIterator:
-    def __next__(self) -> int:
-        return 42
-
-class IntIterable:
-    def __iter__(self) -> IntIterator:
-        return IntIterator()
-
-for x in IntIterable():
-    if x > 5:
-        break
-else:
-    x = 'foo'
-
-reveal_type(x)  # revealed: int | Literal["foo"]
-```
-
-## With old-style iteration protocol
-
-```py
-class OldStyleIterable:
-    def __getitem__(self, key: int) -> int:
-        return 42
-
-for x in OldStyleIterable():
-    pass
-
-reveal_type(x)  # revealed: Unbound | int
-```
-
-## With heterogeneous tuple
-
-```py
-for x in (1, 'a', b'foo'):
-    pass
-
-reveal_type(x)  # revealed: Unbound | Literal[1] | Literal["a"] | Literal[b"foo"]
-```
-
-## With non-callable iterator
-
-```py
-class NotIterable:
-    if flag:
-        __iter__ = 1
-    else:
-        __iter__ = None
-
-for x in NotIterable(): # error: "Object of type `NotIterable` is not iterable"
-    pass
-
-reveal_type(x)  # revealed: Unbound | Unknown
-```
-
-## Invalid iterable
-
-```py
-nonsense = 123
-for x in nonsense: # error: "Object of type `Literal[123]` is not iterable"
-    pass
-```
-
-## New over old style iteration protocol
-
-```py
-class NotIterable:
-    def __getitem__(self, key: int) -> int:
-        return 42
-
-    __iter__ = None
-
-for x in NotIterable(): # error: "Object of type `NotIterable` is not iterable"
-    pass
-```

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

@@ -1,18 +0,0 @@
-# Iterators
-
-## Yield must be iterable
-
-```py
-class NotIterable: pass
-
-class Iterator:
-    def __next__(self) -> int:
-        return 42
-
-class Iterable:
-    def __iter__(self) -> Iterator: ...
-
-def generator_function():
-    yield from Iterable()
-    yield from NotIterable() # error: "Object of type `NotIterable` is not iterable"
-```

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

@@ -1,43 +0,0 @@
-# While loops
-
-## Basic While Loop
-
-```py
-x = 1
-while flag:
-    x = 2
-
-reveal_type(x)  # revealed: Literal[1, 2]
-```
-
-## While with else (no break)
-
-```py
-x = 1
-while flag:
-    x = 2
-else:
-    y = x
-    x = 3
-
-reveal_type(x)  # revealed: Literal[3]
-reveal_type(y)  # revealed: Literal[1, 2]
-```
-
-## While with Else (may break)
-
-```py
-x = 1
-y = 0
-while flag:
-    x = 2
-    if flag2:
-        y = 4
-        break
-else:
-    y = x
-    x = 3
-
-reveal_type(x)  # revealed: Literal[2, 3]
-reveal_type(y)  # revealed: Literal[1, 2, 4]
-```

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

@@ -1,29 +0,0 @@
-# Narrowing for `is` conditionals
-
-## `is None`
-
-```py
-x = None if flag else 1
-
-if x is None:
-    # TODO the following should be simplified to 'None'
-    reveal_type(x)  # revealed: None | Literal[1] & None
-
-reveal_type(x)  # revealed: None | Literal[1]
-```
-
-## `is` for other types
-
-```py
-class A:
-    ...
-
-x = A()
-y = x if flag else None
-
-if y is x:
-    # TODO the following should be simplified to 'A'
-    reveal_type(y)  # revealed: A | None & A
-
-reveal_type(y)  # revealed: A | None
-```

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

@@ -1,39 +0,0 @@
-# Narrowing for `is not` conditionals
-
-## `is not None`
-
-The type guard removes `None` from the union type:
-
-```py
-x = None if flag else 1
-
-if x is not None:
-    reveal_type(x)  # revealed: Literal[1]
-
-reveal_type(x)  # revealed: None | Literal[1]
-```
-
-## `is not` for other singleton types
-
-```py
-x = True if flag else False
-reveal_type(x)  # revealed: bool
-
-if x is not False:
-    # TODO the following should be `Literal[True]`
-    reveal_type(x)  # revealed: bool & ~Literal[False]
-```
-
-## `is not` for non-singleton types
-
-Non-singleton types should *not* narrow the type: two instances of a
-non-singleton class may occupy different addresses in memory even if
-they compare equal.
-
-```py
-x = 345
-y = 345
-
-if x is not y:
-    reveal_type(x)  # revealed: Literal[345]
-```

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

@@ -1,17 +0,0 @@
-# Narrowing for `match` statements
-
-## Single `match` pattern
-
-```py
-x = None if flag else 1
-reveal_type(x)  # revealed: None | Literal[1]
-
-y = 0
-
-match x:
-    case None:
-        y = x
-
-# TODO intersection simplification: should be just Literal[0] | None
-reveal_type(y)  # revealed: Literal[0] | None | Literal[1] & None
-```

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

@@ -1,9 +0,0 @@
-# `is not None` narrowing
-
-```py
-x = None if flag else 1
-if x is not None:
-    reveal_type(x)  # revealed: Literal[1]
-
-reveal_type(x)  # revealed: None | Literal[1]
-```

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

@@ -1,32 +0,0 @@
-# Builtin scope
-
-## Conditionally global or builtin
-
-If a builtin name is conditionally defined as a global, a name lookup should union the builtin type
-with the conditionally-defined type:
-
-```py
-def returns_bool() -> bool:
-    return True
-
-if returns_bool():
-    copyright = 1
-
-def f():
-    reveal_type(copyright)  # revealed: Literal[copyright] | Literal[1]
-```
-
-## Conditionally global or builtin, with annotation
-
-Same is true if the name is annotated:
-
-```py
-def returns_bool() -> bool:
-    return True
-
-if returns_bool():
-    copyright: int = 1
-
-def f():
-    reveal_type(copyright)  # revealed: Literal[copyright] | int
-```

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

@@ -1,17 +0,0 @@
-# Classes shadowing
-
-## Implicit error
-
-```py
-class C: pass
-C = 1 # error: "Implicit shadowing of class `C`; annotate to make it explicit if this is intentional"
-```
-
-## Explicit
-
-No diagnostic is raised in the case of explicit shadowing:
-
-```py
-class C: pass
-C: int = 1
-```

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

@@ -1,24 +0,0 @@
-# Function shadowing
-
-## Parameter
-
-Parameter `x` of type `str` is shadowed and reassigned with a new `int` value inside the function. No diagnostics should be generated.
-
-```py path=a.py
-def f(x: str):
-    x: int = int(x)
-```
-
-## Implicit error
-
-```py path=a.py
-def f(): pass
-f = 1 # error: "Implicit shadowing of function `f`; annotate to make it explicit if this is intentional"
-```
-
-## Explicit shadowing
-
-```py path=a.py
-def f(): pass
-f: int = 1
-```

crates/red_knot_python_semantic/resources/mdtest/shadowing/variable_declaration.md

@@ -1,11 +0,0 @@
-# Shadwing declaration
-
-## Shadow after incompatible declarations is OK
-
-```py
-if flag:
-    x: str
-else:
-    x: int
-x: bytes = b'foo'
-```

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

@@ -1,10 +0,0 @@
-# Class defenitions in stubs
-
-## Cyclical class definition
-
-In type stubs, classes can reference themselves in their base class definitions. For example, in `typeshed`, we have `class str(Sequence[str]): ...`.
-
-```py path=a.pyi
-class C(C): ...
-reveal_type(C)  # revealed: Literal[C]
-```

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

@@ -1,15 +0,0 @@
-# Bytes subscript
-
-## Simple
-
-```py
-w = b'red' b'knot'
-x = b'hello'
-y = b'world' + b'!'
-z = b'\xff\x00'
-
-reveal_type(w)  # revealed: Literal[b"redknot"]
-reveal_type(x)  # revealed: Literal[b"hello"]
-reveal_type(y)  # revealed: Literal[b"world!"]
-reveal_type(z)  # revealed: Literal[b"\xff\x00"]
-```

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

@@ -1,92 +0,0 @@
-# Class subscript
-
-## Class getitem unbound
-
-```py
-class NotSubscriptable: pass
-a = NotSubscriptable[0]  # error: "Cannot subscript object of type `Literal[NotSubscriptable]` with no `__class_getitem__` method"
-```
-
-## Class getitem
-
-```py
-class Identity:
-    def __class_getitem__(cls, item: int) -> str:
-        return item
-
-a = Identity[0]  
-reveal_type(a) # revealed: str
-```
-
-## Class getitem union
-
-```py
-flag = True
-
-class Identity:
-    if flag:
-        def __class_getitem__(cls, item: int) -> str:
-            return item
-    else:
-        def __class_getitem__(cls, item: int) -> int:
-            return item
-
-a = Identity[0]  
-reveal_type(a) # revealed: str | int
-```
-
-## Class getitem with class union
-
-```py
-flag = True
-
-class Identity1:
-    def __class_getitem__(cls, item: int) -> str:
-        return item
-
-class Identity2:
-    def __class_getitem__(cls, item: int) -> int:
-        return item
-
-if flag:
-    a = Identity1
-else:
-    a = Identity2
-
-b = a[0]
-reveal_type(a) # revealed: Literal[Identity1, Identity2]
-reveal_type(b) # revealed: str | int
-```
-
-## Class getitem with unbound method union
-
-```py
-flag = True
-
-if flag:
-    class Identity:
-        def __class_getitem__(self, x: int) -> str:
-            pass
-else:
-    class Identity: pass
-
-a = Identity[42] # error: [call-non-callable] "Method `__class_getitem__` of type `Literal[__class_getitem__] | Unbound` is not callable on object of type `Literal[Identity, Identity]`" 
-reveal_type(a) # revealed: str | Unknown 
-```
-
-## TODO: Class getitem non-class union
-
-```py
-flag = True
-
-if flag:
-    class Identity:
-        def __class_getitem__(self, x: int) -> str:
-            pass
-else:
-    Identity = 1
-
-a = Identity[42] # error: "Cannot subscript object of type `Literal[Identity] | Literal[1]` with no `__getitem__` method"
-# TODO: should _probably_ emit `str | Unknown` 
-reveal_type(a) # revealed: Unknown 
-```

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

@@ -1,45 +0,0 @@
-# Instance subscript
-
-## Getitem unbound
-
-```py
-class NotSubscriptable: pass
-a = NotSubscriptable()[0]  # error: "Cannot subscript object of type `NotSubscriptable` with no `__getitem__` method"
-```
-
-## Getitem not callable
-
-```py
-class NotSubscriptable:
-    __getitem__ = None
-
-a = NotSubscriptable()[0]  # error: "Method `__getitem__` of type `None` is not callable on object of type `NotSubscriptable`"
-```
-
-## Valid getitem
-
-```py
-class Identity:
-    def __getitem__(self, index: int) -> int:
-        return index
-
-a = Identity()[0]  
-reveal_type(a) # revealed: int
-```
-
-## Getitem union
-
-```py
-flag = True
-
-class Identity:
-    if flag:
-        def __getitem__(self, index: int) -> int:
-            return index
-    else:
-        def __getitem__(self, index: int) -> str:
-            return str(index)
-
-a = Identity()[0]  
-reveal_type(a) # revealed: int | str
-```

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

@@ -1,33 +0,0 @@
-# List subscripts
-
-## Indexing into lists
-
-A list can be indexed into with:
-
-- numbers
-- slices
-
-```py
-x = [1, 2, 3]
-reveal_type(x)  # revealed: list
-# TODO reveal int
-reveal_type(x[0])  # revealed: @Todo
-# TODO reveal list
-reveal_type(x[0:1])  # revealed: @Todo
-# TODO error
-reveal_type(x["a"])  # revealed: @Todo
-```
-
-## Assignments within list assignment
-
-In assignment, we might also have a named assignment.
-This should also get type checked.
-
-```py
-x = [1, 2, 3]
-x[0 if (y := 2) else 1] = 5
-# TODO error? (indeterminite index type)
-x["a" if (y := 2) else 1] = 6
-# TODO error (can't index via string)
-x["a" if (y := 2) else "b"] = 6
-```

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

@@ -1,32 +0,0 @@
-# Subscript on strings
-
-## Simple
-
-```py
-s = 'abcde'
-
-a = s[0]
-b = s[1]
-c = s[-1]
-d = s[-2]
-e = s[8]        # error: [index-out-of-bounds] "Index 8 is out of bounds for string `Literal["abcde"]` with length 5"
-f = s[-8]       # error: [index-out-of-bounds] "Index -8 is out of bounds for string `Literal["abcde"]` with length 5"
-
-reveal_type(a)  # revealed: Literal["a"]
-reveal_type(b)  # revealed: Literal["b"]
-reveal_type(c)  # revealed: Literal["e"]
-reveal_type(d)  # revealed: Literal["d"]
-reveal_type(e)  # revealed: Unknown
-reveal_type(f)  # revealed: Unknown
-```
-
-## Function return
-
-```py
-def add(x: int, y: int) -> int:
-    return x + y
-
-a = 'abcde'[add(0, 1)]
-# TODO: Support overloads... Should be `str`
-reveal_type(a)  # revealed: @Todo
-```

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

@@ -1,21 +0,0 @@
-# Tuple subscripts
-
-## Basic
-
-```py
-t = (1, 'a', 'b')
-
-a = t[0]
-b = t[1]
-c = t[-1]
-d = t[-2]
-e = t[4]        # error: [index-out-of-bounds]
-f = t[-4]       # error: [index-out-of-bounds]
-
-reveal_type(a)  # revealed: Literal[1]
-reveal_type(b)  # revealed: Literal["a"]
-reveal_type(c)  # revealed: Literal["b"]
-reveal_type(d)  # revealed: Literal["a"]
-reveal_type(e)  # revealed: Unknown
-reveal_type(f)  # revealed: Unknown
-```

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

@@ -1,37 +0,0 @@
-# Unary Operations
-
-## Unary Addition
-
-```py
-a = +0
-b = +1
-c = +True
-
-reveal_type(a)  # revealed: Literal[0]
-reveal_type(b)  # revealed: Literal[1]
-reveal_type(c)  # revealed: Literal[1]
-```
-
-## Unary Subtraction
-
-```py
-a = -0
-b = -1
-c = -True
-
-reveal_type(a)  # revealed: Literal[0]
-reveal_type(b)  # revealed: Literal[-1]
-reveal_type(c)  # revealed: Literal[-1]
-```
-
-## Unary Bitwise Inversion
-
-```py
-a = ~0
-b = ~1
-c = ~True
-
-reveal_type(a) # revealed: Literal[-1] 
-reveal_type(b) # revealed: Literal[-2]
-reveal_type(c) # revealed: Literal[-2]
-```

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

@@ -1,149 +0,0 @@
-# Unary not
-
-## None
-
-```py
-a = not None
-b = not not None
-reveal_type(a)  # revealed: Literal[True]
-reveal_type(b)  # revealed: Literal[False]
-```
-
-## Function
-
-```py
-from typing import reveal_type
-
-def f():
-    return 1
-
-a = not f
-b = not reveal_type
-
-reveal_type(a)  # revealed: Literal[False]
-# TODO Unknown should not be part of the type of typing.reveal_type
-# reveal_type(b)  revealed: Literal[False]
-```
-
-## Module
-
-```py
-import b; import warnings
-
-x = not b
-z = not warnings
-
-reveal_type(x)  # revealed: Literal[False]
-reveal_type(z)  # revealed: Literal[False]
-```
-
-```py path=b.py
-y = 1
-```
-
-## Union
-
-```py
-if flag:
-    p = 1
-    q = 3.3
-    r = "hello"
-    s = "world"
-    t = 0
-else:
-    p = "hello"
-    q = 4
-    r = ""
-    s = 0
-    t = ""
-
-a = not p
-b = not q
-c = not r
-d = not s
-e = not t
-
-reveal_type(a)  # revealed: Literal[False]
-reveal_type(b)  # revealed: bool
-reveal_type(c)  # revealed: bool
-reveal_type(d)  # revealed: bool
-reveal_type(e)  # revealed: Literal[True]
-```
-
-## Integer literal
-
-```py
-a = not 1
-b = not 1234567890987654321
-e = not 0
-x = not -1
-y = not -1234567890987654321
-z = not --987
-
-reveal_type(a)  # revealed: Literal[False]
-reveal_type(b)  # revealed: Literal[False]
-reveal_type(e)  # revealed: Literal[True]
-reveal_type(x)  # revealed: Literal[False]
-reveal_type(y)  # revealed: Literal[False]
-reveal_type(z)  # revealed: Literal[False]
-```
-
-## Boolean literal
-
-```py
-w = True
-x = False
-y = not w
-z = not x
-
-reveal_type(w)  # revealed: Literal[True]
-reveal_type(x)  # revealed: Literal[False]
-reveal_type(y)  # revealed: Literal[False]
-reveal_type(z)  # revealed: Literal[True]
-```
-
-## String literal
-
-```py
-a = not "hello"
-b = not ""
-c = not "0"
-d = not "hello" + "world"
-
-reveal_type(a)  # revealed: Literal[False]
-reveal_type(b)  # revealed: Literal[True]
-reveal_type(c)  # revealed: Literal[False]
-reveal_type(d)  # revealed: Literal[False]
-```
-
-## Bytes literal
-
-```py
-a = not b"hello"
-b = not b""
-c = not b"0"
-d = not b"hello" + b"world"
-
-reveal_type(a)  # revealed: Literal[False]
-reveal_type(b)  # revealed: Literal[True]
-reveal_type(c)  # revealed: Literal[False]
-reveal_type(d)  # revealed: Literal[False]
-```
-
-## Tuple
-
-```py
-a = not (1,)
-b = not (1, 2)
-c = not (1, 2, 3)
-d = not ()
-e = not ("hello",)
-f = not (1, "hello")
-
-reveal_type(a)  # revealed: Literal[False]
-reveal_type(b)  # revealed: Literal[False]
-reveal_type(c)  # revealed: Literal[False]
-reveal_type(d)  # revealed: Literal[True]
-reveal_type(e)  # revealed: Literal[False]
-reveal_type(f)  # revealed: Literal[False]
-```

crates/red_knot_python_semantic/resources/mdtest/unpacking.md

@@ -1,273 +0,0 @@
-# Unpacking
-
-## Tuple
-
-### Simple tuple
-
-```py
-(a, b, c) = (1, 2, 3)
-reveal_type(a)  # revealed: Literal[1]
-reveal_type(b)  # revealed: Literal[2]
-reveal_type(c)  # revealed: Literal[3]
-```
-
-### Simple list
-
-```py
-[a, b, c] = (1, 2, 3)
-reveal_type(a)  # revealed: Literal[1]
-reveal_type(b)  # revealed: Literal[2]
-reveal_type(c)  # revealed: Literal[3]
-```
-
-### Simple mixed
-
-```py
-[a, (b, c), d] = (1, (2, 3), 4)
-reveal_type(a)  # revealed: Literal[1]
-reveal_type(b)  # revealed: Literal[2]
-reveal_type(c)  # revealed: Literal[3]
-reveal_type(d)  # revealed: Literal[4]
-```
-
-### Multiple assignment
-
-```py
-a, b = c = 1, 2
-reveal_type(a)  # revealed: Literal[1]
-reveal_type(b)  # revealed: Literal[2]
-reveal_type(c)  # revealed: tuple[Literal[1], Literal[2]]
-```
-
-### Nested tuple with unpacking
-
-```py
-(a, (b, c), d) = (1, (2, 3), 4)
-reveal_type(a)  # revealed: Literal[1]
-reveal_type(b)  # revealed: Literal[2]
-reveal_type(c)  # revealed: Literal[3]
-reveal_type(d)  # revealed: Literal[4]
-```
-
-### Nested tuple without unpacking
-
-```py
-(a, b, c) = (1, (2, 3), 4)
-reveal_type(a)  # revealed: Literal[1]
-reveal_type(b)  # revealed: tuple[Literal[2], Literal[3]]
-reveal_type(c)  # revealed: Literal[4]
-```
-
-### Uneven unpacking (1)
-
-```py
-# TODO: Add diagnostic (there aren't enough values to unpack)
-(a, b, c) = (1, 2)
-reveal_type(a)  # revealed: Literal[1]
-reveal_type(b)  # revealed: Literal[2]
-reveal_type(c)  # revealed: Unknown
-```
-
-### Uneven unpacking (2)
-
-```py
-# TODO: Add diagnostic (too many values to unpack)
-(a, b) = (1, 2, 3)
-reveal_type(a)  # revealed: Literal[1]
-reveal_type(b)  # revealed: Literal[2]
-```
-
-### Starred expression (1)
-
-```py
-# TODO: Add diagnostic (need more values to unpack)
-# TODO: Remove 'not-iterable' diagnostic
-[a, *b, c, d] = (1, 2)  # error: "Object of type `None` is not iterable"
-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(c)  # revealed: Literal[2]
-reveal_type(d)  # revealed: Unknown
-```
-
-### Starred expression (2)
-
-```py
-[a, *b, c] = (1, 2)  # error: "Object of type `None` is not iterable"
-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(c)  # revealed: Literal[2]
-```
-
-### Starred expression (3)
-
-```py
-# TODO: Remove 'not-iterable' diagnostic
-[a, *b, c] = (1, 2, 3)  # error: "Object of type `None` is not iterable"
-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(c)  # revealed: Literal[3]
-```
-
-### Starred expression (4)
-
-```py
-# TODO: Remove 'not-iterable' diagnostic
-[a, *b, c, d] = (1, 2, 3, 4, 5, 6)  # error: "Object of type `None` is not iterable"
-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(c)  # revealed: Literal[5]
-reveal_type(d)  # revealed: Literal[6]
-```
-
-### Starred expression (5)
-
-```py
-# TODO: Remove 'not-iterable' diagnostic
-[a, b, *c] = (1, 2, 3, 4)  # error: "Object of type `None` is not iterable"
-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
-```
-
-### Non-iterable unpacking
-
-TODO: Remove duplicate diagnostics. This is happening because for a sequence-like
-assignment target, multiple definitions are created and the inference engine runs
-on each of them which results in duplicate diagnostics.
-
-```py
-# error: "Object of type `Literal[1]` is not iterable"
-# error: "Object of type `Literal[1]` is not iterable"
-a, b = 1
-reveal_type(a)  # revealed: Unknown
-reveal_type(b)  # revealed: Unknown
-```
-
-### Custom iterator unpacking
-
-```py
-class Iterator:
-    def __next__(self) -> int:
-        return 42
-
-
-class Iterable:
-    def __iter__(self) -> Iterator:
-        return Iterator()
-
-
-(a, b) = Iterable()
-reveal_type(a)  # revealed: int
-reveal_type(b)  # revealed: int
-```
-
-### Custom iterator unpacking nested
-
-```py
-class Iterator:
-    def __next__(self) -> int:
-        return 42
-
-
-class Iterable:
-    def __iter__(self) -> Iterator:
-        return Iterator()
-
-
-(a, (b, c), d) = (1, Iterable(), 2)
-reveal_type(a)  # revealed: Literal[1]
-reveal_type(b)  # revealed: int
-reveal_type(c)  # revealed: int
-reveal_type(d)  # revealed: Literal[2]
-```
-
-## String
-
-### Simple unpacking
-
-```py
-a, b = 'ab'
-reveal_type(a)  # revealed: LiteralString
-reveal_type(b)  # revealed: LiteralString
-```
-
-### Uneven unpacking (1)
-
-```py
-# TODO: Add diagnostic (there aren't enough values to unpack)
-a, b, c = 'ab'
-reveal_type(a)  # revealed: LiteralString
-reveal_type(b)  # revealed: LiteralString
-reveal_type(c)  # revealed: Unknown
-```
-
-### Uneven unpacking (2)
-
-```py
-# TODO: Add diagnostic (too many values to unpack)
-a, b = 'abc'
-reveal_type(a)  # revealed: LiteralString
-reveal_type(b)  # revealed: LiteralString
-```
-
-### Starred expression (1)
-
-```py
-# TODO: Add diagnostic (need more values to unpack)
-# TODO: Remove 'not-iterable' diagnostic
-(a, *b, c, d) = "ab"  # error: "Object of type `None` is not iterable"
-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(c)  # revealed: LiteralString
-reveal_type(d)  # revealed: Unknown
-```
-
-### Starred expression (2)
-
-```py
-(a, *b, c) = "ab"  # error: "Object of type `None` is not iterable"
-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(c)  # revealed: LiteralString
-```
-
-### Starred expression (3)
-
-```py
-# TODO: Remove 'not-iterable' diagnostic
-(a, *b, c) = "abc"  # error: "Object of type `None` is not iterable"
-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(c)  # revealed: LiteralString
-```
-
-### Starred expression (4)
-
-```py
-# TODO: Remove 'not-iterable' diagnostic
-(a, *b, c, d) = "abcdef"  # error: "Object of type `None` is not iterable"
-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(c)  # revealed: LiteralString
-reveal_type(d)  # revealed: LiteralString
-```
-
-### Starred expression (5)
-
-```py
-# TODO: Remove 'not-iterable' diagnostic
-(a, b, *c) = "abcd"  # error: "Object of type `None` is not iterable"
-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
-```

crates/red_knot_python_semantic/src/db.rs

@@ -11,6 +11,7 @@ pub trait Db: SourceDb + Upcast<dyn SourceDb> {
 pub(crate) mod tests {
     use std::sync::Arc;
 
+    use crate::module_resolver::vendored_typeshed_stubs;
     use ruff_db::files::{File, Files};
     use ruff_db::system::{DbWithTestSystem, System, TestSystem};
     use ruff_db::vendored::VendoredFileSystem;
@@ -32,7 +33,7 @@ pub(crate) mod tests {
             Self {
                 storage: salsa::Storage::default(),
                 system: TestSystem::default(),
-                vendored: red_knot_vendored::file_system().clone(),
+                vendored: vendored_typeshed_stubs().clone(),
                 events: std::sync::Arc::default(),
                 files: Files::default(),
             }

crates/red_knot_python_semantic/src/lib.rs

@@ -4,7 +4,7 @@ use rustc_hash::FxHasher;
 
 pub use db::Db;
 pub use module_name::ModuleName;
-pub use module_resolver::{resolve_module, system_module_search_paths, Module};
+pub use module_resolver::{resolve_module, system_module_search_paths, vendored_typeshed_stubs};
 pub use program::{Program, ProgramSettings, SearchPathSettings, SitePackages};
 pub use python_version::PythonVersion;
 pub use semantic_model::{HasTy, SemanticModel};
@@ -23,3 +23,4 @@ mod stdlib;
 pub mod types;
 
 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;
+type FxOrderMap<K, V> = ordermap::map::OrderMap<K, V, BuildHasherDefault<FxHasher>>;

crates/red_knot_python_semantic/src/module_resolver/mod.rs

@@ -1,9 +1,10 @@
 use std::iter::FusedIterator;
 
-pub use module::Module;
+pub(crate) use module::Module;
 pub use resolver::resolve_module;
 pub(crate) use resolver::{file_to_module, SearchPaths};
 use ruff_db::system::SystemPath;
+pub use typeshed::vendored_typeshed_stubs;
 
 use crate::module_resolver::resolver::search_paths;
 use crate::Db;

crates/red_knot_python_semantic/src/module_resolver/resolver.rs

@@ -1,23 +1,22 @@
+use rustc_hash::{FxBuildHasher, FxHashSet};
 use std::borrow::Cow;
 use std::iter::FusedIterator;
-
-use rustc_hash::{FxBuildHasher, FxHashSet};
+use std::ops::Deref;
 
 use ruff_db::files::{File, FilePath, FileRootKind};
 use ruff_db::system::{DirectoryEntry, System, SystemPath, SystemPathBuf};
 use ruff_db::vendored::{VendoredFileSystem, VendoredPath};
 
+use super::module::{Module, ModuleKind};
+use super::path::{ModulePath, SearchPath, SearchPathValidationError};
 use crate::db::Db;
 use crate::module_name::ModuleName;
 use crate::module_resolver::typeshed::{vendored_typeshed_versions, TypeshedVersions};
 use crate::site_packages::VirtualEnvironment;
 use crate::{Program, PythonVersion, SearchPathSettings, SitePackages};
 
-use super::module::{Module, ModuleKind};
-use super::path::{ModulePath, SearchPath, SearchPathValidationError};
-
 /// Resolves a module name to a module.
-pub fn resolve_module(db: &dyn Db, module_name: &ModuleName) -> Option<Module> {
+pub fn resolve_module(db: &dyn Db, module_name: ModuleName) -> Option<Module> {
     let interned_name = ModuleNameIngredient::new(db, module_name);
 
     resolve_module_query(db, interned_name)
@@ -36,14 +35,14 @@ pub(crate) fn resolve_module_query<'db>(
     let _span = tracing::trace_span!("resolve_module", %name).entered();
 
     let Some((search_path, module_file, kind)) = resolve_name(db, name) else {
-        tracing::debug!("Module `{name}` not found in search paths");
+        tracing::debug!("Module '{name}' not found in the search paths.");
         return None;
     };
 
     let module = Module::new(name.clone(), kind, search_path, module_file);
 
     tracing::trace!(
-        "Resolved module `{name}` to `{path}`",
+        "Resolved module '{name}' to '{path}'.",
         path = module_file.path(db)
     );
 
@@ -103,7 +102,7 @@ pub(crate) fn file_to_module(db: &dyn Db, file: File) -> Option<Module> {
     // If it doesn't, then that means that multiple modules have the same name in different
     // root paths, but that the module corresponding to `path` is in a lower priority search path,
     // in which case we ignore it.
-    let module = resolve_module(db, &module_name)?;
+    let module = resolve_module(db, module_name)?;
 
     if file == module.file() {
         Some(module)
@@ -137,7 +136,7 @@ pub(crate) struct SearchPaths {
     /// for the first `site-packages` path
     site_packages: Vec<SearchPath>,
 
-    typeshed_versions: TypeshedVersions,
+    typeshed_versions: ResolvedTypeshedVersions,
 }
 
 impl SearchPaths {
@@ -203,11 +202,11 @@ impl SearchPaths {
 
             let search_path = SearchPath::custom_stdlib(db, &custom_typeshed)?;
 
-            (parsed, search_path)
+            (ResolvedTypeshedVersions::Custom(parsed), search_path)
         } else {
             tracing::debug!("Using vendored stdlib");
             (
-                vendored_typeshed_versions(db),
+                ResolvedTypeshedVersions::Vendored(vendored_typeshed_versions()),
                 SearchPath::vendored_stdlib(),
             )
         };
@@ -280,6 +279,23 @@ impl SearchPaths {
     }
 }
 
+#[derive(Debug, PartialEq, Eq)]
+enum ResolvedTypeshedVersions {
+    Vendored(&'static TypeshedVersions),
+    Custom(TypeshedVersions),
+}
+
+impl Deref for ResolvedTypeshedVersions {
+    type Target = TypeshedVersions;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            ResolvedTypeshedVersions::Vendored(versions) => versions,
+            ResolvedTypeshedVersions::Custom(versions) => versions,
+        }
+    }
+}
+
 /// Collect all dynamic search paths. For each `site-packages` path:
 /// - Collect that `site-packages` path
 /// - Collect any search paths listed in `.pth` files in that `site-packages` directory
@@ -324,7 +340,7 @@ pub(crate) fn dynamic_resolution_paths(db: &dyn Db) -> Vec<SearchPath> {
 
         let site_packages_root = files
             .root(db.upcast(), site_packages_dir)
-            .expect("Site-package root to have been created");
+            .expect("Site-package root to have been created.");
 
         // This query needs to be re-executed each time a `.pth` file
         // is added, modified or removed from the `site-packages` directory.
@@ -728,11 +744,11 @@ mod tests {
             .build();
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
-        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
+        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
 
         assert_eq!(
             Some(&foo_module),
-            resolve_module(&db, &foo_module_name).as_ref()
+            resolve_module(&db, foo_module_name.clone()).as_ref()
         );
 
         assert_eq!("foo", foo_module.name());
@@ -755,7 +771,7 @@ mod tests {
             .build();
 
         let builtins_module_name = ModuleName::new_static("builtins").unwrap();
-        let builtins = resolve_module(&db, &builtins_module_name).expect("builtins to resolve");
+        let builtins = resolve_module(&db, builtins_module_name).expect("builtins to resolve");
 
         assert_eq!(builtins.file().path(&db), &stdlib.join("builtins.pyi"));
     }
@@ -776,7 +792,7 @@ mod tests {
             .build();
 
         let builtins_module_name = ModuleName::new_static("builtins").unwrap();
-        let builtins = resolve_module(&db, &builtins_module_name).expect("builtins to resolve");
+        let builtins = resolve_module(&db, builtins_module_name).expect("builtins to resolve");
 
         assert_eq!(builtins.file().path(&db), &stdlib.join("builtins.pyi"));
     }
@@ -794,11 +810,11 @@ mod tests {
             .build();
 
         let functools_module_name = ModuleName::new_static("functools").unwrap();
-        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
+        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
 
         assert_eq!(
             Some(&functools_module),
-            resolve_module(&db, &functools_module_name).as_ref()
+            resolve_module(&db, functools_module_name).as_ref()
         );
 
         assert_eq!(&stdlib, functools_module.search_path());
@@ -848,7 +864,7 @@ mod tests {
 
         let existing_modules = create_module_names(&["asyncio", "functools", "xml.etree"]);
         for module_name in existing_modules {
-            let resolved_module = resolve_module(&db, &module_name).unwrap_or_else(|| {
+            let resolved_module = resolve_module(&db, module_name.clone()).unwrap_or_else(|| {
                 panic!("Expected module {module_name} to exist in the mock stdlib")
             });
             let search_path = resolved_module.search_path();
@@ -901,7 +917,7 @@ mod tests {
 
         for module_name in nonexisting_modules {
             assert!(
-                resolve_module(&db, &module_name).is_none(),
+                resolve_module(&db, module_name.clone()).is_none(),
                 "Unexpectedly resolved a module for {module_name}"
             );
         }
@@ -944,7 +960,7 @@ mod tests {
         ]);
 
         for module_name in existing_modules {
-            let resolved_module = resolve_module(&db, &module_name).unwrap_or_else(|| {
+            let resolved_module = resolve_module(&db, module_name.clone()).unwrap_or_else(|| {
                 panic!("Expected module {module_name} to exist in the mock stdlib")
             });
             let search_path = resolved_module.search_path();
@@ -980,7 +996,7 @@ mod tests {
         let nonexisting_modules = create_module_names(&["importlib", "xml", "xml.etree"]);
         for module_name in nonexisting_modules {
             assert!(
-                resolve_module(&db, &module_name).is_none(),
+                resolve_module(&db, module_name.clone()).is_none(),
                 "Unexpectedly resolved a module for {module_name}"
             );
         }
@@ -1002,11 +1018,11 @@ mod tests {
             .build();
 
         let functools_module_name = ModuleName::new_static("functools").unwrap();
-        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
+        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
 
         assert_eq!(
             Some(&functools_module),
-            resolve_module(&db, &functools_module_name).as_ref()
+            resolve_module(&db, functools_module_name).as_ref()
         );
         assert_eq!(&src, functools_module.search_path());
         assert_eq!(ModuleKind::Module, functools_module.kind());
@@ -1026,7 +1042,7 @@ mod tests {
             .build();
 
         let pydoc_data_topics_name = ModuleName::new_static("pydoc_data.topics").unwrap();
-        let pydoc_data_topics = resolve_module(&db, &pydoc_data_topics_name).unwrap();
+        let pydoc_data_topics = resolve_module(&db, pydoc_data_topics_name).unwrap();
 
         assert_eq!("pydoc_data.topics", pydoc_data_topics.name());
         assert_eq!(pydoc_data_topics.search_path(), &stdlib);
@@ -1043,7 +1059,7 @@ mod tests {
             .build();
 
         let foo_path = src.join("foo/__init__.py");
-        let foo_module = resolve_module(&db, &ModuleName::new_static("foo").unwrap()).unwrap();
+        let foo_module = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
 
         assert_eq!("foo", foo_module.name());
         assert_eq!(&src, foo_module.search_path());
@@ -1070,7 +1086,7 @@ mod tests {
 
         let TestCase { db, src, .. } = TestCaseBuilder::new().with_src_files(SRC).build();
 
-        let foo_module = resolve_module(&db, &ModuleName::new_static("foo").unwrap()).unwrap();
+        let foo_module = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
         let foo_init_path = src.join("foo/__init__.py");
 
         assert_eq!(&src, foo_module.search_path());
@@ -1098,11 +1114,11 @@ mod tests {
         let foo_bar_module_name = ModuleName::new_static("foo.bar").unwrap();
 
         // `foo.py` takes priority over the `foo` namespace package
-        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
+        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
         assert_eq!(foo_module.file().path(&db), &src.join("foo.py"));
 
         // `foo.bar` isn't recognised as a module
-        let foo_bar_module = resolve_module(&db, &foo_bar_module_name);
+        let foo_bar_module = resolve_module(&db, foo_bar_module_name.clone());
         assert_eq!(foo_bar_module, None);
     }
 
@@ -1112,7 +1128,7 @@ mod tests {
 
         let TestCase { db, src, .. } = TestCaseBuilder::new().with_src_files(SRC).build();
 
-        let foo = resolve_module(&db, &ModuleName::new_static("foo").unwrap()).unwrap();
+        let foo = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
         let foo_stub = src.join("foo.pyi");
 
         assert_eq!(&src, foo.search_path());
@@ -1136,7 +1152,7 @@ mod tests {
         let TestCase { db, src, .. } = TestCaseBuilder::new().with_src_files(SRC).build();
 
         let baz_module =
-            resolve_module(&db, &ModuleName::new_static("foo.bar.baz").unwrap()).unwrap();
+            resolve_module(&db, ModuleName::new_static("foo.bar.baz").unwrap()).unwrap();
         let baz_path = src.join("foo/bar/baz.py");
 
         assert_eq!(&src, baz_module.search_path());
@@ -1175,14 +1191,14 @@ mod tests {
         let one_module_name = ModuleName::new_static("parent.child.one").unwrap();
         let one_module_path = FilePath::System(src.join("parent/child/one.py"));
         assert_eq!(
-            resolve_module(&db, &one_module_name),
+            resolve_module(&db, one_module_name),
             path_to_module(&db, &one_module_path)
         );
 
         let two_module_name = ModuleName::new_static("parent.child.two").unwrap();
         let two_module_path = FilePath::System(site_packages.join("parent/child/two.py"));
         assert_eq!(
-            resolve_module(&db, &two_module_name),
+            resolve_module(&db, two_module_name),
             path_to_module(&db, &two_module_path)
         );
     }
@@ -1215,12 +1231,12 @@ mod tests {
 
         let one_module_path = FilePath::System(src.join("parent/child/one.py"));
         let one_module_name =
-            resolve_module(&db, &ModuleName::new_static("parent.child.one").unwrap());
+            resolve_module(&db, ModuleName::new_static("parent.child.one").unwrap());
         assert_eq!(one_module_name, path_to_module(&db, &one_module_path));
 
         assert_eq!(
             None,
-            resolve_module(&db, &ModuleName::new_static("parent.child.two").unwrap())
+            resolve_module(&db, ModuleName::new_static("parent.child.two").unwrap())
         );
     }
 
@@ -1236,7 +1252,7 @@ mod tests {
             .with_site_packages_files(&[("foo.py", "")])
             .build();
 
-        let foo_module = resolve_module(&db, &ModuleName::new_static("foo").unwrap()).unwrap();
+        let foo_module = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
         let foo_src_path = src.join("foo.py");
 
         assert_eq!(&src, foo_module.search_path());
@@ -1301,8 +1317,8 @@ mod tests {
         )
         .context("Invalid program settings")?;
 
-        let foo_module = resolve_module(&db, &ModuleName::new_static("foo").unwrap()).unwrap();
-        let bar_module = resolve_module(&db, &ModuleName::new_static("bar").unwrap()).unwrap();
+        let foo_module = resolve_module(&db, ModuleName::new_static("foo").unwrap()).unwrap();
+        let bar_module = resolve_module(&db, ModuleName::new_static("bar").unwrap()).unwrap();
 
         assert_ne!(foo_module, bar_module);
 
@@ -1337,7 +1353,7 @@ mod tests {
             .build();
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
-        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
+        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
 
         let bar_path = src.join("bar.py");
         let bar = system_path_to_file(&db, &bar_path).expect("bar.py to exist");
@@ -1351,7 +1367,7 @@ mod tests {
         // Re-query the foo module. The foo module should still be cached because `bar.py` isn't relevant
         // for resolving `foo`.
 
-        let foo_module2 = resolve_module(&db, &foo_module_name);
+        let foo_module2 = resolve_module(&db, foo_module_name);
 
         assert!(!db
             .take_salsa_events()
@@ -1368,14 +1384,14 @@ mod tests {
         let foo_path = src.join("foo.py");
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
-        assert_eq!(resolve_module(&db, &foo_module_name), None);
+        assert_eq!(resolve_module(&db, foo_module_name.clone()), None);
 
         // Now write the foo file
         db.write_file(&foo_path, "x = 1")?;
 
         let foo_file = system_path_to_file(&db, &foo_path).expect("foo.py to exist");
 
-        let foo_module = resolve_module(&db, &foo_module_name).expect("Foo module to resolve");
+        let foo_module = resolve_module(&db, foo_module_name).expect("Foo module to resolve");
         assert_eq!(foo_file, foo_module.file());
 
         Ok(())
@@ -1389,7 +1405,7 @@ mod tests {
         let TestCase { mut db, src, .. } = TestCaseBuilder::new().with_src_files(SRC).build();
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
-        let foo_module = resolve_module(&db, &foo_module_name).expect("foo module to exist");
+        let foo_module = resolve_module(&db, foo_module_name.clone()).expect("foo module to exist");
         let foo_init_path = src.join("foo/__init__.py");
 
         assert_eq!(&foo_init_path, foo_module.file().path(&db));
@@ -1401,7 +1417,7 @@ mod tests {
         File::sync_path(&mut db, &foo_init_path);
         File::sync_path(&mut db, foo_init_path.parent().unwrap());
 
-        let foo_module = resolve_module(&db, &foo_module_name).expect("Foo module to resolve");
+        let foo_module = resolve_module(&db, foo_module_name).expect("Foo module to resolve");
         assert_eq!(&src.join("foo.py"), foo_module.file().path(&db));
 
         Ok(())
@@ -1427,7 +1443,7 @@ mod tests {
         let functools_module_name = ModuleName::new_static("functools").unwrap();
         let stdlib_functools_path = stdlib.join("functools.pyi");
 
-        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
+        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
         assert_eq!(functools_module.search_path(), &stdlib);
         assert_eq!(
             Ok(functools_module.file()),
@@ -1440,7 +1456,7 @@ mod tests {
         let site_packages_functools_path = site_packages.join("functools.py");
         db.write_file(&site_packages_functools_path, "f: int")
             .unwrap();
-        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
+        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
         let events = db.take_salsa_events();
         assert_function_query_was_not_run(
             &db,
@@ -1473,7 +1489,7 @@ mod tests {
             .build();
 
         let functools_module_name = ModuleName::new_static("functools").unwrap();
-        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
+        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
         assert_eq!(functools_module.search_path(), &stdlib);
         assert_eq!(
             Ok(functools_module.file()),
@@ -1484,7 +1500,7 @@ mod tests {
         // since first-party files take higher priority in module resolution:
         let src_functools_path = src.join("functools.py");
         db.write_file(&src_functools_path, "FOO: int").unwrap();
-        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
+        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
         assert_eq!(functools_module.search_path(), &src);
         assert_eq!(
             Ok(functools_module.file()),
@@ -1515,7 +1531,7 @@ mod tests {
         let functools_module_name = ModuleName::new_static("functools").unwrap();
         let src_functools_path = src.join("functools.py");
 
-        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
+        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
         assert_eq!(functools_module.search_path(), &src);
         assert_eq!(
             Ok(functools_module.file()),
@@ -1528,7 +1544,7 @@ mod tests {
             .remove_file(&src_functools_path)
             .unwrap();
         File::sync_path(&mut db, &src_functools_path);
-        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
+        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
         assert_eq!(functools_module.search_path(), &stdlib);
         assert_eq!(
             Ok(functools_module.file()),
@@ -1550,8 +1566,8 @@ mod tests {
         let foo_module_name = ModuleName::new_static("foo").unwrap();
         let foo_bar_module_name = ModuleName::new_static("foo.bar").unwrap();
 
-        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
-        let foo_bar_module = resolve_module(&db, &foo_bar_module_name).unwrap();
+        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
+        let foo_bar_module = resolve_module(&db, foo_bar_module_name.clone()).unwrap();
 
         assert_eq!(
             foo_module.file().path(&db),
@@ -1579,11 +1595,11 @@ mod tests {
 
         // Lines with leading whitespace in `.pth` files do not parse:
         let foo_module_name = ModuleName::new_static("foo").unwrap();
-        assert_eq!(resolve_module(&db, &foo_module_name), None);
+        assert_eq!(resolve_module(&db, foo_module_name), None);
 
         // Lines with trailing whitespace in `.pth` files do:
         let bar_module_name = ModuleName::new_static("bar").unwrap();
-        let bar_module = resolve_module(&db, &bar_module_name).unwrap();
+        let bar_module = resolve_module(&db, bar_module_name.clone()).unwrap();
         assert_eq!(
             bar_module.file().path(&db),
             &FilePath::system("/y/src/bar.py")
@@ -1602,7 +1618,7 @@ mod tests {
             .build();
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
-        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
+        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
 
         assert_eq!(
             foo_module.file().path(&db),
@@ -1650,10 +1666,10 @@ not_a_directory
         let b_module_name = ModuleName::new_static("b").unwrap();
         let spam_module_name = ModuleName::new_static("spam").unwrap();
 
-        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
-        let a_module = resolve_module(&db, &a_module_name).unwrap();
-        let b_module = resolve_module(&db, &b_module_name).unwrap();
-        let spam_module = resolve_module(&db, &spam_module_name).unwrap();
+        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
+        let a_module = resolve_module(&db, a_module_name.clone()).unwrap();
+        let b_module = resolve_module(&db, b_module_name.clone()).unwrap();
+        let spam_module = resolve_module(&db, spam_module_name.clone()).unwrap();
 
         assert_eq!(
             foo_module.file().path(&db),
@@ -1681,14 +1697,14 @@ not_a_directory
         let foo_module_name = ModuleName::new_static("foo").unwrap();
         let bar_module_name = ModuleName::new_static("bar").unwrap();
 
-        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
+        let foo_module = resolve_module(&db, foo_module_name).unwrap();
         assert_eq!(
             foo_module.file().path(&db),
             &FilePath::system("/x/src/foo.py")
         );
 
         db.clear_salsa_events();
-        let bar_module = resolve_module(&db, &bar_module_name).unwrap();
+        let bar_module = resolve_module(&db, bar_module_name).unwrap();
         assert_eq!(
             bar_module.file().path(&db),
             &FilePath::system("/y/src/bar.py")
@@ -1713,7 +1729,7 @@ not_a_directory
         db.write_files(x_directory).unwrap();
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
-        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
+        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
         assert_eq!(
             foo_module.file().path(&db),
             &FilePath::system("/x/src/foo.py")
@@ -1725,7 +1741,7 @@ not_a_directory
 
         File::sync_path(&mut db, &site_packages.join("_foo.pth"));
 
-        assert_eq!(resolve_module(&db, &foo_module_name), None);
+        assert_eq!(resolve_module(&db, foo_module_name.clone()), None);
     }
 
     #[test]
@@ -1740,7 +1756,7 @@ not_a_directory
         db.write_files(x_directory).unwrap();
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
-        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
+        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
         let src_path = SystemPathBuf::from("/x/src");
         assert_eq!(
             foo_module.file().path(&db),
@@ -1753,7 +1769,7 @@ not_a_directory
         db.memory_file_system().remove_directory(&src_path).unwrap();
         File::sync_path(&mut db, &src_path.join("foo.py"));
         File::sync_path(&mut db, &src_path);
-        assert_eq!(resolve_module(&db, &foo_module_name), None);
+        assert_eq!(resolve_module(&db, foo_module_name.clone()), None);
     }
 
     #[test]
@@ -1812,7 +1828,7 @@ not_a_directory
         // The editable installs discovered from the `.pth` file in the first `site-packages` directory
         // take precedence over the second `site-packages` directory...
         let a_module_name = ModuleName::new_static("a").unwrap();
-        let a_module = resolve_module(&db, &a_module_name).unwrap();
+        let a_module = resolve_module(&db, a_module_name.clone()).unwrap();
         assert_eq!(a_module.file().path(&db), &editable_install_location);
 
         db.memory_file_system()
@@ -1823,7 +1839,7 @@ not_a_directory
         // ...But now that the `.pth` file in the first `site-packages` directory has been deleted,
         // the editable install no longer exists, so the module now resolves to the file in the
         // second `site-packages` directory
-        let a_module = resolve_module(&db, &a_module_name).unwrap();
+        let a_module = resolve_module(&db, a_module_name).unwrap();
         assert_eq!(a_module.file().path(&db), &system_site_packages_location);
     }
 }

crates/red_knot_python_semantic/src/module_resolver/typeshed/mod.rs

@@ -0,0 +1,8 @@
+pub use self::vendored::vendored_typeshed_stubs;
+pub(super) use self::versions::{
+    typeshed_versions, vendored_typeshed_versions, TypeshedVersions, TypeshedVersionsParseError,
+    TypeshedVersionsQueryResult,
+};
+
+mod vendored;
+mod versions;

crates/red_knot_python_semantic/src/module_resolver/typeshed/vendored.rs

@@ -6,7 +6,7 @@ use ruff_db::vendored::VendoredFileSystem;
 // Luckily this crate will fail to build if this file isn't available at build time.
 static TYPESHED_ZIP_BYTES: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/zipped_typeshed.zip"));
 
-pub fn file_system() -> &'static VendoredFileSystem {
+pub fn vendored_typeshed_stubs() -> &'static VendoredFileSystem {
     static VENDORED_TYPESHED_STUBS: Lazy<VendoredFileSystem> =
         Lazy::new(|| VendoredFileSystem::new_static(TYPESHED_ZIP_BYTES).unwrap());
     &VENDORED_TYPESHED_STUBS
@@ -42,7 +42,7 @@ mod tests {
     #[test]
     fn typeshed_vfs_consistent_with_vendored_stubs() {
         let vendored_typeshed_dir = Path::new("vendor/typeshed").canonicalize().unwrap();
-        let vendored_typeshed_stubs = file_system();
+        let vendored_typeshed_stubs = vendored_typeshed_stubs();
 
         let mut empty_iterator = true;
         for entry in walkdir::WalkDir::new(&vendored_typeshed_dir).min_depth(1) {

crates/red_knot_python_semantic/src/module_resolver/typeshed/versions.rs

@@ -4,19 +4,25 @@ use std::num::{NonZeroU16, NonZeroUsize};
 use std::ops::{RangeFrom, RangeInclusive};
 use std::str::FromStr;
 
+use once_cell::sync::Lazy;
 use rustc_hash::FxHashMap;
 
+use super::vendored::vendored_typeshed_stubs;
 use crate::db::Db;
 use crate::module_name::ModuleName;
 use crate::{Program, PythonVersion};
 
-pub(in crate::module_resolver) fn vendored_typeshed_versions(db: &dyn Db) -> TypeshedVersions {
+static VENDORED_VERSIONS: Lazy<TypeshedVersions> = Lazy::new(|| {
     TypeshedVersions::from_str(
-        &db.vendored()
+        &vendored_typeshed_stubs()
             .read_to_string("stdlib/VERSIONS")
-            .expect("The vendored typeshed stubs should contain a VERSIONS file"),
+            .unwrap(),
     )
-    .expect("The VERSIONS file in the vendored typeshed stubs should be well-formed")
+    .unwrap()
+});
+
+pub(crate) fn vendored_typeshed_versions() -> &'static TypeshedVersions {
+    &VENDORED_VERSIONS
 }
 
 pub(crate) fn typeshed_versions(db: &dyn Db) -> &TypeshedVersions {
@@ -326,8 +332,6 @@ mod tests {
 
     use insta::assert_snapshot;
 
-    use crate::db::tests::TestDb;
-
     use super::*;
 
     const TYPESHED_STDLIB_DIR: &str = "stdlib";
@@ -349,9 +353,12 @@ mod tests {
 
     #[test]
     fn can_parse_vendored_versions_file() {
-        let db = TestDb::new();
+        let versions_data = include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/vendor/typeshed/stdlib/VERSIONS"
+        ));
 
-        let versions = vendored_typeshed_versions(&db);
+        let versions = TypeshedVersions::from_str(versions_data).unwrap();
         assert!(versions.len() > 100);
         assert!(versions.len() < 1000);
 
@@ -388,10 +395,9 @@ mod tests {
 
     #[test]
     fn typeshed_versions_consistent_with_vendored_stubs() {
-        let db = TestDb::new();
-        let vendored_typeshed_versions = vendored_typeshed_versions(&db);
-        let vendored_typeshed_dir =
-            Path::new(env!("CARGO_MANIFEST_DIR")).join("../red_knot_vendored/vendor/typeshed");
+        const VERSIONS_DATA: &str = include_str!("../../../vendor/typeshed/stdlib/VERSIONS");
+        let vendored_typeshed_dir = Path::new("vendor/typeshed").canonicalize().unwrap();
+        let vendored_typeshed_versions = TypeshedVersions::from_str(VERSIONS_DATA).unwrap();
 
         let mut empty_iterator = true;
 

crates/red_knot_python_semantic/src/python_version.rs

@@ -54,13 +54,6 @@ impl TryFrom<(&str, &str)> for PythonVersion {
     }
 }
 
-impl From<(u8, u8)> for PythonVersion {
-    fn from(value: (u8, u8)) -> Self {
-        let (major, minor) = value;
-        Self { major, minor }
-    }
-}
-
 impl fmt::Display for PythonVersion {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let PythonVersion { major, minor } = self;

crates/red_knot_python_semantic/src/semantic_index.rs

@@ -1,7 +1,7 @@
 use std::iter::FusedIterator;
 use std::sync::Arc;
 
-use rustc_hash::{FxBuildHasher, FxHashMap};
+use rustc_hash::FxHashMap;
 use salsa::plumbing::AsId;
 
 use ruff_db::files::File;
@@ -31,7 +31,7 @@ pub(crate) use self::use_def::{
     BindingWithConstraints, BindingWithConstraintsIterator, DeclarationsIterator,
 };
 
-type SymbolMap = hashbrown::HashMap<ScopedSymbolId, (), FxBuildHasher>;
+type SymbolMap = hashbrown::HashMap<ScopedSymbolId, (), ()>;
 
 /// Returns the semantic index for `file`.
 ///
@@ -115,9 +115,6 @@ pub(crate) struct SemanticIndex<'db> {
     /// Note: We should not depend on this map when analysing other files or
     /// changing a file invalidates all dependents.
     ast_ids: IndexVec<FileScopeId, AstIds>,
-
-    /// Flags about the global scope (code usage impacting inference)
-    has_future_annotations: bool,
 }
 
 impl<'db> SemanticIndex<'db> {
@@ -218,12 +215,6 @@ impl<'db> SemanticIndex<'db> {
     pub(crate) fn node_scope(&self, node: NodeWithScopeRef) -> FileScopeId {
         self.scopes_by_node[&node.node_key()]
     }
-
-    /// Checks if there is an import of `__future__.annotations` in the global scope, which affects
-    /// the logic for type inference.
-    pub(super) fn has_future_annotations(&self) -> bool {
-        self.has_future_annotations
-    }
 }
 
 pub struct AncestorsIter<'a> {
@@ -464,7 +455,7 @@ mod tests {
             global_table
                 .symbol_by_name("foo")
                 .is_some_and(|symbol| { !symbol.is_bound() && symbol.is_used() }),
-            "a symbol used but not bound in a scope should have only the used flag"
+            "a symbol used but not defined in a scope should have only the used flag"
         );
         let use_def = use_def_map(&db, scope);
         let binding = use_def
@@ -994,7 +985,7 @@ class C[T]:
         let ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
             value: ast::Number::Int(num),
             ..
-        }) = assignment.value()
+        }) = &*assignment.assignment().value
         else {
             panic!("should be a number literal")
         };
@@ -1036,7 +1027,7 @@ class C[T]:
         }
 
         let TestCase { db, file } = test_case(
-            r"
+            r#"
 class Test:
     def foo():
         def bar():
@@ -1045,7 +1036,7 @@ class Test:
         pass
 
 def x():
-    pass",
+    pass"#,
         );
 
         let index = semantic_index(&db, file);

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -1,6 +1,5 @@
 use std::sync::Arc;
 
-use except_handlers::TryNodeContextStackManager;
 use rustc_hash::FxHashMap;
 
 use ruff_db::files::File;
@@ -29,30 +28,21 @@ use crate::Db;
 
 use super::constraint::{Constraint, PatternConstraint};
 use super::definition::{
-    AssignmentKind, DefinitionCategory, ExceptHandlerDefinitionNodeRef,
-    MatchPatternDefinitionNodeRef, WithItemDefinitionNodeRef,
+    ExceptHandlerDefinitionNodeRef, MatchPatternDefinitionNodeRef, WithItemDefinitionNodeRef,
 };
 
-mod except_handlers;
-
 pub(super) struct SemanticIndexBuilder<'db> {
     // Builder state
     db: &'db dyn Db,
     file: File,
     module: &'db ParsedModule,
     scope_stack: Vec<FileScopeId>,
-    /// The assignments we're currently visiting, with
-    /// the most recent visit at the end of the Vec
-    current_assignments: Vec<CurrentAssignment<'db>>,
+    /// The assignment we're currently visiting.
+    current_assignment: Option<CurrentAssignment<'db>>,
     /// The match case we're currently visiting.
     current_match_case: Option<CurrentMatchCase<'db>>,
     /// Flow states at each `break` in the current loop.
     loop_break_states: Vec<FlowSnapshot>,
-    /// Per-scope contexts regarding nested `try`/`except` statements
-    try_node_context_stack_manager: TryNodeContextStackManager,
-
-    /// Flags about the file's global scope
-    has_future_annotations: bool,
 
     // Semantic Index fields
     scopes: IndexVec<FileScopeId, Scope>,
@@ -73,12 +63,9 @@ impl<'db> SemanticIndexBuilder<'db> {
             file,
             module: parsed,
             scope_stack: Vec::new(),
-            current_assignments: vec![],
+            current_assignment: None,
             current_match_case: None,
             loop_break_states: vec![],
-            try_node_context_stack_manager: TryNodeContextStackManager::default(),
-
-            has_future_annotations: false,
 
             scopes: IndexVec::new(),
             symbol_tables: IndexVec::new(),
@@ -117,7 +104,6 @@ impl<'db> SemanticIndexBuilder<'db> {
             kind: node.scope_kind(),
             descendents: children_start..children_start,
         };
-        self.try_node_context_stack_manager.enter_nested_scope();
 
         let file_scope_id = self.scopes.push(scope);
         self.symbol_tables.push(SymbolTableBuilder::new());
@@ -147,7 +133,6 @@ impl<'db> SemanticIndexBuilder<'db> {
         let children_end = self.scopes.next_index();
         let scope = &mut self.scopes[id];
         scope.descendents = scope.descendents.start..children_end;
-        self.try_node_context_stack_manager.exit_scope();
         id
     }
 
@@ -206,9 +191,8 @@ impl<'db> SemanticIndexBuilder<'db> {
     ) -> Definition<'db> {
         let definition_node: DefinitionNodeRef<'_> = definition_node.into();
         #[allow(unsafe_code)]
-        // SAFETY: `definition_node` is guaranteed to be a child of `self.module`
         let kind = unsafe { definition_node.into_owned(self.module.clone()) };
-        let category = kind.category();
+        let (is_declaration, is_binding) = (kind.is_declaration(), kind.is_binding());
         let definition = Definition::new(
             self.db,
             self.file,
@@ -223,23 +207,18 @@ impl<'db> SemanticIndexBuilder<'db> {
             .insert(definition_node.key(), definition);
         debug_assert_eq!(existing_definition, None);
 
-        if category.is_binding() {
+        if is_binding {
             self.mark_symbol_bound(symbol);
         }
 
         let use_def = self.current_use_def_map_mut();
-        match category {
-            DefinitionCategory::DeclarationAndBinding => {
-                use_def.record_declaration_and_binding(symbol, definition);
-            }
-            DefinitionCategory::Declaration => use_def.record_declaration(symbol, definition),
-            DefinitionCategory::Binding => use_def.record_binding(symbol, definition),
+        match (is_declaration, is_binding) {
+            (true, true) => use_def.record_declaration_and_binding(symbol, definition),
+            (true, false) => use_def.record_declaration(symbol, definition),
+            (false, true) => use_def.record_binding(symbol, definition),
+            (false, false) => unreachable!("definition must be declaration or binding or both"),
         }
 
-        let mut try_node_stack_manager = std::mem::take(&mut self.try_node_context_stack_manager);
-        try_node_stack_manager.record_definition(self);
-        self.try_node_context_stack_manager = try_node_stack_manager;
-
         definition
     }
 
@@ -251,19 +230,6 @@ impl<'db> SemanticIndexBuilder<'db> {
         expression
     }
 
-    fn push_assignment(&mut self, assignment: CurrentAssignment<'db>) {
-        self.current_assignments.push(assignment);
-    }
-
-    fn pop_assignment(&mut self) {
-        let popped_assignment = self.current_assignments.pop();
-        debug_assert!(popped_assignment.is_some());
-    }
-
-    fn current_assignment(&self) -> Option<&CurrentAssignment<'db>> {
-        self.current_assignments.last()
-    }
-
     fn add_pattern_constraint(
         &mut self,
         subject: &ast::Expr,
@@ -335,11 +301,9 @@ impl<'db> SemanticIndexBuilder<'db> {
                 };
                 let symbol = self.add_symbol(name.id.clone());
                 // TODO create Definition for PEP 695 typevars
-                // note that the "bound" on the typevar is a totally different thing than whether
-                // or not a name is "bound" by a typevar declaration; the latter is always true.
                 self.mark_symbol_bound(symbol);
-                if let Some(bounds) = bound {
-                    self.visit_expr(bounds);
+                if let Some(bound) = bound {
+                    self.visit_expr(bound);
                 }
                 if let Some(default) = default {
                     self.visit_expr(default);
@@ -356,23 +320,11 @@ impl<'db> SemanticIndexBuilder<'db> {
         nested_scope
     }
 
-    /// This method does several things:
-    /// - It pushes a new scope onto the stack for visiting
-    ///   a list/dict/set comprehension or generator expression
-    /// - Inside that scope, it visits a list of [`Comprehension`] nodes,
-    ///   assumed to be the "generators" that compose a comprehension
-    ///   (that is, the `for x in y` and `for y in z` parts of `x for x in y for y in z`).
-    /// - Inside that scope, it also calls a closure for visiting the outer `elt`
-    ///   of a list/dict/set comprehension or generator expression
-    /// - It then pops the new scope off the stack
+    /// Visit a list of [`Comprehension`] nodes, assumed to be the "generators" that compose a
+    /// comprehension (that is, the `for x in y` and `for y in z` parts of `x for x in y for y in z`.)
     ///
     /// [`Comprehension`]: ast::Comprehension
-    fn with_generators_scope(
-        &mut self,
-        scope: NodeWithScopeRef,
-        generators: &'db [ast::Comprehension],
-        visit_outer_elt: impl FnOnce(&mut Self),
-    ) {
+    fn visit_generators(&mut self, scope: NodeWithScopeRef, generators: &'db [ast::Comprehension]) {
         let mut generators_iter = generators.iter();
 
         let Some(generator) = generators_iter.next() else {
@@ -385,12 +337,12 @@ impl<'db> SemanticIndexBuilder<'db> {
         self.visit_expr(&generator.iter);
         self.push_scope(scope);
 
-        self.push_assignment(CurrentAssignment::Comprehension {
+        self.current_assignment = Some(CurrentAssignment::Comprehension {
             node: generator,
             first: true,
         });
         self.visit_expr(&generator.target);
-        self.pop_assignment();
+        self.current_assignment = None;
 
         for expr in &generator.ifs {
             self.visit_expr(expr);
@@ -400,20 +352,17 @@ impl<'db> SemanticIndexBuilder<'db> {
             self.add_standalone_expression(&generator.iter);
             self.visit_expr(&generator.iter);
 
-            self.push_assignment(CurrentAssignment::Comprehension {
+            self.current_assignment = Some(CurrentAssignment::Comprehension {
                 node: generator,
                 first: false,
             });
             self.visit_expr(&generator.target);
-            self.pop_assignment();
+            self.current_assignment = None;
 
             for expr in &generator.ifs {
                 self.visit_expr(expr);
             }
         }
-
-        visit_outer_elt(self);
-        self.pop_scope();
     }
 
     fn declare_parameter(&mut self, parameter: AnyParameterRef) {
@@ -441,7 +390,7 @@ impl<'db> SemanticIndexBuilder<'db> {
         self.pop_scope();
         assert!(self.scope_stack.is_empty());
 
-        assert_eq!(&self.current_assignments, &[]);
+        assert!(self.current_assignment.is_none());
 
         let mut symbol_tables: IndexVec<_, _> = self
             .symbol_tables
@@ -481,7 +430,6 @@ impl<'db> SemanticIndexBuilder<'db> {
             scopes_by_expression: self.scopes_by_expression,
             scopes_by_node: self.scopes_by_node,
             use_def_maps,
-            has_future_annotations: self.has_future_annotations,
         }
     }
 }
@@ -575,52 +523,29 @@ where
                         &alias.name.id
                     };
 
-                    // Look for imports `from __future__ import annotations`, ignore `as ...`
-                    // We intentionally don't enforce the rules about location of `__future__`
-                    // imports here, we assume the user's intent was to apply the `__future__`
-                    // import, so we still check using it (and will also emit a diagnostic about a
-                    // miss-placed `__future__` import.)
-                    self.has_future_annotations |= alias.name.id == "annotations"
-                        && node.module.as_deref() == Some("__future__");
-
                     let symbol = self.add_symbol(symbol_name.clone());
-
                     self.add_definition(symbol, ImportFromDefinitionNodeRef { node, alias_index });
                 }
             }
             ast::Stmt::Assign(node) => {
-                debug_assert_eq!(&self.current_assignments, &[]);
+                debug_assert!(self.current_assignment.is_none());
                 self.visit_expr(&node.value);
                 self.add_standalone_expression(&node.value);
-                for (target_index, target) in node.targets.iter().enumerate() {
-                    let kind = match target {
-                        ast::Expr::List(_) | ast::Expr::Tuple(_) => Some(AssignmentKind::Sequence),
-                        ast::Expr::Name(_) => Some(AssignmentKind::Name),
-                        _ => None,
-                    };
-                    if let Some(kind) = kind {
-                        self.push_assignment(CurrentAssignment::Assign {
-                            assignment: node,
-                            target_index,
-                            kind,
-                        });
-                    }
+                self.current_assignment = Some(node.into());
+                for target in &node.targets {
                     self.visit_expr(target);
-                    if kind.is_some() {
-                        // only need to pop in the case where we pushed something
-                        self.pop_assignment();
-                    }
                 }
+                self.current_assignment = None;
             }
             ast::Stmt::AnnAssign(node) => {
-                debug_assert_eq!(&self.current_assignments, &[]);
+                debug_assert!(self.current_assignment.is_none());
                 self.visit_expr(&node.annotation);
                 if let Some(value) = &node.value {
                     self.visit_expr(value);
                 }
-                self.push_assignment(node.into());
+                self.current_assignment = Some(node.into());
                 self.visit_expr(&node.target);
-                self.pop_assignment();
+                self.current_assignment = None;
             }
             ast::Stmt::AugAssign(
                 aug_assign @ ast::StmtAugAssign {
@@ -630,11 +555,11 @@ where
                     value,
                 },
             ) => {
-                debug_assert_eq!(&self.current_assignments, &[]);
+                debug_assert!(self.current_assignment.is_none());
                 self.visit_expr(value);
-                self.push_assignment(aug_assign.into());
+                self.current_assignment = Some(aug_assign.into());
                 self.visit_expr(target);
-                self.pop_assignment();
+                self.current_assignment = None;
             }
             ast::Stmt::If(node) => {
                 self.visit_expr(&node.test);
@@ -702,9 +627,9 @@ where
                     self.visit_expr(&item.context_expr);
                     if let Some(optional_vars) = item.optional_vars.as_deref() {
                         self.add_standalone_expression(&item.context_expr);
-                        self.push_assignment(item.into());
+                        self.current_assignment = Some(item.into());
                         self.visit_expr(optional_vars);
-                        self.pop_assignment();
+                        self.current_assignment = None;
                     }
                 }
                 self.visit_body(body);
@@ -729,10 +654,10 @@ where
                 let pre_loop = self.flow_snapshot();
                 let saved_break_states = std::mem::take(&mut self.loop_break_states);
 
-                debug_assert_eq!(&self.current_assignments, &[]);
-                self.push_assignment(for_stmt.into());
+                debug_assert!(self.current_assignment.is_none());
+                self.current_assignment = Some(for_stmt.into());
                 self.visit_expr(target);
-                self.pop_assignment();
+                self.current_assignment = None;
 
                 // TODO: Definitions created by loop variables
                 // (and definitions created inside the body)
@@ -793,104 +718,40 @@ where
                 is_star,
                 range: _,
             }) => {
-                // Save the state prior to visiting any of the `try` block.
-                //
-                // Potentially none of the `try` block could have been executed prior to executing
-                // the `except` block(s) and/or the `finally` block.
-                // We will merge this state with all of the intermediate
-                // states during the `try` block before visiting those suites.
-                let pre_try_block_state = self.flow_snapshot();
-
-                self.try_node_context_stack_manager.push_context();
-
-                // Visit the `try` block!
                 self.visit_body(body);
 
-                let mut post_except_states = vec![];
+                for except_handler in handlers {
+                    let ast::ExceptHandler::ExceptHandler(except_handler) = except_handler;
+                    let ast::ExceptHandlerExceptHandler {
+                        name: symbol_name,
+                        type_: handled_exceptions,
+                        body: handler_body,
+                        range: _,
+                    } = except_handler;
 
-                // Take a record also of all the intermediate states we encountered
-                // while visiting the `try` block
-                let try_block_snapshots = self.try_node_context_stack_manager.pop_context();
-
-                if !handlers.is_empty() {
-                    // Save the state immediately *after* visiting the `try` block
-                    // but *before* we prepare for visiting the `except` block(s).
-                    //
-                    // We will revert to this state prior to visiting the the `else` block,
-                    // as there necessarily must have been 0 `except` blocks executed
-                    // if we hit the `else` block.
-                    let post_try_block_state = self.flow_snapshot();
-
-                    // Prepare for visiting the `except` block(s)
-                    self.flow_restore(pre_try_block_state);
-                    for state in try_block_snapshots {
-                        self.flow_merge(state);
+                    if let Some(handled_exceptions) = handled_exceptions {
+                        self.visit_expr(handled_exceptions);
                     }
 
-                    let pre_except_state = self.flow_snapshot();
-                    let num_handlers = handlers.len();
+                    // If `handled_exceptions` above was `None`, it's something like `except as e:`,
+                    // which is invalid syntax. However, it's still pretty obvious here that the user
+                    // *wanted* `e` to be bound, so we should still create a definition here nonetheless.
+                    if let Some(symbol_name) = symbol_name {
+                        let symbol = self.add_symbol(symbol_name.id.clone());
 
-                    for (i, except_handler) in handlers.iter().enumerate() {
-                        let ast::ExceptHandler::ExceptHandler(except_handler) = except_handler;
-                        let ast::ExceptHandlerExceptHandler {
-                            name: symbol_name,
-                            type_: handled_exceptions,
-                            body: handler_body,
-                            range: _,
-                        } = except_handler;
-
-                        if let Some(handled_exceptions) = handled_exceptions {
-                            self.visit_expr(handled_exceptions);
-                        }
-
-                        // If `handled_exceptions` above was `None`, it's something like `except as e:`,
-                        // which is invalid syntax. However, it's still pretty obvious here that the user
-                        // *wanted* `e` to be bound, so we should still create a definition here nonetheless.
-                        if let Some(symbol_name) = symbol_name {
-                            let symbol = self.add_symbol(symbol_name.id.clone());
-
-                            self.add_definition(
-                                symbol,
-                                DefinitionNodeRef::ExceptHandler(ExceptHandlerDefinitionNodeRef {
-                                    handler: except_handler,
-                                    is_star: *is_star,
-                                }),
-                            );
-                        }
-
-                        self.visit_body(handler_body);
-                        // Each `except` block is mutually exclusive with all other `except` blocks.
-                        post_except_states.push(self.flow_snapshot());
-
-                        // It's unnecessary to do the `self.flow_restore()` call for the final except handler,
-                        // as we'll immediately call `self.flow_restore()` to a different state
-                        // as soon as this loop over the handlers terminates.
-                        if i < (num_handlers - 1) {
-                            self.flow_restore(pre_except_state.clone());
-                        }
+                        self.add_definition(
+                            symbol,
+                            DefinitionNodeRef::ExceptHandler(ExceptHandlerDefinitionNodeRef {
+                                handler: except_handler,
+                                is_star: *is_star,
+                            }),
+                        );
                     }
 
-                    // If we get to the `else` block, we know that 0 of the `except` blocks can have been executed,
-                    // and the entire `try` block must have been executed:
-                    self.flow_restore(post_try_block_state);
+                    self.visit_body(handler_body);
                 }
 
                 self.visit_body(orelse);
-
-                for post_except_state in post_except_states {
-                    self.flow_merge(post_except_state);
-                }
-
-                // TODO: there's lots of complexity here that isn't yet handled by our model.
-                // In order to accurately model the semantics of `finally` suites, we in fact need to visit
-                // the suite twice: once under the (current) assumption that either the `try + else` suite
-                // ran to completion or exactly one `except` branch ran to completion, and then again under
-                // the assumption that potentially none of the branches ran to completion and we in fact
-                // jumped from a `try`, `else` or `except` branch straight into the `finally` branch.
-                // This requires rethinking some fundamental assumptions semantic indexing makes.
-                // For more details, see:
-                // - https://astral-sh.notion.site/Exception-handler-control-flow-11348797e1ca80bb8ce1e9aedbbe439d
-                // - https://github.com/astral-sh/ruff/pull/13633#discussion_r1788626702
                 self.visit_body(finalbody);
             }
             _ => {
@@ -906,7 +767,7 @@ where
 
         match expr {
             ast::Expr::Name(name_node @ ast::ExprName { id, ctx, .. }) => {
-                let (is_use, is_definition) = match (ctx, self.current_assignment()) {
+                let (is_use, is_definition) = match (ctx, self.current_assignment) {
                     (ast::ExprContext::Store, Some(CurrentAssignment::AugAssign(_))) => {
                         // For augmented assignment, the target expression is also used.
                         (true, true)
@@ -917,21 +778,14 @@ where
                     (ast::ExprContext::Invalid, _) => (false, false),
                 };
                 let symbol = self.add_symbol(id.clone());
-
                 if is_definition {
-                    match self.current_assignment().copied() {
-                        Some(CurrentAssignment::Assign {
-                            assignment,
-                            target_index,
-                            kind,
-                        }) => {
+                    match self.current_assignment {
+                        Some(CurrentAssignment::Assign(assignment)) => {
                             self.add_definition(
                                 symbol,
                                 AssignmentDefinitionNodeRef {
                                     assignment,
-                                    target_index,
-                                    name: name_node,
-                                    kind,
+                                    target: name_node,
                                 },
                             );
                         }
@@ -990,11 +844,12 @@ where
                 walk_expr(self, expr);
             }
             ast::Expr::Named(node) => {
+                debug_assert!(self.current_assignment.is_none());
                 // TODO walrus in comprehensions is implicitly nonlocal
                 self.visit_expr(&node.value);
-                self.push_assignment(node.into());
+                self.current_assignment = Some(node.into());
                 self.visit_expr(&node.target);
-                self.pop_assignment();
+                self.current_assignment = None;
             }
             ast::Expr::Lambda(lambda) => {
                 if let Some(parameters) = &lambda.parameters {
@@ -1018,7 +873,6 @@ where
                 }
 
                 self.visit_expr(lambda.body.as_ref());
-                self.pop_scope();
             }
             ast::Expr::If(ast::ExprIf {
                 body, test, orelse, ..
@@ -1039,33 +893,30 @@ where
                     elt, generators, ..
                 },
             ) => {
-                self.with_generators_scope(
+                self.visit_generators(
                     NodeWithScopeRef::ListComprehension(list_comprehension),
                     generators,
-                    |builder| builder.visit_expr(elt),
                 );
+                self.visit_expr(elt);
             }
             ast::Expr::SetComp(
                 set_comprehension @ ast::ExprSetComp {
                     elt, generators, ..
                 },
             ) => {
-                self.with_generators_scope(
+                self.visit_generators(
                     NodeWithScopeRef::SetComprehension(set_comprehension),
                     generators,
-                    |builder| builder.visit_expr(elt),
                 );
+                self.visit_expr(elt);
             }
             ast::Expr::Generator(
                 generator @ ast::ExprGenerator {
                     elt, generators, ..
                 },
             ) => {
-                self.with_generators_scope(
-                    NodeWithScopeRef::GeneratorExpression(generator),
-                    generators,
-                    |builder| builder.visit_expr(elt),
-                );
+                self.visit_generators(NodeWithScopeRef::GeneratorExpression(generator), generators);
+                self.visit_expr(elt);
             }
             ast::Expr::DictComp(
                 dict_comprehension @ ast::ExprDictComp {
@@ -1075,19 +926,28 @@ where
                     ..
                 },
             ) => {
-                self.with_generators_scope(
+                self.visit_generators(
                     NodeWithScopeRef::DictComprehension(dict_comprehension),
                     generators,
-                    |builder| {
-                        builder.visit_expr(key);
-                        builder.visit_expr(value);
-                    },
                 );
+                self.visit_expr(key);
+                self.visit_expr(value);
             }
             _ => {
                 walk_expr(self, expr);
             }
         }
+
+        if matches!(
+            expr,
+            ast::Expr::Lambda(_)
+                | ast::Expr::ListComp(_)
+                | ast::Expr::SetComp(_)
+                | ast::Expr::Generator(_)
+                | ast::Expr::DictComp(_)
+        ) {
+            self.pop_scope();
+        }
     }
 
     fn visit_parameters(&mut self, parameters: &'ast ast::Parameters) {
@@ -1153,13 +1013,9 @@ where
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq)]
+#[derive(Copy, Clone, Debug)]
 enum CurrentAssignment<'a> {
-    Assign {
-        assignment: &'a ast::StmtAssign,
-        target_index: usize,
-        kind: AssignmentKind,
-    },
+    Assign(&'a ast::StmtAssign),
     AnnAssign(&'a ast::StmtAnnAssign),
     AugAssign(&'a ast::StmtAugAssign),
     For(&'a ast::StmtFor),
@@ -1171,6 +1027,12 @@ enum CurrentAssignment<'a> {
     WithItem(&'a ast::WithItem),
 }
 
+impl<'a> From<&'a ast::StmtAssign> for CurrentAssignment<'a> {
+    fn from(value: &'a ast::StmtAssign) -> Self {
+        Self::Assign(value)
+    }
+}
+
 impl<'a> From<&'a ast::StmtAnnAssign> for CurrentAssignment<'a> {
     fn from(value: &'a ast::StmtAnnAssign) -> Self {
         Self::AnnAssign(value)

crates/red_knot_python_semantic/src/semantic_index/builder/except_handlers.rs

@@ -1,102 +0,0 @@
-use crate::semantic_index::use_def::FlowSnapshot;
-
-use super::SemanticIndexBuilder;
-
-/// An abstraction over the fact that each scope should have its own [`TryNodeContextStack`]
-#[derive(Debug, Default)]
-pub(super) struct TryNodeContextStackManager(Vec<TryNodeContextStack>);
-
-impl TryNodeContextStackManager {
-    /// Push a new [`TryNodeContextStack`] onto the stack of stacks.
-    ///
-    /// Each [`TryNodeContextStack`] is only valid for a single scope
-    pub(super) fn enter_nested_scope(&mut self) {
-        self.0.push(TryNodeContextStack::default());
-    }
-
-    /// Pop a new [`TryNodeContextStack`] off the stack of stacks.
-    ///
-    /// Each [`TryNodeContextStack`] is only valid for a single scope
-    pub(super) fn exit_scope(&mut self) {
-        let popped_context = self.0.pop();
-        debug_assert!(
-            popped_context.is_some(),
-            "exit_scope() should never be called on an empty stack \
-(this indicates an unbalanced `enter_nested_scope()`/`exit_scope()` pair of calls)"
-        );
-    }
-
-    /// Push a [`TryNodeContext`] onto the [`TryNodeContextStack`]
-    /// at the top of our stack of stacks
-    pub(super) fn push_context(&mut self) {
-        self.current_try_context_stack().push_context();
-    }
-
-    /// Pop a [`TryNodeContext`] off the [`TryNodeContextStack`]
-    /// at the top of our stack of stacks. Return the Vec of [`FlowSnapshot`]s
-    /// recorded while we were visiting the `try` suite.
-    pub(super) fn pop_context(&mut self) -> Vec<FlowSnapshot> {
-        self.current_try_context_stack().pop_context()
-    }
-
-    /// Retrieve the stack that is at the top of our stack of stacks.
-    /// For each `try` block on that stack, push the snapshot onto the `try` block
-    pub(super) fn record_definition(&mut self, builder: &SemanticIndexBuilder) {
-        self.current_try_context_stack().record_definition(builder);
-    }
-
-    /// Retrieve the [`TryNodeContextStack`] that is relevant for the current scope.
-    fn current_try_context_stack(&mut self) -> &mut TryNodeContextStack {
-        self.0
-            .last_mut()
-            .expect("There should always be at least one `TryBlockContexts` on the stack")
-    }
-}
-
-/// The contexts of nested `try`/`except` blocks for a single scope
-#[derive(Debug, Default)]
-struct TryNodeContextStack(Vec<TryNodeContext>);
-
-impl TryNodeContextStack {
-    /// Push a new [`TryNodeContext`] for recording intermediate states
-    /// while visiting a [`ruff_python_ast::StmtTry`] node that has a `finally` branch.
-    fn push_context(&mut self) {
-        self.0.push(TryNodeContext::default());
-    }
-
-    /// Pop a [`TryNodeContext`] off the stack. Return the Vec of [`FlowSnapshot`]s
-    /// recorded while we were visiting the `try` suite.
-    fn pop_context(&mut self) -> Vec<FlowSnapshot> {
-        let TryNodeContext {
-            try_suite_snapshots,
-        } = self
-            .0
-            .pop()
-            .expect("Cannot pop a `try` block off an empty `TryBlockContexts` stack");
-        try_suite_snapshots
-    }
-
-    /// For each `try` block on the stack, push the snapshot onto the `try` block
-    fn record_definition(&mut self, builder: &SemanticIndexBuilder) {
-        for context in &mut self.0 {
-            context.record_definition(builder.flow_snapshot());
-        }
-    }
-}
-
-/// Context for tracking definitions over the course of a single
-/// [`ruff_python_ast::StmtTry`] node
-///
-/// It will likely be necessary to add more fields to this struct in the future
-/// when we add more advanced handling of `finally` branches.
-#[derive(Debug, Default)]
-struct TryNodeContext {
-    try_suite_snapshots: Vec<FlowSnapshot>,
-}
-
-impl TryNodeContext {
-    /// Take a record of what the internal state looked like after a definition
-    fn record_definition(&mut self, snapshot: FlowSnapshot) {
-        self.try_suite_snapshots.push(snapshot);
-    }
-}

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -3,7 +3,6 @@ use ruff_db::parsed::ParsedModule;
 use ruff_python_ast as ast;
 
 use crate::ast_node_ref::AstNodeRef;
-use crate::module_resolver::file_to_module;
 use crate::node_key::NodeKey;
 use crate::semantic_index::symbol::{FileScopeId, ScopeId, ScopedSymbolId};
 use crate::Db;
@@ -34,26 +33,6 @@ impl<'db> Definition<'db> {
     pub(crate) fn scope(self, db: &'db dyn Db) -> ScopeId<'db> {
         self.file_scope(db).to_scope_id(db, self.file(db))
     }
-
-    pub(crate) fn category(self, db: &'db dyn Db) -> DefinitionCategory {
-        self.kind(db).category()
-    }
-
-    pub(crate) fn is_declaration(self, db: &'db dyn Db) -> bool {
-        self.kind(db).category().is_declaration()
-    }
-
-    pub(crate) fn is_binding(self, db: &'db dyn Db) -> bool {
-        self.kind(db).category().is_binding()
-    }
-
-    /// Return true if this is a symbol was defined in the `typing` or `typing_extensions` modules
-    pub(crate) fn is_typing_definition(self, db: &'db dyn Db) -> bool {
-        file_to_module(db, self.file(db)).is_some_and(|module| {
-            module.search_path().is_standard_library()
-                && matches!(&**module.name(), "typing" | "typing_extensions")
-        })
-    }
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -161,9 +140,7 @@ pub(crate) struct ImportFromDefinitionNodeRef<'a> {
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct AssignmentDefinitionNodeRef<'a> {
     pub(crate) assignment: &'a ast::StmtAssign,
-    pub(crate) target_index: usize,
-    pub(crate) name: &'a ast::ExprName,
-    pub(crate) kind: AssignmentKind,
+    pub(crate) target: &'a ast::ExprName,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -226,17 +203,12 @@ impl DefinitionNodeRef<'_> {
             DefinitionNodeRef::NamedExpression(named) => {
                 DefinitionKind::NamedExpression(AstNodeRef::new(parsed, named))
             }
-            DefinitionNodeRef::Assignment(AssignmentDefinitionNodeRef {
-                assignment,
-                target_index,
-                name,
-                kind,
-            }) => DefinitionKind::Assignment(AssignmentDefinitionKind {
-                assignment: AstNodeRef::new(parsed.clone(), assignment),
-                target_index,
-                name: AstNodeRef::new(parsed, name),
-                kind,
-            }),
+            DefinitionNodeRef::Assignment(AssignmentDefinitionNodeRef { assignment, target }) => {
+                DefinitionKind::Assignment(AssignmentDefinitionKind {
+                    assignment: AstNodeRef::new(parsed.clone(), assignment),
+                    target: AstNodeRef::new(parsed, target),
+                })
+            }
             DefinitionNodeRef::AnnotatedAssignment(assign) => {
                 DefinitionKind::AnnotatedAssignment(AstNodeRef::new(parsed, assign))
             }
@@ -307,10 +279,8 @@ impl DefinitionNodeRef<'_> {
             Self::NamedExpression(node) => node.into(),
             Self::Assignment(AssignmentDefinitionNodeRef {
                 assignment: _,
-                target_index: _,
-                name,
-                kind: _,
-            }) => name.into(),
+                target,
+            }) => target.into(),
             Self::AnnotatedAssignment(node) => node.into(),
             Self::AugmentedAssignment(node) => node.into(),
             Self::For(ForStmtDefinitionNodeRef {
@@ -332,41 +302,6 @@ impl DefinitionNodeRef<'_> {
     }
 }
 
-#[derive(Clone, Copy, Debug)]
-pub(crate) enum DefinitionCategory {
-    /// A Definition which binds a value to a name (e.g. `x = 1`).
-    Binding,
-    /// A Definition which declares the upper-bound of acceptable types for this name (`x: int`).
-    Declaration,
-    /// A Definition which both declares a type and binds a value (e.g. `x: int = 1`).
-    DeclarationAndBinding,
-}
-
-impl DefinitionCategory {
-    /// True if this definition establishes a "declared type" for the symbol.
-    ///
-    /// If so, any assignments reached by this definition are in error if they assign a value of a
-    /// type not assignable to the declared type.
-    ///
-    /// Annotations establish a declared type. So do function and class definitions, and imports.
-    pub(crate) fn is_declaration(self) -> bool {
-        matches!(
-            self,
-            DefinitionCategory::Declaration | DefinitionCategory::DeclarationAndBinding
-        )
-    }
-
-    /// True if this definition assigns a value to the symbol.
-    ///
-    /// False only for annotated assignments without a RHS.
-    pub(crate) fn is_binding(self) -> bool {
-        matches!(
-            self,
-            DefinitionCategory::Binding | DefinitionCategory::DeclarationAndBinding
-        )
-    }
-}
-
 #[derive(Clone, Debug)]
 pub enum DefinitionKind {
     Import(AstNodeRef<ast::Alias>),
@@ -387,46 +322,33 @@ pub enum DefinitionKind {
 }
 
 impl DefinitionKind {
-    pub(crate) fn category(&self) -> DefinitionCategory {
+    /// True if this definition establishes a "declared type" for the symbol.
+    ///
+    /// If so, any assignments reached by this definition are in error if they assign a value of a
+    /// type not assignable to the declared type.
+    ///
+    /// Annotations establish a declared type. So do function and class definition.
+    pub(crate) fn is_declaration(&self) -> bool {
         match self {
-            // functions, classes, and imports always bind, and we consider them declarations
-            DefinitionKind::Function(_)
-            | DefinitionKind::Class(_)
-            | DefinitionKind::Import(_)
-            | DefinitionKind::ImportFrom(_) => DefinitionCategory::DeclarationAndBinding,
-            // a parameter always binds a value, but is only a declaration if annotated
-            DefinitionKind::Parameter(parameter) => {
-                if parameter.annotation.is_some() {
-                    DefinitionCategory::DeclarationAndBinding
-                } else {
-                    DefinitionCategory::Binding
-                }
-            }
-            // presence of a default is irrelevant, same logic as for a no-default parameter
+            DefinitionKind::Function(_) => true,
+            DefinitionKind::Class(_) => true,
+            DefinitionKind::Parameter(parameter) => parameter.annotation.is_some(),
             DefinitionKind::ParameterWithDefault(parameter_with_default) => {
-                if parameter_with_default.parameter.annotation.is_some() {
-                    DefinitionCategory::DeclarationAndBinding
-                } else {
-                    DefinitionCategory::Binding
-                }
+                parameter_with_default.parameter.annotation.is_some()
             }
-            // annotated assignment is always a declaration, only a binding if there is a RHS
-            DefinitionKind::AnnotatedAssignment(ann_assign) => {
-                if ann_assign.value.is_some() {
-                    DefinitionCategory::DeclarationAndBinding
-                } else {
-                    DefinitionCategory::Declaration
-                }
-            }
-            // all of these bind values without declaring a type
-            DefinitionKind::NamedExpression(_)
-            | DefinitionKind::Assignment(_)
-            | DefinitionKind::AugmentedAssignment(_)
-            | DefinitionKind::For(_)
-            | DefinitionKind::Comprehension(_)
-            | DefinitionKind::WithItem(_)
-            | DefinitionKind::MatchPattern(_)
-            | DefinitionKind::ExceptHandler(_) => DefinitionCategory::Binding,
+            DefinitionKind::AnnotatedAssignment(_) => true,
+            _ => false,
+        }
+    }
+
+    /// True if this definition assigns a value to the symbol.
+    ///
+    /// False only for annotated assignments without a RHS.
+    pub(crate) fn is_binding(&self) -> bool {
+        if let DefinitionKind::AnnotatedAssignment(ann_assign) = self {
+            ann_assign.value.is_some()
+        } else {
+            true
         }
     }
 }
@@ -494,34 +416,17 @@ impl ImportFromDefinitionKind {
 #[derive(Clone, Debug)]
 pub struct AssignmentDefinitionKind {
     assignment: AstNodeRef<ast::StmtAssign>,
-    target_index: usize,
-    name: AstNodeRef<ast::ExprName>,
-    kind: AssignmentKind,
+    target: AstNodeRef<ast::ExprName>,
 }
 
 impl AssignmentDefinitionKind {
-    pub(crate) fn value(&self) -> &ast::Expr {
-        &self.assignment.node().value
+    pub(crate) fn assignment(&self) -> &ast::StmtAssign {
+        self.assignment.node()
     }
 
-    pub(crate) fn target(&self) -> &ast::Expr {
-        &self.assignment.node().targets[self.target_index]
+    pub(crate) fn target(&self) -> &ast::ExprName {
+        self.target.node()
     }
-
-    pub(crate) fn name(&self) -> &ast::ExprName {
-        self.name.node()
-    }
-
-    pub(crate) fn kind(&self) -> AssignmentKind {
-        self.kind
-    }
-}
-
-/// The kind of assignment target expression.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum AssignmentKind {
-    Sequence,
-    Name,
 }
 
 #[derive(Clone, Debug)]

crates/red_knot_python_semantic/src/semantic_index/symbol.rs

@@ -51,7 +51,7 @@ impl Symbol {
 
 bitflags! {
     #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-    struct SymbolFlags: u8 {
+    pub(super) struct SymbolFlags: u8 {
         const IS_USED         = 1 << 0;
         const IS_BOUND      = 1 << 1;
         /// TODO: This flag is not yet set by anything

crates/red_knot_python_semantic/src/semantic_index/use_def.rs

@@ -1,6 +1,6 @@
 //! First, some terminology:
 //!
-//! * A "binding" gives a new value to a variable. This includes many different Python statements
+//! * a "binding" gives a new value to a variable. This includes many different Python statements
 //!   (assignment statements of course, but also imports, `def` and `class` statements, `as`
 //!   clauses in `with` and `except` statements, match patterns, and others) and even one
 //!   expression kind (named expressions). It notably does not include annotated assignment
@@ -8,7 +8,7 @@
 //!   variable. We consider function parameters to be bindings as well, since (from the perspective
 //!   of the function's internal scope), a function parameter begins the scope bound to a value.
 //!
-//! * A "declaration" establishes an upper bound type for the values that a variable may be
+//! * a "declaration" establishes an upper bound type for the values that a variable may be
 //!   permitted to take on. Annotated assignment statements (with or without an RHS value) are
 //!   declarations; annotated function parameters are also declarations. We consider `def` and
 //!   `class` statements to also be declarations, so as to prohibit accidentally shadowing them.
@@ -23,15 +23,12 @@
 //!
 //! At any given use of a variable, we can ask about both its "declared type" and its "inferred
 //! type". These may be different, but the inferred type must always be assignable to the declared
-//! type; that is, the declared type is always wider, and the inferred type may be more precise. If
-//! we see an invalid assignment, we emit a diagnostic and abandon our inferred type, deferring to
-//! the declared type (this allows an explicit annotation to override bad inference, without a
-//! cast), maintaining the invariant.
+//! type; that is, the declared type is always wider, and the inferred type may be more precise.
 //!
 //! The **inferred type** represents the most precise type we believe encompasses all possible
-//! values for the variable at a given use. It is based on a union of the bindings which can reach
-//! that use through some control flow path, and the narrowing constraints that control flow must
-//! have passed through between the binding and the use. For example, in this code:
+//! values for the variable at a given use. It is based on the bindings which can reach that use
+//! through some control flow path, and the narrowing constraints that control flow must have
+//! passed through between the binding and the use. For example, in this code:
 //!
 //! ```python
 //! x = 1 if flag else None
@@ -67,13 +64,12 @@
 //! Path(path)`, with the explicit `: Path` annotation, is permitted.
 //!
 //! The general rule is that whatever declaration(s) can reach a given binding determine the
-//! validity of that binding. If there is a path in which the symbol is not declared, that is a
-//! declaration of `Unknown`. If multiple declarations can reach a binding, we union them, but by
-//! default we also issue a type error, since this implicit union of declared types may hide an
-//! error.
+//! validity of that binding. If multiple declarations can reach a binding, they must be
+//! equivalent declarations, or we issue a type error, since we can't reconcile to a single
+//! declared type.
 //!
 //! To support type inference, we build a map from each use of a symbol to the bindings live at
-//! that use, and the type narrowing constraints that apply to each binding.
+//! that use, and the type-narrowing constraints that apply to each binding.
 //!
 //! Let's take this code sample:
 //!
@@ -108,7 +104,7 @@
 //! all uses (that means a `Name` node with `Load` context) so we have a `ScopedUseId` to
 //! efficiently represent each use.
 //!
-//! We also need to know, for a given definition of a symbol, what type narrowing constraints apply
+//! We also need to know, for a given definition of a symbol, what type-narrowing constraints apply
 //! to it. For instance, in this code sample:
 //!
 //! ```python
@@ -146,7 +142,7 @@
 //! via a global or nonlocal reference.) But modeling this fully accurately requires whole-program
 //! analysis that isn't tractable for an efficient analysis, since it means a given symbol could
 //! have a different type every place it's referenced throughout the program, depending on the
-//! shape of arbitrarily-sized call/import graphs. So we follow other Python type checkers in
+//! shape of arbitrarily-sized call/import graphs. So we follow other Python type-checkers in
 //! making the simplifying assumption that usually the scope will finish execution before its
 //! symbols are made visible to other scopes; for instance, most imports will import from a
 //! complete module, not a partially-executed module. (We may want to get a little smarter than
@@ -173,7 +169,7 @@
 //!
 //! The simplest way to model "unbound" would be as a "binding" itself: the initial "binding" for
 //! each symbol in a scope. But actually modeling it this way would unnecessarily increase the
-//! number of [`Definition`]s that Salsa must track. Since "unbound" is special in that all symbols
+//! number of [`Definition`] that Salsa must track. Since "unbound" is special in that all symbols
 //! share it, and it doesn't have any additional per-symbol state, and constraints are irrelevant
 //! to it, we can represent it more efficiently: we use the `may_be_unbound` boolean on the
 //! [`SymbolBindings`] struct. If this flag is `true` for a use of a symbol, it means the symbol
@@ -318,8 +314,7 @@ impl<'db> UseDefMap<'db> {
         &self,
         symbol: ScopedSymbolId,
     ) -> DeclarationsIterator<'_, 'db> {
-        let declarations = self.public_symbols[symbol].declarations();
-        self.declarations_iterator(declarations)
+        self.declarations_iterator(self.public_symbols[symbol].declarations())
     }
 
     pub(crate) fn has_public_declarations(&self, symbol: ScopedSymbolId) -> bool {
@@ -344,7 +339,6 @@ impl<'db> UseDefMap<'db> {
         DeclarationsIterator {
             all_definitions: &self.all_definitions,
             inner: declarations.iter(),
-            may_be_undeclared: declarations.may_be_undeclared(),
         }
     }
 }
@@ -406,13 +400,6 @@ impl std::iter::FusedIterator for ConstraintsIterator<'_, '_> {}
 pub(crate) struct DeclarationsIterator<'map, 'db> {
     all_definitions: &'map IndexVec<ScopedDefinitionId, Definition<'db>>,
     inner: DeclarationIdIterator<'map>,
-    may_be_undeclared: bool,
-}
-
-impl DeclarationsIterator<'_, '_> {
-    pub(crate) fn may_be_undeclared(&self) -> bool {
-        self.may_be_undeclared
-    }
 }
 
 impl<'map, 'db> Iterator for DeclarationsIterator<'map, 'db> {
@@ -550,9 +537,8 @@ impl<'db> UseDefMapBuilder<'db> {
             if let Some(snapshot) = snapshot_definitions_iter.next() {
                 current.merge(snapshot);
             } else {
-                // Symbol not present in snapshot, so it's unbound/undeclared from that path.
+                // Symbol not present in snapshot, so it's unbound from that path.
                 current.set_may_be_unbound();
-                current.set_may_be_undeclared();
             }
         }
     }

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

@@ -105,8 +105,9 @@ impl<const B: usize> BitSet<B> {
             max_len = other_len;
             self.resize_blocks(max_len);
         }
-        for (my_block, other_block) in self.blocks_mut().iter_mut().zip(other.blocks()) {
-            *my_block |= other_block;
+        let other_blocks = other.blocks();
+        for (i, my_block) in self.blocks_mut().iter_mut().enumerate() {
+            *my_block |= other_blocks.get(i).unwrap_or(&0);
         }
     }
 

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

@@ -1,13 +1,13 @@
-//! Track live bindings per symbol, applicable constraints per binding, and live declarations.
+//! Track visible definitions of a symbol, and applicable constraints per definition.
 //!
 //! These data structures operate entirely on scope-local newtype-indices for definitions and
 //! constraints, referring to their location in the `all_definitions` and `all_constraints`
 //! indexvecs in [`super::UseDefMapBuilder`].
 //!
-//! We need to track arbitrary associations between bindings and constraints, not just a single set
-//! of currently dominating constraints (where "dominating" means "control flow must have passed
-//! through it to reach this point"), because we can have dominating constraints that apply to some
-//! bindings but not others, as in this code:
+//! We need to track arbitrary associations between definitions and constraints, not just a single
+//! set of currently dominating constraints (where "dominating" means "control flow must have
+//! passed through it to reach this point"), because we can have dominating constraints that apply
+//! to some definitions but not others, as in this code:
 //!
 //! ```python
 //! x = 1 if flag else None
@@ -18,11 +18,11 @@
 //! ```
 //!
 //! The `x is not None` constraint dominates the final use of `x`, but it applies only to the first
-//! binding of `x`, not the second, so `None` is a possible value for `x`.
+//! definition of `x`, not the second, so `None` is a possible value for `x`.
 //!
-//! And we can't just track, for each binding, an index into a list of dominating constraints,
-//! either, because we can have bindings which are still visible, but subject to constraints that
-//! are no longer dominating, as in this code:
+//! And we can't just track, for each definition, an index into a list of dominating constraints,
+//! either, because we can have definitions which are still visible, but subject to constraints
+//! that are no longer dominating, as in this code:
 //!
 //! ```python
 //! x = 0
@@ -33,16 +33,13 @@
 //! ```
 //!
 //! From the point of view of the final use of `x`, the `x is not None` constraint no longer
-//! dominates, but it does dominate the `x = 1 if flag2 else None` binding, so we have to keep
+//! dominates, but it does dominate the `x = 1 if flag2 else None` definition, so we have to keep
 //! track of that.
 //!
 //! The data structures used here ([`BitSet`] and [`smallvec::SmallVec`]) optimize for keeping all
 //! data inline (avoiding lots of scattered allocations) in small-to-medium cases, and falling back
-//! to heap allocation to be able to scale to arbitrary numbers of live bindings and constraints
-//! when needed.
-//!
-//! Tracking live declarations is simpler, since constraints are not involved, but otherwise very
-//! similar to tracking live bindings.
+//! to heap allocation to be able to scale to arbitrary numbers of definitions and constraints when
+//! needed.
 use super::bitset::{BitSet, BitSetIterator};
 use ruff_index::newtype_index;
 use smallvec::SmallVec;
@@ -86,28 +83,18 @@ type ConstraintsIntoIterator = smallvec::IntoIter<InlineConstraintArray>;
 pub(super) struct SymbolDeclarations {
     /// [`BitSet`]: which declarations (as [`ScopedDefinitionId`]) can reach the current location?
     live_declarations: Declarations,
-
-    /// Could the symbol be un-declared at this point?
-    may_be_undeclared: bool,
 }
 
 impl SymbolDeclarations {
     fn undeclared() -> Self {
         Self {
             live_declarations: Declarations::default(),
-            may_be_undeclared: true,
         }
     }
 
     /// Record a newly-encountered declaration for this symbol.
     fn record_declaration(&mut self, declaration_id: ScopedDefinitionId) {
         self.live_declarations = Declarations::with(declaration_id.into());
-        self.may_be_undeclared = false;
-    }
-
-    /// Add undeclared as a possibility for this symbol.
-    fn set_may_be_undeclared(&mut self) {
-        self.may_be_undeclared = true;
     }
 
     /// Return an iterator over live declarations for this symbol.
@@ -120,10 +107,6 @@ impl SymbolDeclarations {
     pub(super) fn is_empty(&self) -> bool {
         self.live_declarations.is_empty()
     }
-
-    pub(super) fn may_be_undeclared(&self) -> bool {
-        self.may_be_undeclared
-    }
 }
 
 /// Live bindings and narrowing constraints for a single symbol at some point in control flow.
@@ -161,8 +144,9 @@ impl SymbolBindings {
         // The new binding replaces all previous live bindings in this path, and has no
         // constraints.
         self.live_bindings = Bindings::with(binding_id.into());
-        self.constraints = Constraints::with_capacity(1);
-        self.constraints.push(BitSet::default());
+        let mut constraints = Constraints::with_capacity(1);
+        constraints.push(BitSet::default());
+        self.constraints = constraints;
         self.may_be_unbound = false;
     }
 
@@ -216,11 +200,6 @@ impl SymbolState {
         self.bindings.record_constraint(constraint_id);
     }
 
-    /// Add undeclared as a possibility for this symbol.
-    pub(super) fn set_may_be_undeclared(&mut self) {
-        self.declarations.set_may_be_undeclared();
-    }
-
     /// Record a newly-encountered declaration of this symbol.
     pub(super) fn record_declaration(&mut self, declaration_id: ScopedDefinitionId) {
         self.declarations.record_declaration(declaration_id);
@@ -234,11 +213,7 @@ impl SymbolState {
                 constraints: Constraints::default(),
                 may_be_unbound: self.bindings.may_be_unbound || b.bindings.may_be_unbound,
             },
-            declarations: SymbolDeclarations {
-                live_declarations: self.declarations.live_declarations.clone(),
-                may_be_undeclared: self.declarations.may_be_undeclared
-                    || b.declarations.may_be_undeclared,
-            },
+            declarations: self.declarations.clone(),
         };
 
         std::mem::swap(&mut a, self);
@@ -409,52 +384,47 @@ impl<'a> Iterator for DeclarationIdIterator<'a> {
     }
 }
 
-impl std::iter::FusedIterator for DeclarationIdIterator<'_> {}
-
 #[cfg(test)]
 mod tests {
     use super::{ScopedConstraintId, ScopedDefinitionId, SymbolState};
 
-    fn assert_bindings(symbol: &SymbolState, may_be_unbound: bool, expected: &[&str]) {
-        assert_eq!(symbol.may_be_unbound(), may_be_unbound);
-        let actual = symbol
-            .bindings()
-            .iter()
-            .map(|def_id_with_constraints| {
-                format!(
-                    "{}<{}>",
-                    def_id_with_constraints.definition.as_u32(),
-                    def_id_with_constraints
-                        .constraint_ids
-                        .map(ScopedConstraintId::as_u32)
-                        .map(|idx| idx.to_string())
-                        .collect::<Vec<_>>()
-                        .join(", ")
-                )
-            })
-            .collect::<Vec<_>>();
-        assert_eq!(actual, expected);
-    }
+    impl SymbolState {
+        pub(crate) fn assert_bindings(&self, may_be_unbound: bool, expected: &[&str]) {
+            assert_eq!(self.may_be_unbound(), may_be_unbound);
+            let actual = self
+                .bindings()
+                .iter()
+                .map(|def_id_with_constraints| {
+                    format!(
+                        "{}<{}>",
+                        def_id_with_constraints.definition.as_u32(),
+                        def_id_with_constraints
+                            .constraint_ids
+                            .map(ScopedConstraintId::as_u32)
+                            .map(|idx| idx.to_string())
+                            .collect::<Vec<_>>()
+                            .join(", ")
+                    )
+                })
+                .collect::<Vec<_>>();
+            assert_eq!(actual, expected);
+        }
 
-    pub(crate) fn assert_declarations(
-        symbol: &SymbolState,
-        may_be_undeclared: bool,
-        expected: &[u32],
-    ) {
-        assert_eq!(symbol.declarations.may_be_undeclared(), may_be_undeclared);
-        let actual = symbol
-            .declarations()
-            .iter()
-            .map(ScopedDefinitionId::as_u32)
-            .collect::<Vec<_>>();
-        assert_eq!(actual, expected);
+        pub(crate) fn assert_declarations(&self, expected: &[u32]) {
+            let actual = self
+                .declarations()
+                .iter()
+                .map(ScopedDefinitionId::as_u32)
+                .collect::<Vec<_>>();
+            assert_eq!(actual, expected);
+        }
     }
 
     #[test]
     fn unbound() {
         let sym = SymbolState::undefined();
 
-        assert_bindings(&sym, true, &[]);
+        sym.assert_bindings(true, &[]);
     }
 
     #[test]
@@ -462,7 +432,7 @@ mod tests {
         let mut sym = SymbolState::undefined();
         sym.record_binding(ScopedDefinitionId::from_u32(0));
 
-        assert_bindings(&sym, false, &["0<>"]);
+        sym.assert_bindings(false, &["0<>"]);
     }
 
     #[test]
@@ -471,7 +441,7 @@ mod tests {
         sym.record_binding(ScopedDefinitionId::from_u32(0));
         sym.set_may_be_unbound();
 
-        assert_bindings(&sym, true, &["0<>"]);
+        sym.assert_bindings(true, &["0<>"]);
     }
 
     #[test]
@@ -480,7 +450,7 @@ mod tests {
         sym.record_binding(ScopedDefinitionId::from_u32(0));
         sym.record_constraint(ScopedConstraintId::from_u32(0));
 
-        assert_bindings(&sym, false, &["0<0>"]);
+        sym.assert_bindings(false, &["0<0>"]);
     }
 
     #[test]
@@ -496,7 +466,7 @@ mod tests {
 
         sym0a.merge(sym0b);
         let mut sym0 = sym0a;
-        assert_bindings(&sym0, false, &["0<0>"]);
+        sym0.assert_bindings(false, &["0<0>"]);
 
         // merging the same definition with differing constraints drops all constraints
         let mut sym1a = SymbolState::undefined();
@@ -509,7 +479,7 @@ mod tests {
 
         sym1a.merge(sym1b);
         let sym1 = sym1a;
-        assert_bindings(&sym1, false, &["1<>"]);
+        sym1.assert_bindings(false, &["1<>"]);
 
         // merging a constrained definition with unbound keeps both
         let mut sym2a = SymbolState::undefined();
@@ -520,19 +490,12 @@ mod tests {
 
         sym2a.merge(sym2b);
         let sym2 = sym2a;
-        assert_bindings(&sym2, true, &["2<3>"]);
+        sym2.assert_bindings(true, &["2<3>"]);
 
         // merging different definitions keeps them each with their existing constraints
         sym0.merge(sym2);
         let sym = sym0;
-        assert_bindings(&sym, true, &["0<0>", "2<3>"]);
-    }
-
-    #[test]
-    fn no_declaration() {
-        let sym = SymbolState::undefined();
-
-        assert_declarations(&sym, true, &[]);
+        sym.assert_bindings(true, &["0<0>", "2<3>"]);
     }
 
     #[test]
@@ -540,7 +503,7 @@ mod tests {
         let mut sym = SymbolState::undefined();
         sym.record_declaration(ScopedDefinitionId::from_u32(1));
 
-        assert_declarations(&sym, false, &[1]);
+        sym.assert_declarations(&[1]);
     }
 
     #[test]
@@ -549,7 +512,7 @@ mod tests {
         sym.record_declaration(ScopedDefinitionId::from_u32(1));
         sym.record_declaration(ScopedDefinitionId::from_u32(2));
 
-        assert_declarations(&sym, false, &[2]);
+        sym.assert_declarations(&[2]);
     }
 
     #[test]
@@ -562,27 +525,6 @@ mod tests {
 
         sym.merge(sym2);
 
-        assert_declarations(&sym, false, &[1, 2]);
-    }
-
-    #[test]
-    fn record_declaration_merge_partial_undeclared() {
-        let mut sym = SymbolState::undefined();
-        sym.record_declaration(ScopedDefinitionId::from_u32(1));
-
-        let sym2 = SymbolState::undefined();
-
-        sym.merge(sym2);
-
-        assert_declarations(&sym, true, &[1]);
-    }
-
-    #[test]
-    fn set_may_be_undeclared() {
-        let mut sym = SymbolState::undefined();
-        sym.record_declaration(ScopedDefinitionId::from_u32(0));
-        sym.set_may_be_undeclared();
-
-        assert_declarations(&sym, true, &[0]);
+        sym.assert_declarations(&[1, 2]);
     }
 }

crates/red_knot_python_semantic/src/semantic_model.rs

@@ -35,7 +35,7 @@ impl<'db> SemanticModel<'db> {
         line_index(self.db.upcast(), self.file)
     }
 
-    pub fn resolve_module(&self, module_name: &ModuleName) -> Option<Module> {
+    pub fn resolve_module(&self, module_name: ModuleName) -> Option<Module> {
         resolve_module(self.db, module_name)
     }
 

crates/red_knot_python_semantic/src/site_packages.rs

@@ -192,7 +192,7 @@ impl VirtualEnvironment {
             } else {
                 tracing::warn!(
                     "Failed to resolve `sys.prefix` of the system Python installation \
-from the `home` value in the `pyvenv.cfg` file at `{}`. \
+from the `home` value in the `pyvenv.cfg` file at '{}'. \
 System site-packages will not be used for module resolution.",
                     venv_path.join("pyvenv.cfg")
                 );
@@ -426,7 +426,7 @@ impl Deref for SysPrefixPath {
 
 impl fmt::Display for SysPrefixPath {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "`sys.prefix` path `{}`", self.0)
+        write!(f, "`sys.prefix` path '{}'", self.0)
     }
 }
 
@@ -483,7 +483,7 @@ impl Deref for PythonHomePath {
 
 impl fmt::Display for PythonHomePath {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "`home` location `{}`", self.0)
+        write!(f, "`home` location '{}'", self.0)
     }
 }
 

crates/red_knot_python_semantic/src/stdlib.rs

@@ -11,7 +11,6 @@ enum CoreStdlibModule {
     Builtins,
     Types,
     Typeshed,
-    TypingExtensions,
 }
 
 impl CoreStdlibModule {
@@ -20,7 +19,6 @@ impl CoreStdlibModule {
             Self::Builtins => "builtins",
             Self::Types => "types",
             Self::Typeshed => "_typeshed",
-            Self::TypingExtensions => "typing_extensions",
         };
         ModuleName::new_static(module_name)
             .unwrap_or_else(|| panic!("{module_name} should be a valid module name!"))
@@ -35,15 +33,8 @@ fn core_module_symbol_ty<'db>(
     core_module: CoreStdlibModule,
     symbol: &str,
 ) -> Type<'db> {
-    resolve_module(db, &core_module.name())
+    resolve_module(db, core_module.name())
         .map(|module| global_symbol_ty(db, module.file(), symbol))
-        .map(|ty| {
-            if ty.is_unbound() {
-                ty
-            } else {
-                ty.replace_unbound_with(db, Type::Never)
-            }
-        })
         .unwrap_or(Type::Unbound)
 }
 
@@ -71,19 +62,11 @@ pub(crate) fn typeshed_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db
     core_module_symbol_ty(db, CoreStdlibModule::Typeshed, symbol)
 }
 
-/// Lookup the type of `symbol` in the `typing_extensions` module namespace.
-///
-/// Returns `Unbound` if the `typing_extensions` module isn't available for some reason.
-#[inline]
-pub(crate) fn typing_extensions_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::TypingExtensions, symbol)
-}
-
 /// Get the scope of a core stdlib module.
 ///
 /// Can return `None` if a custom typeshed is used that is missing the core module in question.
 fn core_module_scope(db: &dyn Db, core_module: CoreStdlibModule) -> Option<ScopeId<'_>> {
-    resolve_module(db, &core_module.name()).map(|module| global_scope(db, module.file()))
+    resolve_module(db, core_module.name()).map(|module| global_scope(db, module.file()))
 }
 
 /// Get the `builtins` module scope.