macos 14 runner, no deployment target

Co-authored-by: Micha Reiser <micha@reiser.io>

.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 ruff_db --document-private-items
+      - run: cargo doc --no-deps -p red_knot_python_semantic -p red_knot -p red_knot_test -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,6 +518,8 @@ 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
@@ -525,13 +527,15 @@ 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: pip install -r docs/requirements-insiders.txt
+        run: uv pip install -r docs/requirements-insiders.txt --system
       - name: "Install dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
-        run: pip install -r docs/requirements.txt
+        run: uv pip install -r docs/requirements.txt --system
       - name: "Update README File"
         run: python scripts/transform_readme.py --target mkdocs
       - name: "Generate docs"
@@ -608,7 +612,7 @@ jobs:
           just test
 
   benchmarks:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     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

@@ -0,0 +1,76 @@
+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/publish-docs.yml

@@ -34,10 +34,10 @@ jobs:
       - name: "Set docs version"
         run: |
           version="${{ (inputs.plan != '' && fromJson(inputs.plan).announcement_tag) || inputs.ref }}"
-          # if version is missing, exit with error
-          if [[ -z "$version" ]]; then
-          echo "Can't build docs without a version."
-          exit 1
+          # if version is missing, use 'latest'
+          if [ -z "$version" ]; then
+            echo "Using 'latest' as version"
+            version="latest"
           fi
 
           # Use version as display name for now
@@ -145,6 +145,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.ASTRAL_DOCS_PAT }}
         run: |
           branch_name="${{ env.branch_name }}"
+
           # auto-merge the PR if the build was triggered by a release. Manual builds should be reviewed by a human.
           # give the PR a few seconds to be created before trying to auto-merge it
           sleep 10

.github/workflows/release.yml

@@ -1,3 +1,5 @@
+# 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
 #
@@ -64,7 +66,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.18.0/cargo-dist-installer.sh | sh"
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.22.1/cargo-dist-installer.sh | sh"
       - name: Cache cargo-dist
         uses: actions/upload-artifact@v4
         with:

.github/workflows/sync_typeshed.yaml

@@ -37,13 +37,13 @@ jobs:
       - name: Sync typeshed
         id: sync
         run: |
-          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
+          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
       - 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_python_semantic/vendor/.*|
+    crates/red_knot_vendored/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.19
+    rev: v0.20.2
     hooks:
       - id: validate-pyproject
 
@@ -28,6 +28,7 @@ repos:
         additional_dependencies:
           - mdformat-mkdocs
           - mdformat-admon
+          - mdformat-footnote
         exclude: |
           (?x)^(
             docs/formatter/black\.md
@@ -35,7 +36,7 @@ repos:
           )$
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.41.0
+    rev: v0.42.0
     hooks:
       - id: markdownlint-fix
         exclude: |
@@ -45,7 +46,7 @@ repos:
           )$
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.24.1
+    rev: v1.25.0
     hooks:
       - id: typos
 
@@ -59,7 +60,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.2
+    rev: v0.6.9
     hooks:
       - id: ruff-format
       - id: ruff
@@ -68,8 +69,8 @@ repos:
         require_serial: true
 
   # Prettier
-  - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v3.1.0
+  - repo: https://github.com/rbubley/mirrors-prettier
+    rev: v3.3.3
     hooks:
       - id: prettier
         types: [yaml]

CHANGELOG.md

@@ -1,5 +1,164 @@
 # 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
