Offset syntax error for each cell

2024-05-17 13:36:21 +05:30
1357 changed files with 16986 additions and 44690 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,10 +1,3 @@
 [alias]
 dev = "run --package ruff_dev --bin ruff_dev"
 benchmark = "bench -p ruff_benchmark --bench linter --bench formatter --"
-
-# statically link the C runtime so the executable does not depend on
-# that shared/dynamic library.
-#
-# See: https://github.com/astral-sh/ruff/issues/11503
-[target.'cfg(all(target_env="msvc", target_os = "windows"))']
-rustflags = ["-C", "target-feature=+crt-static"]
--- a/.gitattributes
+++ b/.gitattributes
@@ -8,10 +8,6 @@ crates/ruff_linter/resources/test/fixtures/pycodestyle/W391_3.py text eol=crlf
 crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples_crlf.py text eol=crlf
 crates/ruff_python_formatter/tests/snapshots/format@docstring_code_examples_crlf.py.snap text eol=crlf

-crates/ruff_python_parser/resources/invalid/re_lexing/line_continuation_windows_eol.py text eol=crlf
-crates/ruff_python_parser/resources/invalid/re_lex_logical_token_windows_eol.py text eol=crlf
-crates/ruff_python_parser/resources/invalid/re_lex_logical_token_mac_eol.py text eol=cr
-
 crates/ruff_python_parser/resources/inline linguist-generated=true

 ruff.schema.json linguist-generated=true text=auto eol=lf
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -15,6 +15,3 @@

 # Script for fuzzing the parser
 /scripts/fuzz-parser/ @AlexWaygood
-
-# red-knot
-/crates/red_knot/ @carljm @MichaReiser
--- a/.github/renovate.json5
+++ b/.github/renovate.json5
@@ -41,13 +41,6 @@
      description: "Disable PRs updating GitHub runners (e.g. 'runs-on: macos-14')",
      enabled: false,
    },
-    {
-      // Disable updates of `zip-rs`; intentionally pinned for now due to ownership change
-      // See: https://github.com/astral-sh/uv/issues/3642
-      matchPackagePatterns: ["zip"],
-      matchManagers: ["cargo"],
-      enabled: false,
-    },
    {
      groupName: "pre-commit dependencies",
      matchManagers: ["pre-commit"],
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -167,9 +167,6 @@ jobs:
      - uses: Swatinem/rust-cache@v2
      - name: "Run tests"
        shell: bash
-        env:
-          # Workaround for <https://github.com/nextest-rs/nextest/issues/1493>.
-          RUSTUP_WINDOWS_PATH_ADD_BIN: 1
        run: |
          cargo nextest run --all-features --profile ci
          cargo test --all-features --doc
@@ -212,38 +209,6 @@ jobs:
      - name: "Build"
        run: cargo build --release --locked

-  cargo-build-msrv:
-    name: "cargo build (msrv)"
-    runs-on: ubuntu-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
-    timeout-minutes: 20
-    steps:
-      - uses: actions/checkout@v4
-      - uses: SebRollen/toml-action@v1.2.0
-        id: msrv
-        with:
-          file: "Cargo.toml"
-          field: "workspace.package.rust-version"
-      - name: "Install Rust toolchain"
-        run: rustup default ${{ steps.msrv.outputs.value }}
-      - name: "Install mold"
-        uses: rui314/setup-mold@v1
-      - name: "Install cargo nextest"
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-nextest
-      - name: "Install cargo insta"
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-insta
-      - uses: Swatinem/rust-cache@v2
-      - name: "Run tests"
-        shell: bash
-        env:
-          NEXTEST_PROFILE: "ci"
-        run: cargo +${{ steps.msrv.outputs.value }} insta test --all-features --unreferenced reject --test-runner nextest
-
  cargo-fuzz:
    name: "cargo fuzz"
    runs-on: ubuntu-latest
@@ -257,13 +222,10 @@ jobs:
      - uses: Swatinem/rust-cache@v2
        with:
          workspaces: "fuzz -> target"
-      - name: "Install cargo-binstall"
-        uses: cargo-bins/cargo-binstall@main
+      - name: "Install cargo-fuzz"
+        uses: taiki-e/install-action@v2
        with:
          tool: cargo-fuzz@0.11.2
-      - name: "Install cargo-fuzz"
-        # Download the latest version from quick install and not the github releases because github releases only has MUSL targets.
-        run: cargo binstall cargo-fuzz --force  --disable-strategies crate-meta-data --no-confirm
      - run: cargo fuzz build -s none

  fuzz-parser:
@@ -341,7 +303,7 @@ jobs:
          name: ruff
          path: target/debug

-      - uses: dawidd6/action-download-artifact@v6
+      - uses: dawidd6/action-download-artifact@v3
        name: Download baseline Ruff binary
        with:
          name: ruff
--- a/.github/workflows/docs.yaml
+++ b/.github/workflows/docs.yaml
@@ -47,7 +47,7 @@ jobs:
        run: mkdocs build --strict -f mkdocs.public.yml
      - name: "Deploy to Cloudflare Pages"
        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.6.1
+        uses: cloudflare/wrangler-action@v3.5.0
        with:
          apiToken: ${{ secrets.CF_API_TOKEN }}
          accountId: ${{ secrets.CF_ACCOUNT_ID }}
--- a/.github/workflows/playground.yaml
+++ b/.github/workflows/playground.yaml
@@ -40,7 +40,7 @@ jobs:
        working-directory: playground
      - name: "Deploy to Cloudflare Pages"
        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.6.1
+        uses: cloudflare/wrangler-action@v3.5.0
        with:
          apiToken: ${{ secrets.CF_API_TOKEN }}
          accountId: ${{ secrets.CF_ACCOUNT_ID }}
--- a/.github/workflows/pr-comment.yaml
+++ b/.github/workflows/pr-comment.yaml
@@ -17,7 +17,7 @@ jobs:
  comment:
    runs-on: ubuntu-latest
    steps:
-      - uses: dawidd6/action-download-artifact@v6
+      - uses: dawidd6/action-download-artifact@v3
        name: Download pull request number
        with:
          name: pr-number
@@ -32,7 +32,7 @@ jobs:
            echo "pr-number=$(<pr-number)" >> $GITHUB_OUTPUT
          fi

-      - uses: dawidd6/action-download-artifact@v6
+      - uses: dawidd6/action-download-artifact@v3
        name: "Download ecosystem results"
        id: download-ecosystem-result
        if: steps.pr-number.outputs.pr-number
@@ -48,14 +48,6 @@ jobs:
        id: generate-comment
        if: steps.download-ecosystem-result.outputs.found_artifact == 'true'
        run: |
-          # Guard against malicious ecosystem results that symlink to a secret
-          # file on this runner
-          if [[ -L pr/ecosystem/ecosystem-result ]]
-          then
-              echo "Error: ecosystem-result cannot be a symlink"
-              exit 1
-          fi
-
          # Note this identifier is used to find the comment to update on
          # subsequent runs
          echo '<!-- generated-comment ecosystem -->' >> comment.txt
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -163,9 +163,6 @@ jobs:
        with:
          target: ${{ matrix.platform.target }}
          args: --release --locked --out dist
-        env:
-          # aarch64 build fails, see https://github.com/PyO3/maturin/issues/2110
-          XWIN_VERSION: 16
      - name: "Test wheel"
        if: ${{ !startsWith(matrix.platform.target, 'aarch64') }}
        shell: bash
@@ -572,7 +569,7 @@ jobs:
          fi

      - name: "Build and push Docker image"
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v5
        with:
          context: .
          platforms: linux/amd64,linux/arm64
--- a/.github/workflows/sync_typeshed.yaml
+++ b/.github/workflows/sync_typeshed.yaml
@@ -37,13 +37,13 @@ jobs:
      - name: Sync typeshed
        id: sync
        run: |
-          rm -rf ruff/crates/red_knot_module_resolver/vendor/typeshed
-          mkdir ruff/crates/red_knot_module_resolver/vendor/typeshed
-          cp typeshed/README.md ruff/crates/red_knot_module_resolver/vendor/typeshed
-          cp typeshed/LICENSE ruff/crates/red_knot_module_resolver/vendor/typeshed
-          cp -r typeshed/stdlib ruff/crates/red_knot_module_resolver/vendor/typeshed/stdlib
-          rm -rf ruff/crates/red_knot_module_resolver/vendor/typeshed/stdlib/@tests
-          git -C typeshed rev-parse HEAD > ruff/crates/red_knot_module_resolver/vendor/typeshed/source_commit.txt
+          rm -rf ruff/crates/red_knot/vendor/typeshed
+          mkdir ruff/crates/red_knot/vendor/typeshed
+          cp typeshed/README.md ruff/crates/red_knot/vendor/typeshed
+          cp typeshed/LICENSE ruff/crates/red_knot/vendor/typeshed
+          cp -r typeshed/stdlib ruff/crates/red_knot/vendor/typeshed/stdlib
+          rm -rf ruff/crates/red_knot/vendor/typeshed/stdlib/@tests
+          git -C typeshed rev-parse HEAD > ruff/crates/red_knot/vendor/typeshed/source_commit.txt
      - name: Commit the changes
        id: commit
        if: ${{ steps.sync.outcome == 'success' }}
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -2,7 +2,7 @@ fail_fast: true

 exclude: |
  (?x)^(
-    crates/red_knot_module_resolver/vendor/.*|
+    crates/red_knot/vendor/.*|
    crates/ruff_linter/resources/.*|
    crates/ruff_linter/src/rules/.*/snapshots/.*|
    crates/ruff/resources/.*|
@@ -14,7 +14,7 @@ exclude: |

 repos:
  - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.18
+    rev: v0.17
    hooks:
      - id: validate-pyproject

@@ -32,7 +32,7 @@ repos:
          )$

  - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.41.0
+    rev: v0.40.0
    hooks:
      - id: markdownlint-fix
        exclude: |
@@ -42,7 +42,7 @@ repos:
          )$

  - repo: https://github.com/crate-ci/typos
-    rev: v1.22.9
+    rev: v1.21.0
    hooks:
      - id: typos

@@ -56,7 +56,7 @@ repos:
        pass_filenames: false # This makes it a lot faster

  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.10
+    rev: v0.4.4
    hooks:
      - id: ruff-format
      - id: ruff
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -1,5 +0,0 @@
-{
-    "recommendations": [
-        "rust-lang.rust-analyzer"
-    ]
-}
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,6 +0,0 @@
-{
-    "rust-analyzer.check.extraArgs": [
-        "--all-features"
-    ],
-    "rust-analyzer.check.command": "clippy",
-}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,217 +1,5 @@
 # Changelog

