Initial version

Remove extraneous baz.py file (#14299 )
[red-knot] Add tests for member lookup on union types (#14296 )
2024-11-13 10:25:30 +01:00 · 2024-11-12 14:01:19 +00:00 · 2024-11-12 14:11:55 +01:00 · 2024-11-12 11:13:15 +00:00 · 2024-11-11 15:23:34 -05:00 · 2024-11-11 20:48:49 +01:00
683 changed files with 16087 additions and 4736 deletions
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -16,7 +16,7 @@ env:
  CARGO_TERM_COLOR: always
  RUSTUP_MAX_RETRIES: 10
  PACKAGE_NAME: ruff
-  PYTHON_VERSION: "3.11"
+  PYTHON_VERSION: "3.12"

 jobs:
  determine_changes:
--- a/.github/workflows/publish-playground.yml
+++ b/.github/workflows/publish-playground.yml
@@ -47,7 +47,7 @@ jobs:
        working-directory: playground
      - name: "Deploy to Cloudflare Pages"
        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.9.0
+        uses: cloudflare/wrangler-action@v3.12.1
        with:
          apiToken: ${{ secrets.CF_API_TOKEN }}
          accountId: ${{ secrets.CF_ACCOUNT_ID }}
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -17,7 +17,7 @@ exclude: |

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

@@ -51,11 +51,15 @@ repos:
      - id: blacken-docs
        args: ["--pyi", "--line-length", "130"]
        files: '^crates/.*/resources/mdtest/.*\.md'
+        exclude: |
+          (?x)^(
+            .*?invalid(_.+)*_syntax\.md
+          )$
        additional_dependencies:
          - black==24.10.0

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

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

  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.0
+    rev: v0.7.3
    hooks:
      - id: ruff-format
      - id: ruff
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,42 @@
 # Changelog

+## 0.7.3
+
+### Preview features
+
+- Formatter: Disallow single-line implicit concatenated strings ([#13928](https://github.com/astral-sh/ruff/pull/13928))
+- \[`flake8-pyi`\] Include all Python file types for `PYI006` and `PYI066` ([#14059](https://github.com/astral-sh/ruff/pull/14059))
+- \[`flake8-simplify`\] Implement `split-of-static-string` (`SIM905`) ([#14008](https://github.com/astral-sh/ruff/pull/14008))
+- \[`refurb`\] Implement `subclass-builtin` (`FURB189`) ([#14105](https://github.com/astral-sh/ruff/pull/14105))
+- \[`ruff`\] Improve diagnostic messages and docs (`RUF031`, `RUF032`, `RUF034`) ([#14068](https://github.com/astral-sh/ruff/pull/14068))
+
+### Rule changes
+
+- Detect items that hash to same value in duplicate sets (`B033`, `PLC0208`) ([#14064](https://github.com/astral-sh/ruff/pull/14064))
+- \[`eradicate`\] Better detection of IntelliJ language injection comments (`ERA001`) ([#14094](https://github.com/astral-sh/ruff/pull/14094))
+- \[`flake8-pyi`\] Add autofix for `docstring-in-stub` (`PYI021`) ([#14150](https://github.com/astral-sh/ruff/pull/14150))
+- \[`flake8-pyi`\] Update `duplicate-literal-member` (`PYI062`) to alawys provide an autofix ([#14188](https://github.com/astral-sh/ruff/pull/14188))
+- \[`pyflakes`\] Detect items that hash to same value in duplicate dictionaries (`F601`) ([#14065](https://github.com/astral-sh/ruff/pull/14065))
+- \[`ruff`\] Fix false positive for decorators (`RUF028`) ([#14061](https://github.com/astral-sh/ruff/pull/14061))
+
+### Bug fixes
+
+- Avoid parsing joint rule codes as distinct codes in `# noqa` ([#12809](https://github.com/astral-sh/ruff/pull/12809))
+- \[`eradicate`\] ignore `# language=` in commented-out-code rule (ERA001) ([#14069](https://github.com/astral-sh/ruff/pull/14069))
+- \[`flake8-bugbear`\] - do not run `mutable-argument-default` on stubs (`B006`) ([#14058](https://github.com/astral-sh/ruff/pull/14058))
+- \[`flake8-builtins`\] Skip lambda expressions in `builtin-argument-shadowing (A002)` ([#14144](https://github.com/astral-sh/ruff/pull/14144))
+- \[`flake8-comprehension`\] Also remove trailing comma while fixing `C409` and `C419` ([#14097](https://github.com/astral-sh/ruff/pull/14097))
+- \[`flake8-simplify`\] Allow `open` without context manager in `return` statement (`SIM115`) ([#14066](https://github.com/astral-sh/ruff/pull/14066))
+- \[`pylint`\] Respect hash-equivalent literals in `iteration-over-set` (`PLC0208`) ([#14063](https://github.com/astral-sh/ruff/pull/14063))
+- \[`pylint`\] Update known dunder methods for Python 3.13 (`PLW3201`) ([#14146](https://github.com/astral-sh/ruff/pull/14146))
+- \[`pyupgrade`\] - ignore kwarg unpacking for `UP044` ([#14053](https://github.com/astral-sh/ruff/pull/14053))
+- \[`refurb`\] Parse more exotic decimal strings in `verbose-decimal-constructor` (`FURB157`) ([#14098](https://github.com/astral-sh/ruff/pull/14098))
+
+### Documentation
+
+- Add links to missing related options within rule documentations ([#13971](https://github.com/astral-sh/ruff/pull/13971))
+- Add rule short code to mkdocs tags to allow searching via rule codes ([#14040](https://github.com/astral-sh/ruff/pull/14040))
+
 ## 0.7.2

 ### Preview features
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,12 +2,6 @@
 # It is not intended for manual editing.
 version = 3

-[[package]]
-name = "Inflector"
-version = "0.11.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
-
 [[package]]
 name = "adler"
 version = "1.0.2"
@@ -123,9 +117,9 @@ dependencies = [

 [[package]]
 name = "anyhow"
-version = "1.0.91"
+version = "1.0.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c042108f3ed77fd83760a5fd79b53be043192bb3b9dba91d8c574c0ada7850c8"
+checksum = "4c95c10ba0b00a02636238b814946408b1322d5ac4760326e6fb8ec956d85775"

 [[package]]
 name = "append-only-vec"
@@ -407,7 +401,7 @@ dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -424,7 +418,7 @@ checksum = "2f8c93eb5f77c9050c7750e14f13ef1033a40a0aac70c6371535b6763a01438c"
 dependencies = [
 "nix 0.28.0",
 "terminfo",
- "thiserror",
+ "thiserror 1.0.67",
 "which",
 "winapi",
 ]
@@ -687,7 +681,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "strsim 0.10.0",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -698,7 +692,7 @@ checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f"
 dependencies = [
 "darling_core",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -812,6 +806,17 @@ dependencies = [
 "windows-sys 0.48.0",
 ]

+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
 [[package]]
 name = "doc-comment"
 version = "0.3.3"
@@ -1045,9 +1050,9 @@ dependencies = [

 [[package]]
 name = "hashbrown"
-version = "0.15.0"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e087f84d4f86bf4b218b927129862374b72199ae7d8657835f1e89000eea4fb"
+checksum = "3a9bfc1af68b1726ea47d3d5109de126281def866b33970e10fbab11b5dafab3"

 [[package]]
 name = "hashlink"
@@ -1108,6 +1113,124 @@ dependencies = [
 "cc",
 ]

+[[package]]
+name = "icu_collections"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_locid_transform_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e"
+
+[[package]]
+name = "icu_normalizer"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "utf16_iter",
+ "utf8_iter",
+ "write16",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516"
+
+[[package]]
+name = "icu_properties"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locid_transform",
+ "icu_properties_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569"
+
+[[package]]
+name = "icu_provider"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_provider_macros",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_provider_macros"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -1116,12 +1239,23 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"

 [[package]]
 name = "idna"
-version = "0.5.0"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
 ]

 [[package]]
@@ -1162,12 +1296,12 @@ dependencies = [

 [[package]]
 name = "indexmap"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5"
+checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
 dependencies = [
 "equivalent",
- "hashbrown 0.14.5",
+ "hashbrown 0.15.1",
 "serde",
 ]

@@ -1193,9 +1327,9 @@ checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"

 [[package]]
 name = "inotify"
-version = "0.9.6"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8069d3ec154eb856955c1c0fbffefbf5f3c40a104ec912d4797314c1801abff"
+checksum = "fdd168d97690d0b8c412d6b6c10360277f4d7ee495c5d0d5d5fe0854923255cc"
 dependencies = [
 "bitflags 1.3.2",
 "inotify-sys",
@@ -1213,9 +1347,9 @@ dependencies = [

 [[package]]
 name = "insta"
-version = "1.41.0"
+version = "1.41.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f72d3e19488cf7d8ea52d2fc0f8754fc933398b337cd3cbdb28aaeb35159ef"
+checksum = "7e9ffc4d4892617c50a928c52b2961cb5174b6fc6ebf252b2fac9d21955c48b8"
 dependencies = [
 "console",
 "globset",
@@ -1260,14 +1394,14 @@ dependencies = [

 [[package]]
 name = "is-macro"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2069faacbe981460232f880d26bf3c7634e322d49053aa48c27e3ae642f728f1"
+checksum = "1d57a3e447e24c22647738e4607f1df1e0ec6f72e16182c4cd199f647cdfb0e4"
 dependencies = [
- "Inflector",
+ "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -1367,9 +1501,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.161"
+version = "0.2.162"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1"
+checksum = "18d287de67fe55fd7e1581fe933d965a5a9477b38e949cfa9f8574ef01506398"

 [[package]]
 name = "libcst"
@@ -1383,7 +1517,7 @@ dependencies = [
 "paste",
 "peg",
 "regex",
- "thiserror",
+ "thiserror 1.0.67",
 ]

 [[package]]
@@ -1393,7 +1527,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2ae40017ac09cd2c6a53504cb3c871c7f2b41466eac5bc66ba63f39073b467b"
 dependencies = [
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -1429,6 +1563,12 @@ version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"

+[[package]]
+name = "litemap"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "643cb0b8d4fcc284004d5fd0d67ccf61dfffadb7f75e1e71bc420f4688a3a704"
+
 [[package]]
 name = "lock_api"
 version = "0.4.11"
@@ -1486,9 +1626,9 @@ checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"

 [[package]]
 name = "matchit"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
+checksum = "bd0aa4b8ca861b08d68afc8702af3250776898c1508b278e1da9d01e01d4b45c"

 [[package]]
 name = "memchr"
@@ -1532,14 +1672,15 @@ dependencies = [

 [[package]]
 name = "mio"
-version = "0.8.11"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
 dependencies = [
+ "hermit-abi",
 "libc",
 "log",
 "wasi",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -1593,12 +1734,11 @@ dependencies = [

 [[package]]
 name = "notify"
-version = "6.1.1"
+version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
+checksum = "c533b4c39709f9ba5005d8002048266593c1cfaf3c5f0739d5b8ab0c6c504009"
 dependencies = [
 "bitflags 2.6.0",
- "crossbeam-channel",
 "filetime",
 "fsevent-sys",
 "inotify",
@@ -1606,8 +1746,18 @@ dependencies = [
 "libc",
 "log",
 "mio",
+ "notify-types",
 "walkdir",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "notify-types"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7393c226621f817964ffb3dc5704f9509e107a8b024b489cc2c1b217378785df"
+dependencies = [
+ "instant",
 ]

 [[package]]
@@ -1786,9 +1936,9 @@ dependencies = [

 [[package]]
 name = "pep440_rs"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c8ee724d21f351f9d47276614ac9710975db827ba9fe2ca5a517ba648193307"
+checksum = "0922a442c78611fa8c5ed6065d2d898a820cf12fa90604217fdb2d01675efec7"
 dependencies = [
 "serde",
 "unicode-width 0.2.0",
@@ -1805,7 +1955,7 @@ dependencies = [
 "pep440_rs 0.4.0",
 "regex",
 "serde",
- "thiserror",
+ "thiserror 1.0.67",
 "tracing",
 "unicode-width 0.1.13",
 "url",
@@ -1824,7 +1974,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd53dff83f26735fdc1ca837098ccf133605d794cdae66acfc2bfac3ec809d95"
 dependencies = [
 "memchr",
- "thiserror",
+ "thiserror 1.0.67",
 "ucd-trie",
 ]

@@ -1848,7 +1998,7 @@ dependencies = [
 "pest_meta",
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -1994,7 +2144,7 @@ dependencies = [
 "newtype-uuid",
 "quick-xml",
 "strip-ansi-escapes",
- "thiserror",
+ "thiserror 1.0.67",
 "uuid",
 ]

@@ -2101,7 +2251,8 @@ dependencies = [
 "compact_str",
 "countme",
 "dir-test",
- "hashbrown 0.15.0",
+ "hashbrown 0.15.1",
+ "indexmap",
 "insta",
 "itertools 0.13.0",
 "memchr",
@@ -2122,7 +2273,7 @@ dependencies = [
 "static_assertions",
 "tempfile",
 "test-case",
- "thiserror",
+ "thiserror 2.0.3",
 "tracing",
 ]

@@ -2242,7 +2393,7 @@ checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
 dependencies = [
 "getrandom",
 "libredox",
- "thiserror",
+ "thiserror 1.0.67",
 ]

 [[package]]
@@ -2306,7 +2457,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.7.2"
+version = "0.7.3"
 dependencies = [
 "anyhow",
 "argfile",
@@ -2353,7 +2504,7 @@ dependencies = [
 "strum",
 "tempfile",
 "test-case",
- "thiserror",
+ "thiserror 2.0.3",
 "tikv-jemallocator",
 "toml",
 "tracing",
@@ -2421,7 +2572,7 @@ dependencies = [
 "salsa",
 "serde",
 "tempfile",
- "thiserror",
+ "thiserror 2.0.3",
 "tracing",
 "tracing-subscriber",
 "tracing-tree",
@@ -2523,7 +2674,7 @@ dependencies = [

 [[package]]
 name = "ruff_linter"
-version = "0.7.2"
+version = "0.7.3"
 dependencies = [
 "aho-corasick",
 "annotate-snippets 0.9.2",
@@ -2546,7 +2697,7 @@ dependencies = [
 "natord",
 "path-absolutize",
 "pathdiff",
- "pep440_rs 0.7.1",
+ "pep440_rs 0.7.2",
 "pyproject-toml",
 "quick-junit",
 "regex",
@@ -2573,7 +2724,7 @@ dependencies = [
 "strum",
 "strum_macros",
 "test-case",
- "thiserror",
+ "thiserror 2.0.3",
 "toml",
 "typed-arena",
 "unicode-normalization",
@@ -2590,7 +2741,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "ruff_python_trivia",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -2607,7 +2758,7 @@ dependencies = [
 "serde_json",
 "serde_with",
 "test-case",
- "thiserror",
+ "thiserror 2.0.3",
 "uuid",
 ]

@@ -2627,6 +2778,7 @@ dependencies = [
 "ruff_source_file",
 "ruff_text_size",
 "rustc-hash 2.0.0",
+ "salsa",
 "schemars",
 "serde",
 ]
@@ -2679,7 +2831,7 @@ dependencies = [
 "similar",
 "smallvec",
 "static_assertions",
- "thiserror",
+ "thiserror 2.0.3",
 "tracing",
 ]

@@ -2759,6 +2911,7 @@ dependencies = [
 name = "ruff_python_stdlib"
 version = "0.0.0"
 dependencies = [
+ "bitflags 2.6.0",
 "unicode-ident",
 ]

@@ -2811,7 +2964,7 @@ dependencies = [
 "serde",
 "serde_json",
 "shellexpand",
- "thiserror",
+ "thiserror 2.0.3",
 "tracing",
 "tracing-subscriber",
 ]
@@ -2837,7 +2990,7 @@ dependencies = [

 [[package]]
 name = "ruff_wasm"
-version = "0.7.2"
+version = "0.7.3"
 dependencies = [
 "console_error_panic_hook",
 "console_log",
@@ -2876,7 +3029,7 @@ dependencies = [
 "matchit",
 "path-absolutize",
 "path-slash",
- "pep440_rs 0.7.1",
+ "pep440_rs 0.7.2",
 "regex",
 "ruff_cache",
 "ruff_formatter",
@@ -2920,9 +3073,9 @@ checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152"

 [[package]]
 name = "rustix"
-version = "0.38.37"
+version = "0.38.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811"
+checksum = "99e4ea3e1cdc4b559b8e5650f9c8e5998e3e5c1343b4eaf034565f32318d63c0"
 dependencies = [
 "bitflags 2.6.0",
 "errno",
@@ -3008,7 +3161,7 @@ dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 "synstructure",
 ]

@@ -3042,7 +3195,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "serde_derive_internals",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -3065,9 +3218,9 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"

 [[package]]
 name = "serde"
-version = "1.0.213"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ea7893ff5e2466df8d720bb615088341b295f849602c6956047f8f80f0e9bc1"
+checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
 dependencies = [
 "serde_derive",
 ]
@@ -3085,13 +3238,13 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.213"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e85ad2009c50b58e87caa8cd6dac16bdf511bbfb7af6c33df902396aa480fa5"
+checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -3102,7 +3255,7 @@ checksum = "330f01ce65a3a5fe59a60c82f3c9a024b573b8a6e875bd233fe5f934e71d54e3"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -3125,7 +3278,7 @@ checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -3166,7 +3319,7 @@ dependencies = [
 "darling",
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -3222,6 +3375,12 @@ version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"

+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
@@ -3268,7 +3427,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "rustversion",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -3290,9 +3449,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.85"
+version = "2.0.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5023162dfcd14ef8f32034d8bcd4cc5ddc61ef7a247c024a33e24e1f24d21b56"
+checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -3307,14 +3466,14 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
 name = "tempfile"
-version = "3.13.0"
+version = "3.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b"
+checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c"
 dependencies = [
 "cfg-if",
 "fastrand",
@@ -3370,7 +3529,7 @@ dependencies = [
 "cfg-if",
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -3381,28 +3540,48 @@ checksum = "5c89e72a01ed4c579669add59014b9a524d609c0c88c6a585ce37485879f6ffb"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 "test-case-core",
 ]

 [[package]]
 name = "thiserror"
-version = "1.0.65"
+version = "1.0.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d11abd9594d9b38965ef50805c5e469ca9cc6f197f883f717e0269a3057b3d5"
+checksum = "3b3c6efbfc763e64eb85c11c25320f0737cb7364c4b6336db90aa9ebe27a0bbd"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 1.0.67",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c006c85c7651b3cf2ada4584faa36773bd07bac24acfb39f3c431b36d7e667aa"
+dependencies = [
+ "thiserror-impl 2.0.3",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "1.0.65"
+version = "1.0.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae71770322cbd277e69d762a16c444af02aa0575ac0d174f0b9562d3b37f8602"
+checksum = "b607164372e89797d78b8e23a6d67d5d1038c1c65efd52e1389ef8b77caba2a6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f077553d607adc1caf65430528a576c757a71ed73944b66ebb58ef2bbd243568"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -3435,6 +3614,16 @@ dependencies = [
 "tikv-jemalloc-sys",
 ]

+[[package]]
+name = "tinystr"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
 [[package]]
 name = "tinytemplate"
 version = "1.2.1"
@@ -3514,7 +3703,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -3651,12 +3840,6 @@ dependencies = [
 "unic-common",
 ]

-[[package]]
-name = "unicode-bidi"
-version = "0.3.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.13"
@@ -3736,9 +3919,9 @@ dependencies = [

 [[package]]
 name = "url"
-version = "2.5.2"
+version = "2.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
+checksum = "8d157f1b96d14500ffdc1f10ba712e780825526c03d9a49b4d0324b0d9113ada"
 dependencies = [
 "form_urlencoded",
 "idna",
@@ -3746,6 +3929,18 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "utf16_iter"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.1"
@@ -3772,7 +3967,7 @@ checksum = "6b91f57fe13a38d0ce9e28a03463d8d3c2468ed03d75375110ec71d93b449a08"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -3858,7 +4053,7 @@ dependencies = [
 "once_cell",
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 "wasm-bindgen-shared",
 ]

@@ -3892,7 +4087,7 @@ checksum = "26c6ab57572f7a24a4985830b120de1594465e5d500f24afe89e16b4e833ef68"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 "wasm-bindgen-backend",
 "wasm-bindgen-shared",
 ]
@@ -3926,7 +4121,7 @@ checksum = "c97b2ef2c8d627381e51c071c2ab328eac606d3f69dd82bcbca20a9e389d95f0"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
 ]

 [[package]]
@@ -4182,6 +4377,18 @@ version = "0.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"

+[[package]]
+name = "write16"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
+
+[[package]]
+name = "writeable"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
+
 [[package]]
 name = "yansi"
 version = "1.0.1"
@@ -4197,6 +4404,30 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "yoke"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c5b1314b079b0930c31e3af543d8ee1757b1951ae1e1565ec704403a7240ca5"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28cc31741b18cb6f1d5ff12f5b7523e3d6eb0852bbbad19d73905511d9849b95"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+ "synstructure",
+]
+
 [[package]]
 name = "zerocopy"
 version = "0.7.32"
@@ -4214,7 +4445,28 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.87",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91ec111ce797d0e0784a1116d0ddcdbea84322cd79e5d5ad173daeba4f93ab55"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ea7b4a3637ea8669cedf0f1fd5c286a17f3de97b8dd5a70a6c167a1730e63a5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+ "synstructure",
 ]

 [[package]]
@@ -4223,6 +4475,28 @@ version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d"

+[[package]]
+name = "zerovec"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
 [[package]]
 name = "zip"
 version = "0.6.6"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -81,6 +81,7 @@ hashbrown = { version = "0.15.0", default-features = false, features = [
 ignore = { version = "0.4.22" }
 imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
+indexmap = {version = "2.6.0" }
 indicatif = { version = "0.17.8" }
 indoc = { version = "2.0.4" }
 insta = { version = "1.35.1" }
@@ -101,7 +102,7 @@ matchit = { version = "0.8.1" }
 memchr = { version = "2.7.1" }
 mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
-notify = { version = "6.1.1" }
+notify = { version = "7.0.0" }
 ordermap = { version = "0.5.0" }
 path-absolutize = { version = "3.1.1" }
 path-slash = { version = "0.2.1" }
@@ -135,7 +136,7 @@ strum_macros = { version = "0.26.0" }
 syn = { version = "2.0.55" }
 tempfile = { version = "3.9.0" }
 test-case = { version = "3.3.1" }
-thiserror = { version = "1.0.58" }
+thiserror = { version = "2.0.0" }
 tikv-jemallocator = { version = "0.6.0" }
 toml = { version = "0.8.11" }
 tracing = { version = "0.1.40" }
--- a/README.md
+++ b/README.md
@@ -136,8 +136,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"

 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.7.2/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.7.2/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.7.3/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.7.3/install.ps1 | iex"
 ```

 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -170,7 +170,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
  # Ruff version.
-  rev: v0.7.2
+  rev: v0.7.3
  hooks:
    # Run the linter.
    - id: ruff
--- a/crates/red_knot/src/main.rs
+++ b/crates/red_knot/src/main.rs
@@ -5,8 +5,6 @@ use anyhow::{anyhow, Context};
 use clap::Parser;
 use colored::Colorize;
 use crossbeam::channel as crossbeam_channel;
-use salsa::plumbing::ZalsaDatabase;
-
 use red_knot_python_semantic::SitePackages;
 use red_knot_server::run_server;
 use red_knot_workspace::db::RootDatabase;
@@ -14,7 +12,9 @@ use red_knot_workspace::watch;
 use red_knot_workspace::watch::WorkspaceWatcher;
 use red_knot_workspace::workspace::settings::Configuration;
 use red_knot_workspace::workspace::WorkspaceMetadata;
+use ruff_db::diagnostic::Diagnostic;
 use ruff_db::system::{OsSystem, System, SystemPath, SystemPathBuf};
+use salsa::plumbing::ZalsaDatabase;
 use target_version::TargetVersion;

 use crate::logging::{setup_tracing, Verbosity};
@@ -318,8 +318,9 @@ impl MainLoop {
                } => {
                    let has_diagnostics = !result.is_empty();
                    if check_revision == revision {
+                        #[allow(clippy::print_stdout)]
                        for diagnostic in result {
-                            tracing::error!("{}", diagnostic);
+                            println!("{}", diagnostic.display(db));
                        }
                    } else {
                        tracing::debug!(
@@ -378,7 +379,10 @@ impl MainLoopCancellationToken {
 #[derive(Debug)]
 enum MainLoopMessage {
    CheckWorkspace,
-    CheckCompleted { result: Vec<String>, revision: u64 },
+    CheckCompleted {
+        result: Vec<Box<dyn Diagnostic>>,
+        revision: u64,
+    },
    ApplyChanges(Vec<watch::ChangeEvent>),
    Exit,
 }
--- a/crates/red_knot_python_semantic/Cargo.toml
+++ b/crates/red_knot_python_semantic/Cargo.toml
@@ -13,7 +13,7 @@ license = { workspace = true }
 [dependencies]
 ruff_db = { workspace = true }
 ruff_index = { workspace = true }
-ruff_python_ast = { workspace = true }
+ruff_python_ast = { workspace = true, features = ["salsa"] }
 ruff_python_stdlib = { workspace = true }
 ruff_source_file = { workspace = true }
 ruff_text_size = { workspace = true }
@@ -24,7 +24,8 @@ bitflags = { workspace = true }
 camino = { workspace = true }
 compact_str = { workspace = true }
 countme = { workspace = true }
-itertools = { workspace = true}
+indexmap = { workspace = true }
+itertools = { workspace = true }
 ordermap = { workspace = true }
 salsa = { workspace = true }
 thiserror = { workspace = true }
@@ -43,10 +44,9 @@ red_knot_test = { workspace = true }
 red_knot_vendored = { workspace = true }

 anyhow = { workspace = true }
-dir-test = {workspace = true}
+dir-test = { workspace = true }
 insta = { workspace = true }
 tempfile = { workspace = true }

 [lints]
 workspace = true
-
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/starred.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/starred.md
@@ -0,0 +1,18 @@
+# Starred expression annotations
+
+Type annotations for `*args` can be starred expressions themselves:
+
+```py
+from typing_extensions import TypeVarTuple
+
+Ts = TypeVarTuple("Ts")
+
+def append_int(*args: *Ts) -> tuple[*Ts, int]:
+    # TODO: should show some representation of the variadic generic type
+    reveal_type(args)  # revealed: @Todo
+
+    return (*args, 1)
+
+# TODO should be tuple[Literal[True], Literal["a"], int]
+reveal_type(append_int(True, "a"))  # revealed: @Todo
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/annotations/string.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/annotations/string.md
@@ -0,0 +1,9 @@
+# String annotations
+
+```py
+def f() -> "int":
+    return 1
+
+# TODO: We do not support string annotations, but we should not panic if we encounter them
+reveal_type(f())  # revealed: @Todo
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/assignment/augmented.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/assignment/augmented.md
@@ -85,7 +85,7 @@ f = Foo()
 # that `Foo.__iadd__` may be unbound as additional context.
 f += "Hello, world!"

-reveal_type(f)  # revealed: int
+reveal_type(f)  # revealed: int | Unknown
 ```

 ## Partially bound with `__add__`
@@ -104,8 +104,7 @@ class Foo:
 f = Foo()
 f += "Hello, world!"

-# TODO(charlie): This should be `int | str`, since `__iadd__` may be unbound.
-reveal_type(f)  # revealed: int
+reveal_type(f)  # revealed: int | str
 ```

 ## Partially bound target union
@@ -127,8 +126,7 @@ else:
    f = 42.0
 f += 12

-# TODO(charlie): This should be `str | int | float`
-reveal_type(f)  # revealed: @Todo
+reveal_type(f)  # revealed: int | str | float
 ```

 ## Target union
@@ -149,6 +147,36 @@ else:
    f = 42.0
 f += 12

-# TODO(charlie): This should be `str | float`.
-reveal_type(f)  # revealed: @Todo
+reveal_type(f)  # revealed: str | float
+```
+
+## Partially bound target union with `__add__`
+
+```py
+def bool_instance() -> bool:
+    return True
+
+flag = bool_instance()
+
+class Foo:
+    def __add__(self, other: int) -> str:
+        return "Hello, world!"
+    if bool_instance():
+        def __iadd__(self, other: int) -> int:
+            return 42
+
+class Bar:
+    def __add__(self, other: int) -> bytes:
+        return b"Hello, world!"
+
+    def __iadd__(self, other: int) -> float:
+        return 42.0
+
+if flag:
+    f = Foo()
+else:
+    f = Bar()
+f += 12
+
+reveal_type(f)  # revealed: int | str | float
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/assignment/unbound.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/assignment/unbound.md
@@ -35,6 +35,7 @@ class C:
    if flag:
        x = 2

+# error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C]` is possibly unbound"
 reveal_type(C.x)  # revealed: Literal[2]
 reveal_type(C.y)  # revealed: Literal[1]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/attributes.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/attributes.md
@@ -9,12 +9,128 @@ def bool_instance() -> bool:
 flag = bool_instance()

 if flag:
-    class C:
+    class C1:
        x = 1

 else:
-    class C:
+    class C1:
        x = 2

-reveal_type(C.x)  # revealed: Literal[1, 2]
+class C2:
+    if flag:
+        x = 3
+    else:
+        x = 4
+
+reveal_type(C1.x)  # revealed: Literal[1, 2]
+reveal_type(C2.x)  # revealed: Literal[3, 4]
+```
+
+## Inherited attributes
+
+```py
+class A:
+    X = "foo"
+
+class B(A): ...
+class C(B): ...
+
+reveal_type(C.X)  # revealed: Literal["foo"]
+```
+
+## Inherited attributes (multiple inheritance)
+
+```py
+class O: ...
+
+class F(O):
+    X = 56
+
+class E(O):
+    X = 42
+
+class D(O): ...
+class C(D, F): ...
+class B(E, D): ...
+class A(B, C): ...
+
+# revealed: tuple[Literal[A], Literal[B], Literal[E], Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
+reveal_type(A.__mro__)
+
+# `E` is earlier in the MRO than `F`, so we should use the type of `E.X`
+reveal_type(A.X)  # revealed: Literal[42]
+```
+
+## Unions with possibly unbound paths
+
+### Definite boundness within a class
+
+In this example, the `x` attribute is not defined in the `C2` element of the union:
+
+```py
+def bool_instance() -> bool:
+    return True
+
+class C1:
+    x = 1
+
+class C2: ...
+
+class C3:
+    x = 3
+
+flag1 = bool_instance()
+flag2 = bool_instance()
+
+C = C1 if flag1 else C2 if flag2 else C3
+
+# error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C1, C2, C3]` is possibly unbound"
+reveal_type(C.x)  # revealed: Literal[1, 3]
+```
+
+### Possibly-unbound within a class
+
+We raise the same diagnostic if the attribute is possibly-unbound in at least one element of the
+union:
+
+```py
+def bool_instance() -> bool:
+    return True
+
+class C1:
+    x = 1
+
+class C2:
+    if bool_instance():
+        x = 2
+
+class C3:
+    x = 3
+
+flag1 = bool_instance()
+flag2 = bool_instance()
+
+C = C1 if flag1 else C2 if flag2 else C3
+
+# error: [possibly-unbound-attribute] "Attribute `x` on type `Literal[C1, C2, C3]` is possibly unbound"
+reveal_type(C.x)  # revealed: Literal[1, 2, 3]
+```
+
+## Unions with all paths unbound
+
+If the symbol is unbound in all elements of the union, we detect that:
+
+```py
+def bool_instance() -> bool:
+    return True
+
+class C1: ...
+class C2: ...
+
+flag = bool_instance()
+
+C = C1 if flag else C2
+
+# error: [unresolved-attribute] "Type `Literal[C1, C2]` has no attribute `x`"
+reveal_type(C.x)  # revealed: Unknown
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/binary/instances.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/binary/instances.md
@@ -202,11 +202,7 @@ reveal_type(A() + B())  # revealed: MyString
 # N.B. Still a subtype of `A`, even though `A` does not appear directly in the class's `__bases__`
 class C(B): ...

-# TODO: we currently only understand direct subclasses as subtypes of the superclass.
-# We need to iterate through the full MRO rather than just the class's bases;
-# if we do, we'll understand `C` as a subtype of `A`, and correctly understand this as being
-# `MyString` rather than `str`
-reveal_type(A() + C())  # revealed: str
+reveal_type(A() + C())  # revealed: MyString
 ```

 ## Reflected precedence 2
--- a/crates/red_knot_python_semantic/resources/mdtest/call/callable_instance.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/callable_instance.md
@@ -18,3 +18,58 @@ class Unit: ...
 b = Unit()(3.0)  # error: "Object of type `Unit` is not callable"
 reveal_type(b)  # revealed: Unknown
 ```
+
+## Possibly unbound `__call__` method
+
+```py
+def flag() -> bool: ...
+
+class PossiblyNotCallable:
+    if flag():
+        def __call__(self) -> int: ...
+
+a = PossiblyNotCallable()
+result = a()  # error: "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
+reveal_type(result)  # revealed: int
+```
+
+## Possibly unbound callable
+
+```py
+def flag() -> bool: ...
+
+if flag():
+    class PossiblyUnbound:
+        def __call__(self) -> int: ...
+
+# error: [possibly-unresolved-reference]
+a = PossiblyUnbound()
+reveal_type(a())  # revealed: int
+```
+
+## Non-callable `__call__`
+
+```py
+class NonCallable:
+    __call__ = 1
+
+a = NonCallable()
+# error: "Object of type `NonCallable` is not callable"
+reveal_type(a())  # revealed: Unknown
+```
+
+## Possibly non-callable `__call__`
+
+```py
+def flag() -> bool: ...
+
+class NonCallable:
+    if flag():
+        __call__ = 1
+    else:
+        def __call__(self) -> int: ...
+
+a = NonCallable()
+# error: "Object of type `Literal[1] | Literal[__call__]` is not callable (due to union element `Literal[1]`)"
+reveal_type(a())  # revealed: Unknown | int
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/call/function.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/call/function.md
@@ -44,3 +44,16 @@ reveal_type(bar())  # revealed: @Todo
 nonsense = 123
 x = nonsense()  # error: "Object of type `Literal[123]` is not callable"
 ```
+
+## Potentially unbound function
+
+```py
+def flag() -> bool: ...
+
+if flag():
+    def foo() -> int:
+        return 42
+
+# error: [possibly-unresolved-reference]
+reveal_type(foo())  # revealed: int
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/identity.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/identity.md
@@ -0,0 +1,40 @@
+# Identity tests
+
+```py
+class A: ...
+
+def get_a() -> A: ...
+def get_object() -> object: ...
+
+a1 = get_a()
+a2 = get_a()
+
+n1 = None
+n2 = None
+
+o = get_object()
+
+reveal_type(a1 is a1)  # revealed: bool
+reveal_type(a1 is a2)  # revealed: bool
+
+reveal_type(n1 is n1)  # revealed: Literal[True]
+reveal_type(n1 is n2)  # revealed: Literal[True]
+
+reveal_type(a1 is n1)  # revealed: Literal[False]
+reveal_type(n1 is a1)  # revealed: Literal[False]
+
+reveal_type(a1 is o)  # revealed: bool
+reveal_type(n1 is o)  # revealed: bool
+
+reveal_type(a1 is not a1)  # revealed: bool
+reveal_type(a1 is not a2)  # revealed: bool
+
+reveal_type(n1 is not n1)  # revealed: Literal[False]
+reveal_type(n1 is not n2)  # revealed: Literal[False]
+
+reveal_type(a1 is not n1)  # revealed: Literal[True]
+reveal_type(n1 is not a1)  # revealed: Literal[True]
+
+reveal_type(a1 is not o)  # revealed: bool
+reveal_type(n1 is not o)  # revealed: bool
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/instances/membership_test.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/instances/membership_test.md
@@ -93,13 +93,11 @@ class AlwaysFalse:
    def __contains__(self, item: int) -> Literal[""]:
        return ""

-# TODO: it should be Literal[True] and Literal[False]
-reveal_type(42 in AlwaysTrue())  # revealed: @Todo
-reveal_type(42 not in AlwaysTrue())  # revealed: @Todo
+reveal_type(42 in AlwaysTrue())  # revealed: Literal[True]
+reveal_type(42 not in AlwaysTrue())  # revealed: Literal[False]

-# TODO: it should be Literal[False] and Literal[True]
-reveal_type(42 in AlwaysFalse())  # revealed: @Todo
-reveal_type(42 not in AlwaysFalse())  # revealed: @Todo
+reveal_type(42 in AlwaysFalse())  # revealed: Literal[False]
+reveal_type(42 not in AlwaysFalse())  # revealed: Literal[True]
 ```

 ## No Fallback for `__contains__`
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/intersections.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/intersections.md
@@ -0,0 +1,155 @@
+# Comparison: Intersections
+
+## Positive contributions
+
+If we have an intersection type `A & B` and we get a definitive true/false answer for one of the
+types, we can infer that the result for the intersection type is also true/false:
+
+```py
+class Base: ...
+
+class Child1(Base):
+    def __eq__(self, other) -> Literal[True]:
+        return True
+
+class Child2(Base): ...
+
+def get_base() -> Base: ...
+
+x = get_base()
+c1 = Child1()
+
+# Create an intersection type through narrowing:
+if isinstance(x, Child1):
+    if isinstance(x, Child2):
+        reveal_type(x)  # revealed: Child1 & Child2
+
+        reveal_type(x == 1)  # revealed: Literal[True]
+
+        # Other comparison operators fall back to the base type:
+        reveal_type(x > 1)  # revealed: bool
+        reveal_type(x is c1)  # revealed: bool
+```
+
+## Negative contributions
+
+Negative contributions to the intersection type only allow simplifications in a few special cases
+(equality and identity comparisons).
+
+### Equality comparisons
+
+#### Literal strings
+
+```py
+x = "x" * 1_000_000_000
+y = "y" * 1_000_000_000
+reveal_type(x)  # revealed: LiteralString
+
+if x != "abc":
+    reveal_type(x)  # revealed: LiteralString & ~Literal["abc"]
+
+    reveal_type(x == "abc")  # revealed: Literal[False]
+    reveal_type("abc" == x)  # revealed: Literal[False]
+    reveal_type(x == "something else")  # revealed: bool
+    reveal_type("something else" == x)  # revealed: bool
+
+    reveal_type(x != "abc")  # revealed: Literal[True]
+    reveal_type("abc" != x)  # revealed: Literal[True]
+    reveal_type(x != "something else")  # revealed: bool
+    reveal_type("something else" != x)  # revealed: bool
+
+    reveal_type(x == y)  # revealed: bool
+    reveal_type(y == x)  # revealed: bool
+    reveal_type(x != y)  # revealed: bool
+    reveal_type(y != x)  # revealed: bool
+
+    reveal_type(x >= "abc")  # revealed: bool
+    reveal_type("abc" >= x)  # revealed: bool
+
+    reveal_type(x in "abc")  # revealed: bool
+    reveal_type("abc" in x)  # revealed: bool
+```
+
+#### Integers
+
+```py
+def get_int() -> int: ...
+
+x = get_int()
+
+if x != 1:
+    reveal_type(x)  # revealed: int & ~Literal[1]
+
+    reveal_type(x != 1)  # revealed: Literal[True]
+    reveal_type(x != 2)  # revealed: bool
+
+    reveal_type(x == 1)  # revealed: Literal[False]
+    reveal_type(x == 2)  # revealed: bool
+```
+
+### Identity comparisons
+
+```py
+class A: ...
+
+def get_object() -> object: ...
+
+o = object()
+
+a = A()
+n = None
+
+if o is not None:
+    reveal_type(o)  # revealed: object & ~None
+
+    reveal_type(o is n)  # revealed: Literal[False]
+    reveal_type(o is not n)  # revealed: Literal[True]
+```
+
+## Diagnostics
+
+### Unsupported operators for positive contributions
+
+Raise an error if any of the positive contributions to the intersection type are unsupported for the
+given operator:
+
+```py
+class Container:
+    def __contains__(self, x) -> bool: ...
+
+class NonContainer: ...
+
+def get_object() -> object: ...
+
+x = get_object()
+
+if isinstance(x, Container):
+    if isinstance(x, NonContainer):
+        reveal_type(x)  # revealed: Container & NonContainer
+
+        # error: [unsupported-operator] "Operator `in` is not supported for types `int` and `NonContainer`"
+        reveal_type(2 in x)  # revealed: bool
+```
+
+### Unsupported operators for negative contributions
+
+Do *not* raise an error if any of the negative contributions to the intersection type are
+unsupported for the given operator:
+
+```py
+class Container:
+    def __contains__(self, x) -> bool: ...
+
+class NonContainer: ...
+
+def get_object() -> object: ...
+
+x = get_object()
+
+if isinstance(x, Container):
+    if not isinstance(x, NonContainer):
+        reveal_type(x)  # revealed: Container & ~NonContainer
+
+        # No error here!
+        reveal_type(2 in x)  # revealed: bool
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/comparison/non_boolean_returns.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/comparison/non_boolean_returns.md
--- a/crates/red_knot_python_semantic/resources/mdtest/exception/invalid_syntax.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/exception/invalid_syntax.md
@@ -0,0 +1,13 @@
+# Exception Handling
+
+## Invalid syntax
+
+```py
+from typing_extensions import reveal_type
+
+try:
+    print
+except as e:  # error: [invalid-syntax]
+    reveal_type(e)  # revealed: Unknown
+
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/expression/attribute.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/expression/attribute.md
@@ -0,0 +1,28 @@
+# Attribute access
+
+## Boundness
+
+```py
+def flag() -> bool: ...
+
+class A:
+    always_bound = 1
+
+    if flag():
+        union = 1
+    else:
+        union = "abc"
+
+    if flag():
+        possibly_unbound = "abc"
+
+reveal_type(A.always_bound)  # revealed: Literal[1]
+
+reveal_type(A.union)  # revealed: Literal[1] | Literal["abc"]
+
+# error: [possibly-unbound-attribute] "Attribute `possibly_unbound` on type `Literal[A]` is possibly unbound"
+reveal_type(A.possibly_unbound)  # revealed: Literal["abc"]
+
+# error: [unresolved-attribute] "Type `Literal[A]` has no attribute `non_existent`"
+reveal_type(A.non_existent)  # revealed: Unknown
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/expression/if.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/expression/if.md
@@ -0,0 +1,24 @@
+# If expression
+
+## Union
+
+```py
+def bool_instance() -> bool:
+    return True
+
+reveal_type(1 if bool_instance() else 2)  # revealed: Literal[1, 2]
+```
+
+## Statically known branches
+
+```py
+reveal_type(1 if True else 2)  # revealed: Literal[1]
+reveal_type(1 if "not empty" else 2)  # revealed: Literal[1]
+reveal_type(1 if (1,) else 2)  # revealed: Literal[1]
+reveal_type(1 if 1 else 2)  # revealed: Literal[1]
+
+reveal_type(1 if False else 2)  # revealed: Literal[2]
+reveal_type(1 if None else 2)  # revealed: Literal[2]
+reveal_type(1 if "" else 2)  # revealed: Literal[2]
+reveal_type(1 if 0 else 2)  # revealed: Literal[2]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/generics.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/generics.md
@@ -6,13 +6,9 @@ Basic PEP 695 generics

 ```py
 class MyBox[T]:
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
    data: T
    box_model_number = 695

-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
    def __init__(self, data: T):
        self.data = data

@@ -31,17 +27,12 @@ reveal_type(MyBox.box_model_number)  # revealed: Literal[695]

 ```py
 class MyBox[T]:
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
    data: T

-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
    def __init__(self, data: T):
        self.data = data

-# TODO not error on the subscripting or the use of type param
-# error: [unresolved-reference] "Name `T` used when not defined"
+# TODO not error on the subscripting
 # error: [non-subscriptable]
 class MySecureBox[T](MyBox[T]): ...

@@ -66,3 +57,55 @@ class S[T](Seq[S]): ...  # error: [non-subscriptable]

 reveal_type(S)  # revealed: Literal[S]
 ```
+
+## Type params
+
+A PEP695 type variable defines a value of type `typing.TypeVar` with attributes `__name__`,
+`__bounds__`, `__constraints__`, and `__default__` (the latter three all lazily evaluated):
+
+```py
+def f[T, U: A, V: (A, B), W = A, X: A = A1]():
+    reveal_type(T)  # revealed: TypeVar
+    reveal_type(T.__name__)  # revealed: Literal["T"]
+    reveal_type(T.__bound__)  # revealed: None
+    reveal_type(T.__constraints__)  # revealed: tuple[()]
+    reveal_type(T.__default__)  # revealed: NoDefault
+
+    reveal_type(U)  # revealed: TypeVar
+    reveal_type(U.__name__)  # revealed: Literal["U"]
+    reveal_type(U.__bound__)  # revealed: type[A]
+    reveal_type(U.__constraints__)  # revealed: tuple[()]
+    reveal_type(U.__default__)  # revealed: NoDefault
+
+    reveal_type(V)  # revealed: TypeVar
+    reveal_type(V.__name__)  # revealed: Literal["V"]
+    reveal_type(V.__bound__)  # revealed: None
+    reveal_type(V.__constraints__)  # revealed: tuple[type[A], type[B]]
+    reveal_type(V.__default__)  # revealed: NoDefault
+
+    reveal_type(W)  # revealed: TypeVar
+    reveal_type(W.__name__)  # revealed: Literal["W"]
+    reveal_type(W.__bound__)  # revealed: None
+    reveal_type(W.__constraints__)  # revealed: tuple[()]
+    reveal_type(W.__default__)  # revealed: type[A]
+
+    reveal_type(X)  # revealed: TypeVar
+    reveal_type(X.__name__)  # revealed: Literal["X"]
+    reveal_type(X.__bound__)  # revealed: type[A]
+    reveal_type(X.__constraints__)  # revealed: tuple[()]
+    reveal_type(X.__default__)  # revealed: type[A1]
+
+class A: ...
+class B: ...
+class A1(A): ...
+```
+
+## Minimum two constraints
+
+A typevar with less than two constraints emits a diagnostic and is treated as unconstrained:
+
+```py
+# error: [invalid-typevar-constraints] "TypeVar must have at least two constrained types"
+def f[T: (int,)]():
+    reveal_type(T.__constraints__)  # revealed: tuple[()]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/import/conditional.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/import/conditional.md
@@ -21,6 +21,7 @@ reveal_type(y)
 ```

 ```py
+# error: [possibly-unbound-import] "Member `y` of module `maybe_unbound` is possibly unbound"
 from maybe_unbound import x, y

 reveal_type(x)  # revealed: Literal[3]
@@ -50,6 +51,7 @@ reveal_type(y)
 Importing an annotated name prefers the declared type over the inferred type:

 ```py
+# error: [possibly-unbound-import] "Member `y` of module `maybe_unbound_annotated` is possibly unbound"
 from maybe_unbound_annotated import x, y

 reveal_type(x)  # revealed: Literal[3]
--- a/crates/red_knot_python_semantic/resources/mdtest/literal/literal.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/literal/literal.md
@@ -0,0 +1,91 @@
+# Literal
+
+<https://typing.readthedocs.io/en/latest/spec/literal.html#literals>
+
+## Parameterization
+
+```py
+from typing import Literal
+from enum import Enum
+
+mode: Literal["w", "r"]
+mode2: Literal["w"] | Literal["r"]
+union_var: Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]
+a1: Literal[26]
+a2: Literal[0x1A]
+a3: Literal[-4]
+a4: Literal["hello world"]
+a5: Literal[b"hello world"]
+a6: Literal[True]
+a7: Literal[None]
+a8: Literal[Literal[1]]
+a9: Literal[Literal["w"], Literal["r"], Literal[Literal["w+"]]]
+
+class Color(Enum):
+    RED = 0
+    GREEN = 1
+    BLUE = 2
+
+b1: Literal[Color.RED]
+
+def f():
+    reveal_type(mode)  # revealed: Literal["w", "r"]
+    reveal_type(mode2)  # revealed: Literal["w", "r"]
+    # TODO: should be revealed: Literal[1, 2, 3, "foo", 5] | None
+    reveal_type(union_var)  # revealed: Literal[1, 2, 3, 5] | Literal["foo"] | None
+    reveal_type(a1)  # revealed: Literal[26]
+    reveal_type(a2)  # revealed: Literal[26]
+    reveal_type(a3)  # revealed: Literal[-4]
+    reveal_type(a4)  # revealed: Literal["hello world"]
+    reveal_type(a5)  # revealed: Literal[b"hello world"]
+    reveal_type(a6)  # revealed: Literal[True]
+    reveal_type(a7)  # revealed: None
+    reveal_type(a8)  # revealed: Literal[1]
+    reveal_type(a9)  # revealed: Literal["w", "r", "w+"]
+    # TODO: This should be Color.RED
+    reveal_type(b1)  # revealed: Literal[0]
+
+# error: [invalid-literal-parameter]
+invalid1: Literal[3 + 4]
+# error: [invalid-literal-parameter]
+invalid2: Literal[4 + 3j]
+# error: [invalid-literal-parameter]
+invalid3: Literal[(3, 4)]
+invalid4: Literal[
+    1 + 2,  # error: [invalid-literal-parameter]
+    "foo",
+    hello,  # error: [invalid-literal-parameter]
+    (1, 2, 3),  # error: [invalid-literal-parameter]
+]
+```
+
+## Detecting Literal outside typing and typing_extensions
+
+Only Literal that is defined in typing and typing_extension modules is detected as the special
+Literal.
+
+```pyi path=other.pyi
+from typing import _SpecialForm
+
+Literal: _SpecialForm
+```
+
+```py
+from other import Literal
+
+a1: Literal[26]
+
+def f():
+    reveal_type(a1)  # revealed: @Todo
+```
+
+## Detecting typing_extensions.Literal
+
+```py
+from typing_extensions import Literal
+
+a1: Literal[26]
+
+def f():
+    reveal_type(a1)  # revealed: Literal[26]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/loops/async_for_loops.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/loops/async_for_loops.md
--- a/crates/red_knot_python_semantic/resources/mdtest/loops/for_loop.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/loops/for_loop.md
@@ -238,7 +238,7 @@ class Test:
 def coinflip() -> bool:
    return True

-# TODO: we should emit a diagnostic here (it might not be iterable)
+# error: [not-iterable] "Object of type `Test | Literal[42]` is not iterable because its `__iter__` method is possibly unbound"
 for x in Test() if coinflip() else 42:
    reveal_type(x)  # revealed: int
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/metaclass.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/metaclass.md
@@ -0,0 +1,196 @@
+## Default
+
+```py
+class M(type): ...
+
+reveal_type(M.__class__)  # revealed: Literal[type]
+```
+
+## `object`
+
+```py
+reveal_type(object.__class__)  # revealed: Literal[type]
+```
+
+## `type`
+
+```py
+reveal_type(type.__class__)  # revealed: Literal[type]
+```
+
+## Basic
+
+```py
+class M(type): ...
+class B(metaclass=M): ...
+
+reveal_type(B.__class__)  # revealed: Literal[M]
+```
+
+## Invalid metaclass
+
+A class which doesn't inherit `type` (and/or doesn't implement a custom `__new__` accepting the same
+arguments as `type.__new__`) isn't a valid metaclass.
+
+```py
+class M: ...
+class A(metaclass=M): ...
+
+# TODO: emit a diagnostic for the invalid metaclass
+reveal_type(A.__class__)  # revealed: Literal[M]
+```
+
+## Linear inheritance
+
+If a class is a subclass of a class with a custom metaclass, then the subclass will also have that
+metaclass.
+
+```py
+class M(type): ...
+class A(metaclass=M): ...
+class B(A): ...
+
+reveal_type(B.__class__)  # revealed: Literal[M]
+```
+
+## Conflict (1)
+
+The metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its
+bases. ("Strict subclass" is a synonym for "proper subclass"; a non-strict subclass can be a
+subclass or the class itself.)
+
+```py
+class M1(type): ...
+class M2(type): ...
+class A(metaclass=M1): ...
+class B(metaclass=M2): ...
+
+# error: [conflicting-metaclass] "The metaclass of a derived class (`C`) must be a subclass of the metaclasses of all its bases, but `M1` (metaclass of base class `A`) and `M2` (metaclass of base class `B`) have no subclass relationship"
+class C(A, B): ...
+
+reveal_type(C.__class__)  # revealed: Unknown
+```
+
+## Conflict (2)
+
+The metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its
+bases. ("Strict subclass" is a synonym for "proper subclass"; a non-strict subclass can be a
+subclass or the class itself.)
+
+```py
+class M1(type): ...
+class M2(type): ...
+class A(metaclass=M1): ...
+
+# error: [conflicting-metaclass] "The metaclass of a derived class (`B`) must be a subclass of the metaclasses of all its bases, but `M2` (metaclass of `B`) and `M1` (metaclass of base class `A`) have no subclass relationship"
+class B(A, metaclass=M2): ...
+
+reveal_type(B.__class__)  # revealed: Unknown
+```
+
+## Common metaclass
+
+A class has two explicit bases, both of which have the same metaclass.
+
+```py
+class M(type): ...
+class A(metaclass=M): ...
+class B(metaclass=M): ...
+class C(A, B): ...
+
+reveal_type(C.__class__)  # revealed: Literal[M]
+```
+
+## Metaclass metaclass
+
+A class has an explicit base with a custom metaclass. That metaclass itself has a custom metaclass.
+
+```py
+class M1(type): ...
+class M2(type, metaclass=M1): ...
+class M3(M2): ...
+class A(metaclass=M3): ...
+class B(A): ...
+
+reveal_type(A.__class__)  # revealed: Literal[M3]
+```
+
+## Diamond inheritance
+
+```py
+class M(type): ...
+class M1(M): ...
+class M2(M): ...
+class M12(M1, M2): ...
+class A(metaclass=M1): ...
+class B(metaclass=M2): ...
+class C(metaclass=M12): ...
+
+# error: [conflicting-metaclass] "The metaclass of a derived class (`D`) must be a subclass of the metaclasses of all its bases, but `M1` (metaclass of base class `A`) and `M2` (metaclass of base class `B`) have no subclass relationship"
+class D(A, B, C): ...
+
+reveal_type(D.__class__)  # revealed: Unknown
+```
+
+## Unknown
+
+```py
+from nonexistent_module import UnknownClass  # error: [unresolved-import]
+
+class C(UnknownClass): ...
+
+# TODO: should be `type[type] & Unknown`
+reveal_type(C.__class__)  # revealed: Literal[type]
+
+class M(type): ...
+class A(metaclass=M): ...
+class B(A, UnknownClass): ...
+
+# TODO: should be `type[M] & Unknown`
+reveal_type(B.__class__)  # revealed: Literal[M]
+```
+
+## Duplicate
+
+```py
+class M(type): ...
+class A(metaclass=M): ...
+class B(A, A): ...  # error: [duplicate-base] "Duplicate base class `A`"
+
+reveal_type(B.__class__)  # revealed: Literal[M]
+```
+
+## Non-class
+
+When a class has an explicit `metaclass` that is not a class, but is a callable that accepts
+`type.__new__` arguments, we should return the meta type of its return type.
+
+```py
+def f(*args, **kwargs) -> int: ...
+
+class A(metaclass=f): ...
+
+# TODO should be `type[int]`
+reveal_type(A.__class__)  # revealed: @Todo
+```
+
+## Cyclic
+
+Retrieving the metaclass of a cyclically defined class should not cause an infinite loop.
+
+```py path=a.pyi
+class A(B): ...  # error: [cyclic-class-def]
+class B(C): ...  # error: [cyclic-class-def]
+class C(A): ...  # error: [cyclic-class-def]
+
+reveal_type(A.__class__)  # revealed: Unknown
+```
+
+## PEP 695 generic
+
+```py
+class M(type): ...
+class A[T: str](metaclass=M): ...
+
+reveal_type(A.__class__)  # revealed: Literal[M]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/mro.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/mro.md
@@ -0,0 +1,409 @@
+# Method Resolution Order tests
+
+Tests that assert that we can infer the correct type for a class's `__mro__` attribute.
+
+This attribute is rarely accessed directly at runtime. However, it's extremely important for *us* to
+know the precise possible values of a class's Method Resolution Order, or we won't be able to infer
+the correct type of attributes accessed from instances.
+
+For documentation on method resolution orders, see:
+
+- <https://docs.python.org/3/glossary.html#term-method-resolution-order>
+- <https://docs.python.org/3/howto/mro.html#python-2-3-mro>
+
+## No bases
+
+```py
+class C: ...
+
+reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[object]]
+```
+
+## The special case: `object` itself
+
+```py
+reveal_type(object.__mro__)  # revealed: tuple[Literal[object]]
+```
+
+## Explicit inheritance from `object`
+
+```py
+class C(object): ...
+
+reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[object]]
+```
+
+## Explicit inheritance from non-`object` single base
+
+```py
+class A: ...
+class B(A): ...
+
+reveal_type(B.__mro__)  # revealed: tuple[Literal[B], Literal[A], Literal[object]]
+```
+
+## Linearization of multiple bases
+
+```py
+class A: ...
+class B: ...
+class C(A, B): ...
+
+reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[A], Literal[B], Literal[object]]
+```
+
+## Complex diamond inheritance (1)
+
+This is "ex_2" from <https://docs.python.org/3/howto/mro.html#the-end>
+
+```py
+class O: ...
+class X(O): ...
+class Y(O): ...
+class A(X, Y): ...
+class B(Y, X): ...
+
+reveal_type(A.__mro__)  # revealed: tuple[Literal[A], Literal[X], Literal[Y], Literal[O], Literal[object]]
+reveal_type(B.__mro__)  # revealed: tuple[Literal[B], Literal[Y], Literal[X], Literal[O], Literal[object]]
+```
+
+## Complex diamond inheritance (2)
+
+This is "ex_5" from <https://docs.python.org/3/howto/mro.html#the-end>
+
+```py
+class O: ...
+class F(O): ...
+class E(O): ...
+class D(O): ...
+class C(D, F): ...
+class B(D, E): ...
+class A(B, C): ...
+
+# revealed: tuple[Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
+reveal_type(C.__mro__)
+# revealed: tuple[Literal[B], Literal[D], Literal[E], Literal[O], Literal[object]]
+reveal_type(B.__mro__)
+# revealed: tuple[Literal[A], Literal[B], Literal[C], Literal[D], Literal[E], Literal[F], Literal[O], Literal[object]]
+reveal_type(A.__mro__)
+```
+
+## Complex diamond inheritance (3)
+
+This is "ex_6" from <https://docs.python.org/3/howto/mro.html#the-end>
+
+```py
+class O: ...
+class F(O): ...
+class E(O): ...
+class D(O): ...
+class C(D, F): ...
+class B(E, D): ...
+class A(B, C): ...
+
+# revealed: tuple[Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
+reveal_type(C.__mro__)
+# revealed: tuple[Literal[B], Literal[E], Literal[D], Literal[O], Literal[object]]
+reveal_type(B.__mro__)
+# revealed: tuple[Literal[A], Literal[B], Literal[E], Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
+reveal_type(A.__mro__)
+```
+
+## Complex diamond inheritance (4)
+
+This is "ex_9" from <https://docs.python.org/3/howto/mro.html#the-end>
+
+```py
+class O: ...
+class A(O): ...
+class B(O): ...
+class C(O): ...
+class D(O): ...
+class E(O): ...
+class K1(A, B, C): ...
+class K2(D, B, E): ...
+class K3(D, A): ...
+class Z(K1, K2, K3): ...
+
+# revealed: tuple[Literal[K1], Literal[A], Literal[B], Literal[C], Literal[O], Literal[object]]
+reveal_type(K1.__mro__)
+# revealed: tuple[Literal[K2], Literal[D], Literal[B], Literal[E], Literal[O], Literal[object]]
+reveal_type(K2.__mro__)
+# revealed: tuple[Literal[K3], Literal[D], Literal[A], Literal[O], Literal[object]]
+reveal_type(K3.__mro__)
+# revealed: tuple[Literal[Z], Literal[K1], Literal[K2], Literal[K3], Literal[D], Literal[A], Literal[B], Literal[C], Literal[E], Literal[O], Literal[object]]
+reveal_type(Z.__mro__)
+```
+
+## Inheritance from `Unknown`
+
+```py
+from does_not_exist import DoesNotExist  # error: [unresolved-import]
+
+class A(DoesNotExist): ...
+class B: ...
+class C: ...
+class D(A, B, C): ...
+class E(B, C): ...
+class F(E, A): ...
+
+reveal_type(A.__mro__)  # revealed: tuple[Literal[A], Unknown, Literal[object]]
+reveal_type(D.__mro__)  # revealed: tuple[Literal[D], Literal[A], Unknown, Literal[B], Literal[C], Literal[object]]
+reveal_type(E.__mro__)  # revealed: tuple[Literal[E], Literal[B], Literal[C], Literal[object]]
+reveal_type(F.__mro__)  # revealed: tuple[Literal[F], Literal[E], Literal[B], Literal[C], Literal[A], Unknown, Literal[object]]
+```
+
+## `__bases__` lists that cause errors at runtime
+
+If the class's `__bases__` cause an exception to be raised at runtime and therefore the class
+creation to fail, we infer the class's `__mro__` as being `[<class>, Unknown, object]`:
+
+```py
+# error: [inconsistent-mro] "Cannot create a consistent method resolution order (MRO) for class `Foo` with bases list `[<class 'object'>, <class 'int'>]`"
+class Foo(object, int): ...
+
+reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
+
+class Bar(Foo): ...
+
+reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Literal[Foo], Unknown, Literal[object]]
+
+# This is the `TypeError` at the bottom of "ex_2"
+# in the examples at <https://docs.python.org/3/howto/mro.html#the-end>
+class O: ...
+class X(O): ...
+class Y(O): ...
+class A(X, Y): ...
+class B(Y, X): ...
+
+reveal_type(A.__mro__)  # revealed: tuple[Literal[A], Literal[X], Literal[Y], Literal[O], Literal[object]]
+reveal_type(B.__mro__)  # revealed: tuple[Literal[B], Literal[Y], Literal[X], Literal[O], Literal[object]]
+
+# error: [inconsistent-mro] "Cannot create a consistent method resolution order (MRO) for class `Z` with bases list `[<class 'A'>, <class 'B'>]`"
+class Z(A, B): ...
+
+reveal_type(Z.__mro__)  # revealed: tuple[Literal[Z], Unknown, Literal[object]]
+
+class AA(Z): ...
+
+reveal_type(AA.__mro__)  # revealed: tuple[Literal[AA], Literal[Z], Unknown, Literal[object]]
+```
+
+## `__bases__` includes a `Union`
+
+We don't support union types in a class's bases; a base must resolve to a single `ClassLiteralType`.
+If we find a union type in a class's bases, we infer the class's `__mro__` as being
+`[<class>, Unknown, object]`, the same as for MROs that cause errors at runtime.
+
+```py
+def returns_bool() -> bool:
+    return True
+
+class A: ...
+class B: ...
+
+if returns_bool():
+    x = A
+else:
+    x = B
+
+reveal_type(x)  # revealed: Literal[A, B]
+
+# error: 11 [invalid-base] "Invalid class base with type `Literal[A, B]` (all bases must be a class, `Any`, `Unknown` or `Todo`)"
+class Foo(x): ...
+
+reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
+```
+
+## `__bases__` includes multiple `Union`s
+
+```py
+def returns_bool() -> bool:
+    return True
+
+class A: ...
+class B: ...
+class C: ...
+class D: ...
+
+if returns_bool():
+    x = A
+else:
+    x = B
+
+if returns_bool():
+    y = C
+else:
+    y = D
+
+reveal_type(x)  # revealed: Literal[A, B]
+reveal_type(y)  # revealed: Literal[C, D]
+
+# error: 11 [invalid-base] "Invalid class base with type `Literal[A, B]` (all bases must be a class, `Any`, `Unknown` or `Todo`)"
+# error: 14 [invalid-base] "Invalid class base with type `Literal[C, D]` (all bases must be a class, `Any`, `Unknown` or `Todo`)"
+class Foo(x, y): ...
+
+reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
+```
+
+## `__bases__` lists that cause errors... now with `Union`s
+
+```py
+def returns_bool() -> bool:
+    return True
+
+class O: ...
+class X(O): ...
+class Y(O): ...
+
+if bool():
+    foo = Y
+else:
+    foo = object
+
+# error: 21 [invalid-base] "Invalid class base with type `Literal[Y, object]` (all bases must be a class, `Any`, `Unknown` or `Todo`)"
+class PossibleError(foo, X): ...
+
+reveal_type(PossibleError.__mro__)  # revealed: tuple[Literal[PossibleError], Unknown, Literal[object]]
+
+class A(X, Y): ...
+
+reveal_type(A.__mro__)  # revealed: tuple[Literal[A], Literal[X], Literal[Y], Literal[O], Literal[object]]
+
+if returns_bool():
+    class B(X, Y): ...
+
+else:
+    class B(Y, X): ...
+
+# revealed: tuple[Literal[B], Literal[X], Literal[Y], Literal[O], Literal[object]] | tuple[Literal[B], Literal[Y], Literal[X], Literal[O], Literal[object]]
+reveal_type(B.__mro__)
+
+# error: 12 [invalid-base] "Invalid class base with type `Literal[B, B]` (all bases must be a class, `Any`, `Unknown` or `Todo`)"
+class Z(A, B): ...
+
+reveal_type(Z.__mro__)  # revealed: tuple[Literal[Z], Unknown, Literal[object]]
+```
+
+## `__bases__` lists with duplicate bases
+
+```py
+class Foo(str, str): ...  # error: 16 [duplicate-base] "Duplicate base class `str`"
+
+reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
+
+class Spam: ...
+class Eggs: ...
+class Ham(
+    Spam,
+    Eggs,
+    Spam,  # error: [duplicate-base] "Duplicate base class `Spam`"
+    Eggs,  # error: [duplicate-base] "Duplicate base class `Eggs`"
+): ...
+
+reveal_type(Ham.__mro__)  # revealed: tuple[Literal[Ham], Unknown, Literal[object]]
+
+class Mushrooms: ...
+class Omelette(Spam, Eggs, Mushrooms, Mushrooms): ...  # error: [duplicate-base]
+
+reveal_type(Omelette.__mro__)  # revealed: tuple[Literal[Omelette], Unknown, Literal[object]]
+```
+
+## `__bases__` lists with duplicate `Unknown` bases
+
+```py
+# error: [unresolved-import]
+# error: [unresolved-import]
+from does_not_exist import unknown_object_1, unknown_object_2
+
+reveal_type(unknown_object_1)  # revealed: Unknown
+reveal_type(unknown_object_2)  # revealed: Unknown
+
+# We *should* emit an error here to warn the user that we have no idea
+# what the MRO of this class should really be.
+# However, we don't complain about "duplicate base classes" here,
+# even though two classes are both inferred as being `Unknown`.
+#
+# (TODO: should we revisit this? Does it violate the gradual guarantee?
+# Should we just silently infer `[Foo, Unknown, object]` as the MRO here
+# without emitting any error at all? Not sure...)
+#
+# error: [inconsistent-mro] "Cannot create a consistent method resolution order (MRO) for class `Foo` with bases list `[Unknown, Unknown]`"
+class Foo(unknown_object_1, unknown_object_2): ...
+
+reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
+```
+
+## Unrelated objects inferred as `Any`/`Unknown` do not have special `__mro__` attributes
+
+```py
+from does_not_exist import unknown_object  # error: [unresolved-import]
+
+reveal_type(unknown_object)  # revealed: Unknown
+reveal_type(unknown_object.__mro__)  # revealed: Unknown
+```
+
+## Classes that inherit from themselves
+
+These are invalid, but we need to be able to handle them gracefully without panicking.
+
+```py path=a.pyi
+class Foo(Foo): ...  # error: [cyclic-class-def]
+
+reveal_type(Foo)  # revealed: Literal[Foo]
+reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
+
+class Bar: ...
+class Baz: ...
+class Boz(Bar, Baz, Boz): ...  # error: [cyclic-class-def]
+
+reveal_type(Boz)  # revealed: Literal[Boz]
+reveal_type(Boz.__mro__)  # revealed: tuple[Literal[Boz], Unknown, Literal[object]]
+```
+
+## Classes with indirect cycles in their MROs
+
+These are similarly unlikely, but we still shouldn't crash:
+
+```py path=a.pyi
+class Foo(Bar): ...  # error: [cyclic-class-def]
+class Bar(Baz): ...  # error: [cyclic-class-def]
+class Baz(Foo): ...  # error: [cyclic-class-def]
+
+reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
+reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Unknown, Literal[object]]
+reveal_type(Baz.__mro__)  # revealed: tuple[Literal[Baz], Unknown, Literal[object]]
+```
+
+## Classes with cycles in their MROs, and multiple inheritance
+
+```py path=a.pyi
+class Spam: ...
+class Foo(Bar): ...  # error: [cyclic-class-def]
+class Bar(Baz): ...  # error: [cyclic-class-def]
+class Baz(Foo, Spam): ...  # error: [cyclic-class-def]
+
+reveal_type(Foo.__mro__)  # revealed: tuple[Literal[Foo], Unknown, Literal[object]]
+reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Unknown, Literal[object]]
+reveal_type(Baz.__mro__)  # revealed: tuple[Literal[Baz], Unknown, Literal[object]]
+```
+
+## Classes with cycles in their MRO, and a sub-graph
+
+```py path=a.pyi
+class FooCycle(BarCycle): ...  # error: [cyclic-class-def]
+class Foo: ...
+class BarCycle(FooCycle): ...  # error: [cyclic-class-def]
+class Bar(Foo): ...
+
+# TODO: can we avoid emitting the errors for these?
+# The classes have cyclic superclasses,
+# but are not themselves cyclic...
+class Baz(Bar, BarCycle): ...  # error: [cyclic-class-def]
+class Spam(Baz): ...  # error: [cyclic-class-def]
+
+reveal_type(FooCycle.__mro__)  # revealed: tuple[Literal[FooCycle], Unknown, Literal[object]]
+reveal_type(BarCycle.__mro__)  # revealed: tuple[Literal[BarCycle], Unknown, Literal[object]]
+reveal_type(Baz.__mro__)  # revealed: tuple[Literal[Baz], Unknown, Literal[object]]
+reveal_type(Spam.__mro__)  # revealed: tuple[Literal[Spam], Unknown, Literal[object]]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/boolean.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/boolean.md
@@ -0,0 +1,282 @@
+# Narrowing for conditionals with boolean expressions
+
+## Narrowing in `and` conditional
+
+```py
+class A: ...
+class B: ...
+
+def instance() -> A | B:
+    return A()
+
+x = instance()
+
+if isinstance(x, A) and isinstance(x, B):
+    reveal_type(x)  # revealed:  A & B
+else:
+    reveal_type(x)  # revealed:  B & ~A | A & ~B
+```
+
+## Arms might not add narrowing constraints
+
+```py
+class A: ...
+class B: ...
+
+def bool_instance() -> bool:
+    return True
+
+def instance() -> A | B:
+    return A()
+
+x = instance()
+
+if isinstance(x, A) and bool_instance():
+    reveal_type(x)  # revealed: A
+else:
+    reveal_type(x)  # revealed: A | B
+
+if bool_instance() and isinstance(x, A):
+    reveal_type(x)  # revealed: A
+else:
+    reveal_type(x)  # revealed: A | B
+
+reveal_type(x)  # revealed: A | B
+```
+
+## Statically known arms
+
+```py
+class A: ...
+class B: ...
+
+def instance() -> A | B:
+    return A()
+
+x = instance()
+
+if isinstance(x, A) and True:
+    reveal_type(x)  # revealed: A
+else:
+    reveal_type(x)  # revealed: B & ~A
+
+if True and isinstance(x, A):
+    reveal_type(x)  # revealed: A
+else:
+    reveal_type(x)  # revealed: B & ~A
+
+if False and isinstance(x, A):
+    # TODO: should emit an `unreachable code` diagnostic
+    reveal_type(x)  # revealed: A
+else:
+    reveal_type(x)  # revealed: A | B
+
+if False or isinstance(x, A):
+    reveal_type(x)  # revealed: A
+else:
+    reveal_type(x)  # revealed: B & ~A
+
+if True or isinstance(x, A):
+    reveal_type(x)  # revealed: A | B
+else:
+    # TODO: should emit an `unreachable code` diagnostic
+    reveal_type(x)  # revealed: B & ~A
+
+reveal_type(x)  # revealed: A | B
+```
+
+## The type of multiple symbols can be narrowed down
+
+```py
+class A: ...
+class B: ...
+
+def instance() -> A | B:
+    return A()
+
+x = instance()
+y = instance()
+
+if isinstance(x, A) and isinstance(y, B):
+    reveal_type(x)  # revealed: A
+    reveal_type(y)  # revealed: B
+else:
+    # No narrowing: Only-one or both checks might have failed
+    reveal_type(x)  # revealed: A | B
+    reveal_type(y)  # revealed: A | B
+
+reveal_type(x)  # revealed: A | B
+reveal_type(y)  # revealed: A | B
+```
+
+## Narrowing in `or` conditional
+
+```py
+class A: ...
+class B: ...
+class C: ...
+
+def instance() -> A | B | C:
+    return A()
+
+x = instance()
+
+if isinstance(x, A) or isinstance(x, B):
+    reveal_type(x)  # revealed:  A | B
+else:
+    reveal_type(x)  # revealed:  C & ~A & ~B
+```
+
+## In `or`, all arms should add constraint in order to narrow
+
+```py
+class A: ...
+class B: ...
+class C: ...
+
+def instance() -> A | B | C:
+    return A()
+
+def bool_instance() -> bool:
+    return True
+
+x = instance()
+
+if isinstance(x, A) or isinstance(x, B) or bool_instance():
+    reveal_type(x)  # revealed:  A | B | C
+else:
+    reveal_type(x)  # revealed:  C & ~A & ~B
+```
+
+## in `or`, all arms should narrow the same set of symbols
+
+```py
+class A: ...
+class B: ...
+class C: ...
+
+def instance() -> A | B | C:
+    return A()
+
+x = instance()
+y = instance()
+
+if isinstance(x, A) or isinstance(y, A):
+    # The predicate might be satisfied by the right side, so the type of `x` can’t be narrowed down here.
+    reveal_type(x)  # revealed:  A | B | C
+    # The same for `y`
+    reveal_type(y)  # revealed:  A | B | C
+else:
+    reveal_type(x)  # revealed:  B & ~A | C & ~A
+    reveal_type(y)  # revealed:  B & ~A | C & ~A
+
+if (isinstance(x, A) and isinstance(y, A)) or (isinstance(x, B) and isinstance(y, B)):
+    # Here, types of `x` and `y` can be narrowd since all `or` arms constraint them.
+    reveal_type(x)  # revealed:  A | B
+    reveal_type(y)  # revealed:  A | B
+else:
+    reveal_type(x)  # revealed:  A | B | C
+    reveal_type(y)  # revealed:  A | B | C
+```
+
+## mixing `and` and `not`
+
+```py
+class A: ...
+class B: ...
+class C: ...
+
+def instance() -> A | B | C:
+    return A()
+
+x = instance()
+
+if isinstance(x, B) and not isinstance(x, C):
+    reveal_type(x)  # revealed:  B & ~C
+else:
+    # ~(B & ~C) -> ~B | C -> (A & ~B) | (C & ~B) | C -> (A & ~B) | C
+    reveal_type(x)  # revealed: A & ~B | C
+```
+
+## mixing `or` and `not`
+
+```py
+class A: ...
+class B: ...
+class C: ...
+
+def instance() -> A | B | C:
+    return A()
+
+x = instance()
+
+if isinstance(x, B) or not isinstance(x, C):
+    reveal_type(x)  # revealed: B | A & ~C
+else:
+    reveal_type(x)  # revealed: C & ~B
+```
+
+## `or` with nested `and`
+
+```py
+class A: ...
+class B: ...
+class C: ...
+
+def instance() -> A | B | C:
+    return A()
+
+x = instance()
+
+if isinstance(x, A) or (isinstance(x, B) and not isinstance(x, C)):
+    reveal_type(x)  # revealed:  A | B & ~C
+else:
+    # ~(A | (B & ~C)) -> ~A & ~(B & ~C) -> ~A & (~B | C) -> (~A & C) | (~A ~ B)
+    reveal_type(x)  # revealed:  C & ~A
+```
+
+## `and` with nested `or`
+
+```py
+class A: ...
+class B: ...
+class C: ...
+
+def instance() -> A | B | C:
+    return A()
+
+x = instance()
+
+if isinstance(x, A) and (isinstance(x, B) or not isinstance(x, C)):
+    # A & (B | ~C) -> (A & B) | (A & ~C)
+    reveal_type(x)  # revealed:  A & B | A & ~C
+else:
+    # ~((A & B) | (A & ~C)) ->
+    # ~(A & B) & ~(A & ~C) ->
+    # (~A | ~B) & (~A | C) ->
+    # [(~A | ~B) & ~A] | [(~A | ~B) & C] ->
+    # ~A | (~A & C) | (~B & C) ->
+    # ~A | (C & ~B) ->
+    # ~A | (C & ~B)  The positive side of ~A is  A | B | C ->
+    reveal_type(x)  # revealed:  B & ~A | C & ~A | C & ~B
+```
+
+## Boolean expression internal narrowing
+
+```py
+def optional_string() -> str | None:
+    return None
+
+x = optional_string()
+y = optional_string()
+
+if x is None and y is not x:
+    reveal_type(y)  # revealed: str
+
+# Neither of the conditions alone is sufficient for narrowing y's type:
+if x is None:
+    reveal_type(y)  # revealed: str | None
+
+if y is not x:
+    reveal_type(y)  # revealed: str | None
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/elif_else.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/elif_else.md
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/is.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/is.md
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/is_not.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/is_not.md
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/nested.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/nested.md
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/not.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/not.md
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/not_eq.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/not_eq.md
--- a/crates/red_knot_python_semantic/resources/mdtest/narrow/issubclass.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/narrow/issubclass.md
@@ -0,0 +1,247 @@
+# Narrowing for `issubclass` checks
+
+Narrowing for `issubclass(class, classinfo)` expressions.
+
+## `classinfo` is a single type
+
+### Basic example
+
+```py
+def flag() -> bool: ...
+
+t = int if flag() else str
+
+if issubclass(t, bytes):
+    reveal_type(t)  # revealed: Never
+
+if issubclass(t, object):
+    reveal_type(t)  # revealed: Literal[int, str]
+
+if issubclass(t, int):
+    reveal_type(t)  # revealed: Literal[int]
+else:
+    reveal_type(t)  # revealed: Literal[str]
+
+if issubclass(t, str):
+    reveal_type(t)  # revealed: Literal[str]
+    if issubclass(t, int):
+        reveal_type(t)  # revealed: Never
+```
+
+### Proper narrowing in `elif` and `else` branches
+
+```py
+def flag() -> bool: ...
+
+t = int if flag() else str if flag() else bytes
+
+if issubclass(t, int):
+    reveal_type(t)  # revealed: Literal[int]
+else:
+    reveal_type(t)  # revealed: Literal[str, bytes]
+
+if issubclass(t, int):
+    reveal_type(t)  # revealed: Literal[int]
+elif issubclass(t, str):
+    reveal_type(t)  # revealed: Literal[str]
+else:
+    reveal_type(t)  # revealed: Literal[bytes]
+```
+
+### Multiple derived classes
+
+```py
+class Base: ...
+class Derived1(Base): ...
+class Derived2(Base): ...
+class Unrelated: ...
+
+def flag() -> bool: ...
+
+t1 = Derived1 if flag() else Derived2
+
+if issubclass(t1, Base):
+    reveal_type(t1)  # revealed: Literal[Derived1, Derived2]
+
+if issubclass(t1, Derived1):
+    reveal_type(t1)  # revealed: Literal[Derived1]
+else:
+    reveal_type(t1)  # revealed: Literal[Derived2]
+
+t2 = Derived1 if flag() else Base
+
+if issubclass(t2, Base):
+    reveal_type(t2)  # revealed: Literal[Derived1, Base]
+
+t3 = Derived1 if flag() else Unrelated
+
+if issubclass(t3, Base):
+    reveal_type(t3)  # revealed: Literal[Derived1]
+else:
+    reveal_type(t3)  # revealed: Literal[Unrelated]
+```
+
+### Narrowing for non-literals
+
+```py
+class A: ...
+class B: ...
+
+def get_class() -> type[object]: ...
+
+t = get_class()
+
+if issubclass(t, A):
+    reveal_type(t)  # revealed: type[A]
+    if issubclass(t, B):
+        reveal_type(t)  # revealed: type[A] & type[B]
+else:
+    reveal_type(t)  # revealed: type[object] & ~type[A]
+```
+
+### Handling of `None`
+
+```py
+# TODO: this error should ideally go away once we (1) understand `sys.version_info` branches,
+# and (2) set the target Python version for this test to 3.10.
+# error: [possibly-unbound-import] "Member `NoneType` of module `types` is possibly unbound"
+from types import NoneType
+
+def flag() -> bool: ...
+
+t = int if flag() else NoneType
+
+if issubclass(t, NoneType):
+    reveal_type(t)  # revealed: Literal[NoneType]
+
+if issubclass(t, type(None)):
+    # TODO: this should be just `Literal[NoneType]`
+    reveal_type(t)  # revealed: Literal[int, NoneType]
+```
+
+## `classinfo` contains multiple types
+
+### (Nested) tuples of types
+
+```py
+class Unrelated: ...
+
+def flag() -> bool: ...
+
+t = int if flag() else str if flag() else bytes
+
+if issubclass(t, (int, (Unrelated, (bytes,)))):
+    reveal_type(t)  # revealed: Literal[int, bytes]
+else:
+    reveal_type(t)  # revealed: Literal[str]
+```
+
+## Special cases
+
+### Emit a diagnostic if the first argument is of wrong type
+
+#### Too wide
+
+`type[object]` is a subtype of `object`, but not every `object` can be passed as the first argument
+to `issubclass`:
+
+```py
+class A: ...
+
+def get_object() -> object: ...
+
+t = get_object()
+
+# TODO: we should emit a diagnostic here
+if issubclass(t, A):
+    reveal_type(t)  # revealed: type[A]
+```
+
+#### Wrong
+
+`Literal[1]` and `type` are entirely disjoint, so the inferred type of `Literal[1] & type[int]` is
+eagerly simplified to `Never` as a result of the type narrowing in the `if issubclass(t, int)`
+branch:
+
+```py
+t = 1
+
+# TODO: we should emit a diagnostic here
+if issubclass(t, int):
+    reveal_type(t)  # revealed: Never
+```
+
+### Do not use custom `issubclass` for narrowing
+
+```py
+def issubclass(c, ci):
+    return True
+
+def flag() -> bool: ...
+
+t = int if flag() else str
+if issubclass(t, int):
+    reveal_type(t)  # revealed: Literal[int, str]
+```
+
+### Do support narrowing if `issubclass` is aliased
+
+```py
+issubclass_alias = issubclass
+
+def flag() -> bool: ...
+
+t = int if flag() else str
+if issubclass_alias(t, int):
+    reveal_type(t)  # revealed: Literal[int]
+```
+
+### Do support narrowing if `issubclass` is imported
+
+```py
+from builtins import issubclass as imported_issubclass
+
+def flag() -> bool: ...
+
+t = int if flag() else str
+if imported_issubclass(t, int):
+    reveal_type(t)  # revealed: Literal[int]
+```
+
+### Do not narrow if second argument is not a proper `classinfo` argument
+
+```py
+from typing import Any
+
+def flag() -> bool: ...
+
+t = int if flag() else str
+
+# TODO: this should cause us to emit a diagnostic during
+# type checking
+if issubclass(t, "str"):
+    reveal_type(t)  # revealed: Literal[int, str]
+
+# TODO: this should cause us to emit a diagnostic during
+# type checking
+if issubclass(t, (bytes, "str")):
+    reveal_type(t)  # revealed: Literal[int, str]
+
+# TODO: this should cause us to emit a diagnostic during
+# type checking
+if issubclass(t, Any):
+    reveal_type(t)  # revealed: Literal[int, str]
+```
+
+### Do not narrow if there are keyword arguments
+
+```py
+def flag() -> bool: ...
+
+t = int if flag() else str
+
+# TODO: this should cause us to emit a diagnostic
+# (`issubclass` has no `foo` parameter)
+if issubclass(t, int, foo="bar"):
+    reveal_type(t)  # revealed: Literal[int, str]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/scopes/moduletype_attrs.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/scopes/moduletype_attrs.md
@@ -58,11 +58,9 @@ reveal_type(typing.__name__)  # revealed: str
 reveal_type(typing.__init__)  # revealed: Literal[__init__]

 # These come from `builtins.object`, not `types.ModuleType`:
-# TODO: we don't currently understand `types.ModuleType` as inheriting from `object`;
-# these should not reveal `Unknown`:
-reveal_type(typing.__eq__)  # revealed: Unknown
-reveal_type(typing.__class__)  # revealed: Unknown
-reveal_type(typing.__module__)  # revealed: Unknown
+reveal_type(typing.__eq__)  # revealed: Literal[__eq__]
+
+reveal_type(typing.__class__)  # revealed: Literal[type]

 # TODO: needs support for attribute access on instances, properties and generics;
 # should be `dict[str, Any]`
@@ -76,6 +74,7 @@ we're dealing with:
 ```py path=__getattr__.py
 import typing

+# error: [unresolved-attribute]
 reveal_type(typing.__getattr__)  # revealed: Unknown
 ```

--- a/crates/red_knot_python_semantic/resources/mdtest/stubs/class.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/stubs/class.md
@@ -6,7 +6,12 @@ In type stubs, classes can reference themselves in their base class definitions.
 `typeshed`, we have `class str(Sequence[str]): ...`.

 ```py path=a.pyi
-class C(C): ...
+class Foo[T]: ...

-reveal_type(C)  # revealed: Literal[C]
+# TODO: actually is subscriptable
+# error: [non-subscriptable]
+class Bar(Foo[Bar]): ...
+
+reveal_type(Bar)  # revealed: Literal[Bar]
+reveal_type(Bar.__mro__)  # revealed: tuple[Literal[Bar], Unknown, Literal[object]]
 ```
--- a/crates/red_knot_python_semantic/resources/mdtest/subscript/class.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/subscript/class.md
@@ -39,7 +39,8 @@ reveal_type(UnionClassGetItem[0])  # revealed: str | int
 ## Class getitem with class union

 ```py
-flag = True
+def bool_instance() -> bool:
+    return True

 class A:
    def __class_getitem__(cls, item: int) -> str:
@@ -49,7 +50,7 @@ class B:
    def __class_getitem__(cls, item: int) -> int:
        return item

-x = A if flag else B
+x = A if bool_instance() else B

 reveal_type(x)  # revealed: Literal[A, B]
 reveal_type(x[0])  # revealed: str | int
--- a/crates/red_knot_python_semantic/resources/mdtest/sys_version_info.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/sys_version_info.md
@@ -0,0 +1,137 @@
+# `sys.version_info`
+
+## The type of `sys.version_info`
+
+The type of `sys.version_info` is `sys._version_info`, at least according to typeshed's stubs (which
+we treat as the single source of truth for the standard library). This is quite a complicated type
+in typeshed, so there are many things we don't fully understand about the type yet; this is the
+source of several TODOs in this test file. Many of these TODOs should be naturally fixed as we
+implement more type-system features in the future.
+
+```py
+import sys
+
+reveal_type(sys.version_info)  # revealed: _version_info
+```
+
+## Literal types from comparisons
+
+Comparing `sys.version_info` with a 2-element tuple of literal integers always produces a `Literal`
+type:
+
+```py
+import sys
+
+reveal_type(sys.version_info >= (3, 8))  # revealed: Literal[True]
+reveal_type((3, 8) <= sys.version_info)  # revealed: Literal[True]
+
+reveal_type(sys.version_info > (3, 8))  # revealed: Literal[True]
+reveal_type((3, 8) < sys.version_info)  # revealed: Literal[True]
+
+reveal_type(sys.version_info < (3, 8))  # revealed: Literal[False]
+reveal_type((3, 8) > sys.version_info)  # revealed: Literal[False]
+
+reveal_type(sys.version_info <= (3, 8))  # revealed: Literal[False]
+reveal_type((3, 8) >= sys.version_info)  # revealed: Literal[False]
+
+reveal_type(sys.version_info == (3, 8))  # revealed: Literal[False]
+reveal_type((3, 8) == sys.version_info)  # revealed: Literal[False]
+
+reveal_type(sys.version_info != (3, 8))  # revealed: Literal[True]
+reveal_type((3, 8) != sys.version_info)  # revealed: Literal[True]
+```
+
+## Non-literal types from comparisons
+
+Comparing `sys.version_info` with tuples of other lengths will sometimes produce `Literal` types,
+sometimes not:
+
+```py
+import sys
+
+reveal_type(sys.version_info >= (3, 8, 1))  # revealed: bool
+reveal_type(sys.version_info >= (3, 8, 1, "final", 0))  # revealed: bool
+
+# TODO: this is an invalid comparison (`sys.version_info` is a tuple of length 5)
+# Should we issue a diagnostic here?
+reveal_type(sys.version_info >= (3, 8, 1, "final", 0, 5))  # revealed: bool
+
+# TODO: this should be `Literal[False]`; see #14279
+reveal_type(sys.version_info == (3, 8, 1, "finallllll", 0))  # revealed: bool
+```
+
+## Imports and aliases
+
+Comparisons with `sys.version_info` still produce literal types, even if the symbol is aliased to
+another name:
+
+```py
+from sys import version_info
+from sys import version_info as foo
+
+reveal_type(version_info >= (3, 8))  # revealed: Literal[True]
+reveal_type(foo >= (3, 8))  # revealed: Literal[True]
+
+bar = version_info
+reveal_type(bar >= (3, 8))  # revealed: Literal[True]
+```
+
+## Non-stdlib modules named `sys`
+
+Only comparisons with the symbol `version_info` from the `sys` module produce literal types:
+
+```py path=package/__init__.py
+```
+
+```py path=package/sys.py
+version_info: tuple[int, int] = (4, 2)
+```
+
+```py path=package/script.py
+from .sys import version_info
+
+reveal_type(version_info >= (3, 8))  # revealed: bool
+```
+
+## Accessing fields by name
+
+The fields of `sys.version_info` can be accessed by name:
+
+```py path=a.py
+import sys
+
+reveal_type(sys.version_info.major >= 3)  # revealed: Literal[True]
+reveal_type(sys.version_info.minor >= 8)  # revealed: Literal[True]
+reveal_type(sys.version_info.minor >= 9)  # revealed: Literal[False]
+```
+
+But the `micro`, `releaselevel` and `serial` fields are inferred as `@Todo` until we support
+properties on instance types:
+
+```py path=b.py
+import sys
+
+reveal_type(sys.version_info.micro)  # revealed: @Todo
+reveal_type(sys.version_info.releaselevel)  # revealed: @Todo
+reveal_type(sys.version_info.serial)  # revealed: @Todo
+```
+
+## Accessing fields by index/slice
+
+The fields of `sys.version_info` can be accessed by index or by slice:
+
+```py
+import sys
+
+reveal_type(sys.version_info[0] < 3)  # revealed: Literal[False]
+reveal_type(sys.version_info[1] > 8)  # revealed: Literal[False]
+
+# revealed: tuple[Literal[3], Literal[8], int, Literal["alpha", "beta", "candidate", "final"], int]
+reveal_type(sys.version_info[:5])
+
+reveal_type(sys.version_info[:2] >= (3, 8))  # revealed: Literal[True]
+reveal_type(sys.version_info[0:2] >= (3, 9))  # revealed: Literal[False]
+reveal_type(sys.version_info[:3] >= (3, 9, 1))  # revealed: Literal[False]
+reveal_type(sys.version_info[3] == "final")  # revealed: bool
+reveal_type(sys.version_info[3] == "finalllllll")  # revealed: Literal[False]
+```
--- a/crates/red_knot_python_semantic/resources/mdtest/unary/instance.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/unary/instance.md
@@ -1,6 +1,8 @@
 # Unary Operations

 ```py
+from typing import Literal
+
 class Number:
    def __init__(self, value: int):
        self.value = 1
@@ -18,7 +20,7 @@ a = Number()

 reveal_type(+a)  # revealed: int
 reveal_type(-a)  # revealed: int
-reveal_type(~a)  # revealed: @Todo
+reveal_type(~a)  # revealed: Literal[True]

 class NoDunder: ...

--- a/crates/red_knot_python_semantic/resources/mdtest/unary/not.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/unary/not.md
@@ -10,8 +10,6 @@ reveal_type(not not None)  # revealed: Literal[False]
 ## Function

 ```py
-from typing import reveal_type
-
 def f():
    return 1

--- a/crates/red_knot_python_semantic/resources/mdtest/unpacking.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/unpacking.md
@@ -145,13 +145,8 @@ reveal_type(f)  # revealed: Unknown

 ### Non-iterable unpacking

-TODO: Remove duplicate diagnostics. This is happening because for a sequence-like assignment target,
-multiple definitions are created and the inference engine runs on each of them which results in
-duplicate diagnostics.
-
 ```py
 # error: "Object of type `Literal[1]` is not iterable"
-# error: "Object of type `Literal[1]` is not iterable"
 a, b = 1
 reveal_type(a)  # revealed: Unknown
 reveal_type(b)  # revealed: Unknown
--- a/crates/red_knot_python_semantic/resources/mdtest/with/async_with.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/with/async_with.md
--- a/crates/red_knot_python_semantic/resources/mdtest/with/sync.md
+++ b/crates/red_knot_python_semantic/resources/mdtest/with/sync.md
--- a/crates/red_knot_python_semantic/src/lib.rs
+++ b/crates/red_knot_python_semantic/src/lib.rs
@@ -22,6 +22,7 @@ pub(crate) mod site_packages;
 mod stdlib;
 pub(crate) mod symbol;
 pub mod types;
+mod unpack;
 mod util;

 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;
--- a/crates/red_knot_python_semantic/src/semantic_index.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index.rs
@@ -125,6 +125,7 @@ impl<'db> SemanticIndex<'db> {
    ///
    /// Use the Salsa cached [`symbol_table()`] query if you only need the
    /// symbol table for a single scope.
+    #[track_caller]
    pub(super) fn symbol_table(&self, scope_id: FileScopeId) -> Arc<SymbolTable> {
        self.symbol_tables[scope_id].clone()
    }
@@ -133,15 +134,18 @@ impl<'db> SemanticIndex<'db> {
    ///
    /// Use the Salsa cached [`use_def_map()`] query if you only need the
    /// use-def map for a single scope.
+    #[track_caller]
    pub(super) fn use_def_map(&self, scope_id: FileScopeId) -> Arc<UseDefMap> {
        self.use_def_maps[scope_id].clone()
    }

+    #[track_caller]
    pub(crate) fn ast_ids(&self, scope_id: FileScopeId) -> &AstIds {
        &self.ast_ids[scope_id]
    }

    /// Returns the ID of the `expression`'s enclosing scope.
+    #[track_caller]
    pub(crate) fn expression_scope_id(
        &self,
        expression: impl Into<ExpressionNodeKey>,
@@ -151,11 +155,13 @@ impl<'db> SemanticIndex<'db> {

    /// Returns the [`Scope`] of the `expression`'s enclosing scope.
    #[allow(unused)]
+    #[track_caller]
    pub(crate) fn expression_scope(&self, expression: impl Into<ExpressionNodeKey>) -> &Scope {
        &self.scopes[self.expression_scope_id(expression)]
    }

    /// Returns the [`Scope`] with the given id.
+    #[track_caller]
    pub(crate) fn scope(&self, id: FileScopeId) -> &Scope {
        &self.scopes[id]
    }
@@ -172,6 +178,7 @@ impl<'db> SemanticIndex<'db> {

    /// Returns the parent scope of `scope_id`.
    #[allow(unused)]
+    #[track_caller]
    pub(crate) fn parent_scope(&self, scope_id: FileScopeId) -> Option<&Scope> {
        Some(&self.scopes[self.parent_scope_id(scope_id)?])
    }
@@ -195,6 +202,7 @@ impl<'db> SemanticIndex<'db> {
    }

    /// Returns the [`Definition`] salsa ingredient for `definition_key`.
+    #[track_caller]
    pub(crate) fn definition(
        &self,
        definition_key: impl Into<DefinitionNodeKey>,
@@ -206,6 +214,7 @@ impl<'db> SemanticIndex<'db> {
    /// Panics if we have no expression ingredient for that node. We can only call this method for
    /// standalone-inferable expressions, which we call `add_standalone_expression` for in
    /// [`SemanticIndexBuilder`].
+    #[track_caller]
    pub(crate) fn expression(
        &self,
        expression_key: impl Into<ExpressionNodeKey>,
@@ -213,8 +222,18 @@ impl<'db> SemanticIndex<'db> {
        self.expressions_by_node[&expression_key.into()]
    }

+    pub(crate) fn try_expression(
+        &self,
+        expression_key: impl Into<ExpressionNodeKey>,
+    ) -> Option<Expression<'db>> {
+        self.expressions_by_node
+            .get(&expression_key.into())
+            .copied()
+    }
+
    /// Returns the id of the scope that `node` creates. This is different from [`Definition::scope`] which
    /// returns the scope in which that definition is defined in.
+    #[track_caller]
    pub(crate) fn node_scope(&self, node: NodeWithScopeRef) -> FileScopeId {
        self.scopes_by_node[&node.node_key()]
    }
--- a/crates/red_knot_python_semantic/src/semantic_index/ast_ids.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/ast_ids.rs
@@ -87,6 +87,14 @@ pub trait HasScopedAstId {
    fn scoped_ast_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id;
 }

+impl<T: HasScopedAstId> HasScopedAstId for Box<T> {
+    type Id = <T as HasScopedAstId>::Id;
+
+    fn scoped_ast_id(&self, db: &dyn Db, scope: ScopeId) -> Self::Id {
+        self.as_ref().scoped_ast_id(db, scope)
+    }
+}
+
 /// Uniquely identifies an [`ast::Expr`] in a [`crate::semantic_index::symbol::FileScopeId`].
 #[newtype_index]
 pub struct ScopedExpressionId;
--- a/crates/red_knot_python_semantic/src/semantic_index/builder.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/builder.rs
@@ -25,12 +25,13 @@ use crate::semantic_index::symbol::{
 };
 use crate::semantic_index::use_def::{FlowSnapshot, UseDefMapBuilder};
 use crate::semantic_index::SemanticIndex;
+use crate::unpack::Unpack;
 use crate::Db;

 use super::constraint::{Constraint, ConstraintNode, PatternConstraint};
 use super::definition::{
-    AssignmentKind, DefinitionCategory, ExceptHandlerDefinitionNodeRef,
-    MatchPatternDefinitionNodeRef, WithItemDefinitionNodeRef,
+    DefinitionCategory, ExceptHandlerDefinitionNodeRef, MatchPatternDefinitionNodeRef,
+    WithItemDefinitionNodeRef,
 };

 mod except_handlers;
@@ -46,6 +47,7 @@ pub(super) struct SemanticIndexBuilder<'db> {
    current_assignments: Vec<CurrentAssignment<'db>>,
    /// The match case we're currently visiting.
    current_match_case: Option<CurrentMatchCase<'db>>,
+
    /// Flow states at each `break` in the current loop.
    loop_break_states: Vec<FlowSnapshot>,
    /// Per-scope contexts regarding nested `try`/`except` statements
@@ -112,9 +114,11 @@ impl<'db> SemanticIndexBuilder<'db> {
    fn push_scope_with_parent(&mut self, node: NodeWithScopeRef, parent: Option<FileScopeId>) {
        let children_start = self.scopes.next_index() + 1;

+        #[allow(unsafe_code)]
        let scope = Scope {
            parent,
-            kind: node.scope_kind(),
+            // SAFETY: `node` is guaranteed to be a child of `self.module`
+            node: unsafe { node.to_kind(self.module.clone()) },
            descendents: children_start..children_start,
        };
        self.try_node_context_stack_manager.enter_nested_scope();
@@ -124,15 +128,7 @@ impl<'db> SemanticIndexBuilder<'db> {
        self.use_def_maps.push(UseDefMapBuilder::new());
        let ast_id_scope = self.ast_ids.push(AstIdsBuilder::new());

-        #[allow(unsafe_code)]
-        // SAFETY: `node` is guaranteed to be a child of `self.module`
-        let scope_id = ScopeId::new(
-            self.db,
-            self.file,
-            file_scope_id,
-            unsafe { node.to_kind(self.module.clone()) },
-            countme::Count::default(),
-        );
+        let scope_id = ScopeId::new(self.db, self.file, file_scope_id, countme::Count::default());

        self.scope_ids_by_scope.push(scope_id);
        self.scopes_by_node.insert(node.node_key(), file_scope_id);
@@ -203,10 +199,10 @@ impl<'db> SemanticIndexBuilder<'db> {
        self.current_symbol_table().mark_symbol_used(id);
    }

-    fn add_definition<'a>(
+    fn add_definition(
        &mut self,
        symbol: ScopedSymbolId,
-        definition_node: impl Into<DefinitionNodeRef<'a>>,
+        definition_node: impl Into<DefinitionNodeRef<'db>>,
    ) -> Definition<'db> {
        let definition_node: DefinitionNodeRef<'_> = definition_node.into();
        #[allow(unsafe_code)]
@@ -285,8 +281,12 @@ impl<'db> SemanticIndexBuilder<'db> {
        debug_assert!(popped_assignment.is_some());
    }

-    fn current_assignment(&self) -> Option<&CurrentAssignment<'db>> {
-        self.current_assignments.last()
+    fn current_assignment(&self) -> Option<CurrentAssignment<'db>> {
+        self.current_assignments.last().copied()
+    }
+
+    fn current_assignment_mut(&mut self) -> Option<&mut CurrentAssignment<'db>> {
+        self.current_assignments.last_mut()
    }

    fn add_pattern_constraint(
@@ -373,6 +373,11 @@ impl<'db> SemanticIndexBuilder<'db> {
                if let Some(default) = default {
                    self.visit_expr(default);
                }
+                match type_param {
+                    ast::TypeParam::TypeVar(node) => self.add_definition(symbol, node),
+                    ast::TypeParam::ParamSpec(node) => self.add_definition(symbol, node),
+                    ast::TypeParam::TypeVarTuple(node) => self.add_definition(symbol, node),
+                };
            }
        }

@@ -445,7 +450,7 @@ impl<'db> SemanticIndexBuilder<'db> {
        self.pop_scope();
    }

-    fn declare_parameter(&mut self, parameter: AnyParameterRef) {
+    fn declare_parameter(&mut self, parameter: AnyParameterRef<'db>) {
        let symbol = self.add_symbol(parameter.name().id().clone());

        let definition = self.add_definition(symbol, parameter);
@@ -584,6 +589,27 @@ where
                    },
                );
            }
+            ast::Stmt::TypeAlias(type_alias) => {
+                let symbol = self.add_symbol(
+                    type_alias
+                        .name
+                        .as_name_expr()
+                        .expect("type alias name is a name expr")
+                        .id
+                        .clone(),
+                );
+                self.add_definition(symbol, type_alias);
+
+                self.with_type_params(
+                    NodeWithScopeRef::TypeAliasTypeParameters(type_alias),
+                    type_alias.type_params.as_ref(),
+                    |builder| {
+                        builder.push_scope(NodeWithScopeRef::TypeAliasTypeParameters(type_alias));
+                        builder.visit_expr(&type_alias.value);
+                        builder.pop_scope()
+                    },
+                );
+            }
            ast::Stmt::Import(node) => {
                for alias in &node.names {
                    let symbol_name = if let Some(asname) = &alias.asname {
@@ -619,24 +645,48 @@ where
            }
            ast::Stmt::Assign(node) => {
                debug_assert_eq!(&self.current_assignments, &[]);
+
                self.visit_expr(&node.value);
-                self.add_standalone_expression(&node.value);
-                for (target_index, target) in node.targets.iter().enumerate() {
-                    let kind = match target {
-                        ast::Expr::List(_) | ast::Expr::Tuple(_) => Some(AssignmentKind::Sequence),
-                        ast::Expr::Name(_) => Some(AssignmentKind::Name),
+                let value = self.add_standalone_expression(&node.value);
+
+                for target in &node.targets {
+                    // We only handle assignments to names and unpackings here, other targets like
+                    // attribute and subscript are handled separately as they don't create a new
+                    // definition.
+                    let current_assignment = match target {
+                        ast::Expr::List(_) | ast::Expr::Tuple(_) => {
+                            Some(CurrentAssignment::Assign {
+                                node,
+                                first: true,
+                                unpack: Some(Unpack::new(
+                                    self.db,
+                                    self.file,
+                                    self.current_scope(),
+                                    #[allow(unsafe_code)]
+                                    unsafe {
+                                        AstNodeRef::new(self.module.clone(), target)
+                                    },
+                                    value,
+                                    countme::Count::default(),
+                                )),
+                            })
+                        }
+                        ast::Expr::Name(_) => Some(CurrentAssignment::Assign {
+                            node,
+                            unpack: None,
+                            first: false,
+                        }),
                        _ => None,
                    };
-                    if let Some(kind) = kind {
-                        self.push_assignment(CurrentAssignment::Assign {
-                            assignment: node,
-                            target_index,
-                            kind,
-                        });
+
+                    if let Some(current_assignment) = current_assignment {
+                        self.push_assignment(current_assignment);
                    }
+
                    self.visit_expr(target);
-                    if kind.is_some() {
-                        // only need to pop in the case where we pushed something
+
+                    if current_assignment.is_some() {
+                        // Only need to pop in the case where we pushed something
                        self.pop_assignment();
                    }
                }
@@ -970,19 +1020,19 @@ where
                }

                if is_definition {
-                    match self.current_assignment().copied() {
+                    match self.current_assignment() {
                        Some(CurrentAssignment::Assign {
-                            assignment,
-                            target_index,
-                            kind,
+                            node,
+                            first,
+                            unpack,
                        }) => {
                            self.add_definition(
                                symbol,
                                AssignmentDefinitionNodeRef {
-                                    assignment,
-                                    target_index,
+                                    unpack,
+                                    value: &node.value,
                                    name: name_node,
-                                    kind,
+                                    first,
                                },
                            );
                        }
@@ -1033,6 +1083,11 @@ where
                    }
                }

+                if let Some(CurrentAssignment::Assign { first, .. }) = self.current_assignment_mut()
+                {
+                    *first = false;
+                }
+
                walk_expr(self, expr);
            }
            ast::Expr::Named(node) => {
@@ -1073,10 +1128,13 @@ where
                // AST inspection, so we can't simplify here, need to record test expression for
                // later checking)
                self.visit_expr(test);
+                let constraint = self.record_expression_constraint(test);
                let pre_if = self.flow_snapshot();
                self.visit_expr(body);
                let post_body = self.flow_snapshot();
                self.flow_restore(pre_if);
+
+                self.record_negated_constraint(constraint);
                self.visit_expr(orelse);
                self.flow_merge(post_body);
            }
@@ -1229,9 +1287,9 @@ where
 #[derive(Copy, Clone, Debug, PartialEq)]
 enum CurrentAssignment<'a> {
    Assign {
-        assignment: &'a ast::StmtAssign,
-        target_index: usize,
-        kind: AssignmentKind,
+        node: &'a ast::StmtAssign,
+        first: bool,
+        unpack: Option<Unpack<'a>>,
    },
    AnnAssign(&'a ast::StmtAnnAssign),
    AugAssign(&'a ast::StmtAugAssign),
--- a/crates/red_knot_python_semantic/src/semantic_index/definition.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/definition.rs
@@ -6,8 +6,22 @@ use crate::ast_node_ref::AstNodeRef;
 use crate::module_resolver::file_to_module;
 use crate::node_key::NodeKey;
 use crate::semantic_index::symbol::{FileScopeId, ScopeId, ScopedSymbolId};
+use crate::unpack::Unpack;
 use crate::Db;

+/// A definition of a symbol.
+///
+/// ## Module-local type
+/// This type should not be used as part of any cross-module API because
+/// it holds a reference to the AST node. Range-offset changes
+/// then propagate through all usages, and deserialization requires
+/// reparsing the entire module.
+///
+/// E.g. don't use this type in:
+///
+/// * a return type of a cross-module query
+/// * a field of a type that is a return type of a cross-module query
+/// * an argument of a cross-module query
 #[salsa::tracked]
 pub struct Definition<'db> {
    /// The file in which the definition occurs.
@@ -24,7 +38,7 @@ pub struct Definition<'db> {

    #[no_eq]
    #[return_ref]
-    pub(crate) kind: DefinitionKind,
+    pub(crate) kind: DefinitionKind<'db>,

    #[no_eq]
    count: countme::Count<Definition<'static>>,
@@ -69,6 +83,7 @@ pub(crate) enum DefinitionNodeRef<'a> {
    For(ForStmtDefinitionNodeRef<'a>),
    Function(&'a ast::StmtFunctionDef),
    Class(&'a ast::StmtClassDef),
+    TypeAlias(&'a ast::StmtTypeAlias),
    NamedExpression(&'a ast::ExprNamed),
    Assignment(AssignmentDefinitionNodeRef<'a>),
    AnnotatedAssignment(&'a ast::StmtAnnAssign),
@@ -78,6 +93,9 @@ pub(crate) enum DefinitionNodeRef<'a> {
    WithItem(WithItemDefinitionNodeRef<'a>),
    MatchPattern(MatchPatternDefinitionNodeRef<'a>),
    ExceptHandler(ExceptHandlerDefinitionNodeRef<'a>),
+    TypeVar(&'a ast::TypeParamTypeVar),
+    ParamSpec(&'a ast::TypeParamParamSpec),
+    TypeVarTuple(&'a ast::TypeParamTypeVarTuple),
 }

 impl<'a> From<&'a ast::StmtFunctionDef> for DefinitionNodeRef<'a> {
@@ -92,6 +110,12 @@ impl<'a> From<&'a ast::StmtClassDef> for DefinitionNodeRef<'a> {
    }
 }

+impl<'a> From<&'a ast::StmtTypeAlias> for DefinitionNodeRef<'a> {
+    fn from(node: &'a ast::StmtTypeAlias) -> Self {
+        Self::TypeAlias(node)
+    }
+}
+
 impl<'a> From<&'a ast::ExprNamed> for DefinitionNodeRef<'a> {
    fn from(node: &'a ast::ExprNamed) -> Self {
        Self::NamedExpression(node)
@@ -116,6 +140,24 @@ impl<'a> From<&'a ast::Alias> for DefinitionNodeRef<'a> {
    }
 }

+impl<'a> From<&'a ast::TypeParamTypeVar> for DefinitionNodeRef<'a> {
+    fn from(value: &'a ast::TypeParamTypeVar) -> Self {
+        Self::TypeVar(value)
+    }
+}
+
+impl<'a> From<&'a ast::TypeParamParamSpec> for DefinitionNodeRef<'a> {
+    fn from(value: &'a ast::TypeParamParamSpec) -> Self {
+        Self::ParamSpec(value)
+    }
+}
+
+impl<'a> From<&'a ast::TypeParamTypeVarTuple> for DefinitionNodeRef<'a> {
+    fn from(value: &'a ast::TypeParamTypeVarTuple) -> Self {
+        Self::TypeVarTuple(value)
+    }
+}
+
 impl<'a> From<ImportFromDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
    fn from(node_ref: ImportFromDefinitionNodeRef<'a>) -> Self {
        Self::ImportFrom(node_ref)
@@ -166,10 +208,10 @@ pub(crate) struct ImportFromDefinitionNodeRef<'a> {

 #[derive(Copy, Clone, Debug)]
 pub(crate) struct AssignmentDefinitionNodeRef<'a> {
-    pub(crate) assignment: &'a ast::StmtAssign,
-    pub(crate) target_index: usize,
+    pub(crate) unpack: Option<Unpack<'a>>,
+    pub(crate) value: &'a ast::Expr,
    pub(crate) name: &'a ast::ExprName,
-    pub(crate) kind: AssignmentKind,
+    pub(crate) first: bool,
 }

 #[derive(Copy, Clone, Debug)]
@@ -211,9 +253,9 @@ pub(crate) struct MatchPatternDefinitionNodeRef<'a> {
    pub(crate) index: u32,
 }

-impl DefinitionNodeRef<'_> {
+impl<'db> DefinitionNodeRef<'db> {
    #[allow(unsafe_code)]
-    pub(super) unsafe fn into_owned(self, parsed: ParsedModule) -> DefinitionKind {
+    pub(super) unsafe fn into_owned(self, parsed: ParsedModule) -> DefinitionKind<'db> {
        match self {
            DefinitionNodeRef::Import(alias) => {
                DefinitionKind::Import(AstNodeRef::new(parsed, alias))
@@ -230,19 +272,22 @@ impl DefinitionNodeRef<'_> {
            DefinitionNodeRef::Class(class) => {
                DefinitionKind::Class(AstNodeRef::new(parsed, class))
            }
+            DefinitionNodeRef::TypeAlias(type_alias) => {
+                DefinitionKind::TypeAlias(AstNodeRef::new(parsed, type_alias))
+            }
            DefinitionNodeRef::NamedExpression(named) => {
                DefinitionKind::NamedExpression(AstNodeRef::new(parsed, named))
            }
            DefinitionNodeRef::Assignment(AssignmentDefinitionNodeRef {
-                assignment,
-                target_index,
+                unpack,
+                value,
                name,
-                kind,
+                first,
            }) => DefinitionKind::Assignment(AssignmentDefinitionKind {
-                assignment: AstNodeRef::new(parsed.clone(), assignment),
-                target_index,
+                target: TargetKind::from(unpack),
+                value: AstNodeRef::new(parsed.clone(), value),
                name: AstNodeRef::new(parsed, name),
-                kind,
+                first,
            }),
            DefinitionNodeRef::AnnotatedAssignment(assign) => {
                DefinitionKind::AnnotatedAssignment(AstNodeRef::new(parsed, assign))
@@ -303,6 +348,15 @@ impl DefinitionNodeRef<'_> {
                handler: AstNodeRef::new(parsed, handler),
                is_star,
            }),
+            DefinitionNodeRef::TypeVar(node) => {
+                DefinitionKind::TypeVar(AstNodeRef::new(parsed, node))
+            }
+            DefinitionNodeRef::ParamSpec(node) => {
+                DefinitionKind::ParamSpec(AstNodeRef::new(parsed, node))
+            }
+            DefinitionNodeRef::TypeVarTuple(node) => {
+                DefinitionKind::TypeVarTuple(AstNodeRef::new(parsed, node))
+            }
        }
    }

@@ -314,12 +368,13 @@ impl DefinitionNodeRef<'_> {
            }
            Self::Function(node) => node.into(),
            Self::Class(node) => node.into(),
+            Self::TypeAlias(node) => node.into(),
            Self::NamedExpression(node) => node.into(),
            Self::Assignment(AssignmentDefinitionNodeRef {
-                assignment: _,
-                target_index: _,
+                value: _,
+                unpack: _,
                name,
-                kind: _,
+                first: _,
            }) => name.into(),
            Self::AnnotatedAssignment(node) => node.into(),
            Self::AugmentedAssignment(node) => node.into(),
@@ -342,6 +397,9 @@ impl DefinitionNodeRef<'_> {
                identifier.into()
            }
            Self::ExceptHandler(ExceptHandlerDefinitionNodeRef { handler, .. }) => handler.into(),
+            Self::TypeVar(node) => node.into(),
+            Self::ParamSpec(node) => node.into(),
+            Self::TypeVarTuple(node) => node.into(),
        }
    }
 }
@@ -382,13 +440,14 @@ impl DefinitionCategory {
 }

 #[derive(Clone, Debug)]
-pub enum DefinitionKind {
+pub enum DefinitionKind<'db> {
    Import(AstNodeRef<ast::Alias>),
    ImportFrom(ImportFromDefinitionKind),
    Function(AstNodeRef<ast::StmtFunctionDef>),
    Class(AstNodeRef<ast::StmtClassDef>),
+    TypeAlias(AstNodeRef<ast::StmtTypeAlias>),
    NamedExpression(AstNodeRef<ast::ExprNamed>),
-    Assignment(AssignmentDefinitionKind),
+    Assignment(AssignmentDefinitionKind<'db>),
    AnnotatedAssignment(AstNodeRef<ast::StmtAnnAssign>),
    AugmentedAssignment(AstNodeRef<ast::StmtAugAssign>),
    For(ForStmtDefinitionKind),
@@ -398,16 +457,23 @@ pub enum DefinitionKind {
    WithItem(WithItemDefinitionKind),
    MatchPattern(MatchPatternDefinitionKind),
    ExceptHandler(ExceptHandlerDefinitionKind),
+    TypeVar(AstNodeRef<ast::TypeParamTypeVar>),
+    ParamSpec(AstNodeRef<ast::TypeParamParamSpec>),
+    TypeVarTuple(AstNodeRef<ast::TypeParamTypeVarTuple>),
 }

-impl DefinitionKind {
+impl DefinitionKind<'_> {
    pub(crate) fn category(&self) -> DefinitionCategory {
        match self {
            // functions, classes, and imports always bind, and we consider them declarations
            DefinitionKind::Function(_)
            | DefinitionKind::Class(_)
+            | DefinitionKind::TypeAlias(_)
            | DefinitionKind::Import(_)
-            | DefinitionKind::ImportFrom(_) => DefinitionCategory::DeclarationAndBinding,
+            | DefinitionKind::ImportFrom(_)
+            | DefinitionKind::TypeVar(_)
+            | DefinitionKind::ParamSpec(_)
+            | DefinitionKind::TypeVarTuple(_) => DefinitionCategory::DeclarationAndBinding,
            // a parameter always binds a value, but is only a declaration if annotated
            DefinitionKind::Parameter(parameter) => {
                if parameter.annotation.is_some() {
@@ -445,6 +511,21 @@ impl DefinitionKind {
    }
 }

+#[derive(Copy, Clone, Debug, PartialEq)]
+pub(crate) enum TargetKind<'db> {
+    Sequence(Unpack<'db>),
+    Name,
+}
+
+impl<'db> From<Option<Unpack<'db>>> for TargetKind<'db> {
+    fn from(value: Option<Unpack<'db>>) -> Self {
+        match value {
+            Some(unpack) => TargetKind::Sequence(unpack),
+            None => TargetKind::Name,
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 #[allow(dead_code)]
 pub struct MatchPatternDefinitionKind {
@@ -506,38 +587,31 @@ impl ImportFromDefinitionKind {
 }

 #[derive(Clone, Debug)]
-pub struct AssignmentDefinitionKind {
-    assignment: AstNodeRef<ast::StmtAssign>,
-    target_index: usize,
+pub struct AssignmentDefinitionKind<'db> {
+    target: TargetKind<'db>,
+    value: AstNodeRef<ast::Expr>,
    name: AstNodeRef<ast::ExprName>,
-    kind: AssignmentKind,
+    first: bool,
 }

-impl AssignmentDefinitionKind {
-    pub(crate) fn value(&self) -> &ast::Expr {
-        &self.assignment.node().value
+impl<'db> AssignmentDefinitionKind<'db> {
+    pub(crate) fn target(&self) -> TargetKind<'db> {
+        self.target
    }

-    pub(crate) fn target(&self) -> &ast::Expr {
-        &self.assignment.node().targets[self.target_index]
+    pub(crate) fn value(&self) -> &ast::Expr {
+        self.value.node()
    }

    pub(crate) fn name(&self) -> &ast::ExprName {
        self.name.node()
    }

-    pub(crate) fn kind(&self) -> AssignmentKind {
-        self.kind
+    pub(crate) fn is_first(&self) -> bool {
+        self.first
    }
 }

-/// The kind of assignment target expression.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum AssignmentKind {
-    Sequence,
-    Name,
-}
-
 #[derive(Clone, Debug)]
 pub struct WithItemDefinitionKind {
    node: AstNodeRef<ast::WithItem>,
@@ -621,6 +695,12 @@ impl From<&ast::StmtClassDef> for DefinitionNodeKey {
    }
 }

+impl From<&ast::StmtTypeAlias> for DefinitionNodeKey {
+    fn from(node: &ast::StmtTypeAlias) -> Self {
+        Self(NodeKey::from_node(node))
+    }
+}
+
 impl From<&ast::ExprName> for DefinitionNodeKey {
    fn from(node: &ast::ExprName) -> Self {
        Self(NodeKey::from_node(node))
@@ -674,3 +754,21 @@ impl From<&ast::ExceptHandlerExceptHandler> for DefinitionNodeKey {
        Self(NodeKey::from_node(handler))
    }
 }
+
+impl From<&ast::TypeParamTypeVar> for DefinitionNodeKey {
+    fn from(value: &ast::TypeParamTypeVar) -> Self {
+        Self(NodeKey::from_node(value))
+    }
+}
+
+impl From<&ast::TypeParamParamSpec> for DefinitionNodeKey {
+    fn from(value: &ast::TypeParamParamSpec) -> Self {
+        Self(NodeKey::from_node(value))
+    }
+}
+
+impl From<&ast::TypeParamTypeVarTuple> for DefinitionNodeKey {
+    fn from(value: &ast::TypeParamTypeVarTuple) -> Self {
+        Self(NodeKey::from_node(value))
+    }
+}
--- a/crates/red_knot_python_semantic/src/semantic_index/expression.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/expression.rs
@@ -8,6 +8,18 @@ use salsa;
 /// An independently type-inferable expression.
 ///
 /// Includes constraint expressions (e.g. if tests) and the RHS of an unpacking assignment.
+///
+/// ## Module-local type
+/// This type should not be used as part of any cross-module API because
+/// it holds a reference to the AST node. Range-offset changes
+/// then propagate through all usages, and deserialization requires
+/// reparsing the entire module.
+///
+/// E.g. don't use this type in:
+///
+/// * a return type of a cross-module query
+/// * a field of a type that is a return type of a cross-module query
+/// * an argument of a cross-module query
 #[salsa::tracked]
 pub(crate) struct Expression<'db> {
    /// The file in which the expression occurs.
--- a/crates/red_knot_python_semantic/src/semantic_index/symbol.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/symbol.rs
@@ -103,14 +103,10 @@ pub struct ScopedSymbolId;
 pub struct ScopeId<'db> {
    #[id]
    pub file: File,
+
    #[id]
    pub file_scope_id: FileScopeId,

-    /// The node that introduces this scope.
-    #[no_eq]
-    #[return_ref]
-    pub node: NodeWithScopeKind,
-
    #[no_eq]
    count: countme::Count<ScopeId<'static>>,
 }
@@ -131,6 +127,14 @@ impl<'db> ScopeId<'db> {
        )
    }

+    pub(crate) fn node(self, db: &dyn Db) -> &NodeWithScopeKind {
+        self.scope(db).node()
+    }
+
+    pub(crate) fn scope(self, db: &dyn Db) -> &Scope {
+        semantic_index(db, self.file(db)).scope(self.file_scope_id(db))
+    }
+
    #[cfg(test)]
    pub(crate) fn name(self, db: &'db dyn Db) -> &'db str {
        match self.node(db) {
@@ -138,6 +142,11 @@ impl<'db> ScopeId<'db> {
            NodeWithScopeKind::Class(class) | NodeWithScopeKind::ClassTypeParameters(class) => {
                class.name.as_str()
            }
+            NodeWithScopeKind::TypeAliasTypeParameters(type_alias) => type_alias
+                .name
+                .as_name_expr()
+                .map(|name| name.id.as_str())
+                .unwrap_or("<type alias>"),
            NodeWithScopeKind::Function(function)
            | NodeWithScopeKind::FunctionTypeParameters(function) => function.name.as_str(),
            NodeWithScopeKind::Lambda(_) => "<lambda>",
@@ -169,10 +178,10 @@ impl FileScopeId {
    }
 }

-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug)]
 pub struct Scope {
    pub(super) parent: Option<FileScopeId>,
-    pub(super) kind: ScopeKind,
+    pub(super) node: NodeWithScopeKind,
    pub(super) descendents: Range<FileScopeId>,
 }

@@ -181,8 +190,12 @@ impl Scope {
        self.parent
    }

+    pub fn node(&self) -> &NodeWithScopeKind {
+        &self.node
+    }
+
    pub fn kind(&self) -> ScopeKind {
-        self.kind
+        self.node().scope_kind()
    }
 }

@@ -331,6 +344,7 @@ pub(crate) enum NodeWithScopeRef<'a> {
    Lambda(&'a ast::ExprLambda),
    FunctionTypeParameters(&'a ast::StmtFunctionDef),
    ClassTypeParameters(&'a ast::StmtClassDef),
+    TypeAliasTypeParameters(&'a ast::StmtTypeAlias),
    ListComprehension(&'a ast::ExprListComp),
    SetComprehension(&'a ast::ExprSetComp),
    DictComprehension(&'a ast::ExprDictComp),
@@ -352,6 +366,9 @@ impl NodeWithScopeRef<'_> {
            NodeWithScopeRef::Function(function) => {
                NodeWithScopeKind::Function(AstNodeRef::new(module, function))
            }
+            NodeWithScopeRef::TypeAliasTypeParameters(type_alias) => {
+                NodeWithScopeKind::TypeAliasTypeParameters(AstNodeRef::new(module, type_alias))
+            }
            NodeWithScopeRef::Lambda(lambda) => {
                NodeWithScopeKind::Lambda(AstNodeRef::new(module, lambda))
            }
@@ -376,21 +393,6 @@ impl NodeWithScopeRef<'_> {
        }
    }

-    pub(super) fn scope_kind(self) -> ScopeKind {
-        match self {
-            NodeWithScopeRef::Module => ScopeKind::Module,
-            NodeWithScopeRef::Class(_) => ScopeKind::Class,
-            NodeWithScopeRef::Function(_) => ScopeKind::Function,
-            NodeWithScopeRef::Lambda(_) => ScopeKind::Function,
-            NodeWithScopeRef::FunctionTypeParameters(_)
-            | NodeWithScopeRef::ClassTypeParameters(_) => ScopeKind::Annotation,
-            NodeWithScopeRef::ListComprehension(_)
-            | NodeWithScopeRef::SetComprehension(_)
-            | NodeWithScopeRef::DictComprehension(_)
-            | NodeWithScopeRef::GeneratorExpression(_) => ScopeKind::Comprehension,
-        }
-    }
-
    pub(crate) fn node_key(self) -> NodeWithScopeKey {
        match self {
            NodeWithScopeRef::Module => NodeWithScopeKey::Module,
@@ -407,6 +409,9 @@ impl NodeWithScopeRef<'_> {
            NodeWithScopeRef::ClassTypeParameters(class) => {
                NodeWithScopeKey::ClassTypeParameters(NodeKey::from_node(class))
            }
+            NodeWithScopeRef::TypeAliasTypeParameters(type_alias) => {
+                NodeWithScopeKey::TypeAliasTypeParameters(NodeKey::from_node(type_alias))
+            }
            NodeWithScopeRef::ListComprehension(comprehension) => {
                NodeWithScopeKey::ListComprehension(NodeKey::from_node(comprehension))
            }
@@ -431,6 +436,7 @@ pub enum NodeWithScopeKind {
    ClassTypeParameters(AstNodeRef<ast::StmtClassDef>),
    Function(AstNodeRef<ast::StmtFunctionDef>),
    FunctionTypeParameters(AstNodeRef<ast::StmtFunctionDef>),
+    TypeAliasTypeParameters(AstNodeRef<ast::StmtTypeAlias>),
    Lambda(AstNodeRef<ast::ExprLambda>),
    ListComprehension(AstNodeRef<ast::ExprListComp>),
    SetComprehension(AstNodeRef<ast::ExprSetComp>),
@@ -438,6 +444,38 @@ pub enum NodeWithScopeKind {
    GeneratorExpression(AstNodeRef<ast::ExprGenerator>),
 }

+impl NodeWithScopeKind {
+    pub(super) const fn scope_kind(&self) -> ScopeKind {
+        match self {
+            Self::Module => ScopeKind::Module,
+            Self::Class(_) => ScopeKind::Class,
+            Self::Function(_) => ScopeKind::Function,
+            Self::Lambda(_) => ScopeKind::Function,
+            Self::FunctionTypeParameters(_)
+            | Self::ClassTypeParameters(_)
+            | Self::TypeAliasTypeParameters(_) => ScopeKind::Annotation,
+            Self::ListComprehension(_)
+            | Self::SetComprehension(_)
+            | Self::DictComprehension(_)
+            | Self::GeneratorExpression(_) => ScopeKind::Comprehension,
+        }
+    }
+
+    pub fn expect_class(&self) -> &ast::StmtClassDef {
+        match self {
+            Self::Class(class) => class.node(),
+            _ => panic!("expected class"),
+        }
+    }
+
+    pub fn expect_function(&self) -> &ast::StmtFunctionDef {
+        match self {
+            Self::Function(function) => function.node(),
+            _ => panic!("expected function"),
+        }
+    }
+}
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
 pub(crate) enum NodeWithScopeKey {
    Module,
@@ -445,6 +483,7 @@ pub(crate) enum NodeWithScopeKey {
    ClassTypeParameters(NodeKey),
    Function(NodeKey),
    FunctionTypeParameters(NodeKey),
+    TypeAliasTypeParameters(NodeKey),
    Lambda(NodeKey),
    ListComprehension(NodeKey),
    SetComprehension(NodeKey),
--- a/crates/red_knot_python_semantic/src/semantic_index/use_def.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/use_def.rs
@@ -277,7 +277,7 @@ impl<'db> UseDefMap<'db> {

    pub(crate) fn use_boundness(&self, use_id: ScopedUseId) -> Boundness {
        if self.bindings_by_use[use_id].may_be_unbound() {
-            Boundness::MayBeUnbound
+            Boundness::PossiblyUnbound
        } else {
            Boundness::Bound
        }
@@ -292,7 +292,7 @@ impl<'db> UseDefMap<'db> {

    pub(crate) fn public_boundness(&self, symbol: ScopedSymbolId) -> Boundness {
        if self.public_symbols[symbol].may_be_unbound() {
-            Boundness::MayBeUnbound
+            Boundness::PossiblyUnbound
        } else {
            Boundness::Bound
        }
--- a/crates/red_knot_python_semantic/src/stdlib.rs
+++ b/crates/red_knot_python_semantic/src/stdlib.rs
@@ -8,34 +8,38 @@ use crate::Db;

 /// Enumeration of various core stdlib modules, for which we have dedicated Salsa queries.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum CoreStdlibModule {
+pub(crate) enum CoreStdlibModule {
    Builtins,
    Types,
-    // the Typing enum is currently only used in tests
-    #[allow(dead_code)]
-    Typing,
    Typeshed,
    TypingExtensions,
+    Typing,
+    Sys,
 }

 impl CoreStdlibModule {
-    fn name(self) -> ModuleName {
-        let module_name = match self {
+    pub(crate) const fn as_str(self) -> &'static str {
+        match self {
            Self::Builtins => "builtins",
            Self::Types => "types",
            Self::Typing => "typing",
            Self::Typeshed => "_typeshed",
            Self::TypingExtensions => "typing_extensions",
-        };
-        ModuleName::new_static(module_name)
-            .unwrap_or_else(|| panic!("{module_name} should be a valid module name!"))
+            Self::Sys => "sys",
+        }
+    }
+
+    pub(crate) fn name(self) -> ModuleName {
+        let self_as_str = self.as_str();
+        ModuleName::new_static(self_as_str)
+            .unwrap_or_else(|| panic!("{self_as_str} should be a valid module name!"))
    }
 }

 /// Lookup the type of `symbol` in a given core module
 ///
 /// Returns `Symbol::Unbound` if the given core module cannot be resolved for some reason
-fn core_module_symbol<'db>(
+pub(crate) fn core_module_symbol<'db>(
    db: &'db dyn Db,
    core_module: CoreStdlibModule,
    symbol: &str,
@@ -53,29 +57,14 @@ pub(crate) fn builtins_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db>
    core_module_symbol(db, CoreStdlibModule::Builtins, symbol)
 }

-/// Lookup the type of `symbol` in the `types` module namespace.
-///
-/// Returns `Symbol::Unbound` if the `types` module isn't available for some reason.
-#[inline]
-pub(crate) fn types_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
-    core_module_symbol(db, CoreStdlibModule::Types, symbol)
-}
-
 /// Lookup the type of `symbol` in the `typing` module namespace.
 ///
 /// Returns `Symbol::Unbound` if the `typing` module isn't available for some reason.
 #[inline]
-#[allow(dead_code)] // currently only used in tests
+#[cfg(test)]
 pub(crate) fn typing_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
    core_module_symbol(db, CoreStdlibModule::Typing, symbol)
 }
-/// Lookup the type of `symbol` in the `_typeshed` module namespace.
-///
-/// Returns `Symbol::Unbound` if the `_typeshed` module isn't available for some reason.
-#[inline]
-pub(crate) fn typeshed_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
-    core_module_symbol(db, CoreStdlibModule::Typeshed, symbol)
-}

 /// Lookup the type of `symbol` in the `typing_extensions` module namespace.
 ///
--- a/crates/red_knot_python_semantic/src/symbol.rs
+++ b/crates/red_knot_python_semantic/src/symbol.rs
@@ -3,10 +3,19 @@ use crate::{
    Db,
 };

-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum Boundness {
    Bound,
-    MayBeUnbound,
+    PossiblyUnbound,
+}
+
+impl Boundness {
+    pub(crate) fn or(self, other: Boundness) -> Boundness {
+        match (self, other) {
+            (Boundness::Bound, _) | (_, Boundness::Bound) => Boundness::Bound,
+            (Boundness::PossiblyUnbound, Boundness::PossiblyUnbound) => Boundness::PossiblyUnbound,
+        }
+    }
 }

 /// The result of a symbol lookup, which can either be a (possibly unbound) type
@@ -17,14 +26,14 @@ pub(crate) enum Boundness {
 /// bound = 1
 ///
 /// if flag:
-///     maybe_unbound = 2
+///     possibly_unbound = 2
 /// ```
 ///
 /// If we look up symbols in this scope, we would get the following results:
 /// ```rs
-/// bound:          Symbol::Type(Type::IntLiteral(1), Boundness::Bound),
-/// maybe_unbound:  Symbol::Type(Type::IntLiteral(2), Boundness::MayBeUnbound),
-/// non_existent:   Symbol::Unbound,
+/// bound:             Symbol::Type(Type::IntLiteral(1), Boundness::Bound),
+/// possibly_unbound:  Symbol::Type(Type::IntLiteral(2), Boundness::PossiblyUnbound),
+/// non_existent:      Symbol::Unbound,
 /// ```
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) enum Symbol<'db> {
@@ -37,25 +46,18 @@ impl<'db> Symbol<'db> {
        matches!(self, Symbol::Unbound)
    }

-    pub(crate) fn may_be_unbound(&self) -> bool {
+    pub(crate) fn possibly_unbound(&self) -> bool {
        match self {
-            Symbol::Type(_, Boundness::MayBeUnbound) | Symbol::Unbound => true,
+            Symbol::Type(_, Boundness::PossiblyUnbound) | Symbol::Unbound => true,
            Symbol::Type(_, Boundness::Bound) => false,
        }
    }

-    pub(crate) fn unwrap_or(&self, other: Type<'db>) -> Type<'db> {
-        match self {
-            Symbol::Type(ty, _) => *ty,
-            Symbol::Unbound => other,
-        }
-    }
-
-    pub(crate) fn unwrap_or_unknown(&self) -> Type<'db> {
-        self.unwrap_or(Type::Unknown)
-    }
-
-    pub(crate) fn as_type(&self) -> Option<Type<'db>> {
+    /// Returns the type of the symbol, ignoring possible unboundness.
+    ///
+    /// If the symbol is *definitely* unbound, this function will return `None`. Otherwise,
+    /// if there is at least one control-flow path where the symbol is bound, return the type.
+    pub(crate) fn ignore_possibly_unbound(&self) -> Option<Type<'db>> {
        match self {
            Symbol::Type(ty, _) => Some(*ty),
            Symbol::Unbound => None,
@@ -65,28 +67,80 @@ impl<'db> Symbol<'db> {
    #[cfg(test)]
    #[track_caller]
    pub(crate) fn expect_type(self) -> Type<'db> {
-        self.as_type()
+        self.ignore_possibly_unbound()
            .expect("Expected a (possibly unbound) type, not an unbound symbol")
    }

    #[must_use]
-    pub(crate) fn replace_unbound_with(
-        self,
-        db: &'db dyn Db,
-        replacement: &Symbol<'db>,
-    ) -> Symbol<'db> {
-        match replacement {
-            Symbol::Type(replacement, _) => Symbol::Type(
-                match self {
-                    Symbol::Type(ty, Boundness::Bound) => ty,
-                    Symbol::Type(ty, Boundness::MayBeUnbound) => {
-                        UnionType::from_elements(db, [*replacement, ty])
-                    }
-                    Symbol::Unbound => *replacement,
-                },
-                Boundness::Bound,
-            ),
+    pub(crate) fn or_fall_back_to(self, db: &'db dyn Db, fallback: &Symbol<'db>) -> Symbol<'db> {
+        match fallback {
+            Symbol::Type(fallback_ty, fallback_boundness) => match self {
+                Symbol::Type(_, Boundness::Bound) => self,
+                Symbol::Type(ty, boundness @ Boundness::PossiblyUnbound) => Symbol::Type(
+                    UnionType::from_elements(db, [*fallback_ty, ty]),
+                    fallback_boundness.or(boundness),
+                ),
+                Symbol::Unbound => fallback.clone(),
+            },
            Symbol::Unbound => self,
        }
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::tests::setup_db;
+
+    #[test]
+    fn test_symbol_or_fall_back_to() {
+        use Boundness::{Bound, PossiblyUnbound};
+
+        let db = setup_db();
+        let ty1 = Type::IntLiteral(1);
+        let ty2 = Type::IntLiteral(2);
+
+        // Start from an unbound symbol
+        assert_eq!(
+            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Unbound
+        );
+        assert_eq!(
+            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Type(ty1, PossiblyUnbound)),
+            Symbol::Type(ty1, PossiblyUnbound)
+        );
+        assert_eq!(
+            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Type(ty1, Bound)),
+            Symbol::Type(ty1, Bound)
+        );
+
+        // Start from a possibly unbound symbol
+        assert_eq!(
+            Symbol::Type(ty1, PossiblyUnbound).or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Type(ty1, PossiblyUnbound)
+        );
+        assert_eq!(
+            Symbol::Type(ty1, PossiblyUnbound)
+                .or_fall_back_to(&db, &Symbol::Type(ty2, PossiblyUnbound)),
+            Symbol::Type(UnionType::from_elements(&db, [ty2, ty1]), PossiblyUnbound)
+        );
+        assert_eq!(
+            Symbol::Type(ty1, PossiblyUnbound).or_fall_back_to(&db, &Symbol::Type(ty2, Bound)),
+            Symbol::Type(UnionType::from_elements(&db, [ty2, ty1]), Bound)
+        );
+
+        // Start from a definitely bound symbol
+        assert_eq!(
+            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Type(ty1, Bound)
+        );
+        assert_eq!(
+            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Type(ty2, PossiblyUnbound)),
+            Symbol::Type(ty1, Bound)
+        );
+        assert_eq!(
+            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Type(ty2, Bound)),
+            Symbol::Type(ty1, Bound)
+        );
+    }
+}
--- a/crates/red_knot_python_semantic/src/types.rs
+++ b/crates/red_knot_python_semantic/src/types.rs
--- a/crates/red_knot_python_semantic/src/types/builder.rs
+++ b/crates/red_knot_python_semantic/src/types/builder.rs
@@ -25,12 +25,11 @@
 //!   * No type in an intersection can be a supertype of any other type in the intersection (just
 //!     eliminate the supertype from the intersection).
 //!   * An intersection containing two non-overlapping types should simplify to [`Type::Never`].
-use crate::types::{IntersectionType, Type, UnionType};
+
+use crate::types::{InstanceType, IntersectionType, KnownClass, Type, UnionType};
 use crate::{Db, FxOrderSet};
 use smallvec::SmallVec;

-use super::KnownClass;
-
 pub(crate) struct UnionBuilder<'db> {
    elements: Vec<Type<'db>>,
    db: &'db dyn Db,
@@ -80,7 +79,6 @@ impl<'db> UnionBuilder<'db> {
                        to_remove.push(index);
                    }
                }
-
                match to_remove[..] {
                    [] => self.elements.push(to_add),
                    [index] => self.elements[index] = to_add,
@@ -103,7 +101,6 @@ impl<'db> UnionBuilder<'db> {
                }
            }
        }
-
        self
    }

@@ -249,8 +246,8 @@ impl<'db> InnerIntersectionBuilder<'db> {
            }
        } else {
            // ~Literal[True] & bool = Literal[False]
-            if let Type::Instance(class_type) = new_positive {
-                if class_type.is_known(db, KnownClass::Bool) {
+            if let Type::Instance(InstanceType { class }) = new_positive {
+                if class.is_known(db, KnownClass::Bool) {
                    if let Some(&Type::BooleanLiteral(value)) = self
                        .negative
                        .iter()
@@ -320,7 +317,7 @@ impl<'db> InnerIntersectionBuilder<'db> {
                // Adding any of these types to the negative side of an intersection
                // is equivalent to adding it to the positive side. We do this to
                // simplify the representation.
-                self.positive.insert(ty);
+                self.add_positive(db, ty);
            }
            // ~Literal[True] & bool = Literal[False]
            Type::BooleanLiteral(bool)
@@ -386,8 +383,9 @@ mod tests {
    use crate::program::{Program, SearchPathSettings};
    use crate::python_version::PythonVersion;
    use crate::stdlib::typing_symbol;
-    use crate::types::{KnownClass, StringLiteralType, UnionBuilder};
+    use crate::types::{global_symbol, KnownClass, UnionBuilder};
    use crate::ProgramSettings;
+    use ruff_db::files::system_path_to_file;
    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
    use test_case::test_case;

@@ -594,6 +592,22 @@ mod tests {
        assert_eq!(ta_not_i0.display(&db).to_string(), "int & Any | Literal[1]");
    }

+    #[test]
+    fn build_intersection_simplify_negative_any() {
+        let db = setup_db();
+
+        let ty = IntersectionBuilder::new(&db)
+            .add_negative(Type::Any)
+            .build();
+        assert_eq!(ty, Type::Any);
+
+        let ty = IntersectionBuilder::new(&db)
+            .add_positive(Type::Never)
+            .add_negative(Type::Any)
+            .build();
+        assert_eq!(ty, Type::Never);
+    }
+
    #[test]
    fn intersection_distributes_over_union() {
        let db = setup_db();
@@ -675,8 +689,8 @@ mod tests {
    fn build_intersection_self_negation() {
        let db = setup_db();
        let ty = IntersectionBuilder::new(&db)
-            .add_positive(Type::None)
-            .add_negative(Type::None)
+            .add_positive(Type::none(&db))
+            .add_negative(Type::none(&db))
            .build();

        assert_eq!(ty, Type::Never);
@@ -686,18 +700,18 @@ mod tests {
    fn build_intersection_simplify_negative_never() {
        let db = setup_db();
        let ty = IntersectionBuilder::new(&db)
-            .add_positive(Type::None)
+            .add_positive(Type::none(&db))
            .add_negative(Type::Never)
            .build();

-        assert_eq!(ty, Type::None);
+        assert_eq!(ty, Type::none(&db));
    }

    #[test]
    fn build_intersection_simplify_positive_never() {
        let db = setup_db();
        let ty = IntersectionBuilder::new(&db)
-            .add_positive(Type::None)
+            .add_positive(Type::none(&db))
            .add_positive(Type::Never)
            .build();

@@ -709,14 +723,14 @@ mod tests {
        let db = setup_db();

        let ty = IntersectionBuilder::new(&db)
-            .add_negative(Type::None)
+            .add_negative(Type::none(&db))
            .add_positive(Type::IntLiteral(1))
            .build();
        assert_eq!(ty, Type::IntLiteral(1));

        let ty = IntersectionBuilder::new(&db)
            .add_positive(Type::IntLiteral(1))
-            .add_negative(Type::None)
+            .add_negative(Type::none(&db))
            .build();
        assert_eq!(ty, Type::IntLiteral(1));
    }
@@ -761,7 +775,7 @@ mod tests {
            .build();
        assert_eq!(ty, s);

-        let literal = Type::StringLiteral(StringLiteralType::new(&db, "a"));
+        let literal = Type::string_literal(&db, "a");
        let expected = IntersectionBuilder::new(&db)
            .add_positive(s)
            .add_negative(literal)
@@ -864,7 +878,7 @@ mod tests {

        let ty = IntersectionBuilder::new(&db)
            .add_positive(s)
-            .add_negative(Type::StringLiteral(StringLiteralType::new(&db, "a")))
+            .add_negative(Type::string_literal(&db, "a"))
            .add_negative(t)
            .build();
        assert_eq!(ty, Type::Never);
@@ -875,7 +889,7 @@ mod tests {
        let db = setup_db();

        let t1 = Type::IntLiteral(1);
-        let t2 = Type::None;
+        let t2 = Type::none(&db);

        let ty = IntersectionBuilder::new(&db)
            .add_positive(t1)
@@ -898,7 +912,7 @@ mod tests {
        let db = setup_db();

        let t_p = KnownClass::Int.to_instance(&db);
-        let t_n = Type::StringLiteral(StringLiteralType::new(&db, "t_n"));
+        let t_n = Type::string_literal(&db, "t_n");

        let ty = IntersectionBuilder::new(&db)
            .add_positive(t_p)
@@ -993,4 +1007,66 @@ mod tests {
            .build();
        assert_eq!(result, ty);
    }
+
+    #[test]
+    fn build_intersection_of_two_unions_simplify() {
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/module.py",
+            "
+            class A: ...
+            class B: ...
+            a = A()
+            b = B()
+        ",
+        )
+        .unwrap();
+
+        let file = system_path_to_file(&db, "src/module.py").expect("file to exist");
+
+        let a = global_symbol(&db, file, "a").expect_type();
+        let b = global_symbol(&db, file, "b").expect_type();
+        let union = UnionBuilder::new(&db).add(a).add(b).build();
+        assert_eq!(union.display(&db).to_string(), "A | B");
+        let reversed_union = UnionBuilder::new(&db).add(b).add(a).build();
+        assert_eq!(reversed_union.display(&db).to_string(), "B | A");
+        let intersection = IntersectionBuilder::new(&db)
+            .add_positive(union)
+            .add_positive(reversed_union)
+            .build();
+        assert_eq!(intersection.display(&db).to_string(), "B | A");
+    }
+
+    #[test]
+    fn build_union_of_two_intersections_simplify() {
+        let mut db = setup_db();
+        db.write_dedented(
+            "/src/module.py",
+            "
+            class A: ...
+            class B: ...
+            a = A()
+            b = B()
+        ",
+        )
+        .unwrap();
+
+        let file = system_path_to_file(&db, "src/module.py").expect("file to exist");
+
+        let a = global_symbol(&db, file, "a").expect_type();
+        let b = global_symbol(&db, file, "b").expect_type();
+        let intersection = IntersectionBuilder::new(&db)
+            .add_positive(a)
+            .add_positive(b)
+            .build();
+        let reversed_intersection = IntersectionBuilder::new(&db)
+            .add_positive(b)
+            .add_positive(a)
+            .build();
+        let union = UnionBuilder::new(&db)
+            .add(intersection)
+            .add(reversed_intersection)
+            .build();
+        assert_eq!(union.display(&db).to_string(), "A & B");
+    }
 }
--- a/crates/red_knot_python_semantic/src/types/diagnostic.rs
+++ b/crates/red_knot_python_semantic/src/types/diagnostic.rs
@@ -1,14 +1,15 @@
+use crate::types::{ClassLiteralType, Type};
+use crate::Db;
+use ruff_db::diagnostic::{Diagnostic, Severity};
 use ruff_db::files::File;
 use ruff_python_ast::{self as ast, AnyNodeRef};
 use ruff_text_size::{Ranged, TextRange};
+use std::borrow::Cow;
 use std::fmt::Formatter;
 use std::ops::Deref;
 use std::sync::Arc;

-use crate::types::Type;
-use crate::Db;
-
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug, Eq, PartialEq, Clone)]
 pub struct TypeCheckDiagnostic {
    // TODO: Don't use string keys for rules
    pub(super) rule: String,
@@ -31,6 +32,28 @@ impl TypeCheckDiagnostic {
    }
 }

+impl Diagnostic for TypeCheckDiagnostic {
+    fn rule(&self) -> &str {
+        TypeCheckDiagnostic::rule(self)
+    }
+
+    fn message(&self) -> Cow<str> {
+        TypeCheckDiagnostic::message(self).into()
+    }
+
+    fn file(&self) -> File {
+        TypeCheckDiagnostic::file(self)
+    }
+
+    fn range(&self) -> Option<TextRange> {
+        Some(Ranged::range(self))
+    }
+
+    fn severity(&self) -> Severity {
+        Severity::Error
+    }
+}
+
 impl Ranged for TypeCheckDiagnostic {
    fn range(&self) -> TextRange {
        self.range
@@ -141,6 +164,23 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
        );
    }

+    /// Emit a diagnostic declaring that the object represented by `node` is not iterable
+    /// because its `__iter__` method is possibly unbound.
+    pub(super) fn add_not_iterable_possibly_unbound(
+        &mut self,
+        node: AnyNodeRef,
+        element_ty: Type<'db>,
+    ) {
+        self.add(
+            node,
+            "not-iterable",
+            format_args!(
+                "Object of type `{}` is not iterable because its `__iter__` method is possibly unbound",
+                element_ty.display(self.db)
+            ),
+        );
+    }
+
    /// Emit a diagnostic declaring that an index is out of bounds for a tuple.
    pub(super) fn add_index_out_of_bounds(
        &mut self,
@@ -209,7 +249,7 @@ impl<'db> TypeCheckDiagnosticsBuilder<'db> {
        assigned_ty: Type<'db>,
    ) {
        match declared_ty {
-            Type::ClassLiteral(class) => {
+            Type::ClassLiteral(ClassLiteralType { class }) => {
                self.add(node, "invalid-assignment", format_args!(
                        "Implicit shadowing of class `{}`; annotate to make it explicit if this is intentional",
                        class.name(self.db)));
--- a/crates/red_knot_python_semantic/src/types/display.rs
+++ b/crates/red_knot_python_semantic/src/types/display.rs
@@ -6,7 +6,9 @@ use ruff_db::display::FormatterJoinExtension;
 use ruff_python_ast::str::Quote;
 use ruff_python_literal::escape::AsciiEscape;

-use crate::types::{IntersectionType, Type, UnionType};
+use crate::types::{
+    ClassLiteralType, InstanceType, IntersectionType, KnownClass, SubclassOfType, Type, UnionType,
+};
 use crate::Db;
 use rustc_hash::FxHashMap;

@@ -64,7 +66,14 @@ impl Display for DisplayRepresentation<'_> {
            Type::Any => f.write_str("Any"),
            Type::Never => f.write_str("Never"),
            Type::Unknown => f.write_str("Unknown"),
-            Type::None => f.write_str("None"),
+            Type::Instance(InstanceType { class }) => {
+                let representation = match class.known(self.db) {
+                    Some(KnownClass::NoneType) => "None",
+                    Some(KnownClass::NoDefaultType) => "NoDefault",
+                    _ => class.name(self.db),
+                };
+                f.write_str(representation)
+            }
            // `[Type::Todo]`'s display should be explicit that is not a valid display of
            // any other type
            Type::Todo => f.write_str("@Todo"),
@@ -72,8 +81,11 @@ impl Display for DisplayRepresentation<'_> {
                write!(f, "<module '{:?}'>", file.path(self.db))
            }
            // TODO functions and classes should display using a fully qualified name
-            Type::ClassLiteral(class) => f.write_str(class.name(self.db)),
-            Type::Instance(class) => f.write_str(class.name(self.db)),
+            Type::ClassLiteral(ClassLiteralType { class }) => f.write_str(class.name(self.db)),
+            Type::SubclassOf(SubclassOfType { class }) => {
+                write!(f, "type[{}]", class.name(self.db))
+            }
+            Type::KnownInstance(known_instance) => f.write_str(known_instance.as_str()),
            Type::FunctionLiteral(function) => f.write_str(function.name(self.db)),
            Type::Union(union) => union.display(self.db).fmt(f),
            Type::Intersection(intersection) => intersection.display(self.db).fmt(f),
@@ -322,9 +334,7 @@ mod tests {
    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};

    use crate::db::tests::TestDb;
-    use crate::types::{
-        global_symbol, BytesLiteralType, SliceLiteralType, StringLiteralType, Type, UnionType,
-    };
+    use crate::types::{global_symbol, SliceLiteralType, Type, UnionType};
    use crate::{Program, ProgramSettings, PythonVersion, SearchPathSettings};

    fn setup_db() -> TestDb {
@@ -370,17 +380,17 @@ mod tests {
            Type::Unknown,
            Type::IntLiteral(-1),
            global_symbol(&db, mod_file, "A").expect_type(),
-            Type::StringLiteral(StringLiteralType::new(&db, "A")),
-            Type::BytesLiteral(BytesLiteralType::new(&db, [0u8].as_slice())),
-            Type::BytesLiteral(BytesLiteralType::new(&db, [7u8].as_slice())),
+            Type::string_literal(&db, "A"),
+            Type::bytes_literal(&db, &[0u8]),
+            Type::bytes_literal(&db, &[7u8]),
            Type::IntLiteral(0),
            Type::IntLiteral(1),
-            Type::StringLiteral(StringLiteralType::new(&db, "B")),
+            Type::string_literal(&db, "B"),
            global_symbol(&db, mod_file, "foo").expect_type(),
            global_symbol(&db, mod_file, "bar").expect_type(),
            global_symbol(&db, mod_file, "B").expect_type(),
            Type::BooleanLiteral(true),
-            Type::None,
+            Type::none(&db),
        ];
        let union = UnionType::from_elements(&db, union_elements).expect_union();
        let display = format!("{}", union.display(&db));
--- a/crates/red_knot_python_semantic/src/types/infer.rs
+++ b/crates/red_knot_python_semantic/src/types/infer.rs
--- a/crates/red_knot_python_semantic/src/types/mro.rs
+++ b/crates/red_knot_python_semantic/src/types/mro.rs
@@ -0,0 +1,454 @@
+use std::collections::VecDeque;
+use std::ops::Deref;
+
+use itertools::Either;
+use rustc_hash::FxHashSet;
+
+use super::{Class, ClassLiteralType, KnownClass, KnownInstanceType, Type};
+use crate::Db;
+
+/// The inferred method resolution order of a given class.
+///
+/// See [`Class::iter_mro`] for more details.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub(super) struct Mro<'db>(Box<[ClassBase<'db>]>);
+
+impl<'db> Mro<'db> {
+    /// Attempt to resolve the MRO of a given class
+    ///
+    /// In the event that a possible list of bases would (or could) lead to a
+    /// `TypeError` being raised at runtime due to an unresolvable MRO, we infer
+    /// the MRO of the class as being `[<the class in question>, Unknown, object]`.
+    /// This seems most likely to reduce the possibility of cascading errors
+    /// elsewhere.
+    ///
+    /// (We emit a diagnostic warning about the runtime `TypeError` in
+    /// [`super::infer::TypeInferenceBuilder::infer_region_scope`].)
+    pub(super) fn of_class(db: &'db dyn Db, class: Class<'db>) -> Result<Self, MroError<'db>> {
+        Self::of_class_impl(db, class).map_err(|error_kind| MroError {
+            kind: error_kind,
+            fallback_mro: Self::from_error(db, class),
+        })
+    }
+
+    pub(super) fn from_error(db: &'db dyn Db, class: Class<'db>) -> Self {
+        Self::from([
+            ClassBase::Class(class),
+            ClassBase::Unknown,
+            ClassBase::object(db),
+        ])
+    }
+
+    fn of_class_impl(db: &'db dyn Db, class: Class<'db>) -> Result<Self, MroErrorKind<'db>> {
+        let class_bases = class.explicit_bases(db);
+
+        if !class_bases.is_empty() && class.is_cyclically_defined(db) {
+            // We emit errors for cyclically defined classes elsewhere.
+            // It's important that we don't even try to infer the MRO for a cyclically defined class,
+            // or we'll end up in an infinite loop.
+            return Ok(Mro::from_error(db, class));
+        }
+
+        match class_bases {
+            // `builtins.object` is the special case:
+            // the only class in Python that has an MRO with length <2
+            [] if class.is_known(db, KnownClass::Object) => {
+                Ok(Self::from([ClassBase::Class(class)]))
+            }
+
+            // All other classes in Python have an MRO with length >=2.
+            // Even if a class has no explicit base classes,
+            // it will implicitly inherit from `object` at runtime;
+            // `object` will appear in the class's `__bases__` list and `__mro__`:
+            //
+            // ```pycon
+            // >>> class Foo: ...
+            // ...
+            // >>> Foo.__bases__
+            // (<class 'object'>,)
+            // >>> Foo.__mro__
+            // (<class '__main__.Foo'>, <class 'object'>)
+            // ```
+            [] => Ok(Self::from([ClassBase::Class(class), ClassBase::object(db)])),
+
+            // Fast path for a class that has only a single explicit base.
+            //
+            // This *could* theoretically be handled by the final branch below,
+            // but it's a common case (i.e., worth optimizing for),
+            // and the `c3_merge` function requires lots of allocations.
+            [single_base] => {
+                let single_base = ClassBase::try_from_ty(*single_base).ok_or(*single_base);
+                single_base.map_or_else(
+                    |invalid_base_ty| {
+                        let bases_info = Box::from([(0, invalid_base_ty)]);
+                        Err(MroErrorKind::InvalidBases(bases_info))
+                    },
+                    |single_base| {
+                        let mro = std::iter::once(ClassBase::Class(class))
+                            .chain(single_base.mro(db))
+                            .collect();
+                        Ok(mro)
+                    },
+                )
+            }
+
+            // The class has multiple explicit bases.
+            //
+            // We'll fallback to a full implementation of the C3-merge algorithm to determine
+            // what MRO Python will give this class at runtime
+            // (if an MRO is indeed resolvable at all!)
+            multiple_bases => {
+                let mut valid_bases = vec![];
+                let mut invalid_bases = vec![];
+
+                for (i, base) in multiple_bases.iter().enumerate() {
+                    match ClassBase::try_from_ty(*base).ok_or(*base) {
+                        Ok(valid_base) => valid_bases.push(valid_base),
+                        Err(invalid_base) => invalid_bases.push((i, invalid_base)),
+                    }
+                }
+
+                if !invalid_bases.is_empty() {
+                    return Err(MroErrorKind::InvalidBases(invalid_bases.into_boxed_slice()));
+                }
+
+                let mut seqs = vec![VecDeque::from([ClassBase::Class(class)])];
+                for base in &valid_bases {
+                    seqs.push(base.mro(db).collect());
+                }
+                seqs.push(valid_bases.iter().copied().collect());
+
+                c3_merge(seqs).ok_or_else(|| {
+                    let mut seen_bases = FxHashSet::default();
+                    let mut duplicate_bases = vec![];
+                    for (index, base) in valid_bases
+                        .iter()
+                        .enumerate()
+                        .filter_map(|(index, base)| Some((index, base.into_class_literal_type()?)))
+                    {
+                        if !seen_bases.insert(base) {
+                            duplicate_bases.push((index, base));
+                        }
+                    }
+
+                    if duplicate_bases.is_empty() {
+                        MroErrorKind::UnresolvableMro {
+                            bases_list: valid_bases.into_boxed_slice(),
+                        }
+                    } else {
+                        MroErrorKind::DuplicateBases(duplicate_bases.into_boxed_slice())
+                    }
+                })
+            }
+        }
+    }
+}
+
+impl<'db, const N: usize> From<[ClassBase<'db>; N]> for Mro<'db> {
+    fn from(value: [ClassBase<'db>; N]) -> Self {
+        Self(Box::from(value))
+    }
+}
+
+impl<'db> From<Vec<ClassBase<'db>>> for Mro<'db> {
+    fn from(value: Vec<ClassBase<'db>>) -> Self {
+        Self(value.into_boxed_slice())
+    }
+}
+
+impl<'db> Deref for Mro<'db> {
+    type Target = [ClassBase<'db>];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<'db> FromIterator<ClassBase<'db>> for Mro<'db> {
+    fn from_iter<T: IntoIterator<Item = ClassBase<'db>>>(iter: T) -> Self {
+        Self(iter.into_iter().collect())
+    }
+}
+
+/// Iterator that yields elements of a class's MRO.
+///
+/// We avoid materialising the *full* MRO unless it is actually necessary:
+/// - Materialising the full MRO is expensive
+/// - We need to do it for every class in the code that we're checking, as we need to make sure
+///   that there are no class definitions in the code we're checking that would cause an
+///   exception to be raised at runtime. But the same does *not* necessarily apply for every class
+///   in third-party and stdlib dependencies: we never emit diagnostics about non-first-party code.
+/// - However, we *do* need to resolve attribute accesses on classes/instances from
+///   third-party and stdlib dependencies. That requires iterating over the MRO of third-party/stdlib
+///   classes, but not necessarily the *whole* MRO: often just the first element is enough.
+///   Luckily we know that for any class `X`, the first element of `X`'s MRO will always be `X` itself.
+///   We can therefore avoid resolving the full MRO for many third-party/stdlib classes while still
+///   being faithful to the runtime semantics.
+///
+/// Even for first-party code, where we will have to resolve the MRO for every class we encounter,
+/// loading the cached MRO comes with a certain amount of overhead, so it's best to avoid calling the
+/// Salsa-tracked [`Class::try_mro`] method unless it's absolutely necessary.
+pub(super) struct MroIterator<'db> {
+    db: &'db dyn Db,
+
+    /// The class whose MRO we're iterating over
+    class: Class<'db>,
+
+    /// Whether or not we've already yielded the first element of the MRO
+    first_element_yielded: bool,
+
+    /// Iterator over all elements of the MRO except the first.
+    ///
+    /// The full MRO is expensive to materialize, so this field is `None`
+    /// unless we actually *need* to iterate past the first element of the MRO,
+    /// at which point it is lazily materialized.
+    subsequent_elements: Option<std::slice::Iter<'db, ClassBase<'db>>>,
+}
+
+impl<'db> MroIterator<'db> {
+    pub(super) fn new(db: &'db dyn Db, class: Class<'db>) -> Self {
+        Self {
+            db,
+            class,
+            first_element_yielded: false,
+            subsequent_elements: None,
+        }
+    }
+
+    /// Materialize the full MRO of the class.
+    /// Return an iterator over that MRO which skips the first element of the MRO.
+    fn full_mro_except_first_element(&mut self) -> impl Iterator<Item = ClassBase<'db>> + '_ {
+        self.subsequent_elements
+            .get_or_insert_with(|| {
+                let mut full_mro_iter = match self.class.try_mro(self.db) {
+                    Ok(mro) => mro.iter(),
+                    Err(error) => error.fallback_mro().iter(),
+                };
+                full_mro_iter.next();
+                full_mro_iter
+            })
+            .copied()
+    }
+}
+
+impl<'db> Iterator for MroIterator<'db> {
+    type Item = ClassBase<'db>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if !self.first_element_yielded {
+            self.first_element_yielded = true;
+            return Some(ClassBase::Class(self.class));
+        }
+        self.full_mro_except_first_element().next()
+    }
+}
+
+impl std::iter::FusedIterator for MroIterator<'_> {}
+
+#[derive(Debug, PartialEq, Eq)]
+pub(super) struct MroError<'db> {
+    kind: MroErrorKind<'db>,
+    fallback_mro: Mro<'db>,
+}
+
+impl<'db> MroError<'db> {
+    /// Return an [`MroErrorKind`] variant describing why we could not resolve the MRO for this class.
+    pub(super) fn reason(&self) -> &MroErrorKind<'db> {
+        &self.kind
+    }
+
+    /// Return the fallback MRO we should infer for this class during type inference
+    /// (since accurate resolution of its "true" MRO was impossible)
+    pub(super) fn fallback_mro(&self) -> &Mro<'db> {
+        &self.fallback_mro
+    }
+}
+
+/// Possible ways in which attempting to resolve the MRO of a class might fail.
+#[derive(Debug, PartialEq, Eq)]
+pub(super) enum MroErrorKind<'db> {
+    /// The class inherits from one or more invalid bases.
+    ///
+    /// To avoid excessive complexity in our implementation,
+    /// we only permit classes to inherit from class-literal types,
+    /// `Todo`, `Unknown` or `Any`. Anything else results in us
+    /// emitting a diagnostic.
+    ///
+    /// This variant records the indices and types of class bases
+    /// that we deem to be invalid. The indices are the indices of nodes
+    /// in the bases list of the class's [`StmtClassDef`](ruff_python_ast::StmtClassDef) node.
+    /// Each index is the index of a node representing an invalid base.
+    InvalidBases(Box<[(usize, Type<'db>)]>),
+
+    /// The class has one or more duplicate bases.
+    ///
+    /// This variant records the indices and [`Class`]es
+    /// of the duplicate bases. The indices are the indices of nodes
+    /// in the bases list of the class's [`StmtClassDef`](ruff_python_ast::StmtClassDef) node.
+    /// Each index is the index of a node representing a duplicate base.
+    DuplicateBases(Box<[(usize, Class<'db>)]>),
+
+    /// The MRO is otherwise unresolvable through the C3-merge algorithm.
+    ///
+    /// See [`c3_merge`] for more details.
+    UnresolvableMro { bases_list: Box<[ClassBase<'db>]> },
+}
+
+/// Enumeration of the possible kinds of types we allow in class bases.
+///
+/// This is much more limited than the [`Type`] enum:
+/// all types that would be invalid to have as a class base are
+/// transformed into [`ClassBase::Unknown`]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub(super) enum ClassBase<'db> {
+    Any,
+    Unknown,
+    Todo,
+    Class(Class<'db>),
+}
+
+impl<'db> ClassBase<'db> {
+    pub(super) fn display(self, db: &'db dyn Db) -> impl std::fmt::Display + 'db {
+        struct Display<'db> {
+            base: ClassBase<'db>,
+            db: &'db dyn Db,
+        }
+
+        impl std::fmt::Display for Display<'_> {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                match self.base {
+                    ClassBase::Any => f.write_str("Any"),
+                    ClassBase::Todo => f.write_str("Todo"),
+                    ClassBase::Unknown => f.write_str("Unknown"),
+                    ClassBase::Class(class) => write!(f, "<class '{}'>", class.name(self.db)),
+                }
+            }
+        }
+
+        Display { base: self, db }
+    }
+
+    #[cfg(test)]
+    #[track_caller]
+    pub(super) fn expect_class_base(self) -> Class<'db> {
+        match self {
+            ClassBase::Class(class) => class,
+            _ => panic!("Expected a `ClassBase::Class()` variant"),
+        }
+    }
+
+    /// Return a `ClassBase` representing the class `builtins.object`
+    fn object(db: &'db dyn Db) -> Self {
+        KnownClass::Object
+            .to_class_literal(db)
+            .into_class_literal()
+            .map_or(Self::Unknown, |ClassLiteralType { class }| {
+                Self::Class(class)
+            })
+    }
+
+    /// Attempt to resolve `ty` into a `ClassBase`.
+    ///
+    /// Return `None` if `ty` is not an acceptable type for a class base.
+    fn try_from_ty(ty: Type<'db>) -> Option<Self> {
+        match ty {
+            Type::Any => Some(Self::Any),
+            Type::Unknown => Some(Self::Unknown),
+            Type::Todo => Some(Self::Todo),
+            Type::ClassLiteral(ClassLiteralType { class }) => Some(Self::Class(class)),
+            Type::Union(_) => None, // TODO -- forces consideration of multiple possible MROs?
+            Type::Intersection(_) => None, // TODO -- probably incorrect?
+            Type::Instance(_) => None, // TODO -- handle `__mro_entries__`?
+            Type::Never
+            | Type::BooleanLiteral(_)
+            | Type::FunctionLiteral(_)
+            | Type::BytesLiteral(_)
+            | Type::IntLiteral(_)
+            | Type::StringLiteral(_)
+            | Type::LiteralString
+            | Type::Tuple(_)
+            | Type::SliceLiteral(_)
+            | Type::ModuleLiteral(_)
+            | Type::SubclassOf(_) => None,
+            Type::KnownInstance(known_instance) => match known_instance {
+                KnownInstanceType::Literal => None,
+                KnownInstanceType::TypeVar(_) => None,
+            },
+        }
+    }
+
+    fn into_class_literal_type(self) -> Option<Class<'db>> {
+        match self {
+            Self::Class(class) => Some(class),
+            _ => None,
+        }
+    }
+
+    /// Iterate over the MRO of this base
+    fn mro(
+        self,
+        db: &'db dyn Db,
+    ) -> Either<impl Iterator<Item = ClassBase<'db>>, impl Iterator<Item = ClassBase<'db>>> {
+        match self {
+            ClassBase::Any => Either::Left([ClassBase::Any, ClassBase::object(db)].into_iter()),
+            ClassBase::Unknown => {
+                Either::Left([ClassBase::Unknown, ClassBase::object(db)].into_iter())
+            }
+            ClassBase::Todo => Either::Left([ClassBase::Todo, ClassBase::object(db)].into_iter()),
+            ClassBase::Class(class) => Either::Right(class.iter_mro(db)),
+        }
+    }
+}
+
+impl<'db> From<ClassBase<'db>> for Type<'db> {
+    fn from(value: ClassBase<'db>) -> Self {
+        match value {
+            ClassBase::Any => Type::Any,
+            ClassBase::Todo => Type::Todo,
+            ClassBase::Unknown => Type::Unknown,
+            ClassBase::Class(class) => Type::class_literal(class),
+        }
+    }
+}
+
+/// Implementation of the [C3-merge algorithm] for calculating a Python class's
+/// [method resolution order].
+///
+/// [C3-merge algorithm]: https://docs.python.org/3/howto/mro.html#python-2-3-mro
+/// [method resolution order]: https://docs.python.org/3/glossary.html#term-method-resolution-order
+fn c3_merge(mut sequences: Vec<VecDeque<ClassBase>>) -> Option<Mro> {
+    // Most MROs aren't that long...
+    let mut mro = Vec::with_capacity(8);
+
+    loop {
+        sequences.retain(|sequence| !sequence.is_empty());
+
+        if sequences.is_empty() {
+            return Some(Mro::from(mro));
+        }
+
+        // If the candidate exists "deeper down" in the inheritance hierarchy,
+        // we should refrain from adding it to the MRO for now. Add the first candidate
+        // for which this does not hold true. If this holds true for all candidates,
+        // return `None`; it will be impossible to find a consistent MRO for the class
+        // with the given bases.
+        let mro_entry = sequences.iter().find_map(|outer_sequence| {
+            let candidate = outer_sequence[0];
+
+            let not_head = sequences
+                .iter()
+                .all(|sequence| sequence.iter().skip(1).all(|base| base != &candidate));
+
+            not_head.then_some(candidate)
+        })?;
+
+        mro.push(mro_entry);
+
+        // Make sure we don't try to add the candidate to the MRO twice:
+        for sequence in &mut sequences {
+            if sequence[0] == mro_entry {
+                sequence.pop_front();
+            }
+        }
+    }
+}
--- a/crates/red_knot_python_semantic/src/types/narrow.rs
+++ b/crates/red_knot_python_semantic/src/types/narrow.rs
@@ -5,12 +5,15 @@ use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{ScopeId, ScopedSymbolId, SymbolTable};
 use crate::semantic_index::symbol_table;
 use crate::types::{
-    infer_expression_types, IntersectionBuilder, KnownFunction, Type, UnionBuilder,
+    infer_expression_types, ClassLiteralType, IntersectionBuilder, KnownClass,
+    KnownConstraintFunction, KnownFunction, Truthiness, Type, UnionBuilder,
 };
 use crate::Db;
 use itertools::Itertools;
 use ruff_python_ast as ast;
+use ruff_python_ast::{BoolOp, ExprBoolOp};
 use rustc_hash::FxHashMap;
+use std::collections::hash_map::Entry;
 use std::sync::Arc;

 /// Return the type constraint that `test` (if true) would place on `definition`, if any.
@@ -34,21 +37,20 @@ pub(crate) fn narrowing_constraint<'db>(
    constraint: Constraint<'db>,
    definition: Definition<'db>,
 ) -> Option<Type<'db>> {
-    match constraint.node {
+    let constraints = match constraint.node {
        ConstraintNode::Expression(expression) => {
            if constraint.is_positive {
                all_narrowing_constraints_for_expression(db, expression)
-                    .get(&definition.symbol(db))
-                    .copied()
            } else {
                all_negative_narrowing_constraints_for_expression(db, expression)
-                    .get(&definition.symbol(db))
-                    .copied()
            }
        }
-        ConstraintNode::Pattern(pattern) => all_narrowing_constraints_for_pattern(db, pattern)
-            .get(&definition.symbol(db))
-            .copied(),
+        ConstraintNode::Pattern(pattern) => all_narrowing_constraints_for_pattern(db, pattern),
+    };
+    if let Some(constraints) = constraints {
+        constraints.get(&definition.symbol(db)).copied()
+    } else {
+        None
    }
 }

@@ -56,7 +58,7 @@ pub(crate) fn narrowing_constraint<'db>(
 fn all_narrowing_constraints_for_pattern<'db>(
    db: &'db dyn Db,
    pattern: PatternConstraint<'db>,
-) -> NarrowingConstraints<'db> {
+) -> Option<NarrowingConstraints<'db>> {
    NarrowingConstraintsBuilder::new(db, ConstraintNode::Pattern(pattern), true).finish()
 }

@@ -64,7 +66,7 @@ fn all_narrowing_constraints_for_pattern<'db>(
 fn all_narrowing_constraints_for_expression<'db>(
    db: &'db dyn Db,
    expression: Expression<'db>,
-) -> NarrowingConstraints<'db> {
+) -> Option<NarrowingConstraints<'db>> {
    NarrowingConstraintsBuilder::new(db, ConstraintNode::Expression(expression), true).finish()
 }

@@ -72,39 +74,83 @@ fn all_narrowing_constraints_for_expression<'db>(
 fn all_negative_narrowing_constraints_for_expression<'db>(
    db: &'db dyn Db,
    expression: Expression<'db>,
-) -> NarrowingConstraints<'db> {
+) -> Option<NarrowingConstraints<'db>> {
    NarrowingConstraintsBuilder::new(db, ConstraintNode::Expression(expression), false).finish()
 }

-/// Generate a constraint from the *type* of the second argument of an `isinstance` call.
+/// Generate a constraint from the type of a `classinfo` argument to `isinstance` or `issubclass`.
 ///
-/// Example: for `isinstance(…, str)`, we would infer `Type::ClassLiteral(str)` from the
-/// second argument, but we need to generate a `Type::Instance(str)` constraint that can
-/// be used to narrow down the type of the first argument.
-fn generate_isinstance_constraint<'db>(
+/// The `classinfo` argument can be a class literal, a tuple of (tuples of) class literals. PEP 604
+/// union types are not yet supported. Returns `None` if the `classinfo` argument has a wrong type.
+fn generate_classinfo_constraint<'db, F>(
    db: &'db dyn Db,
    classinfo: &Type<'db>,
-) -> Option<Type<'db>> {
+    to_constraint: F,
+) -> Option<Type<'db>>
+where
+    F: Fn(ClassLiteralType<'db>) -> Type<'db> + Copy,
+{
    match classinfo {
-        Type::ClassLiteral(class) => Some(Type::Instance(*class)),
        Type::Tuple(tuple) => {
            let mut builder = UnionBuilder::new(db);
            for element in tuple.elements(db) {
-                builder = builder.add(generate_isinstance_constraint(db, element)?);
+                builder = builder.add(generate_classinfo_constraint(db, element, to_constraint)?);
            }
            Some(builder.build())
        }
+        Type::ClassLiteral(class_literal_type) => Some(to_constraint(*class_literal_type)),
        _ => None,
    }
 }

 type NarrowingConstraints<'db> = FxHashMap<ScopedSymbolId, Type<'db>>;

+fn merge_constraints_and<'db>(
+    into: &mut NarrowingConstraints<'db>,
+    from: NarrowingConstraints<'db>,
+    db: &'db dyn Db,
+) {
+    for (key, value) in from {
+        match into.entry(key) {
+            Entry::Occupied(mut entry) => {
+                *entry.get_mut() = IntersectionBuilder::new(db)
+                    .add_positive(*entry.get())
+                    .add_positive(value)
+                    .build();
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(value);
+            }
+        }
+    }
+}
+
+fn merge_constraints_or<'db>(
+    into: &mut NarrowingConstraints<'db>,
+    from: &NarrowingConstraints<'db>,
+    db: &'db dyn Db,
+) {
+    for (key, value) in from {
+        match into.entry(*key) {
+            Entry::Occupied(mut entry) => {
+                *entry.get_mut() = UnionBuilder::new(db).add(*entry.get()).add(*value).build();
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(KnownClass::Object.to_instance(db));
+            }
+        }
+    }
+    for (key, value) in into.iter_mut() {
+        if !from.contains_key(key) {
+            *value = KnownClass::Object.to_instance(db);
+        }
+    }
+}
+
 struct NarrowingConstraintsBuilder<'db> {
    db: &'db dyn Db,
    constraint: ConstraintNode<'db>,
    is_positive: bool,
-    constraints: NarrowingConstraints<'db>,
 }

 impl<'db> NarrowingConstraintsBuilder<'db> {
@@ -113,24 +159,31 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
            db,
            constraint,
            is_positive,
-            constraints: NarrowingConstraints::default(),
        }
    }

-    fn finish(mut self) -> NarrowingConstraints<'db> {
-        match self.constraint {
+    fn finish(mut self) -> Option<NarrowingConstraints<'db>> {
+        let constraints: Option<NarrowingConstraints<'db>> = match self.constraint {
            ConstraintNode::Expression(expression) => {
-                self.evaluate_expression_constraint(expression, self.is_positive);
+                self.evaluate_expression_constraint(expression, self.is_positive)
            }
            ConstraintNode::Pattern(pattern) => self.evaluate_pattern_constraint(pattern),
+        };
+        if let Some(mut constraints) = constraints {
+            constraints.shrink_to_fit();
+            Some(constraints)
+        } else {
+            None
        }
-        self.constraints.shrink_to_fit();
-        self.constraints
    }

-    fn evaluate_expression_constraint(&mut self, expression: Expression<'db>, is_positive: bool) {
+    fn evaluate_expression_constraint(
+        &mut self,
+        expression: Expression<'db>,
+        is_positive: bool,
+    ) -> Option<NarrowingConstraints<'db>> {
        let expression_node = expression.node_ref(self.db).node();
-        self.evaluate_expression_node_constraint(expression_node, expression, is_positive);
+        self.evaluate_expression_node_constraint(expression_node, expression, is_positive)
    }

    fn evaluate_expression_node_constraint(
@@ -138,52 +191,51 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
        expression_node: &ruff_python_ast::Expr,
        expression: Expression<'db>,
        is_positive: bool,
-    ) {
+    ) -> Option<NarrowingConstraints<'db>> {
        match expression_node {
            ast::Expr::Compare(expr_compare) => {
-                self.add_expr_compare(expr_compare, expression, is_positive);
+                self.evaluate_expr_compare(expr_compare, expression, is_positive)
            }
            ast::Expr::Call(expr_call) => {
-                self.add_expr_call(expr_call, expression, is_positive);
+                self.evaluate_expr_call(expr_call, expression, is_positive)
            }
-            ast::Expr::UnaryOp(unary_op) if unary_op.op == ast::UnaryOp::Not => {
-                self.evaluate_expression_node_constraint(
-                    &unary_op.operand,
-                    expression,
-                    !is_positive,
-                );
-            }
-            _ => {} // TODO other test expression kinds
+            ast::Expr::UnaryOp(unary_op) if unary_op.op == ast::UnaryOp::Not => self
+                .evaluate_expression_node_constraint(&unary_op.operand, expression, !is_positive),
+            ast::Expr::BoolOp(bool_op) => self.evaluate_bool_op(bool_op, expression, is_positive),
+            _ => None, // TODO other test expression kinds
        }
    }

-    fn evaluate_pattern_constraint(&mut self, pattern: PatternConstraint<'db>) {
+    fn evaluate_pattern_constraint(
+        &mut self,
+        pattern: PatternConstraint<'db>,
+    ) -> Option<NarrowingConstraints<'db>> {
        let subject = pattern.subject(self.db);

        match pattern.pattern(self.db).node() {
            ast::Pattern::MatchValue(_) => {
-                // TODO
+                None // TODO
            }
            ast::Pattern::MatchSingleton(singleton_pattern) => {
-                self.add_match_pattern_singleton(subject, singleton_pattern);
+                self.evaluate_match_pattern_singleton(subject, singleton_pattern)
            }
            ast::Pattern::MatchSequence(_) => {
-                // TODO
+                None // TODO
            }
            ast::Pattern::MatchMapping(_) => {
-                // TODO
+                None // TODO
            }
            ast::Pattern::MatchClass(_) => {
-                // TODO
+                None // TODO
            }
            ast::Pattern::MatchStar(_) => {
-                // TODO
+                None // TODO
            }
            ast::Pattern::MatchAs(_) => {
-                // TODO
+                None // TODO
            }
            ast::Pattern::MatchOr(_) => {
-                // TODO
+                None // TODO
            }
        }
    }
@@ -199,12 +251,12 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
        }
    }

-    fn add_expr_compare(
+    fn evaluate_expr_compare(
        &mut self,
        expr_compare: &ast::ExprCompare,
        expression: Expression<'db>,
        is_positive: bool,
-    ) {
+    ) -> Option<NarrowingConstraints<'db>> {
        let ast::ExprCompare {
            range: _,
            left,
@@ -214,14 +266,14 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
        if !left.is_name_expr() && comparators.iter().all(|c| !c.is_name_expr()) {
            // If none of the comparators are name expressions,
            // we have no symbol to narrow down the type of.
-            return;
+            return None;
        }
        if !is_positive && comparators.len() > 1 {
            // We can't negate a constraint made by a multi-comparator expression, since we can't
            // know which comparison part is the one being negated.
            // For example, the negation of  `x is 1 is y is 2`, would be `(x is not 1) or (y is not 1) or (y is not 2)`
            // and that requires cross-symbol constraints, which we don't support yet.
-            return;
+            return None;
        }
        let scope = self.scope();
        let inference = infer_expression_types(self.db, expression);
@@ -229,6 +281,7 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
        let comparator_tuples = std::iter::once(&**left)
            .chain(comparators)
            .tuple_windows::<(&ruff_python_ast::Expr, &ruff_python_ast::Expr)>();
+        let mut constraints = NarrowingConstraints::default();
        for (op, (left, right)) in std::iter::zip(&**ops, comparator_tuples) {
            if let ast::Expr::Name(ast::ExprName {
                range: _,
@@ -242,24 +295,24 @@ impl<'db> NarrowingConstraintsBuilder<'db> {

                match if is_positive { *op } else { op.negate() } {
                    ast::CmpOp::IsNot => {
-                        if rhs_ty.is_singleton() {
+                        if rhs_ty.is_singleton(self.db) {
                            let ty = IntersectionBuilder::new(self.db)
                                .add_negative(rhs_ty)
                                .build();
-                            self.constraints.insert(symbol, ty);
+                            constraints.insert(symbol, ty);
                        } else {
                            // Non-singletons cannot be safely narrowed using `is not`
                        }
                    }
                    ast::CmpOp::Is => {
-                        self.constraints.insert(symbol, rhs_ty);
+                        constraints.insert(symbol, rhs_ty);
                    }
                    ast::CmpOp::NotEq => {
                        if rhs_ty.is_single_valued(self.db) {
                            let ty = IntersectionBuilder::new(self.db)
                                .add_negative(rhs_ty)
                                .build();
-                            self.constraints.insert(symbol, ty);
+                            constraints.insert(symbol, ty);
                        }
                    }
                    _ => {
@@ -268,59 +321,135 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
                }
            }
        }
+        Some(constraints)
    }

-    fn add_expr_call(
+    fn evaluate_expr_call(
        &mut self,
        expr_call: &ast::ExprCall,
        expression: Expression<'db>,
        is_positive: bool,
-    ) {
+    ) -> Option<NarrowingConstraints<'db>> {
        let scope = self.scope();
        let inference = infer_expression_types(self.db, expression);

-        if let Some(func_type) = inference
+        // TODO: add support for PEP 604 union types on the right hand side of `isinstance`
+        // and `issubclass`, for example `isinstance(x, str | (int | float))`.
+        match inference
            .expression_ty(expr_call.func.scoped_ast_id(self.db, scope))
-            .into_function_literal_type()
+            .into_function_literal()
+            .and_then(|f| f.known(self.db))
+            .and_then(KnownFunction::constraint_function)
        {
-            if func_type.is_known(self.db, KnownFunction::IsInstance)
-                && expr_call.arguments.keywords.is_empty()
-            {
-                if let [ast::Expr::Name(ast::ExprName { id, .. }), rhs] = &*expr_call.arguments.args
+            Some(function) if expr_call.arguments.keywords.is_empty() => {
+                if let [ast::Expr::Name(ast::ExprName { id, .. }), class_info] =
+                    &*expr_call.arguments.args
                {
                    let symbol = self.symbols().symbol_id_by_name(id).unwrap();

-                    let rhs_type = inference.expression_ty(rhs.scoped_ast_id(self.db, scope));
+                    let class_info_ty =
+                        inference.expression_ty(class_info.scoped_ast_id(self.db, scope));

-                    // TODO: add support for PEP 604 union types on the right hand side:
-                    // isinstance(x, str | (int | float))
-                    if let Some(mut constraint) = generate_isinstance_constraint(self.db, &rhs_type)
-                    {
-                        if !is_positive {
-                            constraint = constraint.negate(self.db);
+                    let to_constraint = match function {
+                        KnownConstraintFunction::IsInstance => {
+                            |class_literal: ClassLiteralType<'db>| {
+                                Type::instance(class_literal.class)
+                            }
                        }
-                        self.constraints.insert(symbol, constraint);
-                    }
+                        KnownConstraintFunction::IsSubclass => {
+                            |class_literal: ClassLiteralType<'db>| {
+                                Type::subclass_of(class_literal.class)
+                            }
+                        }
+                    };
+
+                    generate_classinfo_constraint(self.db, &class_info_ty, to_constraint).map(
+                        |constraint| {
+                            let mut constraints = NarrowingConstraints::default();
+                            constraints.insert(symbol, constraint.negate_if(self.db, !is_positive));
+                            constraints
+                        },
+                    )
+                } else {
+                    None
                }
            }
+            _ => None,
        }
    }

-    fn add_match_pattern_singleton(
+    fn evaluate_match_pattern_singleton(
        &mut self,
        subject: &ast::Expr,
        pattern: &ast::PatternMatchSingleton,
-    ) {
+    ) -> Option<NarrowingConstraints<'db>> {
        if let Some(ast::ExprName { id, .. }) = subject.as_name_expr() {
            // SAFETY: we should always have a symbol for every Name node.
            let symbol = self.symbols().symbol_id_by_name(id).unwrap();

            let ty = match pattern.value {
-                ast::Singleton::None => Type::None,
+                ast::Singleton::None => Type::none(self.db),
                ast::Singleton::True => Type::BooleanLiteral(true),
                ast::Singleton::False => Type::BooleanLiteral(false),
            };
-            self.constraints.insert(symbol, ty);
+            let mut constraints = NarrowingConstraints::default();
+            constraints.insert(symbol, ty);
+            Some(constraints)
+        } else {
+            None
+        }
+    }
+
+    fn evaluate_bool_op(
+        &mut self,
+        expr_bool_op: &ExprBoolOp,
+        expression: Expression<'db>,
+        is_positive: bool,
+    ) -> Option<NarrowingConstraints<'db>> {
+        let inference = infer_expression_types(self.db, expression);
+        let scope = self.scope();
+        let mut sub_constraints = expr_bool_op
+            .values
+            .iter()
+            // filter our arms with statically known truthiness
+            .filter(|expr| {
+                inference
+                    .expression_ty(expr.scoped_ast_id(self.db, scope))
+                    .bool(self.db)
+                    != match expr_bool_op.op {
+                        BoolOp::And => Truthiness::AlwaysTrue,
+                        BoolOp::Or => Truthiness::AlwaysFalse,
+                    }
+            })
+            .map(|sub_expr| {
+                self.evaluate_expression_node_constraint(sub_expr, expression, is_positive)
+            })
+            .collect::<Vec<_>>();
+        match (expr_bool_op.op, is_positive) {
+            (BoolOp::And, true) | (BoolOp::Or, false) => {
+                let mut aggregation: Option<NarrowingConstraints> = None;
+                for sub_constraint in sub_constraints.into_iter().flatten() {
+                    if let Some(ref mut some_aggregation) = aggregation {
+                        merge_constraints_and(some_aggregation, sub_constraint, self.db);
+                    } else {
+                        aggregation = Some(sub_constraint);
+                    }
+                }
+                aggregation
+            }
+            (BoolOp::Or, true) | (BoolOp::And, false) => {
+                let (first, rest) = sub_constraints.split_first_mut()?;
+                if let Some(ref mut first) = first {
+                    for rest_constraint in rest {
+                        if let Some(rest_constraint) = rest_constraint {
+                            merge_constraints_or(first, rest_constraint, self.db);
+                        } else {
+                            return None;
+                        }
+                    }
+                }
+                first.clone()
+            }
        }
    }
 }
--- a/crates/red_knot_python_semantic/src/types/unpacker.rs
+++ b/crates/red_knot_python_semantic/src/types/unpacker.rs
@@ -0,0 +1,142 @@
+use std::borrow::Cow;
+
+use ruff_db::files::File;
+use ruff_python_ast::{self as ast, AnyNodeRef};
+use rustc_hash::FxHashMap;
+
+use crate::semantic_index::ast_ids::{HasScopedAstId, ScopedExpressionId};
+use crate::semantic_index::symbol::ScopeId;
+use crate::types::{Type, TypeCheckDiagnostics, TypeCheckDiagnosticsBuilder};
+use crate::Db;
+
+/// Unpacks the value expression type to their respective targets.
+pub(crate) struct Unpacker<'db> {
+    db: &'db dyn Db,
+    targets: FxHashMap<ScopedExpressionId, Type<'db>>,
+    diagnostics: TypeCheckDiagnosticsBuilder<'db>,
+}
+
+impl<'db> Unpacker<'db> {
+    pub(crate) fn new(db: &'db dyn Db, file: File) -> Self {
+        Self {
+            db,
+            targets: FxHashMap::default(),
+            diagnostics: TypeCheckDiagnosticsBuilder::new(db, file),
+        }
+    }
+
+    pub(crate) fn unpack(&mut self, target: &ast::Expr, value_ty: Type<'db>, scope: ScopeId<'db>) {
+        match target {
+            ast::Expr::Name(target_name) => {
+                self.targets
+                    .insert(target_name.scoped_ast_id(self.db, scope), value_ty);
+            }
+            ast::Expr::Starred(ast::ExprStarred { value, .. }) => {
+                self.unpack(value, value_ty, scope);
+            }
+            ast::Expr::List(ast::ExprList { elts, .. })
+            | ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => match value_ty {
+                Type::Tuple(tuple_ty) => {
+                    let starred_index = elts.iter().position(ast::Expr::is_starred_expr);
+
+                    let element_types = if let Some(starred_index) = starred_index {
+                        if tuple_ty.len(self.db) >= elts.len() - 1 {
+                            let mut element_types = Vec::with_capacity(elts.len());
+                            element_types.extend_from_slice(
+                                // SAFETY: Safe because of the length check above.
+                                &tuple_ty.elements(self.db)[..starred_index],
+                            );
+
+                            // E.g., in `(a, *b, c, d) = ...`, the index of starred element `b`
+                            // is 1 and the remaining elements after that are 2.
+                            let remaining = elts.len() - (starred_index + 1);
+                            // This index represents the type of the last element that belongs
+                            // to the starred expression, in an exclusive manner.
+                            let starred_end_index = tuple_ty.len(self.db) - remaining;
+                            // SAFETY: Safe because of the length check above.
+                            let _starred_element_types =
+                                &tuple_ty.elements(self.db)[starred_index..starred_end_index];
+                            // TODO: Combine the types into a list type. If the
+                            // starred_element_types is empty, then it should be `List[Any]`.
+                            // combine_types(starred_element_types);
+                            element_types.push(Type::Todo);
+
+                            element_types.extend_from_slice(
+                                // SAFETY: Safe because of the length check above.
+                                &tuple_ty.elements(self.db)[starred_end_index..],
+                            );
+                            Cow::Owned(element_types)
+                        } else {
+                            let mut element_types = tuple_ty.elements(self.db).to_vec();
+                            // Subtract 1 to insert the starred expression type at the correct
+                            // index.
+                            element_types.resize(elts.len() - 1, Type::Unknown);
+                            // TODO: This should be `list[Unknown]`
+                            element_types.insert(starred_index, Type::Todo);
+                            Cow::Owned(element_types)
+                        }
+                    } else {
+                        Cow::Borrowed(tuple_ty.elements(self.db).as_ref())
+                    };
+
+                    for (index, element) in elts.iter().enumerate() {
+                        self.unpack(
+                            element,
+                            element_types.get(index).copied().unwrap_or(Type::Unknown),
+                            scope,
+                        );
+                    }
+                }
+                Type::StringLiteral(string_literal_ty) => {
+                    // Deconstruct the string literal to delegate the inference back to the
+                    // tuple type for correct handling of starred expressions. We could go
+                    // further and deconstruct to an array of `StringLiteral` with each
+                    // individual character, instead of just an array of `LiteralString`, but
+                    // there would be a cost and it's not clear that it's worth it.
+                    let value_ty = Type::tuple(
+                        self.db,
+                        &vec![Type::LiteralString; string_literal_ty.len(self.db)],
+                    );
+                    self.unpack(target, value_ty, scope);
+                }
+                _ => {
+                    let value_ty = if value_ty.is_literal_string() {
+                        Type::LiteralString
+                    } else {
+                        value_ty
+                            .iterate(self.db)
+                            .unwrap_with_diagnostic(AnyNodeRef::from(target), &mut self.diagnostics)
+                    };
+                    for element in elts {
+                        self.unpack(element, value_ty, scope);
+                    }
+                }
+            },
+            _ => {}
+        }
+    }
+
+    pub(crate) fn finish(mut self) -> UnpackResult<'db> {
+        self.targets.shrink_to_fit();
+        UnpackResult {
+            diagnostics: self.diagnostics.finish(),
+            targets: self.targets,
+        }
+    }
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub(crate) struct UnpackResult<'db> {
+    targets: FxHashMap<ScopedExpressionId, Type<'db>>,
+    diagnostics: TypeCheckDiagnostics,
+}
+
+impl<'db> UnpackResult<'db> {
+    pub(crate) fn get(&self, expr_id: ScopedExpressionId) -> Option<Type<'db>> {
+        self.targets.get(&expr_id).copied()
+    }
+
+    pub(crate) fn diagnostics(&self) -> &TypeCheckDiagnostics {
+        &self.diagnostics
+    }
+}
--- a/crates/red_knot_python_semantic/src/unpack.rs
+++ b/crates/red_knot_python_semantic/src/unpack.rs
@@ -0,0 +1,55 @@
+use ruff_db::files::File;
+use ruff_python_ast::{self as ast};
+
+use crate::ast_node_ref::AstNodeRef;
+use crate::semantic_index::expression::Expression;
+use crate::semantic_index::symbol::{FileScopeId, ScopeId};
+use crate::Db;
+
+/// This ingredient represents a single unpacking.
+///
+/// This is required to make use of salsa to cache the complete unpacking of multiple variables
+/// involved. It allows us to:
+/// 1. Avoid doing structural match multiple times for each definition
+/// 2. Avoid highlighting the same error multiple times
+///
+/// ## Module-local type
+/// This type should not be used as part of any cross-module API because
+/// it holds a reference to the AST node. Range-offset changes
+/// then propagate through all usages, and deserialization requires
+/// reparsing the entire module.
+///
+/// E.g. don't use this type in:
+///
+/// * a return type of a cross-module query
+/// * a field of a type that is a return type of a cross-module query
+/// * an argument of a cross-module query
+#[salsa::tracked]
+pub(crate) struct Unpack<'db> {
+    #[id]
+    pub(crate) file: File,
+
+    #[id]
+    pub(crate) file_scope: FileScopeId,
+
+    /// The target expression that is being unpacked. For example, in `(a, b) = (1, 2)`, the target
+    /// expression is `(a, b)`.
+    #[no_eq]
+    #[return_ref]
+    pub(crate) target: AstNodeRef<ast::Expr>,
+
+    /// The ingredient representing the value expression of the unpacking. For example, in
+    /// `(a, b) = (1, 2)`, the value expression is `(1, 2)`.
+    #[no_eq]
+    pub(crate) value: Expression<'db>,
+
+    #[no_eq]
+    count: countme::Count<Unpack<'static>>,
+}
+
+impl<'db> Unpack<'db> {
+    /// Returns the scope where the unpacking is happening.
+    pub(crate) fn scope(self, db: &'db dyn Db) -> ScopeId<'db> {
+        self.file_scope(db).to_scope_id(db, self.file(db))
+    }
+}
--- a/crates/red_knot_python_semantic/tests/mdtest.rs
+++ b/crates/red_knot_python_semantic/tests/mdtest.rs
@@ -1,7 +1,8 @@
-use dir_test::{dir_test, Fixture};
-use red_knot_test::run;
+use std::ffi::OsStr;
 use std::path::Path;

+use dir_test::{dir_test, Fixture};
+
 /// See `crates/red_knot_test/README.md` for documentation on these tests.
 #[dir_test(
    dir: "$CARGO_MANIFEST_DIR/resources/mdtest",
@@ -9,16 +10,16 @@ use std::path::Path;
 )]
 #[allow(clippy::needless_pass_by_value)]
 fn mdtest(fixture: Fixture<&str>) {
-    let path = fixture.path();
+    let fixture_path = Path::new(fixture.path());
+    let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+    let workspace_root = crate_dir.parent().and_then(Path::parent).unwrap();

-    let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"))
-        .join("resources/mdtest")
-        .canonicalize()
+    let long_title = fixture_path
+        .strip_prefix(workspace_root)
+        .unwrap()
+        .to_str()
        .unwrap();
+    let short_title = fixture_path.file_name().and_then(OsStr::to_str).unwrap();

-    let relative_path = path
-        .strip_prefix(crate_dir.to_str().unwrap())
-        .unwrap_or(path);
-
-    run(Path::new(path), relative_path);
+    red_knot_test::run(fixture_path, long_title, short_title);
 }
--- a/crates/red_knot_server/src/edit.rs
+++ b/crates/red_knot_server/src/edit.rs
@@ -6,7 +6,7 @@ mod text_document;

 use lsp_types::{PositionEncodingKind, Url};
 pub use notebook::NotebookDocument;
-pub(crate) use range::RangeExt;
+pub(crate) use range::{RangeExt, ToRangeExt};
 pub(crate) use text_document::DocumentVersion;
 pub use text_document::TextDocument;

--- a/crates/red_knot_server/src/edit/range.rs
+++ b/crates/red_knot_server/src/edit/range.rs
@@ -1,13 +1,32 @@
+use super::notebook;
 use super::PositionEncoding;
-use ruff_source_file::LineIndex;
+use lsp_types as types;
+use ruff_notebook::NotebookIndex;
 use ruff_source_file::OneIndexed;
+use ruff_source_file::{LineIndex, SourceLocation};
 use ruff_text_size::{TextRange, TextSize};

+pub(crate) struct NotebookRange {
+    pub(crate) cell: notebook::CellId,
+    pub(crate) range: types::Range,
+}
+
 pub(crate) trait RangeExt {
    fn to_text_range(&self, text: &str, index: &LineIndex, encoding: PositionEncoding)
        -> TextRange;
 }

+pub(crate) trait ToRangeExt {
+    fn to_range(&self, text: &str, index: &LineIndex, encoding: PositionEncoding) -> types::Range;
+    fn to_notebook_range(
+        &self,
+        text: &str,
+        source_index: &LineIndex,
+        notebook_index: &NotebookIndex,
+        encoding: PositionEncoding,
+    ) -> NotebookRange;
+}
+
 fn u32_index_to_usize(index: u32) -> usize {
    usize::try_from(index).expect("u32 fits in usize")
 }
@@ -75,6 +94,61 @@ impl RangeExt for lsp_types::Range {
    }
 }

+impl ToRangeExt for TextRange {
+    fn to_range(&self, text: &str, index: &LineIndex, encoding: PositionEncoding) -> types::Range {
+        types::Range {
+            start: source_location_to_position(&offset_to_source_location(
+                self.start(),
+                text,
+                index,
+                encoding,
+            )),
+            end: source_location_to_position(&offset_to_source_location(
+                self.end(),
+                text,
+                index,
+                encoding,
+            )),
+        }
+    }
+
+    fn to_notebook_range(
+        &self,
+        text: &str,
+        source_index: &LineIndex,
+        notebook_index: &NotebookIndex,
+        encoding: PositionEncoding,
+    ) -> NotebookRange {
+        let start = offset_to_source_location(self.start(), text, source_index, encoding);
+        let mut end = offset_to_source_location(self.end(), text, source_index, encoding);
+        let starting_cell = notebook_index.cell(start.row);
+
+        // weird edge case here - if the end of the range is where the newline after the cell got added (making it 'out of bounds')
+        // we need to move it one character back (which should place it at the end of the last line).
+        // we test this by checking if the ending offset is in a different (or nonexistent) cell compared to the cell of the starting offset.
+        if notebook_index.cell(end.row) != starting_cell {
+            end.row = end.row.saturating_sub(1);
+            end.column = offset_to_source_location(
+                self.end().checked_sub(1.into()).unwrap_or_default(),
+                text,
+                source_index,
+                encoding,
+            )
+            .column;
+        }
+
+        let start = source_location_to_position(&notebook_index.translate_location(&start));
+        let end = source_location_to_position(&notebook_index.translate_location(&end));
+
+        NotebookRange {
+            cell: starting_cell
+                .map(OneIndexed::to_zero_indexed)
+                .unwrap_or_default(),
+            range: types::Range { start, end },
+        }
+    }
+}
+
 /// Converts a UTF-16 code unit offset for a given line into a UTF-8 column number.
 fn utf8_column_offset(utf16_code_unit_offset: u32, line: &str) -> TextSize {
    let mut utf8_code_unit_offset = TextSize::new(0);
@@ -96,3 +170,46 @@ fn utf8_column_offset(utf16_code_unit_offset: u32, line: &str) -> TextSize {

    utf8_code_unit_offset
 }
+
+fn offset_to_source_location(
+    offset: TextSize,
+    text: &str,
+    index: &LineIndex,
+    encoding: PositionEncoding,
+) -> SourceLocation {
+    match encoding {
+        PositionEncoding::UTF8 => {
+            let row = index.line_index(offset);
+            let column = offset - index.line_start(row, text);
+
+            SourceLocation {
+                column: OneIndexed::from_zero_indexed(column.to_usize()),
+                row,
+            }
+        }
+        PositionEncoding::UTF16 => {
+            let row = index.line_index(offset);
+
+            let column = if index.is_ascii() {
+                (offset - index.line_start(row, text)).to_usize()
+            } else {
+                let up_to_line = &text[TextRange::new(index.line_start(row, text), offset)];
+                up_to_line.encode_utf16().count()
+            };
+
+            SourceLocation {
+                column: OneIndexed::from_zero_indexed(column),
+                row,
+            }
+        }
+        PositionEncoding::UTF32 => index.source_location(offset, text),
+    }
+}
+
+fn source_location_to_position(location: &SourceLocation) -> types::Position {
+    types::Position {
+        line: u32::try_from(location.row.to_zero_indexed()).expect("row usize fits in u32"),
+        character: u32::try_from(location.column.to_zero_indexed())
+            .expect("character usize fits in u32"),
+    }
+}
--- a/crates/red_knot_server/src/server/api/requests/diagnostic.rs
+++ b/crates/red_knot_server/src/server/api/requests/diagnostic.rs
@@ -3,15 +3,17 @@ use std::borrow::Cow;
 use lsp_types::request::DocumentDiagnosticRequest;
 use lsp_types::{
    Diagnostic, DiagnosticSeverity, DocumentDiagnosticParams, DocumentDiagnosticReport,
-    DocumentDiagnosticReportResult, FullDocumentDiagnosticReport, Position, Range,
+    DocumentDiagnosticReportResult, FullDocumentDiagnosticReport, NumberOrString, Range,
    RelatedFullDocumentDiagnosticReport, Url,
 };

-use red_knot_workspace::db::RootDatabase;
-
+use crate::edit::ToRangeExt;
 use crate::server::api::traits::{BackgroundDocumentRequestHandler, RequestHandler};
 use crate::server::{client::Notifier, Result};
 use crate::session::DocumentSnapshot;
+use red_knot_workspace::db::{Db, RootDatabase};
+use ruff_db::diagnostic::Severity;
+use ruff_db::source::{line_index, source_text};

 pub(crate) struct DocumentDiagnosticRequestHandler;

@@ -64,36 +66,37 @@ fn compute_diagnostics(snapshot: &DocumentSnapshot, db: &RootDatabase) -> Vec<Di
    diagnostics
        .as_slice()
        .iter()
-        .map(|message| to_lsp_diagnostic(message))
+        .map(|message| to_lsp_diagnostic(db, message, snapshot.encoding()))
        .collect()
 }

-fn to_lsp_diagnostic(message: &str) -> Diagnostic {
-    let words = message.split(':').collect::<Vec<_>>();
+fn to_lsp_diagnostic(
+    db: &dyn Db,
+    diagnostic: &dyn ruff_db::diagnostic::Diagnostic,
+    encoding: crate::PositionEncoding,
+) -> Diagnostic {
+    let range = if let Some(range) = diagnostic.range() {
+        let index = line_index(db.upcast(), diagnostic.file());
+        let source = source_text(db.upcast(), diagnostic.file());

-    let (range, message) = match words.as_slice() {
-        [_, _, line, column, message] | [_, line, column, message] => {
-            let line = line.parse::<u32>().unwrap_or_default().saturating_sub(1);
-            let column = column.parse::<u32>().unwrap_or_default();
-            (
-                Range::new(
-                    Position::new(line, column.saturating_sub(1)),
-                    Position::new(line, column),
-                ),
-                message.trim(),
-            )
-        }
-        _ => (Range::default(), message),
+        range.to_range(&source, &index, encoding)
+    } else {
+        Range::default()
+    };
+
+    let severity = match diagnostic.severity() {
+        Severity::Info => DiagnosticSeverity::INFORMATION,
+        Severity::Error => DiagnosticSeverity::ERROR,
    };

    Diagnostic {
        range,
-        severity: Some(DiagnosticSeverity::ERROR),
+        severity: Some(severity),
        tags: None,
-        code: None,
+        code: Some(NumberOrString::String(diagnostic.rule().to_string())),
        code_description: None,
        source: Some("red-knot".into()),
-        message: message.to_string(),
+        message: diagnostic.message().into_owned(),
        related_information: None,
        data: None,
    }
--- a/crates/red_knot_test/src/diagnostic.rs
+++ b/crates/red_knot_test/src/diagnostic.rs
@@ -2,8 +2,8 @@
 //!
 //! We don't assume that we will get the diagnostics in source order.

+use ruff_db::diagnostic::Diagnostic;
 use ruff_source_file::{LineIndex, OneIndexed};
-use ruff_text_size::Ranged;
 use std::ops::{Deref, Range};

 /// All diagnostics for one embedded Python file, sorted and grouped by start line number.
@@ -19,13 +19,17 @@ pub(crate) struct SortedDiagnostics<T> {

 impl<T> SortedDiagnostics<T>
 where
-    T: Ranged + Clone,
+    T: Diagnostic,
 {
    pub(crate) fn new(diagnostics: impl IntoIterator<Item = T>, line_index: &LineIndex) -> Self {
        let mut diagnostics: Vec<_> = diagnostics
            .into_iter()
            .map(|diagnostic| DiagnosticWithLine {
-                line_number: line_index.line_index(diagnostic.start()),
+                line_number: diagnostic
+                    .range()
+                    .map_or(OneIndexed::from_zero_indexed(0), |range| {
+                        line_index.line_index(range.start())
+                    }),
                diagnostic,
            })
            .collect();
@@ -94,7 +98,7 @@ pub(crate) struct LineDiagnosticsIterator<'a, T> {

 impl<'a, T> Iterator for LineDiagnosticsIterator<'a, T>
 where
-    T: Ranged + Clone,
+    T: Diagnostic,
 {
    type Item = LineDiagnostics<'a, T>;

@@ -110,7 +114,7 @@ where
    }
 }

-impl<T> std::iter::FusedIterator for LineDiagnosticsIterator<'_, T> where T: Clone + Ranged {}
+impl<T> std::iter::FusedIterator for LineDiagnosticsIterator<'_, T> where T: Diagnostic {}

 /// All diagnostics that start on a single line of source code in one embedded Python file.
 #[derive(Debug)]
@@ -139,11 +143,14 @@ struct DiagnosticWithLine<T> {
 #[cfg(test)]
 mod tests {
    use crate::db::Db;
-    use ruff_db::files::system_path_to_file;
+    use crate::diagnostic::Diagnostic;
+    use ruff_db::diagnostic::Severity;
+    use ruff_db::files::{system_path_to_file, File};
    use ruff_db::source::line_index;
    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
    use ruff_source_file::OneIndexed;
    use ruff_text_size::{TextRange, TextSize};
+    use std::borrow::Cow;

    #[test]
    fn sort_and_group() {
@@ -152,13 +159,18 @@ mod tests {
        let file = system_path_to_file(&db, "/src/test.py").unwrap();
        let lines = line_index(&db, file);

-        let ranges = vec![
+        let ranges = [
            TextRange::new(TextSize::new(0), TextSize::new(1)),
            TextRange::new(TextSize::new(5), TextSize::new(10)),
            TextRange::new(TextSize::new(1), TextSize::new(7)),
        ];

-        let sorted = super::SortedDiagnostics::new(&ranges, &lines);
+        let diagnostics: Vec<_> = ranges
+            .into_iter()
+            .map(|range| DummyDiagnostic { range, file })
+            .collect();
+
+        let sorted = super::SortedDiagnostics::new(diagnostics, &lines);
        let grouped = sorted.iter_lines().collect::<Vec<_>>();

        let [line1, line2] = &grouped[..] else {
@@ -170,4 +182,32 @@ mod tests {
        assert_eq!(line2.line_number, OneIndexed::from_zero_indexed(1));
        assert_eq!(line2.diagnostics.len(), 1);
    }
+
+    #[derive(Debug)]
+    struct DummyDiagnostic {
+        range: TextRange,
+        file: File,
+    }
+
+    impl Diagnostic for DummyDiagnostic {
+        fn rule(&self) -> &str {
+            "dummy"
+        }
+
+        fn message(&self) -> Cow<str> {
+            "dummy".into()
+        }
+
+        fn file(&self) -> File {
+            self.file
+        }
+
+        fn range(&self) -> Option<TextRange> {
+            Some(self.range)
+        }
+
+        fn severity(&self) -> Severity {
+            Severity::Error
+        }
+    }
 }
--- a/crates/red_knot_test/src/lib.rs
+++ b/crates/red_knot_test/src/lib.rs
@@ -1,6 +1,7 @@
 use colored::Colorize;
 use parser as test_parser;
 use red_knot_python_semantic::types::check_types;
+use ruff_db::diagnostic::{Diagnostic, ParseDiagnostic};
 use ruff_db::files::{system_path_to_file, File, Files};
 use ruff_db::parsed::parsed_module;
 use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
@@ -18,9 +19,9 @@ mod parser;
 ///
 /// Panic on test failure, and print failure details.
 #[allow(clippy::print_stdout)]
-pub fn run(path: &Path, title: &str) {
+pub fn run(path: &Path, long_title: &str, short_title: &str) {
    let source = std::fs::read_to_string(path).unwrap();
-    let suite = match test_parser::parse(title, &source) {
+    let suite = match test_parser::parse(short_title, &source) {
        Ok(suite) => suite,
        Err(err) => {
            panic!("Error parsing `{}`: {err}", path.to_str().unwrap())
@@ -48,8 +49,8 @@ pub fn run(path: &Path, title: &str) {
                    for failure in failures {
                        let absolute_line_number =
                            backtick_line.checked_add(relative_line_number).unwrap();
-                        let line_info = format!("{title}:{absolute_line_number}").cyan();
-                        println!("    {line_info} {failure}");
+                        let line_info = format!("{long_title}:{absolute_line_number}").cyan();
+                        println!("  {line_info} {failure}");
                    }
                }
            }
@@ -87,16 +88,24 @@ fn run_test(db: &mut db::Db, test: &parser::MarkdownTest) -> Result<(), Failures
        .filter_map(|test_file| {
            let parsed = parsed_module(db, test_file.file);

-            // TODO allow testing against code with syntax errors
-            assert!(
-                parsed.errors().is_empty(),
-                "Python syntax errors in {}, {}: {:?}",
-                test.name(),
-                test_file.file.path(db),
-                parsed.errors()
-            );
+            let mut diagnostics: Vec<Box<_>> = parsed
+                .errors()
+                .iter()
+                .cloned()
+                .map(|error| {
+                    let diagnostic: Box<dyn Diagnostic> =
+                        Box::new(ParseDiagnostic::new(test_file.file, error));
+                    diagnostic
+                })
+                .collect();

-            match matcher::match_file(db, test_file.file, check_types(db, test_file.file)) {
+            let type_diagnostics = check_types(db, test_file.file);
+            diagnostics.extend(type_diagnostics.into_iter().map(|diagnostic| {
+                let diagnostic: Box<dyn Diagnostic> = Box::new((*diagnostic).clone());
+                diagnostic
+            }));
+
+            match matcher::match_file(db, test_file.file, diagnostics) {
                Ok(()) => None,
                Err(line_failures) => Some(FileFailures {
                    backtick_offset: test_file.backtick_offset,
--- a/crates/red_knot_test/src/matcher.rs
+++ b/crates/red_knot_test/src/matcher.rs
@@ -1,17 +1,15 @@
-//! Match [`TypeCheckDiagnostic`]s against [`Assertion`]s and produce test failure messages for any
+//! Match [`Diagnostic`]s against [`Assertion`]s and produce test failure messages for any
 //! mismatches.
 use crate::assertion::{Assertion, ErrorAssertion, InlineFileAssertions};
 use crate::db::Db;
 use crate::diagnostic::SortedDiagnostics;
 use colored::Colorize;
-use red_knot_python_semantic::types::TypeCheckDiagnostic;
+use ruff_db::diagnostic::Diagnostic;
 use ruff_db::files::File;
 use ruff_db::source::{line_index, source_text, SourceText};
 use ruff_source_file::{LineIndex, OneIndexed};
-use ruff_text_size::Ranged;
 use std::cmp::Ordering;
 use std::ops::Range;
-use std::sync::Arc;

 #[derive(Debug, Default)]
 pub(super) struct FailuresByLine {
@@ -55,7 +53,7 @@ pub(super) fn match_file<T>(
    diagnostics: impl IntoIterator<Item = T>,
 ) -> Result<(), FailuresByLine>
 where
-    T: Diagnostic + Clone,
+    T: Diagnostic,
 {
    // Parse assertions from comments in the file, and get diagnostics from the file; both
    // ordered by line number.
@@ -126,22 +124,6 @@ where
    }
 }

-pub(super) trait Diagnostic: Ranged {
-    fn rule(&self) -> &str;
-
-    fn message(&self) -> &str;
-}
-
-impl Diagnostic for Arc<TypeCheckDiagnostic> {
-    fn rule(&self) -> &str {
-        self.as_ref().rule()
-    }
-
-    fn message(&self) -> &str {
-        self.as_ref().message()
-    }
-}
-
 trait Unmatched {
    fn unmatched(&self) -> String;
 }
@@ -253,10 +235,15 @@ impl Matcher {
        }
    }

-    fn column<T: Ranged>(&self, ranged: &T) -> OneIndexed {
-        self.line_index
-            .source_location(ranged.start(), &self.source)
-            .column
+    fn column<T: Diagnostic>(&self, diagnostic: &T) -> OneIndexed {
+        diagnostic
+            .range()
+            .map(|range| {
+                self.line_index
+                    .source_location(range.start(), &self.source)
+                    .column
+            })
+            .unwrap_or(OneIndexed::from_zero_indexed(0))
    }

    /// Check if `assertion` matches any [`Diagnostic`]s in `unmatched`.
@@ -323,20 +310,21 @@ impl Matcher {
 #[cfg(test)]
 mod tests {
    use super::FailuresByLine;
-    use ruff_db::files::system_path_to_file;
+    use ruff_db::diagnostic::{Diagnostic, Severity};
+    use ruff_db::files::{system_path_to_file, File};
    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
    use ruff_python_trivia::textwrap::dedent;
    use ruff_source_file::OneIndexed;
-    use ruff_text_size::{Ranged, TextRange};
+    use ruff_text_size::TextRange;
+    use std::borrow::Cow;

-    #[derive(Clone, Debug)]
-    struct TestDiagnostic {
+    struct ExpectedDiagnostic {
        rule: &'static str,
        message: &'static str,
        range: TextRange,
    }

-    impl TestDiagnostic {
+    impl ExpectedDiagnostic {
        fn new(rule: &'static str, message: &'static str, offset: usize) -> Self {
            let offset: u32 = offset.try_into().unwrap();
            Self {
@@ -345,32 +333,64 @@ mod tests {
                range: TextRange::new(offset.into(), (offset + 1).into()),
            }
        }
+
+        fn into_diagnostic(self, file: File) -> TestDiagnostic {
+            TestDiagnostic {
+                rule: self.rule,
+                message: self.message,
+                range: self.range,
+                file,
+            }
+        }
    }

-    impl super::Diagnostic for TestDiagnostic {
+    #[derive(Debug)]
+    struct TestDiagnostic {
+        rule: &'static str,
+        message: &'static str,
+        range: TextRange,
+        file: File,
+    }
+
+    impl Diagnostic for TestDiagnostic {
        fn rule(&self) -> &str {
            self.rule
        }

-        fn message(&self) -> &str {
-            self.message
+        fn message(&self) -> Cow<str> {
+            self.message.into()
+        }
+
+        fn file(&self) -> File {
+            self.file
+        }
+
+        fn range(&self) -> Option<TextRange> {
+            Some(self.range)
+        }
+
+        fn severity(&self) -> Severity {
+            Severity::Error
        }
    }

-    impl Ranged for TestDiagnostic {
-        fn range(&self) -> ruff_text_size::TextRange {
-            self.range
-        }
-    }
-
-    fn get_result(source: &str, diagnostics: Vec<TestDiagnostic>) -> Result<(), FailuresByLine> {
+    fn get_result(
+        source: &str,
+        diagnostics: Vec<ExpectedDiagnostic>,
+    ) -> Result<(), FailuresByLine> {
        colored::control::set_override(false);

        let mut db = crate::db::Db::setup(SystemPathBuf::from("/src"));
        db.write_file("/src/test.py", source).unwrap();
        let file = system_path_to_file(&db, "/src/test.py").unwrap();

-        super::match_file(&db, file, diagnostics)
+        super::match_file(
+            &db,
+            file,
+            diagnostics
+                .into_iter()
+                .map(|diagnostic| diagnostic.into_diagnostic(file)),
+        )
    }

    fn assert_fail(result: Result<(), FailuresByLine>, messages: &[(usize, &[&str])]) {
@@ -403,7 +423,7 @@ mod tests {
    fn revealed_match() {
        let result = get_result(
            "x # revealed: Foo",
-            vec![TestDiagnostic::new(
+            vec![ExpectedDiagnostic::new(
                "revealed-type",
                "Revealed type is `Foo`",
                0,
@@ -417,7 +437,7 @@ mod tests {
    fn revealed_wrong_rule() {
        let result = get_result(
            "x # revealed: Foo",
-            vec![TestDiagnostic::new(
+            vec![ExpectedDiagnostic::new(
                "not-revealed-type",
                "Revealed type is `Foo`",
                0,
@@ -440,7 +460,11 @@ mod tests {
    fn revealed_wrong_message() {
        let result = get_result(
            "x # revealed: Foo",
-            vec![TestDiagnostic::new("revealed-type", "Something else", 0)],
+            vec![ExpectedDiagnostic::new(
+                "revealed-type",
+                "Something else",
+                0,
+            )],
        );

        assert_fail(
@@ -467,8 +491,8 @@ mod tests {
        let result = get_result(
            "x # revealed: Foo",
            vec![
-                TestDiagnostic::new("revealed-type", "Revealed type is `Foo`", 0),
-                TestDiagnostic::new("undefined-reveal", "Doesn't matter", 0),
+                ExpectedDiagnostic::new("revealed-type", "Revealed type is `Foo`", 0),
+                ExpectedDiagnostic::new("undefined-reveal", "Doesn't matter", 0),
            ],
        );

@@ -479,7 +503,11 @@ mod tests {
    fn revealed_match_with_only_undefined() {
        let result = get_result(
            "x # revealed: Foo",
-            vec![TestDiagnostic::new("undefined-reveal", "Doesn't matter", 0)],
+            vec![ExpectedDiagnostic::new(
+                "undefined-reveal",
+                "Doesn't matter",
+                0,
+            )],
        );

        assert_fail(result, &[(0, &["unmatched assertion: revealed: Foo"])]);
@@ -490,8 +518,8 @@ mod tests {
        let result = get_result(
            "x # revealed: Foo",
            vec![
-                TestDiagnostic::new("revealed-type", "Revealed type is `Bar`", 0),
-                TestDiagnostic::new("undefined-reveal", "Doesn't matter", 0),
+                ExpectedDiagnostic::new("revealed-type", "Revealed type is `Bar`", 0),
+                ExpectedDiagnostic::new("undefined-reveal", "Doesn't matter", 0),
            ],
        );

@@ -512,8 +540,8 @@ mod tests {
        let result = get_result(
            "reveal_type(1)",
            vec![
-                TestDiagnostic::new("undefined-reveal", "undefined reveal message", 0),
-                TestDiagnostic::new("revealed-type", "Revealed type is `Literal[1]`", 12),
+                ExpectedDiagnostic::new("undefined-reveal", "undefined reveal message", 0),
+                ExpectedDiagnostic::new("revealed-type", "Revealed type is `Literal[1]`", 12),
            ],
        );

@@ -535,8 +563,8 @@ mod tests {
        let result = get_result(
            "reveal_type(1) # error: [something-else]",
            vec![
-                TestDiagnostic::new("undefined-reveal", "undefined reveal message", 0),
-                TestDiagnostic::new("revealed-type", "Revealed type is `Literal[1]`", 12),
+                ExpectedDiagnostic::new("undefined-reveal", "undefined reveal message", 0),
+                ExpectedDiagnostic::new("revealed-type", "Revealed type is `Literal[1]`", 12),
            ],
        );

@@ -565,7 +593,7 @@ mod tests {
    fn error_match_rule() {
        let result = get_result(
            "x # error: [some-rule]",
-            vec![TestDiagnostic::new("some-rule", "Any message", 0)],
+            vec![ExpectedDiagnostic::new("some-rule", "Any message", 0)],
        );

        assert_ok(&result);
@@ -575,7 +603,7 @@ mod tests {
    fn error_wrong_rule() {
        let result = get_result(
            "x # error: [some-rule]",
-            vec![TestDiagnostic::new("anything", "Any message", 0)],
+            vec![ExpectedDiagnostic::new("anything", "Any message", 0)],
        );

        assert_fail(
@@ -594,7 +622,11 @@ mod tests {
    fn error_match_message() {
        let result = get_result(
            r#"x # error: "contains this""#,
-            vec![TestDiagnostic::new("anything", "message contains this", 0)],
+            vec![ExpectedDiagnostic::new(
+                "anything",
+                "message contains this",
+                0,
+            )],
        );

        assert_ok(&result);
@@ -604,7 +636,7 @@ mod tests {
    fn error_wrong_message() {
        let result = get_result(
            r#"x # error: "contains this""#,
-            vec![TestDiagnostic::new("anything", "Any message", 0)],
+            vec![ExpectedDiagnostic::new("anything", "Any message", 0)],
        );

        assert_fail(
@@ -623,7 +655,7 @@ mod tests {
    fn error_match_column_and_rule() {
        let result = get_result(
            "x # error: 1 [some-rule]",
-            vec![TestDiagnostic::new("some-rule", "Any message", 0)],
+            vec![ExpectedDiagnostic::new("some-rule", "Any message", 0)],
        );

        assert_ok(&result);
@@ -633,7 +665,7 @@ mod tests {
    fn error_wrong_column() {
        let result = get_result(
            "x # error: 2 [rule]",
-            vec![TestDiagnostic::new("rule", "Any message", 0)],
+            vec![ExpectedDiagnostic::new("rule", "Any message", 0)],
        );

        assert_fail(
@@ -652,7 +684,11 @@ mod tests {
    fn error_match_column_and_message() {
        let result = get_result(
            r#"x # error: 1 "contains this""#,
-            vec![TestDiagnostic::new("anything", "message contains this", 0)],
+            vec![ExpectedDiagnostic::new(
+                "anything",
+                "message contains this",
+                0,
+            )],
        );

        assert_ok(&result);
@@ -662,7 +698,11 @@ mod tests {
    fn error_match_rule_and_message() {
        let result = get_result(
            r#"x # error: [a-rule] "contains this""#,
-            vec![TestDiagnostic::new("a-rule", "message contains this", 0)],
+            vec![ExpectedDiagnostic::new(
+                "a-rule",
+                "message contains this",
+                0,
+            )],
        );

        assert_ok(&result);
@@ -672,7 +712,11 @@ mod tests {
    fn error_match_all() {
        let result = get_result(
            r#"x # error: 1 [a-rule] "contains this""#,
-            vec![TestDiagnostic::new("a-rule", "message contains this", 0)],
+            vec![ExpectedDiagnostic::new(
+                "a-rule",
+                "message contains this",
+                0,
+            )],
        );

        assert_ok(&result);
@@ -682,7 +726,11 @@ mod tests {
    fn error_match_all_wrong_column() {
        let result = get_result(
            r#"x # error: 2 [some-rule] "contains this""#,
-            vec![TestDiagnostic::new("some-rule", "message contains this", 0)],
+            vec![ExpectedDiagnostic::new(
+                "some-rule",
+                "message contains this",
+                0,
+            )],
        );

        assert_fail(
@@ -701,7 +749,7 @@ mod tests {
    fn error_match_all_wrong_rule() {
        let result = get_result(
            r#"x # error: 1 [some-rule] "contains this""#,
-            vec![TestDiagnostic::new(
+            vec![ExpectedDiagnostic::new(
                "other-rule",
                "message contains this",
                0,
@@ -724,7 +772,7 @@ mod tests {
    fn error_match_all_wrong_message() {
        let result = get_result(
            r#"x # error: 1 [some-rule] "contains this""#,
-            vec![TestDiagnostic::new("some-rule", "Any message", 0)],
+            vec![ExpectedDiagnostic::new("some-rule", "Any message", 0)],
        );

        assert_fail(
@@ -757,9 +805,9 @@ mod tests {
        let result = get_result(
            &source,
            vec![
-                TestDiagnostic::new("line-two", "msg", two),
-                TestDiagnostic::new("line-three", "msg", three),
-                TestDiagnostic::new("line-five", "msg", five),
+                ExpectedDiagnostic::new("line-two", "msg", two),
+                ExpectedDiagnostic::new("line-three", "msg", three),
+                ExpectedDiagnostic::new("line-five", "msg", five),
            ],
        );

@@ -788,8 +836,8 @@ mod tests {
        let result = get_result(
            &source,
            vec![
-                TestDiagnostic::new("line-one", "msg", one),
-                TestDiagnostic::new("line-two", "msg", two),
+                ExpectedDiagnostic::new("line-one", "msg", one),
+                ExpectedDiagnostic::new("line-two", "msg", two),
            ],
        );

@@ -809,8 +857,8 @@ mod tests {
        let result = get_result(
            &source,
            vec![
-                TestDiagnostic::new("one-rule", "msg", x),
-                TestDiagnostic::new("other-rule", "msg", x),
+                ExpectedDiagnostic::new("one-rule", "msg", x),
+                ExpectedDiagnostic::new("other-rule", "msg", x),
            ],
        );

@@ -830,8 +878,8 @@ mod tests {
        let result = get_result(
            &source,
            vec![
-                TestDiagnostic::new("one-rule", "msg", x),
-                TestDiagnostic::new("one-rule", "msg", x),
+                ExpectedDiagnostic::new("one-rule", "msg", x),
+                ExpectedDiagnostic::new("one-rule", "msg", x),
            ],
        );

@@ -851,9 +899,9 @@ mod tests {
        let result = get_result(
            &source,
            vec![
-                TestDiagnostic::new("one-rule", "msg", x),
-                TestDiagnostic::new("other-rule", "msg", x),
-                TestDiagnostic::new("third-rule", "msg", x),
+                ExpectedDiagnostic::new("one-rule", "msg", x),
+                ExpectedDiagnostic::new("other-rule", "msg", x),
+                ExpectedDiagnostic::new("third-rule", "msg", x),
            ],
        );

@@ -877,8 +925,8 @@ mod tests {
        let result = get_result(
            &source,
            vec![
-                TestDiagnostic::new("undefined-reveal", "msg", reveal),
-                TestDiagnostic::new("revealed-type", "Revealed type is `Literal[5]`", reveal),
+                ExpectedDiagnostic::new("undefined-reveal", "msg", reveal),
+                ExpectedDiagnostic::new("revealed-type", "Revealed type is `Literal[5]`", reveal),
            ],
        );

@@ -891,7 +939,7 @@ mod tests {
        let x = source.find('x').unwrap();
        let result = get_result(
            source,
-            vec![TestDiagnostic::new("some-rule", "some message", x)],
+            vec![ExpectedDiagnostic::new("some-rule", "some message", x)],
        );

        assert_fail(
@@ -912,7 +960,7 @@ mod tests {
        let x = source.find('x').unwrap();
        let result = get_result(
            source,
-            vec![TestDiagnostic::new("some-rule", "some message", x)],
+            vec![ExpectedDiagnostic::new("some-rule", "some message", x)],
        );

        assert_fail(
--- a/crates/red_knot_wasm/src/lib.rs
+++ b/crates/red_knot_wasm/src/lib.rs
@@ -6,6 +6,7 @@ use wasm_bindgen::prelude::*;
 use red_knot_workspace::db::RootDatabase;
 use red_knot_workspace::workspace::settings::Configuration;
 use red_knot_workspace::workspace::WorkspaceMetadata;
+use ruff_db::diagnostic::Diagnostic;
 use ruff_db::files::{system_path_to_file, File};
 use ruff_db::system::walk_directory::WalkDirectoryBuilder;
 use ruff_db::system::{
@@ -110,14 +111,20 @@ impl Workspace {
    pub fn check_file(&self, file_id: &FileHandle) -> Result<Vec<String>, Error> {
        let result = self.db.check_file(file_id.file).map_err(into_error)?;

-        Ok(result)
+        Ok(result
+            .into_iter()
+            .map(|diagnostic| diagnostic.display(&self.db).to_string())
+            .collect())
    }

    /// Checks all open files
    pub fn check(&self) -> Result<Vec<String>, Error> {
        let result = self.db.check().map_err(into_error)?;

-        Ok(result)
+        Ok(result
+            .into_iter()
+            .map(|diagnostic| diagnostic.display(&self.db).to_string())
+            .collect())
    }

    /// Returns the parsed AST for `path`
--- a/crates/red_knot_wasm/tests/api.rs
+++ b/crates/red_knot_wasm/tests/api.rs
@@ -19,6 +19,6 @@ fn check() {

    assert_eq!(
        result,
-        vec!["/test.py:1:8: Cannot resolve import `random22`"]
+        vec!["error[unresolved-import] /test.py:1:8 Cannot resolve import `random22`"]
    );
 }
--- a/crates/red_knot_workspace/resources/test/corpus/25_func_annotations_starred.py
+++ b/crates/red_knot_workspace/resources/test/corpus/25_func_annotations_starred.py
@@ -0,0 +1,8 @@
+# Regression test for https://github.com/astral-sh/ruff/issues/14115
+#
+# This is invalid syntax, but should not lead to a crash.
+
+def f() -> *int: ...
+
+
+f()
--- a/crates/red_knot_workspace/resources/test/corpus/27_func_generic_constraint.py
+++ b/crates/red_knot_workspace/resources/test/corpus/27_func_generic_constraint.py
@@ -1,2 +1,5 @@
 def foo[T: (str, bytes)](x: T) -> T:
    ...
+
+def bar[T: (str,)](x: T) -> T:
+    ...
--- a/crates/red_knot_workspace/resources/test/corpus/89_type_alias.py
+++ b/crates/red_knot_workspace/resources/test/corpus/89_type_alias.py
@@ -1 +1,2 @@
 type foo = int
+type ListOrSet[T] = list[T] | set[T]
--- a/crates/red_knot_workspace/src/db.rs
+++ b/crates/red_knot_workspace/src/db.rs
@@ -4,14 +4,14 @@ use std::sync::Arc;
 use salsa::plumbing::ZalsaDatabase;
 use salsa::{Cancelled, Event};

+use crate::workspace::{check_file, Workspace, WorkspaceMetadata};
 use red_knot_python_semantic::{Db as SemanticDb, Program};
+use ruff_db::diagnostic::Diagnostic;
 use ruff_db::files::{File, Files};
 use ruff_db::system::System;
 use ruff_db::vendored::VendoredFileSystem;
 use ruff_db::{Db as SourceDb, Upcast};

-use crate::workspace::{check_file, Workspace, WorkspaceMetadata};
-
 mod changes;

 #[salsa::db]
@@ -51,11 +51,11 @@ impl RootDatabase {
    }

    /// Checks all open files in the workspace and its dependencies.
-    pub fn check(&self) -> Result<Vec<String>, Cancelled> {
+    pub fn check(&self) -> Result<Vec<Box<dyn Diagnostic>>, Cancelled> {
        self.with_db(|db| db.workspace().check(db))
    }

-    pub fn check_file(&self, file: File) -> Result<Vec<String>, Cancelled> {
+    pub fn check_file(&self, file: File) -> Result<Vec<Box<dyn Diagnostic>>, Cancelled> {
        let _span = tracing::debug_span!("check_file", file=%file.path(self)).entered();

        self.with_db(|db| check_file(db, file))
--- a/crates/red_knot_workspace/src/workspace.rs
+++ b/crates/red_knot_workspace/src/workspace.rs
@@ -1,23 +1,23 @@
-use std::{collections::BTreeMap, sync::Arc};
-
 use rustc_hash::{FxBuildHasher, FxHashSet};
 use salsa::{Durability, Setter as _};
+use std::borrow::Cow;
+use std::{collections::BTreeMap, sync::Arc};

+use crate::db::Db;
+use crate::db::RootDatabase;
+use crate::workspace::files::{Index, Indexed, IndexedIter, PackageFiles};
 pub use metadata::{PackageMetadata, WorkspaceMetadata};
 use red_knot_python_semantic::types::check_types;
 use red_knot_python_semantic::SearchPathSettings;
+use ruff_db::diagnostic::{Diagnostic, ParseDiagnostic, Severity};
 use ruff_db::parsed::parsed_module;
-use ruff_db::source::{line_index, source_text, SourceDiagnostic};
+use ruff_db::source::{source_text, SourceTextError};
 use ruff_db::{
    files::{system_path_to_file, File},
    system::{walk_directory::WalkState, SystemPath, SystemPathBuf},
 };
 use ruff_python_ast::{name::Name, PySourceType};
-use ruff_text_size::Ranged;
-
-use crate::db::Db;
-use crate::db::RootDatabase;
-use crate::workspace::files::{Index, Indexed, IndexedIter, PackageFiles};
+use ruff_text_size::TextRange;

 mod files;
 mod metadata;
@@ -188,7 +188,7 @@ impl Workspace {
    }

    /// Checks all open files in the workspace and its dependencies.
-    pub fn check(self, db: &RootDatabase) -> Vec<String> {
+    pub fn check(self, db: &RootDatabase) -> Vec<Box<dyn Diagnostic>> {
        let workspace_span = tracing::debug_span!("check_workspace");
        let _span = workspace_span.enter();

@@ -378,47 +378,31 @@ impl Package {
    }
 }

-#[salsa::tracked]
-pub(super) fn check_file(db: &dyn Db, file: File) -> Vec<String> {
-    tracing::debug!("Checking file '{path}'", path = file.path(db));
-
-    let mut diagnostics = Vec::new();
-
-    let source_diagnostics = source_text::accumulated::<SourceDiagnostic>(db.upcast(), file);
-    // TODO(micha): Consider using a single accumulator for all diagnostics
-    diagnostics.extend(
-        source_diagnostics
-            .iter()
-            .map(std::string::ToString::to_string),
-    );
-
+pub(super) fn check_file(db: &dyn Db, file: File) -> Vec<Box<dyn Diagnostic>> {
+    let mut diagnostics: Vec<Box<dyn Diagnostic>> = Vec::new();
    // Abort checking if there are IO errors.
    let source = source_text(db.upcast(), file);

-    if source.has_read_error() {
+    if let Some(read_error) = source.read_error() {
+        diagnostics.push(Box::new(IOErrorDiagnostic {
+            file,
+            error: read_error.clone(),
+        }));
        return diagnostics;
    }

    let parsed = parsed_module(db.upcast(), file);
+    diagnostics.extend(parsed.errors().iter().map(|error| {
+        let diagnostic: Box<dyn Diagnostic> = Box::new(ParseDiagnostic::new(file, error.clone()));
+        diagnostic
+    }));

-    if !parsed.errors().is_empty() {
-        let path = file.path(db);
-        let line_index = line_index(db.upcast(), file);
-        diagnostics.extend(parsed.errors().iter().map(|err| {
-            let source_location = line_index.source_location(err.location.start(), source.as_str());
-            format!("{path}:{source_location}: {message}", message = err.error)
-        }));
-    }
+    diagnostics.extend(check_types(db.upcast(), file).iter().map(|diagnostic| {
+        let boxed: Box<dyn Diagnostic> = Box::new(diagnostic.clone());
+        boxed
+    }));

-    for diagnostic in check_types(db.upcast(), file) {
-        let index = line_index(db.upcast(), diagnostic.file());
-        let location = index.source_location(diagnostic.start(), source.as_str());
-        diagnostics.push(format!(
-            "{path}:{location}: {message}",
-            path = file.path(db),
-            message = diagnostic.message()
-        ));
-    }
+    diagnostics.sort_unstable_by_key(|diagnostic| diagnostic.range().unwrap_or_default().start());

    diagnostics
 }
@@ -533,17 +517,45 @@ impl Iterator for WorkspaceFilesIter<'_> {
    }
 }

+#[derive(Debug)]
+pub struct IOErrorDiagnostic {
+    file: File,
+    error: SourceTextError,
+}
+
+impl Diagnostic for IOErrorDiagnostic {
+    fn rule(&self) -> &str {
+        "io"
+    }
+
+    fn message(&self) -> Cow<str> {
+        self.error.to_string().into()
+    }
+
+    fn file(&self) -> File {
+        self.file
+    }
+
+    fn range(&self) -> Option<TextRange> {
+        None
+    }
+
+    fn severity(&self) -> Severity {
+        Severity::Error
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    use crate::db::tests::TestDb;
+    use crate::workspace::check_file;
    use red_knot_python_semantic::types::check_types;
+    use ruff_db::diagnostic::Diagnostic;
    use ruff_db::files::system_path_to_file;
    use ruff_db::source::source_text;
    use ruff_db::system::{DbWithTestSystem, SystemPath};
    use ruff_db::testing::assert_function_query_was_not_run;

-    use crate::db::tests::TestDb;
-    use crate::workspace::check_file;
-
    #[test]
    fn check_file_skips_type_checking_when_file_cant_be_read() -> ruff_db::system::Result<()> {
        let mut db = TestDb::new();
@@ -558,7 +570,10 @@ mod tests {

        assert_eq!(source_text(&db, file).as_str(), "");
        assert_eq!(
-            check_file(&db, file),
+            check_file(&db, file)
+                .into_iter()
+                .map(|diagnostic| diagnostic.message().into_owned())
+                .collect::<Vec<_>>(),
            vec!["Failed to read file: No such file or directory".to_string()]
        );

@@ -570,7 +585,13 @@ mod tests {
        db.write_file(path, "").unwrap();

        assert_eq!(source_text(&db, file).as_str(), "");
-        assert_eq!(check_file(&db, file), vec![] as Vec<String>);
+        assert_eq!(
+            check_file(&db, file)
+                .into_iter()
+                .map(|diagnostic| diagnostic.message().into_owned())
+                .collect::<Vec<_>>(),
+            vec![] as Vec<String>
+        );

        Ok(())
    }
--- a/crates/ruff/Cargo.toml
+++ b/crates/ruff/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.7.2"
+version = "0.7.3"
 publish = true
 authors = { workspace = true }
 edition = { workspace = true }
--- a/crates/ruff/src/cache.rs
+++ b/crates/ruff/src/cache.rs
@@ -20,6 +20,7 @@ use tempfile::NamedTempFile;
 use ruff_cache::{CacheKey, CacheKeyHasher};
 use ruff_diagnostics::{DiagnosticKind, Fix};
 use ruff_linter::message::{DiagnosticMessage, Message};
+use ruff_linter::package::PackageRoot;
 use ruff_linter::{warn_user, VERSION};
 use ruff_macros::CacheKey;
 use ruff_notebook::NotebookIndex;
@@ -497,7 +498,7 @@ pub(crate) struct PackageCacheMap<'a>(FxHashMap<&'a Path, Cache>);

 impl<'a> PackageCacheMap<'a> {
    pub(crate) fn init(
-        package_roots: &FxHashMap<&'a Path, Option<&'a Path>>,
+        package_roots: &FxHashMap<&'a Path, Option<PackageRoot<'a>>>,
        resolver: &Resolver,
    ) -> Self {
        fn init_cache(path: &Path) {
@@ -513,7 +514,9 @@ impl<'a> PackageCacheMap<'a> {
        Self(
            package_roots
                .iter()
-                .map(|(package, package_root)| package_root.unwrap_or(package))
+                .map(|(package, package_root)| {
+                    package_root.map(PackageRoot::path).unwrap_or(package)
+                })
                .unique()
                .par_bridge()
                .map(|cache_root| {
@@ -587,6 +590,7 @@ mod tests {

    use ruff_cache::CACHE_DIR_NAME;
    use ruff_linter::message::Message;
+    use ruff_linter::package::PackageRoot;
    use ruff_linter::settings::flags;
    use ruff_linter::settings::types::UnsafeFixes;
    use ruff_python_ast::PySourceType;
@@ -641,7 +645,7 @@ mod tests {

                let diagnostics = lint_path(
                    &path,
-                    Some(&package_root),
+                    Some(PackageRoot::root(&package_root)),
                    &settings.linter,
                    Some(&cache),
                    flags::Noqa::Enabled,
@@ -683,7 +687,7 @@ mod tests {
        for path in paths {
            got_diagnostics += lint_path(
                &path,
-                Some(&package_root),
+                Some(PackageRoot::root(&package_root)),
                &settings.linter,
                Some(&cache),
                flags::Noqa::Enabled,
@@ -1056,7 +1060,7 @@ mod tests {
        ) -> Result<Diagnostics, anyhow::Error> {
            lint_path(
                &self.package_root.join(path),
-                Some(&self.package_root),
+                Some(PackageRoot::root(&self.package_root)),
                &self.settings.linter,
                Some(cache),
                flags::Noqa::Enabled,
--- a/crates/ruff/src/commands/analyze_graph.rs
+++ b/crates/ruff/src/commands/analyze_graph.rs
@@ -6,6 +6,7 @@ use log::{debug, warn};
 use path_absolutize::CWD;
 use ruff_db::system::{SystemPath, SystemPathBuf};
 use ruff_graph::{Direction, ImportMap, ModuleDb, ModuleImports};
+use ruff_linter::package::PackageRoot;
 use ruff_linter::{warn_user, warn_user_once};
 use ruff_python_ast::{PySourceType, SourceType};
 use ruff_workspace::resolver::{match_exclusion, python_files_in_path, ResolvedFile};
@@ -49,7 +50,12 @@ pub(crate) fn analyze_graph(
                .collect::<Vec<_>>(),
        )
        .into_iter()
-        .map(|(path, package)| (path.to_path_buf(), package.map(Path::to_path_buf)))
+        .map(|(path, package)| {
+            (
+                path.to_path_buf(),
+                package.map(PackageRoot::path).map(Path::to_path_buf),
+            )
+        })
        .collect::<FxHashMap<_, _>>();

    // Create a database from the source roots.
--- a/crates/ruff/src/commands/check.rs
+++ b/crates/ruff/src/commands/check.rs
@@ -13,6 +13,7 @@ use rustc_hash::FxHashMap;

 use ruff_diagnostics::Diagnostic;
 use ruff_linter::message::Message;
+use ruff_linter::package::PackageRoot;
 use ruff_linter::registry::Rule;
 use ruff_linter::settings::types::UnsafeFixes;
 use ruff_linter::settings::{flags, LinterSettings};
@@ -87,7 +88,9 @@ pub(crate) fn check(
                    return None;
                }

-                let cache_root = package.unwrap_or_else(|| path.parent().unwrap_or(path));
+                let cache_root = package
+                    .map(PackageRoot::path)
+                    .unwrap_or_else(|| path.parent().unwrap_or(path));
                let cache = caches.get(cache_root);

                lint_path(
@@ -181,7 +184,7 @@ pub(crate) fn check(
 #[allow(clippy::too_many_arguments)]
 fn lint_path(
    path: &Path,
-    package: Option<&Path>,
+    package: Option<PackageRoot<'_>>,
    settings: &LinterSettings,
    cache: Option<&Cache>,
    noqa: flags::Noqa,
--- a/crates/ruff/src/commands/check_stdin.rs
+++ b/crates/ruff/src/commands/check_stdin.rs
@@ -1,7 +1,7 @@
 use std::path::Path;

 use anyhow::Result;
-
+use ruff_linter::package::PackageRoot;
 use ruff_linter::packaging;
 use ruff_linter::settings::flags;
 use ruff_workspace::resolver::{match_exclusion, python_file_at_path, PyprojectConfig, Resolver};
@@ -42,6 +42,7 @@ pub(crate) fn check_stdin(
    let stdin = read_from_stdin()?;
    let package_root = filename.and_then(Path::parent).and_then(|path| {
        packaging::detect_package_root(path, &resolver.base_settings().linter.namespace_packages)
+            .map(PackageRoot::root)
    });
    let mut diagnostics = lint_stdin(
        filename,
--- a/crates/ruff/src/commands/format.rs
+++ b/crates/ruff/src/commands/format.rs
@@ -18,6 +18,7 @@ use tracing::debug;
 use ruff_diagnostics::SourceMap;
 use ruff_linter::fs;
 use ruff_linter::logging::{DisplayParseError, LogLevel};
+use ruff_linter::package::PackageRoot;
 use ruff_linter::registry::Rule;
 use ruff_linter::rules::flake8_quotes::settings::Quote;
 use ruff_linter::source_kind::{SourceError, SourceKind};
@@ -136,7 +137,9 @@ pub(crate) fn format(
                        .parent()
                        .and_then(|parent| package_roots.get(parent).copied())
                        .flatten();
-                    let cache_root = package.unwrap_or_else(|| path.parent().unwrap_or(path));
+                    let cache_root = package
+                        .map(PackageRoot::path)
+                        .unwrap_or_else(|| path.parent().unwrap_or(path));
                    let cache = caches.get(cache_root);

                    Some(
--- a/crates/ruff/src/diagnostics.rs
+++ b/crates/ruff/src/diagnostics.rs
@@ -16,6 +16,7 @@ use ruff_diagnostics::Diagnostic;
 use ruff_linter::codes::Rule;
 use ruff_linter::linter::{lint_fix, lint_only, FixTable, FixerResult, LinterResult, ParseSource};
 use ruff_linter::message::{Message, SyntaxErrorMessage};
+use ruff_linter::package::PackageRoot;
 use ruff_linter::pyproject_toml::lint_pyproject_toml;
 use ruff_linter::settings::types::UnsafeFixes;
 use ruff_linter::settings::{flags, LinterSettings};
@@ -180,7 +181,7 @@ impl AddAssign for FixMap {
 /// Lint the source code at the given `Path`.
 pub(crate) fn lint_path(
    path: &Path,
-    package: Option<&Path>,
+    package: Option<PackageRoot<'_>>,
    settings: &LinterSettings,
    cache: Option<&Cache>,
    noqa: flags::Noqa,
@@ -373,7 +374,7 @@ pub(crate) fn lint_path(
 /// stdin.
 pub(crate) fn lint_stdin(
    path: Option<&Path>,
-    package: Option<&Path>,
+    package: Option<PackageRoot<'_>>,
    contents: String,
    settings: &Settings,
    noqa: flags::Noqa,
--- a/crates/ruff/src/printer.rs
+++ b/crates/ruff/src/printer.rs
@@ -27,11 +27,11 @@ bitflags! {
    #[derive(Default, Debug, Copy, Clone)]
    pub(crate) struct Flags: u8 {
        /// Whether to show violations when emitting diagnostics.
-        const SHOW_VIOLATIONS = 0b0000_0001;
+        const SHOW_VIOLATIONS = 1 << 0;
        /// Whether to show a summary of the fixed violations when emitting diagnostics.
-        const SHOW_FIX_SUMMARY = 0b0000_0100;
+        const SHOW_FIX_SUMMARY = 1 << 1;
        /// Whether to show a diff of each fixed violation when emitting diagnostics.
-        const SHOW_FIX_DIFF = 0b0000_1000;
+        const SHOW_FIX_DIFF = 1 << 2;
    }
 }

--- a/crates/ruff/tests/lint.rs
+++ b/crates/ruff/tests/lint.rs
@@ -8,6 +8,7 @@ use std::process::Command;
 use std::str;

 use anyhow::Result;
+use assert_fs::fixture::{ChildPath, FileTouch, PathChild};
 use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
 use tempfile::TempDir;

@@ -1224,10 +1225,7 @@ fn negated_per_file_ignores_absolute() -> Result<()> {
    let ignored = tempdir.path().join("ignored.py");
    fs::write(ignored, "")?;

-    insta::with_settings!({filters => vec![
-        // Replace windows paths
-        (r"\\", "/"),
-    ]}, {
+    insta::with_settings!({filters => vec![(r"\\", "/")]}, {
        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
            .args(STDIN_BASE_OPTIONS)
            .arg("--config")
@@ -1918,3 +1916,58 @@ fn checks_notebooks_in_stable() -> anyhow::Result<()> {
    "###);
    Ok(())
 }
+
+/// Verify that implicit namespace packages are detected even when they are nested.
+///
+/// See: <https://github.com/astral-sh/ruff/issues/13519>
+#[test]
+fn nested_implicit_namespace_package() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let root = ChildPath::new(tempdir.path());
+
+    root.child("foo").child("__init__.py").touch()?;
+    root.child("foo")
+        .child("bar")
+        .child("baz")
+        .child("__init__.py")
+        .touch()?;
+    root.child("foo")
+        .child("bar")
+        .child("baz")
+        .child("bop.py")
+        .touch()?;
+
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--select")
+        .arg("INP")
+        .current_dir(&tempdir)
+        , @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    All checks passed!
+
+    ----- stderr -----
+    "###);
+
+    insta::with_settings!({filters => vec![(r"\\", "/")]}, {
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+            .args(STDIN_BASE_OPTIONS)
+            .arg("--select")
+            .arg("INP")
+            .arg("--preview")
+            .current_dir(&tempdir)
+            , @r###"
+        success: false
+        exit_code: 1
+        ----- stdout -----
+        foo/bar/baz/__init__.py:1:1: INP001 File `foo/bar/baz/__init__.py` declares a package, but is nested under an implicit namespace package. Add an `__init__.py` to `foo/bar`.
+        Found 1 error.
+
+        ----- stderr -----
+        "###);
+    });
+
+    Ok(())
+}
--- a/crates/ruff/tests/snapshots/integration_test__rule_f401.snap
+++ b/crates/ruff/tests/snapshots/integration_test__rule_f401.snap
@@ -85,6 +85,7 @@ else:

 ## Options
 - `lint.ignore-init-module-imports`
+- `lint.pyflakes.allowed-unused-imports`

 ## References
 - [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)
--- a/crates/ruff/tests/snapshots/show_settings__display_default_settings.snap
+++ b/crates/ruff/tests/snapshots/show_settings__display_default_settings.snap
@@ -375,6 +375,7 @@ linter.pylint.max_public_methods = 20
 linter.pylint.max_locals = 15
 linter.pyupgrade.keep_runtime_typing = false
 linter.ruff.parenthesize_tuple_in_subscript = false
+linter.ruff.extend_markup_names = []

 # Formatter Settings
 formatter.exclude = []
--- a/crates/ruff_benchmark/benches/red_knot.rs
+++ b/crates/ruff_benchmark/benches/red_knot.rs
@@ -8,6 +8,7 @@ use red_knot_workspace::workspace::settings::Configuration;
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_benchmark::criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use ruff_benchmark::TestFile;
+use ruff_db::diagnostic::Diagnostic;
 use ruff_db::files::{system_path_to_file, File};
 use ruff_db::source::source_text;
 use ruff_db::system::{MemoryFileSystem, SystemPath, SystemPathBuf, TestSystem};
@@ -24,31 +25,32 @@ const TOMLLIB_312_URL: &str = "https://raw.githubusercontent.com/python/cpython/

 static EXPECTED_DIAGNOSTICS: &[&str] = &[
    // We don't support `*` imports yet:
-    "/src/tomllib/_parser.py:7:29: Module `collections.abc` has no member `Iterable`",
+    "error[unresolved-import] /src/tomllib/_parser.py:7:29 Module `collections.abc` has no member `Iterable`",
    // We don't support terminal statements in control flow yet:
-    "/src/tomllib/_parser.py:246:15: Method `__class_getitem__` of type `Literal[frozenset]` is possibly unbound",
-    "/src/tomllib/_parser.py:66:18: Name `s` used when possibly not defined",
-    "/src/tomllib/_parser.py:98:12: Name `char` used when possibly not defined",
-    "/src/tomllib/_parser.py:101:12: Name `char` used when possibly not defined",
-    "/src/tomllib/_parser.py:104:14: Name `char` used when possibly not defined",
-    "/src/tomllib/_parser.py:108:17: Conflicting declared types for `second_char`: Unknown, str | None",
-    "/src/tomllib/_parser.py:115:14: Name `char` used when possibly not defined",
-    "/src/tomllib/_parser.py:126:12: Name `char` used when possibly not defined",
-    "/src/tomllib/_parser.py:267:9: Conflicting declared types for `char`: Unknown, str | None",
-    "/src/tomllib/_parser.py:348:20: Name `nest` used when possibly not defined",
-    "/src/tomllib/_parser.py:353:5: Name `nest` used when possibly not defined",
-    "/src/tomllib/_parser.py:364:9: Conflicting declared types for `char`: Unknown, str | None",
-    "/src/tomllib/_parser.py:381:13: Conflicting declared types for `char`: Unknown, str | None",
-    "/src/tomllib/_parser.py:395:9: Conflicting declared types for `char`: Unknown, str | None",
-    "/src/tomllib/_parser.py:453:24: Name `nest` used when possibly not defined",
-    "/src/tomllib/_parser.py:455:9: Name `nest` used when possibly not defined",
-    "/src/tomllib/_parser.py:482:16: Name `char` used when possibly not defined",
-    "/src/tomllib/_parser.py:566:12: Name `char` used when possibly not defined",
-    "/src/tomllib/_parser.py:573:12: Name `char` used when possibly not defined",
-    "/src/tomllib/_parser.py:579:12: Name `char` used when possibly not defined",
-    "/src/tomllib/_parser.py:580:63: Name `char` used when possibly not defined",
-    "/src/tomllib/_parser.py:590:9: Conflicting declared types for `char`: Unknown, str | None",
-    "/src/tomllib/_parser.py:629:38: Name `datetime_obj` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:66:18 Name `s` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:98:12 Name `char` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:101:12 Name `char` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:104:14 Name `char` used when possibly not defined",
+    "error[conflicting-declarations] /src/tomllib/_parser.py:108:17 Conflicting declared types for `second_char`: Unknown, str | None",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:115:14 Name `char` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:126:12 Name `char` used when possibly not defined",
+    "error[call-possibly-unbound-method] /src/tomllib/_parser.py:246:15 Method `__class_getitem__` of type `Literal[frozenset]` is possibly unbound",
+    "error[conflicting-declarations] /src/tomllib/_parser.py:267:9 Conflicting declared types for `char`: Unknown, str | None",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:348:20 Name `nest` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:353:5 Name `nest` used when possibly not defined",
+    "error[conflicting-declarations] /src/tomllib/_parser.py:364:9 Conflicting declared types for `char`: Unknown, str | None",
+    "error[conflicting-declarations] /src/tomllib/_parser.py:381:13 Conflicting declared types for `char`: Unknown, str | None",
+    "error[conflicting-declarations] /src/tomllib/_parser.py:395:9 Conflicting declared types for `char`: Unknown, str | None",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:453:24 Name `nest` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:455:9 Name `nest` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:482:16 Name `char` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:566:12 Name `char` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:573:12 Name `char` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:579:12 Name `char` used when possibly not defined",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:580:63 Name `char` used when possibly not defined",
+    "error[conflicting-declarations] /src/tomllib/_parser.py:590:9 Conflicting declared types for `char`: Unknown, str | None",
+    "error[possibly-unresolved-reference] /src/tomllib/_parser.py:629:38 Name `datetime_obj` used when possibly not defined",
+    "error[invalid-base] /src/tomllib/_parser.py:692:8354 Invalid class base with type `GenericAlias` (all bases must be a class, `Any`, `Unknown` or `Todo`)",
 ];

 fn get_test_file(name: &str) -> TestFile {
@@ -122,7 +124,14 @@ fn setup_rayon() {
 fn benchmark_incremental(criterion: &mut Criterion) {
    fn setup() -> Case {
        let case = setup_case();
-        let result = case.db.check().unwrap();
+
+        let result: Vec<_> = case
+            .db
+            .check()
+            .unwrap()
+            .into_iter()
+            .map(|diagnostic| diagnostic.display(&case.db).to_string())
+            .collect();

        assert_eq!(result, EXPECTED_DIAGNOSTICS);

@@ -149,7 +158,7 @@ fn benchmark_incremental(criterion: &mut Criterion) {

        let result = db.check().unwrap();

-        assert_eq!(result, EXPECTED_DIAGNOSTICS);
+        assert_eq!(result.len(), EXPECTED_DIAGNOSTICS.len());
    }

    setup_rayon();
@@ -167,7 +176,12 @@ fn benchmark_cold(criterion: &mut Criterion) {
            setup_case,
            |case| {
                let Case { db, .. } = case;
-                let result = db.check().unwrap();
+                let result: Vec<_> = db
+                    .check()
+                    .unwrap()
+                    .into_iter()
+                    .map(|diagnostic| diagnostic.display(db).to_string())
+                    .collect();

                assert_eq!(result, EXPECTED_DIAGNOSTICS);
            },
--- a/crates/ruff_db/src/diagnostic.rs
+++ b/crates/ruff_db/src/diagnostic.rs
@@ -0,0 +1,180 @@
+use crate::{
+    files::File,
+    source::{line_index, source_text},
+    Db,
+};
+use ruff_python_parser::ParseError;
+use ruff_text_size::TextRange;
+use std::borrow::Cow;
+
+pub trait Diagnostic: Send + Sync + std::fmt::Debug {
+    fn rule(&self) -> &str;
+
+    fn message(&self) -> std::borrow::Cow<str>;
+
+    fn file(&self) -> File;
+
+    fn range(&self) -> Option<TextRange>;
+
+    fn severity(&self) -> Severity;
+
+    fn display<'a>(&'a self, db: &'a dyn Db) -> DisplayDiagnostic<'a>
+    where
+        Self: Sized,
+    {
+        DisplayDiagnostic {
+            db,
+            diagnostic: self,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum Severity {
+    Info,
+    Error,
+}
+
+pub struct DisplayDiagnostic<'db> {
+    db: &'db dyn Db,
+    diagnostic: &'db dyn Diagnostic,
+}
+
+impl<'db> DisplayDiagnostic<'db> {
+    pub fn new(db: &'db dyn Db, diagnostic: &'db dyn Diagnostic) -> Self {
+        Self { db, diagnostic }
+    }
+}
+
+impl std::fmt::Display for DisplayDiagnostic<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.diagnostic.severity() {
+            Severity::Info => f.write_str("info")?,
+            Severity::Error => f.write_str("error")?,
+        }
+
+        write!(
+            f,
+            "[{rule}] {path}",
+            rule = self.diagnostic.rule(),
+            path = self.diagnostic.file().path(self.db)
+        )?;
+
+        if let Some(range) = self.diagnostic.range() {
+            let index = line_index(self.db, self.diagnostic.file());
+            let source = source_text(self.db, self.diagnostic.file());
+
+            let start = index.source_location(range.start(), &source);
+
+            write!(f, ":{line}:{col}", line = start.row, col = start.column)?;
+        }
+
+        write!(f, " {message}", message = self.diagnostic.message())
+    }
+}
+
+impl<T> Diagnostic for Box<T>
+where
+    T: Diagnostic,
+{
+    fn rule(&self) -> &str {
+        (**self).rule()
+    }
+
+    fn message(&self) -> Cow<str> {
+        (**self).message()
+    }
+
+    fn file(&self) -> File {
+        (**self).file()
+    }
+
+    fn range(&self) -> Option<TextRange> {
+        (**self).range()
+    }
+
+    fn severity(&self) -> Severity {
+        (**self).severity()
+    }
+}
+
+impl<T> Diagnostic for std::sync::Arc<T>
+where
+    T: Diagnostic,
+{
+    fn rule(&self) -> &str {
+        (**self).rule()
+    }
+
+    fn message(&self) -> std::borrow::Cow<str> {
+        (**self).message()
+    }
+
+    fn file(&self) -> File {
+        (**self).file()
+    }
+
+    fn range(&self) -> Option<TextRange> {
+        (**self).range()
+    }
+
+    fn severity(&self) -> Severity {
+        (**self).severity()
+    }
+}
+
+impl Diagnostic for Box<dyn Diagnostic> {
+    fn rule(&self) -> &str {
+        (**self).rule()
+    }
+
+    fn message(&self) -> Cow<str> {
+        (**self).message()
+    }
+
+    fn file(&self) -> File {
+        (**self).file()
+    }
+
+    fn range(&self) -> Option<TextRange> {
+        (**self).range()
+    }
+
+    fn severity(&self) -> Severity {
+        (**self).severity()
+    }
+}
+
+#[derive(Debug)]
+pub struct ParseDiagnostic {
+    file: File,
+    error: ParseError,
+}
+
+impl ParseDiagnostic {
+    pub fn new(file: File, error: ParseError) -> Self {
+        Self { file, error }
+    }
+}
+
+impl Diagnostic for ParseDiagnostic {
+    fn rule(&self) -> &str {
+        "invalid-syntax"
+    }
+
+    fn message(&self) -> Cow<str> {
+        self.error.error.to_string().into()
+    }
+
+    fn file(&self) -> File {
+        self.file
+    }
+
+    fn range(&self) -> Option<TextRange> {
+        Some(self.error.location)
+    }
+
+    fn severity(&self) -> Severity {
+        Severity::Error
+    }
+}
--- a/crates/ruff_db/src/lib.rs
+++ b/crates/ruff_db/src/lib.rs
@@ -6,6 +6,7 @@ use crate::files::Files;
 use crate::system::System;
 use crate::vendored::VendoredFileSystem;

+pub mod diagnostic;
 pub mod display;
 pub mod file_revision;
 pub mod files;
--- a/crates/ruff_db/src/source.rs
+++ b/crates/ruff_db/src/source.rs
@@ -1,9 +1,7 @@
-use std::fmt::Formatter;
 use std::ops::Deref;
 use std::sync::Arc;

 use countme::Count;
-use salsa::Accumulator;

 use ruff_notebook::Notebook;
 use ruff_python_ast::PySourceType;
@@ -17,16 +15,14 @@ use crate::Db;
 pub fn source_text(db: &dyn Db, file: File) -> SourceText {
    let path = file.path(db);
    let _span = tracing::trace_span!("source_text", file = %path).entered();
-    let mut has_read_error = false;
+    let mut read_error = None;

    let kind = if is_notebook(file.path(db)) {
        file.read_to_notebook(db)
            .unwrap_or_else(|error| {
                tracing::debug!("Failed to read notebook '{path}': {error}");

-                has_read_error = true;
-                SourceDiagnostic(Arc::new(SourceTextError::FailedToReadNotebook(error)))
-                    .accumulate(db);
+                read_error = Some(SourceTextError::FailedToReadNotebook(error.to_string()));
                Notebook::empty()
            })
            .into()
@@ -35,8 +31,7 @@ pub fn source_text(db: &dyn Db, file: File) -> SourceText {
            .unwrap_or_else(|error| {
                tracing::debug!("Failed to read file '{path}': {error}");

-                has_read_error = true;
-                SourceDiagnostic(Arc::new(SourceTextError::FailedToReadFile(error))).accumulate(db);
+                read_error = Some(SourceTextError::FailedToReadFile(error.to_string()));
                String::new()
            })
            .into()
@@ -45,7 +40,7 @@ pub fn source_text(db: &dyn Db, file: File) -> SourceText {
    SourceText {
        inner: Arc::new(SourceTextInner {
            kind,
-            has_read_error,
+            read_error,
            count: Count::new(),
        }),
    }
@@ -98,8 +93,8 @@ impl SourceText {
    }

    /// Returns `true` if there was an error when reading the content of the file.
-    pub fn has_read_error(&self) -> bool {
-        self.inner.has_read_error
+    pub fn read_error(&self) -> Option<&SourceTextError> {
+        self.inner.read_error.as_ref()
    }
 }

@@ -132,7 +127,7 @@ impl std::fmt::Debug for SourceText {
 struct SourceTextInner {
    count: Count<SourceText>,
    kind: SourceTextKind,
-    has_read_error: bool,
+    read_error: Option<SourceTextError>,
 }

 #[derive(Eq, PartialEq)]
@@ -153,21 +148,12 @@ impl From<Notebook> for SourceTextKind {
    }
 }

-#[salsa::accumulator]
-pub struct SourceDiagnostic(Arc<SourceTextError>);
-
-impl std::fmt::Display for SourceDiagnostic {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Display::fmt(&self.0, f)
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, thiserror::Error, PartialEq, Eq, Clone)]
 pub enum SourceTextError {
    #[error("Failed to read notebook: {0}`")]
-    FailedToReadNotebook(#[from] ruff_notebook::NotebookError),
+    FailedToReadNotebook(String),
    #[error("Failed to read file: {0}")]
-    FailedToReadFile(#[from] std::io::Error),
+    FailedToReadFile(String),
 }

 /// Computes the [`LineIndex`] for `file`.
--- a/crates/ruff_linter/Cargo.toml
+++ b/crates/ruff_linter/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.7.2"
+version = "0.7.3"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
--- a/crates/ruff_linter/init.py
+++ b/crates/ruff_linter/init.py
--- a/crates/ruff_linter/resources/test/fixtures/flake8_boolean_trap/FBT.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_boolean_trap/FBT.py
@@ -94,7 +94,7 @@ class Registry:
        object.__setattr__(self, "flag", True)


-from typing import Optional, Union
+from typing import Optional, Union, Self


 def func(x: Union[list, Optional[int | str | float | bool]]):
@@ -154,3 +154,23 @@ from pydantic_settings import BaseSettings

 class Settings(BaseSettings):
    foo: bool = Field(True, exclude=True)
+
+
+# https://github.com/astral-sh/ruff/issues/14202
+class SupportsXorBool:
+    def __xor__(self, other: bool) -> Self: ...
+
+# check overload
+class CustomFloat:
+    @overload
+    def __mul__(self, other: bool) -> Self: ...
+    @overload
+    def __mul__(self, other: float) -> Self: ...
+    @overload
+    def __mul__(self, other: Self) -> Self: ...
+
+# check union
+class BooleanArray:
+    def __or__(self, other: Self | bool) -> Self: ...
+    def __ror__(self, other: Self | bool) -> Self: ...
+    def __ior__(self, other: Self | bool) -> Self: ...
--- a/crates/ruff_linter/resources/test/fixtures/flake8_bugbear/B006_1.pyi
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_bugbear/B006_1.pyi
@@ -0,0 +1,10 @@
+# we disable this rule for pyi files
+
+def mquantiles(
+    a: _ArrayLikeFloat_co,
+    prob: _ArrayLikeFloat_co = [0.25, 0.5, 0.75],
+    alphap: AnyReal = 0.4,
+    betap: AnyReal = 0.4,
+    axis: CanIndex | None = None,
+    limit: tuple[AnyReal, AnyReal] | tuple[()] = (),
+) -> _MArrayND: ...
--- a/Show More
+++ b/Show More