+
+- \[`flake8-builtins`\] Use dynamic builtins list based on Python version ([#13172](https://github.com/astral-sh/ruff/pull/13172))
+- \[`pydoclint`\] Permit yielding `None` in `DOC402` and `DOC403` ([#13148](https://github.com/astral-sh/ruff/pull/13148))
+- \[`pylint`\] Update diagnostic message for `PLW3201` ([#13194](https://github.com/astral-sh/ruff/pull/13194))
+- \[`ruff`\] Implement `post-init-default` (`RUF033`) ([#13192](https://github.com/astral-sh/ruff/pull/13192))
+- \[`ruff`\] Implement useless if-else (`RUF034`) ([#13218](https://github.com/astral-sh/ruff/pull/13218))
+
+### Rule changes
+
+- \[`flake8-pyi`\] Respect `pep8_naming.classmethod-decorators` settings when determining if a method is a classmethod in `custom-type-var-return-type` (`PYI019`) ([#13162](https://github.com/astral-sh/ruff/pull/13162))
+- \[`flake8-pyi`\] Teach various rules that annotations might be stringized ([#12951](https://github.com/astral-sh/ruff/pull/12951))
+- \[`pylint`\] Avoid `no-self-use` for `attrs`-style validators ([#13166](https://github.com/astral-sh/ruff/pull/13166))
+- \[`pylint`\] Recurse into subscript subexpressions when searching for list/dict lookups (`PLR1733`, `PLR1736`) ([#13186](https://github.com/astral-sh/ruff/pull/13186))
+- \[`pyupgrade`\] Detect `aiofiles.open` calls in `UP015` ([#13173](https://github.com/astral-sh/ruff/pull/13173))
+- \[`pyupgrade`\] Mark `sys.version_info[0] < 3` and similar comparisons as outdated (`UP036`) ([#13175](https://github.com/astral-sh/ruff/pull/13175))
+
+### CLI
+
+- Enrich messages of SARIF results ([#13180](https://github.com/astral-sh/ruff/pull/13180))
+- Handle singular case for incompatible rules warning in `ruff format` output ([#13212](https://github.com/astral-sh/ruff/pull/13212))
+
+### Bug fixes
+
+- \[`pydocstyle`\] Improve heuristics for detecting Google-style docstrings ([#13142](https://github.com/astral-sh/ruff/pull/13142))
+- \[`refurb`\] Treat `sep` arguments with effects as unsafe removals (`FURB105`) ([#13165](https://github.com/astral-sh/ruff/pull/13165))
+
 ## 0.6.3
 
 ### Preview features

CONTRIBUTING.md

@@ -29,16 +29,14 @@ You'll also need [Insta](https://insta.rs/docs/) to update snapshot tests:
 cargo install cargo-insta
 ```
 
-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'll need [uv](https://docs.astral.sh/uv/getting-started/installation/) (or `pipx` and `pip`) to
+run Python utility commands.
 
 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
 ```
 
@@ -66,7 +64,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
-pre-commit run --all-files --show-diff-on-failure  # Rust and Python formatting, Markdown and Python linting, etc.
+uvx 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
@@ -267,26 +265,20 @@ 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
-    python scripts/generate_mkdocs.py
+    uv run --no-project --isolated --with-requirements docs/requirements.txt scripts/generate_mkdocs.py
     ```
 
 1. Run the development server with:
 
     ```shell
     # For contributors.
-    mkdocs serve -f mkdocs.public.yml
+    uvx --with-requirements docs/requirements.txt -- mkdocs serve -f mkdocs.public.yml
 
     # For members of the Astral org, which has access to MkDocs Insiders via sponsorship.
-    mkdocs serve -f mkdocs.insiders.yml
+    uvx --with-requirements docs/requirements-insiders.txt -- mkdocs serve -f mkdocs.insiders.yml
     ```
 
 The documentation should then be available locally at
@@ -368,9 +360,8 @@ 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
-pip install -e ./python/ruff-ecosystem
-ruff-ecosystem check ruff "./target/debug/ruff"
-ruff-ecosystem format ruff "./target/debug/ruff"
+uvx --from ./python/ruff-ecosystem ruff-ecosystem check ruff "./target/debug/ruff"
+uvx --from ./python/ruff-ecosystem 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,9 +14,10 @@ license = "MIT"
 [workspace.dependencies]
 ruff = { path = "crates/ruff" }
 ruff_cache = { path = "crates/ruff_cache" }
-ruff_db = { path = "crates/ruff_db" }
+ruff_db = { path = "crates/ruff_db", default-features = false }
 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" }
@@ -33,15 +34,18 @@ 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_workspace = { path = "crates/red_knot_workspace" }
+red_knot_test = { path = "crates/red_knot_test" }
+red_knot_workspace = { path = "crates/red_knot_workspace", default-features = false }
 
 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" }
@@ -68,7 +72,11 @@ fern = { version = "0.6.1" }
 filetime = { version = "0.2.23" }
 glob = { version = "0.3.1" }
 globset = { version = "0.4.14" }
-hashbrown = "0.14.3"
+globwalk = { version = "0.9.1" }
+hashbrown = { version = "0.15.0", default-features = false, features = [
+    "raw-entry",
+    "inline-more",
+] }
 ignore = { version = "0.4.22" }
 imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
@@ -86,7 +94,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" }
@@ -102,13 +110,14 @@ pep440_rs = { version = "0.6.0", features = ["serde"] }
 pretty_assertions = "1.3.0"
 proc-macro2 = { version = "1.0.79" }
 pyproject-toml = { version = "0.9.0" }
-quick-junit = { version = "0.4.0" }
+quick-junit = { version = "0.5.0" }
 quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
+rstest = { version = "0.22.0", default-features = false }
 rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "f608ff8b24f07706492027199f51132244034f29" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "b14be5c0392f4c55eca60b92e457a35549372382" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -116,7 +125,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"] }
@@ -133,7 +142,10 @@ 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" }
@@ -144,10 +156,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" }
@@ -158,7 +170,10 @@ 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 }
@@ -230,9 +245,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.18.0"
+cargo-dist-version = "0.22.1"
 # 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)
@@ -241,33 +256,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
-# Publish jobs to run in CI
+# Which actions to run on pull requests
 pr-run-mode = "skip"
 # Whether CI should trigger releases with dispatches instead of tag pushes
 dispatch-releases = true
-# The stage during which the GitHub Release should be created
+# Which phase cargo-dist should use to create the GitHub release
 github-release = "announce"
 # Whether CI should include auto-generated code to build local artifacts
 build-local-artifacts = false
@@ -275,9 +290,15 @@ build-local-artifacts = false
 local-artifacts-jobs = ["./build-binaries", "./build-docker"]
 # Publish jobs to run in CI
 publish-jobs = ["./publish-pypi", "./publish-wasm"]
-# Announcement jobs to run in CI
-post-announce-jobs = ["./notify-dependents", "./publish-docs", "./publish-playground"]
+# Post-announce 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.3/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.6.3/install.ps1 | iex"
+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"
 ```
 
 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.3
+  rev: v0.6.9
   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/chartboost/ruff-action):
+[`ruff-action`](https://github.com/astral-sh/ruff-action):
 
 ```yaml
 name: Ruff
@@ -192,7 +192,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: chartboost/ruff-action@v1
+      - uses: astral-sh/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_python_semantic/vendor/**/*", "**/resources/**/*", "**/snapshots/**/*"]
+extend-exclude = ["crates/red_knot_vendored/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 pd` is a thing
+pn = "pn"  # `import panel as pn` 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,9 +13,8 @@ license.workspace = true
 
 [dependencies]
 red_knot_python_semantic = { workspace = true }
-red_knot_workspace = { workspace = true }
+red_knot_workspace = { workspace = true, features = ["zstd"] }
 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!(
-            "Temp directory '{}' is not a valid UTF-8 path.",
+            "Temporary 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,7 +501,10 @@ 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!(
@@ -525,7 +528,11 @@ 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")),
@@ -544,7 +551,11 @@ 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
@@ -569,7 +580,11 @@ 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()));
@@ -592,10 +607,14 @@ 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("foo.baz").unwrap()
+        &ModuleName::new_static("sub.a").unwrap()
+    )
+    .is_some());
+    assert!(resolve_module(
+        case.db().upcast(),
+        &ModuleName::new_static("foo.baz").unwrap()
     )
     .is_none());
 
@@ -623,11 +642,15 @@ 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());
 
@@ -665,7 +688,11 @@ 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");
 
@@ -688,7 +715,11 @@ 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()));
@@ -710,7 +741,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
     );
 
@@ -720,7 +751,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()]
@@ -736,7 +767,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 {
@@ -751,7 +782,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(())
 }
@@ -805,7 +836,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
     );
 
@@ -820,7 +851,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(())
 }
@@ -1044,7 +1075,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");
@@ -1125,7 +1156,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");
@@ -1229,7 +1260,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 }
-once_cell = { workspace = true }
+itertools = { workspace = true}
 ordermap = { workspace = true }
 salsa = { workspace = true }
 thiserror = { workspace = true }
@@ -33,21 +33,19 @@ rustc-hash = { workspace = true }
 hashbrown = { workspace = true }
 smallvec = { workspace = true }
 static_assertions = { workspace = true }
-
-[build-dependencies]
-path-slash = { workspace = true }
-walkdir = { workspace = true }
-zip = { workspace = true, features = ["zstd", "deflate"] }
+test-case = { workspace = true }
+memchr = { workspace = true }
 
 [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/build.rs

@@ -1,87 +1,4 @@
-//! 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();
+/// Rebuild the crate if a test file is added or removed from
+pub fn main() {
+    println!("cargo:rerun-if-changed=resources/mdtest");
 }

crates/red_knot_python_semantic/resources/README.md

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,273 @@
+# 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/ast_node_ref.rs

@@ -31,10 +31,10 @@ impl<T> AstNodeRef<T> {
     /// which the `AstNodeRef` belongs.
     ///
     /// ## Safety
+    ///
     /// Dereferencing the `node` can result in undefined behavior if `parsed` isn't the
     /// [`ParsedModule`] to which `node` belongs. It's the caller's responsibility to ensure that
     /// the invariant `node belongs to parsed` is upheld.
-
     pub(super) unsafe fn new(parsed: ParsedModule, node: &T) -> Self {
         Self {
             _parsed: parsed,

crates/red_knot_python_semantic/src/builtins.rs

@@ -1,16 +0,0 @@
-use crate::module_name::ModuleName;
-use crate::module_resolver::resolve_module;
-use crate::semantic_index::global_scope;
-use crate::semantic_index::symbol::ScopeId;
-use crate::Db;
-
-/// Salsa query to get the builtins scope.
-///
-/// Can return None if a custom typeshed is used that is missing `builtins.pyi`.
-#[salsa::tracked]
-pub(crate) fn builtins_scope(db: &dyn Db) -> Option<ScopeId<'_>> {
-    let builtins_name =
-        ModuleName::new_static("builtins").expect("Expected 'builtins' to be a valid module name");
-    let builtins_file = resolve_module(db, builtins_name)?.file();
-    Some(global_scope(db, builtins_file))
-}

crates/red_knot_python_semantic/src/db.rs

@@ -11,7 +11,6 @@ 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;
@@ -33,7 +32,7 @@ pub(crate) mod tests {
             Self {
                 storage: salsa::Storage::default(),
                 system: TestSystem::default(),
-                vendored: vendored_typeshed_stubs().clone(),
+                vendored: red_knot_vendored::file_system().clone(),
                 events: std::sync::Arc::default(),
                 files: Files::default(),
             }

crates/red_knot_python_semantic/src/lib.rs

@@ -4,13 +4,12 @@ use rustc_hash::FxHasher;
 
 pub use db::Db;
 pub use module_name::ModuleName;
-pub use module_resolver::{resolve_module, system_module_search_paths, vendored_typeshed_stubs};
+pub use module_resolver::{resolve_module, system_module_search_paths, Module};
 pub use program::{Program, ProgramSettings, SearchPathSettings, SitePackages};
 pub use python_version::PythonVersion;
 pub use semantic_model::{HasTy, SemanticModel};
 
 pub mod ast_node_ref;
-mod builtins;
 mod db;
 mod module_name;
 mod module_resolver;
@@ -20,6 +19,7 @@ mod python_version;
 pub mod semantic_index;
 mod semantic_model;
 pub(crate) mod site_packages;
+mod stdlib;
 pub mod types;
 
 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;

crates/red_knot_python_semantic/src/module_resolver/mod.rs

@@ -1,10 +1,9 @@
 use std::iter::FusedIterator;
 
-pub(crate) use module::Module;
+pub 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/path.rs

@@ -59,6 +59,10 @@ impl ModulePath {
         self.relative_path.push(component);
     }
 
+    pub(crate) fn pop(&mut self) -> bool {
+        self.relative_path.pop()
+    }
+
     #[must_use]
     pub(super) fn is_directory(&self, resolver: &ResolverContext) -> bool {
         let ModulePath {

crates/red_knot_python_semantic/src/module_resolver/resolver.rs

@@ -1,22 +1,23 @@
-use rustc_hash::{FxBuildHasher, FxHashSet};
 use std::borrow::Cow;
 use std::iter::FusedIterator;
-use std::ops::Deref;
+
+use rustc_hash::{FxBuildHasher, FxHashSet};
 
 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)
@@ -35,14 +36,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 the search paths.");
+        tracing::debug!("Module `{name}` not found in 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)
     );
 
@@ -102,7 +103,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)
@@ -136,7 +137,7 @@ pub(crate) struct SearchPaths {
     /// for the first `site-packages` path
     site_packages: Vec<SearchPath>,
 
-    typeshed_versions: ResolvedTypeshedVersions,
+    typeshed_versions: TypeshedVersions,
 }
 
 impl SearchPaths {
@@ -202,11 +203,11 @@ impl SearchPaths {
 
             let search_path = SearchPath::custom_stdlib(db, &custom_typeshed)?;
 
-            (ResolvedTypeshedVersions::Custom(parsed), search_path)
+            (parsed, search_path)
         } else {
             tracing::debug!("Using vendored stdlib");
             (
-                ResolvedTypeshedVersions::Vendored(vendored_typeshed_versions()),
+                vendored_typeshed_versions(db),
                 SearchPath::vendored_stdlib(),
             )
         };
@@ -279,23 +280,6 @@ 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
@@ -340,7 +324,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.
@@ -569,24 +553,16 @@ fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(SearchPath, File, Mod
 
                 package_path.push(module_name);
 
-                // Must be a `__init__.pyi` or `__init__.py` or it isn't a package.
-                let kind = if package_path.is_directory(&resolver_state) {
-                    package_path.push("__init__");
-                    ModuleKind::Package
-                } else {
-                    ModuleKind::Module
-                };
-
-                // TODO Implement full https://peps.python.org/pep-0561/#type-checker-module-resolution-order resolution
-                if let Some(stub) = package_path.with_pyi_extension().to_file(&resolver_state) {
-                    return Some((search_path.clone(), stub, kind));
+                // Check for a regular package first (highest priority)
+                package_path.push("__init__");
+                if let Some(regular_package) = resolve_file_module(&package_path, &resolver_state) {
+                    return Some((search_path.clone(), regular_package, ModuleKind::Package));
                 }
 
-                if let Some(module) = package_path
-                    .with_py_extension()
-                    .and_then(|path| path.to_file(&resolver_state))
-                {
-                    return Some((search_path.clone(), module, kind));
+                // Check for a file module next
+                package_path.pop();
+                if let Some(file_module) = resolve_file_module(&package_path, &resolver_state) {
+                    return Some((search_path.clone(), file_module, ModuleKind::Module));
                 }
 
                 // For regular packages, don't search the next search path. All files of that
@@ -607,6 +583,23 @@ fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(SearchPath, File, Mod
     None
 }
 
+/// If `module` exists on disk with either a `.pyi` or `.py` extension,
+/// return the [`File`] corresponding to that path.
+///
+/// `.pyi` files take priority, as they always have priority when
+/// resolving modules.
+fn resolve_file_module(module: &ModulePath, resolver_state: &ResolverContext) -> Option<File> {
+    // Stubs have precedence over source files
+    module
+        .with_pyi_extension()
+        .to_file(resolver_state)
+        .or_else(|| {
+            module
+                .with_py_extension()
+                .and_then(|path| path.to_file(resolver_state))
+        })
+}
+
 fn resolve_package<'a, 'db, I>(
     module_search_path: &SearchPath,
     components: I,
@@ -633,7 +626,10 @@ where
 
         if is_regular_package {
             in_namespace_package = false;
-        } else if package_path.is_directory(resolver_state) {
+        } else if package_path.is_directory(resolver_state)
+            // Pure modules hide namespace packages with the same name
+            && resolve_file_module(&package_path, resolver_state).is_none()
+        {
             // A directory without an `__init__.py` is a namespace package, continue with the next folder.
             in_namespace_package = true;
         } else if in_namespace_package {
@@ -732,11 +728,11 @@ mod tests {
             .build();
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
-        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
+        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
 
         assert_eq!(
             Some(&foo_module),
-            resolve_module(&db, foo_module_name.clone()).as_ref()
+            resolve_module(&db, &foo_module_name).as_ref()
         );
 
         assert_eq!("foo", foo_module.name());
@@ -759,7 +755,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"));
     }
@@ -780,7 +776,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"));
     }
@@ -798,11 +794,11 @@ mod tests {
             .build();
 
         let functools_module_name = ModuleName::new_static("functools").unwrap();
-        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
+        let functools_module = resolve_module(&db, &functools_module_name).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());
@@ -852,7 +848,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.clone()).unwrap_or_else(|| {
+            let resolved_module = resolve_module(&db, &module_name).unwrap_or_else(|| {
                 panic!("Expected module {module_name} to exist in the mock stdlib")
             });
             let search_path = resolved_module.search_path();
@@ -905,7 +901,7 @@ mod tests {
 
         for module_name in nonexisting_modules {
             assert!(
-                resolve_module(&db, module_name.clone()).is_none(),
+                resolve_module(&db, &module_name).is_none(),
                 "Unexpectedly resolved a module for {module_name}"
             );
         }
@@ -948,7 +944,7 @@ mod tests {
         ]);
 
         for module_name in existing_modules {
-            let resolved_module = resolve_module(&db, module_name.clone()).unwrap_or_else(|| {
+            let resolved_module = resolve_module(&db, &module_name).unwrap_or_else(|| {
                 panic!("Expected module {module_name} to exist in the mock stdlib")
             });
             let search_path = resolved_module.search_path();
@@ -984,7 +980,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.clone()).is_none(),
+                resolve_module(&db, &module_name).is_none(),
                 "Unexpectedly resolved a module for {module_name}"
             );
         }
@@ -1006,11 +1002,11 @@ mod tests {
             .build();
 
         let functools_module_name = ModuleName::new_static("functools").unwrap();
-        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
+        let functools_module = resolve_module(&db, &functools_module_name).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());
@@ -1030,7 +1026,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);
@@ -1047,7 +1043,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());
@@ -1074,7 +1070,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());
@@ -1091,13 +1087,32 @@ mod tests {
         );
     }
 
+    #[test]
+    fn single_file_takes_priority_over_namespace_package() {
+        //const SRC: &[FileSpec] = &[("foo.py", "x = 1")];
+        const SRC: &[FileSpec] = &[("foo.py", "x = 1"), ("foo/bar.py", "x = 2")];
+
+        let TestCase { db, src, .. } = TestCaseBuilder::new().with_src_files(SRC).build();
+
+        let foo_module_name = ModuleName::new_static("foo").unwrap();
+        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();
+        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);
+        assert_eq!(foo_bar_module, None);
+    }
+
     #[test]
     fn typing_stub_over_module() {
         const SRC: &[FileSpec] = &[("foo.py", "print('Hello, world!')"), ("foo.pyi", "x: int")];
 
         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());
@@ -1121,7 +1136,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());
@@ -1160,14 +1175,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)
         );
     }
@@ -1200,12 +1215,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())
         );
     }
 
@@ -1221,7 +1236,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());
@@ -1286,8 +1301,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);
 
@@ -1322,7 +1337,7 @@ mod tests {
             .build();
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
-        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
+        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
 
         let bar_path = src.join("bar.py");
         let bar = system_path_to_file(&db, &bar_path).expect("bar.py to exist");
@@ -1336,7 +1351,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()
@@ -1353,14 +1368,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.clone()), None);
+        assert_eq!(resolve_module(&db, &foo_module_name), 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(())
@@ -1374,7 +1389,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.clone()).expect("foo module to exist");
+        let foo_module = resolve_module(&db, &foo_module_name).expect("foo module to exist");
         let foo_init_path = src.join("foo/__init__.py");
 
         assert_eq!(&foo_init_path, foo_module.file().path(&db));
@@ -1386,7 +1401,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(())
@@ -1412,7 +1427,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.clone()).unwrap();
+        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
         assert_eq!(functools_module.search_path(), &stdlib);
         assert_eq!(
             Ok(functools_module.file()),
@@ -1425,7 +1440,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.clone()).unwrap();
+        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
         let events = db.take_salsa_events();
         assert_function_query_was_not_run(
             &db,
@@ -1458,7 +1473,7 @@ mod tests {
             .build();
 
         let functools_module_name = ModuleName::new_static("functools").unwrap();
-        let functools_module = resolve_module(&db, functools_module_name.clone()).unwrap();
+        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
         assert_eq!(functools_module.search_path(), &stdlib);
         assert_eq!(
             Ok(functools_module.file()),
@@ -1469,7 +1484,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.clone()).unwrap();
+        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
         assert_eq!(functools_module.search_path(), &src);
         assert_eq!(
             Ok(functools_module.file()),
@@ -1500,7 +1515,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.clone()).unwrap();
+        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
         assert_eq!(functools_module.search_path(), &src);
         assert_eq!(
             Ok(functools_module.file()),
@@ -1513,7 +1528,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.clone()).unwrap();
+        let functools_module = resolve_module(&db, &functools_module_name).unwrap();
         assert_eq!(functools_module.search_path(), &stdlib);
         assert_eq!(
             Ok(functools_module.file()),
@@ -1535,8 +1550,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.clone()).unwrap();
-        let foo_bar_module = resolve_module(&db, foo_bar_module_name.clone()).unwrap();
+        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
+        let foo_bar_module = resolve_module(&db, &foo_bar_module_name).unwrap();
 
         assert_eq!(
             foo_module.file().path(&db),
@@ -1564,11 +1579,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.clone()).unwrap();
+        let bar_module = resolve_module(&db, &bar_module_name).unwrap();
         assert_eq!(
             bar_module.file().path(&db),
             &FilePath::system("/y/src/bar.py")
@@ -1587,7 +1602,7 @@ mod tests {
             .build();
 
         let foo_module_name = ModuleName::new_static("foo").unwrap();
-        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
+        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
 
         assert_eq!(
             foo_module.file().path(&db),
@@ -1635,10 +1650,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.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();
+        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();
 
         assert_eq!(
             foo_module.file().path(&db),
@@ -1666,14 +1681,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")
@@ -1698,7 +1713,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.clone()).unwrap();
+        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
         assert_eq!(
             foo_module.file().path(&db),
             &FilePath::system("/x/src/foo.py")
@@ -1710,7 +1725,7 @@ not_a_directory
 
         File::sync_path(&mut db, &site_packages.join("_foo.pth"));
 
-        assert_eq!(resolve_module(&db, foo_module_name.clone()), None);
+        assert_eq!(resolve_module(&db, &foo_module_name), None);
     }
 
     #[test]
@@ -1725,7 +1740,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.clone()).unwrap();
+        let foo_module = resolve_module(&db, &foo_module_name).unwrap();
         let src_path = SystemPathBuf::from("/x/src");
         assert_eq!(
             foo_module.file().path(&db),
@@ -1738,7 +1753,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.clone()), None);
+        assert_eq!(resolve_module(&db, &foo_module_name), None);
     }
 
     #[test]
@@ -1797,7 +1812,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.clone()).unwrap();
+        let a_module = resolve_module(&db, &a_module_name).unwrap();
         assert_eq!(a_module.file().path(&db), &editable_install_location);
 
         db.memory_file_system()
@@ -1808,7 +1823,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.rs

@@ -4,25 +4,19 @@ 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};
 
-static VENDORED_VERSIONS: Lazy<TypeshedVersions> = Lazy::new(|| {
+pub(in crate::module_resolver) fn vendored_typeshed_versions(db: &dyn Db) -> TypeshedVersions {
     TypeshedVersions::from_str(
-        &vendored_typeshed_stubs()
+        &db.vendored()
             .read_to_string("stdlib/VERSIONS")
-            .unwrap(),
+            .expect("The vendored typeshed stubs should contain a VERSIONS file"),
     )
-    .unwrap()
-});
-
-pub(crate) fn vendored_typeshed_versions() -> &'static TypeshedVersions {
-    &VENDORED_VERSIONS
+    .expect("The VERSIONS file in the vendored typeshed stubs should be well-formed")
 }
 
 pub(crate) fn typeshed_versions(db: &dyn Db) -> &TypeshedVersions {
@@ -332,6 +326,8 @@ mod tests {
 
     use insta::assert_snapshot;
 
+    use crate::db::tests::TestDb;
+
     use super::*;
 
     const TYPESHED_STDLIB_DIR: &str = "stdlib";
@@ -353,12 +349,9 @@ mod tests {
 
     #[test]
     fn can_parse_vendored_versions_file() {
-        let versions_data = include_str!(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/vendor/typeshed/stdlib/VERSIONS"
-        ));
+        let db = TestDb::new();
 
-        let versions = TypeshedVersions::from_str(versions_data).unwrap();
+        let versions = vendored_typeshed_versions(&db);
         assert!(versions.len() > 100);
         assert!(versions.len() < 1000);
 
@@ -395,9 +388,10 @@ mod tests {
 
     #[test]
     fn typeshed_versions_consistent_with_vendored_stubs() {
-        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 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");
 
         let mut empty_iterator = true;
 

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

@@ -1,8 +0,0 @@
-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/python_version.rs

@@ -54,6 +54,13 @@ 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::FxHashMap;
+use rustc_hash::{FxBuildHasher, FxHashMap};
 use salsa::plumbing::AsId;
 
 use ruff_db::files::File;
@@ -21,14 +21,17 @@ use crate::Db;
 
 pub mod ast_ids;
 mod builder;
+pub(crate) mod constraint;
 pub mod definition;
 pub mod expression;
 pub mod symbol;
 mod use_def;
 
-pub(crate) use self::use_def::{DefinitionWithConstraints, DefinitionWithConstraintsIterator};
+pub(crate) use self::use_def::{
+    BindingWithConstraints, BindingWithConstraintsIterator, DeclarationsIterator,
+};
 
-type SymbolMap = hashbrown::HashMap<ScopedSymbolId, (), ()>;
+type SymbolMap = hashbrown::HashMap<ScopedSymbolId, (), FxBuildHasher>;
 
 /// Returns the semantic index for `file`.
 ///
@@ -112,6 +115,9 @@ 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> {
@@ -212,6 +218,12 @@ 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> {
@@ -325,16 +337,16 @@ mod tests {
     use crate::Db;
 
     impl UseDefMap<'_> {
-        fn first_public_definition(&self, symbol: ScopedSymbolId) -> Option<Definition<'_>> {
-            self.public_definitions(symbol)
+        fn first_public_binding(&self, symbol: ScopedSymbolId) -> Option<Definition<'_>> {
+            self.public_bindings(symbol)
                 .next()
-                .map(|constrained_definition| constrained_definition.definition)
+                .map(|constrained_binding| constrained_binding.binding)
         }
 
-        fn first_use_definition(&self, use_id: ScopedUseId) -> Option<Definition<'_>> {
-            self.use_definitions(use_id)
+        fn first_binding_at_use(&self, use_id: ScopedUseId) -> Option<Definition<'_>> {
+            self.bindings_at_use(use_id)
                 .next()
-                .map(|constrained_definition| constrained_definition.definition)
+                .map(|constrained_binding| constrained_binding.binding)
         }
     }
 
@@ -396,8 +408,8 @@ mod tests {
         let foo = global_table.symbol_id_by_name("foo").unwrap();
 
         let use_def = use_def_map(&db, scope);
-        let definition = use_def.first_public_definition(foo).unwrap();
-        assert!(matches!(definition.node(&db), DefinitionKind::Import(_)));
+        let binding = use_def.first_public_binding(foo).unwrap();
+        assert!(matches!(binding.kind(&db), DefinitionKind::Import(_)));
     }
 
     #[test]
@@ -426,22 +438,19 @@ mod tests {
         assert!(
             global_table
                 .symbol_by_name("foo")
-                .is_some_and(|symbol| { symbol.is_defined() && !symbol.is_used() }),
+                .is_some_and(|symbol| { symbol.is_bound() && !symbol.is_used() }),
             "symbols that are defined get the defined flag"
         );
 
         let use_def = use_def_map(&db, scope);
-        let definition = use_def
-            .first_public_definition(
+        let binding = use_def
+            .first_public_binding(
                 global_table
                     .symbol_id_by_name("foo")
                     .expect("symbol to exist"),
             )
             .unwrap();
-        assert!(matches!(
-            definition.node(&db),
-            DefinitionKind::ImportFrom(_)
-        ));
+        assert!(matches!(binding.kind(&db), DefinitionKind::ImportFrom(_)));
     }
 
     #[test]
@@ -454,17 +463,14 @@ mod tests {
         assert!(
             global_table
                 .symbol_by_name("foo")
-                .is_some_and(|symbol| { !symbol.is_defined() && symbol.is_used() }),
-            "a symbol used but not defined in a scope should have only the used flag"
+                .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"
         );
         let use_def = use_def_map(&db, scope);
-        let definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("x").expect("symbol exists"))
+        let binding = use_def
+            .first_public_binding(global_table.symbol_id_by_name("x").expect("symbol exists"))
             .unwrap();
-        assert!(matches!(
-            definition.node(&db),
-            DefinitionKind::Assignment(_)
-        ));
+        assert!(matches!(binding.kind(&db), DefinitionKind::Assignment(_)));
     }
 
     #[test]
@@ -476,12 +482,12 @@ mod tests {
         assert_eq!(names(&global_table), vec!["x"]);
 
         let use_def = use_def_map(&db, scope);
-        let definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("x").unwrap())
+        let binding = use_def
+            .first_public_binding(global_table.symbol_id_by_name("x").unwrap())
             .unwrap();
 
         assert!(matches!(
-            definition.node(&db),
+            binding.kind(&db),
             DefinitionKind::AugmentedAssignment(_)
         ));
     }
@@ -514,13 +520,10 @@ y = 2
         assert_eq!(names(&class_table), vec!["x"]);
 
         let use_def = index.use_def_map(class_scope_id);
-        let definition = use_def
-            .first_public_definition(class_table.symbol_id_by_name("x").expect("symbol exists"))
+        let binding = use_def
+            .first_public_binding(class_table.symbol_id_by_name("x").expect("symbol exists"))
             .unwrap();
-        assert!(matches!(
-            definition.node(&db),
-            DefinitionKind::Assignment(_)
-        ));
+        assert!(matches!(binding.kind(&db), DefinitionKind::Assignment(_)));
     }
 
     #[test]
@@ -550,17 +553,14 @@ y = 2
         assert_eq!(names(&function_table), vec!["x"]);
 
         let use_def = index.use_def_map(function_scope_id);
-        let definition = use_def
-            .first_public_definition(
+        let binding = use_def
+            .first_public_binding(
                 function_table
                     .symbol_id_by_name("x")
                     .expect("symbol exists"),
             )
             .unwrap();
-        assert!(matches!(
-            definition.node(&db),
-            DefinitionKind::Assignment(_)
-        ));
+        assert!(matches!(binding.kind(&db), DefinitionKind::Assignment(_)));
     }
 
     #[test]
@@ -592,27 +592,27 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
 
         let use_def = index.use_def_map(function_scope_id);
         for name in ["a", "b", "c", "d"] {
-            let definition = use_def
-                .first_public_definition(
+            let binding = use_def
+                .first_public_binding(
                     function_table
                         .symbol_id_by_name(name)
                         .expect("symbol exists"),
                 )
                 .unwrap();
             assert!(matches!(
-                definition.node(&db),
+                binding.kind(&db),
                 DefinitionKind::ParameterWithDefault(_)
             ));
         }
         for name in ["args", "kwargs"] {
-            let definition = use_def
-                .first_public_definition(
+            let binding = use_def
+                .first_public_binding(
                     function_table
                         .symbol_id_by_name(name)
                         .expect("symbol exists"),
                 )
                 .unwrap();
-            assert!(matches!(definition.node(&db), DefinitionKind::Parameter(_)));
+            assert!(matches!(binding.kind(&db), DefinitionKind::Parameter(_)));
         }
     }
 
@@ -640,23 +640,19 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
 
         let use_def = index.use_def_map(lambda_scope_id);
         for name in ["a", "b", "c", "d"] {
-            let definition = use_def
-                .first_public_definition(
-                    lambda_table.symbol_id_by_name(name).expect("symbol exists"),
-                )
+            let binding = use_def
+                .first_public_binding(lambda_table.symbol_id_by_name(name).expect("symbol exists"))
                 .unwrap();
             assert!(matches!(
-                definition.node(&db),
+                binding.kind(&db),
                 DefinitionKind::ParameterWithDefault(_)
             ));
         }
         for name in ["args", "kwargs"] {
-            let definition = use_def
-                .first_public_definition(
-                    lambda_table.symbol_id_by_name(name).expect("symbol exists"),
-                )
+            let binding = use_def
+                .first_public_binding(lambda_table.symbol_id_by_name(name).expect("symbol exists"))
                 .unwrap();
-            assert!(matches!(definition.node(&db), DefinitionKind::Parameter(_)));
+            assert!(matches!(binding.kind(&db), DefinitionKind::Parameter(_)));
         }
     }
 
@@ -666,7 +662,7 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
     fn comprehension_scope() {
         let TestCase { db, file } = test_case(
             "
-[x for x in iter1]
+[x for x, y in iter1]
 ",
         );
 
@@ -690,7 +686,22 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
 
         let comprehension_symbol_table = index.symbol_table(comprehension_scope_id);
 
-        assert_eq!(names(&comprehension_symbol_table), vec!["x"]);
+        assert_eq!(names(&comprehension_symbol_table), vec!["x", "y"]);
+
+        let use_def = index.use_def_map(comprehension_scope_id);
+        for name in ["x", "y"] {
+            let binding = use_def
+                .first_public_binding(
+                    comprehension_symbol_table
+                        .symbol_id_by_name(name)
+                        .expect("symbol exists"),
+                )
+                .unwrap();
+            assert!(matches!(
+                binding.kind(&db),
+                DefinitionKind::Comprehension(_)
+            ));
+        }
     }
 
     /// Test case to validate that the `x` variable used in the comprehension is referencing the
@@ -726,12 +737,12 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
         let element_use_id =
             element.scoped_use_id(&db, comprehension_scope_id.to_scope_id(&db, file));
 
-        let definition = use_def.first_use_definition(element_use_id).unwrap();
-        let DefinitionKind::Comprehension(comprehension) = definition.node(&db) else {
+        let binding = use_def.first_binding_at_use(element_use_id).unwrap();
+        let DefinitionKind::Comprehension(comprehension) = binding.kind(&db) else {
             panic!("expected generator definition")
         };
-        let ast::Comprehension { target, .. } = comprehension.node();
-        let name = target.as_name_expr().unwrap().id().as_str();
+        let target = comprehension.target();
+        let name = target.id().as_str();
 
         assert_eq!(name, "x");
         assert_eq!(target.range(), TextRange::new(23.into(), 24.into()));
@@ -806,12 +817,10 @@ with item1 as x, item2 as y:
 
         let use_def = index.use_def_map(FileScopeId::global());
         for name in ["x", "y"] {
-            let Some(definition) = use_def.first_public_definition(
-                global_table.symbol_id_by_name(name).expect("symbol exists"),
-            ) else {
-                panic!("Expected with item definition for {name}");
-            };
-            assert!(matches!(definition.node(&db), DefinitionKind::WithItem(_)));
+            let binding = use_def
+                .first_public_binding(global_table.symbol_id_by_name(name).expect("symbol exists"))
+                .expect("Expected with item definition for {name}");
+            assert!(matches!(binding.kind(&db), DefinitionKind::WithItem(_)));
         }
     }
 
@@ -831,12 +840,10 @@ with context() as (x, y):
 
         let use_def = index.use_def_map(FileScopeId::global());
         for name in ["x", "y"] {
-            let Some(definition) = use_def.first_public_definition(
-                global_table.symbol_id_by_name(name).expect("symbol exists"),
-            ) else {
-                panic!("Expected with item definition for {name}");
-            };
-            assert!(matches!(definition.node(&db), DefinitionKind::WithItem(_)));
+            let binding = use_def
+                .first_public_binding(global_table.symbol_id_by_name(name).expect("symbol exists"))
+                .expect("Expected with item definition for {name}");
+            assert!(matches!(binding.kind(&db), DefinitionKind::WithItem(_)));
         }
     }
 
@@ -873,14 +880,14 @@ def func():
         assert_eq!(names(&func2_table), vec!["y"]);
 
         let use_def = index.use_def_map(FileScopeId::global());
-        let definition = use_def
-            .first_public_definition(
+        let binding = use_def
+            .first_public_binding(
                 global_table
                     .symbol_id_by_name("func")
                     .expect("symbol exists"),
             )
             .unwrap();
-        assert!(matches!(definition.node(&db), DefinitionKind::Function(_)));
+        assert!(matches!(binding.kind(&db), DefinitionKind::Function(_)));
     }
 
     #[test]
@@ -948,7 +955,7 @@ class C[T]:
         assert!(
             ann_table
                 .symbol_by_name("T")
-                .is_some_and(|s| s.is_defined() && !s.is_used()),
+                .is_some_and(|s| s.is_bound() && !s.is_used()),
             "type parameters are defined by the scope that introduces them"
         );
 
@@ -980,14 +987,14 @@ class C[T]:
         };
         let x_use_id = x_use_expr_name.scoped_use_id(&db, scope);
         let use_def = use_def_map(&db, scope);
-        let definition = use_def.first_use_definition(x_use_id).unwrap();
-        let DefinitionKind::Assignment(assignment) = definition.node(&db) else {
+        let binding = use_def.first_binding_at_use(x_use_id).unwrap();
+        let DefinitionKind::Assignment(assignment) = binding.kind(&db) else {
             panic!("should be an assignment definition")
         };
         let ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
             value: ast::Number::Int(num),
             ..
-        }) = &*assignment.assignment().value
+        }) = assignment.value()
         else {
             panic!("should be a number literal")
         };
@@ -1029,7 +1036,7 @@ class C[T]:
         }
 
         let TestCase { db, file } = test_case(
-            r#"
+            r"
 class Test:
     def foo():
         def bar():
@@ -1038,7 +1045,7 @@ class Test:
         pass
 
 def x():
-    pass"#,
+    pass",
         );
 
         let index = semantic_index(&db, file);
@@ -1073,7 +1080,7 @@ def x():
     }
 
     #[test]
-    fn match_stmt_symbols() {
+    fn match_stmt() {
         let TestCase { db, file } = test_case(
             "
 match subject:
@@ -1087,13 +1094,69 @@ match subject:
 ",
         );
 
-        let global_table = symbol_table(&db, global_scope(&db, file));
+        let global_scope_id = global_scope(&db, file);
+        let global_table = symbol_table(&db, global_scope_id);
 
         assert!(global_table.symbol_by_name("Foo").unwrap().is_used());
         assert_eq!(
             names(&global_table),
-            vec!["subject", "a", "b", "c", "d", "f", "e", "h", "g", "Foo", "i", "j", "k", "l"]
+            vec!["subject", "a", "b", "c", "d", "e", "f", "g", "h", "Foo", "i", "j", "k", "l"]
         );
+
+        let use_def = use_def_map(&db, global_scope_id);
+        for (name, expected_index) in [
+            ("a", 0),
+            ("b", 0),
+            ("c", 1),
+            ("d", 2),
+            ("e", 0),
+            ("f", 1),
+            ("g", 0),
+            ("h", 1),
+            ("i", 0),
+            ("j", 1),
+            ("k", 0),
+            ("l", 1),
+        ] {
+            let binding = use_def
+                .first_public_binding(global_table.symbol_id_by_name(name).expect("symbol exists"))
+                .expect("Expected with item definition for {name}");
+            if let DefinitionKind::MatchPattern(pattern) = binding.kind(&db) {
+                assert_eq!(pattern.index(), expected_index);
+            } else {
+                panic!("Expected match pattern definition for {name}");
+            }
+        }
+    }
+
+    #[test]
+    fn nested_match_case() {
+        let TestCase { db, file } = test_case(
+            "
+match 1:
+    case first:
+        match 2:
+            case second:
+                pass
+",
+        );
+
+        let global_scope_id = global_scope(&db, file);
+        let global_table = symbol_table(&db, global_scope_id);
+
+        assert_eq!(names(&global_table), vec!["first", "second"]);
+
+        let use_def = use_def_map(&db, global_scope_id);
+        for (name, expected_index) in [("first", 0), ("second", 0)] {
+            let binding = use_def
+                .first_public_binding(global_table.symbol_id_by_name(name).expect("symbol exists"))
+                .expect("Expected with item definition for {name}");
+            if let DefinitionKind::MatchPattern(pattern) = binding.kind(&db) {
+                assert_eq!(pattern.index(), expected_index);
+            } else {
+                panic!("Expected match pattern definition for {name}");
+            }
+        }
     }
 
     #[test]
@@ -1105,11 +1168,11 @@ match subject:
         assert_eq!(&names(&global_table), &["a", "x"]);
 
         let use_def = use_def_map(&db, scope);
-        let definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("x").unwrap())
+        let binding = use_def
+            .first_public_binding(global_table.symbol_id_by_name("x").unwrap())
             .unwrap();
 
-        assert!(matches!(definition.node(&db), DefinitionKind::For(_)));
+        assert!(matches!(binding.kind(&db), DefinitionKind::For(_)));
     }
 
     #[test]
@@ -1121,15 +1184,15 @@ match subject:
         assert_eq!(&names(&global_table), &["a", "x", "y"]);
 
         let use_def = use_def_map(&db, scope);
-        let x_definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("x").unwrap())
+        let x_binding = use_def
+            .first_public_binding(global_table.symbol_id_by_name("x").unwrap())
             .unwrap();
-        let y_definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("y").unwrap())
+        let y_binding = use_def
+            .first_public_binding(global_table.symbol_id_by_name("y").unwrap())
             .unwrap();
 
-        assert!(matches!(x_definition.node(&db), DefinitionKind::For(_)));
-        assert!(matches!(y_definition.node(&db), DefinitionKind::For(_)));
+        assert!(matches!(x_binding.kind(&db), DefinitionKind::For(_)));
+        assert!(matches!(y_binding.kind(&db), DefinitionKind::For(_)));
     }
 
     #[test]
@@ -1141,10 +1204,10 @@ match subject:
         assert_eq!(&names(&global_table), &["e", "a", "b", "c", "d"]);
 
         let use_def = use_def_map(&db, scope);
-        let definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("a").unwrap())
+        let binding = use_def
+            .first_public_binding(global_table.symbol_id_by_name("a").unwrap())
             .unwrap();
 
-        assert!(matches!(definition.node(&db), DefinitionKind::For(_)));
+        assert!(matches!(binding.kind(&db), DefinitionKind::For(_)));
     }
 }

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use except_handlers::TryNodeContextStackManager;
 use rustc_hash::FxHashMap;
 
 use ruff_db::files::File;
@@ -19,14 +20,20 @@ use crate::semantic_index::definition::{
 };
 use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{
-    FileScopeId, NodeWithScopeKey, NodeWithScopeRef, Scope, ScopeId, ScopedSymbolId, SymbolFlags,
+    FileScopeId, NodeWithScopeKey, NodeWithScopeRef, Scope, ScopeId, ScopedSymbolId,
     SymbolTableBuilder,
 };
 use crate::semantic_index::use_def::{FlowSnapshot, UseDefMapBuilder};
 use crate::semantic_index::SemanticIndex;
 use crate::Db;
 
-use super::definition::WithItemDefinitionNodeRef;
+use super::constraint::{Constraint, PatternConstraint};
+use super::definition::{
+    AssignmentKind, DefinitionCategory, ExceptHandlerDefinitionNodeRef,
+    MatchPatternDefinitionNodeRef, WithItemDefinitionNodeRef,
+};
+
+mod except_handlers;
 
 pub(super) struct SemanticIndexBuilder<'db> {
     // Builder state
@@ -34,10 +41,18 @@ pub(super) struct SemanticIndexBuilder<'db> {
     file: File,
     module: &'db ParsedModule,
     scope_stack: Vec<FileScopeId>,
-    /// The assignment we're currently visiting.
-    current_assignment: Option<CurrentAssignment<'db>>,
+    /// The assignments we're currently visiting, with
+    /// the most recent visit at the end of the Vec
+    current_assignments: Vec<CurrentAssignment<'db>>,
+    /// The match case we're currently visiting.
+    current_match_case: Option<CurrentMatchCase<'db>>,
     /// Flow states at each `break` in the current loop.
     loop_break_states: Vec<FlowSnapshot>,
+    /// Per-scope contexts regarding nested `try`/`except` statements
+    try_node_context_stack_manager: TryNodeContextStackManager,
+
+    /// Flags about the file's global scope
+    has_future_annotations: bool,
 
     // Semantic Index fields
     scopes: IndexVec<FileScopeId, Scope>,
@@ -58,8 +73,12 @@ impl<'db> SemanticIndexBuilder<'db> {
             file,
             module: parsed,
             scope_stack: Vec::new(),
-            current_assignment: None,
+            current_assignments: vec![],
+            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(),
@@ -98,6 +117,7 @@ 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());
@@ -127,6 +147,7 @@ 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
     }
 
@@ -162,49 +183,112 @@ impl<'db> SemanticIndexBuilder<'db> {
         self.current_use_def_map_mut().merge(state);
     }
 
-    fn add_or_update_symbol(&mut self, name: Name, flags: SymbolFlags) -> ScopedSymbolId {
-        let symbol_table = self.current_symbol_table();
-        let (symbol_id, added) = symbol_table.add_or_update_symbol(name, flags);
+    fn add_symbol(&mut self, name: Name) -> ScopedSymbolId {
+        let (symbol_id, added) = self.current_symbol_table().add_symbol(name);
         if added {
-            let use_def_map = self.current_use_def_map_mut();
-            use_def_map.add_symbol(symbol_id);
+            self.current_use_def_map_mut().add_symbol(symbol_id);
         }
         symbol_id
     }
 
+    fn mark_symbol_bound(&mut self, id: ScopedSymbolId) {
+        self.current_symbol_table().mark_symbol_bound(id);
+    }
+
+    fn mark_symbol_used(&mut self, id: ScopedSymbolId) {
+        self.current_symbol_table().mark_symbol_used(id);
+    }
+
     fn add_definition<'a>(
         &mut self,
         symbol: ScopedSymbolId,
         definition_node: impl Into<DefinitionNodeRef<'a>>,
     ) -> 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 definition = Definition::new(
             self.db,
             self.file,
             self.current_scope(),
             symbol,
-            #[allow(unsafe_code)]
-            unsafe {
-                definition_node.into_owned(self.module.clone())
-            },
+            kind,
             countme::Count::default(),
         );
 
-        self.definitions_by_node
+        let existing_definition = self
+            .definitions_by_node
             .insert(definition_node.key(), definition);
-        self.current_use_def_map_mut()
-            .record_definition(symbol, definition);
+        debug_assert_eq!(existing_definition, None);
+
+        if category.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),
+        }
+
+        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
     }
 