-## 0.4.10
-
-### Parser
-
- Implement re-lexing logic for better error recovery ([#11845](https://github.com/astral-sh/ruff/pull/11845))
-
-### Rule changes
-
- \[`flake8-copyright`\] Update `CPY001` to check the first 4096 bytes instead of 1024 ([#11927](https://github.com/astral-sh/ruff/pull/11927))
- \[`pycodestyle`\] Update `E999` to show all syntax errors instead of just the first one ([#11900](https://github.com/astral-sh/ruff/pull/11900))
-
-### Server
-
- Add tracing setup guide to Helix documentation ([#11883](https://github.com/astral-sh/ruff/pull/11883))
- Add tracing setup guide to Neovim documentation ([#11884](https://github.com/astral-sh/ruff/pull/11884))
- Defer notebook cell deletion to avoid an error message ([#11864](https://github.com/astral-sh/ruff/pull/11864))
-
-### Security
-
- Guard against malicious ecosystem comment artifacts ([#11879](https://github.com/astral-sh/ruff/pull/11879))
-
-## 0.4.9
-
-### Preview features
-
- \[`pylint`\] Implement `consider-dict-items` (`C0206`) ([#11688](https://github.com/astral-sh/ruff/pull/11688))
- \[`refurb`\] Implement `repeated-global` (`FURB154`) ([#11187](https://github.com/astral-sh/ruff/pull/11187))
-
-### Rule changes
-
- \[`pycodestyle`\] Adapt fix for `E203` to work identical to `ruff format` ([#10999](https://github.com/astral-sh/ruff/pull/10999))
-
-### Formatter
-
- Fix formatter instability for lines only consisting of zero-width characters ([#11748](https://github.com/astral-sh/ruff/pull/11748))
-
-### Server
-
- Add supported commands in server capabilities ([#11850](https://github.com/astral-sh/ruff/pull/11850))
- Use real file path when available in `ruff server` ([#11800](https://github.com/astral-sh/ruff/pull/11800))
- Improve error message when a command is run on an unavailable document ([#11823](https://github.com/astral-sh/ruff/pull/11823))
- Introduce the `ruff.printDebugInformation` command ([#11831](https://github.com/astral-sh/ruff/pull/11831))
- Tracing system now respects log level and trace level, with options to log to a file ([#11747](https://github.com/astral-sh/ruff/pull/11747))
-
-### CLI
-
- Handle non-printable characters in diff view ([#11687](https://github.com/astral-sh/ruff/pull/11687))
-
-### Bug fixes
-
- \[`refurb`\] Avoid suggesting starmap when arguments are used outside call (`FURB140`) ([#11830](https://github.com/astral-sh/ruff/pull/11830))
- \[`flake8-bugbear`\] Avoid panic in `B909` when checking large loop blocks ([#11772](https://github.com/astral-sh/ruff/pull/11772))
- \[`refurb`\] Fix misbehavior of `operator.itemgetter` when getter param is a tuple (`FURB118`) ([#11774](https://github.com/astral-sh/ruff/pull/11774))
-
-## 0.4.8
-
-### Performance
-
- Linter performance has been improved by around 10% on some microbenchmarks by refactoring the lexer and parser to maintain synchronicity between them ([#11457](https://github.com/astral-sh/ruff/pull/11457))
-
-### Preview features
-
- \[`flake8-bugbear`\] Implement `return-in-generator` (`B901`) ([#11644](https://github.com/astral-sh/ruff/pull/11644))
- \[`flake8-pyi`\] Implement `PYI063` ([#11699](https://github.com/astral-sh/ruff/pull/11699))
- \[`pygrep_hooks`\] Check blanket ignores via file-level pragmas (`PGH004`) ([#11540](https://github.com/astral-sh/ruff/pull/11540))
-
-### Rule changes
-
- \[`pyupgrade`\] Update `UP035` for Python 3.13 and the latest version of `typing_extensions` ([#11693](https://github.com/astral-sh/ruff/pull/11693))
- \[`numpy`\] Update `NPY001` rule for NumPy 2.0 ([#11735](https://github.com/astral-sh/ruff/pull/11735))
-
-### Server
-
- Formatting a document with syntax problems no longer spams a visible error popup ([#11745](https://github.com/astral-sh/ruff/pull/11745))
-
-### CLI
-
- Add RDJson support for `--output-format` flag ([#11682](https://github.com/astral-sh/ruff/pull/11682))
-
-### Bug fixes
-
- \[`pyupgrade`\] Write empty string in lieu of panic when fixing `UP032` ([#11696](https://github.com/astral-sh/ruff/pull/11696))
- \[`flake8-simplify`\] Simplify double negatives in `SIM103` ([#11684](https://github.com/astral-sh/ruff/pull/11684))
- Ensure the expression generator adds a newline before `type` statements ([#11720](https://github.com/astral-sh/ruff/pull/11720))
- Respect per-file ignores for blanket and redirected noqa rules ([#11728](https://github.com/astral-sh/ruff/pull/11728))
-
-## 0.4.7
-
-### Preview features
-
- \[`flake8-pyi`\] Implement `PYI064` ([#11325](https://github.com/astral-sh/ruff/pull/11325))
- \[`flake8-pyi`\] Implement `PYI066` ([#11541](https://github.com/astral-sh/ruff/pull/11541))
- \[`flake8-pyi`\] Implement `PYI057` ([#11486](https://github.com/astral-sh/ruff/pull/11486))
- \[`pyflakes`\] Enable `F822` in `__init__.py` files by default ([#11370](https://github.com/astral-sh/ruff/pull/11370))
-
-### Formatter
-
- Fix incorrect placement of trailing stub function comments ([#11632](https://github.com/astral-sh/ruff/pull/11632))
-
-### Server
-
- Respect file exclusions in `ruff server` ([#11590](https://github.com/astral-sh/ruff/pull/11590))
- Add support for documents not exist on disk ([#11588](https://github.com/astral-sh/ruff/pull/11588))
- Add Vim and Kate setup guide for `ruff server` ([#11615](https://github.com/astral-sh/ruff/pull/11615))
-
-### Bug fixes
-
- Avoid removing newlines between docstring headers and rST blocks ([#11609](https://github.com/astral-sh/ruff/pull/11609))
- Infer indentation with imports when logical indent is absent ([#11608](https://github.com/astral-sh/ruff/pull/11608))
- Use char index rather than position for indent slice ([#11645](https://github.com/astral-sh/ruff/pull/11645))
- \[`flake8-comprehension`\] Strip parentheses around generators in `C400` ([#11607](https://github.com/astral-sh/ruff/pull/11607))
- Mark `repeated-isinstance-calls` as unsafe on Python 3.10 and later ([#11622](https://github.com/astral-sh/ruff/pull/11622))
-
-## 0.4.6
-
-### Breaking changes
-
- Use project-relative paths when calculating GitLab fingerprints ([#11532](https://github.com/astral-sh/ruff/pull/11532))
- Bump minimum supported Windows version to Windows 10 ([#11613](https://github.com/astral-sh/ruff/pull/11613))
-
-### Preview features
-
- \[`flake8-async`\] Sleep with >24 hour interval should usually sleep forever (`ASYNC116`) ([#11498](https://github.com/astral-sh/ruff/pull/11498))
-
-### Rule changes
-
- \[`numpy`\] Add missing functions to NumPy 2.0 migration rule ([#11528](https://github.com/astral-sh/ruff/pull/11528))
- \[`mccabe`\] Consider irrefutable pattern similar to `if .. else` for `C901` ([#11565](https://github.com/astral-sh/ruff/pull/11565))
- Consider `match`-`case` statements for `C901`, `PLR0912`, and `PLR0915` ([#11521](https://github.com/astral-sh/ruff/pull/11521))
- Remove empty strings when converting to f-string (`UP032`) ([#11524](https://github.com/astral-sh/ruff/pull/11524))
- \[`flake8-bandit`\] `request-without-timeout` should warn for `requests.request` ([#11548](https://github.com/astral-sh/ruff/pull/11548))
- \[`flake8-self`\] Ignore sunder accesses in `flake8-self` rules ([#11546](https://github.com/astral-sh/ruff/pull/11546))
- \[`pyupgrade`\] Lint for `TypeAliasType` usages (`UP040`) ([#11530](https://github.com/astral-sh/ruff/pull/11530))
-
-### Server
-
- Respect excludes in `ruff server` configuration discovery ([#11551](https://github.com/astral-sh/ruff/pull/11551))
- Use default settings if initialization options is empty or not provided ([#11566](https://github.com/astral-sh/ruff/pull/11566))
- `ruff server` correctly treats `.pyi` files as stub files ([#11535](https://github.com/astral-sh/ruff/pull/11535))
- `ruff server` searches for configuration in parent directories ([#11537](https://github.com/astral-sh/ruff/pull/11537))
- `ruff server`: An empty code action filter no longer returns notebook source actions ([#11526](https://github.com/astral-sh/ruff/pull/11526))
-
-### Bug fixes
-
- \[`flake8-logging-format`\] Fix autofix title in `logging-warn` (`G010`) ([#11514](https://github.com/astral-sh/ruff/pull/11514))
- \[`refurb`\] Avoid recommending `operator.itemgetter` with dependence on lambda arguments ([#11574](https://github.com/astral-sh/ruff/pull/11574))
- \[`flake8-simplify`\] Avoid recommending context manager in `__enter__` implementations ([#11575](https://github.com/astral-sh/ruff/pull/11575))
- Create intermediary directories for `--output-file` ([#11550](https://github.com/astral-sh/ruff/pull/11550))
- Propagate reads on global variables ([#11584](https://github.com/astral-sh/ruff/pull/11584))
- Treat all `singledispatch` arguments as runtime-required ([#11523](https://github.com/astral-sh/ruff/pull/11523))
-
-## 0.4.5
-
-### Ruff's language server is now in Beta
-
-`v0.4.5` marks the official Beta release of `ruff server`, an integrated language server built into Ruff.
-`ruff server` supports the same feature set as `ruff-lsp`, powering linting, formatting, and
-code fixes in Ruff's editor integrations -- but with superior performance and
-no installation required. We'd love your feedback!
-
-You can enable `ruff server` in the [VS Code extension](https://github.com/astral-sh/ruff-vscode?tab=readme-ov-file#enabling-the-rust-based-language-server) today.
-
-To read more about this exciting milestone, check out our [blog post](https://astral.sh/blog/ruff-v0.4.5)!
-
-### Rule changes
-
- \[`flake8-future-annotations`\] Reword `future-rewritable-type-annotation` (`FA100`) message ([#11381](https://github.com/astral-sh/ruff/pull/11381))
- \[`isort`\] Expanded the set of standard-library modules to include `_string`, etc. ([#11374](https://github.com/astral-sh/ruff/pull/11374))
- \[`pycodestyle`\] Consider soft keywords for `E27` rules ([#11446](https://github.com/astral-sh/ruff/pull/11446))
- \[`pyflakes`\] Recommend adding unused import bindings to `__all__` ([#11314](https://github.com/astral-sh/ruff/pull/11314))
- \[`pyflakes`\] Update documentation and deprecate `ignore_init_module_imports` ([#11436](https://github.com/astral-sh/ruff/pull/11436))
- \[`pyupgrade`\] Mark quotes as unnecessary for non-evaluated annotations ([#11485](https://github.com/astral-sh/ruff/pull/11485))
-
-### Formatter
-
- Avoid multiline quotes warning with `quote-style = preserve` ([#11490](https://github.com/astral-sh/ruff/pull/11490))
-
-### Server
-
- Support Jupyter Notebook files ([#11206](https://github.com/astral-sh/ruff/pull/11206))
- Support `noqa` comment code actions ([#11276](https://github.com/astral-sh/ruff/pull/11276))
- Fix automatic configuration reloading ([#11492](https://github.com/astral-sh/ruff/pull/11492))
- Fix several issues with configuration in Neovim and Helix ([#11497](https://github.com/astral-sh/ruff/pull/11497))
-
-### CLI
-
- Add `--output-format` as a CLI option for `ruff config` ([#11438](https://github.com/astral-sh/ruff/pull/11438))
-
-### Bug fixes
-
- Avoid `PLE0237` for property with setter ([#11377](https://github.com/astral-sh/ruff/pull/11377))
- Avoid `TCH005` for `if` stmt with `elif`/`else` block ([#11376](https://github.com/astral-sh/ruff/pull/11376))
- Avoid flagging `__future__` annotations as required for non-evaluated type annotations ([#11414](https://github.com/astral-sh/ruff/pull/11414))
- Check for ruff executable in 'bin' directory as installed by 'pip install --target'. ([#11450](https://github.com/astral-sh/ruff/pull/11450))
- Sort edits prior to deduplicating in quotation fix ([#11452](https://github.com/astral-sh/ruff/pull/11452))
- Treat escaped newline as valid sequence ([#11465](https://github.com/astral-sh/ruff/pull/11465))
- \[`flake8-pie`\] Preserve parentheses in `unnecessary-dict-kwargs` ([#11372](https://github.com/astral-sh/ruff/pull/11372))
- \[`pylint`\] Ignore `__slots__` with dynamic values ([#11488](https://github.com/astral-sh/ruff/pull/11488))
- \[`pylint`\] Remove `try` body from branch counting ([#11487](https://github.com/astral-sh/ruff/pull/11487))
- \[`refurb`\] Respect operator precedence in `FURB110` ([#11464](https://github.com/astral-sh/ruff/pull/11464))
-
-### Documentation
-
- Add `--preview` to the README ([#11395](https://github.com/astral-sh/ruff/pull/11395))
- Add Python 3.13 to list of allowed Python versions ([#11411](https://github.com/astral-sh/ruff/pull/11411))
- Simplify Neovim setup documentation ([#11489](https://github.com/astral-sh/ruff/pull/11489))
- Update CONTRIBUTING.md to reflect the new parser ([#11434](https://github.com/astral-sh/ruff/pull/11434))
- Update server documentation with new migration guide ([#11499](https://github.com/astral-sh/ruff/pull/11499))
- \[`pycodestyle`\] Clarify motivation for `E713` and `E714` ([#11483](https://github.com/astral-sh/ruff/pull/11483))
- \[`pyflakes`\] Update docs to describe WAI behavior (F541) ([#11362](https://github.com/astral-sh/ruff/pull/11362))
- \[`pylint`\] Clearly indicate what is counted as a branch ([#11423](https://github.com/astral-sh/ruff/pull/11423))
-
 ## 0.4.4

 ### Preview features
@@ -286,10 +74,6 @@ To read more about this exciting milestone, check out our [blog post](https://as
 - Avoid allocations for isort module names ([#11251](https://github.com/astral-sh/ruff/pull/11251))
 - Build a separate ARM wheel for macOS ([#11149](https://github.com/astral-sh/ruff/pull/11149))

-### Windows
-
- Increase the minimum requirement to Windows 10.
-
 ## 0.4.2

 ### Rule changes
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -101,8 +101,6 @@ pre-commit run --all-files --show-diff-on-failure  # Rust and Python formatting,
 These checks will run on GitHub Actions when you open your pull request, but running them locally
 will save you time and expedite the merge process.

-If you're using VS Code, you can also install the recommended [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer) extension to get these checks while editing.
-
 Note that many code changes also require updating the snapshot tests, which is done interactively
 after running `cargo test` like so:

@@ -351,9 +349,7 @@ even patch releases may contain [non-backwards-compatible changes](https://semve
    - The commit hash of the merged release pull request on `main`
 1. The release workflow will do the following:
    1. Build all the assets. If this fails (even though we tested in step 4), we haven't tagged or
-        uploaded anything, you can restart after pushing a fix. If you just need to rerun the build,
-        make sure you're [re-running all the failed
-        jobs](https://docs.github.com/en/actions/managing-workflow-runs/re-running-workflows-and-jobs#re-running-failed-jobs-in-a-workflow) and not just a single failed job.
+        uploaded anything, you can restart after pushing a fix.
    1. Upload to PyPI.
    1. Create and push the Git tag (as extracted from `pyproject.toml`). We create the Git tag only
        after building the wheels and uploading to PyPI, since we can't delete or modify the tag ([#4468](https://github.com/astral-sh/ruff/issues/4468)).
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ resolver = "2"

 [workspace.package]
 edition = "2021"
-rust-version = "1.75"
+rust-version = "1.71"
 homepage = "https://docs.astral.sh/ruff"
 documentation = "https://docs.astral.sh/ruff"
 repository = "https://github.com/astral-sh/ruff"
@@ -14,7 +14,6 @@ license = "MIT"
 [workspace.dependencies]
 ruff = { path = "crates/ruff" }
 ruff_cache = { path = "crates/ruff_cache" }
-ruff_db = { path = "crates/ruff_db" }
 ruff_diagnostics = { path = "crates/ruff_diagnostics" }
 ruff_formatter = { path = "crates/ruff_formatter" }
 ruff_index = { path = "crates/ruff_index" }
@@ -35,8 +34,6 @@ ruff_source_file = { path = "crates/ruff_source_file" }
 ruff_text_size = { path = "crates/ruff_text_size" }
 ruff_workspace = { path = "crates/ruff_workspace" }

-red_knot_module_resolver = { path = "crates/red_knot_module_resolver" }
-
 aho-corasick = { version = "1.1.3" }
 annotate-snippets = { version = "0.9.2", features = ["color"] }
 anyhow = { version = "1.0.80" }
@@ -45,7 +42,6 @@ bincode = { version = "1.3.3" }
 bitflags = { version = "2.5.0" }
 bstr = { version = "1.9.1" }
 cachedir = { version = "0.3.1" }
-camino = { version = "1.1.7" }
 chrono = { version = "0.4.35", default-features = false, features = ["clock"] }
 clap = { version = "4.5.3", features = ["derive"] }
 clap_complete_command = { version = "0.5.1" }
@@ -66,26 +62,26 @@ filetime = { version = "0.2.23" }
 glob = { version = "0.3.1" }
 globset = { version = "0.4.14" }
 hashbrown = "0.14.3"
+hexf-parse = { version = "0.2.1" }
 ignore = { version = "0.4.22" }
 imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
 indexmap = { version = "2.2.6" }
 indicatif = { version = "0.17.8" }
 indoc = { version = "2.0.4" }
-insta = { version = "1.35.1" }
+insta = { version = "1.35.1", feature = ["filters", "glob"] }
 insta-cmd = { version = "0.6.0" }
 is-macro = { version = "0.3.5" }
 is-wsl = { version = "0.4.0" }
-itertools = { version = "0.13.0" }
+itertools = { version = "0.12.1" }
 js-sys = { version = "0.3.69" }
 jod-thread = { version = "0.1.2" }
+lexical-parse-float = { version = "0.8.0", features = ["format"] }
 libc = { version = "0.2.153" }
 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",
-] }
+lsp-types = { version = "0.95.0", features = ["proposed"] }
 matchit = { version = "0.8.1" }
 memchr = { version = "2.7.1" }
 mimalloc = { version = "0.1.39" }
@@ -105,21 +101,18 @@ quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
-rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "f706aa2d32d473ee633a77c1af01d180c85da308" }
+result-like = { version = "0.5.0" }
+rustc-hash = { version = "1.1.0" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
 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",
-] }
+serde_with = { version = "3.6.0", default-features = false, features = ["macros"] }
 shellexpand = { version = "3.0.0" }
 similar = { version = "2.4.0", features = ["inline"] }
 smallvec = { version = "1.13.2" }
-smol_str = { version = "0.2.2" }
 static_assertions = "1.1.0"
 strum = { version = "0.26.0", features = ["strum_macros"] }
 strum_macros = { version = "0.26.0" }
@@ -141,17 +134,11 @@ unicode_names2 = { version = "1.2.2" }
 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",
-] }
+uuid = { version = "1.6.1", features = ["v4", "fast-rng", "macro-diagnostics", "js"] }
 walkdir = { version = "2.3.2" }
 wasm-bindgen = { version = "0.2.92" }
 wasm-bindgen-test = { version = "0.3.42" }
 wild = { version = "2" }
-zip = { version = "0.6.6", default-features = false, features = ["zstd"] }

 [workspace.lints.rust]
 unsafe_code = "warn"
--- a/README.md
+++ b/README.md
@@ -28,7 +28,7 @@ An extremely fast Python linter and code formatter, written in Rust.
 - ⚡️ 10-100x faster than existing linters (like Flake8) and formatters (like Black)
 - 🐍 Installable via `pip`
 - 🛠️ `pyproject.toml` support
- 🤝 Python 3.13 compatibility
+- 🤝 Python 3.12 compatibility
 - ⚖️ Drop-in parity with [Flake8](https://docs.astral.sh/ruff/faq/#how-does-ruff-compare-to-flake8), isort, and Black
 - 📦 Built-in caching, to avoid re-analyzing unchanged files
 - 🔧 Fix support, for automatic error correction (e.g., automatically remove unused imports)
@@ -152,7 +152,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.4.10
+  rev: v0.4.4
  hooks:
    # Run the linter.
    - id: ruff
@@ -408,7 +408,6 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [Dagster](https://github.com/dagster-io/dagster)
 - Databricks ([MLflow](https://github.com/mlflow/mlflow))
 - [FastAPI](https://github.com/tiangolo/fastapi)
- [Godot](https://github.com/godotengine/godot)
 - [Gradio](https://github.com/gradio-app/gradio)
 - [Great Expectations](https://github.com/great-expectations/great_expectations)
 - [HTTPX](https://github.com/encode/httpx)
@@ -434,7 +433,6 @@ Ruff is used by a number of major open-source projects and companies, including:
 - Modern Treasury ([Python SDK](https://github.com/Modern-Treasury/modern-treasury-python))
 - Mozilla ([Firefox](https://github.com/mozilla/gecko-dev))
 - [Mypy](https://github.com/python/mypy)
- [Nautobot](https://github.com/nautobot/nautobot)
 - Netflix ([Dispatch](https://github.com/Netflix/dispatch))
 - [Neon](https://github.com/neondatabase/neon)
 - [Nokia](https://nokia.com/)
@@ -442,7 +440,6 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [NumPyro](https://github.com/pyro-ppl/numpyro)
 - [ONNX](https://github.com/onnx/onnx)
 - [OpenBB](https://github.com/OpenBB-finance/OpenBBTerminal)
- [Open Wine Components](https://github.com/Open-Wine-Components/umu-launcher)
 - [PDM](https://github.com/pdm-project/pdm)
 - [PaddlePaddle](https://github.com/PaddlePaddle/Paddle)
 - [Pandas](https://github.com/pandas-dev/pandas)
@@ -470,7 +467,6 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [Sphinx](https://github.com/sphinx-doc/sphinx)
 - [Stable Baselines3](https://github.com/DLR-RM/stable-baselines3)
 - [Starlette](https://github.com/encode/starlette)
- [Streamlit](https://github.com/streamlit/streamlit)
 - [The Algorithms](https://github.com/TheAlgorithms/Python)
 - [Vega-Altair](https://github.com/altair-viz/altair)
 - WordPress ([Openverse](https://github.com/WordPress/openverse))
--- a/_typos.toml
+++ b/_typos.toml
@@ -1,6 +1,6 @@
 [files]
 # https://github.com/crate-ci/typos/issues/868
-extend-exclude = ["crates/red_knot_module_resolver/vendor/**/*", "**/resources/**/*", "**/snapshots/**/*"]
+extend-exclude = ["crates/red_knot/vendor/**/*", "**/resources/**/*", "**/snapshots/**/*"]

 [default.extend-words]
 "arange" = "arange"  # e.g. `numpy.arange`
--- a/crates/red_knot/Cargo.toml
+++ b/crates/red_knot/Cargo.toml
@@ -12,8 +12,6 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-red_knot_module_resolver = { workspace = true }
-
 ruff_python_parser = { workspace = true }
 ruff_python_ast = { workspace = true }
 ruff_text_size = { workspace = true }
@@ -27,7 +25,6 @@ ctrlc = { version = "3.4.4" }
 dashmap = { workspace = true }
 hashbrown = { workspace = true }
 indexmap = { workspace = true }
-is-macro = { workspace = true }
 notify = { workspace = true }
 parking_lot = { workspace = true }
 rayon = { workspace = true }
@@ -38,6 +35,7 @@ tracing-subscriber = { workspace = true }
 tracing-tree = { workspace = true }

 [dev-dependencies]
+textwrap = { version = "0.16.1" }
 tempfile = { workspace = true }

 [lints]
--- a/crates/red_knot/README.md
+++ b/crates/red_knot/README.md
@@ -0,0 +1,9 @@
+# Red Knot
+
+The Red Knot crate contains code working towards multifile analysis, type inference and, ultimately, type-checking. It's very much a work in progress for now.
+
+## Vendored types for the stdlib
+
+Red Knot vendors [typeshed](https://github.com/python/typeshed)'s stubs for the standard library. The vendored stubs can be found in `crates/red_knot/vendor/typeshed`. The file `crates/red_knot/vendor/typeshed/source_commit.txt` tells you the typeshed commit that our vendored stdlib stubs currently correspond to.
+
+The typeshed stubs are updated every two weeks via an automated PR using the `sync_typeshed.yaml` workflow in the `.github/workflows` directory. This workflow can also be triggered at any time via [workflow dispatch](https://docs.github.com/en/actions/using-workflows/manually-running-a-workflow#running-a-workflow).
--- a/crates/red_knot/src/ast_ids.rs
+++ b/crates/red_knot/src/ast_ids.rs
@@ -6,8 +6,8 @@ use std::marker::PhantomData;
 use rustc_hash::FxHashMap;

 use ruff_index::{Idx, IndexVec};
-use ruff_python_ast::visitor::source_order;
-use ruff_python_ast::visitor::source_order::{SourceOrderVisitor, TraversalSignal};
+use ruff_python_ast::visitor::preorder;
+use ruff_python_ast::visitor::preorder::{PreorderVisitor, TraversalSignal};
 use ruff_python_ast::{
    AnyNodeRef, AstNode, ExceptHandler, ExceptHandlerExceptHandler, Expr, MatchCase, ModModule,
    NodeKind, Parameter, Stmt, StmtAnnAssign, StmtAssign, StmtAugAssign, StmtClassDef,
@@ -91,9 +91,9 @@ impl AstIds {
        while let Some(deferred) = visitor.deferred.pop() {
            match deferred {
                DeferredNode::FunctionDefinition(def) => {
-                    def.visit_source_order(&mut visitor);
+                    def.visit_preorder(&mut visitor);
                }
-                DeferredNode::ClassDefinition(def) => def.visit_source_order(&mut visitor),
+                DeferredNode::ClassDefinition(def) => def.visit_preorder(&mut visitor),
            }
        }

@@ -182,7 +182,7 @@ impl<'a> AstIdsVisitor<'a> {
    }
 }

-impl<'a> SourceOrderVisitor<'a> for AstIdsVisitor<'a> {
+impl<'a> PreorderVisitor<'a> for AstIdsVisitor<'a> {
    fn visit_stmt(&mut self, stmt: &'a Stmt) {
        match stmt {
            Stmt::FunctionDef(def) => {
@@ -226,14 +226,14 @@ impl<'a> SourceOrderVisitor<'a> for AstIdsVisitor<'a> {
            Stmt::IpyEscapeCommand(_) => {}
        }

-        source_order::walk_stmt(self, stmt);
+        preorder::walk_stmt(self, stmt);
    }

    fn visit_expr(&mut self, _expr: &'a Expr) {}

    fn visit_parameter(&mut self, parameter: &'a Parameter) {
        self.create_id(parameter);
-        source_order::walk_parameter(self, parameter);
+        preorder::walk_parameter(self, parameter);
    }

    fn visit_except_handler(&mut self, except_handler: &'a ExceptHandler) {
@@ -243,17 +243,17 @@ impl<'a> SourceOrderVisitor<'a> for AstIdsVisitor<'a> {
            }
        }

-        source_order::walk_except_handler(self, except_handler);
+        preorder::walk_except_handler(self, except_handler);
    }

    fn visit_with_item(&mut self, with_item: &'a WithItem) {
        self.create_id(with_item);
-        source_order::walk_with_item(self, with_item);
+        preorder::walk_with_item(self, with_item);
    }

    fn visit_match_case(&mut self, match_case: &'a MatchCase) {
        self.create_id(match_case);
-        source_order::walk_match_case(self, match_case);
+        preorder::walk_match_case(self, match_case);
    }

    fn visit_type_param(&mut self, type_param: &'a TypeParam) {
@@ -275,7 +275,10 @@ pub struct TypedNodeKey<N: AstNode> {

 impl<N: AstNode> TypedNodeKey<N> {
    pub fn from_node(node: &N) -> Self {
-        let inner = NodeKey::from_node(node.as_any_node_ref());
+        let inner = NodeKey {
+            kind: node.as_any_node_ref().kind(),
+            range: node.range(),
+        };
        Self {
            inner,
            _marker: PhantomData,
@@ -309,7 +312,7 @@ struct FindNodeKeyVisitor<'a> {
    result: Option<AnyNodeRef<'a>>,
 }

-impl<'a> SourceOrderVisitor<'a> for FindNodeKeyVisitor<'a> {
+impl<'a> PreorderVisitor<'a> for FindNodeKeyVisitor<'a> {
    fn enter_node(&mut self, node: AnyNodeRef<'a>) -> TraversalSignal {
        if self.result.is_some() {
            return TraversalSignal::Skip;
@@ -349,12 +352,6 @@ pub struct NodeKey {
 }

 impl NodeKey {
-    pub fn from_node(node: AnyNodeRef) -> Self {
-        NodeKey {
-            kind: node.kind(),
-            range: node.range(),
-        }
-    }
    pub fn resolve<'a>(&self, root: AnyNodeRef<'a>) -> Option<AnyNodeRef<'a>> {
        // We need to do a binary search here. Only traverse into a node if the range is withint the node
        let mut visitor = FindNodeKeyVisitor {
--- a/crates/red_knot/src/db.rs
+++ b/crates/red_knot/src/db.rs
@@ -9,9 +9,9 @@ use crate::files::FileId;
 use crate::lint::{LintSemanticStorage, LintSyntaxStorage};
 use crate::module::ModuleResolver;
 use crate::parse::ParsedStorage;
-use crate::semantic::SemanticIndexStorage;
-use crate::semantic::TypeStore;
 use crate::source::SourceStorage;
+use crate::symbols::SymbolTablesStorage;
+use crate::types::TypeStore;

 mod jars;
 mod query;
@@ -125,7 +125,7 @@ pub struct SourceJar {
 #[derive(Debug, Default)]
 pub struct SemanticJar {
    pub module_resolver: ModuleResolver,
-    pub semantic_indices: SemanticIndexStorage,
+    pub symbol_tables: SymbolTablesStorage,
    pub type_store: TypeStore,
 }

--- a/crates/red_knot/src/lib.rs
+++ b/crates/red_knot/src/lib.rs
@@ -17,8 +17,9 @@ pub mod lint;
 pub mod module;
 mod parse;
 pub mod program;
-mod semantic;
 pub mod source;
+mod symbols;
+mod types;
 pub mod watch;

 pub(crate) type FxDashMap<K, V> = dashmap::DashMap<K, V, BuildHasherDefault<FxHasher>>;
--- a/crates/red_knot/src/lint.rs
+++ b/crates/red_knot/src/lint.rs
@@ -5,18 +5,17 @@ use std::time::Duration;

 use ruff_python_ast::visitor::Visitor;
 use ruff_python_ast::{ModModule, StringLiteral};
-use ruff_python_parser::Parsed;

 use crate::cache::KeyValueCache;
 use crate::db::{LintDb, LintJar, QueryResult};
 use crate::files::FileId;
-use crate::module::{resolve_module, ModuleName};
-use crate::parse::parse;
-use crate::semantic::{infer_definition_type, infer_symbol_public_type, Type};
-use crate::semantic::{
-    resolve_global_symbol, semantic_index, Definition, GlobalSymbolId, SemanticIndex, SymbolId,
-};
+use crate::module::ModuleName;
+use crate::parse::{parse, Parsed};
 use crate::source::{source_text, Source};
+use crate::symbols::{
+    resolve_global_symbol, symbol_table, Definition, GlobalSymbolId, SymbolId, SymbolTable,
+};
+use crate::types::{infer_definition_type, infer_symbol_type, Type};

 #[tracing::instrument(level = "debug", skip(db))]
 pub(crate) fn lint_syntax(db: &dyn LintDb, file_id: FileId) -> QueryResult<Diagnostics> {
@@ -41,7 +40,7 @@ pub(crate) fn lint_syntax(db: &dyn LintDb, file_id: FileId) -> QueryResult<Diagn
        let parsed = parse(db.upcast(), *file_id)?;

        if parsed.errors().is_empty() {
-            let ast = parsed.syntax();
+            let ast = parsed.ast();

            let mut visitor = SyntaxLintVisitor {
                diagnostics,
@@ -82,13 +81,13 @@ pub(crate) fn lint_semantic(db: &dyn LintDb, file_id: FileId) -> QueryResult<Dia
    storage.get(&file_id, |file_id| {
        let source = source_text(db.upcast(), *file_id)?;
        let parsed = parse(db.upcast(), *file_id)?;
-        let semantic_index = semantic_index(db.upcast(), *file_id)?;
+        let symbols = symbol_table(db.upcast(), *file_id)?;

        let context = SemanticLintContext {
            file_id: *file_id,
            source,
-            parsed: &parsed,
-            semantic_index,
+            parsed,
+            symbols,
            db,
            diagnostics: RefCell::new(Vec::new()),
        };
@@ -102,17 +101,17 @@ pub(crate) fn lint_semantic(db: &dyn LintDb, file_id: FileId) -> QueryResult<Dia

 fn lint_unresolved_imports(context: &SemanticLintContext) -> QueryResult<()> {
    // TODO: Consider iterating over the dependencies (imports) only instead of all definitions.
-    for (symbol, definition) in context.semantic_index().symbol_table().all_definitions() {
+    for (symbol, definition) in context.symbols().all_definitions() {
        match definition {
            Definition::Import(import) => {
-                let ty = context.infer_symbol_public_type(symbol)?;
+                let ty = context.infer_symbol_type(symbol)?;

                if ty.is_unknown() {
                    context.push_diagnostic(format!("Unresolved module {}", import.module));
                }
            }
            Definition::ImportFrom(import) => {
-                let ty = context.infer_symbol_public_type(symbol)?;
+                let ty = context.infer_symbol_type(symbol)?;

                if ty.is_unknown() {
                    let module_name = import.module().map(Deref::deref).unwrap_or_default();
@@ -145,14 +144,16 @@ fn lint_bad_overrides(context: &SemanticLintContext) -> QueryResult<()> {
    // TODO we should have a special marker on the real typing module (from typeshed) so if you
    // have your own "typing" module in your project, we don't consider it THE typing module (and
    // same for other stdlib modules that our lint rules care about)
-    let Some(typing_override) = context.resolve_global_symbol("typing", "override")? else {
+    let Some(typing_override) =
+        resolve_global_symbol(context.db.upcast(), ModuleName::new("typing"), "override")?
+    else {
        // TODO once we bundle typeshed, this should be unreachable!()
        return Ok(());
    };

    // TODO we should maybe index definitions by type instead of iterating all, or else iterate all
    // just once, match, and branch to all lint rules that care about a type of definition
-    for (symbol, definition) in context.semantic_index().symbol_table().all_definitions() {
+    for (symbol, definition) in context.symbols().all_definitions() {
        if !matches!(definition, Definition::FunctionDef(_)) {
            continue;
        }
@@ -193,8 +194,8 @@ fn lint_bad_overrides(context: &SemanticLintContext) -> QueryResult<()> {
 pub struct SemanticLintContext<'a> {
    file_id: FileId,
    source: Source,
-    parsed: &'a Parsed<ModModule>,
-    semantic_index: Arc<SemanticIndex>,
+    parsed: Parsed,
+    symbols: Arc<SymbolTable>,
    db: &'a dyn LintDb,
    diagnostics: RefCell<Vec<String>>,
 }
@@ -208,16 +209,16 @@ impl<'a> SemanticLintContext<'a> {
        self.file_id
    }

-    pub fn ast(&self) -> &'a ModModule {
-        self.parsed.syntax()
+    pub fn ast(&self) -> &ModModule {
+        self.parsed.ast()
    }

-    pub fn semantic_index(&self) -> &SemanticIndex {
-        &self.semantic_index
+    pub fn symbols(&self) -> &SymbolTable {
+        &self.symbols
    }

-    pub fn infer_symbol_public_type(&self, symbol_id: SymbolId) -> QueryResult<Type> {
-        infer_symbol_public_type(
+    pub fn infer_symbol_type(&self, symbol_id: SymbolId) -> QueryResult<Type> {
+        infer_symbol_type(
            self.db.upcast(),
            GlobalSymbolId {
                file_id: self.file_id,
@@ -233,18 +234,6 @@ impl<'a> SemanticLintContext<'a> {
    pub fn extend_diagnostics(&mut self, diagnostics: impl IntoIterator<Item = String>) {
        self.diagnostics.get_mut().extend(diagnostics);
    }
-
-    pub fn resolve_global_symbol(
-        &self,
-        module: &str,
-        symbol_name: &str,
-    ) -> QueryResult<Option<GlobalSymbolId>> {
-        let Some(module) = resolve_module(self.db.upcast(), ModuleName::new(module))? else {
-            return Ok(None);
-        };
-
-        resolve_global_symbol(self.db.upcast(), module, symbol_name)
-    }
 }

 #[derive(Debug)]
--- a/crates/red_knot/src/main.rs
+++ b/crates/red_knot/src/main.rs
@@ -12,7 +12,7 @@ use tracing_subscriber::{Layer, Registry};
 use tracing_tree::time::Uptime;

 use red_knot::db::{HasJar, ParallelDatabase, QueryError, SourceDb, SourceJar};
-use red_knot::module::{set_module_search_paths, ModuleResolutionInputs};
+use red_knot::module::{set_module_search_paths, ModuleSearchPath, ModuleSearchPathKind};
 use red_knot::program::check::ExecutionMode;
 use red_knot::program::{FileWatcherChange, Program};
 use red_knot::watch::FileWatcher;
@@ -44,17 +44,12 @@ fn main() -> anyhow::Result<()> {
    let workspace_folder = entry_point.parent().unwrap();
    let workspace = Workspace::new(workspace_folder.to_path_buf());

-    let workspace_search_path = workspace.root().to_path_buf();
-
-    let search_paths = ModuleResolutionInputs {
-        extra_paths: vec![],
-        workspace_root: workspace_search_path,
-        site_packages: None,
-        custom_typeshed: None,
-    };
-
+    let workspace_search_path = ModuleSearchPath::new(
+        workspace.root().to_path_buf(),
+        ModuleSearchPathKind::FirstParty,
+    );
    let mut program = Program::new(workspace);
-    set_module_search_paths(&mut program, search_paths);
+    set_module_search_paths(&mut program, vec![workspace_search_path]);

    let entry_id = program.file_id(entry_point);
    program.workspace_mut().open_file(entry_id);
--- a/crates/red_knot/src/module.rs
+++ b/crates/red_knot/src/module.rs
@@ -7,22 +7,16 @@ use std::sync::Arc;
 use dashmap::mapref::entry::Entry;
 use smol_str::SmolStr;

-use red_knot_module_resolver::ModuleKind;
-
 use crate::db::{QueryResult, SemanticDb, SemanticJar};
 use crate::files::FileId;
-use crate::semantic::Dependency;
+use crate::symbols::Dependency;
 use crate::FxDashMap;

-/// Representation of a Python module.
-///
-/// The inner type wrapped by this struct is a unique identifier for the module
-/// that is used by the struct's methods to lazily query information about the module.
+/// ID uniquely identifying a module.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
 pub struct Module(u32);

 impl Module {
-    /// Return the absolute name of the module (e.g. `foo.bar`)
    pub fn name(&self, db: &dyn SemanticDb) -> QueryResult<ModuleName> {
        let jar: &SemanticJar = db.jar()?;
        let modules = &jar.module_resolver;
@@ -30,7 +24,6 @@ impl Module {
        Ok(modules.modules.get(self).unwrap().name.clone())
    }

-    /// Return the path to the source code that defines this module
    pub fn path(&self, db: &dyn SemanticDb) -> QueryResult<ModulePath> {
        let jar: &SemanticJar = db.jar()?;
        let modules = &jar.module_resolver;
@@ -38,7 +31,6 @@ impl Module {
        Ok(modules.modules.get(self).unwrap().path.clone())
    }

-    /// Determine whether this module is a single-file module or a package
    pub fn kind(&self, db: &dyn SemanticDb) -> QueryResult<ModuleKind> {
        let jar: &SemanticJar = db.jar()?;
        let modules = &jar.module_resolver;
@@ -46,16 +38,6 @@ impl Module {
        Ok(modules.modules.get(self).unwrap().kind)
    }

-    /// Attempt to resolve a dependency of this module to an absolute [`ModuleName`].
-    ///
-    /// A dependency could be either absolute (e.g. the `foo` dependency implied by `from foo import bar`)
-    /// or relative to this module (e.g. the `.foo` dependency implied by `from .foo import bar`)
-    ///
-    /// - Returns an error if the query failed.
-    /// - Returns `Ok(None)` if the query succeeded,
-    ///   but the dependency refers to a module that does not exist.
-    /// - Returns `Ok(Some(ModuleName))` if the query succeeded,
-    ///   and the dependency refers to a module that exists.
    pub fn resolve_dependency(
        &self,
        db: &dyn SemanticDb,
@@ -105,8 +87,7 @@ impl Module {

 /// A module name, e.g. `foo.bar`.
 ///
-/// Always normalized to the absolute form
-/// (never a relative module name, i.e., never `.foo`).
+/// Always normalized to the absolute form (never a relative module name).
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub struct ModuleName(smol_str::SmolStr);

@@ -143,13 +124,10 @@ impl ModuleName {
        Some(Self(name))
    }

-    /// An iterator over the components of the module name:
-    /// `foo.bar.baz` -> `foo`, `bar`, `baz`
    pub fn components(&self) -> impl DoubleEndedIterator<Item = &str> {
        self.0.split('.')
    }

-    /// The name of this module's immediate parent, if it has a parent
    pub fn parent(&self) -> Option<ModuleName> {
        let (_, parent) = self.0.rsplit_once('.')?;

@@ -179,6 +157,14 @@ impl std::fmt::Display for ModuleName {
    }
 }

+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum ModuleKind {
+    Module,
+
+    /// A python package (a `__init__.py` or `__init__.pyi` file)
+    Package,
+}
+
 /// A search path in which to search modules.
 /// Corresponds to a path in [`sys.path`](https://docs.python.org/3/library/sys_path_init.html) at runtime.
 ///
@@ -195,12 +181,10 @@ impl ModuleSearchPath {
        }
    }

-    /// Determine whether this is a first-party, third-party or standard-library search path
    pub fn kind(&self) -> ModuleSearchPathKind {
        self.inner.kind
    }

-    /// Return the location of the search path on the file system
    pub fn path(&self) -> &Path {
        &self.inner.path
    }
@@ -218,31 +202,22 @@ struct ModuleSearchPathInner {
    kind: ModuleSearchPathKind,
 }

-/// Enumeration of the different kinds of search paths type checkers are expected to support.
-///
-/// N.B. Although we don't implement `Ord` for this enum, they are ordered in terms of the
-/// priority that we want to give these modules when resolving them.
-/// This is roughly [the order given in the typing spec], but typeshed's stubs
-/// for the standard library are moved higher up to match Python's semantics at runtime.
-///
-/// [the order given in the typing spec]: https://typing.readthedocs.io/en/latest/spec/distributing.html#import-resolution-ordering
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, is_macro::Is)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
 pub enum ModuleSearchPathKind {
-    /// "Extra" paths provided by the user in a config file, env var or CLI flag.
-    /// E.g. mypy's `MYPYPATH` env var, or pyright's `stubPath` configuration setting
-    Extra,
-
-    /// Files in the project we're directly being invoked on
+    // Project dependency
    FirstParty,

-    /// The `stdlib` directory of typeshed (either vendored or custom)
+    // e.g. site packages
+    ThirdParty,
+
+    // e.g. built-in modules, typeshed
    StandardLibrary,
+}

-    /// Stubs or runtime modules installed in site-packages
-    SitePackagesThirdParty,
-
-    /// Vendored third-party stubs from typeshed
-    VendoredThirdParty,
+impl ModuleSearchPathKind {
+    pub const fn is_first_party(self) -> bool {
+        matches!(self, Self::FirstParty)
+    }
 }

 #[derive(Debug, Eq, PartialEq)]
@@ -256,11 +231,9 @@ pub struct ModuleData {
 // Queries
 //////////////////////////////////////////////////////

-/// Resolves a module name to a module.
-///
-/// TODO: This would not work with Salsa because `ModuleName` isn't an ingredient
-/// and, therefore, cannot be used as part of a query.
-/// For this to work with salsa, it would be necessary to intern all `ModuleName`s.
+/// Resolves a module name to a module id
+/// TODO: This would not work with Salsa because `ModuleName` isn't an ingredient and, therefore, cannot be used as part of a query.
+///  For this to work with salsa, it would be necessary to intern all `ModuleName`s.
 #[tracing::instrument(level = "debug", skip(db))]
 pub fn resolve_module(db: &dyn SemanticDb, name: ModuleName) -> QueryResult<Option<Module>> {
    let jar: &SemanticJar = db.jar()?;
@@ -282,7 +255,7 @@ pub fn resolve_module(db: &dyn SemanticDb, name: ModuleName) -> QueryResult<Opti
            let file_id = db.file_id(&normalized);
            let path = ModulePath::new(root_path.clone(), file_id);

-            let module = Module(
+            let id = Module(
                modules
                    .next_module_id
                    .fetch_add(1, std::sync::atomic::Ordering::Relaxed),
@@ -290,7 +263,7 @@ pub fn resolve_module(db: &dyn SemanticDb, name: ModuleName) -> QueryResult<Opti

            modules
                .modules
-                .insert(module, Arc::from(ModuleData { name, path, kind }));
+                .insert(id, Arc::from(ModuleData { name, path, kind }));

            // A path can map to multiple modules because of symlinks:
            // ```
@@ -299,33 +272,33 @@ pub fn resolve_module(db: &dyn SemanticDb, name: ModuleName) -> QueryResult<Opti
            // ```
            // Here, both `foo` and `bar` resolve to the same module but through different paths.
            // That's why we need to insert the absolute path and not the normalized path here.
-            let absolute_file_id = if absolute_path == normalized {
+            let absolute_id = if absolute_path == normalized {
                file_id
            } else {
                db.file_id(&absolute_path)
            };

-            modules.by_file.insert(absolute_file_id, module);
+            modules.by_file.insert(absolute_id, id);

-            entry.insert_entry(module);
+            entry.insert_entry(id);

-            Ok(Some(module))
+            Ok(Some(id))
        }
    }
 }

-/// Resolves the module for the given path.
+/// Resolves the module id for the given path.
 ///
-/// Returns `None` if the path is not a module locatable via `sys.path`.
+/// Returns `None` if the path is not a module in `sys.path`.
 #[tracing::instrument(level = "debug", skip(db))]
 pub fn path_to_module(db: &dyn SemanticDb, path: &Path) -> QueryResult<Option<Module>> {
    let file = db.file_id(path);
    file_to_module(db, file)
 }

-/// Resolves the module for the file with the given id.
+/// Resolves the module id for the file with the given id.
 ///
-/// Returns `None` if the file is not a module locatable via `sys.path`.
+/// Returns `None` if the file is not a module in `sys.path`.
 #[tracing::instrument(level = "debug", skip(db))]
 pub fn file_to_module(db: &dyn SemanticDb, file: FileId) -> QueryResult<Option<Module>> {
    let jar: &SemanticJar = db.jar()?;
@@ -352,12 +325,12 @@ pub fn file_to_module(db: &dyn SemanticDb, file: FileId) -> QueryResult<Option<M

    // Resolve the module name to see if Python would resolve the name to the same path.
    // If it doesn't, then that means that multiple modules have the same in different
-    // root paths, but that the module corresponding to the past path is in a lower priority search path,
+    // root paths, but that the module corresponding to the past path is in a lower priority path,
    // in which case we ignore it.
-    let Some(module) = resolve_module(db, module_name)? else {
+    let Some(module_id) = resolve_module(db, module_name)? else {
        return Ok(None);
    };
-    let module_path = module.path(db)?;
+    let module_path = module_id.path(db)?;

    if module_path.root() == &root_path {
        let Ok(normalized) = path.canonicalize() else {
@@ -377,7 +350,7 @@ pub fn file_to_module(db: &dyn SemanticDb, file: FileId) -> QueryResult<Option<M
        }

        // Path has been inserted by `resolved`
-        Ok(Some(module))
+        Ok(Some(module_id))
    } else {
        // This path is for a module with the same name but in a module search path with a lower priority.
        // Ignore it.
@@ -390,100 +363,25 @@ pub fn file_to_module(db: &dyn SemanticDb, file: FileId) -> QueryResult<Option<M
 //////////////////////////////////////////////////////

 /// Changes the module search paths to `search_paths`.
-pub fn set_module_search_paths(db: &mut dyn SemanticDb, search_paths: ModuleResolutionInputs) {
+pub fn set_module_search_paths(db: &mut dyn SemanticDb, search_paths: Vec<ModuleSearchPath>) {
    let jar: &mut SemanticJar = db.jar_mut();

-    jar.module_resolver = ModuleResolver::new(search_paths.into_ordered_search_paths());
+    jar.module_resolver = ModuleResolver::new(search_paths);
 }

-/// Struct for holding the various paths that are put together
-/// to create an `OrderedSearchPatsh` instance
-///
-/// - `extra_paths` is a list of user-provided paths
-///   that should take first priority in the module resolution.
-///   Examples in other type checkers are mypy's MYPYPATH environment variable,
-///   or pyright's stubPath configuration setting.
-/// - `workspace_root` is the root of the workspace,
-///   used for finding first-party modules
-/// - `site-packages` is the path to the user's `site-packages` directory,
-///   where third-party packages from ``PyPI`` are installed
-/// - `custom_typeshed` is a path to standard-library typeshed stubs.
-///   Currently this has to be a directory that exists on disk.
-///   (TODO: fall back to vendored stubs if no custom directory is provided.)
-#[derive(Debug)]
-pub struct ModuleResolutionInputs {
-    pub extra_paths: Vec<PathBuf>,
-    pub workspace_root: PathBuf,
-    pub site_packages: Option<PathBuf>,
-    pub custom_typeshed: Option<PathBuf>,
-}
-
-impl ModuleResolutionInputs {
-    /// Implementation of PEP 561's module resolution order
-    /// (with some small, deliberate, differences)
-    fn into_ordered_search_paths(self) -> OrderedSearchPaths {
-        let ModuleResolutionInputs {
-            extra_paths,
-            workspace_root,
-            site_packages,
-            custom_typeshed,
-        } = self;
-
-        OrderedSearchPaths(
-            extra_paths
-                .into_iter()
-                .map(|path| ModuleSearchPath::new(path, ModuleSearchPathKind::Extra))
-                .chain(std::iter::once(ModuleSearchPath::new(
-                    workspace_root,
-                    ModuleSearchPathKind::FirstParty,
-                )))
-                // TODO fallback to vendored typeshed stubs if no custom typeshed directory is provided by the user
-                .chain(custom_typeshed.into_iter().map(|path| {
-                    ModuleSearchPath::new(
-                        path.join(TYPESHED_STDLIB_DIRECTORY),
-                        ModuleSearchPathKind::StandardLibrary,
-                    )
-                }))
-                .chain(site_packages.into_iter().map(|path| {
-                    ModuleSearchPath::new(path, ModuleSearchPathKind::SitePackagesThirdParty)
-                }))
-                // TODO vendor typeshed's third-party stubs as well as the stdlib and fallback to them as a final step
-                .collect(),
-        )
-    }
-}
-
-const TYPESHED_STDLIB_DIRECTORY: &str = "stdlib";
-
-/// A resolved module resolution order, implementing PEP 561
-/// (with some small, deliberate differences)
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
-struct OrderedSearchPaths(Vec<ModuleSearchPath>);
-
-impl Deref for OrderedSearchPaths {
-    type Target = [ModuleSearchPath];
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-/// Adds a module located at `path` to the resolver.
+/// Adds a module to the resolver.
 ///
 /// Returns `None` if the path doesn't resolve to a module.
 ///
-/// Returns `Some(module, other_modules)`, where `module` is the resolved module
-/// with file location `path`, and `other_modules` is a `Vec` of `ModuleData` instances.
-/// Each element in `other_modules` provides information regarding a single module that needs
-/// re-resolving because it was part of a namespace package and might now resolve differently.
-///
+/// Returns `Some` with the id of the module and the ids of the modules that need re-resolving
+/// because they were part of a namespace package and might now resolve differently.
 /// Note: This won't work with salsa because `Path` is not an ingredient.
 pub fn add_module(db: &mut dyn SemanticDb, path: &Path) -> Option<(Module, Vec<Arc<ModuleData>>)> {
    // No locking is required because we're holding a mutable reference to `modules`.

    // TODO This needs tests

-    // Note: Intentionally bypass caching here. Module should not be in the cache yet.
+    // Note: Intentionally by-pass caching here. Module should not be in the cache yet.
    let module = path_to_module(db, path).ok()??;

    // The code below is to handle the addition of `__init__.py` files.
@@ -507,15 +405,15 @@ pub fn add_module(db: &mut dyn SemanticDb, path: &Path) -> Option<(Module, Vec<A
    let jar: &mut SemanticJar = db.jar_mut();
    let modules = &mut jar.module_resolver;

-    modules.by_file.retain(|_, module| {
+    modules.by_file.retain(|_, id| {
        if modules
            .modules
-            .get(module)
+            .get(id)
            .unwrap()
            .name
            .starts_with(&parent_name)
        {
-            to_remove.push(*module);
+            to_remove.push(*id);
            false
        } else {
            true
@@ -524,8 +422,8 @@ pub fn add_module(db: &mut dyn SemanticDb, path: &Path) -> Option<(Module, Vec<A

    // TODO remove need for this vec
    let mut removed = Vec::with_capacity(to_remove.len());
-    for module in &to_remove {
-        removed.push(modules.remove_module(*module));
+    for id in &to_remove {
+        removed.push(modules.remove_module_by_id(*id));
    }

    Some((module, removed))
@@ -534,14 +432,14 @@ pub fn add_module(db: &mut dyn SemanticDb, path: &Path) -> Option<(Module, Vec<A
 #[derive(Default)]
 pub struct ModuleResolver {
    /// The search paths where modules are located (and searched). Corresponds to `sys.path` at runtime.
-    search_paths: OrderedSearchPaths,
+    search_paths: Vec<ModuleSearchPath>,

    // Locking: Locking is done by acquiring a (write) lock on `by_name`. This is because `by_name` is the primary
    // lookup method. Acquiring locks in any other ordering can result in deadlocks.
-    /// Looks up a module by name
+    /// Resolves a module name to it's module id.
    by_name: FxDashMap<ModuleName, Module>,

-    /// A map of all known modules to data about those modules
+    /// All known modules, indexed by the module id.
    modules: FxDashMap<Module, Arc<ModuleData>>,

    /// Lookup from absolute path to module.
@@ -551,7 +449,7 @@ pub struct ModuleResolver {
 }

 impl ModuleResolver {
-    fn new(search_paths: OrderedSearchPaths) -> Self {
+    pub fn new(search_paths: Vec<ModuleSearchPath>) -> Self {
        Self {
            search_paths,
            modules: FxDashMap::default(),
@@ -561,27 +459,24 @@ impl ModuleResolver {
        }
    }

-    /// Remove a module from the inner cache
-    pub(crate) fn remove_module_by_file(&mut self, file_id: FileId) {
+    pub(crate) fn remove_module(&mut self, file_id: FileId) {
        // No locking is required because we're holding a mutable reference to `self`.
-        let Some((_, module)) = self.by_file.remove(&file_id) else {
+        let Some((_, id)) = self.by_file.remove(&file_id) else {
            return;
        };

-        self.remove_module(module);
+        self.remove_module_by_id(id);
    }

-    fn remove_module(&mut self, module: Module) -> Arc<ModuleData> {
-        let (_, module_data) = self.modules.remove(&module).unwrap();
+    fn remove_module_by_id(&mut self, id: Module) -> Arc<ModuleData> {
+        let (_, module) = self.modules.remove(&id).unwrap();

-        self.by_name.remove(&module_data.name).unwrap();
+        self.by_name.remove(&module.name).unwrap();

-        // It's possible that multiple paths map to the same module.
-        // Search all other paths referencing the same module.
-        self.by_file
-            .retain(|_, current_module| *current_module != module);
+        // It's possible that multiple paths map to the same id. Search all other paths referencing the same module id.
+        self.by_file.retain(|_, current_id| *current_id != id);

-        module_data
+        module
    }
 }

@@ -610,19 +505,15 @@ impl ModulePath {
        Self { root, file_id }
    }

-    /// The search path that was used to locate the module
    pub fn root(&self) -> &ModuleSearchPath {
        &self.root
    }

-    /// The file containing the source code for the module
    pub fn file(&self) -> FileId {
        self.file_id
    }
 }

-/// Given a module name and a list of search paths in which to lookup modules,
-/// attempt to resolve the module name
 fn resolve_name(
    name: &ModuleName,
    search_paths: &[ModuleSearchPath],
@@ -744,9 +635,7 @@ enum PackageKind {
    /// A root package or module. E.g. `foo` in `foo.bar.baz` or just `foo`.
    Root,

-    /// A regular sub-package where the parent contains an `__init__.py`.
-    ///
-    /// For example, `bar` in `foo.bar` when the `foo` directory contains an `__init__.py`.
+    /// A regular sub-package where the parent contains an `__init__.py`. For example `bar` in `foo.bar` when the `foo` directory contains an `__init__.py`.
    Regular,

    /// A sub-package in a namespace package. A namespace package is a package without an `__init__.py`.
@@ -764,23 +653,21 @@ impl PackageKind {
 #[cfg(test)]
 mod tests {
    use std::num::NonZeroU32;
-    use std::path::PathBuf;

    use crate::db::tests::TestDb;
    use crate::db::SourceDb;
    use crate::module::{
        path_to_module, resolve_module, set_module_search_paths, ModuleKind, ModuleName,
-        ModuleResolutionInputs, TYPESHED_STDLIB_DIRECTORY,
+        ModuleSearchPath, ModuleSearchPathKind,
    };
-    use crate::semantic::Dependency;
+    use crate::symbols::Dependency;

    struct TestCase {
        temp_dir: tempfile::TempDir,
        db: TestDb,

-        src: PathBuf,
-        custom_typeshed: PathBuf,
-        site_packages: PathBuf,
+        src: ModuleSearchPath,
+        site_packages: ModuleSearchPath,
    }

    fn create_resolver() -> std::io::Result<TestCase> {
@@ -788,31 +675,25 @@ mod tests {

        let src = temp_dir.path().join("src");
        let site_packages = temp_dir.path().join("site_packages");
-        let custom_typeshed = temp_dir.path().join("typeshed");

        std::fs::create_dir(&src)?;
        std::fs::create_dir(&site_packages)?;
-        std::fs::create_dir(&custom_typeshed)?;

-        let src = src.canonicalize()?;
-        let site_packages = site_packages.canonicalize()?;
-        let custom_typeshed = custom_typeshed.canonicalize()?;
+        let src = ModuleSearchPath::new(src.canonicalize()?, ModuleSearchPathKind::FirstParty);
+        let site_packages = ModuleSearchPath::new(
+            site_packages.canonicalize()?,
+            ModuleSearchPathKind::ThirdParty,
+        );

-        let search_paths = ModuleResolutionInputs {
-            extra_paths: vec![],
-            workspace_root: src.clone(),
-            site_packages: Some(site_packages.clone()),
-            custom_typeshed: Some(custom_typeshed.clone()),
-        };
+        let roots = vec![src.clone(), site_packages.clone()];

        let mut db = TestDb::default();
-        set_module_search_paths(&mut db, search_paths);
+        set_module_search_paths(&mut db, roots);

        Ok(TestCase {
            temp_dir,
            db,
            src,
-            custom_typeshed,
            site_packages,
        })
    }
@@ -826,7 +707,7 @@ mod tests {
            ..
        } = create_resolver()?;

-        let foo_path = src.join("foo.py");
+        let foo_path = src.path().join("foo.py");
        std::fs::write(&foo_path, "print('Hello, world!')")?;

        let foo_module = resolve_module(&db, ModuleName::new("foo"))?.unwrap();
@@ -837,7 +718,7 @@ mod tests {
        );

        assert_eq!(ModuleName::new("foo"), foo_module.name(&db)?);
-        assert_eq!(&src, foo_module.path(&db)?.root().path());
+        assert_eq!(&src, foo_module.path(&db)?.root());
        assert_eq!(ModuleKind::Module, foo_module.kind(&db)?);
        assert_eq!(&foo_path, &*db.file_path(foo_module.path(&db)?.file()));

@@ -846,76 +727,6 @@ mod tests {
        Ok(())
    }

-    #[test]
-    fn stdlib() -> anyhow::Result<()> {
-        let TestCase {
-            db,
-            custom_typeshed,
-            ..
-        } = create_resolver()?;
-        let stdlib_dir = custom_typeshed.join(TYPESHED_STDLIB_DIRECTORY);
-        std::fs::create_dir_all(&stdlib_dir).unwrap();
-        let functools_path = stdlib_dir.join("functools.py");
-        std::fs::write(&functools_path, "def update_wrapper(): ...").unwrap();
-        let functools_module = resolve_module(&db, ModuleName::new("functools"))?.unwrap();
-
-        assert_eq!(
-            Some(functools_module),
-            resolve_module(&db, ModuleName::new("functools"))?
-        );
-        assert_eq!(&stdlib_dir, functools_module.path(&db)?.root().path());
-        assert_eq!(ModuleKind::Module, functools_module.kind(&db)?);
-        assert_eq!(
-            &functools_path,
-            &*db.file_path(functools_module.path(&db)?.file())
-        );
-
-        assert_eq!(
-            Some(functools_module),
-            path_to_module(&db, &functools_path)?
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn first_party_precedence_over_stdlib() -> anyhow::Result<()> {
-        let TestCase {
-            db,
-            src,
-            custom_typeshed,
-            ..
-        } = create_resolver()?;
-
-        let stdlib_dir = custom_typeshed.join(TYPESHED_STDLIB_DIRECTORY);
-        std::fs::create_dir_all(&stdlib_dir).unwrap();
-        std::fs::create_dir_all(&src).unwrap();
-
-        let stdlib_functools_path = stdlib_dir.join("functools.py");
-        let first_party_functools_path = src.join("functools.py");
-        std::fs::write(stdlib_functools_path, "def update_wrapper(): ...").unwrap();
-        std::fs::write(&first_party_functools_path, "def update_wrapper(): ...").unwrap();
-        let functools_module = resolve_module(&db, ModuleName::new("functools"))?.unwrap();
-
-        assert_eq!(
-            Some(functools_module),
-            resolve_module(&db, ModuleName::new("functools"))?
-        );
-        assert_eq!(&src, functools_module.path(&db).unwrap().root().path());
-        assert_eq!(ModuleKind::Module, functools_module.kind(&db)?);
-        assert_eq!(
-            &first_party_functools_path,
-            &*db.file_path(functools_module.path(&db)?.file())
-        );
-
-        assert_eq!(
-            Some(functools_module),
-            path_to_module(&db, &first_party_functools_path)?
-        );
-
-        Ok(())
-    }
-
    #[test]
    fn resolve_package() -> anyhow::Result<()> {
        let TestCase {
@@ -925,7 +736,7 @@ mod tests {
            ..
        } = create_resolver()?;

-        let foo_dir = src.join("foo");
+        let foo_dir = src.path().join("foo");
        let foo_path = foo_dir.join("__init__.py");
        std::fs::create_dir(&foo_dir)?;
        std::fs::write(&foo_path, "print('Hello, world!')")?;
@@ -933,7 +744,7 @@ mod tests {
        let foo_module = resolve_module(&db, ModuleName::new("foo"))?.unwrap();

        assert_eq!(ModuleName::new("foo"), foo_module.name(&db)?);
-        assert_eq!(&src, foo_module.path(&db)?.root().path());
+        assert_eq!(&src, foo_module.path(&db)?.root());
        assert_eq!(&foo_path, &*db.file_path(foo_module.path(&db)?.file()));

        assert_eq!(Some(foo_module), path_to_module(&db, &foo_path)?);
@@ -953,17 +764,17 @@ mod tests {
            ..
        } = create_resolver()?;

-        let foo_dir = src.join("foo");
+        let foo_dir = src.path().join("foo");
        let foo_init = foo_dir.join("__init__.py");
        std::fs::create_dir(&foo_dir)?;
        std::fs::write(&foo_init, "print('Hello, world!')")?;

-        let foo_py = src.join("foo.py");
+        let foo_py = src.path().join("foo.py");
        std::fs::write(&foo_py, "print('Hello, world!')")?;

        let foo_module = resolve_module(&db, ModuleName::new("foo"))?.unwrap();

-        assert_eq!(&src, foo_module.path(&db)?.root().path());
+        assert_eq!(&src, foo_module.path(&db)?.root());
        assert_eq!(&foo_init, &*db.file_path(foo_module.path(&db)?.file()));
        assert_eq!(ModuleKind::Package, foo_module.kind(&db)?);

@@ -982,14 +793,14 @@ mod tests {
            ..
        } = create_resolver()?;

-        let foo_stub = src.join("foo.pyi");
-        let foo_py = src.join("foo.py");
+        let foo_stub = src.path().join("foo.pyi");
+        let foo_py = src.path().join("foo.py");
        std::fs::write(&foo_stub, "x: int")?;
        std::fs::write(&foo_py, "print('Hello, world!')")?;

        let foo = resolve_module(&db, ModuleName::new("foo"))?.unwrap();

-        assert_eq!(&src, foo.path(&db)?.root().path());
+        assert_eq!(&src, foo.path(&db)?.root());
        assert_eq!(&foo_stub, &*db.file_path(foo.path(&db)?.file()));

        assert_eq!(Some(foo), path_to_module(&db, &foo_stub)?);
@@ -1007,7 +818,7 @@ mod tests {
            ..
        } = create_resolver()?;

-        let foo = src.join("foo");
+        let foo = src.path().join("foo");
        let bar = foo.join("bar");
        let baz = bar.join("baz.py");

@@ -1018,7 +829,7 @@ mod tests {

        let baz_module = resolve_module(&db, ModuleName::new("foo.bar.baz"))?.unwrap();

-        assert_eq!(&src, baz_module.path(&db)?.root().path());
+        assert_eq!(&src, baz_module.path(&db)?.root());
        assert_eq!(&baz, &*db.file_path(baz_module.path(&db)?.file()));

        assert_eq!(Some(baz_module), path_to_module(&db, &baz)?);
@@ -1033,7 +844,6 @@ mod tests {
            temp_dir: _,
            src,
            site_packages,
-            ..
        } = create_resolver()?;

        // From [PEP420](https://peps.python.org/pep-0420/#nested-namespace-packages).
@@ -1049,14 +859,14 @@ mod tests {
        //       two.py
        // ```

-        let parent1 = src.join("parent");
+        let parent1 = src.path().join("parent");
        let child1 = parent1.join("child");
        let one = child1.join("one.py");

        std::fs::create_dir_all(child1)?;
        std::fs::write(&one, "print('Hello, world!')")?;

-        let parent2 = site_packages.join("parent");
+        let parent2 = site_packages.path().join("parent");
        let child2 = parent2.join("child");
        let two = child2.join("two.py");

@@ -1080,7 +890,6 @@ mod tests {
            temp_dir: _,
            src,
            site_packages,
-            ..
        } = create_resolver()?;

        // Adopted test case from the [PEP420 examples](https://peps.python.org/pep-0420/#nested-namespace-packages).
@@ -1096,7 +905,7 @@ mod tests {
        //       two.py
        // ```

-        let parent1 = src.join("parent");
+        let parent1 = src.path().join("parent");
        let child1 = parent1.join("child");
        let one = child1.join("one.py");

@@ -1104,7 +913,7 @@ mod tests {
        std::fs::write(child1.join("__init__.py"), "print('Hello, world!')")?;
        std::fs::write(&one, "print('Hello, world!')")?;

-        let parent2 = site_packages.join("parent");
+        let parent2 = site_packages.path().join("parent");
        let child2 = parent2.join("child");
        let two = child2.join("two.py");

@@ -1129,18 +938,17 @@ mod tests {
            src,
            site_packages,
            temp_dir: _temp_dir,
-            ..
        } = create_resolver()?;

-        let foo_src = src.join("foo.py");
-        let foo_site_packages = site_packages.join("foo.py");
+        let foo_src = src.path().join("foo.py");
+        let foo_site_packages = site_packages.path().join("foo.py");

        std::fs::write(&foo_src, "")?;
        std::fs::write(&foo_site_packages, "")?;

        let foo_module = resolve_module(&db, ModuleName::new("foo"))?.unwrap();

-        assert_eq!(&src, foo_module.path(&db)?.root().path());
+        assert_eq!(&src, foo_module.path(&db)?.root());
        assert_eq!(&foo_src, &*db.file_path(foo_module.path(&db)?.file()));

        assert_eq!(Some(foo_module), path_to_module(&db, &foo_src)?);
@@ -1159,8 +967,8 @@ mod tests {
            ..
        } = create_resolver()?;

-        let foo = src.join("foo.py");
-        let bar = src.join("bar.py");
+        let foo = src.path().join("foo.py");
+        let bar = src.path().join("bar.py");

        std::fs::write(&foo, "")?;
        std::os::unix::fs::symlink(&foo, &bar)?;
@@ -1170,12 +978,12 @@ mod tests {

        assert_ne!(foo_module, bar_module);

-        assert_eq!(&src, foo_module.path(&db)?.root().path());
+        assert_eq!(&src, foo_module.path(&db)?.root());
        assert_eq!(&foo, &*db.file_path(foo_module.path(&db)?.file()));

        // Bar has a different name but it should point to the same file.

-        assert_eq!(&src, bar_module.path(&db)?.root().path());
+        assert_eq!(&src, bar_module.path(&db)?.root());
        assert_eq!(foo_module.path(&db)?.file(), bar_module.path(&db)?.file());
        assert_eq!(&foo, &*db.file_path(bar_module.path(&db)?.file()));

@@ -1194,7 +1002,7 @@ mod tests {
            ..
        } = create_resolver()?;

-        let foo_dir = src.join("foo");
+        let foo_dir = src.path().join("foo");
        let foo_path = foo_dir.join("__init__.py");
        let bar_path = foo_dir.join("bar.py");

--- a/crates/red_knot/src/parse.rs
+++ b/crates/red_knot/src/parse.rs
@@ -1,33 +1,85 @@
 use std::ops::{Deref, DerefMut};
 use std::sync::Arc;

-use ruff_python_ast::ModModule;
-use ruff_python_parser::Parsed;
+use ruff_python_ast as ast;
+use ruff_python_parser::{Mode, ParseError};
+use ruff_text_size::{Ranged, TextRange};

 use crate::cache::KeyValueCache;
 use crate::db::{QueryResult, SourceDb};
 use crate::files::FileId;
 use crate::source::source_text;

+#[derive(Debug, Clone, PartialEq)]
+pub struct Parsed {
+    inner: Arc<ParsedInner>,
+}
+
+#[derive(Debug, PartialEq)]
+struct ParsedInner {
+    ast: ast::ModModule,
+    errors: Vec<ParseError>,
+}
+
+impl Parsed {
+    fn new(ast: ast::ModModule, errors: Vec<ParseError>) -> Self {
+        Self {
+            inner: Arc::new(ParsedInner { ast, errors }),
+        }
+    }
+
+    pub(crate) fn from_text(text: &str) -> Self {
+        let result = ruff_python_parser::parse(text, Mode::Module);
+
+        let (module, errors) = match result {
+            Ok(ast::Mod::Module(module)) => (module, vec![]),
+            Ok(ast::Mod::Expression(expression)) => (
+                ast::ModModule {
+                    range: expression.range(),
+                    body: vec![ast::Stmt::Expr(ast::StmtExpr {
+                        range: expression.range(),
+                        value: expression.body,
+                    })],
+                },
+                vec![],
+            ),
+            Err(errors) => (
+                ast::ModModule {
+                    range: TextRange::default(),
+                    body: Vec::new(),
+                },
+                vec![errors],
+            ),
+        };
+
+        Parsed::new(module, errors)
+    }
+
+    pub fn ast(&self) -> &ast::ModModule {
+        &self.inner.ast
+    }
+
+    pub fn errors(&self) -> &[ParseError] {
+        &self.inner.errors
+    }
+}
+
 #[tracing::instrument(level = "debug", skip(db))]
-pub(crate) fn parse(db: &dyn SourceDb, file_id: FileId) -> QueryResult<Arc<Parsed<ModModule>>> {
+pub(crate) fn parse(db: &dyn SourceDb, file_id: FileId) -> QueryResult<Parsed> {
    let jar = db.jar()?;

    jar.parsed.get(&file_id, |file_id| {
        let source = source_text(db, *file_id)?;

-        Ok(Arc::new(ruff_python_parser::parse_unchecked_source(
-            source.text(),
-            source.kind().into(),
-        )))
+        Ok(Parsed::from_text(source.text()))
    })
 }

 #[derive(Debug, Default)]
-pub struct ParsedStorage(KeyValueCache<FileId, Arc<Parsed<ModModule>>>);
+pub struct ParsedStorage(KeyValueCache<FileId, Parsed>);

 impl Deref for ParsedStorage {
-    type Target = KeyValueCache<FileId, Arc<Parsed<ModModule>>>;
+    type Target = KeyValueCache<FileId, Parsed>;

    fn deref(&self) -> &Self::Target {
        &self.0
--- a/crates/red_knot/src/program/check.rs
+++ b/crates/red_knot/src/program/check.rs
@@ -6,7 +6,7 @@ use crate::files::FileId;
 use crate::lint::{lint_semantic, lint_syntax, Diagnostics};
 use crate::module::{file_to_module, resolve_module};
 use crate::program::Program;
-use crate::semantic::{semantic_index, Dependency};
+use crate::symbols::{symbol_table, Dependency};

 impl Program {
    /// Checks all open files in the workspace and its dependencies.
@@ -28,8 +28,8 @@ impl Program {
    fn check_file(&self, file: FileId, context: &CheckFileContext) -> QueryResult<Diagnostics> {
        self.cancelled()?;

-        let index = semantic_index(self, file)?;
-        let dependencies = index.symbol_table().dependencies();
+        let symbol_table = symbol_table(self, file)?;
+        let dependencies = symbol_table.dependencies();

        if !dependencies.is_empty() {
            let module = file_to_module(self, file)?;
--- a/crates/red_knot/src/program/mod.rs
+++ b/crates/red_knot/src/program/mod.rs
@@ -42,8 +42,8 @@ impl Program {

        let (source, semantic, lint) = self.jars_mut();
        for change in aggregated_changes.iter() {
-            semantic.module_resolver.remove_module_by_file(change.id);
-            semantic.semantic_indices.remove(&change.id);
+            semantic.module_resolver.remove_module(change.id);
+            semantic.symbol_tables.remove(&change.id);
            source.sources.remove(&change.id);
            source.parsed.remove(&change.id);
            // TODO: remove all dependent modules as well
--- a/crates/red_knot/src/semantic.rs
+++ b/crates/red_knot/src/semantic.rs
@@ -1,882 +0,0 @@
-use std::num::NonZeroU32;
-
-use ruff_python_ast as ast;
-use ruff_python_ast::visitor::source_order::SourceOrderVisitor;
-use ruff_python_ast::AstNode;
-
-use crate::ast_ids::{NodeKey, TypedNodeKey};
-use crate::cache::KeyValueCache;
-use crate::db::{QueryResult, SemanticDb, SemanticJar};
-use crate::files::FileId;
-use crate::module::Module;
-use crate::module::ModuleName;
-use crate::parse::parse;
-use crate::Name;
-pub(crate) use definitions::Definition;
-use definitions::{ImportDefinition, ImportFromDefinition};
-pub(crate) use flow_graph::ConstrainedDefinition;
-use flow_graph::{FlowGraph, FlowGraphBuilder, FlowNodeId, ReachableDefinitionsIterator};
-use ruff_index::{newtype_index, IndexVec};
-use rustc_hash::FxHashMap;
-use std::ops::{Deref, DerefMut};
-use std::sync::Arc;
-pub(crate) use symbol_table::{Dependency, SymbolId};
-use symbol_table::{ScopeId, ScopeKind, SymbolFlags, SymbolTable, SymbolTableBuilder};
-pub(crate) use types::{infer_definition_type, infer_symbol_public_type, Type, TypeStore};
-
-mod definitions;
-mod flow_graph;
-mod symbol_table;
-mod types;
-
-#[tracing::instrument(level = "debug", skip(db))]
-pub fn semantic_index(db: &dyn SemanticDb, file_id: FileId) -> QueryResult<Arc<SemanticIndex>> {
-    let jar: &SemanticJar = db.jar()?;
-
-    jar.semantic_indices.get(&file_id, |_| {
-        let parsed = parse(db.upcast(), file_id)?;
-        Ok(Arc::from(SemanticIndex::from_ast(parsed.syntax())))
-    })
-}
-
-#[tracing::instrument(level = "debug", skip(db))]
-pub fn resolve_global_symbol(
-    db: &dyn SemanticDb,
-    module: Module,
-    name: &str,
-) -> QueryResult<Option<GlobalSymbolId>> {
-    let file_id = module.path(db)?.file();
-    let symbol_table = &semantic_index(db, file_id)?.symbol_table;
-    let Some(symbol_id) = symbol_table.root_symbol_id_by_name(name) else {
-        return Ok(None);
-    };
-    Ok(Some(GlobalSymbolId { file_id, symbol_id }))
-}
-
-#[newtype_index]
-pub struct ExpressionId;
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct GlobalSymbolId {
-    pub(crate) file_id: FileId,
-    pub(crate) symbol_id: SymbolId,
-}
-
-#[derive(Debug)]
-pub struct SemanticIndex {
-    symbol_table: SymbolTable,
-    flow_graph: FlowGraph,
-    expressions: FxHashMap<NodeKey, ExpressionId>,
-    expressions_by_id: IndexVec<ExpressionId, NodeKey>,
-}
-
-impl SemanticIndex {
-    pub fn from_ast(module: &ast::ModModule) -> Self {
-        let root_scope_id = SymbolTable::root_scope_id();
-        let mut indexer = SemanticIndexer {
-            symbol_table_builder: SymbolTableBuilder::new(),
-            flow_graph_builder: FlowGraphBuilder::new(),
-            scopes: vec![ScopeState {
-                scope_id: root_scope_id,
-                current_flow_node_id: FlowGraph::start(),
-            }],
-            expressions: FxHashMap::default(),
-            expressions_by_id: IndexVec::default(),
-            current_definition: None,
-        };
-        indexer.visit_body(&module.body);
-        indexer.finish()
-    }
-
-    fn resolve_expression_id<'a>(
-        &self,
-        ast: &'a ast::ModModule,
-        expression_id: ExpressionId,
-    ) -> ast::AnyNodeRef<'a> {
-        let node_key = self.expressions_by_id[expression_id];
-        node_key
-            .resolve(ast.as_any_node_ref())
-            .expect("node to resolve")
-    }
-
-    /// Return an iterator over all definitions of `symbol_id` reachable from `use_expr`. The value
-    /// of `symbol_id` in `use_expr` must originate from one of the iterated definitions (or from
-    /// an external reassignment of the name outside of this scope).
-    pub fn reachable_definitions(
-        &self,
-        symbol_id: SymbolId,
-        use_expr: &ast::Expr,
-    ) -> ReachableDefinitionsIterator {
-        let expression_id = self.expression_id(use_expr);
-        ReachableDefinitionsIterator::new(
-            &self.flow_graph,
-            symbol_id,
-            self.flow_graph.for_expr(expression_id),
-        )
-    }
-
-    pub fn expression_id(&self, expression: &ast::Expr) -> ExpressionId {
-        self.expressions[&NodeKey::from_node(expression.into())]
-    }
-
-    pub fn symbol_table(&self) -> &SymbolTable {
-        &self.symbol_table
-    }
-}
-
-#[derive(Debug)]
-struct ScopeState {
-    scope_id: ScopeId,
-    current_flow_node_id: FlowNodeId,
-}
-
-#[derive(Debug)]
-struct SemanticIndexer {
-    symbol_table_builder: SymbolTableBuilder,
-    flow_graph_builder: FlowGraphBuilder,
-    scopes: Vec<ScopeState>,
-    /// the definition whose target(s) we are currently walking
-    current_definition: Option<Definition>,
-    expressions: FxHashMap<NodeKey, ExpressionId>,
-    expressions_by_id: IndexVec<ExpressionId, NodeKey>,
-}
-
-impl SemanticIndexer {
-    pub(crate) fn finish(mut self) -> SemanticIndex {
-        let SemanticIndexer {
-            flow_graph_builder,
-            symbol_table_builder,
-            ..
-        } = self;
-        self.expressions.shrink_to_fit();
-        self.expressions_by_id.shrink_to_fit();
-        SemanticIndex {
-            flow_graph: flow_graph_builder.finish(),
-            symbol_table: symbol_table_builder.finish(),
-            expressions: self.expressions,
-            expressions_by_id: self.expressions_by_id,
-        }
-    }
-
-    fn set_current_flow_node(&mut self, new_flow_node_id: FlowNodeId) {
-        let scope_state = self.scopes.last_mut().expect("scope stack is never empty");
-        scope_state.current_flow_node_id = new_flow_node_id;
-    }
-
-    fn current_flow_node(&self) -> FlowNodeId {
-        self.scopes
-            .last()
-            .expect("scope stack is never empty")
-            .current_flow_node_id
-    }
-
-    fn add_or_update_symbol(&mut self, identifier: &str, flags: SymbolFlags) -> SymbolId {
-        self.symbol_table_builder
-            .add_or_update_symbol(self.cur_scope(), identifier, flags)
-    }
-
-    fn add_or_update_symbol_with_def(
-        &mut self,
-        identifier: &str,
-        definition: Definition,
-    ) -> SymbolId {
-        let symbol_id = self.add_or_update_symbol(identifier, SymbolFlags::IS_DEFINED);
-        self.symbol_table_builder
-            .add_definition(symbol_id, definition.clone());
-        let new_flow_node_id =
-            self.flow_graph_builder
-                .add_definition(symbol_id, definition, self.current_flow_node());
-        self.set_current_flow_node(new_flow_node_id);
-        symbol_id
-    }
-
-    fn push_scope(
-        &mut self,
-        name: &str,
-        kind: ScopeKind,
-        definition: Option<Definition>,
-        defining_symbol: Option<SymbolId>,
-    ) -> ScopeId {
-        let scope_id = self.symbol_table_builder.add_child_scope(
-            self.cur_scope(),
-            name,
-            kind,
-            definition,
-            defining_symbol,
-        );
-        self.scopes.push(ScopeState {
-            scope_id,
-            current_flow_node_id: FlowGraph::start(),
-        });
-        scope_id
-    }
-
-    fn pop_scope(&mut self) -> ScopeId {
-        self.scopes
-            .pop()
-            .expect("Scope stack should never be empty")
-            .scope_id
-    }
-
-    fn cur_scope(&self) -> ScopeId {
-        self.scopes
-            .last()
-            .expect("Scope stack should never be empty")
-            .scope_id
-    }
-
-    fn record_scope_for_node(&mut self, node_key: NodeKey, scope_id: ScopeId) {
-        self.symbol_table_builder
-            .record_scope_for_node(node_key, scope_id);
-    }
-
-    fn insert_constraint(&mut self, expr: &ast::Expr) {
-        let node_key = NodeKey::from_node(expr.into());
-        let expression_id = self.expressions[&node_key];
-        let constraint = self
-            .flow_graph_builder
-            .add_constraint(self.current_flow_node(), expression_id);
-        self.set_current_flow_node(constraint);
-    }
-
-    fn with_type_params(
-        &mut self,
-        name: &str,
-        params: &Option<Box<ast::TypeParams>>,
-        definition: Option<Definition>,
-        defining_symbol: Option<SymbolId>,
-        nested: impl FnOnce(&mut Self) -> ScopeId,
-    ) -> ScopeId {
-        if let Some(type_params) = params {
-            self.push_scope(name, ScopeKind::Annotation, definition, defining_symbol);
-            for type_param in &type_params.type_params {
-                let name = match type_param {
-                    ast::TypeParam::TypeVar(ast::TypeParamTypeVar { name, .. }) => name,
-                    ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, .. }) => name,
-                    ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple { name, .. }) => name,
-                };
-                self.add_or_update_symbol(name, SymbolFlags::IS_DEFINED);
-            }
-        }
-        let scope_id = nested(self);
-        if params.is_some() {
-            self.pop_scope();
-        }
-        scope_id
-    }
-}
-
-impl SourceOrderVisitor<'_> for SemanticIndexer {
-    fn visit_expr(&mut self, expr: &ast::Expr) {
-        let node_key = NodeKey::from_node(expr.into());
-        let expression_id = self.expressions_by_id.push(node_key);
-
-        let flow_expression_id = self
-            .flow_graph_builder
-            .record_expr(self.current_flow_node());
-        debug_assert_eq!(expression_id, flow_expression_id);
-
-        let symbol_expression_id = self
-            .symbol_table_builder
-            .record_expression(self.cur_scope());
-
-        debug_assert_eq!(expression_id, symbol_expression_id);
-
-        self.expressions.insert(node_key, expression_id);
-
-        match expr {
-            ast::Expr::Name(ast::ExprName { id, ctx, .. }) => {
-                let 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(),
-                };
-                self.add_or_update_symbol(id, flags);
-                if flags.contains(SymbolFlags::IS_DEFINED) {
-                    if let Some(curdef) = self.current_definition.clone() {
-                        self.add_or_update_symbol_with_def(id, curdef);
-                    }
-                }
-                ast::visitor::source_order::walk_expr(self, expr);
-            }
-            ast::Expr::Named(node) => {
-                debug_assert!(self.current_definition.is_none());
-                self.current_definition =
-                    Some(Definition::NamedExpr(TypedNodeKey::from_node(node)));
-                // TODO walrus in comprehensions is implicitly nonlocal
-                self.visit_expr(&node.target);
-                self.current_definition = None;
-                self.visit_expr(&node.value);
-            }
-            ast::Expr::If(ast::ExprIf {
-                body, test, orelse, ..
-            }) => {
-                // TODO detect statically known truthy or falsy test (via type inference, not naive
-                // AST inspection, so we can't simplify here, need to record test expression in CFG
-                // for later checking)
-
-                self.visit_expr(test);
-
-                let if_branch = self.flow_graph_builder.add_branch(self.current_flow_node());
-
-                self.set_current_flow_node(if_branch);
-                self.insert_constraint(test);
-                self.visit_expr(body);
-
-                let post_body = self.current_flow_node();
-
-                self.set_current_flow_node(if_branch);
-                self.visit_expr(orelse);
-
-                let post_else = self
-                    .flow_graph_builder
-                    .add_phi(self.current_flow_node(), post_body);
-
-                self.set_current_flow_node(post_else);
-            }
-            _ => {
-                ast::visitor::source_order::walk_expr(self, expr);
-            }
-        }
-    }
-
-    fn visit_stmt(&mut self, stmt: &ast::Stmt) {
-        // TODO need to capture more definition statements here
-        match stmt {
-            ast::Stmt::ClassDef(node) => {
-                let node_key = TypedNodeKey::from_node(node);
-                let def = Definition::ClassDef(node_key.clone());
-                let symbol_id = self.add_or_update_symbol_with_def(&node.name, def.clone());
-                for decorator in &node.decorator_list {
-                    self.visit_decorator(decorator);
-                }
-                let scope_id = self.with_type_params(
-                    &node.name,
-                    &node.type_params,
-                    Some(def.clone()),
-                    Some(symbol_id),
-                    |indexer| {
-                        if let Some(arguments) = &node.arguments {
-                            indexer.visit_arguments(arguments);
-                        }
-                        let scope_id = indexer.push_scope(
-                            &node.name,
-                            ScopeKind::Class,
-                            Some(def.clone()),
-                            Some(symbol_id),
-                        );
-                        indexer.visit_body(&node.body);
-                        indexer.pop_scope();
-                        scope_id
-                    },
-                );
-                self.record_scope_for_node(*node_key.erased(), scope_id);
-            }
-            ast::Stmt::FunctionDef(node) => {
-                let node_key = TypedNodeKey::from_node(node);
-                let def = Definition::FunctionDef(node_key.clone());
-                let symbol_id = self.add_or_update_symbol_with_def(&node.name, def.clone());
-                for decorator in &node.decorator_list {
-                    self.visit_decorator(decorator);
-                }
-                let scope_id = self.with_type_params(
-                    &node.name,
-                    &node.type_params,
-                    Some(def.clone()),
-                    Some(symbol_id),
-                    |indexer| {
-                        indexer.visit_parameters(&node.parameters);
-                        for expr in &node.returns {
-                            indexer.visit_annotation(expr);
-                        }
-                        let scope_id = indexer.push_scope(
-                            &node.name,
-                            ScopeKind::Function,
-                            Some(def.clone()),
-                            Some(symbol_id),
-                        );
-                        indexer.visit_body(&node.body);
-                        indexer.pop_scope();
-                        scope_id
-                    },
-                );
-                self.record_scope_for_node(*node_key.erased(), scope_id);
-            }
-            ast::Stmt::Import(ast::StmtImport { names, .. }) => {
-                for alias in names {
-                    let symbol_name = if let Some(asname) = &alias.asname {
-                        asname.id.as_str()
-                    } else {
-                        alias.name.id.split('.').next().unwrap()
-                    };
-
-                    let module = ModuleName::new(&alias.name.id);
-
-                    let def = Definition::Import(ImportDefinition {
-                        module: module.clone(),
-                    });
-                    self.add_or_update_symbol_with_def(symbol_name, def);
-                    self.symbol_table_builder
-                        .add_dependency(Dependency::Module(module));
-                }
-            }
-            ast::Stmt::ImportFrom(ast::StmtImportFrom {
-                module,
-                names,
-                level,
-                ..
-            }) => {
-                let module = module.as_ref().map(|m| ModuleName::new(&m.id));
-
-                for alias in names {
-                    let symbol_name = if let Some(asname) = &alias.asname {
-                        asname.id.as_str()
-                    } else {
-                        alias.name.id.as_str()
-                    };
-                    let def = Definition::ImportFrom(ImportFromDefinition {
-                        module: module.clone(),
-                        name: Name::new(&alias.name.id),
-                        level: *level,
-                    });
-                    self.add_or_update_symbol_with_def(symbol_name, def);
-                }
-
-                let dependency = if let Some(module) = module {
-                    match NonZeroU32::new(*level) {
-                        Some(level) => Dependency::Relative {
-                            level,
-                            module: Some(module),
-                        },
-                        None => Dependency::Module(module),
-                    }
-                } else {
-                    Dependency::Relative {
-                        level: NonZeroU32::new(*level)
-                            .expect("Import without a module to have a level > 0"),
-                        module,
-                    }
-                };
-
-                self.symbol_table_builder.add_dependency(dependency);
-            }
-            ast::Stmt::Assign(node) => {
-                debug_assert!(self.current_definition.is_none());
-                self.visit_expr(&node.value);
-                self.current_definition =
-                    Some(Definition::Assignment(TypedNodeKey::from_node(node)));
-                for expr in &node.targets {
-                    self.visit_expr(expr);
-                }
-
-                self.current_definition = None;
-            }
-            ast::Stmt::If(node) => {
-                // TODO detect statically known truthy or falsy test (via type inference, not naive
-                // AST inspection, so we can't simplify here, need to record test expression in CFG
-                // for later checking)
-
-                // we visit the if "test" condition first regardless
-                self.visit_expr(&node.test);
-
-                // create branch node: does the if test pass or not?
-                let if_branch = self.flow_graph_builder.add_branch(self.current_flow_node());
-
-                // visit the body of the `if` clause
-                self.set_current_flow_node(if_branch);
-                self.insert_constraint(&node.test);
-                self.visit_body(&node.body);
-
-                // Flow node for the last if/elif condition branch; represents the "no branch
-                // taken yet" possibility (where "taking a branch" means that the condition in an
-                // if or elif evaluated to true and control flow went into that clause).
-                let mut prior_branch = if_branch;
-
-                // Flow node for the state after the prior if/elif/else clause; represents "we have
-                // taken one of the branches up to this point." Initially set to the post-if-clause
-                // state, later will be set to the phi node joining that possible path with the
-                // possibility that we took a later if/elif/else clause instead.
-                let mut post_prior_clause = self.current_flow_node();
-
-                // Flag to mark if the final clause is an "else" -- if so, that means the "match no
-                // clauses" path is not possible, we have to go through one of the clauses.
-                let mut last_branch_is_else = false;
-
-                for clause in &node.elif_else_clauses {
-                    if let Some(test) = &clause.test {
-                        self.visit_expr(test);
-                        // This is an elif clause. Create a new branch node. Its predecessor is the
-                        // previous branch node, because we can only take one branch in an entire
-                        // if/elif/else chain, so if we take this branch, it can only be because we
-                        // didn't take the previous one.
-                        prior_branch = self.flow_graph_builder.add_branch(prior_branch);
-                        self.set_current_flow_node(prior_branch);
-                        self.insert_constraint(test);
-                    } else {
-                        // This is an else clause. No need to create a branch node; there's no
-                        // branch here, if we haven't taken any previous branch, we definitely go
-                        // into the "else" clause.
-                        self.set_current_flow_node(prior_branch);
-                        last_branch_is_else = true;
-                    }
-                    self.visit_elif_else_clause(clause);
-                    // Update `post_prior_clause` to a new phi node joining the possibility that we
-                    // took any of the previous branches with the possibility that we took the one
-                    // just visited.
-                    post_prior_clause = self
-                        .flow_graph_builder
-                        .add_phi(self.current_flow_node(), post_prior_clause);
-                }
-
-                if !last_branch_is_else {
-                    // Final branch was not an "else", which means it's possible we took zero
-                    // branches in the entire if/elif chain, so we need one more phi node to join
-                    // the "no branches taken" possibility.
-                    post_prior_clause = self
-                        .flow_graph_builder
-                        .add_phi(post_prior_clause, prior_branch);
-                }
-
-                // Onward, with current flow node set to our final Phi node.
-                self.set_current_flow_node(post_prior_clause);
-            }
-            _ => {
-                ast::visitor::source_order::walk_stmt(self, stmt);
-            }
-        }
-    }
-}
-
-#[derive(Debug, Default)]
-pub struct SemanticIndexStorage(KeyValueCache<FileId, Arc<SemanticIndex>>);
-
-impl Deref for SemanticIndexStorage {
-    type Target = KeyValueCache<FileId, Arc<SemanticIndex>>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl DerefMut for SemanticIndexStorage {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::semantic::symbol_table::{Symbol, SymbolIterator};
-    use ruff_python_ast as ast;
-    use ruff_python_ast::ModModule;
-    use ruff_python_parser::{Mode, Parsed};
-
-    use super::{Definition, ScopeKind, SemanticIndex, SymbolId};
-
-    fn parse(code: &str) -> Parsed<ModModule> {
-        ruff_python_parser::parse_unchecked(code, Mode::Module)
-            .try_into_module()
-            .unwrap()
-    }
-
-    fn names<I>(it: SymbolIterator<I>) -> Vec<&str>
-    where
-        I: Iterator<Item = SymbolId>,
-    {
-        let mut symbols: Vec<_> = it.map(Symbol::name).collect();
-        symbols.sort_unstable();
-        symbols
-    }
-
-    #[test]
-    fn empty() {
-        let parsed = parse("");
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()).len(), 0);
-    }
-
-    #[test]
-    fn simple() {
-        let parsed = parse("x");
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["x"]);
-        assert_eq!(
-            table
-                .definitions(table.root_symbol_id_by_name("x").unwrap())
-                .len(),
-            0
-        );
-    }
-
-    #[test]
-    fn annotation_only() {
-        let parsed = parse("x: int");
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["int", "x"]);
-        // TODO record definition
-    }
-
-    #[test]
-    fn import() {
-        let parsed = parse("import foo");
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["foo"]);
-        assert_eq!(
-            table
-                .definitions(table.root_symbol_id_by_name("foo").unwrap())
-                .len(),
-            1
-        );
-    }
-
-    #[test]
-    fn import_sub() {
-        let parsed = parse("import foo.bar");
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["foo"]);
-    }
-
-    #[test]
-    fn import_as() {
-        let parsed = parse("import foo.bar as baz");
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["baz"]);
-    }
-
-    #[test]
-    fn import_from() {
-        let parsed = parse("from bar import foo");
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["foo"]);
-        assert_eq!(
-            table
-                .definitions(table.root_symbol_id_by_name("foo").unwrap())
-                .len(),
-            1
-        );
-        assert!(
-            table.root_symbol_id_by_name("foo").is_some_and(|sid| {
-                let s = sid.symbol(&table);
-                s.is_defined() || !s.is_used()
-            }),
-            "symbols that are defined get the defined flag"
-        );
-    }
-
-    #[test]
-    fn assign() {
-        let parsed = parse("x = foo");
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["foo", "x"]);
-        assert_eq!(
-            table
-                .definitions(table.root_symbol_id_by_name("x").unwrap())
-                .len(),
-            1
-        );
-        assert!(
-            table.root_symbol_id_by_name("foo").is_some_and(|sid| {
-                let s = sid.symbol(&table);
-                !s.is_defined() && s.is_used()
-            }),
-            "a symbol used but not defined in a scope should have only the used flag"
-        );
-    }
-
-    #[test]
-    fn class_scope() {
-        let parsed = parse(
-            "
-                class C:
-                    x = 1
-                y = 2
-                ",
-        );
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["C", "y"]);
-        let scopes = table.root_child_scope_ids();
-        assert_eq!(scopes.len(), 1);
-        let c_scope = scopes[0].scope(&table);
-        assert_eq!(c_scope.kind(), ScopeKind::Class);
-        assert_eq!(c_scope.name(), "C");
-        assert_eq!(names(table.symbols_for_scope(scopes[0])), vec!["x"]);
-        assert_eq!(
-            table
-                .definitions(table.root_symbol_id_by_name("C").unwrap())
-                .len(),
-            1
-        );
-    }
-
-    #[test]
-    fn func_scope() {
-        let parsed = parse(
-            "
-                def func():
-                    x = 1
-                y = 2
-                ",
-        );
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["func", "y"]);
-        let scopes = table.root_child_scope_ids();
-        assert_eq!(scopes.len(), 1);
-        let func_scope = scopes[0].scope(&table);
-        assert_eq!(func_scope.kind(), ScopeKind::Function);
-        assert_eq!(func_scope.name(), "func");
-        assert_eq!(names(table.symbols_for_scope(scopes[0])), vec!["x"]);
-        assert_eq!(
-            table
-                .definitions(table.root_symbol_id_by_name("func").unwrap())
-                .len(),
-            1
-        );
-    }
-
-    #[test]
-    fn dupes() {
-        let parsed = parse(
-            "
-                def func():
-                    x = 1
-                def func():
-                    y = 2
-                ",
-        );
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["func"]);
-        let scopes = table.root_child_scope_ids();
-        assert_eq!(scopes.len(), 2);
-        let func_scope_1 = scopes[0].scope(&table);
-        let func_scope_2 = scopes[1].scope(&table);
-        assert_eq!(func_scope_1.kind(), ScopeKind::Function);
-        assert_eq!(func_scope_1.name(), "func");
-        assert_eq!(func_scope_2.kind(), ScopeKind::Function);
-        assert_eq!(func_scope_2.name(), "func");
-        assert_eq!(names(table.symbols_for_scope(scopes[0])), vec!["x"]);
-        assert_eq!(names(table.symbols_for_scope(scopes[1])), vec!["y"]);
-        assert_eq!(
-            table
-                .definitions(table.root_symbol_id_by_name("func").unwrap())
-                .len(),
-            2
-        );
-    }
-
-    #[test]
-    fn generic_func() {
-        let parsed = parse(
-            "
-                def func[T]():
-                    x = 1
-                ",
-        );
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["func"]);
-        let scopes = table.root_child_scope_ids();
-        assert_eq!(scopes.len(), 1);
-        let ann_scope_id = scopes[0];
-        let ann_scope = ann_scope_id.scope(&table);
-        assert_eq!(ann_scope.kind(), ScopeKind::Annotation);
-        assert_eq!(ann_scope.name(), "func");
-        assert_eq!(names(table.symbols_for_scope(ann_scope_id)), vec!["T"]);
-        let scopes = table.child_scope_ids_of(ann_scope_id);
-        assert_eq!(scopes.len(), 1);
-        let func_scope_id = scopes[0];
-        let func_scope = func_scope_id.scope(&table);
-        assert_eq!(func_scope.kind(), ScopeKind::Function);
-        assert_eq!(func_scope.name(), "func");
-        assert_eq!(names(table.symbols_for_scope(func_scope_id)), vec!["x"]);
-    }
-
-    #[test]
-    fn generic_class() {
-        let parsed = parse(
-            "
-                class C[T]:
-                    x = 1
-                ",
-        );
-        let table = SemanticIndex::from_ast(parsed.syntax()).symbol_table;
-        assert_eq!(names(table.root_symbols()), vec!["C"]);
-        let scopes = table.root_child_scope_ids();
-        assert_eq!(scopes.len(), 1);
-        let ann_scope_id = scopes[0];
-        let ann_scope = ann_scope_id.scope(&table);
-        assert_eq!(ann_scope.kind(), ScopeKind::Annotation);
-        assert_eq!(ann_scope.name(), "C");
-        assert_eq!(names(table.symbols_for_scope(ann_scope_id)), vec!["T"]);
-        assert!(
-            table
-                .symbol_by_name(ann_scope_id, "T")
-                .is_some_and(|s| s.is_defined() && !s.is_used()),
-            "type parameters are defined by the scope that introduces them"
-        );
-        let scopes = table.child_scope_ids_of(ann_scope_id);
-        assert_eq!(scopes.len(), 1);
-        let func_scope_id = scopes[0];
-        let func_scope = func_scope_id.scope(&table);
-        assert_eq!(func_scope.kind(), ScopeKind::Class);
-        assert_eq!(func_scope.name(), "C");
-        assert_eq!(names(table.symbols_for_scope(func_scope_id)), vec!["x"]);
-    }
-
-    #[test]
-    fn reachability_trivial() {
-        let parsed = parse("x = 1; x");
-        let ast = parsed.syntax();
-        let index = SemanticIndex::from_ast(ast);
-        let table = &index.symbol_table;
-        let x_sym = table
-            .root_symbol_id_by_name("x")
-            .expect("x symbol should exist");
-        let ast::Stmt::Expr(ast::StmtExpr { value: x_use, .. }) = &ast.body[1] else {
-            panic!("should be an expr")
-        };
-        let x_defs: Vec<_> = index
-            .reachable_definitions(x_sym, x_use)
-            .map(|constrained_definition| constrained_definition.definition)
-            .collect();
-        assert_eq!(x_defs.len(), 1);
-        let Definition::Assignment(node_key) = &x_defs[0] else {
-            panic!("def should be an assignment")
-        };
-        let Some(def_node) = node_key.resolve(ast.into()) else {
-            panic!("node key should resolve")
-        };
-        let ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
-            value: ast::Number::Int(num),
-            ..
-        }) = &*def_node.value
-        else {
-            panic!("should be a number literal")
-        };
-        assert_eq!(*num, 1);
-    }
-
-    #[test]
-    fn expression_scope() {
-        let parsed = parse("x = 1;\ndef test():\n  y = 4");
-        let ast = parsed.syntax();
-        let index = SemanticIndex::from_ast(ast);
-        let table = &index.symbol_table;
-
-        let x_sym = table
-            .root_symbol_by_name("x")
-            .expect("x symbol should exist");
-
-        let x_stmt = ast.body[0].as_assign_stmt().unwrap();
-
-        let x_id = index.expression_id(&x_stmt.targets[0]);
-
-        assert_eq!(table.scope_of_expression(x_id).kind(), ScopeKind::Module);
-        assert_eq!(table.scope_id_of_expression(x_id), x_sym.scope_id());
-
-        let def = ast.body[1].as_function_def_stmt().unwrap();
-        let y_stmt = def.body[0].as_assign_stmt().unwrap();
-        let y_id = index.expression_id(&y_stmt.targets[0]);
-
-        assert_eq!(table.scope_of_expression(y_id).kind(), ScopeKind::Function);
-    }
-}
--- a/crates/red_knot/src/semantic/definitions.rs
+++ b/crates/red_knot/src/semantic/definitions.rs
@@ -1,52 +0,0 @@
-use crate::ast_ids::TypedNodeKey;
-use crate::semantic::ModuleName;
-use crate::Name;
-use ruff_python_ast as ast;
-
-// TODO storing TypedNodeKey for definitions means we have to search to find them again in the AST;
-// this is at best O(log n). If looking up definitions is a bottleneck we should look for
-// alternatives here.
-// TODO intern Definitions in SymbolTable and reference using IDs?
-#[derive(Clone, Debug)]
-pub enum Definition {
-    // For the import cases, we don't need reference to any arbitrary AST subtrees (annotations,
-    // RHS), and referencing just the import statement node is imprecise (a single import statement
-    // can assign many symbols, we'd have to re-search for the one we care about), so we just copy
-    // the small amount of information we need from the AST.
-    Import(ImportDefinition),
-    ImportFrom(ImportFromDefinition),
-    ClassDef(TypedNodeKey<ast::StmtClassDef>),
-    FunctionDef(TypedNodeKey<ast::StmtFunctionDef>),
-    Assignment(TypedNodeKey<ast::StmtAssign>),
-    AnnotatedAssignment(TypedNodeKey<ast::StmtAnnAssign>),
-    NamedExpr(TypedNodeKey<ast::ExprNamed>),
-    /// represents the implicit initial definition of every name as "unbound"
-    Unbound,
-    // TODO with statements, except handlers, function args...
-}
-
-#[derive(Clone, Debug)]
-pub struct ImportDefinition {
-    pub module: ModuleName,
-}
-
-#[derive(Clone, Debug)]
-pub struct ImportFromDefinition {
-    pub module: Option<ModuleName>,
-    pub name: Name,
-    pub level: u32,
-}
-
-impl ImportFromDefinition {
-    pub fn module(&self) -> Option<&ModuleName> {
-        self.module.as_ref()
-    }
-
-    pub fn name(&self) -> &Name {
-        &self.name
-    }
-
-    pub fn level(&self) -> u32 {
-        self.level
-    }
-}
--- a/crates/red_knot/src/semantic/flow_graph.rs
+++ b/crates/red_knot/src/semantic/flow_graph.rs
@@ -1,270 +0,0 @@
-use super::symbol_table::SymbolId;
-use crate::semantic::{Definition, ExpressionId};
-use ruff_index::{newtype_index, IndexVec};
-use std::iter::FusedIterator;
-use std::ops::Range;
-
-#[newtype_index]
-pub struct FlowNodeId;
-
-#[derive(Debug)]
-pub(crate) enum FlowNode {
-    Start,
-    Definition(DefinitionFlowNode),
-    Branch(BranchFlowNode),
-    Phi(PhiFlowNode),
-    Constraint(ConstraintFlowNode),
-}
-
-/// A point in control flow where a symbol is defined
-#[derive(Debug)]
-pub(crate) struct DefinitionFlowNode {
-    symbol_id: SymbolId,
-    definition: Definition,
-    predecessor: FlowNodeId,
-}
-
-/// A branch in control flow
-#[derive(Debug)]
-pub(crate) struct BranchFlowNode {
-    predecessor: FlowNodeId,
-}
-
-/// A join point where control flow paths come together
-#[derive(Debug)]
-pub(crate) struct PhiFlowNode {
-    first_predecessor: FlowNodeId,
-    second_predecessor: FlowNodeId,
-}
-
-/// A branch test which may apply constraints to a symbol's type
-#[derive(Debug)]
-pub(crate) struct ConstraintFlowNode {
-    predecessor: FlowNodeId,
-    test_expression: ExpressionId,
-}
-
-#[derive(Debug)]
-pub struct FlowGraph {
-    flow_nodes_by_id: IndexVec<FlowNodeId, FlowNode>,
-    expression_map: IndexVec<ExpressionId, FlowNodeId>,
-}
-
-impl FlowGraph {
-    pub fn start() -> FlowNodeId {
-        FlowNodeId::from_usize(0)
-    }
-
-    pub fn for_expr(&self, expr: ExpressionId) -> FlowNodeId {
-        self.expression_map[expr]
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct FlowGraphBuilder {
-    flow_graph: FlowGraph,
-}
-
-impl FlowGraphBuilder {
-    pub(crate) fn new() -> Self {
-        let mut graph = FlowGraph {
-            flow_nodes_by_id: IndexVec::default(),
-            expression_map: IndexVec::default(),
-        };
-        graph.flow_nodes_by_id.push(FlowNode::Start);
-        Self { flow_graph: graph }
-    }
-
-    pub(crate) fn add(&mut self, node: FlowNode) -> FlowNodeId {
-        self.flow_graph.flow_nodes_by_id.push(node)
-    }
-
-    pub(crate) fn add_definition(
-        &mut self,
-        symbol_id: SymbolId,
-        definition: Definition,
-        predecessor: FlowNodeId,
-    ) -> FlowNodeId {
-        self.add(FlowNode::Definition(DefinitionFlowNode {
-            symbol_id,
-            definition,
-            predecessor,
-        }))
-    }
-
-    pub(crate) fn add_branch(&mut self, predecessor: FlowNodeId) -> FlowNodeId {
-        self.add(FlowNode::Branch(BranchFlowNode { predecessor }))
-    }
-
-    pub(crate) fn add_phi(
-        &mut self,
-        first_predecessor: FlowNodeId,
-        second_predecessor: FlowNodeId,
-    ) -> FlowNodeId {
-        self.add(FlowNode::Phi(PhiFlowNode {
-            first_predecessor,
-            second_predecessor,
-        }))
-    }
-
-    pub(crate) fn add_constraint(
-        &mut self,
-        predecessor: FlowNodeId,
-        test_expression: ExpressionId,
-    ) -> FlowNodeId {
-        self.add(FlowNode::Constraint(ConstraintFlowNode {
-            predecessor,
-            test_expression,
-        }))
-    }
-
-    pub(super) fn record_expr(&mut self, node_id: FlowNodeId) -> ExpressionId {
-        self.flow_graph.expression_map.push(node_id)
-    }
-
-    pub(super) fn finish(mut self) -> FlowGraph {
-        self.flow_graph.flow_nodes_by_id.shrink_to_fit();
-        self.flow_graph.expression_map.shrink_to_fit();
-        self.flow_graph
-    }
-}
-
-/// A definition, and the set of constraints between a use and the definition
-#[derive(Debug, Clone)]
-pub struct ConstrainedDefinition {
-    pub definition: Definition,
-    pub constraints: Vec<ExpressionId>,
-}
-
-/// A flow node and the constraints we passed through to reach it
-#[derive(Debug)]
-struct FlowState {
-    node_id: FlowNodeId,
-    constraints_range: Range<usize>,
-}
-
-#[derive(Debug)]
-pub struct ReachableDefinitionsIterator<'a> {
-    flow_graph: &'a FlowGraph,
-    symbol_id: SymbolId,
-    pending: Vec<FlowState>,
-    constraints: Vec<ExpressionId>,
-}
-
-impl<'a> ReachableDefinitionsIterator<'a> {
-    pub fn new(flow_graph: &'a FlowGraph, symbol_id: SymbolId, start_node_id: FlowNodeId) -> Self {
-        Self {
-            flow_graph,
-            symbol_id,
-            pending: vec![FlowState {
-                node_id: start_node_id,
-                constraints_range: 0..0,
-            }],
-            constraints: vec![],
-        }
-    }
-}
-
-impl<'a> Iterator for ReachableDefinitionsIterator<'a> {
-    type Item = ConstrainedDefinition;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let FlowState {
-            mut node_id,
-            mut constraints_range,
-        } = self.pending.pop()?;
-        self.constraints.truncate(constraints_range.end + 1);
-        loop {
-            match &self.flow_graph.flow_nodes_by_id[node_id] {
-                FlowNode::Start => {
-                    // constraints on unbound are irrelevant
-                    return Some(ConstrainedDefinition {
-                        definition: Definition::Unbound,
-                        constraints: vec![],
-                    });
-                }
-                FlowNode::Definition(def_node) => {
-                    if def_node.symbol_id == self.symbol_id {
-                        return Some(ConstrainedDefinition {
-                            definition: def_node.definition.clone(),
-                            constraints: self.constraints[constraints_range].to_vec(),
-                        });
-                    }
-                    node_id = def_node.predecessor;
-                }
-                FlowNode::Branch(branch_node) => {
-                    node_id = branch_node.predecessor;
-                }
-                FlowNode::Phi(phi_node) => {
-                    self.pending.push(FlowState {
-                        node_id: phi_node.first_predecessor,
-                        constraints_range: constraints_range.clone(),
-                    });
-                    node_id = phi_node.second_predecessor;
-                }
-                FlowNode::Constraint(constraint_node) => {
-                    node_id = constraint_node.predecessor;
-                    self.constraints.push(constraint_node.test_expression);
-                    constraints_range.end += 1;
-                }
-            }
-        }
-    }
-}
-
-impl<'a> FusedIterator for ReachableDefinitionsIterator<'a> {}
-
-impl std::fmt::Display for FlowGraph {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        writeln!(f, "flowchart TD")?;
-        for (id, node) in self.flow_nodes_by_id.iter_enumerated() {
-            write!(f, "  id{}", id.as_u32())?;
-            match node {
-                FlowNode::Start => writeln!(f, r"[\Start/]")?,
-                FlowNode::Definition(def_node) => {
-                    writeln!(f, r"(Define symbol {})", def_node.symbol_id.as_u32())?;
-                    writeln!(
-                        f,
-                        r"  id{}-->id{}",
-                        def_node.predecessor.as_u32(),
-                        id.as_u32()
-                    )?;
-                }
-                FlowNode::Branch(branch_node) => {
-                    writeln!(f, r"{{Branch}}")?;
-                    writeln!(
-                        f,
-                        r"  id{}-->id{}",
-                        branch_node.predecessor.as_u32(),
-                        id.as_u32()
-                    )?;
-                }
-                FlowNode::Phi(phi_node) => {
-                    writeln!(f, r"((Phi))")?;
-                    writeln!(
-                        f,
-                        r"  id{}-->id{}",
-                        phi_node.second_predecessor.as_u32(),
-                        id.as_u32()
-                    )?;
-                    writeln!(
-                        f,
-                        r"  id{}-->id{}",
-                        phi_node.first_predecessor.as_u32(),
-                        id.as_u32()
-                    )?;
-                }
-                FlowNode::Constraint(constraint_node) => {
-                    writeln!(f, r"((Constraint))")?;
-                    writeln!(
-                        f,
-                        r"  id{}-->id{}",
-                        constraint_node.predecessor.as_u32(),
-                        id.as_u32()
-                    )?;
-                }
-            }
-        }
-        Ok(())
-    }
-}
--- a/crates/red_knot/src/semantic/symbol_table.rs
+++ b/crates/red_knot/src/semantic/symbol_table.rs
@@ -1,560 +0,0 @@
-#![allow(dead_code)]
-
-use std::hash::{Hash, Hasher};
-use std::iter::{Copied, DoubleEndedIterator, FusedIterator};
-use std::num::NonZeroU32;
-
-use bitflags::bitflags;
-use hashbrown::hash_map::{Keys, RawEntryMut};
-use rustc_hash::{FxHashMap, FxHasher};
-
-use ruff_index::{newtype_index, IndexVec};
-
-use crate::ast_ids::NodeKey;
-use crate::module::ModuleName;
-use crate::semantic::{Definition, ExpressionId};
-use crate::Name;
-
-type Map<K, V> = hashbrown::HashMap<K, V, ()>;
-
-#[newtype_index]
-pub struct ScopeId;
-
-impl ScopeId {
-    pub fn scope(self, table: &SymbolTable) -> &Scope {
-        &table.scopes_by_id[self]
-    }
-}
-
-#[newtype_index]
-pub struct SymbolId;
-
-impl SymbolId {
-    pub fn symbol(self, table: &SymbolTable) -> &Symbol {
-        &table.symbols_by_id[self]
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum ScopeKind {
-    Module,
-    Annotation,
-    Class,
-    Function,
-}
-
-#[derive(Debug)]
-pub struct Scope {
-    name: Name,
-    kind: ScopeKind,
-    parent: Option<ScopeId>,
-    children: Vec<ScopeId>,
-    /// the definition (e.g. class or function) that created this scope
-    definition: Option<Definition>,
-    /// the symbol (e.g. class or function) that owns this scope
-    defining_symbol: Option<SymbolId>,
-    /// symbol IDs, hashed by symbol name
-    symbols_by_name: Map<SymbolId, ()>,
-}
-
-impl Scope {
-    pub fn name(&self) -> &str {
-        self.name.as_str()
-    }
-
-    pub fn kind(&self) -> ScopeKind {
-        self.kind
-    }
-
-    pub fn definition(&self) -> Option<Definition> {
-        self.definition.clone()
-    }
-
-    pub fn defining_symbol(&self) -> Option<SymbolId> {
-        self.defining_symbol
-    }
-}
-
-#[derive(Debug)]
-pub(crate) enum Kind {
-    FreeVar,
-    CellVar,
-    CellVarAssigned,
-    ExplicitGlobal,
-    ImplicitGlobal,
-}
-
-bitflags! {
-    #[derive(Copy,Clone,Debug)]
-    pub struct SymbolFlags: u8 {
-        const IS_USED         = 1 << 0;
-        const IS_DEFINED      = 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
-        const MARKED_NONLOCAL = 1 << 3;
-    }
-}
-
-#[derive(Debug)]
-pub struct Symbol {
-    name: Name,
-    flags: SymbolFlags,
-    scope_id: ScopeId,
-    // kind: Kind,
-}
-
-impl Symbol {
-    pub fn name(&self) -> &str {
-        self.name.as_str()
-    }
-
-    pub fn scope_id(&self) -> ScopeId {
-        self.scope_id
-    }
-
-    /// Is the symbol used in its containing scope?
-    pub fn is_used(&self) -> bool {
-        self.flags.contains(SymbolFlags::IS_USED)
-    }
-
-    /// Is the symbol defined in its containing scope?
-    pub fn is_defined(&self) -> bool {
-        self.flags.contains(SymbolFlags::IS_DEFINED)
-    }
-
-    // TODO: implement Symbol.kind 2-pass analysis to categorize as: free-var, cell-var,
-    // explicit-global, implicit-global and implement Symbol.kind by modifying the preorder
-    // traversal code
-}
-
-#[derive(Debug, Clone)]
-pub enum Dependency {
-    Module(ModuleName),
-    Relative {
-        level: NonZeroU32,
-        module: Option<ModuleName>,
-    },
-}
-
-/// Table of all symbols in all scopes for a module.
-#[derive(Debug)]
-pub struct SymbolTable {
-    scopes_by_id: IndexVec<ScopeId, Scope>,
-    symbols_by_id: IndexVec<SymbolId, Symbol>,
-    /// the definitions for each symbol
-    defs: FxHashMap<SymbolId, Vec<Definition>>,
-    /// map of AST node (e.g. class/function def) to sub-scope it creates
-    scopes_by_node: FxHashMap<NodeKey, ScopeId>,
-    /// Maps expressions to their enclosing scope.
-    expression_scopes: IndexVec<ExpressionId, ScopeId>,
-    /// dependencies of this module
-    dependencies: Vec<Dependency>,
-}
-
-impl SymbolTable {
-    pub fn dependencies(&self) -> &[Dependency] {
-        &self.dependencies
-    }
-
-    pub const fn root_scope_id() -> ScopeId {
-        ScopeId::from_usize(0)
-    }
-
-    pub fn root_scope(&self) -> &Scope {
-        &self.scopes_by_id[SymbolTable::root_scope_id()]
-    }
-
-    pub fn symbol_ids_for_scope(&self, scope_id: ScopeId) -> Copied<Keys<SymbolId, ()>> {
-        self.scopes_by_id[scope_id].symbols_by_name.keys().copied()
-    }
-
-    pub fn symbols_for_scope(
-        &self,
-        scope_id: ScopeId,
-    ) -> SymbolIterator<Copied<Keys<SymbolId, ()>>> {
-        SymbolIterator {
-            table: self,
-            ids: self.symbol_ids_for_scope(scope_id),
-        }
-    }
-
-    pub fn root_symbol_ids(&self) -> Copied<Keys<SymbolId, ()>> {
-        self.symbol_ids_for_scope(SymbolTable::root_scope_id())
-    }
-
-    pub fn root_symbols(&self) -> SymbolIterator<Copied<Keys<SymbolId, ()>>> {
-        self.symbols_for_scope(SymbolTable::root_scope_id())
-    }
-
-    pub fn child_scope_ids_of(&self, scope_id: ScopeId) -> &[ScopeId] {
-        &self.scopes_by_id[scope_id].children
-    }
-
-    pub fn child_scopes_of(&self, scope_id: ScopeId) -> ScopeIterator<&[ScopeId]> {
-        ScopeIterator {
-            table: self,
-            ids: self.child_scope_ids_of(scope_id),
-        }
-    }
-
-    pub fn root_child_scope_ids(&self) -> &[ScopeId] {
-        self.child_scope_ids_of(SymbolTable::root_scope_id())
-    }
-
-    pub fn root_child_scopes(&self) -> ScopeIterator<&[ScopeId]> {
-        self.child_scopes_of(SymbolTable::root_scope_id())
-    }
-
-    pub fn symbol_id_by_name(&self, scope_id: ScopeId, name: &str) -> Option<SymbolId> {
-        let scope = &self.scopes_by_id[scope_id];
-        let hash = SymbolTable::hash_name(name);
-        let name = Name::new(name);
-        Some(
-            *scope
-                .symbols_by_name
-                .raw_entry()
-                .from_hash(hash, |symid| self.symbols_by_id[*symid].name == name)?
-                .0,
-        )
-    }
-
-    pub fn symbol_by_name(&self, scope_id: ScopeId, name: &str) -> Option<&Symbol> {
-        Some(&self.symbols_by_id[self.symbol_id_by_name(scope_id, name)?])
-    }
-
-    pub fn root_symbol_id_by_name(&self, name: &str) -> Option<SymbolId> {
-        self.symbol_id_by_name(SymbolTable::root_scope_id(), name)
-    }
-
-    pub fn root_symbol_by_name(&self, name: &str) -> Option<&Symbol> {
-        self.symbol_by_name(SymbolTable::root_scope_id(), name)
-    }
-
-    pub fn scope_id_of_symbol(&self, symbol_id: SymbolId) -> ScopeId {
-        self.symbols_by_id[symbol_id].scope_id
-    }
-
-    pub fn scope_of_symbol(&self, symbol_id: SymbolId) -> &Scope {
-        &self.scopes_by_id[self.scope_id_of_symbol(symbol_id)]
-    }
-
-    pub fn scope_id_of_expression(&self, expression: ExpressionId) -> ScopeId {
-        self.expression_scopes[expression]
-    }
-
-    pub fn scope_of_expression(&self, expr_id: ExpressionId) -> &Scope {
-        &self.scopes_by_id[self.scope_id_of_expression(expr_id)]
-    }
-
-    pub fn parent_scopes(
-        &self,
-        scope_id: ScopeId,
-    ) -> ScopeIterator<impl Iterator<Item = ScopeId> + '_> {
-        ScopeIterator {
-            table: self,
-            ids: std::iter::successors(Some(scope_id), |scope| self.scopes_by_id[*scope].parent),
-        }
-    }
-
-    pub fn parent_scope(&self, scope_id: ScopeId) -> Option<ScopeId> {
-        self.scopes_by_id[scope_id].parent
-    }
-
-    pub fn scope_id_for_node(&self, node_key: &NodeKey) -> ScopeId {
-        self.scopes_by_node[node_key]
-    }
-
-    pub fn definitions(&self, symbol_id: SymbolId) -> &[Definition] {
-        self.defs
-            .get(&symbol_id)
-            .map(std::vec::Vec::as_slice)
-            .unwrap_or_default()
-    }
-
-    pub fn all_definitions(&self) -> impl Iterator<Item = (SymbolId, &Definition)> + '_ {
-        self.defs
-            .iter()
-            .flat_map(|(sym_id, defs)| defs.iter().map(move |def| (*sym_id, def)))
-    }
-
-    fn hash_name(name: &str) -> u64 {
-        let mut hasher = FxHasher::default();
-        name.hash(&mut hasher);
-        hasher.finish()
-    }
-}
-
-pub struct SymbolIterator<'a, I> {
-    table: &'a SymbolTable,
-    ids: I,
-}
-
-impl<'a, I> Iterator for SymbolIterator<'a, I>
-where
-    I: Iterator<Item = SymbolId>,
-{
-    type Item = &'a Symbol;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let id = self.ids.next()?;
-        Some(&self.table.symbols_by_id[id])
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.ids.size_hint()
-    }
-}
-
-impl<'a, I> FusedIterator for SymbolIterator<'a, I> where
-    I: Iterator<Item = SymbolId> + FusedIterator
-{
-}
-
-impl<'a, I> DoubleEndedIterator for SymbolIterator<'a, I>
-where
-    I: Iterator<Item = SymbolId> + DoubleEndedIterator,
-{
-    fn next_back(&mut self) -> Option<Self::Item> {
-        let id = self.ids.next_back()?;
-        Some(&self.table.symbols_by_id[id])
-    }
-}
-
-// TODO maybe get rid of this and just do all data access via methods on ScopeId?
-pub struct ScopeIterator<'a, I> {
-    table: &'a SymbolTable,
-    ids: I,
-}
-
-/// iterate (`ScopeId`, `Scope`) pairs for given `ScopeId` iterator
-impl<'a, I> Iterator for ScopeIterator<'a, I>
-where
-    I: Iterator<Item = ScopeId>,
-{
-    type Item = (ScopeId, &'a Scope);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let id = self.ids.next()?;
-        Some((id, &self.table.scopes_by_id[id]))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.ids.size_hint()
-    }
-}
-
-impl<'a, I> FusedIterator for ScopeIterator<'a, I> where I: Iterator<Item = ScopeId> + FusedIterator {}
-
-impl<'a, I> DoubleEndedIterator for ScopeIterator<'a, I>
-where
-    I: Iterator<Item = ScopeId> + DoubleEndedIterator,
-{
-    fn next_back(&mut self) -> Option<Self::Item> {
-        let id = self.ids.next_back()?;
-        Some((id, &self.table.scopes_by_id[id]))
-    }
-}
-
-#[derive(Debug)]
-pub(super) struct SymbolTableBuilder {
-    symbol_table: SymbolTable,
-}
-
-impl SymbolTableBuilder {
-    pub(super) fn new() -> Self {
-        let mut table = SymbolTable {
-            scopes_by_id: IndexVec::new(),
-            symbols_by_id: IndexVec::new(),
-            defs: FxHashMap::default(),
-            scopes_by_node: FxHashMap::default(),
-            expression_scopes: IndexVec::new(),
-            dependencies: Vec::new(),
-        };
-        table.scopes_by_id.push(Scope {
-            name: Name::new("<module>"),
-            kind: ScopeKind::Module,
-            parent: None,
-            children: Vec::new(),
-            definition: None,
-            defining_symbol: None,
-            symbols_by_name: Map::default(),
-        });
-        Self {
-            symbol_table: table,
-        }
-    }
-
-    pub(super) fn finish(self) -> SymbolTable {
-        let mut symbol_table = self.symbol_table;
-        symbol_table.scopes_by_id.shrink_to_fit();
-        symbol_table.symbols_by_id.shrink_to_fit();
-        symbol_table.defs.shrink_to_fit();
-        symbol_table.scopes_by_node.shrink_to_fit();
-        symbol_table.expression_scopes.shrink_to_fit();
-        symbol_table.dependencies.shrink_to_fit();
-        symbol_table
-    }
-
-    pub(super) fn add_or_update_symbol(
-        &mut self,
-        scope_id: ScopeId,
-        name: &str,
-        flags: SymbolFlags,
-    ) -> SymbolId {
-        let hash = SymbolTable::hash_name(name);
-        let scope = &mut self.symbol_table.scopes_by_id[scope_id];
-        let name = Name::new(name);
-
-        let entry = scope
-            .symbols_by_name
-            .raw_entry_mut()
-            .from_hash(hash, |existing| {
-                self.symbol_table.symbols_by_id[*existing].name == name
-            });
-
-        match entry {
-            RawEntryMut::Occupied(entry) => {
-                if let Some(symbol) = self.symbol_table.symbols_by_id.get_mut(*entry.key()) {
-                    symbol.flags.insert(flags);
-                };
-                *entry.key()
-            }
-            RawEntryMut::Vacant(entry) => {
-                let id = self.symbol_table.symbols_by_id.push(Symbol {
-                    name,
-                    flags,
-                    scope_id,
-                });
-                entry.insert_with_hasher(hash, id, (), |symid| {
-                    SymbolTable::hash_name(&self.symbol_table.symbols_by_id[*symid].name)
-                });
-                id
-            }
-        }
-    }
-
-    pub(super) fn add_definition(&mut self, symbol_id: SymbolId, definition: Definition) {
-        self.symbol_table
-            .defs
-            .entry(symbol_id)
-            .or_default()
-            .push(definition);
-    }
-
-    pub(super) fn add_child_scope(
-        &mut self,
-        parent_scope_id: ScopeId,
-        name: &str,
-        kind: ScopeKind,
-        definition: Option<Definition>,
-        defining_symbol: Option<SymbolId>,
-    ) -> ScopeId {
-        let new_scope_id = self.symbol_table.scopes_by_id.push(Scope {
-            name: Name::new(name),
-            kind,
-            parent: Some(parent_scope_id),
-            children: Vec::new(),
-            definition,
-            defining_symbol,
-            symbols_by_name: Map::default(),
-        });
-        let parent_scope = &mut self.symbol_table.scopes_by_id[parent_scope_id];
-        parent_scope.children.push(new_scope_id);
-        new_scope_id
-    }
-
-    pub(super) fn record_scope_for_node(&mut self, node_key: NodeKey, scope_id: ScopeId) {
-        self.symbol_table.scopes_by_node.insert(node_key, scope_id);
-    }
-
-    pub(super) fn add_dependency(&mut self, dependency: Dependency) {
-        self.symbol_table.dependencies.push(dependency);
-    }
-
-    /// Records the scope for the current expression
-    pub(super) fn record_expression(&mut self, scope: ScopeId) -> ExpressionId {
-        self.symbol_table.expression_scopes.push(scope)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{ScopeKind, SymbolFlags, SymbolTable, SymbolTableBuilder};
-
-    #[test]
-    fn insert_same_name_symbol_twice() {
-        let mut builder = SymbolTableBuilder::new();
-        let root_scope_id = SymbolTable::root_scope_id();
-        let symbol_id_1 =
-            builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::IS_DEFINED);
-        let symbol_id_2 = builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::IS_USED);
-        let table = builder.finish();
-
-        assert_eq!(symbol_id_1, symbol_id_2);
-        assert!(symbol_id_1.symbol(&table).is_used(), "flags must merge");
-        assert!(symbol_id_1.symbol(&table).is_defined(), "flags must merge");
-    }
-
-    #[test]
-    fn insert_different_named_symbols() {
-        let mut builder = SymbolTableBuilder::new();
-        let root_scope_id = SymbolTable::root_scope_id();
-        let symbol_id_1 = builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::empty());
-        let symbol_id_2 = builder.add_or_update_symbol(root_scope_id, "bar", SymbolFlags::empty());
-
-        assert_ne!(symbol_id_1, symbol_id_2);
-    }
-
-    #[test]
-    fn add_child_scope_with_symbol() {
-        let mut builder = SymbolTableBuilder::new();
-        let root_scope_id = SymbolTable::root_scope_id();
-        let foo_symbol_top =
-            builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::empty());
-        let c_scope = builder.add_child_scope(root_scope_id, "C", ScopeKind::Class, None, None);
-        let foo_symbol_inner = builder.add_or_update_symbol(c_scope, "foo", SymbolFlags::empty());
-
-        assert_ne!(foo_symbol_top, foo_symbol_inner);
-    }
-
-    #[test]
-    fn scope_from_id() {
-        let table = SymbolTableBuilder::new().finish();
-        let root_scope_id = SymbolTable::root_scope_id();
-        let scope = root_scope_id.scope(&table);
-
-        assert_eq!(scope.name.as_str(), "<module>");
-        assert_eq!(scope.kind, ScopeKind::Module);
-    }
-
-    #[test]
-    fn symbol_from_id() {
-        let mut builder = SymbolTableBuilder::new();
-        let root_scope_id = SymbolTable::root_scope_id();
-        let foo_symbol_id =
-            builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::empty());
-        let table = builder.finish();
-        let symbol = foo_symbol_id.symbol(&table);
-
-        assert_eq!(symbol.name(), "foo");
-    }
-
-    #[test]
-    fn bigger_symbol_table() {
-        let mut builder = SymbolTableBuilder::new();
-        let root_scope_id = SymbolTable::root_scope_id();
-        let foo_symbol_id =
-            builder.add_or_update_symbol(root_scope_id, "foo", SymbolFlags::empty());
-        builder.add_or_update_symbol(root_scope_id, "bar", SymbolFlags::empty());
-        builder.add_or_update_symbol(root_scope_id, "baz", SymbolFlags::empty());
-        builder.add_or_update_symbol(root_scope_id, "qux", SymbolFlags::empty());
-        let table = builder.finish();
-
-        let foo_symbol_id_2 = table
-            .root_symbol_id_by_name("foo")
-            .expect("foo symbol to be found");
-
-        assert_eq!(foo_symbol_id_2, foo_symbol_id);
-    }
-}
--- a/crates/red_knot/src/semantic/types/infer.rs
+++ b/crates/red_knot/src/semantic/types/infer.rs
@@ -1,762 +0,0 @@
-#![allow(dead_code)]
-
-use ruff_python_ast as ast;
-use ruff_python_ast::AstNode;
-use std::fmt::Debug;
-
-use crate::db::{QueryResult, SemanticDb, SemanticJar};
-
-use crate::module::{resolve_module, ModuleName};
-use crate::parse::parse;
-use crate::semantic::types::{ModuleTypeId, Type};
-use crate::semantic::{
-    resolve_global_symbol, semantic_index, ConstrainedDefinition, Definition, GlobalSymbolId,
-    ImportDefinition, ImportFromDefinition,
-};
-use crate::{FileId, Name};
-
-// FIXME: Figure out proper dead-lock free synchronisation now that this takes `&db` instead of `&mut db`.
-/// Resolve the public-facing type for a symbol (the type seen by other scopes: other modules, or
-/// nested functions). Because calls to nested functions and imports can occur anywhere in control
-/// flow, this type must be conservative and consider all definitions of the symbol that could
-/// possibly be seen by another scope. Currently we take the most conservative approach, which is
-/// the union of all definitions. We may be able to narrow this in future to eliminate definitions
-/// which can't possibly (or at least likely) be seen by any other scope, so that e.g. we could
-/// infer `Literal["1"]` instead of `Literal[1] | Literal["1"]` for `x` in `x = x; x = str(x);`.
-#[tracing::instrument(level = "trace", skip(db))]
-pub fn infer_symbol_public_type(db: &dyn SemanticDb, symbol: GlobalSymbolId) -> QueryResult<Type> {
-    let index = semantic_index(db, symbol.file_id)?;
-    let defs = index.symbol_table().definitions(symbol.symbol_id).to_vec();
-    let jar: &SemanticJar = db.jar()?;
-
-    if let Some(ty) = jar.type_store.get_cached_symbol_public_type(symbol) {
-        return Ok(ty);
-    }
-
-    let ty = infer_type_from_definitions(db, symbol, defs.iter().cloned())?;
-
-    jar.type_store.cache_symbol_public_type(symbol, ty);
-
-    // TODO record dependencies
-    Ok(ty)
-}
-
-/// Infer type of a symbol as union of the given `Definitions`.
-fn infer_type_from_definitions<T>(
-    db: &dyn SemanticDb,
-    symbol: GlobalSymbolId,
-    definitions: T,
-) -> QueryResult<Type>
-where
-    T: Debug + IntoIterator<Item = Definition>,
-{
-    infer_type_from_constrained_definitions(
-        db,
-        symbol,
-        definitions
-            .into_iter()
-            .map(|definition| ConstrainedDefinition {
-                definition,
-                constraints: vec![],
-            }),
-    )
-}
-
-/// Infer type of a symbol as union of the given `ConstrainedDefinitions`.
-fn infer_type_from_constrained_definitions<T>(
-    db: &dyn SemanticDb,
-    symbol: GlobalSymbolId,
-    constrained_definitions: T,
-) -> QueryResult<Type>
-where
-    T: IntoIterator<Item = ConstrainedDefinition>,
-{
-    let jar: &SemanticJar = db.jar()?;
-    let mut tys = constrained_definitions
-        .into_iter()
-        .map(|def| infer_constrained_definition_type(db, symbol, def.clone()))
-        .peekable();
-    if let Some(first) = tys.next() {
-        if tys.peek().is_some() {
-            Ok(jar.type_store.add_union(
-                symbol.file_id,
-                &Iterator::chain(std::iter::once(first), tys).collect::<QueryResult<Vec<_>>>()?,
-            ))
-        } else {
-            first
-        }
-    } else {
-        Ok(Type::Unknown)
-    }
-}
-
-/// Infer type for a ConstrainedDefinition (intersection of the definition type and the
-/// constraints)
-#[tracing::instrument(level = "trace", skip(db))]
-pub fn infer_constrained_definition_type(
-    db: &dyn SemanticDb,
-    symbol: GlobalSymbolId,
-    constrained_definition: ConstrainedDefinition,
-) -> QueryResult<Type> {
-    let ConstrainedDefinition {
-        definition,
-        constraints,
-    } = constrained_definition;
-    let index = semantic_index(db, symbol.file_id)?;
-    let parsed = parse(db.upcast(), symbol.file_id)?;
-    let mut intersected_types = vec![infer_definition_type(db, symbol, definition)?];
-    for constraint in constraints {
-        if let Some(constraint_type) = infer_constraint_type(
-            db,
-            symbol,
-            index.resolve_expression_id(parsed.syntax(), constraint),
-        )? {
-            intersected_types.push(constraint_type);
-        }
-    }
-    let jar: &SemanticJar = db.jar()?;
-    Ok(jar
-        .type_store
-        .add_intersection(symbol.file_id, &intersected_types, &[]))
-}
-
-/// Infer a type for a Definition
-#[tracing::instrument(level = "trace", skip(db))]
-pub fn infer_definition_type(
-    db: &dyn SemanticDb,
-    symbol: GlobalSymbolId,
-    definition: Definition,
-) -> QueryResult<Type> {
-    let jar: &SemanticJar = db.jar()?;
-    let type_store = &jar.type_store;
-    let file_id = symbol.file_id;
-
-    match definition {
-        Definition::Unbound => Ok(Type::Unbound),
-        Definition::Import(ImportDefinition {
-            module: module_name,
-        }) => {
-            if let Some(module) = resolve_module(db, module_name.clone())? {
-                Ok(Type::Module(ModuleTypeId { module, file_id }))
-            } else {
-                Ok(Type::Unknown)
-            }
-        }
-        Definition::ImportFrom(ImportFromDefinition {
-            module,
-            name,
-            level,
-        }) => {
-            // TODO relative imports
-            assert!(matches!(level, 0));
-            let module_name = ModuleName::new(module.as_ref().expect("TODO relative imports"));
-            let Some(module) = resolve_module(db, module_name.clone())? else {
-                return Ok(Type::Unknown);
-            };
-
-            if let Some(remote_symbol) = resolve_global_symbol(db, module, &name)? {
-                infer_symbol_public_type(db, remote_symbol)
-            } else {
-                Ok(Type::Unknown)
-            }
-        }
-        Definition::ClassDef(node_key) => {
-            if let Some(ty) = type_store.get_cached_node_type(file_id, node_key.erased()) {
-                Ok(ty)
-            } else {
-                let parsed = parse(db.upcast(), file_id)?;
-                let ast = parsed.syntax();
-                let index = semantic_index(db, file_id)?;
-                let node = node_key.resolve_unwrap(ast.as_any_node_ref());
-
-                let mut bases = Vec::with_capacity(node.bases().len());
-
-                for base in node.bases() {
-                    bases.push(infer_expr_type(db, file_id, base)?);
-                }
-                let scope_id = index.symbol_table().scope_id_for_node(node_key.erased());
-                let ty = type_store.add_class(file_id, &node.name.id, scope_id, bases);
-                type_store.cache_node_type(file_id, *node_key.erased(), ty);
-                Ok(ty)
-            }
-        }
-        Definition::FunctionDef(node_key) => {
-            if let Some(ty) = type_store.get_cached_node_type(file_id, node_key.erased()) {
-                Ok(ty)
-            } else {
-                let parsed = parse(db.upcast(), file_id)?;
-                let ast = parsed.syntax();
-                let index = semantic_index(db, file_id)?;
-                let node = node_key
-                    .resolve(ast.as_any_node_ref())
-                    .expect("node key should resolve");
-
-                let decorator_tys = node
-                    .decorator_list
-                    .iter()
-                    .map(|decorator| infer_expr_type(db, file_id, &decorator.expression))
-                    .collect::<QueryResult<_>>()?;
-                let scope_id = index.symbol_table().scope_id_for_node(node_key.erased());
-                let ty = type_store.add_function(
-                    file_id,
-                    &node.name.id,
-                    symbol.symbol_id,
-                    scope_id,
-                    decorator_tys,
-                );
-                type_store.cache_node_type(file_id, *node_key.erased(), ty);
-                Ok(ty)
-            }
-        }
-        Definition::Assignment(node_key) => {
-            let parsed = parse(db.upcast(), file_id)?;
-            let ast = parsed.syntax();
-            let node = node_key.resolve_unwrap(ast.as_any_node_ref());
-            // TODO handle unpacking assignment
-            infer_expr_type(db, file_id, &node.value)
-        }
-        Definition::AnnotatedAssignment(node_key) => {
-            let parsed = parse(db.upcast(), file_id)?;
-            let ast = parsed.syntax();
-            let node = node_key.resolve_unwrap(ast.as_any_node_ref());
-            // TODO actually look at the annotation
-            let Some(value) = &node.value else {
-                return Ok(Type::Unknown);
-            };
-            // TODO handle unpacking assignment
-            infer_expr_type(db, file_id, value)
-        }
-        Definition::NamedExpr(node_key) => {
-            let parsed = parse(db.upcast(), file_id)?;
-            let ast = parsed.syntax();
-            let node = node_key.resolve_unwrap(ast.as_any_node_ref());
-            infer_expr_type(db, file_id, &node.value)
-        }
-    }
-}
-
-/// Return the type that the given constraint (an expression from a control-flow test) requires the
-/// given symbol to have. For example, returns the Type "~None" as the constraint type if given the
-/// symbol ID for x and the expression ID for `x is not None`. Returns (Rust) None if the given
-/// expression applies no constraints on the given symbol.
-#[tracing::instrument(level = "trace", skip(db))]
-fn infer_constraint_type(
-    db: &dyn SemanticDb,
-    symbol_id: GlobalSymbolId,
-    // TODO this should preferably take an &ast::Expr instead of AnyNodeRef
-    expression: ast::AnyNodeRef,
-) -> QueryResult<Option<Type>> {
-    let file_id = symbol_id.file_id;
-    let index = semantic_index(db, file_id)?;
-    let jar: &SemanticJar = db.jar()?;
-    let symbol_name = symbol_id.symbol_id.symbol(&index.symbol_table).name();
-    // TODO narrowing attributes
-    // TODO narrowing dict keys
-    // TODO isinstance, ==/!=, type(...), literals, bools...
-    match expression {
-        ast::AnyNodeRef::ExprCompare(ast::ExprCompare {
-            left,
-            ops,
-            comparators,
-            ..
-        }) => {
-            // TODO chained comparisons
-            match left.as_ref() {
-                ast::Expr::Name(ast::ExprName { id, .. }) if id == symbol_name => match ops[0] {
-                    ast::CmpOp::Is | ast::CmpOp::IsNot => {
-                        Ok(match infer_expr_type(db, file_id, &comparators[0])? {
-                            Type::None => Some(Type::None),
-                            _ => None,
-                        }
-                        .map(|ty| {
-                            if matches!(ops[0], ast::CmpOp::IsNot) {
-                                jar.type_store.add_intersection(file_id, &[], &[ty])
-                            } else {
-                                ty
-                            }
-                        }))
-                    }
-                    _ => Ok(None),
-                },
-                _ => Ok(None),
-            }
-        }
-        _ => Ok(None),
-    }
-}
-
-/// Infer type of the given expression.
-fn infer_expr_type(db: &dyn SemanticDb, file_id: FileId, expr: &ast::Expr) -> QueryResult<Type> {
-    // TODO cache the resolution of the type on the node
-    let index = semantic_index(db, file_id)?;
-    match expr {
-        ast::Expr::NoneLiteral(_) => Ok(Type::None),
-        ast::Expr::NumberLiteral(ast::ExprNumberLiteral { value, .. }) => {
-            match value {
-                ast::Number::Int(n) => {
-                    // TODO support big int literals
-                    Ok(n.as_i64().map(Type::IntLiteral).unwrap_or(Type::Unknown))
-                }
-                // TODO builtins.float or builtins.complex
-                _ => Ok(Type::Unknown),
-            }
-        }
-        ast::Expr::Name(name) => {
-            // TODO look up in the correct scope, don't assume global
-            if let Some(symbol_id) = index.symbol_table().root_symbol_id_by_name(&name.id) {
-                infer_type_from_constrained_definitions(
-                    db,
-                    GlobalSymbolId { file_id, symbol_id },
-                    index.reachable_definitions(symbol_id, expr),
-                )
-            } else {
-                Ok(Type::Unknown)
-            }
-        }
-        ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
-            let value_type = infer_expr_type(db, file_id, value)?;
-            let attr_name = &Name::new(&attr.id);
-            value_type
-                .get_member(db, attr_name)
-                .map(|ty| ty.unwrap_or(Type::Unknown))
-        }
-        ast::Expr::BinOp(ast::ExprBinOp {
-            left, op, right, ..
-        }) => {
-            let left_ty = infer_expr_type(db, file_id, left)?;
-            let right_ty = infer_expr_type(db, file_id, right)?;
-            // TODO add reverse bin op support if right <: left
-            left_ty.resolve_bin_op(db, *op, right_ty)
-        }
-        ast::Expr::Named(ast::ExprNamed { value, .. }) => infer_expr_type(db, file_id, value),
-        ast::Expr::If(ast::ExprIf { body, orelse, .. }) => {
-            // TODO detect statically known truthy or falsy test
-            let body_ty = infer_expr_type(db, file_id, body)?;
-            let else_ty = infer_expr_type(db, file_id, orelse)?;
-            let jar: &SemanticJar = db.jar()?;
-            Ok(jar.type_store.add_union(file_id, &[body_ty, else_ty]))
-        }
-        _ => todo!("expression type resolution for {:?}", expr),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use std::path::PathBuf;
-
-    use crate::db::tests::TestDb;
-    use crate::db::{HasJar, SemanticJar};
-    use crate::module::{
-        resolve_module, set_module_search_paths, ModuleName, ModuleResolutionInputs,
-    };
-    use crate::semantic::{infer_symbol_public_type, resolve_global_symbol, Type};
-    use crate::Name;
-
-    // TODO with virtual filesystem we shouldn't have to write files to disk for these
-    // tests
-
-    struct TestCase {
-        temp_dir: tempfile::TempDir,
-        db: TestDb,
-
-        src: PathBuf,
-    }
-
-    fn create_test() -> std::io::Result<TestCase> {
-        let temp_dir = tempfile::tempdir()?;
-
-        let src = temp_dir.path().join("src");
-        std::fs::create_dir(&src)?;
-        let src = src.canonicalize()?;
-
-        let search_paths = ModuleResolutionInputs {
-            extra_paths: vec![],
-            workspace_root: src.clone(),
-            site_packages: None,
-            custom_typeshed: None,
-        };
-
-        let mut db = TestDb::default();
-        set_module_search_paths(&mut db, search_paths);
-
-        Ok(TestCase { temp_dir, db, src })
-    }
-
-    fn write_to_path(case: &TestCase, relative_path: &str, contents: &str) -> anyhow::Result<()> {
-        let path = case.src.join(relative_path);
-        std::fs::write(path, contents)?;
-        Ok(())
-    }
-
-    fn get_public_type(
-        case: &TestCase,
-        module_name: &str,
-        variable_name: &str,
-    ) -> anyhow::Result<Type> {
-        let db = &case.db;
-        let module = resolve_module(db, ModuleName::new(module_name))?.expect("Module to exist");
-        let symbol = resolve_global_symbol(db, module, variable_name)?.expect("symbol to exist");
-
-        Ok(infer_symbol_public_type(db, symbol)?)
-    }
-
-    fn assert_public_type(
-        case: &TestCase,
-        module_name: &str,
-        variable_name: &str,
-        type_name: &str,
-    ) -> anyhow::Result<()> {
-        let ty = get_public_type(case, module_name, variable_name)?;
-
-        let jar = HasJar::<SemanticJar>::jar(&case.db)?;
-        assert_eq!(format!("{}", ty.display(&jar.type_store)), type_name);
-        Ok(())
-    }
-
-    #[test]
-    fn follow_import_to_class() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(&case, "a.py", "from b import C as D; E = D")?;
-        write_to_path(&case, "b.py", "class C: pass")?;
-
-        assert_public_type(&case, "a", "E", "Literal[C]")
-    }
-
-    #[test]
-    fn resolve_base_class_by_name() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "mod.py",
-            "
-                class Base: pass
-                class Sub(Base): pass
-            ",
-        )?;
-
-        let ty = get_public_type(&case, "mod", "Sub")?;
-
-        let Type::Class(class_id) = ty else {
-            panic!("Sub is not a Class")
-        };
-        let jar = HasJar::<SemanticJar>::jar(&case.db)?;
-        let base_names: Vec<_> = jar
-            .type_store
-            .get_class(class_id)
-            .bases()
-            .iter()
-            .map(|base_ty| format!("{}", base_ty.display(&jar.type_store)))
-            .collect();
-
-        assert_eq!(base_names, vec!["Literal[Base]"]);
-
-        Ok(())
-    }
-
-    #[test]
-    fn resolve_method() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "mod.py",
-            "
-                class C:
-                    def f(self): pass
-            ",
-        )?;
-
-        let ty = get_public_type(&case, "mod", "C")?;
-
-        let Type::Class(class_id) = ty else {
-            panic!("C is not a Class");
-        };
-
-        let member_ty = class_id
-            .get_own_class_member(&case.db, &Name::new("f"))
-            .expect("C.f to resolve");
-
-        let Some(Type::Function(func_id)) = member_ty else {
-            panic!("C.f is not a Function");
-        };
-
-        let jar = HasJar::<SemanticJar>::jar(&case.db)?;
-        let function = jar.type_store.get_function(func_id);
-        assert_eq!(function.name(), "f");
-
-        Ok(())
-    }
-
-    #[test]
-    fn resolve_module_member() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(&case, "a.py", "import b; D = b.C")?;
-        write_to_path(&case, "b.py", "class C: pass")?;
-
-        assert_public_type(&case, "a", "D", "Literal[C]")
-    }
-
-    #[test]
-    fn resolve_literal() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(&case, "a.py", "x = 1")?;
-
-        assert_public_type(&case, "a", "x", "Literal[1]")
-    }
-
-    #[test]
-    fn resolve_union() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                if flag:
-                    x = 1
-                else:
-                    x = 2
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "x", "Literal[1, 2]")
-    }
-
-    #[test]
-    fn resolve_visible_def() -> anyhow::Result<()> {
-        let case = create_test()?;
-        write_to_path(&case, "a.py", "y = 1; y = 2; x = y")?;
-        assert_public_type(&case, "a", "x", "Literal[2]")
-    }
-
-    #[test]
-    fn join_paths() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                y = 1
-                y = 2
-                if flag:
-                    y = 3
-                x = y
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "x", "Literal[2, 3]")
-    }
-
-    #[test]
-    fn maybe_unbound() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                if flag:
-                    y = 1
-                x = y
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "x", "Literal[1] | Unbound")
-    }
-
-    #[test]
-    fn if_elif_else() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                y = 1
-                y = 2
-                if flag:
-                    y = 3
-                elif flag2:
-                    y = 4
-                else:
-                    r = y
-                    y = 5
-                    s = y
-                x = y
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "x", "Literal[3, 4, 5]")?;
-        assert_public_type(&case, "a", "r", "Literal[2]")?;
-        assert_public_type(&case, "a", "s", "Literal[5]")
-    }
-
-    #[test]
-    fn if_elif() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                y = 1
-                y = 2
-                if flag:
-                    y = 3
-                elif flag2:
-                    y = 4
-                x = y
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "x", "Literal[2, 3, 4]")
-    }
-
-    #[test]
-    fn literal_int_arithmetic() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                a = 2 + 1
-                b = a - 4
-                c = a * b
-                d = c / 3
-                e = 5 % 3
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "a", "Literal[3]")?;
-        assert_public_type(&case, "a", "b", "Literal[-1]")?;
-        assert_public_type(&case, "a", "c", "Literal[-3]")?;
-        assert_public_type(&case, "a", "d", "Literal[-1]")?;
-        assert_public_type(&case, "a", "e", "Literal[2]")
-    }
-
-    #[test]
-    fn walrus() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                x = (y := 1) + 1
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "x", "Literal[2]")?;
-        assert_public_type(&case, "a", "y", "Literal[1]")
-    }
-
-    #[test]
-    fn ifexpr() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                x = 1 if flag else 2
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "x", "Literal[1, 2]")
-    }
-
-    #[test]
-    fn ifexpr_walrus() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                y = z = 0
-                x = (y := 1) if flag else (z := 2)
-                a = y
-                b = z
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "x", "Literal[1, 2]")?;
-        assert_public_type(&case, "a", "a", "Literal[0, 1]")?;
-        assert_public_type(&case, "a", "b", "Literal[0, 2]")
-    }
-
-    #[test]
-    fn ifexpr_walrus_2() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                y = 0
-                (y := 1) if flag else (y := 2)
-                a = y
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "a", "Literal[1, 2]")
-    }
-
-    #[test]
-    fn ifexpr_nested() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                x = 1 if flag else 2 if flag2 else 3
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "x", "Literal[1, 2, 3]")
-    }
-
-    #[test]
-    fn none() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                x = 1 if flag else None
-            ",
-        )?;
-
-        assert_public_type(&case, "a", "x", "Literal[1] | None")
-    }
-
-    #[test]
-    fn narrow_none() -> anyhow::Result<()> {
-        let case = create_test()?;
-
-        write_to_path(
-            &case,
-            "a.py",
-            "
-                x = 1 if flag else None
-                y = 0
-                if x is not None:
-                    y = x
-                z = y
-            ",
-        )?;
-
-        // TODO normalization of unions and intersections: this type is technically correct but
-        // begging for normalization
-        assert_public_type(&case, "a", "z", "Literal[0] | Literal[1] | None & ~None")
-    }
-}
--- a/crates/red_knot/src/source.rs
+++ b/crates/red_knot/src/source.rs
@@ -53,16 +53,6 @@ pub enum SourceKind {
    IpyNotebook(Arc<Notebook>),
 }

-impl<'a> From<&'a SourceKind> for PySourceType {
-    fn from(value: &'a SourceKind) -> Self {
-        match value {
-            SourceKind::Python(_) => PySourceType::Python,
-            SourceKind::Stub(_) => PySourceType::Stub,
-            SourceKind::IpyNotebook(_) => PySourceType::Ipynb,
-        }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq)]
 pub struct Source {
    kind: SourceKind,
--- a/crates/red_knot/src/symbols.rs
+++ b/crates/red_knot/src/symbols.rs
--- a/crates/red_knot/src/semantic/types.rs
+++ b/crates/red_knot/src/semantic/types.rs
@@ -2,23 +2,19 @@
 use crate::ast_ids::NodeKey;
 use crate::db::{QueryResult, SemanticDb, SemanticJar};
 use crate::files::FileId;
-use crate::module::{Module, ModuleName};
-use crate::semantic::{
-    resolve_global_symbol, semantic_index, GlobalSymbolId, ScopeId, ScopeKind, SymbolId,
-};
+use crate::symbols::{symbol_table, GlobalSymbolId, ScopeId, ScopeKind, SymbolId};
 use crate::{FxDashMap, FxIndexSet, Name};
 use ruff_index::{newtype_index, IndexVec};
-use ruff_python_ast as ast;
 use rustc_hash::FxHashMap;

 pub(crate) mod infer;

-pub(crate) use infer::{infer_definition_type, infer_symbol_public_type};
+pub(crate) use infer::{infer_definition_type, infer_symbol_type};

 /// unique ID for a type
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Type {
-    /// the dynamic type: a statically-unknown set of values
+    /// the dynamic or gradual type: a statically-unknown set of values
    Any,
    /// the empty set of values
    Never,
@@ -27,19 +23,14 @@ pub enum Type {
    Unknown,
    /// name is not bound to any value
    Unbound,
-    /// the None object (TODO remove this in favor of Instance(types.NoneType)
-    None,
    /// a specific function object
    Function(FunctionTypeId),
-    /// a specific module object
-    Module(ModuleTypeId),
    /// a specific class object
    Class(ClassTypeId),
    /// the set of Python objects with the given class in their __class__'s method resolution order
    Instance(ClassTypeId),
    Union(UnionTypeId),
    Intersection(IntersectionTypeId),
-    IntLiteral(i64),
    // TODO protocols, callable types, overloads, generics, type vars
 }

@@ -55,90 +46,6 @@ impl Type {
    pub const fn is_unknown(&self) -> bool {
        matches!(self, Type::Unknown)
    }
-
-    pub fn get_member(&self, db: &dyn SemanticDb, name: &Name) -> QueryResult<Option<Type>> {
-        match self {
-            Type::Any => Ok(Some(Type::Any)),
-            Type::Never => todo!("attribute lookup on Never type"),
-            Type::Unknown => Ok(Some(Type::Unknown)),
-            Type::Unbound => todo!("attribute lookup on Unbound type"),
-            Type::None => todo!("attribute lookup on None type"),
-            Type::Function(_) => todo!("attribute lookup on Function type"),
-            Type::Module(module_id) => module_id.get_member(db, name),
-            Type::Class(class_id) => class_id.get_class_member(db, name),
-            Type::Instance(_) => {
-                // TODO MRO? get_own_instance_member, get_instance_member
-                todo!("attribute lookup on Instance type")
-            }
-            Type::Union(union_id) => {
-                let jar: &SemanticJar = db.jar()?;
-                let _todo_union_ref = jar.type_store.get_union(*union_id);
-                // TODO perform the get_member on each type in the union
-                // TODO return the union of those results
-                // TODO if any of those results is `None` then include Unknown in the result union
-                todo!("attribute lookup on Union type")
-            }
-            Type::Intersection(_) => {
-                // TODO perform the get_member on each type in the intersection
-                // TODO return the intersection of those results
-                todo!("attribute lookup on Intersection type")
-            }
-            Type::IntLiteral(_) => {
-                // TODO raise error
-                Ok(Some(Type::Unknown))
-            }
-        }
-    }
-
-    // when this is fully fleshed out, it will use the db arg and may return QueryError
-    #[allow(clippy::unnecessary_wraps)]
-    pub fn resolve_bin_op(
-        &self,
-        _db: &dyn SemanticDb,
-        op: ast::Operator,
-        right_ty: Type,
-    ) -> QueryResult<Type> {
-        match self {
-            Type::Any => Ok(Type::Any),
-            Type::Unknown => Ok(Type::Unknown),
-            Type::IntLiteral(n) => {
-                match right_ty {
-                    Type::IntLiteral(m) => {
-                        match op {
-                            ast::Operator::Add => Ok(n
-                                .checked_add(m)
-                                .map(Type::IntLiteral)
-                                // TODO builtins.int
-                                .unwrap_or(Type::Unknown)),
-                            ast::Operator::Sub => Ok(n
-                                .checked_sub(m)
-                                .map(Type::IntLiteral)
-                                // TODO builtins.int
-                                .unwrap_or(Type::Unknown)),
-                            ast::Operator::Mult => Ok(n
-                                .checked_mul(m)
-                                .map(Type::IntLiteral)
-                                // TODO builtins.int
-                                .unwrap_or(Type::Unknown)),
-                            ast::Operator::Div => Ok(n
-                                .checked_div(m)
-                                .map(Type::IntLiteral)
-                                // TODO builtins.int
-                                .unwrap_or(Type::Unknown)),
-                            ast::Operator::Mod => Ok(n
-                                .checked_rem(m)
-                                .map(Type::IntLiteral)
-                                // TODO division by zero error
-                                .unwrap_or(Type::Unknown)),
-                            _ => todo!("complete binop op support for IntLiteral"),
-                        }
-                    }
-                    _ => todo!("complete binop right_ty support for IntLiteral"),
-                }
-            }
-            _ => todo!("complete binop support"),
-        }
-    }
 }

 impl From<FunctionTypeId> for Type {
@@ -173,7 +80,7 @@ impl TypeStore {
        self.modules.remove(&file_id);
    }

-    pub fn cache_symbol_public_type(&self, symbol: GlobalSymbolId, ty: Type) {
+    pub fn cache_symbol_type(&self, symbol: GlobalSymbolId, ty: Type) {
        self.add_or_get_module(symbol.file_id)
            .symbol_types
            .insert(symbol.symbol_id, ty);
@@ -185,7 +92,7 @@ impl TypeStore {
            .insert(node_key, ty);
    }

-    pub fn get_cached_symbol_public_type(&self, symbol: GlobalSymbolId) -> Option<Type> {
+    pub fn get_cached_symbol_type(&self, symbol: GlobalSymbolId) -> Option<Type> {
        self.try_get_module(symbol.file_id)?
            .symbol_types
            .get(&symbol.symbol_id)
@@ -213,7 +120,7 @@ impl TypeStore {
        self.modules.get(&file_id)
    }

-    fn add_function_type(
+    fn add_function(
        &self,
        file_id: FileId,
        name: &str,
@@ -225,18 +132,7 @@ impl TypeStore {
            .add_function(name, symbol_id, scope_id, decorators)
    }

-    fn add_function(
-        &self,
-        file_id: FileId,
-        name: &str,
-        symbol_id: SymbolId,
-        scope_id: ScopeId,
-        decorators: Vec<Type>,
-    ) -> Type {
-        Type::Function(self.add_function_type(file_id, name, symbol_id, scope_id, decorators))
-    }
-
-    fn add_class_type(
+    fn add_class(
        &self,
        file_id: FileId,
        name: &str,
@@ -247,36 +143,12 @@ impl TypeStore {
            .add_class(name, scope_id, bases)
    }

-    fn add_class(&self, file_id: FileId, name: &str, scope_id: ScopeId, bases: Vec<Type>) -> Type {
-        Type::Class(self.add_class_type(file_id, name, scope_id, bases))
-    }
-
-    /// add "raw" union type with exactly given elements
-    fn add_union_type(&self, file_id: FileId, elems: &[Type]) -> UnionTypeId {
+    fn add_union(&mut self, file_id: FileId, elems: &[Type]) -> UnionTypeId {
        self.add_or_get_module(file_id).add_union(elems)
    }

-    /// add union with normalization; may not return a `UnionType`
-    fn add_union(&self, file_id: FileId, elems: &[Type]) -> Type {
-        let mut flattened = Vec::with_capacity(elems.len());
-        for ty in elems {
-            match ty {
-                Type::Union(union_id) => flattened.extend(union_id.elements(self)),
-                _ => flattened.push(*ty),
-            }
-        }
-        // TODO don't add identical unions
-        // TODO de-duplicate union elements
-        match flattened[..] {
-            [] => Type::Never,
-            [ty] => ty,
-            _ => Type::Union(self.add_union_type(file_id, &flattened)),
-        }
-    }
-
-    /// add "raw" intersection type with exactly given elements
-    fn add_intersection_type(
-        &self,
+    fn add_intersection(
+        &mut self,
        file_id: FileId,
        positive: &[Type],
        negative: &[Type],
@@ -285,38 +157,6 @@ impl TypeStore {
            .add_intersection(positive, negative)
    }

-    /// add intersection with normalization; may not return an `IntersectionType`
-    fn add_intersection(&self, file_id: FileId, positive: &[Type], negative: &[Type]) -> Type {
-        let mut pos_flattened = Vec::with_capacity(positive.len());
-        let mut neg_flattened = Vec::with_capacity(negative.len());
-        for ty in positive {
-            match ty {
-                Type::Intersection(intersection_id) => {
-                    pos_flattened.extend(intersection_id.positive(self));
-                    neg_flattened.extend(intersection_id.negative(self));
-                }
-                _ => pos_flattened.push(*ty),
-            }
-        }
-        for ty in negative {
-            match ty {
-                Type::Intersection(intersection_id) => {
-                    pos_flattened.extend(intersection_id.negative(self));
-                    neg_flattened.extend(intersection_id.positive(self));
-                }
-                _ => neg_flattened.push(*ty),
-            }
-        }
-        // TODO don't add identical intersections
-        // TODO deduplicate intersection elements
-        // TODO maintain DNF form (union of intersections)
-        match (&pos_flattened[..], &neg_flattened[..]) {
-            ([], []) => Type::Any, // TODO should be object
-            ([ty], []) => *ty,
-            (pos, neg) => Type::Intersection(self.add_intersection_type(file_id, pos, neg)),
-        }
-    }
-
    fn get_function(&self, id: FunctionTypeId) -> FunctionTypeRef {
        FunctionTypeRef {
            module_store: self.get_module(id.file_id),
@@ -452,11 +292,10 @@ impl FunctionTypeId {
        self,
        db: &dyn SemanticDb,
    ) -> QueryResult<Option<ClassTypeId>> {
-        let index = semantic_index(db, self.file_id)?;
-        let table = index.symbol_table();
+        let table = symbol_table(db, self.file_id)?;
        let FunctionType { symbol_id, .. } = *self.function(db)?;
-        let scope_id = symbol_id.symbol(table).scope_id();
-        let scope = scope_id.scope(table);
+        let scope_id = symbol_id.symbol(&table).scope_id();
+        let scope = scope_id.scope(&table);
        if !matches!(scope.kind(), ScopeKind::Class) {
            return Ok(None);
        };
@@ -497,31 +336,6 @@ impl FunctionTypeId {
    }
 }

-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-pub struct ModuleTypeId {
-    module: Module,
-    file_id: FileId,
-}
-
-impl ModuleTypeId {
-    fn module(self, db: &dyn SemanticDb) -> QueryResult<ModuleStoreRef> {
-        let jar: &SemanticJar = db.jar()?;
-        Ok(jar.type_store.add_or_get_module(self.file_id).downgrade())
-    }
-
-    pub(crate) fn name(self, db: &dyn SemanticDb) -> QueryResult<ModuleName> {
-        self.module.name(db)
-    }
-
-    fn get_member(self, db: &dyn SemanticDb, name: &Name) -> QueryResult<Option<Type>> {
-        if let Some(symbol_id) = resolve_global_symbol(db, self.module, name)? {
-            Ok(Some(infer_symbol_public_type(db, symbol_id)?))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
 pub struct ClassTypeId {
    file_id: FileId,
@@ -561,9 +375,9 @@ impl ClassTypeId {
    fn get_own_class_member(self, db: &dyn SemanticDb, name: &Name) -> QueryResult<Option<Type>> {
        // TODO: this should distinguish instance-only members (e.g. `x: int`) and not return them
        let ClassType { scope_id, .. } = *self.class(db)?;
-        let index = semantic_index(db, self.file_id)?;
-        if let Some(symbol_id) = index.symbol_table().symbol_id_by_name(scope_id, name) {
-            Ok(Some(infer_symbol_public_type(
+        let table = symbol_table(db, self.file_id)?;
+        if let Some(symbol_id) = table.symbol_id_by_name(scope_id, name) {
+            Ok(Some(infer_symbol_type(
                db,
                GlobalSymbolId {
                    file_id: self.file_id,
@@ -575,13 +389,7 @@ impl ClassTypeId {
        }
    }

-    /// Get own class member or fall back to super-class member.
-    fn get_class_member(self, db: &dyn SemanticDb, name: &Name) -> QueryResult<Option<Type>> {
-        self.get_own_class_member(db, name)
-            .or_else(|_| self.get_super_class_member(db, name))
-    }
-
-    // TODO: get_own_instance_member, get_instance_member
+    // TODO: get_own_instance_member, get_class_member, get_instance_member
 }

 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
@@ -590,31 +398,12 @@ pub struct UnionTypeId {
    union_id: ModuleUnionTypeId,
 }

-impl UnionTypeId {
-    pub fn elements(self, type_store: &TypeStore) -> Vec<Type> {
-        let union = type_store.get_union(self);
-        union.elements.iter().copied().collect()
-    }
-}
-
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
 pub struct IntersectionTypeId {
    file_id: FileId,
    intersection_id: ModuleIntersectionTypeId,
 }

-impl IntersectionTypeId {
-    pub fn positive(self, type_store: &TypeStore) -> Vec<Type> {
-        let intersection = type_store.get_intersection(self);
-        intersection.positive.iter().copied().collect()
-    }
-
-    pub fn negative(self, type_store: &TypeStore) -> Vec<Type> {
-        let intersection = type_store.get_intersection(self);
-        intersection.negative.iter().copied().collect()
-    }
-}
-
 #[newtype_index]
 struct ModuleFunctionTypeId;

@@ -638,7 +427,7 @@ struct ModuleTypeStore {
    unions: IndexVec<ModuleUnionTypeId, UnionType>,
    /// arena of all intersection types created in this module
    intersections: IndexVec<ModuleIntersectionTypeId, IntersectionType>,
-    /// cached public types of symbols in this module
+    /// cached types of symbols in this module
    symbol_types: FxHashMap<SymbolId, Type>,
    /// cached types of AST nodes in this module
    node_types: FxHashMap<NodeKey, Type>,
@@ -740,11 +529,6 @@ impl std::fmt::Display for DisplayType<'_> {
            Type::Never => f.write_str("Never"),
            Type::Unknown => f.write_str("Unknown"),
            Type::Unbound => f.write_str("Unbound"),
-            Type::None => f.write_str("None"),
-            Type::Module(module_id) => {
-                // NOTE: something like this?: "<module 'module-name' from 'path-from-fileid'>"
-                todo!("{module_id:?}")
-            }
            // TODO functions and classes should display using a fully qualified name
            Type::Class(class_id) => {
                f.write_str("Literal[")?;
@@ -763,7 +547,6 @@ impl std::fmt::Display for DisplayType<'_> {
                .get_module(int_id.file_id)
                .get_intersection(int_id.intersection_id)
                .display(f, self.store),
-            Type::IntLiteral(n) => write!(f, "Literal[{n}]"),
        }
    }
 }
@@ -822,42 +605,16 @@ pub(crate) struct UnionType {

 impl UnionType {
    fn display(&self, f: &mut std::fmt::Formatter<'_>, store: &TypeStore) -> std::fmt::Result {
-        let (int_literals, other_types): (Vec<Type>, Vec<Type>) = self
-            .elements
-            .iter()
-            .copied()
-            .partition(|ty| matches!(ty, Type::IntLiteral(_)));
+        f.write_str("(")?;
        let mut first = true;
-        if !int_literals.is_empty() {
-            f.write_str("Literal[")?;
-            let mut nums: Vec<i64> = int_literals
-                .into_iter()
-                .filter_map(|ty| {
-                    if let Type::IntLiteral(n) = ty {
-                        Some(n)
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-            nums.sort_unstable();
-            for num in nums {
-                if !first {
-                    f.write_str(", ")?;
-                }
-                write!(f, "{num}")?;
-                first = false;
-            }
-            f.write_str("]")?;
-        }
-        for ty in other_types {
+        for ty in &self.elements {
            if !first {
                f.write_str(" | ")?;
            };
            first = false;
            write!(f, "{}", ty.display(store))?;
        }
-        Ok(())
+        f.write_str(")")
    }
 }

@@ -877,6 +634,7 @@ pub(crate) struct IntersectionType {

 impl IntersectionType {
    fn display(&self, f: &mut std::fmt::Formatter<'_>, store: &TypeStore) -> std::fmt::Result {
+        f.write_str("(")?;
        let mut first = true;
        for (neg, ty) in self
            .positive
@@ -893,79 +651,25 @@ impl IntersectionType {
            };
            write!(f, "{}", ty.display(store))?;
        }
-        Ok(())
+        f.write_str(")")
    }
 }

 #[cfg(test)]
 mod tests {
-    use super::Type;
    use std::path::Path;

    use crate::files::Files;
-    use crate::semantic::symbol_table::SymbolTableBuilder;
-    use crate::semantic::{FileId, ScopeId, SymbolFlags, SymbolTable, TypeStore};
+    use crate::symbols::{SymbolFlags, SymbolTable};
+    use crate::types::{Type, TypeStore};
    use crate::FxIndexSet;

-    struct TestCase {
-        store: TypeStore,
-        files: Files,
-        file_id: FileId,
-        root_scope: ScopeId,
-    }
-
-    fn create_test() -> TestCase {
-        let files = Files::default();
-        let file_id = files.intern(Path::new("/foo"));
-        TestCase {
-            store: TypeStore::default(),
-            files,
-            file_id,
-            root_scope: SymbolTable::root_scope_id(),
-        }
-    }
-
-    fn assert_union_elements(store: &TypeStore, union: Type, elements: &[Type]) {
-        let Type::Union(union_id) = union else {
-            panic!("should be a union")
-        };
-
-        assert_eq!(
-            store.get_union(union_id).elements,
-            elements.iter().copied().collect::<FxIndexSet<_>>()
-        );
-    }
-
-    fn assert_intersection_elements(
-        store: &TypeStore,
-        intersection: Type,
-        positive: &[Type],
-        negative: &[Type],
-    ) {
-        let Type::Intersection(intersection_id) = intersection else {
-            panic!("should be a intersection")
-        };
-
-        assert_eq!(
-            store.get_intersection(intersection_id).positive,
-            positive.iter().copied().collect::<FxIndexSet<_>>()
-        );
-        assert_eq!(
-            store.get_intersection(intersection_id).negative,
-            negative.iter().copied().collect::<FxIndexSet<_>>()
-        );
-    }
-
    #[test]
    fn add_class() {
-        let TestCase {
-            store,
-            file_id,
-            root_scope,
-            ..
-        } = create_test();
-
-        let id = store.add_class_type(file_id, "C", root_scope, Vec::new());
+        let store = TypeStore::default();
+        let files = Files::default();
+        let file_id = files.intern(Path::new("/foo"));
+        let id = store.add_class(file_id, "C", SymbolTable::root_scope_id(), Vec::new());
        assert_eq!(store.get_class(id).name(), "C");
        let inst = Type::Instance(id);
        assert_eq!(format!("{}", inst.display(&store)), "C");
@@ -973,26 +677,21 @@ mod tests {

    #[test]
    fn add_function() {
-        let TestCase {
-            store,
-            file_id,
-            root_scope,
-            ..
-        } = create_test();
-
-        let mut builder = SymbolTableBuilder::new();
-        let func_symbol = builder.add_or_update_symbol(
+        let store = TypeStore::default();
+        let files = Files::default();
+        let file_id = files.intern(Path::new("/foo"));
+        let mut table = SymbolTable::new();
+        let func_symbol = table.add_or_update_symbol(
            SymbolTable::root_scope_id(),
            "func",
            SymbolFlags::IS_DEFINED,
        );
-        builder.finish();

-        let id = store.add_function_type(
+        let id = store.add_function(
            file_id,
            "func",
            func_symbol,
-            root_scope,
+            SymbolTable::root_scope_id(),
            vec![Type::Unknown],
        );
        assert_eq!(store.get_function(id).name(), "func");
@@ -1003,117 +702,44 @@ mod tests {

    #[test]
    fn add_union() {
-        let TestCase {
-            store,
-            file_id,
-            root_scope,
-            ..
-        } = create_test();
-
-        let c1 = store.add_class_type(file_id, "C1", root_scope, Vec::new());
-        let c2 = store.add_class_type(file_id, "C2", root_scope, Vec::new());
+        let mut store = TypeStore::default();
+        let files = Files::default();
+        let file_id = files.intern(Path::new("/foo"));
+        let c1 = store.add_class(file_id, "C1", SymbolTable::root_scope_id(), Vec::new());
+        let c2 = store.add_class(file_id, "C2", SymbolTable::root_scope_id(), Vec::new());
        let elems = vec![Type::Instance(c1), Type::Instance(c2)];
-        let id = store.add_union_type(file_id, &elems);
+        let id = store.add_union(file_id, &elems);
+        assert_eq!(
+            store.get_union(id).elements,
+            elems.into_iter().collect::<FxIndexSet<_>>()
+        );
        let union = Type::Union(id);
-
-        assert_union_elements(&store, union, &elems);
-        assert_eq!(format!("{}", union.display(&store)), "C1 | C2");
+        assert_eq!(format!("{}", union.display(&store)), "(C1 | C2)");
    }

    #[test]
    fn add_intersection() {
-        let TestCase {
-            store,
-            file_id,
-            root_scope,
-            ..
-        } = create_test();
-
-        let c1 = store.add_class_type(file_id, "C1", root_scope, Vec::new());
-        let c2 = store.add_class_type(file_id, "C2", root_scope, Vec::new());
-        let c3 = store.add_class_type(file_id, "C3", root_scope, Vec::new());
+        let mut store = TypeStore::default();
+        let files = Files::default();
+        let file_id = files.intern(Path::new("/foo"));
+        let c1 = store.add_class(file_id, "C1", SymbolTable::root_scope_id(), Vec::new());
+        let c2 = store.add_class(file_id, "C2", SymbolTable::root_scope_id(), Vec::new());
+        let c3 = store.add_class(file_id, "C3", SymbolTable::root_scope_id(), Vec::new());
        let pos = vec![Type::Instance(c1), Type::Instance(c2)];
        let neg = vec![Type::Instance(c3)];
-        let id = store.add_intersection_type(file_id, &pos, &neg);
+        let id = store.add_intersection(file_id, &pos, &neg);
+        assert_eq!(
+            store.get_intersection(id).positive,
+            pos.into_iter().collect::<FxIndexSet<_>>()
+        );
+        assert_eq!(
+            store.get_intersection(id).negative,
+            neg.into_iter().collect::<FxIndexSet<_>>()
+        );
        let intersection = Type::Intersection(id);
-
-        assert_intersection_elements(&store, intersection, &pos, &neg);
-        assert_eq!(format!("{}", intersection.display(&store)), "C1 & C2 & ~C3");
-    }
-
-    #[test]
-    fn flatten_union_zero_elements() {
-        let TestCase { store, file_id, .. } = create_test();
-
-        let ty = store.add_union(file_id, &[]);
-
-        assert!(matches!(ty, Type::Never), "{ty:?} should be Never");
-    }
-
-    #[test]
-    fn flatten_union_one_element() {
-        let TestCase { store, file_id, .. } = create_test();
-
-        let ty = store.add_union(file_id, &[Type::None]);
-
-        assert!(matches!(ty, Type::None), "{ty:?} should be None");
-    }
-
-    #[test]
-    fn flatten_nested_union() {
-        let TestCase { store, file_id, .. } = create_test();
-
-        let l1 = Type::IntLiteral(1);
-        let l2 = Type::IntLiteral(2);
-        let u1 = store.add_union(file_id, &[l1, l2]);
-        let u2 = store.add_union(file_id, &[u1, Type::None]);
-
-        assert_union_elements(&store, u2, &[l1, l2, Type::None]);
-    }
-
-    #[test]
-    fn flatten_intersection_zero_elements() {
-        let TestCase { store, file_id, .. } = create_test();
-
-        let ty = store.add_intersection(file_id, &[], &[]);
-
-        // TODO should be object, not Any
-        assert!(matches!(ty, Type::Any), "{ty:?} should be object");
-    }
-
-    #[test]
-    fn flatten_intersection_one_positive_element() {
-        let TestCase { store, file_id, .. } = create_test();
-
-        let ty = store.add_intersection(file_id, &[Type::None], &[]);
-
-        assert!(matches!(ty, Type::None), "{ty:?} should be None");
-    }
-
-    #[test]
-    fn flatten_intersection_one_negative_element() {
-        let TestCase { store, file_id, .. } = create_test();
-
-        let ty = store.add_intersection(file_id, &[], &[Type::None]);
-
-        assert_intersection_elements(&store, ty, &[], &[Type::None]);
-    }
-
-    #[test]
-    fn flatten_nested_intersection() {
-        let TestCase {
-            store,
-            file_id,
-            root_scope,
-            ..
-        } = create_test();
-
-        let c1 = Type::Instance(store.add_class_type(file_id, "C1", root_scope, vec![]));
-        let c2 = Type::Instance(store.add_class_type(file_id, "C2", root_scope, vec![]));
-        let c1sub = Type::Instance(store.add_class_type(file_id, "C1sub", root_scope, vec![c1]));
-        let i1 = store.add_intersection(file_id, &[c1, c2], &[c1sub]);
-        let i2 = store.add_intersection(file_id, &[i1, Type::None], &[]);
-
-        assert_intersection_elements(&store, i2, &[c1, c2, Type::None], &[c1sub]);
+        assert_eq!(
+            format!("{}", intersection.display(&store)),
+            "(C1 & C2 & ~C3)"
+        );
    }
 }
--- a/crates/red_knot/src/types/infer.rs
+++ b/crates/red_knot/src/types/infer.rs
@@ -0,0 +1,292 @@
+#![allow(dead_code)]
+
+use ruff_python_ast as ast;
+use ruff_python_ast::AstNode;
+
+use crate::db::{QueryResult, SemanticDb, SemanticJar};
+
+use crate::module::ModuleName;
+use crate::parse::parse;
+use crate::symbols::{
+    resolve_global_symbol, symbol_table, Definition, GlobalSymbolId, ImportFromDefinition,
+};
+use crate::types::Type;
+use crate::FileId;
+
+// FIXME: Figure out proper dead-lock free synchronisation now that this takes `&db` instead of `&mut db`.
+#[tracing::instrument(level = "trace", skip(db))]
+pub fn infer_symbol_type(db: &dyn SemanticDb, symbol: GlobalSymbolId) -> QueryResult<Type> {
+    let symbols = symbol_table(db, symbol.file_id)?;
+    let defs = symbols.definitions(symbol.symbol_id);
+    let jar: &SemanticJar = db.jar()?;
+
+    if let Some(ty) = jar.type_store.get_cached_symbol_type(symbol) {
+        return Ok(ty);
+    }
+
+    // TODO handle multiple defs, conditional defs...
+    assert_eq!(defs.len(), 1);
+
+    let ty = infer_definition_type(db, symbol, defs[0].clone())?;
+
+    jar.type_store.cache_symbol_type(symbol, ty);
+
+    // TODO record dependencies
+    Ok(ty)
+}
+
+#[tracing::instrument(level = "trace", skip(db))]
+pub fn infer_definition_type(
+    db: &dyn SemanticDb,
+    symbol: GlobalSymbolId,
+    definition: Definition,
+) -> QueryResult<Type> {
+    let jar: &SemanticJar = db.jar()?;
+    let type_store = &jar.type_store;
+    let file_id = symbol.file_id;
+
+    match definition {
+        Definition::ImportFrom(ImportFromDefinition {
+            module,
+            name,
+            level,
+        }) => {
+            // TODO relative imports
+            assert!(matches!(level, 0));
+            let module_name = ModuleName::new(module.as_ref().expect("TODO relative imports"));
+            if let Some(remote_symbol) = resolve_global_symbol(db, module_name, &name)? {
+                infer_symbol_type(db, remote_symbol)
+            } else {
+                Ok(Type::Unknown)
+            }
+        }
+        Definition::ClassDef(node_key) => {
+            if let Some(ty) = type_store.get_cached_node_type(file_id, node_key.erased()) {
+                Ok(ty)
+            } else {
+                let parsed = parse(db.upcast(), file_id)?;
+                let ast = parsed.ast();
+                let table = symbol_table(db, file_id)?;
+                let node = node_key.resolve_unwrap(ast.as_any_node_ref());
+
+                let mut bases = Vec::with_capacity(node.bases().len());
+
+                for base in node.bases() {
+                    bases.push(infer_expr_type(db, file_id, base)?);
+                }
+                let scope_id = table.scope_id_for_node(node_key.erased());
+                let ty = Type::Class(type_store.add_class(file_id, &node.name.id, scope_id, bases));
+                type_store.cache_node_type(file_id, *node_key.erased(), ty);
+                Ok(ty)
+            }
+        }
+        Definition::FunctionDef(node_key) => {
+            if let Some(ty) = type_store.get_cached_node_type(file_id, node_key.erased()) {
+                Ok(ty)
+            } else {
+                let parsed = parse(db.upcast(), file_id)?;
+                let ast = parsed.ast();
+                let table = symbol_table(db, file_id)?;
+                let node = node_key
+                    .resolve(ast.as_any_node_ref())
+                    .expect("node key should resolve");
+
+                let decorator_tys = node
+                    .decorator_list
+                    .iter()
+                    .map(|decorator| infer_expr_type(db, file_id, &decorator.expression))
+                    .collect::<QueryResult<_>>()?;
+                let scope_id = table.scope_id_for_node(node_key.erased());
+                let ty = type_store
+                    .add_function(
+                        file_id,
+                        &node.name.id,
+                        symbol.symbol_id,
+                        scope_id,
+                        decorator_tys,
+                    )
+                    .into();
+                type_store.cache_node_type(file_id, *node_key.erased(), ty);
+                Ok(ty)
+            }
+        }
+        Definition::Assignment(node_key) => {
+            let parsed = parse(db.upcast(), file_id)?;
+            let ast = parsed.ast();
+            let node = node_key.resolve_unwrap(ast.as_any_node_ref());
+            // TODO handle unpacking assignment correctly
+            infer_expr_type(db, file_id, &node.value)
+        }
+        _ => todo!("other kinds of definitions"),
+    }
+}
+
+fn infer_expr_type(db: &dyn SemanticDb, file_id: FileId, expr: &ast::Expr) -> QueryResult<Type> {
+    // TODO cache the resolution of the type on the node
+    let symbols = symbol_table(db, file_id)?;
+    match expr {
+        ast::Expr::Name(name) => {
+            // TODO look up in the correct scope, don't assume global
+            if let Some(symbol_id) = symbols.root_symbol_id_by_name(&name.id) {
+                infer_symbol_type(db, GlobalSymbolId { file_id, symbol_id })
+            } else {
+                Ok(Type::Unknown)
+            }
+        }
+        _ => todo!("full expression type resolution"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::db::tests::TestDb;
+    use crate::db::{HasJar, SemanticJar};
+    use crate::module::{
+        resolve_module, set_module_search_paths, ModuleName, ModuleSearchPath, ModuleSearchPathKind,
+    };
+    use crate::symbols::{symbol_table, GlobalSymbolId};
+    use crate::types::{infer_symbol_type, Type};
+    use crate::Name;
+
+    // TODO with virtual filesystem we shouldn't have to write files to disk for these
+    // tests
+
+    struct TestCase {
+        temp_dir: tempfile::TempDir,
+        db: TestDb,
+
+        src: ModuleSearchPath,
+    }
+
+    fn create_test() -> std::io::Result<TestCase> {
+        let temp_dir = tempfile::tempdir()?;
+
+        let src = temp_dir.path().join("src");
+        std::fs::create_dir(&src)?;
+        let src = ModuleSearchPath::new(src.canonicalize()?, ModuleSearchPathKind::FirstParty);
+
+        let roots = vec![src.clone()];
+
+        let mut db = TestDb::default();
+        set_module_search_paths(&mut db, roots);
+
+        Ok(TestCase { temp_dir, db, src })
+    }
+
+    #[test]
+    fn follow_import_to_class() -> anyhow::Result<()> {
+        let case = create_test()?;
+        let db = &case.db;
+
+        let a_path = case.src.path().join("a.py");
+        let b_path = case.src.path().join("b.py");
+        std::fs::write(a_path, "from b import C as D; E = D")?;
+        std::fs::write(b_path, "class C: pass")?;
+        let a_file = resolve_module(db, ModuleName::new("a"))?
+            .expect("module should be found")
+            .path(db)?
+            .file();
+        let a_syms = symbol_table(db, a_file)?;
+        let e_sym = a_syms
+            .root_symbol_id_by_name("E")
+            .expect("E symbol should be found");
+
+        let ty = infer_symbol_type(
+            db,
+            GlobalSymbolId {
+                file_id: a_file,
+                symbol_id: e_sym,
+            },
+        )?;
+
+        let jar = HasJar::<SemanticJar>::jar(db)?;
+        assert!(matches!(ty, Type::Class(_)));
+        assert_eq!(format!("{}", ty.display(&jar.type_store)), "Literal[C]");
+
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_base_class_by_name() -> anyhow::Result<()> {
+        let case = create_test()?;
+        let db = &case.db;
+
+        let path = case.src.path().join("mod.py");
+        std::fs::write(path, "class Base: pass\nclass Sub(Base): pass")?;
+        let file = resolve_module(db, ModuleName::new("mod"))?
+            .expect("module should be found")
+            .path(db)?
+            .file();
+        let syms = symbol_table(db, file)?;
+        let sym = syms
+            .root_symbol_id_by_name("Sub")
+            .expect("Sub symbol should be found");
+
+        let ty = infer_symbol_type(
+            db,
+            GlobalSymbolId {
+                file_id: file,
+                symbol_id: sym,
+            },
+        )?;
+
+        let Type::Class(class_id) = ty else {
+            panic!("Sub is not a Class")
+        };
+        let jar = HasJar::<SemanticJar>::jar(db)?;
+        let base_names: Vec<_> = jar
+            .type_store
+            .get_class(class_id)
+            .bases()
+            .iter()
+            .map(|base_ty| format!("{}", base_ty.display(&jar.type_store)))
+            .collect();
+
+        assert_eq!(base_names, vec!["Literal[Base]"]);
+
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_method() -> anyhow::Result<()> {
+        let case = create_test()?;
+        let db = &case.db;
+
+        let path = case.src.path().join("mod.py");
+        std::fs::write(path, "class C:\n  def f(self): pass")?;
+        let file = resolve_module(db, ModuleName::new("mod"))?
+            .expect("module should be found")
+            .path(db)?
+            .file();
+        let syms = symbol_table(db, file)?;
+        let sym = syms
+            .root_symbol_id_by_name("C")
+            .expect("C symbol should be found");
+
+        let ty = infer_symbol_type(
+            db,
+            GlobalSymbolId {
+                file_id: file,
+                symbol_id: sym,
+            },
+        )?;
+
+        let Type::Class(class_id) = ty else {
+            panic!("C is not a Class");
+        };
+
+        let member_ty = class_id
+            .get_own_class_member(db, &Name::new("f"))
+            .expect("C.f to resolve");
+
+        let Some(Type::Function(func_id)) = member_ty else {
+            panic!("C.f is not a Function");
+        };
+
+        let jar = HasJar::<SemanticJar>::jar(db)?;
+        let function = jar.type_store.get_function(func_id);
+        assert_eq!(function.name(), "f");
+
+        Ok(())
+    }
+}
--- a/crates/red_knot_module_resolver/vendor/typeshed/LICENSE
+++ b/crates/red_knot_module_resolver/vendor/typeshed/LICENSE
--- a/crates/red_knot_module_resolver/vendor/typeshed/README.md
+++ b/crates/red_knot_module_resolver/vendor/typeshed/README.md
--- a/crates/red_knot/vendor/typeshed/source_commit.txt
+++ b/crates/red_knot/vendor/typeshed/source_commit.txt
@@ -0,0 +1 @@
+a9d7e861f7a46ae7acd56569326adef302e10f29
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/VERSIONS
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/VERSIONS
@@ -65,9 +65,9 @@ array: 3.0-
 ast: 3.0-
 asynchat: 3.0-3.11
 asyncio: 3.4-
+asyncio.mixins: 3.10-
 asyncio.exceptions: 3.8-
 asyncio.format_helpers: 3.7-
-asyncio.mixins: 3.10-
 asyncio.runners: 3.7-
 asyncio.staggered: 3.8-
 asyncio.taskgroups: 3.11-
@@ -166,7 +166,7 @@ ipaddress: 3.3-
 itertools: 3.0-
 json: 3.0-
 keyword: 3.0-
-lib2to3: 3.0-3.12
+lib2to3: 3.0-
 linecache: 3.0-
 locale: 3.0-
 logging: 3.0-
@@ -270,7 +270,6 @@ threading: 3.0-
 time: 3.0-
 timeit: 3.0-
 tkinter: 3.0-
-tkinter.tix: 3.0-3.12
 token: 3.0-
 tokenize: 3.0-
 tomllib: 3.11-
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/future.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/future.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/main.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/main.pyi
--- a/crates/red_knot/vendor/typeshed/stdlib/_ast.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/_ast.pyi
@@ -0,0 +1,591 @@
+import sys
+import typing_extensions
+from typing import Any, ClassVar, Literal
+
+PyCF_ONLY_AST: Literal[1024]
+PyCF_TYPE_COMMENTS: Literal[4096]
+PyCF_ALLOW_TOP_LEVEL_AWAIT: Literal[8192]
+
+# Alias used for fields that must always be valid identifiers
+# A string `x` counts as a valid identifier if both the following are True
+# (1) `x.isidentifier()` evaluates to `True`
+# (2) `keyword.iskeyword(x)` evaluates to `False`
+_Identifier: typing_extensions.TypeAlias = str
+
+class AST:
+    if sys.version_info >= (3, 10):
+        __match_args__ = ()
+    _attributes: ClassVar[tuple[str, ...]]
+    _fields: ClassVar[tuple[str, ...]]
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    # TODO: Not all nodes have all of the following attributes
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
+    type_comment: str | None
+
+class mod(AST): ...
+class type_ignore(AST): ...
+
+class TypeIgnore(type_ignore):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("lineno", "tag")
+    tag: str
+
+class FunctionType(mod):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("argtypes", "returns")
+    argtypes: list[expr]
+    returns: expr
+
+class Module(mod):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("body", "type_ignores")
+    body: list[stmt]
+    type_ignores: list[TypeIgnore]
+
+class Interactive(mod):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("body",)
+    body: list[stmt]
+
+class Expression(mod):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("body",)
+    body: expr
+
+class stmt(AST): ...
+
+class FunctionDef(stmt):
+    if sys.version_info >= (3, 12):
+        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment", "type_params")
+    elif sys.version_info >= (3, 10):
+        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment")
+    name: _Identifier
+    args: arguments
+    body: list[stmt]
+    decorator_list: list[expr]
+    returns: expr | None
+    if sys.version_info >= (3, 12):
+        type_params: list[type_param]
+
+class AsyncFunctionDef(stmt):
+    if sys.version_info >= (3, 12):
+        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment", "type_params")
+    elif sys.version_info >= (3, 10):
+        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment")
+    name: _Identifier
+    args: arguments
+    body: list[stmt]
+    decorator_list: list[expr]
+    returns: expr | None
+    if sys.version_info >= (3, 12):
+        type_params: list[type_param]
+
+class ClassDef(stmt):
+    if sys.version_info >= (3, 12):
+        __match_args__ = ("name", "bases", "keywords", "body", "decorator_list", "type_params")
+    elif sys.version_info >= (3, 10):
+        __match_args__ = ("name", "bases", "keywords", "body", "decorator_list")
+    name: _Identifier
+    bases: list[expr]
+    keywords: list[keyword]
+    body: list[stmt]
+    decorator_list: list[expr]
+    if sys.version_info >= (3, 12):
+        type_params: list[type_param]
+
+class Return(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value",)
+    value: expr | None
+
+class Delete(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("targets",)
+    targets: list[expr]
+
+class Assign(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("targets", "value", "type_comment")
+    targets: list[expr]
+    value: expr
+
+class AugAssign(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "op", "value")
+    target: Name | Attribute | Subscript
+    op: operator
+    value: expr
+
+class AnnAssign(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "annotation", "value", "simple")
+    target: Name | Attribute | Subscript
+    annotation: expr
+    value: expr | None
+    simple: int
+
+class For(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "iter", "body", "orelse", "type_comment")
+    target: expr
+    iter: expr
+    body: list[stmt]
+    orelse: list[stmt]
+
+class AsyncFor(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "iter", "body", "orelse", "type_comment")
+    target: expr
+    iter: expr
+    body: list[stmt]
+    orelse: list[stmt]
+
+class While(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("test", "body", "orelse")
+    test: expr
+    body: list[stmt]
+    orelse: list[stmt]
+
+class If(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("test", "body", "orelse")
+    test: expr
+    body: list[stmt]
+    orelse: list[stmt]
+
+class With(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("items", "body", "type_comment")
+    items: list[withitem]
+    body: list[stmt]
+
+class AsyncWith(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("items", "body", "type_comment")
+    items: list[withitem]
+    body: list[stmt]
+
+class Raise(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("exc", "cause")
+    exc: expr | None
+    cause: expr | None
+
+class Try(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("body", "handlers", "orelse", "finalbody")
+    body: list[stmt]
+    handlers: list[ExceptHandler]
+    orelse: list[stmt]
+    finalbody: list[stmt]
+
+if sys.version_info >= (3, 11):
+    class TryStar(stmt):
+        __match_args__ = ("body", "handlers", "orelse", "finalbody")
+        body: list[stmt]
+        handlers: list[ExceptHandler]
+        orelse: list[stmt]
+        finalbody: list[stmt]
+
+class Assert(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("test", "msg")
+    test: expr
+    msg: expr | None
+
+class Import(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("names",)
+    names: list[alias]
+
+class ImportFrom(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("module", "names", "level")
+    module: str | None
+    names: list[alias]
+    level: int
+
+class Global(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("names",)
+    names: list[_Identifier]
+
+class Nonlocal(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("names",)
+    names: list[_Identifier]
+
+class Expr(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value",)
+    value: expr
+
+class Pass(stmt): ...
+class Break(stmt): ...
+class Continue(stmt): ...
+class expr(AST): ...
+
+class BoolOp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("op", "values")
+    op: boolop
+    values: list[expr]
+
+class BinOp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("left", "op", "right")
+    left: expr
+    op: operator
+    right: expr
+
+class UnaryOp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("op", "operand")
+    op: unaryop
+    operand: expr
+
+class Lambda(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("args", "body")
+    args: arguments
+    body: expr
+
+class IfExp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("test", "body", "orelse")
+    test: expr
+    body: expr
+    orelse: expr
+
+class Dict(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("keys", "values")
+    keys: list[expr | None]
+    values: list[expr]
+
+class Set(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elts",)
+    elts: list[expr]
+
+class ListComp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elt", "generators")
+    elt: expr
+    generators: list[comprehension]
+
+class SetComp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elt", "generators")
+    elt: expr
+    generators: list[comprehension]
+
+class DictComp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("key", "value", "generators")
+    key: expr
+    value: expr
+    generators: list[comprehension]
+
+class GeneratorExp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elt", "generators")
+    elt: expr
+    generators: list[comprehension]
+
+class Await(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value",)
+    value: expr
+
+class Yield(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value",)
+    value: expr | None
+
+class YieldFrom(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value",)
+    value: expr
+
+class Compare(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("left", "ops", "comparators")
+    left: expr
+    ops: list[cmpop]
+    comparators: list[expr]
+
+class Call(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("func", "args", "keywords")
+    func: expr
+    args: list[expr]
+    keywords: list[keyword]
+
+class FormattedValue(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value", "conversion", "format_spec")
+    value: expr
+    conversion: int
+    format_spec: expr | None
+
+class JoinedStr(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("values",)
+    values: list[expr]
+
+class Constant(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value", "kind")
+    value: Any  # None, str, bytes, bool, int, float, complex, Ellipsis
+    kind: str | None
+    # Aliases for value, for backwards compatibility
+    s: Any
+    n: int | float | complex
+
+class NamedExpr(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "value")
+    target: Name
+    value: expr
+
+class Attribute(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value", "attr", "ctx")
+    value: expr
+    attr: _Identifier
+    ctx: expr_context
+
+if sys.version_info >= (3, 9):
+    _Slice: typing_extensions.TypeAlias = expr
+else:
+    class slice(AST): ...
+    _Slice: typing_extensions.TypeAlias = slice
+
+class Slice(_Slice):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("lower", "upper", "step")
+    lower: expr | None
+    upper: expr | None
+    step: expr | None
+
+if sys.version_info < (3, 9):
+    class ExtSlice(slice):
+        dims: list[slice]
+
+    class Index(slice):
+        value: expr
+
+class Subscript(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value", "slice", "ctx")
+    value: expr
+    slice: _Slice
+    ctx: expr_context
+
+class Starred(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value", "ctx")
+    value: expr
+    ctx: expr_context
+
+class Name(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("id", "ctx")
+    id: _Identifier
+    ctx: expr_context
+
+class List(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elts", "ctx")
+    elts: list[expr]
+    ctx: expr_context
+
+class Tuple(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elts", "ctx")
+    elts: list[expr]
+    ctx: expr_context
+    if sys.version_info >= (3, 9):
+        dims: list[expr]
+
+class expr_context(AST): ...
+
+if sys.version_info < (3, 9):
+    class AugLoad(expr_context): ...
+    class AugStore(expr_context): ...
+    class Param(expr_context): ...
+
+    class Suite(mod):
+        body: list[stmt]
+
+class Del(expr_context): ...
+class Load(expr_context): ...
+class Store(expr_context): ...
+class boolop(AST): ...
+class And(boolop): ...
+class Or(boolop): ...
+class operator(AST): ...
+class Add(operator): ...
+class BitAnd(operator): ...
+class BitOr(operator): ...
+class BitXor(operator): ...
+class Div(operator): ...
+class FloorDiv(operator): ...
+class LShift(operator): ...
+class Mod(operator): ...
+class Mult(operator): ...
+class MatMult(operator): ...
+class Pow(operator): ...
+class RShift(operator): ...
+class Sub(operator): ...
+class unaryop(AST): ...
+class Invert(unaryop): ...
+class Not(unaryop): ...
+class UAdd(unaryop): ...
+class USub(unaryop): ...
+class cmpop(AST): ...
+class Eq(cmpop): ...
+class Gt(cmpop): ...
+class GtE(cmpop): ...
+class In(cmpop): ...
+class Is(cmpop): ...
+class IsNot(cmpop): ...
+class Lt(cmpop): ...
+class LtE(cmpop): ...
+class NotEq(cmpop): ...
+class NotIn(cmpop): ...
+
+class comprehension(AST):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "iter", "ifs", "is_async")
+    target: expr
+    iter: expr
+    ifs: list[expr]
+    is_async: int
+
+class excepthandler(AST): ...
+
+class ExceptHandler(excepthandler):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("type", "name", "body")
+    type: expr | None
+    name: _Identifier | None
+    body: list[stmt]
+
+class arguments(AST):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("posonlyargs", "args", "vararg", "kwonlyargs", "kw_defaults", "kwarg", "defaults")
+    posonlyargs: list[arg]
+    args: list[arg]
+    vararg: arg | None
+    kwonlyargs: list[arg]
+    kw_defaults: list[expr | None]
+    kwarg: arg | None
+    defaults: list[expr]
+
+class arg(AST):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("arg", "annotation", "type_comment")
+    arg: _Identifier
+    annotation: expr | None
+
+class keyword(AST):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("arg", "value")
+    arg: _Identifier | None
+    value: expr
+
+class alias(AST):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("name", "asname")
+    name: str
+    asname: _Identifier | None
+
+class withitem(AST):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("context_expr", "optional_vars")
+    context_expr: expr
+    optional_vars: expr | None
+
+if sys.version_info >= (3, 10):
+    class Match(stmt):
+        __match_args__ = ("subject", "cases")
+        subject: expr
+        cases: list[match_case]
+
+    class pattern(AST): ...
+    # Without the alias, Pyright complains variables named pattern are recursively defined
+    _Pattern: typing_extensions.TypeAlias = pattern
+
+    class match_case(AST):
+        __match_args__ = ("pattern", "guard", "body")
+        pattern: _Pattern
+        guard: expr | None
+        body: list[stmt]
+
+    class MatchValue(pattern):
+        __match_args__ = ("value",)
+        value: expr
+
+    class MatchSingleton(pattern):
+        __match_args__ = ("value",)
+        value: Literal[True, False] | None
+
+    class MatchSequence(pattern):
+        __match_args__ = ("patterns",)
+        patterns: list[pattern]
+
+    class MatchStar(pattern):
+        __match_args__ = ("name",)
+        name: _Identifier | None
+
+    class MatchMapping(pattern):
+        __match_args__ = ("keys", "patterns", "rest")
+        keys: list[expr]
+        patterns: list[pattern]
+        rest: _Identifier | None
+
+    class MatchClass(pattern):
+        __match_args__ = ("cls", "patterns", "kwd_attrs", "kwd_patterns")
+        cls: expr
+        patterns: list[pattern]
+        kwd_attrs: list[_Identifier]
+        kwd_patterns: list[pattern]
+
+    class MatchAs(pattern):
+        __match_args__ = ("pattern", "name")
+        pattern: _Pattern | None
+        name: _Identifier | None
+
+    class MatchOr(pattern):
+        __match_args__ = ("patterns",)
+        patterns: list[pattern]
+
+if sys.version_info >= (3, 12):
+    class type_param(AST):
+        end_lineno: int
+        end_col_offset: int
+
+    class TypeVar(type_param):
+        __match_args__ = ("name", "bound")
+        name: _Identifier
+        bound: expr | None
+
+    class ParamSpec(type_param):
+        __match_args__ = ("name",)
+        name: _Identifier
+
+    class TypeVarTuple(type_param):
+        __match_args__ = ("name",)
+        name: _Identifier
+
+    class TypeAlias(stmt):
+        __match_args__ = ("name", "type_params", "value")
+        name: Name
+        type_params: list[type_param]
+        value: expr
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_bisect.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_bisect.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_bootlocale.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_bootlocale.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_codecs.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_codecs.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_collections_abc.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_collections_abc.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_compat_pickle.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_compat_pickle.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_compression.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_compression.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_csv.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_csv.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_ctypes.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_ctypes.pyi
@@ -201,7 +201,7 @@ class Array(_CData, Generic[_CT]):
    # Sized and _CData prevents using _CDataMeta.
    def __len__(self) -> int: ...
    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...

 def addressof(obj: _CData) -> int: ...
 def alignment(obj_or_type: _CData | type[_CData]) -> int: ...
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_curses.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_curses.pyi
@@ -63,7 +63,8 @@ A_COLOR: int
 A_DIM: int
 A_HORIZONTAL: int
 A_INVIS: int
-A_ITALIC: int
+if sys.platform != "darwin":
+    A_ITALIC: int
 A_LEFT: int
 A_LOW: int
 A_NORMAL: int
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_decimal.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_decimal.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_dummy_thread.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_dummy_thread.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_dummy_threading.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_dummy_threading.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_heapq.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_heapq.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_imp.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_imp.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_json.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_json.pyi
@@ -45,5 +45,5 @@ class make_scanner:
    def __init__(self, context: make_scanner) -> None: ...
    def __call__(self, string: str, index: int) -> tuple[Any, int]: ...

-def encode_basestring_ascii(s: str, /) -> str: ...
+def encode_basestring_ascii(s: str) -> str: ...
 def scanstring(string: str, end: int, strict: bool = ...) -> tuple[str, int]: ...
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_locale.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_locale.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_lsprof.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_lsprof.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_markupbase.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_markupbase.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_msi.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_msi.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_operator.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_operator.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_osx_support.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_osx_support.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_posixsubprocess.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_posixsubprocess.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_py_abc.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_py_abc.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_pydecimal.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_pydecimal.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_random.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_random.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_sitebuiltins.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_sitebuiltins.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_socket.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_socket.pyi
@@ -783,7 +783,7 @@ def ntohl(x: int, /) -> int: ...  # param & ret val are 32-bit ints
 def ntohs(x: int, /) -> int: ...  # param & ret val are 16-bit ints
 def htonl(x: int, /) -> int: ...  # param & ret val are 32-bit ints
 def htons(x: int, /) -> int: ...  # param & ret val are 16-bit ints
-def inet_aton(ip_addr: str, /) -> bytes: ...  # ret val 4 bytes in length
+def inet_aton(ip_string: str, /) -> bytes: ...  # ret val 4 bytes in length
 def inet_ntoa(packed_ip: ReadableBuffer, /) -> str: ...
 def inet_pton(address_family: int, ip_string: str, /) -> bytes: ...
 def inet_ntop(address_family: int, packed_ip: ReadableBuffer, /) -> str: ...
@@ -797,7 +797,7 @@ if sys.platform != "win32":
    def socketpair(family: int = ..., type: int = ..., proto: int = ..., /) -> tuple[socket, socket]: ...

 def if_nameindex() -> list[tuple[int, str]]: ...
-def if_nametoindex(oname: str, /) -> int: ...
+def if_nametoindex(name: str, /) -> int: ...
 def if_indextoname(index: int, /) -> str: ...

 CAPI: object
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_stat.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_stat.pyi
@@ -64,19 +64,19 @@ UF_NODUMP: Literal[0x00000001]
 UF_NOUNLINK: Literal[0x00000010]
 UF_OPAQUE: Literal[0x00000008]

-def S_IMODE(mode: int, /) -> int: ...
-def S_IFMT(mode: int, /) -> int: ...
-def S_ISBLK(mode: int, /) -> bool: ...
-def S_ISCHR(mode: int, /) -> bool: ...
-def S_ISDIR(mode: int, /) -> bool: ...
-def S_ISDOOR(mode: int, /) -> bool: ...
-def S_ISFIFO(mode: int, /) -> bool: ...
-def S_ISLNK(mode: int, /) -> bool: ...
-def S_ISPORT(mode: int, /) -> bool: ...
-def S_ISREG(mode: int, /) -> bool: ...
-def S_ISSOCK(mode: int, /) -> bool: ...
-def S_ISWHT(mode: int, /) -> bool: ...
-def filemode(mode: int, /) -> str: ...
+def S_IMODE(mode: int) -> int: ...
+def S_IFMT(mode: int) -> int: ...
+def S_ISBLK(mode: int) -> bool: ...
+def S_ISCHR(mode: int) -> bool: ...
+def S_ISDIR(mode: int) -> bool: ...
+def S_ISDOOR(mode: int) -> bool: ...
+def S_ISFIFO(mode: int) -> bool: ...
+def S_ISLNK(mode: int) -> bool: ...
+def S_ISPORT(mode: int) -> bool: ...
+def S_ISREG(mode: int) -> bool: ...
+def S_ISSOCK(mode: int) -> bool: ...
+def S_ISWHT(mode: int) -> bool: ...
+def filemode(mode: int) -> str: ...

 if sys.platform == "win32":
    IO_REPARSE_TAG_SYMLINK: int
@@ -101,17 +101,3 @@ if sys.platform == "win32":
    FILE_ATTRIBUTE_SYSTEM: Literal[4]
    FILE_ATTRIBUTE_TEMPORARY: Literal[256]
    FILE_ATTRIBUTE_VIRTUAL: Literal[65536]
-
-if sys.version_info >= (3, 13):
-    SF_SETTABLE: Literal[0x3FFF0000]
-    # https://github.com/python/cpython/issues/114081#issuecomment-2119017790
-    # SF_RESTRICTED: Literal[0x00080000]
-    SF_FIRMLINK: Literal[0x00800000]
-    SF_DATALESS: Literal[0x40000000]
-
-    SF_SUPPORTED: Literal[0x9F0000]
-    SF_SYNTHETIC: Literal[0xC0000000]
-
-    UF_TRACKED: Literal[0x00000040]
-    UF_DATAVAULT: Literal[0x00000080]
-    UF_SETTABLE: Literal[0x0000FFFF]
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_thread.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_thread.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_threading_local.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_threading_local.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_tkinter.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_tkinter.pyi
@@ -1,7 +1,5 @@
 import sys
-from collections.abc import Callable
 from typing import Any, ClassVar, Literal, final
-from typing_extensions import TypeAlias

 # _tkinter is meant to be only used internally by tkinter, but some tkinter
 # functions e.g. return _tkinter.Tcl_Obj objects. Tcl_Obj represents a Tcl
@@ -32,8 +30,6 @@ class Tcl_Obj:

 class TclError(Exception): ...

-_TkinterTraceFunc: TypeAlias = Callable[[tuple[str, ...]], object]
-
 # This class allows running Tcl code. Tkinter uses it internally a lot, and
 # it's often handy to drop a piece of Tcl code into a tkinter program. Example:
 #
@@ -90,9 +86,6 @@ class TkappType:
    def unsetvar(self, *args, **kwargs): ...
    def wantobjects(self, *args, **kwargs): ...
    def willdispatch(self): ...
-    if sys.version_info >= (3, 12):
-        def gettrace(self, /) -> _TkinterTraceFunc | None: ...
-        def settrace(self, func: _TkinterTraceFunc | None, /) -> None: ...

 # These should be kept in sync with tkinter.tix constants, except ALL_EVENTS which doesn't match TCL_ALL_EVENTS
 ALL_EVENTS: Literal[-3]
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_tracemalloc.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_tracemalloc.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/README.md
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/README.md
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/init.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/init.pyi
@@ -326,8 +326,6 @@ class structseq(Generic[_T_co]):
    # but only has any meaning if you supply it a dict where the keys are strings.
    # https://github.com/python/typeshed/pull/6560#discussion_r767149830
    def __new__(cls: type[Self], sequence: Iterable[_T_co], dict: dict[str, Any] = ...) -> Self: ...
-    if sys.version_info >= (3, 13):
-        def __replace__(self: Self, **kwargs: Any) -> Self: ...

 # Superset of typing.AnyStr that also includes LiteralString
 AnyOrLiteralStr = TypeVar("AnyOrLiteralStr", str, bytes, LiteralString)  # noqa: Y001
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/dbapi.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/dbapi.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/importlib.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/importlib.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/wsgi.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/wsgi.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/xml.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_typeshed/xml.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_warnings.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_warnings.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_weakref.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_weakref.pyi
@@ -27,7 +27,7 @@ class ReferenceType(Generic[_T]):
    def __eq__(self, value: object, /) -> bool: ...
    def __hash__(self) -> int: ...
    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...

 ref = ReferenceType

--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_weakrefset.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_weakrefset.pyi
@@ -48,4 +48,4 @@ class WeakSet(MutableSet[_T]):
    def __or__(self, other: Iterable[_S]) -> WeakSet[_S | _T]: ...
    def isdisjoint(self, other: Iterable[_T]) -> bool: ...
    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_winapi.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/_winapi.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/abc.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/abc.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/aifc.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/aifc.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/antigravity.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/antigravity.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/argparse.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/argparse.pyi
@@ -318,36 +318,19 @@ class Action(_AttributeHolder):
    required: bool
    help: str | None
    metavar: str | tuple[str, ...] | None
-    if sys.version_info >= (3, 13):
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            dest: str,
-            nargs: int | str | None = None,
-            const: _T | None = None,
-            default: _T | str | None = None,
-            type: Callable[[str], _T] | FileType | None = None,
-            choices: Iterable[_T] | None = None,
-            required: bool = False,
-            help: str | None = None,
-            metavar: str | tuple[str, ...] | None = None,
-            deprecated: bool = False,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            dest: str,
-            nargs: int | str | None = None,
-            const: _T | None = None,
-            default: _T | str | None = None,
-            type: Callable[[str], _T] | FileType | None = None,
-            choices: Iterable[_T] | None = None,
-            required: bool = False,
-            help: str | None = None,
-            metavar: str | tuple[str, ...] | None = None,
-        ) -> None: ...
-
+    def __init__(
+        self,
+        option_strings: Sequence[str],
+        dest: str,
+        nargs: int | str | None = None,
+        const: _T | None = None,
+        default: _T | str | None = None,
+        type: Callable[[str], _T] | FileType | None = None,
+        choices: Iterable[_T] | None = None,
+        required: bool = False,
+        help: str | None = None,
+        metavar: str | tuple[str, ...] | None = None,
+    ) -> None: ...
    def __call__(
        self, parser: ArgumentParser, namespace: Namespace, values: str | Sequence[Any] | None, option_string: str | None = None
    ) -> None: ...
@@ -356,56 +339,29 @@ class Action(_AttributeHolder):

 if sys.version_info >= (3, 12):
    class BooleanOptionalAction(Action):
-        if sys.version_info >= (3, 13):
-            @overload
-            def __init__(
-                self,
-                option_strings: Sequence[str],
-                dest: str,
-                default: bool | None = None,
-                *,
-                required: bool = False,
-                help: str | None = None,
-                deprecated: bool = False,
-            ) -> None: ...
-            @overload
-            @deprecated("The `type`, `choices`, and `metavar` parameters are ignored and will be removed in Python 3.14.")
-            def __init__(
-                self,
-                option_strings: Sequence[str],
-                dest: str,
-                default: _T | bool | None = None,
-                type: Callable[[str], _T] | FileType | None = sentinel,
-                choices: Iterable[_T] | None = sentinel,
-                required: bool = False,
-                help: str | None = None,
-                metavar: str | tuple[str, ...] | None = sentinel,
-                deprecated: bool = False,
-            ) -> None: ...
-        else:
-            @overload
-            def __init__(
-                self,
-                option_strings: Sequence[str],
-                dest: str,
-                default: bool | None = None,
-                *,
-                required: bool = False,
-                help: str | None = None,
-            ) -> None: ...
-            @overload
-            @deprecated("The `type`, `choices`, and `metavar` parameters are ignored and will be removed in Python 3.14.")
-            def __init__(
-                self,
-                option_strings: Sequence[str],
-                dest: str,
-                default: _T | bool | None = None,
-                type: Callable[[str], _T] | FileType | None = sentinel,
-                choices: Iterable[_T] | None = sentinel,
-                required: bool = False,
-                help: str | None = None,
-                metavar: str | tuple[str, ...] | None = sentinel,
-            ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            default: bool | None = None,
+            *,
+            required: bool = False,
+            help: str | None = None,
+        ) -> None: ...
+        @overload
+        @deprecated("The `type`, `choices`, and `metavar` parameters are ignored and will be removed in Python 3.14.")
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            default: _T | bool | None = None,
+            type: Callable[[str], _T] | FileType | None = sentinel,
+            choices: Iterable[_T] | None = sentinel,
+            required: bool = False,
+            help: str | None = None,
+            metavar: str | tuple[str, ...] | None = sentinel,
+        ) -> None: ...

 elif sys.version_info >= (3, 9):
    class BooleanOptionalAction(Action):
@@ -475,19 +431,7 @@ class _StoreAction(Action): ...

 # undocumented
 class _StoreConstAction(Action):
-    if sys.version_info >= (3, 13):
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            dest: str,
-            const: Any | None = None,
-            default: Any = None,
-            required: bool = False,
-            help: str | None = None,
-            metavar: str | tuple[str, ...] | None = None,
-            deprecated: bool = False,
-        ) -> None: ...
-    elif sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 11):
        def __init__(
            self,
            option_strings: Sequence[str],
@@ -512,37 +456,15 @@ class _StoreConstAction(Action):

 # undocumented
 class _StoreTrueAction(_StoreConstAction):
-    if sys.version_info >= (3, 13):
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            dest: str,
-            default: bool = False,
-            required: bool = False,
-            help: str | None = None,
-            deprecated: bool = False,
-        ) -> None: ...
-    else:
-        def __init__(
-            self, option_strings: Sequence[str], dest: str, default: bool = False, required: bool = False, help: str | None = None
-        ) -> None: ...
+    def __init__(
+        self, option_strings: Sequence[str], dest: str, default: bool = False, required: bool = False, help: str | None = None
+    ) -> None: ...

 # undocumented
 class _StoreFalseAction(_StoreConstAction):
-    if sys.version_info >= (3, 13):
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            dest: str,
-            default: bool = True,
-            required: bool = False,
-            help: str | None = None,
-            deprecated: bool = False,
-        ) -> None: ...
-    else:
-        def __init__(
-            self, option_strings: Sequence[str], dest: str, default: bool = True, required: bool = False, help: str | None = None
-        ) -> None: ...
+    def __init__(
+        self, option_strings: Sequence[str], dest: str, default: bool = True, required: bool = False, help: str | None = None
+    ) -> None: ...

 # undocumented
 class _AppendAction(Action): ...
@@ -552,19 +474,7 @@ class _ExtendAction(_AppendAction): ...

 # undocumented
 class _AppendConstAction(Action):
-    if sys.version_info >= (3, 13):
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            dest: str,
-            const: Any | None = None,
-            default: Any = None,
-            required: bool = False,
-            help: str | None = None,
-            metavar: str | tuple[str, ...] | None = None,
-            deprecated: bool = False,
-        ) -> None: ...
-    elif sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 11):
        def __init__(
            self,
            option_strings: Sequence[str],
@@ -589,72 +499,27 @@ class _AppendConstAction(Action):

 # undocumented
 class _CountAction(Action):
-    if sys.version_info >= (3, 13):
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            dest: str,
-            default: Any = None,
-            required: bool = False,
-            help: str | None = None,
-            deprecated: bool = False,
-        ) -> None: ...
-    else:
-        def __init__(
-            self, option_strings: Sequence[str], dest: str, default: Any = None, required: bool = False, help: str | None = None
-        ) -> None: ...
+    def __init__(
+        self, option_strings: Sequence[str], dest: str, default: Any = None, required: bool = False, help: str | None = None
+    ) -> None: ...

 # undocumented
 class _HelpAction(Action):
-    if sys.version_info >= (3, 13):
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            dest: str = "==SUPPRESS==",
-            default: str = "==SUPPRESS==",
-            help: str | None = None,
-            deprecated: bool = False,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            dest: str = "==SUPPRESS==",
-            default: str = "==SUPPRESS==",
-            help: str | None = None,
-        ) -> None: ...
+    def __init__(
+        self, option_strings: Sequence[str], dest: str = "==SUPPRESS==", default: str = "==SUPPRESS==", help: str | None = None
+    ) -> None: ...

 # undocumented
 class _VersionAction(Action):
    version: str | None
-    if sys.version_info >= (3, 13):
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            version: str | None = None,
-            dest: str = "==SUPPRESS==",
-            default: str = "==SUPPRESS==",
-            help: str | None = None,
-            deprecated: bool = False,
-        ) -> None: ...
-    elif sys.version_info >= (3, 11):
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            version: str | None = None,
-            dest: str = "==SUPPRESS==",
-            default: str = "==SUPPRESS==",
-            help: str | None = None,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            option_strings: Sequence[str],
-            version: str | None = None,
-            dest: str = "==SUPPRESS==",
-            default: str = "==SUPPRESS==",
-            help: str = "show program's version number and exit",
-        ) -> None: ...
+    def __init__(
+        self,
+        option_strings: Sequence[str],
+        version: str | None = None,
+        dest: str = "==SUPPRESS==",
+        default: str = "==SUPPRESS==",
+        help: str = "show program's version number and exit",
+    ) -> None: ...

 # undocumented
 class _SubParsersAction(Action, Generic[_ArgumentParserT]):
@@ -677,30 +542,7 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):

    # Note: `add_parser` accepts all kwargs of `ArgumentParser.__init__`. It also
    # accepts its own `help` and `aliases` kwargs.
-    if sys.version_info >= (3, 13):
-        def add_parser(
-            self,
-            name: str,
-            *,
-            deprecated: bool = False,
-            help: str | None = ...,
-            aliases: Sequence[str] = ...,
-            # Kwargs from ArgumentParser constructor
-            prog: str | None = ...,
-            usage: str | None = ...,
-            description: str | None = ...,
-            epilog: str | None = ...,
-            parents: Sequence[_ArgumentParserT] = ...,
-            formatter_class: _FormatterClass = ...,
-            prefix_chars: str = ...,
-            fromfile_prefix_chars: str | None = ...,
-            argument_default: Any = ...,
-            conflict_handler: str = ...,
-            add_help: bool = ...,
-            allow_abbrev: bool = ...,
-            exit_on_error: bool = ...,
-        ) -> _ArgumentParserT: ...
-    elif sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 9):
        def add_parser(
            self,
            name: str,
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/array.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/array.pyi
@@ -87,6 +87,6 @@ class array(MutableSequence[_T]):
    def __buffer__(self, flags: int, /) -> memoryview: ...
    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
    if sys.version_info >= (3, 12):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...

 ArrayType = array
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/ast.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/ast.pyi
@@ -365,6 +365,3 @@ def walk(node: AST) -> Iterator[AST]: ...

 if sys.version_info >= (3, 9):
    def main() -> None: ...
-
-if sys.version_info >= (3, 14):
-    def compare(left: AST, right: AST, /, *, compare_attributes: bool = False) -> bool: ...
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asynchat.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asynchat.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/init.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/init.pyi
@@ -30,12 +30,12 @@ if sys.platform == "win32":
 else:
    from .unix_events import *

-_T_co = TypeVar("_T_co", covariant=True)
+_T = TypeVar("_T")

 # Aliases imported by multiple submodules in typeshed
 if sys.version_info >= (3, 12):
-    _AwaitableLike: TypeAlias = Awaitable[_T_co]  # noqa: Y047
-    _CoroutineLike: TypeAlias = Coroutine[Any, Any, _T_co]  # noqa: Y047
+    _AwaitableLike: TypeAlias = Awaitable[_T]  # noqa: Y047
+    _CoroutineLike: TypeAlias = Coroutine[Any, Any, _T]  # noqa: Y047
 else:
-    _AwaitableLike: TypeAlias = Generator[Any, None, _T_co] | Awaitable[_T_co]
-    _CoroutineLike: TypeAlias = Generator[Any, None, _T_co] | Coroutine[Any, Any, _T_co]
+    _AwaitableLike: TypeAlias = Generator[Any, None, _T] | Awaitable[_T]
+    _CoroutineLike: TypeAlias = Generator[Any, None, _T] | Coroutine[Any, Any, _T]
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/base_events.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/base_events.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/base_futures.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/base_futures.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/base_subprocess.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/base_subprocess.pyi
--- a/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/base_tasks.pyi
+++ b/crates/red_knot_module_resolver/vendor/typeshed/stdlib/asyncio/base_tasks.pyi
--- a/Show More
+++ b/Show More