-    fn add_constraint(&mut self, constraint_node: &ast::Expr) -> Expression<'db> {
+    fn add_expression_constraint(&mut self, constraint_node: &ast::Expr) -> Expression<'db> {
         let expression = self.add_standalone_expression(constraint_node);
-        self.current_use_def_map_mut().record_constraint(expression);
+        self.current_use_def_map_mut()
+            .record_constraint(Constraint::Expression(expression));
 
         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,
+        pattern: &ast::Pattern,
+    ) -> PatternConstraint<'db> {
+        #[allow(unsafe_code)]
+        let (subject, pattern) = unsafe {
+            (
+                AstNodeRef::new(self.module.clone(), subject),
+                AstNodeRef::new(self.module.clone(), pattern),
+            )
+        };
+        let pattern_constraint = PatternConstraint::new(
+            self.db,
+            self.file,
+            self.current_scope(),
+            subject,
+            pattern,
+            countme::Count::default(),
+        );
+        self.current_use_def_map_mut()
+            .record_constraint(Constraint::Pattern(pattern_constraint));
+        pattern_constraint
+    }
+
     /// Record an expression that needs to be a Salsa ingredient, because we need to infer its type
     /// standalone (type narrowing tests, RHS of an assignment.)
     fn add_standalone_expression(&mut self, expression_node: &ast::Expr) -> Expression<'db> {
@@ -249,10 +333,13 @@ impl<'db> SemanticIndexBuilder<'db> {
                         ..
                     }) => (name, &None, default),
                 };
-                // TODO create Definition for typevars
-                self.add_or_update_symbol(name.id.clone(), SymbolFlags::IS_DEFINED);
-                if let Some(bound) = bound {
-                    self.visit_expr(bound);
+                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(default) = default {
                     self.visit_expr(default);
@@ -269,11 +356,23 @@ impl<'db> SemanticIndexBuilder<'db> {
         nested_scope
     }
 
-    /// 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`.)
+    /// 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
     ///
     /// [`Comprehension`]: ast::Comprehension
-    fn visit_generators(&mut self, scope: NodeWithScopeRef, generators: &'db [ast::Comprehension]) {
+    fn with_generators_scope(
+        &mut self,
+        scope: NodeWithScopeRef,
+        generators: &'db [ast::Comprehension],
+        visit_outer_elt: impl FnOnce(&mut Self),
+    ) {
         let mut generators_iter = generators.iter();
 
         let Some(generator) = generators_iter.next() else {
@@ -282,39 +381,43 @@ impl<'db> SemanticIndexBuilder<'db> {
 
         // The `iter` of the first generator is evaluated in the outer scope, while all subsequent
         // nodes are evaluated in the inner scope.
+        self.add_standalone_expression(&generator.iter);
         self.visit_expr(&generator.iter);
         self.push_scope(scope);
 
-        self.current_assignment = Some(CurrentAssignment::Comprehension {
+        self.push_assignment(CurrentAssignment::Comprehension {
             node: generator,
             first: true,
         });
         self.visit_expr(&generator.target);
-        self.current_assignment = None;
+        self.pop_assignment();
 
         for expr in &generator.ifs {
             self.visit_expr(expr);
         }
 
         for generator in generators_iter {
+            self.add_standalone_expression(&generator.iter);
             self.visit_expr(&generator.iter);
 
-            self.current_assignment = Some(CurrentAssignment::Comprehension {
+            self.push_assignment(CurrentAssignment::Comprehension {
                 node: generator,
                 first: false,
             });
             self.visit_expr(&generator.target);
-            self.current_assignment = None;
+            self.pop_assignment();
 
             for expr in &generator.ifs {
                 self.visit_expr(expr);
             }
         }
+
+        visit_outer_elt(self);
+        self.pop_scope();
     }
 
     fn declare_parameter(&mut self, parameter: AnyParameterRef) {
-        let symbol =
-            self.add_or_update_symbol(parameter.name().id().clone(), SymbolFlags::IS_DEFINED);
+        let symbol = self.add_symbol(parameter.name().id().clone());
 
         let definition = self.add_definition(symbol, parameter);
 
@@ -322,10 +425,11 @@ impl<'db> SemanticIndexBuilder<'db> {
             // Insert a mapping from the parameter to the same definition.
             // This ensures that calling `HasTy::ty` on the inner parameter returns
             // a valid type (and doesn't panic)
-            self.definitions_by_node.insert(
+            let existing_definition = self.definitions_by_node.insert(
                 DefinitionNodeRef::from(AnyParameterRef::Variadic(&with_default.parameter)).key(),
                 definition,
             );
+            debug_assert_eq!(existing_definition, None);
         }
     }
 
@@ -337,7 +441,7 @@ impl<'db> SemanticIndexBuilder<'db> {
         self.pop_scope();
         assert!(self.scope_stack.is_empty());
 
-        assert!(self.current_assignment.is_none());
+        assert_eq!(&self.current_assignments, &[]);
 
         let mut symbol_tables: IndexVec<_, _> = self
             .symbol_tables
@@ -377,6 +481,7 @@ 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,
         }
     }
 }
@@ -424,8 +529,7 @@ where
                 // The symbol for the function name itself has to be evaluated
                 // at the end to match the runtime evaluation of parameter defaults
                 // and return-type annotations.
-                let symbol = self
-                    .add_or_update_symbol(function_def.name.id.clone(), SymbolFlags::IS_DEFINED);
+                let symbol = self.add_symbol(function_def.name.id.clone());
                 self.add_definition(symbol, function_def);
             }
             ast::Stmt::ClassDef(class) => {
@@ -433,8 +537,7 @@ where
                     self.visit_decorator(decorator);
                 }
 
-                let symbol =
-                    self.add_or_update_symbol(class.name.id.clone(), SymbolFlags::IS_DEFINED);
+                let symbol = self.add_symbol(class.name.id.clone());
                 self.add_definition(symbol, class);
 
                 self.with_type_params(
@@ -460,7 +563,7 @@ where
                         Name::new(alias.name.id.split('.').next().unwrap())
                     };
 
-                    let symbol = self.add_or_update_symbol(symbol_name, SymbolFlags::IS_DEFINED);
+                    let symbol = self.add_symbol(symbol_name);
                     self.add_definition(symbol, alias);
                 }
             }
@@ -472,31 +575,52 @@ where
                         &alias.name.id
                     };
 
-                    let symbol =
-                        self.add_or_update_symbol(symbol_name.clone(), SymbolFlags::IS_DEFINED);
+                    // 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!(self.current_assignment.is_none());
+                debug_assert_eq!(&self.current_assignments, &[]);
                 self.visit_expr(&node.value);
                 self.add_standalone_expression(&node.value);
-                self.current_assignment = Some(node.into());
-                for target in &node.targets {
+                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.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!(self.current_assignment.is_none());
-                // TODO deferred annotation visiting
+                debug_assert_eq!(&self.current_assignments, &[]);
                 self.visit_expr(&node.annotation);
                 if let Some(value) = &node.value {
                     self.visit_expr(value);
                 }
-                self.current_assignment = Some(node.into());
+                self.push_assignment(node.into());
                 self.visit_expr(&node.target);
-                self.current_assignment = None;
+                self.pop_assignment();
             }
             ast::Stmt::AugAssign(
                 aug_assign @ ast::StmtAugAssign {
@@ -506,16 +630,16 @@ where
                     value,
                 },
             ) => {
-                debug_assert!(self.current_assignment.is_none());
+                debug_assert_eq!(&self.current_assignments, &[]);
                 self.visit_expr(value);
-                self.current_assignment = Some(aug_assign.into());
+                self.push_assignment(aug_assign.into());
                 self.visit_expr(target);
-                self.current_assignment = None;
+                self.pop_assignment();
             }
             ast::Stmt::If(node) => {
                 self.visit_expr(&node.test);
                 let pre_if = self.flow_snapshot();
-                self.add_constraint(&node.test);
+                self.add_expression_constraint(&node.test);
                 self.visit_body(&node.body);
                 let mut post_clauses: Vec<FlowSnapshot> = vec![];
                 for clause in &node.elif_else_clauses {
@@ -540,14 +664,23 @@ where
                     self.flow_merge(pre_if);
                 }
             }
-            ast::Stmt::While(node) => {
-                self.visit_expr(&node.test);
+            ast::Stmt::While(ast::StmtWhile {
+                test,
+                body,
+                orelse,
+                range: _,
+            }) => {
+                self.visit_expr(test);
 
                 let pre_loop = self.flow_snapshot();
 
                 // Save aside any break states from an outer loop
                 let saved_break_states = std::mem::take(&mut self.loop_break_states);
-                self.visit_body(&node.body);
+
+                // TODO: definitions created inside the body should be fully visible
+                // to other statements/expressions inside the body --Alex/Carl
+                self.visit_body(body);
+
                 // Get the break states from the body of this loop, and restore the saved outer
                 // ones.
                 let break_states =
@@ -556,7 +689,7 @@ where
                 // We may execute the `else` clause without ever executing the body, so merge in
                 // the pre-loop state before visiting `else`.
                 self.flow_merge(pre_loop);
-                self.visit_body(&node.orelse);
+                self.visit_body(orelse);
 
                 // Breaking out of a while loop bypasses the `else` clause, so merge in the break
                 // states after visiting `else`.
@@ -569,9 +702,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.current_assignment = Some(item.into());
+                        self.push_assignment(item.into());
                         self.visit_expr(optional_vars);
-                        self.current_assignment = None;
+                        self.pop_assignment();
                     }
                 }
                 self.visit_body(body);
@@ -590,15 +723,175 @@ where
                     orelse,
                 },
             ) => {
-                // TODO add control flow similar to `ast::Stmt::While` above
                 self.add_standalone_expression(iter);
                 self.visit_expr(iter);
-                debug_assert!(self.current_assignment.is_none());
-                self.current_assignment = Some(for_stmt.into());
+
+                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());
                 self.visit_expr(target);
-                self.current_assignment = None;
+                self.pop_assignment();
+
+                // TODO: Definitions created by loop variables
+                // (and definitions created inside the body)
+                // are fully visible to other statements/expressions inside the body --Alex/Carl
                 self.visit_body(body);
+
+                let break_states =
+                    std::mem::replace(&mut self.loop_break_states, saved_break_states);
+
+                // We may execute the `else` clause without ever executing the body, so merge in
+                // the pre-loop state before visiting `else`.
+                self.flow_merge(pre_loop);
                 self.visit_body(orelse);
+
+                // Breaking out of a `for` loop bypasses the `else` clause, so merge in the break
+                // states after visiting `else`.
+                for break_state in break_states {
+                    self.flow_merge(break_state);
+                }
+            }
+            ast::Stmt::Match(ast::StmtMatch {
+                subject,
+                cases,
+                range: _,
+            }) => {
+                self.add_standalone_expression(subject);
+                self.visit_expr(subject);
+
+                let after_subject = self.flow_snapshot();
+                let Some((first, remaining)) = cases.split_first() else {
+                    return;
+                };
+                self.add_pattern_constraint(subject, &first.pattern);
+                self.visit_match_case(first);
+
+                let mut post_case_snapshots = vec![];
+                for case in remaining {
+                    post_case_snapshots.push(self.flow_snapshot());
+                    self.flow_restore(after_subject.clone());
+                    self.add_pattern_constraint(subject, &case.pattern);
+                    self.visit_match_case(case);
+                }
+                for post_clause_state in post_case_snapshots {
+                    self.flow_merge(post_clause_state);
+                }
+                if !cases
+                    .last()
+                    .is_some_and(|case| case.guard.is_none() && case.pattern.is_wildcard())
+                {
+                    self.flow_merge(after_subject);
+                }
+            }
+            ast::Stmt::Try(ast::StmtTry {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+                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![];
+
+                // 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);
+                    }
+
+                    let pre_except_state = self.flow_snapshot();
+                    let num_handlers = handlers.len();
+
+                    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());
+                        }
+                    }
+
+                    // 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(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);
             }
             _ => {
                 walk_stmt(self, stmt);
@@ -613,30 +906,32 @@ where
 
         match expr {
             ast::Expr::Name(name_node @ ast::ExprName { id, ctx, .. }) => {
-                let mut flags = match ctx {
-                    ast::ExprContext::Load => SymbolFlags::IS_USED,
-                    ast::ExprContext::Store => SymbolFlags::IS_DEFINED,
-                    ast::ExprContext::Del => SymbolFlags::IS_DEFINED,
-                    ast::ExprContext::Invalid => SymbolFlags::empty(),
+                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)
+                    }
+                    (ast::ExprContext::Load, _) => (true, false),
+                    (ast::ExprContext::Store, _) => (false, true),
+                    (ast::ExprContext::Del, _) => (false, true),
+                    (ast::ExprContext::Invalid, _) => (false, false),
                 };
-                if matches!(
-                    self.current_assignment,
-                    Some(CurrentAssignment::AugAssign(_))
-                ) && !ctx.is_invalid()
-                {
-                    // For augmented assignment, the target expression is also used, so we should
-                    // record that as a use.
-                    flags |= SymbolFlags::IS_USED;
-                }
-                let symbol = self.add_or_update_symbol(id.clone(), flags);
-                if flags.contains(SymbolFlags::IS_DEFINED) {
-                    match self.current_assignment {
-                        Some(CurrentAssignment::Assign(assignment)) => {
+                let symbol = self.add_symbol(id.clone());
+
+                if is_definition {
+                    match self.current_assignment().copied() {
+                        Some(CurrentAssignment::Assign {
+                            assignment,
+                            target_index,
+                            kind,
+                        }) => {
                             self.add_definition(
                                 symbol,
                                 AssignmentDefinitionNodeRef {
                                     assignment,
-                                    target: name_node,
+                                    target_index,
+                                    name: name_node,
+                                    kind,
                                 },
                             );
                         }
@@ -652,6 +947,7 @@ where
                                 ForStmtDefinitionNodeRef {
                                     iterable: &node.iter,
                                     target: name_node,
+                                    is_async: node.is_async,
                                 },
                             );
                         }
@@ -664,7 +960,12 @@ where
                         Some(CurrentAssignment::Comprehension { node, first }) => {
                             self.add_definition(
                                 symbol,
-                                ComprehensionDefinitionNodeRef { node, first },
+                                ComprehensionDefinitionNodeRef {
+                                    iterable: &node.iter,
+                                    target: name_node,
+                                    first,
+                                    is_async: node.is_async,
+                                },
                             );
                         }
                         Some(CurrentAssignment::WithItem(with_item)) => {
@@ -680,7 +981,8 @@ where
                     }
                 }
 
-                if flags.contains(SymbolFlags::IS_USED) {
+                if is_use {
+                    self.mark_symbol_used(symbol);
                     let use_id = self.current_ast_ids().record_use(expr);
                     self.current_use_def_map_mut().record_use(symbol, use_id);
                 }
@@ -688,12 +990,11 @@ 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.current_assignment = Some(node.into());
+                self.push_assignment(node.into());
                 self.visit_expr(&node.target);
-                self.current_assignment = None;
+                self.pop_assignment();
             }
             ast::Expr::Lambda(lambda) => {
                 if let Some(parameters) = &lambda.parameters {
@@ -717,6 +1018,7 @@ where
                 }
 
                 self.visit_expr(lambda.body.as_ref());
+                self.pop_scope();
             }
             ast::Expr::If(ast::ExprIf {
                 body, test, orelse, ..
@@ -737,30 +1039,33 @@ where
                     elt, generators, ..
                 },
             ) => {
-                self.visit_generators(
+                self.with_generators_scope(
                     NodeWithScopeRef::ListComprehension(list_comprehension),
                     generators,
+                    |builder| builder.visit_expr(elt),
                 );
-                self.visit_expr(elt);
             }
             ast::Expr::SetComp(
                 set_comprehension @ ast::ExprSetComp {
                     elt, generators, ..
                 },
             ) => {
-                self.visit_generators(
+                self.with_generators_scope(
                     NodeWithScopeRef::SetComprehension(set_comprehension),
                     generators,
+                    |builder| builder.visit_expr(elt),
                 );
-                self.visit_expr(elt);
             }
             ast::Expr::Generator(
                 generator @ ast::ExprGenerator {
                     elt, generators, ..
                 },
             ) => {
-                self.visit_generators(NodeWithScopeRef::GeneratorExpression(generator), generators);
-                self.visit_expr(elt);
+                self.with_generators_scope(
+                    NodeWithScopeRef::GeneratorExpression(generator),
+                    generators,
+                    |builder| builder.visit_expr(elt),
+                );
             }
             ast::Expr::DictComp(
                 dict_comprehension @ ast::ExprDictComp {
@@ -770,31 +1075,22 @@ where
                     ..
                 },
             ) => {
-                self.visit_generators(
+                self.with_generators_scope(
                     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 ruff_python_ast::Parameters) {
+    fn visit_parameters(&mut self, parameters: &'ast ast::Parameters) {
         // Intentionally avoid walking default expressions, as we handle them in the enclosing
         // scope.
         for parameter in parameters.iter().map(ast::AnyParameterRef::as_parameter) {
@@ -802,29 +1098,68 @@ where
         }
     }
 
+    fn visit_match_case(&mut self, match_case: &'ast ast::MatchCase) {
+        debug_assert!(self.current_match_case.is_none());
+        self.current_match_case = Some(CurrentMatchCase::new(&match_case.pattern));
+        self.visit_pattern(&match_case.pattern);
+        self.current_match_case = None;
+
+        if let Some(expr) = &match_case.guard {
+            self.visit_expr(expr);
+        }
+        self.visit_body(&match_case.body);
+    }
+
     fn visit_pattern(&mut self, pattern: &'ast ast::Pattern) {
-        if let ast::Pattern::MatchAs(ast::PatternMatchAs {
-            name: Some(name), ..
-        })
-        | ast::Pattern::MatchStar(ast::PatternMatchStar {
+        if let ast::Pattern::MatchStar(ast::PatternMatchStar {
             name: Some(name),
             range: _,
+        }) = pattern
+        {
+            let symbol = self.add_symbol(name.id().clone());
+            let state = self.current_match_case.as_ref().unwrap();
+            self.add_definition(
+                symbol,
+                MatchPatternDefinitionNodeRef {
+                    pattern: state.pattern,
+                    identifier: name,
+                    index: state.index,
+                },
+            );
+        }
+
+        walk_pattern(self, pattern);
+
+        if let ast::Pattern::MatchAs(ast::PatternMatchAs {
+            name: Some(name), ..
         })
         | ast::Pattern::MatchMapping(ast::PatternMatchMapping {
             rest: Some(name), ..
         }) = pattern
         {
-            // TODO(dhruvmanila): Add definition
-            self.add_or_update_symbol(name.id.clone(), SymbolFlags::IS_DEFINED);
+            let symbol = self.add_symbol(name.id().clone());
+            let state = self.current_match_case.as_ref().unwrap();
+            self.add_definition(
+                symbol,
+                MatchPatternDefinitionNodeRef {
+                    pattern: state.pattern,
+                    identifier: name,
+                    index: state.index,
+                },
+            );
         }
 
-        walk_pattern(self, pattern);
+        self.current_match_case.as_mut().unwrap().index += 1;
     }
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 enum CurrentAssignment<'a> {
-    Assign(&'a ast::StmtAssign),
+    Assign {
+        assignment: &'a ast::StmtAssign,
+        target_index: usize,
+        kind: AssignmentKind,
+    },
     AnnAssign(&'a ast::StmtAnnAssign),
     AugAssign(&'a ast::StmtAugAssign),
     For(&'a ast::StmtFor),
@@ -836,12 +1171,6 @@ 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)
@@ -871,3 +1200,27 @@ impl<'a> From<&'a ast::WithItem> for CurrentAssignment<'a> {
         Self::WithItem(value)
     }
 }
+
+struct CurrentMatchCase<'a> {
+    /// The pattern that's part of the current match case.
+    pattern: &'a ast::Pattern,
+
+    /// The index of the sub-pattern that's being currently visited within the pattern.
+    ///
+    /// For example:
+    /// ```py
+    /// match subject:
+    ///     case a as b: ...
+    ///     case [a, b]: ...
+    ///     case a | b: ...
+    /// ```
+    ///
+    /// In all of the above cases, the index would be 0 for `a` and 1 for `b`.
+    index: u32,
+}
+
+impl<'a> CurrentMatchCase<'a> {
+    fn new(pattern: &'a ast::Pattern) -> Self {
+        Self { pattern, index: 0 }
+    }
+}

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

@@ -0,0 +1,102 @@
+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/constraint.rs

@@ -0,0 +1,39 @@
+use ruff_db::files::File;
+use ruff_python_ast as ast;
+
+use crate::ast_node_ref::AstNodeRef;
+use crate::db::Db;
+use crate::semantic_index::expression::Expression;
+use crate::semantic_index::symbol::{FileScopeId, ScopeId};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Constraint<'db> {
+    Expression(Expression<'db>),
+    Pattern(PatternConstraint<'db>),
+}
+
+#[salsa::tracked]
+pub(crate) struct PatternConstraint<'db> {
+    #[id]
+    pub(crate) file: File,
+
+    #[id]
+    pub(crate) file_scope: FileScopeId,
+
+    #[no_eq]
+    #[return_ref]
+    pub(crate) subject: AstNodeRef<ast::Expr>,
+
+    #[no_eq]
+    #[return_ref]
+    pub(crate) pattern: AstNodeRef<ast::Pattern>,
+
+    #[no_eq]
+    count: countme::Count<PatternConstraint<'static>>,
+}
+
+impl<'db> PatternConstraint<'db> {
+    pub(crate) fn scope(self, db: &'db dyn Db) -> ScopeId<'db> {
+        self.file_scope(db).to_scope_id(db, self.file(db))
+    }
+}

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -3,6 +3,7 @@ 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;
@@ -23,7 +24,7 @@ pub struct Definition<'db> {
 
     #[no_eq]
     #[return_ref]
-    pub(crate) node: DefinitionKind,
+    pub(crate) kind: DefinitionKind,
 
     #[no_eq]
     count: countme::Count<Definition<'static>>,
@@ -33,6 +34,26 @@ 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)]
@@ -49,6 +70,8 @@ pub(crate) enum DefinitionNodeRef<'a> {
     Comprehension(ComprehensionDefinitionNodeRef<'a>),
     Parameter(ast::AnyParameterRef<'a>),
     WithItem(WithItemDefinitionNodeRef<'a>),
+    MatchPattern(MatchPatternDefinitionNodeRef<'a>),
+    ExceptHandler(ExceptHandlerDefinitionNodeRef<'a>),
 }
 
 impl<'a> From<&'a ast::StmtFunctionDef> for DefinitionNodeRef<'a> {
@@ -123,6 +146,12 @@ impl<'a> From<ast::AnyParameterRef<'a>> for DefinitionNodeRef<'a> {
     }
 }
 
+impl<'a> From<MatchPatternDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
+    fn from(node: MatchPatternDefinitionNodeRef<'a>) -> Self {
+        Self::MatchPattern(node)
+    }
+}
+
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct ImportFromDefinitionNodeRef<'a> {
     pub(crate) node: &'a ast::StmtImportFrom,
@@ -132,7 +161,9 @@ pub(crate) struct ImportFromDefinitionNodeRef<'a> {
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct AssignmentDefinitionNodeRef<'a> {
     pub(crate) assignment: &'a ast::StmtAssign,
-    pub(crate) target: &'a ast::ExprName,
+    pub(crate) target_index: usize,
+    pub(crate) name: &'a ast::ExprName,
+    pub(crate) kind: AssignmentKind,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -145,12 +176,32 @@ pub(crate) struct WithItemDefinitionNodeRef<'a> {
 pub(crate) struct ForStmtDefinitionNodeRef<'a> {
     pub(crate) iterable: &'a ast::Expr,
     pub(crate) target: &'a ast::ExprName,
+    pub(crate) is_async: bool,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct ExceptHandlerDefinitionNodeRef<'a> {
+    pub(crate) handler: &'a ast::ExceptHandlerExceptHandler,
+    pub(crate) is_star: bool,
 }
 
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct ComprehensionDefinitionNodeRef<'a> {
-    pub(crate) node: &'a ast::Comprehension,
+    pub(crate) iterable: &'a ast::Expr,
+    pub(crate) target: &'a ast::ExprName,
     pub(crate) first: bool,
+    pub(crate) is_async: bool,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct MatchPatternDefinitionNodeRef<'a> {
+    /// The outermost pattern node in which the identifier being defined occurs.
+    pub(crate) pattern: &'a ast::Pattern,
+    /// The identifier being defined.
+    pub(crate) identifier: &'a ast::Identifier,
+    /// The index of the identifier in the pattern when visiting the `pattern` node in evaluation
+    /// order.
+    pub(crate) index: u32,
 }
 
 impl DefinitionNodeRef<'_> {
@@ -175,30 +226,43 @@ impl DefinitionNodeRef<'_> {
             DefinitionNodeRef::NamedExpression(named) => {
                 DefinitionKind::NamedExpression(AstNodeRef::new(parsed, named))
             }
-            DefinitionNodeRef::Assignment(AssignmentDefinitionNodeRef { assignment, target }) => {
-                DefinitionKind::Assignment(AssignmentDefinitionKind {
-                    assignment: AstNodeRef::new(parsed.clone(), assignment),
-                    target: AstNodeRef::new(parsed, target),
-                })
-            }
+            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::AnnotatedAssignment(assign) => {
                 DefinitionKind::AnnotatedAssignment(AstNodeRef::new(parsed, assign))
             }
             DefinitionNodeRef::AugmentedAssignment(augmented_assignment) => {
                 DefinitionKind::AugmentedAssignment(AstNodeRef::new(parsed, augmented_assignment))
             }
-            DefinitionNodeRef::For(ForStmtDefinitionNodeRef { iterable, target }) => {
-                DefinitionKind::For(ForStmtDefinitionKind {
-                    iterable: AstNodeRef::new(parsed.clone(), iterable),
-                    target: AstNodeRef::new(parsed, target),
-                })
-            }
-            DefinitionNodeRef::Comprehension(ComprehensionDefinitionNodeRef { node, first }) => {
-                DefinitionKind::Comprehension(ComprehensionDefinitionKind {
-                    node: AstNodeRef::new(parsed, node),
-                    first,
-                })
-            }
+            DefinitionNodeRef::For(ForStmtDefinitionNodeRef {
+                iterable,
+                target,
+                is_async,
+            }) => DefinitionKind::For(ForStmtDefinitionKind {
+                iterable: AstNodeRef::new(parsed.clone(), iterable),
+                target: AstNodeRef::new(parsed, target),
+                is_async,
+            }),
+            DefinitionNodeRef::Comprehension(ComprehensionDefinitionNodeRef {
+                iterable,
+                target,
+                first,
+                is_async,
+            }) => DefinitionKind::Comprehension(ComprehensionDefinitionKind {
+                iterable: AstNodeRef::new(parsed.clone(), iterable),
+                target: AstNodeRef::new(parsed, target),
+                first,
+                is_async,
+            }),
             DefinitionNodeRef::Parameter(parameter) => match parameter {
                 ast::AnyParameterRef::Variadic(parameter) => {
                     DefinitionKind::Parameter(AstNodeRef::new(parsed, parameter))
@@ -213,6 +277,22 @@ impl DefinitionNodeRef<'_> {
                     target: AstNodeRef::new(parsed, target),
                 })
             }
+            DefinitionNodeRef::MatchPattern(MatchPatternDefinitionNodeRef {
+                pattern,
+                identifier,
+                index,
+            }) => DefinitionKind::MatchPattern(MatchPatternDefinitionKind {
+                pattern: AstNodeRef::new(parsed.clone(), pattern),
+                identifier: AstNodeRef::new(parsed, identifier),
+                index,
+            }),
+            DefinitionNodeRef::ExceptHandler(ExceptHandlerDefinitionNodeRef {
+                handler,
+                is_star,
+            }) => DefinitionKind::ExceptHandler(ExceptHandlerDefinitionKind {
+                handler: AstNodeRef::new(parsed.clone(), handler),
+                is_star,
+            }),
         }
     }
 
@@ -227,24 +307,66 @@ impl DefinitionNodeRef<'_> {
             Self::NamedExpression(node) => node.into(),
             Self::Assignment(AssignmentDefinitionNodeRef {
                 assignment: _,
-                target,
-            }) => target.into(),
+                target_index: _,
+                name,
+                kind: _,
+            }) => name.into(),
             Self::AnnotatedAssignment(node) => node.into(),
             Self::AugmentedAssignment(node) => node.into(),
             Self::For(ForStmtDefinitionNodeRef {
                 iterable: _,
                 target,
+                is_async: _,
             }) => target.into(),
-            Self::Comprehension(ComprehensionDefinitionNodeRef { node, first: _ }) => node.into(),
+            Self::Comprehension(ComprehensionDefinitionNodeRef { target, .. }) => target.into(),
             Self::Parameter(node) => match node {
                 ast::AnyParameterRef::Variadic(parameter) => parameter.into(),
                 ast::AnyParameterRef::NonVariadic(parameter) => parameter.into(),
             },
             Self::WithItem(WithItemDefinitionNodeRef { node: _, target }) => target.into(),
+            Self::MatchPattern(MatchPatternDefinitionNodeRef { identifier, .. }) => {
+                identifier.into()
+            }
+            Self::ExceptHandler(ExceptHandlerDefinitionNodeRef { handler, .. }) => handler.into(),
         }
     }
 }
 
+#[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>),
@@ -260,22 +382,97 @@ pub enum DefinitionKind {
     Parameter(AstNodeRef<ast::Parameter>),
     ParameterWithDefault(AstNodeRef<ast::ParameterWithDefault>),
     WithItem(WithItemDefinitionKind),
+    MatchPattern(MatchPatternDefinitionKind),
+    ExceptHandler(ExceptHandlerDefinitionKind),
+}
+
+impl DefinitionKind {
+    pub(crate) fn category(&self) -> DefinitionCategory {
+        match self {
+            // functions, classes, and imports always bind, and we consider them declarations
+            DefinitionKind::Function(_)
+            | DefinitionKind::Class(_)
+            | DefinitionKind::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::ParameterWithDefault(parameter_with_default) => {
+                if parameter_with_default.parameter.annotation.is_some() {
+                    DefinitionCategory::DeclarationAndBinding
+                } else {
+                    DefinitionCategory::Binding
+                }
+            }
+            // 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,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+#[allow(dead_code)]
+pub struct MatchPatternDefinitionKind {
+    pattern: AstNodeRef<ast::Pattern>,
+    identifier: AstNodeRef<ast::Identifier>,
+    index: u32,
+}
+
+impl MatchPatternDefinitionKind {
+    pub(crate) fn pattern(&self) -> &ast::Pattern {
+        self.pattern.node()
+    }
+
+    pub(crate) fn index(&self) -> u32 {
+        self.index
+    }
 }
 
 #[derive(Clone, Debug)]
 pub struct ComprehensionDefinitionKind {
-    node: AstNodeRef<ast::Comprehension>,
+    iterable: AstNodeRef<ast::Expr>,
+    target: AstNodeRef<ast::ExprName>,
     first: bool,
+    is_async: bool,
 }
 
 impl ComprehensionDefinitionKind {
-    pub(crate) fn node(&self) -> &ast::Comprehension {
-        self.node.node()
+    pub(crate) fn iterable(&self) -> &ast::Expr {
+        self.iterable.node()
+    }
+
+    pub(crate) fn target(&self) -> &ast::ExprName {
+        self.target.node()
     }
 
     pub(crate) fn is_first(&self) -> bool {
         self.first
     }
+
+    pub(crate) fn is_async(&self) -> bool {
+        self.is_async
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -297,17 +494,34 @@ impl ImportFromDefinitionKind {
 #[derive(Clone, Debug)]
 pub struct AssignmentDefinitionKind {
     assignment: AstNodeRef<ast::StmtAssign>,
-    target: AstNodeRef<ast::ExprName>,
+    target_index: usize,
+    name: AstNodeRef<ast::ExprName>,
+    kind: AssignmentKind,
 }
 
 impl AssignmentDefinitionKind {
-    pub(crate) fn assignment(&self) -> &ast::StmtAssign {
-        self.assignment.node()
+    pub(crate) fn value(&self) -> &ast::Expr {
+        &self.assignment.node().value
     }
 
-    pub(crate) fn target(&self) -> &ast::ExprName {
-        self.target.node()
+    pub(crate) fn target(&self) -> &ast::Expr {
+        &self.assignment.node().targets[self.target_index]
     }
+
+    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)]
@@ -330,6 +544,7 @@ impl WithItemDefinitionKind {
 pub struct ForStmtDefinitionKind {
     iterable: AstNodeRef<ast::Expr>,
     target: AstNodeRef<ast::ExprName>,
+    is_async: bool,
 }
 
 impl ForStmtDefinitionKind {
@@ -340,6 +555,30 @@ impl ForStmtDefinitionKind {
     pub(crate) fn target(&self) -> &ast::ExprName {
         self.target.node()
     }
+
+    pub(crate) fn is_async(&self) -> bool {
+        self.is_async
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ExceptHandlerDefinitionKind {
+    handler: AstNodeRef<ast::ExceptHandlerExceptHandler>,
+    is_star: bool,
+}
+
+impl ExceptHandlerDefinitionKind {
+    pub(crate) fn node(&self) -> &ast::ExceptHandlerExceptHandler {
+        self.handler.node()
+    }
+
+    pub(crate) fn handled_exceptions(&self) -> Option<&ast::Expr> {
+        self.node().type_.as_deref()
+    }
+
+    pub(crate) fn is_star(&self) -> bool {
+        self.is_star
+    }
 }
 
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
@@ -393,12 +632,6 @@ impl From<&ast::StmtFor> for DefinitionNodeKey {
     }
 }
 
-impl From<&ast::Comprehension> for DefinitionNodeKey {
-    fn from(node: &ast::Comprehension) -> Self {
-        Self(NodeKey::from_node(node))
-    }
-}
-
 impl From<&ast::Parameter> for DefinitionNodeKey {
     fn from(node: &ast::Parameter) -> Self {
         Self(NodeKey::from_node(node))
@@ -410,3 +643,15 @@ impl From<&ast::ParameterWithDefault> for DefinitionNodeKey {
         Self(NodeKey::from_node(node))
     }
 }
+
+impl From<&ast::Identifier> for DefinitionNodeKey {
+    fn from(identifier: &ast::Identifier) -> Self {
+        Self(NodeKey::from_node(identifier))
+    }
+}
+
+impl From<&ast::ExceptHandlerExceptHandler> for DefinitionNodeKey {
+    fn from(handler: &ast::ExceptHandlerExceptHandler) -> Self {
+        Self(NodeKey::from_node(handler))
+    }
+}

crates/red_knot_python_semantic/src/semantic_index/symbol.rs

@@ -44,16 +44,16 @@ impl Symbol {
     }
 
     /// Is the symbol defined in its containing scope?
-    pub fn is_defined(&self) -> bool {
-        self.flags.contains(SymbolFlags::IS_DEFINED)
+    pub fn is_bound(&self) -> bool {
+        self.flags.contains(SymbolFlags::IS_BOUND)
     }
 }
 
 bitflags! {
     #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-    pub(super) struct SymbolFlags: u8 {
+    struct SymbolFlags: u8 {
         const IS_USED         = 1 << 0;
-        const IS_DEFINED      = 1 << 1;
+        const IS_BOUND      = 1 << 1;
         /// TODO: This flag is not yet set by anything
         const MARKED_GLOBAL   = 1 << 2;
         /// TODO: This flag is not yet set by anything
@@ -149,6 +149,10 @@ impl FileScopeId {
         FileScopeId::from_u32(0)
     }
 
+    pub fn is_global(self) -> bool {
+        self == FileScopeId::global()
+    }
+
     pub fn to_scope_id(self, db: &dyn Db, file: File) -> ScopeId<'_> {
         let index = semantic_index(db, file);
         index.scope_ids_by_scope[self]
@@ -268,11 +272,7 @@ impl SymbolTableBuilder {
         }
     }
 
-    pub(super) fn add_or_update_symbol(
-        &mut self,
-        name: Name,
-        flags: SymbolFlags,
-    ) -> (ScopedSymbolId, bool) {
+    pub(super) fn add_symbol(&mut self, name: Name) -> (ScopedSymbolId, bool) {
         let hash = SymbolTable::hash_name(&name);
         let entry = self
             .table
@@ -281,15 +281,9 @@ impl SymbolTableBuilder {
             .from_hash(hash, |id| self.table.symbols[*id].name() == &name);
 
         match entry {
-            RawEntryMut::Occupied(entry) => {
-                let symbol = &mut self.table.symbols[*entry.key()];
-                symbol.insert_flags(flags);
-
-                (*entry.key(), false)
-            }
+            RawEntryMut::Occupied(entry) => (*entry.key(), false),
             RawEntryMut::Vacant(entry) => {
-                let mut symbol = Symbol::new(name);
-                symbol.insert_flags(flags);
+                let symbol = Symbol::new(name);
 
                 let id = self.table.symbols.push(symbol);
                 entry.insert_with_hasher(hash, id, (), |id| {
@@ -300,6 +294,14 @@ impl SymbolTableBuilder {
         }
     }
 
+    pub(super) fn mark_symbol_bound(&mut self, id: ScopedSymbolId) {
+        self.table.symbols[id].insert_flags(SymbolFlags::IS_BOUND);
+    }
+
+    pub(super) fn mark_symbol_used(&mut self, id: ScopedSymbolId) {
+        self.table.symbols[id].insert_flags(SymbolFlags::IS_USED);
+    }
+
     pub(super) fn finish(mut self) -> SymbolTable {
         self.table.shrink_to_fit();
         self.table

crates/red_knot_python_semantic/src/semantic_index/use_def.rs

@@ -1,5 +1,79 @@
-//! Build a map from each use of a symbol to the definitions visible from that use, and the
-//! type-narrowing constraints that apply to each definition.
+//! First, some terminology:
+//!
+//! * 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
+//!   statements without a right-hand side value; these do not assign any new value to the
+//!   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
+//!   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.
+//!
+//! Annotated assignments with a right-hand side, and annotated function parameters, are both
+//! bindings and declarations.
+//!
+//! We use [`Definition`] as the universal term (and Salsa tracked struct) encompassing both
+//! bindings and declarations. (This sacrifices a bit of type safety in exchange for improved
+//! performance via fewer Salsa tracked structs and queries, since most declarations -- typed
+//! parameters and annotated assignments with RHS -- are both bindings and declarations.)
+//!
+//! 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.
+//!
+//! 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:
+//!
+//! ```python
+//! x = 1 if flag else None
+//! if x is not None:
+//!     use(x)
+//! ```
+//!
+//! For the use of `x` on the third line, the inferred type should be `Literal[1]`. This is based
+//! on the binding on the first line, which assigns the type `Literal[1] | None`, and the narrowing
+//! constraint on the second line, which rules out the type `None`, since control flow must pass
+//! through this constraint to reach the use in question.
+//!
+//! The **declared type** represents the code author's declaration (usually through a type
+//! annotation) that a given variable should not be assigned any type outside the declared type. In
+//! our model, declared types are also control-flow-sensitive; we allow the code author to
+//! explicitly re-declare the same variable with a different type. So for a given binding of a
+//! variable, we will want to ask which declarations of that variable can reach that binding, in
+//! order to determine whether the binding is permitted, or should be a type error. For example:
+//!
+//! ```python
+//! from pathlib import Path
+//! def f(path: str):
+//!     path: Path = Path(path)
+//! ```
+//!
+//! In this function, the initial declared type of `path` is `str`, meaning that the assignment
+//! `path = Path(path)` would be a type error, since it assigns to `path` a value whose type is not
+//! assignable to `str`. This is the purpose of declared types: they prevent accidental assignment
+//! of the wrong type to a variable.
+//!
+//! But in some cases it is useful to "shadow" or "re-declare" a variable with a new type, and we
+//! permit this, as long as it is done with an explicit re-annotation. So `path: Path =
+//! 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.
+//!
+//! 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.
 //!
 //! Let's take this code sample:
 //!
@@ -7,148 +81,157 @@
 //! x = 1
 //! x = 2
 //! y = x
-//! if y is not None:
+//! if flag:
 //!     x = 3
 //! else:
 //!     x = 4
 //! z = x
 //! ```
 //!
-//! In this snippet, we have four definitions of `x` (the statements assigning `1`, `2`, `3`,
-//! and `4` to it), and two uses of `x` (the `y = x` and `z = x` assignments). The first
-//! [`Definition`] of `x` is never visible to any use, because it's immediately replaced by the
-//! second definition, before any use happens. (A linter could thus flag the statement `x = 1`
-//! as likely superfluous.)
+//! In this snippet, we have four bindings of `x` (the statements assigning `1`, `2`, `3`, and `4`
+//! to it), and two uses of `x` (the `y = x` and `z = x` assignments). The first binding of `x`
+//! does not reach any use, because it's immediately replaced by the second binding, before any use
+//! happens. (A linter could thus flag the statement `x = 1` as likely superfluous.)
 //!
-//! The first use of `x` has one definition visible to it: the assignment `x = 2`.
+//! The first use of `x` has one live binding: the assignment `x = 2`.
 //!
 //! Things get a bit more complex when we have branches. We will definitely take either the `if` or
-//! the `else` branch. Thus, the second use of `x` has two definitions visible to it: `x = 3` and
-//! `x = 4`. The `x = 2` definition is no longer visible, because it must be replaced by either `x
-//! = 3` or `x = 4`, no matter which branch was taken. We don't know which branch was taken, so we
-//! must consider both definitions as visible, which means eventually we would (in type inference)
-//! look at these two definitions and infer a type of `Literal[3, 4]` -- the union of `Literal[3]`
-//! and `Literal[4]` -- for the second use of `x`.
+//! the `else` branch. Thus, the second use of `x` has two live bindings: `x = 3` and `x = 4`. The
+//! `x = 2` assignment is no longer visible, because it must be replaced by either `x = 3` or `x =
+//! 4`, no matter which branch was taken. We don't know which branch was taken, so we must consider
+//! both bindings as live, which means eventually we would (in type inference) look at these two
+//! bindings and infer a type of `Literal[3, 4]` -- the union of `Literal[3]` and `Literal[4]` --
+//! for the second use of `x`.
 //!
 //! So that's one question our use-def map needs to answer: given a specific use of a symbol, which
-//! definition(s) is/are visible from that use. In
-//! [`AstIds`](crate::semantic_index::ast_ids::AstIds) we number all uses (that means a `Name` node
-//! with `Load` context) so we have a `ScopedUseId` to efficiently represent each use.
+//! binding(s) can reach that use. In [`AstIds`](crate::semantic_index::ast_ids::AstIds) we number
+//! all uses (that means a `Name` node with `Load` context) so we have a `ScopedUseId` to
+//! efficiently represent each use.
 //!
-//! Another case we need to handle is when a symbol is referenced from a different scope (the most
-//! obvious example of this is an import). We call this "public" use of a symbol. So the other
-//! question we need to be able to answer is, what are the publicly-visible definitions of each
-//! symbol?
-//!
-//! Technically, public use of a symbol could also occur from any point in control flow of the
-//! scope where the symbol is defined (via inline imports and import cycles, in the case of an
-//! import, or via a function call partway through the local scope that ends up using a symbol from
-//! the scope via a global or nonlocal reference.) But modeling this fully accurately requires
-//! whole-program analysis that isn't tractable for an efficient incremental compiler, 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 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 this in the future, in particular for closures, but for now this is where we
-//! start.)
-//!
-//! So this means that the publicly-visible definitions of a symbol are the definitions still
-//! visible at the end of the scope; effectively we have an implicit "use" of every symbol at the
-//! end of the scope.
-//!
-//! 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
 //! x = 1 if flag else None
 //! if x is not None:
-//!     y = x
+//!     use(x)
 //! ```
 //!
-//! At the use of `x` in `y = x`, the visible definition of `x` is `1 if flag else None`, which
-//! would infer as the type `Literal[1] | None`. But the constraint `x is not None` dominates this
-//! use, which means we can rule out the possibility that `x` is `None` here, which should give us
-//! the type `Literal[1]` for this use.
+//! At the use of `x`, the live binding of `x` is `1 if flag else None`, which would infer as the
+//! type `Literal[1] | None`. But the constraint `x is not None` dominates this use, which means we
+//! can rule out the possibility that `x` is `None` here, which should give us the type
+//! `Literal[1]` for this use.
+//!
+//! For declared types, we need to be able to answer the question "given a binding to a symbol,
+//! which declarations of that symbol can reach the binding?" This allows us to emit a diagnostic
+//! if the binding is attempting to bind a value of a type that is not assignable to the declared
+//! type for that symbol, at that point in control flow.
+//!
+//! We also need to know, given a declaration of a symbol, what the inferred type of that symbol is
+//! at that point. This allows us to emit a diagnostic in a case like `x = "foo"; x: int`. The
+//! binding `x = "foo"` occurs before the declaration `x: int`, so according to our
+//! control-flow-sensitive interpretation of declarations, the assignment is not an error. But the
+//! declaration is an error, since it would violate the "inferred type must be assignable to
+//! declared type" rule.
+//!
+//! Another case we need to handle is when a symbol is referenced from a different scope (for
+//! example, an import or a nonlocal reference). We call this "public" use of a symbol. For public
+//! use of a symbol, we prefer the declared type, if there are any declarations of that symbol; if
+//! not, we fall back to the inferred type. So we also need to know which declarations and bindings
+//! can reach the end of the scope.
+//!
+//! Technically, public use of a symbol could occur from any point in control flow of the scope
+//! where the symbol is defined (via inline imports and import cycles, in the case of an import, or
+//! via a function call partway through the local scope that ends up using a symbol from the scope
+//! 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
+//! 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
+//! this in the future for some closures, but for now this is where we start.)
 //!
 //! The data structure we build to answer these questions is the `UseDefMap`. It has a
-//! `definitions_by_use` vector indexed by [`ScopedUseId`] and a `public_definitions` vector
-//! indexed by [`ScopedSymbolId`]. The values in each of these vectors are (in principle) a list of
-//! visible definitions at that use, or at the end of the scope for that symbol, with a list of the
-//! dominating constraints for each of those definitions.
+//! `bindings_by_use` vector of [`SymbolBindings`] indexed by [`ScopedUseId`], a
+//! `declarations_by_binding` vector of [`SymbolDeclarations`] indexed by [`ScopedDefinitionId`], a
+//! `bindings_by_declaration` vector of [`SymbolBindings`] indexed by [`ScopedDefinitionId`], and
+//! `public_bindings` and `public_definitions` vectors indexed by [`ScopedSymbolId`]. The values in
+//! each of these vectors are (in principle) a list of live bindings at that use/definition, or at
+//! the end of the scope for that symbol, with a list of the dominating constraints for each
+//! binding.
 //!
 //! In order to avoid vectors-of-vectors-of-vectors and all the allocations that would entail, we
 //! don't actually store these "list of visible definitions" as a vector of [`Definition`].
-//! Instead, the values in `definitions_by_use` and `public_definitions` are a [`SymbolState`]
-//! struct which uses bit-sets to track definitions and constraints in terms of
-//! [`ScopedDefinitionId`] and [`ScopedConstraintId`], which are indices into the `all_definitions`
-//! and `all_constraints` indexvecs in the [`UseDefMap`].
+//! Instead, [`SymbolBindings`] and [`SymbolDeclarations`] are structs which use bit-sets to track
+//! definitions (and constraints, in the case of bindings) in terms of [`ScopedDefinitionId`] and
+//! [`ScopedConstraintId`], which are indices into the `all_definitions` and `all_constraints`
+//! indexvecs in the [`UseDefMap`].
 //!
 //! There is another special kind of possible "definition" for a symbol: there might be a path from
 //! the scope entry to a given use in which the symbol is never bound.
 //!
-//! The simplest way to model "unbound" would be as an actual [`Definition`] itself: the initial
-//! visible [`Definition`] for each symbol in a scope. But actually modeling it this way would
-//! unnecessarily increase the number of [`Definition`] that Salsa must track. Since "unbound" is a
-//! special definition 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 [`SymbolState`] struct. If this flag is `true`, it means the
-//! symbol/use really has one additional visible "definition", which is the unbound state. If this
-//! flag is `false`, it means we've eliminated the possibility of unbound: every path we've
-//! followed includes a definition for this symbol.
+//! 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
+//! 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
+//! has a path to the use in which it is never bound. If this flag is `false`, it means we've
+//! eliminated the possibility of unbound: every control flow path to the use includes a binding
+//! for this symbol.
 //!
 //! To build a [`UseDefMap`], the [`UseDefMapBuilder`] is notified of each new use, definition, and
 //! constraint as they are encountered by the
 //! [`SemanticIndexBuilder`](crate::semantic_index::builder::SemanticIndexBuilder) AST visit. For
-//! each symbol, the builder tracks the `SymbolState` for that symbol. When we hit a use of a
-//! symbol, it records the current state for that symbol for that use. When we reach the end of the
-//! scope, it records the state for each symbol as the public definitions of that symbol.
+//! each symbol, the builder tracks the `SymbolState` (`SymbolBindings` and `SymbolDeclarations`)
+//! for that symbol. When we hit a use or definition of a symbol, we record the necessary parts of
+//! the current state for that symbol that we need for that use or definition. When we reach the
+//! end of the scope, it records the state for each symbol as the public definitions of that
+//! symbol.
 //!
-//! Let's walk through the above example. Initially we record for `x` that it has no visible
-//! definitions, and may be unbound. When we see `x = 1`, we record that as the sole visible
-//! definition of `x`, and flip `may_be_unbound` to `false`. Then we see `x = 2`, and it replaces
-//! `x = 1` as the sole visible definition of `x`. When we get to `y = x`, we record that the
-//! visible definitions for that use of `x` are just the `x = 2` definition.
+//! Let's walk through the above example. Initially we record for `x` that it has no bindings, and
+//! may be unbound. When we see `x = 1`, we record that as the sole live binding of `x`, and flip
+//! `may_be_unbound` to `false`. Then we see `x = 2`, and we replace `x = 1` as the sole live
+//! binding of `x`. When we get to `y = x`, we record that the live bindings for that use of `x`
+//! are just the `x = 2` definition.
 //!
 //! Then we hit the `if` branch. We visit the `test` node (`flag` in this case), since that will
-//! happen regardless. Then we take a pre-branch snapshot of the currently visible definitions for
-//! all symbols, which we'll need later. Then we record `flag` as a possible constraint on the
-//! currently visible definition (`x = 2`), and go ahead and visit the `if` body. When we see `x =
-//! 3`, it replaces `x = 2` (constrained by `flag`) as the sole visible definition of `x`. At the
-//! end of the `if` body, we take another snapshot of the currently-visible definitions; we'll call
-//! this the post-if-body snapshot.
+//! happen regardless. Then we take a pre-branch snapshot of the current state for all symbols,
+//! which we'll need later. Then we record `flag` as a possible constraint on the current binding
+//! (`x = 2`), and go ahead and visit the `if` body. When we see `x = 3`, it replaces `x = 2`
+//! (constrained by `flag`) as the sole live binding of `x`. At the end of the `if` body, we take
+//! another snapshot of the current symbol state; we'll call this the post-if-body snapshot.
 //!
 //! Now we need to visit the `else` clause. The conditions when entering the `else` clause should
 //! be the pre-if conditions; if we are entering the `else` clause, we know that the `if` test
 //! failed and we didn't execute the `if` body. So we first reset the builder to the pre-if state,
-//! using the snapshot we took previously (meaning we now have `x = 2` as the sole visible
-//! definition for `x` again), then visit the `else` clause, where `x = 4` replaces `x = 2` as the
-//! sole visible definition of `x`.
+//! using the snapshot we took previously (meaning we now have `x = 2` as the sole binding for `x`
+//! again), then visit the `else` clause, where `x = 4` replaces `x = 2` as the sole live binding
+//! of `x`.
 //!
 //! Now we reach the end of the if/else, and want to visit the following code. The state here needs
 //! to reflect that we might have gone through the `if` branch, or we might have gone through the
 //! `else` branch, and we don't know which. So we need to "merge" our current builder state
-//! (reflecting the end-of-else state, with `x = 4` as the only visible definition) with our
-//! post-if-body snapshot (which has `x = 3` as the only visible definition). The result of this
-//! merge is that we now have two visible definitions of `x`: `x = 3` and `x = 4`.
+//! (reflecting the end-of-else state, with `x = 4` as the only live binding) with our post-if-body
+//! snapshot (which has `x = 3` as the only live binding). The result of this merge is that we now
+//! have two live bindings of `x`: `x = 3` and `x = 4`.
 //!
 //! The [`UseDefMapBuilder`] itself just exposes methods for taking a snapshot, resetting to a
 //! snapshot, and merging a snapshot into the current state. The logic using these methods lives in
 //! [`SemanticIndexBuilder`](crate::semantic_index::builder::SemanticIndexBuilder), e.g. where it
 //! visits a `StmtIf` node.
-//!
-//! (In the future we may have some other questions we want to answer as well, such as "is this
-//! definition used?", which will require tracking a bit more info in our map, e.g. a "used" bit
-//! for each [`Definition`] which is flipped to true when we record that definition for a use.)
 use self::symbol_state::{
-    ConstraintIdIterator, DefinitionIdWithConstraintsIterator, ScopedConstraintId,
-    ScopedDefinitionId, SymbolState,
+    BindingIdWithConstraintsIterator, ConstraintIdIterator, DeclarationIdIterator,
+    ScopedConstraintId, ScopedDefinitionId, SymbolBindings, SymbolDeclarations, SymbolState,
 };
 use crate::semantic_index::ast_ids::ScopedUseId;
 use crate::semantic_index::definition::Definition;
-use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::ScopedSymbolId;
 use ruff_index::IndexVec;
+use rustc_hash::FxHashMap;
+
+use super::constraint::Constraint;
 
 mod bitset;
 mod symbol_state;
@@ -159,63 +242,135 @@ pub(crate) struct UseDefMap<'db> {
     /// Array of [`Definition`] in this scope.
     all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,
 
-    /// Array of constraints (as [`Expression`]) in this scope.
-    all_constraints: IndexVec<ScopedConstraintId, Expression<'db>>,
+    /// Array of [`Constraint`] in this scope.
+    all_constraints: IndexVec<ScopedConstraintId, Constraint<'db>>,
 
-    /// [`SymbolState`] visible at a [`ScopedUseId`].
-    definitions_by_use: IndexVec<ScopedUseId, SymbolState>,
+    /// [`SymbolBindings`] reaching a [`ScopedUseId`].
+    bindings_by_use: IndexVec<ScopedUseId, SymbolBindings>,
+
+    /// [`SymbolBindings`] or [`SymbolDeclarations`] reaching a given [`Definition`].
+    ///
+    /// If the definition is a binding (only) -- `x = 1` for example -- then we need
+    /// [`SymbolDeclarations`] to know whether this binding is permitted by the live declarations.
+    ///
+    /// If the definition is a declaration (only) -- `x: int` for example -- then we need
+    /// [`SymbolBindings`] to know whether this declaration is consistent with the previously
+    /// inferred type.
+    ///
+    /// If the definition is both a declaration and a binding -- `x: int = 1` for example -- then
+    /// we don't actually need anything here, all we'll need to validate is that our own RHS is a
+    /// valid assignment to our own annotation.
+    definitions_by_definition: FxHashMap<Definition<'db>, SymbolDefinitions>,
 
     /// [`SymbolState`] visible at end of scope for each symbol.
-    public_definitions: IndexVec<ScopedSymbolId, SymbolState>,
+    public_symbols: IndexVec<ScopedSymbolId, SymbolState>,
 }
 
 impl<'db> UseDefMap<'db> {
-    pub(crate) fn use_definitions(
+    pub(crate) fn bindings_at_use(
         &self,
         use_id: ScopedUseId,
-    ) -> DefinitionWithConstraintsIterator<'_, 'db> {
-        DefinitionWithConstraintsIterator {
-            all_definitions: &self.all_definitions,
-            all_constraints: &self.all_constraints,
-            inner: self.definitions_by_use[use_id].visible_definitions(),
-        }
+    ) -> BindingWithConstraintsIterator<'_, 'db> {
+        self.bindings_iterator(&self.bindings_by_use[use_id])
     }
 
     pub(crate) fn use_may_be_unbound(&self, use_id: ScopedUseId) -> bool {
-        self.definitions_by_use[use_id].may_be_unbound()
+        self.bindings_by_use[use_id].may_be_unbound()
     }
 
-    pub(crate) fn public_definitions(
+    pub(crate) fn public_bindings(
         &self,
         symbol: ScopedSymbolId,
-    ) -> DefinitionWithConstraintsIterator<'_, 'db> {
-        DefinitionWithConstraintsIterator {
-            all_definitions: &self.all_definitions,
-            all_constraints: &self.all_constraints,
-            inner: self.public_definitions[symbol].visible_definitions(),
-        }
+    ) -> BindingWithConstraintsIterator<'_, 'db> {
+        self.bindings_iterator(self.public_symbols[symbol].bindings())
     }
 
     pub(crate) fn public_may_be_unbound(&self, symbol: ScopedSymbolId) -> bool {
-        self.public_definitions[symbol].may_be_unbound()
+        self.public_symbols[symbol].may_be_unbound()
+    }
+
+    pub(crate) fn bindings_at_declaration(
+        &self,
+        declaration: Definition<'db>,
+    ) -> BindingWithConstraintsIterator<'_, 'db> {
+        if let SymbolDefinitions::Bindings(bindings) = &self.definitions_by_definition[&declaration]
+        {
+            self.bindings_iterator(bindings)
+        } else {
+            unreachable!("Declaration has non-Bindings in definitions_by_definition");
+        }
+    }
+
+    pub(crate) fn declarations_at_binding(
+        &self,
+        binding: Definition<'db>,
+    ) -> DeclarationsIterator<'_, 'db> {
+        if let SymbolDefinitions::Declarations(declarations) =
+            &self.definitions_by_definition[&binding]
+        {
+            self.declarations_iterator(declarations)
+        } else {
+            unreachable!("Binding has non-Declarations in definitions_by_definition");
+        }
+    }
+
+    pub(crate) fn public_declarations(
+        &self,
+        symbol: ScopedSymbolId,
+    ) -> DeclarationsIterator<'_, 'db> {
+        let declarations = self.public_symbols[symbol].declarations();
+        self.declarations_iterator(declarations)
+    }
+
+    pub(crate) fn has_public_declarations(&self, symbol: ScopedSymbolId) -> bool {
+        !self.public_symbols[symbol].declarations().is_empty()
+    }
+
+    fn bindings_iterator<'a>(
+        &'a self,
+        bindings: &'a SymbolBindings,
+    ) -> BindingWithConstraintsIterator<'a, 'db> {
+        BindingWithConstraintsIterator {
+            all_definitions: &self.all_definitions,
+            all_constraints: &self.all_constraints,
+            inner: bindings.iter(),
+        }
+    }
+
+    fn declarations_iterator<'a>(
+        &'a self,
+        declarations: &'a SymbolDeclarations,
+    ) -> DeclarationsIterator<'a, 'db> {
+        DeclarationsIterator {
+            all_definitions: &self.all_definitions,
+            inner: declarations.iter(),
+            may_be_undeclared: declarations.may_be_undeclared(),
+        }
     }
 }
 
-#[derive(Debug)]
-pub(crate) struct DefinitionWithConstraintsIterator<'map, 'db> {
-    all_definitions: &'map IndexVec<ScopedDefinitionId, Definition<'db>>,
-    all_constraints: &'map IndexVec<ScopedConstraintId, Expression<'db>>,
-    inner: DefinitionIdWithConstraintsIterator<'map>,
+/// Either live bindings or live declarations for a symbol.
+#[derive(Debug, PartialEq, Eq)]
+enum SymbolDefinitions {
+    Bindings(SymbolBindings),
+    Declarations(SymbolDeclarations),
 }
 
-impl<'map, 'db> Iterator for DefinitionWithConstraintsIterator<'map, 'db> {
-    type Item = DefinitionWithConstraints<'map, 'db>;
+#[derive(Debug)]
+pub(crate) struct BindingWithConstraintsIterator<'map, 'db> {
+    all_definitions: &'map IndexVec<ScopedDefinitionId, Definition<'db>>,
+    all_constraints: &'map IndexVec<ScopedConstraintId, Constraint<'db>>,
+    inner: BindingIdWithConstraintsIterator<'map>,
+}
+
+impl<'map, 'db> Iterator for BindingWithConstraintsIterator<'map, 'db> {
+    type Item = BindingWithConstraints<'map, 'db>;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.inner
             .next()
-            .map(|def_id_with_constraints| DefinitionWithConstraints {
-                definition: self.all_definitions[def_id_with_constraints.definition],
+            .map(|def_id_with_constraints| BindingWithConstraints {
+                binding: self.all_definitions[def_id_with_constraints.definition],
                 constraints: ConstraintsIterator {
                     all_constraints: self.all_constraints,
                     constraint_ids: def_id_with_constraints.constraint_ids,
@@ -224,20 +379,20 @@ impl<'map, 'db> Iterator for DefinitionWithConstraintsIterator<'map, 'db> {
     }
 }
 
-impl std::iter::FusedIterator for DefinitionWithConstraintsIterator<'_, '_> {}
+impl std::iter::FusedIterator for BindingWithConstraintsIterator<'_, '_> {}
 
-pub(crate) struct DefinitionWithConstraints<'map, 'db> {
-    pub(crate) definition: Definition<'db>,
+pub(crate) struct BindingWithConstraints<'map, 'db> {
+    pub(crate) binding: Definition<'db>,
     pub(crate) constraints: ConstraintsIterator<'map, 'db>,
 }
 
 pub(crate) struct ConstraintsIterator<'map, 'db> {
-    all_constraints: &'map IndexVec<ScopedConstraintId, Expression<'db>>,
+    all_constraints: &'map IndexVec<ScopedConstraintId, Constraint<'db>>,
     constraint_ids: ConstraintIdIterator<'map>,
 }
 
 impl<'map, 'db> Iterator for ConstraintsIterator<'map, 'db> {
-    type Item = Expression<'db>;
+    type Item = Constraint<'db>;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.constraint_ids
@@ -248,25 +403,50 @@ impl<'map, 'db> Iterator for ConstraintsIterator<'map, 'db> {
 
 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> {
+    type Item = Definition<'db>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next().map(|def_id| self.all_definitions[def_id])
+    }
+}
+
+impl std::iter::FusedIterator for DeclarationsIterator<'_, '_> {}
+
 /// A snapshot of the definitions and constraints state at a particular point in control flow.
 #[derive(Clone, Debug)]
 pub(super) struct FlowSnapshot {
-    definitions_by_symbol: IndexVec<ScopedSymbolId, SymbolState>,
+    symbol_states: IndexVec<ScopedSymbolId, SymbolState>,
 }
 
 #[derive(Debug, Default)]
 pub(super) struct UseDefMapBuilder<'db> {
-    /// Append-only array of [`Definition`]; None is unbound.
+    /// Append-only array of [`Definition`].
     all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,
 
-    /// Append-only array of constraints (as [`Expression`]).
-    all_constraints: IndexVec<ScopedConstraintId, Expression<'db>>,
+    /// Append-only array of [`Constraint`].
+    all_constraints: IndexVec<ScopedConstraintId, Constraint<'db>>,
 
-    /// Visible definitions at each so-far-recorded use.
-    definitions_by_use: IndexVec<ScopedUseId, SymbolState>,
+    /// Live bindings at each so-far-recorded use.
+    bindings_by_use: IndexVec<ScopedUseId, SymbolBindings>,
 
-    /// Currently visible definitions for each symbol.
-    definitions_by_symbol: IndexVec<ScopedSymbolId, SymbolState>,
+    /// Live bindings or declarations for each so-far-recorded definition.
+    definitions_by_definition: FxHashMap<Definition<'db>, SymbolDefinitions>,
+
+    /// Currently live bindings and declarations for each symbol.
+    symbol_states: IndexVec<ScopedSymbolId, SymbolState>,
 }
 
 impl<'db> UseDefMapBuilder<'db> {
@@ -275,86 +455,104 @@ impl<'db> UseDefMapBuilder<'db> {
     }
 
     pub(super) fn add_symbol(&mut self, symbol: ScopedSymbolId) {
-        let new_symbol = self.definitions_by_symbol.push(SymbolState::unbound());
+        let new_symbol = self.symbol_states.push(SymbolState::undefined());
         debug_assert_eq!(symbol, new_symbol);
     }
 
-    pub(super) fn record_definition(
+    pub(super) fn record_binding(&mut self, symbol: ScopedSymbolId, binding: Definition<'db>) {
+        let def_id = self.all_definitions.push(binding);
+        let symbol_state = &mut self.symbol_states[symbol];
+        self.definitions_by_definition.insert(
+            binding,
+            SymbolDefinitions::Declarations(symbol_state.declarations().clone()),
+        );
+        symbol_state.record_binding(def_id);
+    }
+
+    pub(super) fn record_constraint(&mut self, constraint: Constraint<'db>) {
+        let constraint_id = self.all_constraints.push(constraint);
+        for state in &mut self.symbol_states {
+            state.record_constraint(constraint_id);
+        }
+    }
+
+    pub(super) fn record_declaration(
+        &mut self,
+        symbol: ScopedSymbolId,
+        declaration: Definition<'db>,
+    ) {
+        let def_id = self.all_definitions.push(declaration);
+        let symbol_state = &mut self.symbol_states[symbol];
+        self.definitions_by_definition.insert(
+            declaration,
+            SymbolDefinitions::Bindings(symbol_state.bindings().clone()),
+        );
+        symbol_state.record_declaration(def_id);
+    }
+
+    pub(super) fn record_declaration_and_binding(
         &mut self,
         symbol: ScopedSymbolId,
         definition: Definition<'db>,
     ) {
-        // We have a new definition of a symbol; this replaces any previous definitions in this
-        // path.
+        // We don't need to store anything in self.definitions_by_definition.
         let def_id = self.all_definitions.push(definition);
-        self.definitions_by_symbol[symbol] = SymbolState::with(def_id);
-    }
-
-    pub(super) fn record_constraint(&mut self, constraint: Expression<'db>) {
-        let constraint_id = self.all_constraints.push(constraint);
-        for definitions in &mut self.definitions_by_symbol {
-            definitions.add_constraint(constraint_id);
-        }
+        let symbol_state = &mut self.symbol_states[symbol];
+        symbol_state.record_declaration(def_id);
+        symbol_state.record_binding(def_id);
     }
 
     pub(super) fn record_use(&mut self, symbol: ScopedSymbolId, use_id: ScopedUseId) {
-        // We have a use of a symbol; clone the currently visible definitions for that symbol, and
-        // record them as the visible definitions for this use.
+        // We have a use of a symbol; clone the current bindings for that symbol, and record them
+        // as the live bindings for this use.
         let new_use = self
-            .definitions_by_use
-            .push(self.definitions_by_symbol[symbol].clone());
+            .bindings_by_use
+            .push(self.symbol_states[symbol].bindings().clone());
         debug_assert_eq!(use_id, new_use);
     }
 
     /// Take a snapshot of the current visible-symbols state.
     pub(super) fn snapshot(&self) -> FlowSnapshot {
         FlowSnapshot {
-            definitions_by_symbol: self.definitions_by_symbol.clone(),
+            symbol_states: self.symbol_states.clone(),
         }
     }
 
-    /// Restore the current builder visible-definitions state to the given snapshot.
+    /// Restore the current builder symbols state to the given snapshot.
     pub(super) fn restore(&mut self, snapshot: FlowSnapshot) {
-        // We never remove symbols from `definitions_by_symbol` (it's an IndexVec, and the symbol
+        // We never remove symbols from `symbol_states` (it's an IndexVec, and the symbol
         // IDs must line up), so the current number of known symbols must always be equal to or
         // greater than the number of known symbols in a previously-taken snapshot.
-        let num_symbols = self.definitions_by_symbol.len();
-        debug_assert!(num_symbols >= snapshot.definitions_by_symbol.len());
+        let num_symbols = self.symbol_states.len();
+        debug_assert!(num_symbols >= snapshot.symbol_states.len());
 
         // Restore the current visible-definitions state to the given snapshot.
-        self.definitions_by_symbol = snapshot.definitions_by_symbol;
+        self.symbol_states = snapshot.symbol_states;
 
         // If the snapshot we are restoring is missing some symbols we've recorded since, we need
         // to fill them in so the symbol IDs continue to line up. Since they don't exist in the
-        // snapshot, the correct state to fill them in with is "unbound".
-        self.definitions_by_symbol
-            .resize(num_symbols, SymbolState::unbound());
+        // snapshot, the correct state to fill them in with is "undefined".
+        self.symbol_states
+            .resize(num_symbols, SymbolState::undefined());
     }
 
     /// Merge the given snapshot into the current state, reflecting that we might have taken either
-    /// path to get here. The new visible-definitions state for each symbol should include
-    /// definitions from both the prior state and the snapshot.
+    /// path to get here. The new state for each symbol should include definitions from both the
+    /// prior state and the snapshot.
     pub(super) fn merge(&mut self, snapshot: FlowSnapshot) {
-        // The tricky thing about merging two Ranges pointing into `all_definitions` is that if the
-        // two Ranges aren't already adjacent in `all_definitions`, we will have to copy at least
-        // one or the other of the ranges to the end of `all_definitions` so as to make them
-        // adjacent. We can't ever move things around in `all_definitions` because previously
-        // recorded uses may still have ranges pointing to any part of it; all we can do is append.
-        // It's possible we may end up with some old entries in `all_definitions` that nobody is
-        // pointing to, but that's OK.
-
-        // We never remove symbols from `definitions_by_symbol` (it's an IndexVec, and the symbol
+        // We never remove symbols from `symbol_states` (it's an IndexVec, and the symbol
         // IDs must line up), so the current number of known symbols must always be equal to or
         // greater than the number of known symbols in a previously-taken snapshot.
-        debug_assert!(self.definitions_by_symbol.len() >= snapshot.definitions_by_symbol.len());
+        debug_assert!(self.symbol_states.len() >= snapshot.symbol_states.len());
 
-        let mut snapshot_definitions_iter = snapshot.definitions_by_symbol.into_iter();
-        for current in &mut self.definitions_by_symbol {
+        let mut snapshot_definitions_iter = snapshot.symbol_states.into_iter();
+        for current in &mut self.symbol_states {
             if let Some(snapshot) = snapshot_definitions_iter.next() {
                 current.merge(snapshot);
             } else {
-                // Symbol not present in snapshot, so it's unbound from that path.
-                current.add_unbound();
+                // Symbol not present in snapshot, so it's unbound/undeclared from that path.
+                current.set_may_be_unbound();
+                current.set_may_be_undeclared();
             }
         }
     }
@@ -362,14 +560,16 @@ impl<'db> UseDefMapBuilder<'db> {
     pub(super) fn finish(mut self) -> UseDefMap<'db> {
         self.all_definitions.shrink_to_fit();
         self.all_constraints.shrink_to_fit();
-        self.definitions_by_symbol.shrink_to_fit();
-        self.definitions_by_use.shrink_to_fit();
+        self.symbol_states.shrink_to_fit();
+        self.bindings_by_use.shrink_to_fit();
+        self.definitions_by_definition.shrink_to_fit();
 
         UseDefMap {
             all_definitions: self.all_definitions,
             all_constraints: self.all_constraints,
-            definitions_by_use: self.definitions_by_use,
-            public_definitions: self.definitions_by_symbol,
+            bindings_by_use: self.bindings_by_use,
+            public_symbols: self.symbol_states,
+            definitions_by_definition: self.definitions_by_definition,
         }
     }
 }

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

@@ -32,17 +32,25 @@ impl<const B: usize> BitSet<B> {
         bitset
     }
 
+    pub(super) fn is_empty(&self) -> bool {
+        self.blocks().iter().all(|&b| b == 0)
+    }
+
     /// Convert from Inline to Heap, if needed, and resize the Heap vector, if needed.
     fn resize(&mut self, value: u32) {
         let num_blocks_needed = (value / 64) + 1;
+        self.resize_blocks(num_blocks_needed as usize);
+    }
+
+    fn resize_blocks(&mut self, num_blocks_needed: usize) {
         match self {
             Self::Inline(blocks) => {
                 let mut vec = blocks.to_vec();
-                vec.resize(num_blocks_needed as usize, 0);
+                vec.resize(num_blocks_needed, 0);
                 *self = Self::Heap(vec);
             }
             Self::Heap(vec) => {
-                vec.resize(num_blocks_needed as usize, 0);
+                vec.resize(num_blocks_needed, 0);
             }
         }
     }
@@ -89,6 +97,19 @@ impl<const B: usize> BitSet<B> {
         }
     }
 
+    /// Union in-place with another [`BitSet`].
+    pub(super) fn union(&mut self, other: &BitSet<B>) {
+        let mut max_len = self.blocks().len();
+        let other_len = other.blocks().len();
+        if other_len > max_len {
+            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;
+        }
+    }
+
     /// Return an iterator over the values (in ascending order) in this [`BitSet`].
     pub(super) fn iter(&self) -> BitSetIterator<'_, B> {
         let blocks = self.blocks();
@@ -218,6 +239,59 @@ mod tests {
         assert_bitset(&b1, &[89]);
     }
 
+    #[test]
+    fn union() {
+        let mut b1 = BitSet::<1>::with(2);
+        let b2 = BitSet::<1>::with(4);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[2, 4]);
+    }
+
+    #[test]
+    fn union_mixed_1() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(89);
+        b2.insert(5);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 5, 89]);
+    }
+
+    #[test]
+    fn union_mixed_2() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(23);
+        b2.insert(89);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 23, 89]);
+    }
+
+    #[test]
+    fn union_heap() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(89);
+        b2.insert(90);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[4, 89, 90]);
+    }
+
+    #[test]
+    fn union_heap_2() {
+        let mut b1 = BitSet::<1>::with(89);
+        let mut b2 = BitSet::<1>::with(89);
+        b1.insert(91);
+        b2.insert(90);
+
+        b1.union(&b2);
+        assert_bitset(&b1, &[89, 90, 91]);
+    }
+
     #[test]
     fn multiple_blocks() {
         let mut b = BitSet::<2>::with(120);
@@ -225,4 +299,11 @@ mod tests {
         assert!(matches!(b, BitSet::Inline(_)));
         assert_bitset(&b, &[45, 120]);
     }
+
+    #[test]
+    fn empty() {
+        let b = BitSet::<1>::default();
+
+        assert!(b.is_empty());
+    }
 }

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

@@ -1,13 +1,13 @@
-//! Track visible definitions of a symbol, and applicable constraints per definition.
+//! Track live bindings per symbol, applicable constraints per binding, and live declarations.
 //!
 //! 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 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:
+//! 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:
 //!
 //! ```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
-//! definition of `x`, not the second, so `None` is a possible value for `x`.
+//! binding of `x`, not the second, so `None` is a possible value for `x`.
 //!
-//! 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:
+//! 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:
 //!
 //! ```python
 //! x = 0
@@ -33,13 +33,16 @@
 //! ```
 //!
 //! 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` definition, so we have to keep
+//! dominates, but it does dominate the `x = 1 if flag2 else None` binding, 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 definitions and constraints when
-//! needed.
+//! 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.
 use super::bitset::{BitSet, BitSetIterator};
 use ruff_index::newtype_index;
 use smallvec::SmallVec;
@@ -53,93 +56,200 @@ pub(super) struct ScopedDefinitionId;
 pub(super) struct ScopedConstraintId;
 
 /// Can reference this * 64 total definitions inline; more will fall back to the heap.
-const INLINE_DEFINITION_BLOCKS: usize = 3;
+const INLINE_BINDING_BLOCKS: usize = 3;
 
-/// A [`BitSet`] of [`ScopedDefinitionId`], representing visible definitions of a symbol in a scope.
-type Definitions = BitSet<INLINE_DEFINITION_BLOCKS>;
-type DefinitionsIterator<'a> = BitSetIterator<'a, INLINE_DEFINITION_BLOCKS>;
+/// A [`BitSet`] of [`ScopedDefinitionId`], representing live bindings of a symbol in a scope.
+type Bindings = BitSet<INLINE_BINDING_BLOCKS>;
+type BindingsIterator<'a> = BitSetIterator<'a, INLINE_BINDING_BLOCKS>;
+
+/// Can reference this * 64 total declarations inline; more will fall back to the heap.
+const INLINE_DECLARATION_BLOCKS: usize = 3;
+
+/// A [`BitSet`] of [`ScopedDefinitionId`], representing live declarations of a symbol in a scope.
+type Declarations = BitSet<INLINE_DECLARATION_BLOCKS>;
+type DeclarationsIterator<'a> = BitSetIterator<'a, INLINE_DECLARATION_BLOCKS>;
 
 /// Can reference this * 64 total constraints inline; more will fall back to the heap.
 const INLINE_CONSTRAINT_BLOCKS: usize = 2;
 
-/// Can keep inline this many visible definitions per symbol at a given time; more will go to heap.
-const INLINE_VISIBLE_DEFINITIONS_PER_SYMBOL: usize = 4;
+/// Can keep inline this many live bindings per symbol at a given time; more will go to heap.
+const INLINE_BINDINGS_PER_SYMBOL: usize = 4;
 
-/// One [`BitSet`] of applicable [`ScopedConstraintId`] per visible definition.
-type InlineConstraintArray =
-    [BitSet<INLINE_CONSTRAINT_BLOCKS>; INLINE_VISIBLE_DEFINITIONS_PER_SYMBOL];
+/// One [`BitSet`] of applicable [`ScopedConstraintId`] per live binding.
+type InlineConstraintArray = [BitSet<INLINE_CONSTRAINT_BLOCKS>; INLINE_BINDINGS_PER_SYMBOL];
 type Constraints = SmallVec<InlineConstraintArray>;
 type ConstraintsIterator<'a> = std::slice::Iter<'a, BitSet<INLINE_CONSTRAINT_BLOCKS>>;
 type ConstraintsIntoIterator = smallvec::IntoIter<InlineConstraintArray>;
 
-/// Visible definitions and narrowing constraints for a single symbol at some point in control flow.
+/// Live declarations for a single symbol at some point in control flow.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub(super) struct SymbolState {
-    /// [`BitSet`]: which [`ScopedDefinitionId`] are visible for this symbol?
-    visible_definitions: Definitions,
+pub(super) struct SymbolDeclarations {
+    /// [`BitSet`]: which declarations (as [`ScopedDefinitionId`]) can reach the current location?
+    live_declarations: Declarations,
 
-    /// For each definition, which [`ScopedConstraintId`] apply?
+    /// 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.
+    pub(super) fn iter(&self) -> DeclarationIdIterator {
+        DeclarationIdIterator {
+            inner: self.live_declarations.iter(),
+        }
+    }
+
+    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.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) struct SymbolBindings {
+    /// [`BitSet`]: which bindings (as [`ScopedDefinitionId`]) can reach the current location?
+    live_bindings: Bindings,
+
+    /// For each live binding, which [`ScopedConstraintId`] apply?
     ///
     /// This is a [`smallvec::SmallVec`] which should always have one [`BitSet`] of constraints per
-    /// definition in `visible_definitions`.
+    /// binding in `live_bindings`.
     constraints: Constraints,
 
     /// Could the symbol be unbound at this point?
     may_be_unbound: bool,
 }
 
-/// A single [`ScopedDefinitionId`] with an iterator of its applicable [`ScopedConstraintId`].
-#[derive(Debug)]
-pub(super) struct DefinitionIdWithConstraints<'a> {
-    pub(super) definition: ScopedDefinitionId,
-    pub(super) constraint_ids: ConstraintIdIterator<'a>,
-}
-
-impl SymbolState {
-    /// Return a new [`SymbolState`] representing an unbound symbol.
-    pub(super) fn unbound() -> Self {
+impl SymbolBindings {
+    fn unbound() -> Self {
         Self {
-            visible_definitions: Definitions::default(),
+            live_bindings: Bindings::default(),
             constraints: Constraints::default(),
             may_be_unbound: true,
         }
     }
 
-    /// Return a new [`SymbolState`] representing a symbol with a single visible definition.
-    pub(super) fn with(definition_id: ScopedDefinitionId) -> Self {
-        let mut constraints = Constraints::with_capacity(1);
-        constraints.push(BitSet::default());
-        Self {
-            visible_definitions: Definitions::with(definition_id.into()),
-            constraints,
-            may_be_unbound: false,
-        }
-    }
-
     /// Add Unbound as a possibility for this symbol.
-    pub(super) fn add_unbound(&mut self) {
+    fn set_may_be_unbound(&mut self) {
         self.may_be_unbound = true;
     }
 
-    /// Add given constraint to all currently-visible definitions.
-    pub(super) fn add_constraint(&mut self, constraint_id: ScopedConstraintId) {
+    /// Record a newly-encountered binding for this symbol.
+    pub(super) fn record_binding(&mut self, binding_id: ScopedDefinitionId) {
+        // 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());
+        self.may_be_unbound = false;
+    }
+
+    /// Add given constraint to all live bindings.
+    pub(super) fn record_constraint(&mut self, constraint_id: ScopedConstraintId) {
         for bitset in &mut self.constraints {
             bitset.insert(constraint_id.into());
         }
     }
 
+    /// Iterate over currently live bindings for this symbol.
+    pub(super) fn iter(&self) -> BindingIdWithConstraintsIterator {
+        BindingIdWithConstraintsIterator {
+            definitions: self.live_bindings.iter(),
+            constraints: self.constraints.iter(),
+        }
+    }
+
+    pub(super) fn may_be_unbound(&self) -> bool {
+        self.may_be_unbound
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) struct SymbolState {
+    declarations: SymbolDeclarations,
+    bindings: SymbolBindings,
+}
+
+impl SymbolState {
+    /// Return a new [`SymbolState`] representing an unbound, undeclared symbol.
+    pub(super) fn undefined() -> Self {
+        Self {
+            declarations: SymbolDeclarations::undeclared(),
+            bindings: SymbolBindings::unbound(),
+        }
+    }
+
+    /// Add Unbound as a possibility for this symbol.
+    pub(super) fn set_may_be_unbound(&mut self) {
+        self.bindings.set_may_be_unbound();
+    }
+
+    /// Record a newly-encountered binding for this symbol.
+    pub(super) fn record_binding(&mut self, binding_id: ScopedDefinitionId) {
+        self.bindings.record_binding(binding_id);
+    }
+
+    /// Add given constraint to all live bindings.
+    pub(super) fn record_constraint(&mut self, constraint_id: ScopedConstraintId) {
+        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);
+    }
+
     /// Merge another [`SymbolState`] into this one.
     pub(super) fn merge(&mut self, b: SymbolState) {
         let mut a = Self {
-            visible_definitions: Definitions::default(),
-            constraints: Constraints::default(),
-            may_be_unbound: self.may_be_unbound || b.may_be_unbound,
+            bindings: SymbolBindings {
+                live_bindings: Bindings::default(),
+                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,
+            },
         };
+
         std::mem::swap(&mut a, self);
-        let mut a_defs_iter = a.visible_definitions.iter();
-        let mut b_defs_iter = b.visible_definitions.iter();
-        let mut a_constraints_iter = a.constraints.into_iter();
-        let mut b_constraints_iter = b.constraints.into_iter();
+        self.declarations
+            .live_declarations
+            .union(&b.declarations.live_declarations);
+
+        let mut a_defs_iter = a.bindings.live_bindings.iter();
+        let mut b_defs_iter = b.bindings.live_bindings.iter();
+        let mut a_constraints_iter = a.bindings.constraints.into_iter();
+        let mut b_constraints_iter = b.bindings.constraints.into_iter();
 
         let mut opt_a_def: Option<u32> = a_defs_iter.next();
         let mut opt_b_def: Option<u32> = b_defs_iter.next();
@@ -152,7 +262,7 @@ impl SymbolState {
 
         // Helper to push `def`, with constraints in `constraints_iter`, onto `self`.
         let push = |def, constraints_iter: &mut ConstraintsIntoIterator, merged: &mut Self| {
-            merged.visible_definitions.insert(def);
+            merged.bindings.live_bindings.insert(def);
             // SAFETY: we only ever create SymbolState with either no definitions and no constraint
             // bitsets (`::unbound`) or one definition and one constraint bitset (`::with`), and
             // `::merge` always pushes one definition and one constraint bitset together (just
@@ -161,7 +271,7 @@ impl SymbolState {
             let constraints = constraints_iter
                 .next()
                 .expect("definitions and constraints length mismatch");
-            merged.constraints.push(constraints);
+            merged.bindings.constraints.push(constraints);
         };
 
         loop {
@@ -191,7 +301,8 @@ impl SymbolState {
                         // If the same definition is visible through both paths, any constraint
                         // that applies on only one path is irrelevant to the resulting type from
                         // unioning the two paths, so we intersect the constraints.
-                        self.constraints
+                        self.bindings
+                            .constraints
                             .last_mut()
                             .unwrap()
                             .intersect(&a_constraints);
@@ -214,40 +325,49 @@ impl SymbolState {
         }
     }
 
-    /// Get iterator over visible definitions with constraints.
-    pub(super) fn visible_definitions(&self) -> DefinitionIdWithConstraintsIterator {
-        DefinitionIdWithConstraintsIterator {
-            definitions: self.visible_definitions.iter(),
-            constraints: self.constraints.iter(),
-        }
+    pub(super) fn bindings(&self) -> &SymbolBindings {
+        &self.bindings
+    }
+
+    pub(super) fn declarations(&self) -> &SymbolDeclarations {
+        &self.declarations
     }
 
     /// Could the symbol be unbound?
     pub(super) fn may_be_unbound(&self) -> bool {
-        self.may_be_unbound
+        self.bindings.may_be_unbound()
     }
 }
 
-/// The default state of a symbol (if we've seen no definitions of it) is unbound.
+/// The default state of a symbol, if we've seen no definitions of it, is undefined (that is,
+/// both unbound and undeclared).
 impl Default for SymbolState {
     fn default() -> Self {
-        SymbolState::unbound()
+        SymbolState::undefined()
     }
 }
 
+/// A single binding (as [`ScopedDefinitionId`]) with an iterator of its applicable
+/// [`ScopedConstraintId`].
+#[derive(Debug)]
+pub(super) struct BindingIdWithConstraints<'a> {
+    pub(super) definition: ScopedDefinitionId,
+    pub(super) constraint_ids: ConstraintIdIterator<'a>,
+}
+
 #[derive(Debug)]
-pub(super) struct DefinitionIdWithConstraintsIterator<'a> {
-    definitions: DefinitionsIterator<'a>,
+pub(super) struct BindingIdWithConstraintsIterator<'a> {
+    definitions: BindingsIterator<'a>,
     constraints: ConstraintsIterator<'a>,
 }
 
-impl<'a> Iterator for DefinitionIdWithConstraintsIterator<'a> {
-    type Item = DefinitionIdWithConstraints<'a>;
+impl<'a> Iterator for BindingIdWithConstraintsIterator<'a> {
+    type Item = BindingIdWithConstraints<'a>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match (self.definitions.next(), self.constraints.next()) {
             (None, None) => None,
-            (Some(def), Some(constraints)) => Some(DefinitionIdWithConstraints {
+            (Some(def), Some(constraints)) => Some(BindingIdWithConstraints {
                 definition: ScopedDefinitionId::from_u32(def),
                 constraint_ids: ConstraintIdIterator {
                     wrapped: constraints.iter(),
@@ -259,7 +379,7 @@ impl<'a> Iterator for DefinitionIdWithConstraintsIterator<'a> {
     }
 }
 
-impl std::iter::FusedIterator for DefinitionIdWithConstraintsIterator<'_> {}
+impl std::iter::FusedIterator for BindingIdWithConstraintsIterator<'_> {}
 
 #[derive(Debug)]
 pub(super) struct ConstraintIdIterator<'a> {
@@ -276,99 +396,193 @@ impl Iterator for ConstraintIdIterator<'_> {
 
 impl std::iter::FusedIterator for ConstraintIdIterator<'_> {}
 
+#[derive(Debug)]
+pub(super) struct DeclarationIdIterator<'a> {
+    inner: DeclarationsIterator<'a>,
+}
+
+impl<'a> Iterator for DeclarationIdIterator<'a> {
+    type Item = ScopedDefinitionId;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next().map(ScopedDefinitionId::from_u32)
+    }
+}
+
+impl std::iter::FusedIterator for DeclarationIdIterator<'_> {}
+
 #[cfg(test)]
 mod tests {
     use super::{ScopedConstraintId, ScopedDefinitionId, SymbolState};
 
-    impl SymbolState {
-        pub(crate) fn assert(&self, may_be_unbound: bool, expected: &[&str]) {
-            assert_eq!(self.may_be_unbound(), may_be_unbound);
-            let actual = self
-                .visible_definitions()
-                .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);
-        }
+    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);
+    }
+
+    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);
     }
 
     #[test]
     fn unbound() {
-        let cd = SymbolState::unbound();
+        let sym = SymbolState::undefined();
 
-        cd.assert(true, &[]);
+        assert_bindings(&sym, true, &[]);
     }
 
     #[test]
     fn with() {
-        let cd = SymbolState::with(ScopedDefinitionId::from_u32(0));
+        let mut sym = SymbolState::undefined();
+        sym.record_binding(ScopedDefinitionId::from_u32(0));
 
-        cd.assert(false, &["0<>"]);
+        assert_bindings(&sym, false, &["0<>"]);
     }
 
     #[test]
-    fn add_unbound() {
-        let mut cd = SymbolState::with(ScopedDefinitionId::from_u32(0));
-        cd.add_unbound();
+    fn set_may_be_unbound() {
+        let mut sym = SymbolState::undefined();
+        sym.record_binding(ScopedDefinitionId::from_u32(0));
+        sym.set_may_be_unbound();
 
-        cd.assert(true, &["0<>"]);
+        assert_bindings(&sym, true, &["0<>"]);
     }
 
     #[test]
-    fn add_constraint() {
-        let mut cd = SymbolState::with(ScopedDefinitionId::from_u32(0));
-        cd.add_constraint(ScopedConstraintId::from_u32(0));
+    fn record_constraint() {
+        let mut sym = SymbolState::undefined();
+        sym.record_binding(ScopedDefinitionId::from_u32(0));
+        sym.record_constraint(ScopedConstraintId::from_u32(0));
 
-        cd.assert(false, &["0<0>"]);
+        assert_bindings(&sym, false, &["0<0>"]);
     }
 
     #[test]
     fn merge() {
         // merging the same definition with the same constraint keeps the constraint
-        let mut cd0a = SymbolState::with(ScopedDefinitionId::from_u32(0));
-        cd0a.add_constraint(ScopedConstraintId::from_u32(0));
+        let mut sym0a = SymbolState::undefined();
+        sym0a.record_binding(ScopedDefinitionId::from_u32(0));
+        sym0a.record_constraint(ScopedConstraintId::from_u32(0));
 
-        let mut cd0b = SymbolState::with(ScopedDefinitionId::from_u32(0));
-        cd0b.add_constraint(ScopedConstraintId::from_u32(0));
+        let mut sym0b = SymbolState::undefined();
+        sym0b.record_binding(ScopedDefinitionId::from_u32(0));
+        sym0b.record_constraint(ScopedConstraintId::from_u32(0));
 
-        cd0a.merge(cd0b);
-        let mut cd0 = cd0a;
-        cd0.assert(false, &["0<0>"]);
+        sym0a.merge(sym0b);
+        let mut sym0 = sym0a;
+        assert_bindings(&sym0, false, &["0<0>"]);
 
         // merging the same definition with differing constraints drops all constraints
-        let mut cd1a = SymbolState::with(ScopedDefinitionId::from_u32(1));
-        cd1a.add_constraint(ScopedConstraintId::from_u32(1));
+        let mut sym1a = SymbolState::undefined();
+        sym1a.record_binding(ScopedDefinitionId::from_u32(1));
+        sym1a.record_constraint(ScopedConstraintId::from_u32(1));
 
-        let mut cd1b = SymbolState::with(ScopedDefinitionId::from_u32(1));
-        cd1b.add_constraint(ScopedConstraintId::from_u32(2));
+        let mut sym1b = SymbolState::undefined();
+        sym1b.record_binding(ScopedDefinitionId::from_u32(1));
+        sym1b.record_constraint(ScopedConstraintId::from_u32(2));
 
-        cd1a.merge(cd1b);
-        let cd1 = cd1a;
-        cd1.assert(false, &["1<>"]);
+        sym1a.merge(sym1b);
+        let sym1 = sym1a;
+        assert_bindings(&sym1, false, &["1<>"]);
 
         // merging a constrained definition with unbound keeps both
-        let mut cd2a = SymbolState::with(ScopedDefinitionId::from_u32(2));
-        cd2a.add_constraint(ScopedConstraintId::from_u32(3));
+        let mut sym2a = SymbolState::undefined();
+        sym2a.record_binding(ScopedDefinitionId::from_u32(2));
+        sym2a.record_constraint(ScopedConstraintId::from_u32(3));
 
-        let cd2b = SymbolState::unbound();
+        let sym2b = SymbolState::undefined();
 
-        cd2a.merge(cd2b);
-        let cd2 = cd2a;
-        cd2.assert(true, &["2<3>"]);
+        sym2a.merge(sym2b);
+        let sym2 = sym2a;
+        assert_bindings(&sym2, true, &["2<3>"]);
 
         // merging different definitions keeps them each with their existing constraints
-        cd0.merge(cd2);
-        let cd = cd0;
-        cd.assert(true, &["0<0>", "2<3>"]);
+        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, &[]);
+    }
+
+    #[test]
+    fn record_declaration() {
+        let mut sym = SymbolState::undefined();
+        sym.record_declaration(ScopedDefinitionId::from_u32(1));
+
+        assert_declarations(&sym, false, &[1]);
+    }
+
+    #[test]
+    fn record_declaration_override() {
+        let mut sym = SymbolState::undefined();
+        sym.record_declaration(ScopedDefinitionId::from_u32(1));
+        sym.record_declaration(ScopedDefinitionId::from_u32(2));
+
+        assert_declarations(&sym, false, &[2]);
+    }
+
+    #[test]
+    fn record_declaration_merge() {
+        let mut sym = SymbolState::undefined();
+        sym.record_declaration(ScopedDefinitionId::from_u32(1));
+
+        let mut sym2 = SymbolState::undefined();
+        sym2.record_declaration(ScopedDefinitionId::from_u32(2));
+
+        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]);
     }
 }

crates/red_knot_python_semantic/src/semantic_model.rs

@@ -8,7 +8,7 @@ use crate::module_name::ModuleName;
 use crate::module_resolver::{resolve_module, Module};
 use crate::semantic_index::ast_ids::HasScopedAstId;
 use crate::semantic_index::semantic_index;
-use crate::types::{definition_ty, global_symbol_ty_by_name, infer_scope_types, Type};
+use crate::types::{binding_ty, global_symbol_ty, infer_scope_types, Type};
 use crate::Db;
 
 pub struct SemanticModel<'db> {
@@ -35,12 +35,12 @@ 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)
     }
 
     pub fn global_symbol_ty(&self, module: &Module, symbol_name: &str) -> Type<'db> {
-        global_symbol_ty_by_name(self.db, module.file(), symbol_name)
+        global_symbol_ty(self.db, module.file(), symbol_name)
     }
 }
 
@@ -147,24 +147,24 @@ impl HasTy for ast::Expr {
     }
 }
 
-macro_rules! impl_definition_has_ty {
+macro_rules! impl_binding_has_ty {
     ($ty: ty) => {
         impl HasTy for $ty {
             #[inline]
             fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
                 let index = semantic_index(model.db, model.file);
-                let definition = index.definition(self);
-                definition_ty(model.db, definition)
+                let binding = index.definition(self);
+                binding_ty(model.db, binding)
             }
         }
     };
 }
 
-impl_definition_has_ty!(ast::StmtFunctionDef);
-impl_definition_has_ty!(ast::StmtClassDef);
-impl_definition_has_ty!(ast::Alias);
-impl_definition_has_ty!(ast::Parameter);
-impl_definition_has_ty!(ast::ParameterWithDefault);
+impl_binding_has_ty!(ast::StmtFunctionDef);
+impl_binding_has_ty!(ast::StmtClassDef);
+impl_binding_has_ty!(ast::Alias);
+impl_binding_has_ty!(ast::Parameter);
+impl_binding_has_ty!(ast::ParameterWithDefault);
 
 #[cfg(test)]
 mod tests {