Include build binaries

.gitattributes

@@ -14,7 +14,5 @@ crates/ruff_python_parser/resources/invalid/re_lex_logical_token_mac_eol.py text
 
 crates/ruff_python_parser/resources/inline linguist-generated=true
 
-ruff.schema.json -diff linguist-generated=true text=auto eol=lf
-crates/ruff_python_ast/src/generated.rs -diff linguist-generated=true text=auto eol=lf
-crates/ruff_python_formatter/src/generated.rs -diff linguist-generated=true text=auto eol=lf
+ruff.schema.json linguist-generated=true text=auto eol=lf
 *.md.snap linguist-language=Markdown

.github/actionlint.yaml

@@ -6,5 +6,4 @@ self-hosted-runner:
   labels:
     - depot-ubuntu-latest-8
     - depot-ubuntu-22.04-16
-    - github-windows-2025-x86_64-8
-    - github-windows-2025-x86_64-16
+    - windows-latest-xlarge

.github/workflows/ci.yaml

@@ -203,7 +203,7 @@ jobs:
 
   cargo-test-windows:
     name: "cargo test (windows)"
-    runs-on: github-windows-2025-x86_64-16
+    runs-on: windows-latest-xlarge
     needs: determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     timeout-minutes: 20
@@ -386,12 +386,6 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup component add rustfmt
       - uses: Swatinem/rust-cache@v2
-      # Run all code generation scripts, and verify that the current output is
-      # already checked into git.
-      - run: python crates/ruff_python_ast/generate.py
-      - run: python crates/ruff_python_formatter/generate.py
-      - run: test -z "$(git status --porcelain)"
-      # Verify that adding a plugin or rule produces clean code.
       - run: ./scripts/add_rule.py --name DoTheThing --prefix F --code 999 --linter pyflakes
       - run: cargo check
       - run: cargo fmt --all --check

.github/workflows/publish-playground.yml

@@ -49,7 +49,7 @@ jobs:
         working-directory: playground
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.13.1
+        uses: cloudflare/wrangler-action@v3.13.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/publish-wasm.yml

@@ -55,3 +55,9 @@ jobs:
         run: npm publish --provenance --access public crates/ruff_wasm/pkg
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Archive npm failure logs
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: npm-logs
+          path: ~/.npm/_logs

.github/workflows/release.yml

@@ -202,20 +202,6 @@ jobs:
           name: artifacts-dist-manifest
           path: dist-manifest.json
 
-  custom-publish-pypi:
-    needs:
-      - plan
-      - host
-    if: ${{ !fromJson(needs.plan.outputs.val).announcement_is_prerelease || fromJson(needs.plan.outputs.val).publish_prereleases }}
-    uses: ./.github/workflows/publish-pypi.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-    # publish jobs get escalated permissions
-    permissions:
-      "id-token": "write"
-      "packages": "write"
-
   custom-publish-wasm:
     needs:
       - plan
@@ -236,12 +222,11 @@ jobs:
     needs:
       - plan
       - host
-      - custom-publish-pypi
       - custom-publish-wasm
     # use "always() && ..." to allow us to wait for all publish jobs while
     # still allowing individual publish jobs to skip themselves (for prereleases).
     # "host" however must run to completion, no skipping allowed!
-    if: ${{ always() && needs.host.result == 'success' && (needs.custom-publish-pypi.result == 'skipped' || needs.custom-publish-pypi.result == 'success') && (needs.custom-publish-wasm.result == 'skipped' || needs.custom-publish-wasm.result == 'success') }}
+    if: ${{ always() && needs.host.result == 'success' && (needs.custom-publish-wasm.result == 'skipped' || needs.custom-publish-wasm.result == 'success') }}
     runs-on: "ubuntu-20.04"
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.pre-commit-config.yaml

@@ -4,7 +4,7 @@ exclude: |
   (?x)^(
     .github/workflows/release.yml|
     crates/red_knot_vendored/vendor/.*|
-    crates/red_knot_project/resources/.*|
+    crates/red_knot_workspace/resources/.*|
     crates/ruff_linter/resources/.*|
     crates/ruff_linter/src/rules/.*/snapshots/.*|
     crates/ruff_notebook/resources/.*|
@@ -73,7 +73,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.2
+    rev: v0.9.1
     hooks:
       - id: ruff-format
       - id: ruff
@@ -91,7 +91,7 @@ repos:
   # zizmor detects security vulnerabilities in GitHub Actions workflows.
   # Additional configuration for the tool is found in `.github/zizmor.yml`
   - repo: https://github.com/woodruffw/zizmor-pre-commit
-    rev: v1.1.1
+    rev: v1.0.1
     hooks:
       - id: zizmor
 
@@ -103,7 +103,7 @@ repos:
   # `actionlint` hook, for verifying correct syntax in GitHub Actions workflows.
   # Some additional configuration for `actionlint` can be found in `.github/actionlint.yaml`.
   - repo: https://github.com/rhysd/actionlint
-    rev: v1.7.7
+    rev: v1.7.6
     hooks:
       - id: actionlint
         stages:

Cargo.lock

@@ -212,9 +212,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.8.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
+checksum = "1be3f42a67d6d345ecd59f675f3f012d6974981560836e938c22b424b85ce1be"
 
 [[package]]
 name = "block-buffer"
@@ -477,7 +477,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
 dependencies = [
  "lazy_static",
- "windows-sys 0.59.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -1062,7 +1062,7 @@ version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0bf760ebf69878d9fd8f110c89703d90ce35095324d1f1edcb595c63945ee757"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "ignore",
  "walkdir",
 ]
@@ -1343,9 +1343,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.7.1"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652"
+checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.2",
@@ -1374,11 +1374,11 @@ checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
 
 [[package]]
 name = "inotify"
-version = "0.11.0"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f37dccff2791ab604f9babef0ba14fbe0be30bd368dc541e2b08d07c8aa908f3"
+checksum = "fdd168d97690d0b8c412d6b6c10360277f4d7ee495c5d0d5d5fe0854923255cc"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 1.3.2",
  "inotify-sys",
  "libc",
 ]
@@ -1422,6 +1422,15 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "is-docker"
 version = "0.2.0"
@@ -1601,7 +1610,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "libc",
  "redox_syscall 0.5.3",
 ]
@@ -1648,9 +1657,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.25"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04cbf5b083de1c7e0222a7a51dbfdba1cbe1c6ab0b15e29fff3f6c077fd9cd9f"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "lsp-server"
@@ -1772,7 +1781,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -1796,11 +1805,11 @@ checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
 
 [[package]]
 name = "notify"
-version = "8.0.0"
+version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fee8403b3d66ac7b26aee6e40a897d85dc5ce26f44da36b8b73e987cc52e943"
+checksum = "c533b4c39709f9ba5005d8002048266593c1cfaf3c5f0739d5b8ab0c6c504009"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "filetime",
  "fsevent-sys",
  "inotify",
@@ -1810,14 +1819,17 @@ dependencies = [
  "mio",
  "notify-types",
  "walkdir",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "notify-types"
-version = "2.0.0"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e0826a989adedc2a244799e823aece04662b66609d96af8dff7ac6df9a8925d"
+checksum = "7393c226621f817964ffb3dc5704f9509e107a8b024b489cc2c1b217378785df"
+dependencies = [
+ "instant",
+]
 
 [[package]]
 name = "nu-ansi-term"
@@ -1883,9 +1895,9 @@ checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
 [[package]]
 name = "ordermap"
-version = "0.5.5"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c55fdf45a2b1e929e3656d404395767e05c98b6ebd8157eb31e370077d545160"
+checksum = "f80a48eb68b6a7da9829b8b0429011708f775af80676a91063d023a66a656106"
 dependencies = [
  "indexmap",
 ]
@@ -2324,55 +2336,25 @@ dependencies = [
  "crossbeam",
  "ctrlc",
  "filetime",
- "insta",
- "insta-cmd",
  "rayon",
- "red_knot_project",
  "red_knot_python_semantic",
  "red_knot_server",
- "regex",
+ "red_knot_workspace",
  "ruff_db",
  "salsa",
  "tempfile",
- "toml",
  "tracing",
  "tracing-flame",
  "tracing-subscriber",
  "tracing-tree",
 ]
 
-[[package]]
-name = "red_knot_project"
-version = "0.0.0"
-dependencies = [
- "anyhow",
- "crossbeam",
- "glob",
- "insta",
- "notify",
- "pep440_rs",
- "rayon",
- "red_knot_python_semantic",
- "red_knot_vendored",
- "ruff_cache",
- "ruff_db",
- "ruff_macros",
- "ruff_python_ast",
- "ruff_text_size",
- "rustc-hash 2.1.0",
- "salsa",
- "serde",
- "thiserror 2.0.11",
- "toml",
- "tracing",
-]
-
 [[package]]
 name = "red_knot_python_semantic"
 version = "0.0.0"
 dependencies = [
  "anyhow",
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "camino",
  "compact_str",
  "countme",
@@ -2419,7 +2401,7 @@ dependencies = [
  "libc",
  "lsp-server",
  "lsp-types",
- "red_knot_project",
+ "red_knot_workspace",
  "ruff_db",
  "ruff_notebook",
  "ruff_python_ast",
@@ -2474,14 +2456,39 @@ dependencies = [
  "console_log",
  "js-sys",
  "log",
- "red_knot_project",
  "red_knot_python_semantic",
+ "red_knot_workspace",
  "ruff_db",
  "ruff_notebook",
  "wasm-bindgen",
  "wasm-bindgen-test",
 ]
 
+[[package]]
+name = "red_knot_workspace"
+version = "0.0.0"
+dependencies = [
+ "anyhow",
+ "crossbeam",
+ "glob",
+ "insta",
+ "notify",
+ "pep440_rs",
+ "rayon",
+ "red_knot_python_semantic",
+ "red_knot_vendored",
+ "ruff_cache",
+ "ruff_db",
+ "ruff_python_ast",
+ "ruff_text_size",
+ "rustc-hash 2.1.0",
+ "salsa",
+ "serde",
+ "thiserror 2.0.11",
+ "toml",
+ "tracing",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.4.1"
@@ -2497,7 +2504,7 @@ version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
 ]
 
 [[package]]
@@ -2589,7 +2596,7 @@ dependencies = [
  "argfile",
  "assert_fs",
  "bincode",
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "cachedir",
  "chrono",
  "clap",
@@ -2661,8 +2668,8 @@ dependencies = [
  "criterion",
  "mimalloc",
  "rayon",
- "red_knot_project",
  "red_knot_python_semantic",
+ "red_knot_workspace",
  "ruff_db",
  "ruff_linter",
  "ruff_python_ast",
@@ -2821,7 +2828,7 @@ version = "0.9.2"
 dependencies = [
  "aho-corasick",
  "anyhow",
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "chrono",
  "clap",
  "colored 3.0.0",
@@ -2911,7 +2918,7 @@ name = "ruff_python_ast"
 version = "0.0.0"
 dependencies = [
  "aho-corasick",
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "compact_str",
  "is-macro",
  "itertools 0.14.0",
@@ -2993,7 +3000,7 @@ dependencies = [
 name = "ruff_python_literal"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "itertools 0.14.0",
  "ruff_python_ast",
  "unic-ucd-category",
@@ -3004,7 +3011,7 @@ name = "ruff_python_parser"
 version = "0.0.0"
 dependencies = [
  "anyhow",
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "bstr",
  "compact_str",
  "insta",
@@ -3036,7 +3043,7 @@ dependencies = [
 name = "ruff_python_semantic"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "is-macro",
  "ruff_cache",
  "ruff_index",
@@ -3055,7 +3062,7 @@ dependencies = [
 name = "ruff_python_stdlib"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "unicode-ident",
 ]
 
@@ -3222,7 +3229,7 @@ version = "0.38.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "99e4ea3e1cdc4b559b8e5650f9c8e5998e3e5c1343b4eaf034565f32318d63c0"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.7.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -3405,9 +3412,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.137"
+version = "1.0.135"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "930cfb6e6abf99298aaad7d29abbef7a9999a9a8806a40088f55f0dcec03146b"
+checksum = "2b0d7ba2887406110130a978386c4e1befb98c674b4fba677954e4db976630d9"
 dependencies = [
  "itoa",
  "memchr",
@@ -3504,9 +3511,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "similar"
-version = "2.7.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+checksum = "1de1d4f81173b03af4c0cbed3c898f6bff5b870e4a7f5d6f4057d62a7a4b686e"
 
 [[package]]
 name = "siphasher"
@@ -3926,9 +3933,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-indicatif"
-version = "0.3.9"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8201ca430e0cd893ef978226fd3516c06d9c494181c8bf4e5b32e30ed4b40aa1"
+checksum = "74ba258e9de86447f75edf6455fded8e5242704c6fccffe7bf8d7fb6daef1180"
 dependencies = [
  "indicatif",
  "tracing",
@@ -4169,9 +4176,9 @@ checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
 
 [[package]]
 name = "uuid"
-version = "1.12.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "744018581f9a3454a9e15beb8a33b017183f1e7c0cd170232a2d1453b23a51c4"
+checksum = "b913a3b5fe84142e269d63cc62b64319ccaf89b748fc31fe025177f767a756c4"
 dependencies = [
  "getrandom",
  "rand",
@@ -4181,9 +4188,9 @@ dependencies = [
 
 [[package]]
 name = "uuid-macro-internal"
-version = "1.12.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "144b419c512fdd5eaa4c2998813e32aaab2b257746ee038de93985a99635501d"
+checksum = "c91084647266237a48351d05d55dee65bba9e1b597f555fcf54680f820284a1c"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

@@ -41,7 +41,7 @@ ruff_workspace = { path = "crates/ruff_workspace" }
 red_knot_python_semantic = { path = "crates/red_knot_python_semantic" }
 red_knot_server = { path = "crates/red_knot_server" }
 red_knot_test = { path = "crates/red_knot_test" }
-red_knot_project = { path = "crates/red_knot_project", default-features = false }
+red_knot_workspace = { path = "crates/red_knot_workspace", default-features = false }
 
 aho-corasick = { version = "1.1.3" }
 anstream = { version = "0.6.18" }
@@ -105,7 +105,7 @@ matchit = { version = "0.8.1" }
 memchr = { version = "2.7.1" }
 mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
-notify = { version = "8.0.0" }
+notify = { version = "7.0.0" }
 ordermap = { version = "0.5.0" }
 path-absolutize = { version = "3.1.1" }
 path-slash = { version = "0.2.1" }
@@ -303,7 +303,7 @@ build-local-artifacts = false
 # Local artifacts jobs to run in CI
 local-artifacts-jobs = ["./build-binaries", "./build-docker"]
 # Publish jobs to run in CI
-publish-jobs = ["./publish-pypi", "./publish-wasm"]
+publish-jobs = ["./publish-wasm"]
 # Post-announce jobs to run in CI
 post-announce-jobs = ["./notify-dependents", "./publish-docs", "./publish-playground"]
 # Custom permissions for GitHub Jobs

crates/red_knot/Cargo.toml

@@ -13,7 +13,7 @@ license.workspace = true
 
 [dependencies]
 red_knot_python_semantic = { workspace = true }
-red_knot_project = { workspace = true, features = ["zstd"] }
+red_knot_workspace = { workspace = true, features = ["zstd"] }
 red_knot_server = { workspace = true }
 ruff_db = { workspace = true, features = ["os", "cache"] }
 
@@ -32,14 +32,9 @@ tracing-flame = { workspace = true }
 tracing-tree = { workspace = true }
 
 [dev-dependencies]
-ruff_db = { workspace = true, features = ["testing"] }
-
-insta = { workspace = true, features = ["filters"] }
-insta-cmd = { workspace = true }
 filetime = { workspace = true }
-regex = { workspace = true }
 tempfile = { workspace = true }
-toml = { workspace = true }
+ruff_db = { workspace = true, features = ["testing"] }
 
 [lints]
 workspace = true

crates/red_knot/src/main.rs

@@ -6,11 +6,13 @@ use clap::Parser;
 use colored::Colorize;
 use crossbeam::channel as crossbeam_channel;
 use python_version::PythonVersion;
-use red_knot_project::metadata::options::{EnvironmentOptions, Options};
-use red_knot_project::watch;
-use red_knot_project::watch::ProjectWatcher;
-use red_knot_project::{ProjectDatabase, ProjectMetadata};
+use red_knot_python_semantic::SitePackages;
 use red_knot_server::run_server;
+use red_knot_workspace::db::ProjectDatabase;
+use red_knot_workspace::project::settings::Configuration;
+use red_knot_workspace::project::ProjectMetadata;
+use red_knot_workspace::watch;
+use red_knot_workspace::watch::ProjectWatcher;
 use ruff_db::diagnostic::Diagnostic;
 use ruff_db::system::{OsSystem, System, SystemPath, SystemPathBuf};
 use salsa::plumbing::ZalsaDatabase;
@@ -69,28 +71,31 @@ struct Args {
 }
 
 impl Args {
-    fn to_options(&self, cli_cwd: &SystemPath) -> Options {
-        Options {
-            environment: Some(EnvironmentOptions {
-                python_version: self.python_version.map(Into::into),
-                venv_path: self
-                    .venv_path
-                    .as_ref()
-                    .map(|venv_path| SystemPath::absolute(venv_path, cli_cwd)),
-                typeshed: self
-                    .typeshed
-                    .as_ref()
-                    .map(|typeshed| SystemPath::absolute(typeshed, cli_cwd)),
-                extra_paths: self.extra_search_path.as_ref().map(|extra_search_paths| {
-                    extra_search_paths
-                        .iter()
-                        .map(|path| SystemPath::absolute(path, cli_cwd))
-                        .collect()
-                }),
-                ..EnvironmentOptions::default()
-            }),
-            ..Default::default()
+    fn to_configuration(&self, cli_cwd: &SystemPath) -> Configuration {
+        let mut configuration = Configuration::default();
+
+        if let Some(python_version) = self.python_version {
+            configuration.python_version = Some(python_version.into());
         }
+
+        if let Some(venv_path) = &self.venv_path {
+            configuration.search_paths.site_packages = Some(SitePackages::Derived {
+                venv_path: SystemPath::absolute(venv_path, cli_cwd),
+            });
+        }
+
+        if let Some(typeshed) = &self.typeshed {
+            configuration.search_paths.typeshed = Some(SystemPath::absolute(typeshed, cli_cwd));
+        }
+
+        if let Some(extra_search_paths) = &self.extra_search_path {
+            configuration.search_paths.extra_paths = extra_search_paths
+                .iter()
+                .map(|path| Some(SystemPath::absolute(path, cli_cwd)))
+                .collect();
+        }
+
+        configuration
     }
 }
 
@@ -159,13 +164,18 @@ fn run() -> anyhow::Result<ExitStatus> {
         .unwrap_or_else(|| cli_base_path.clone());
 
     let system = OsSystem::new(cwd.clone());
-    let cli_options = args.to_options(&cwd);
-    let mut workspace_metadata = ProjectMetadata::discover(system.current_directory(), &system)?;
-    workspace_metadata.apply_cli_options(cli_options.clone());
+    let cli_configuration = args.to_configuration(&cwd);
+    let workspace_metadata = ProjectMetadata::discover(
+        system.current_directory(),
+        &system,
+        Some(&cli_configuration),
+    )?;
 
+    // TODO: Use the `program_settings` to compute the key for the database's persistent
+    //   cache and load the cache if it exists.
     let mut db = ProjectDatabase::new(workspace_metadata, system)?;
 
-    let (main_loop, main_loop_cancellation_token) = MainLoop::new(cli_options);
+    let (main_loop, main_loop_cancellation_token) = MainLoop::new(cli_configuration);
 
     // Listen to Ctrl+C and abort the watch mode.
     let main_loop_cancellation_token = Mutex::new(Some(main_loop_cancellation_token));
@@ -218,11 +228,11 @@ struct MainLoop {
     /// The file system watcher, if running in watch mode.
     watcher: Option<ProjectWatcher>,
 
-    cli_options: Options,
+    cli_configuration: Configuration,
 }
 
 impl MainLoop {
-    fn new(cli_options: Options) -> (Self, MainLoopCancellationToken) {
+    fn new(cli_configuration: Configuration) -> (Self, MainLoopCancellationToken) {
         let (sender, receiver) = crossbeam_channel::bounded(10);
 
         (
@@ -230,7 +240,7 @@ impl MainLoop {
                 sender: sender.clone(),
                 receiver,
                 watcher: None,
-                cli_options,
+                cli_configuration,
             },
             MainLoopCancellationToken { sender },
         )
@@ -314,7 +324,7 @@ impl MainLoop {
                 MainLoopMessage::ApplyChanges(changes) => {
                     revision += 1;
                     // Automatically cancels any pending queries and waits for them to complete.
-                    db.apply_changes(changes, Some(&self.cli_options));
+                    db.apply_changes(changes, Some(&self.cli_configuration));
                     if let Some(watcher) = self.watcher.as_mut() {
                         watcher.update(db);
                     }

crates/red_knot/tests/cli.rs

@@ -1,60 +0,0 @@
-use anyhow::Context;
-use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
-use std::process::Command;
-use tempfile::TempDir;
-
-/// Specifying an option on the CLI should take precedence over the same setting in the
-/// project's configuration.
-#[test]
-fn test_config_override() -> anyhow::Result<()> {
-    let tempdir = TempDir::new()?;
-
-    std::fs::write(
-        tempdir.path().join("pyproject.toml"),
-        r#"
-[tool.knot.environment]
-python-version = "3.11"
-"#,
-    )
-    .context("Failed to write settings")?;
-
-    std::fs::write(
-        tempdir.path().join("test.py"),
-        r#"
-import sys
-
-# Access `sys.last_exc` that was only added in Python 3.12
-print(sys.last_exc)
-"#,
-    )
-    .context("Failed to write test.py")?;
-
-    insta::with_settings!({filters => vec![(&*tempdir_filter(&tempdir), "<temp_dir>/")]}, {
-        assert_cmd_snapshot!(knot().arg("--project").arg(tempdir.path()), @r"
-        success: false
-        exit_code: 1
-        ----- stdout -----
-        error[lint:unresolved-attribute] <temp_dir>/test.py:5:7 Type `<module 'sys'>` has no attribute `last_exc`
-
-        ----- stderr -----
-        ");
-    });
-
-    assert_cmd_snapshot!(knot().arg("--project").arg(tempdir.path()).arg("--python-version").arg("3.12"), @r"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-
-    ----- stderr -----
-    ");
-
-    Ok(())
-}
-
-fn knot() -> Command {
-    Command::new(get_cargo_bin("red_knot"))
-}
-
-fn tempdir_filter(tempdir: &TempDir) -> String {
-    format!(r"{}\\?/?", regex::escape(tempdir.path().to_str().unwrap()))
-}

crates/red_knot/tests/file_watching.rs

@@ -4,11 +4,11 @@ use std::io::Write;
 use std::time::{Duration, Instant};
 
 use anyhow::{anyhow, Context};
-use red_knot_project::metadata::options::{EnvironmentOptions, Options};
-use red_knot_project::metadata::pyproject::{PyProject, Tool};
-use red_knot_project::watch::{directory_watcher, ChangeEvent, ProjectWatcher};
-use red_knot_project::{Db, ProjectDatabase, ProjectMetadata};
-use red_knot_python_semantic::{resolve_module, ModuleName, PythonPlatform, PythonVersion};
+use red_knot_python_semantic::{resolve_module, ModuleName, Program, PythonVersion, SitePackages};
+use red_knot_workspace::db::{Db, ProjectDatabase};
+use red_knot_workspace::project::settings::{Configuration, SearchPathConfiguration};
+use red_knot_workspace::project::ProjectMetadata;
+use red_knot_workspace::watch::{directory_watcher, ChangeEvent, ProjectWatcher};
 use ruff_db::files::{system_path_to_file, File, FileError};
 use ruff_db::source::source_text;
 use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
@@ -22,6 +22,7 @@ struct TestCase {
     /// We need to hold on to it in the test case or the temp files get deleted.
     _temp_dir: tempfile::TempDir,
     root_dir: SystemPathBuf,
+    configuration: Configuration,
 }
 
 impl TestCase {
@@ -111,44 +112,19 @@ impl TestCase {
         Ok(all_events)
     }
 
-    fn take_watch_changes<M: MatchEvent>(&self, matcher: M) -> Vec<ChangeEvent> {
-        self.try_take_watch_changes(matcher, Duration::from_secs(10))
+    fn take_watch_changes(&self) -> Vec<ChangeEvent> {
+        self.try_take_watch_changes(Duration::from_secs(10))
             .expect("Expected watch changes but observed none")
     }
 
-    fn try_take_watch_changes<M: MatchEvent>(
-        &self,
-        mut matcher: M,
-        timeout: Duration,
-    ) -> Result<Vec<ChangeEvent>, Vec<ChangeEvent>> {
-        let watcher = self
-            .watcher
-            .as_ref()
-            .expect("Cannot call `try_take_watch_changes` after `stop_watch`");
+    fn try_take_watch_changes(&self, timeout: Duration) -> Option<Vec<ChangeEvent>> {
+        let watcher = self.watcher.as_ref()?;
 
-        let start = Instant::now();
-        let mut all_events = Vec::new();
-
-        loop {
-            let events = self
-                .changes_receiver
-                .recv_timeout(Duration::from_millis(100))
-                .unwrap_or_default();
-
-            if events
-                .iter()
-                .any(|event| matcher.match_event(event) || event.is_rescan())
-            {
-                all_events.extend(events);
-                break;
-            }
-
-            all_events.extend(events);
-
-            if start.elapsed() > timeout {
-                return Err(all_events);
-            }
-        }
+        let mut all_events = self
+            .changes_receiver
+            .recv_timeout(timeout)
+            .unwrap_or_default();
+        watcher.flush();
 
         while let Ok(event) = self
             .changes_receiver
@@ -158,28 +134,26 @@ impl TestCase {
             watcher.flush();
         }
 
-        Ok(all_events)
+        if all_events.is_empty() {
+            return None;
+        }
+        Some(all_events)
     }
 
     fn apply_changes(&mut self, changes: Vec<ChangeEvent>) {
-        self.db.apply_changes(changes, None);
+        self.db.apply_changes(changes, Some(&self.configuration));
     }
 
-    fn update_options(&mut self, options: Options) -> anyhow::Result<()> {
-        std::fs::write(
-            self.project_path("pyproject.toml").as_std_path(),
-            toml::to_string(&PyProject {
-                project: None,
-                tool: Some(Tool {
-                    knot: Some(options),
-                }),
-            })
-            .context("Failed to serialize options")?,
-        )
-        .context("Failed to write configuration")?;
+    fn update_search_path_settings(
+        &mut self,
+        configuration: SearchPathConfiguration,
+    ) -> anyhow::Result<()> {
+        let program = Program::get(self.db());
 
-        let changes = self.take_watch_changes(event_for_file("pyproject.toml"));
-        self.apply_changes(changes);
+        let new_settings = configuration.to_settings(self.db.project().root(&self.db));
+        self.configuration.search_paths = configuration;
+
+        program.update_search_paths(&mut self.db, &new_settings)?;
 
         if let Some(watcher) = &mut self.watcher {
             watcher.update(&self.db);
@@ -260,13 +234,14 @@ fn setup<F>(setup_files: F) -> anyhow::Result<TestCase>
 where
     F: SetupFiles,
 {
-    setup_with_options(setup_files, |_root, _project_path| None)
+    setup_with_search_paths(setup_files, |_root, _project_path| {
+        SearchPathConfiguration::default()
+    })
 }
 
-// TODO: Replace with configuration?
-fn setup_with_options<F>(
+fn setup_with_search_paths<F>(
     setup_files: F,
-    create_options: impl FnOnce(&SystemPath, &SystemPath) -> Option<Options>,
+    create_search_paths: impl FnOnce(&SystemPath, &SystemPath) -> SearchPathConfiguration,
 ) -> anyhow::Result<TestCase>
 where
     F: SetupFiles,
@@ -300,33 +275,32 @@ where
 
     let system = OsSystem::new(&project_path);
 
-    if let Some(options) = create_options(&root_path, &project_path) {
-        std::fs::write(
-            project_path.join("pyproject.toml").as_std_path(),
-            toml::to_string(&PyProject {
-                project: None,
-                tool: Some(Tool {
-                    knot: Some(options),
-                }),
-            })
-            .context("Failed to serialize options")?,
-        )
-        .context("Failed to write configuration")?;
-    }
+    let search_paths = create_search_paths(&root_path, &project_path);
 
-    let project = ProjectMetadata::discover(&project_path, &system)?;
-    let program_settings = project.to_program_settings(&system);
-
-    for path in program_settings
-        .search_paths
+    for path in search_paths
         .extra_paths
         .iter()
-        .chain(program_settings.search_paths.typeshed.as_ref())
+        .flatten()
+        .chain(search_paths.typeshed.iter())
+        .chain(search_paths.site_packages.iter().flat_map(|site_packages| {
+            if let SitePackages::Known(path) = site_packages {
+                path.as_slice()
+            } else {
+                &[]
+            }
+        }))
     {
         std::fs::create_dir_all(path.as_std_path())
             .with_context(|| format!("Failed to create search path `{path}`"))?;
     }
 
+    let configuration = Configuration {
+        python_version: Some(PythonVersion::PY312),
+        search_paths,
+    };
+
+    let project = ProjectMetadata::discover(&project_path, &system, Some(&configuration))?;
+
     let db = ProjectDatabase::new(project, system)?;
 
     let (sender, receiver) = crossbeam::channel::unbounded();
@@ -342,12 +316,12 @@ where
         watcher: Some(watcher),
         _temp_dir: temp_dir,
         root_dir: root_path,
+        configuration,
     };
 
     // Sometimes the file watcher reports changes for events that happened before the watcher was started.
     // Do a best effort at dropping these events.
-    let _ =
-        test_case.try_take_watch_changes(|_event: &ChangeEvent| true, Duration::from_millis(100));
+    test_case.try_take_watch_changes(Duration::from_millis(100));
 
     Ok(test_case)
 }
@@ -788,15 +762,13 @@ fn directory_deleted() -> anyhow::Result<()> {
 
 #[test]
 fn search_path() -> anyhow::Result<()> {
-    let mut case = setup_with_options([("bar.py", "import sub.a")], |root_path, _project_path| {
-        Some(Options {
-            environment: Some(EnvironmentOptions {
-                extra_paths: Some(vec![root_path.join("site_packages")]),
-                ..EnvironmentOptions::default()
-            }),
-            ..Options::default()
-        })
-    })?;
+    let mut case =
+        setup_with_search_paths([("bar.py", "import sub.a")], |root_path, _project_path| {
+            SearchPathConfiguration {
+                site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
+                ..SearchPathConfiguration::default()
+            }
+        })?;
 
     let site_packages = case.root_path().join("site_packages");
 
@@ -830,12 +802,9 @@ fn add_search_path() -> anyhow::Result<()> {
     assert!(resolve_module(case.db().upcast(), &ModuleName::new_static("a").unwrap()).is_none());
 
     // Register site-packages as a search path.
-    case.update_options(Options {
-        environment: Some(EnvironmentOptions {
-            extra_paths: Some(vec![site_packages.clone()]),
-            ..EnvironmentOptions::default()
-        }),
-        ..Options::default()
+    case.update_search_path_settings(SearchPathConfiguration {
+        site_packages: Some(SitePackages::Known(vec![site_packages.clone()])),
+        ..SearchPathConfiguration::default()
     })
     .expect("Search path settings to be valid");
 
@@ -852,22 +821,19 @@ fn add_search_path() -> anyhow::Result<()> {
 
 #[test]
 fn remove_search_path() -> anyhow::Result<()> {
-    let mut case = setup_with_options([("bar.py", "import sub.a")], |root_path, _project_path| {
-        Some(Options {
-            environment: Some(EnvironmentOptions {
-                extra_paths: Some(vec![root_path.join("site_packages")]),
-                ..EnvironmentOptions::default()
-            }),
-            ..Options::default()
-        })
-    })?;
+    let mut case =
+        setup_with_search_paths([("bar.py", "import sub.a")], |root_path, _project_path| {
+            SearchPathConfiguration {
+                site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
+                ..SearchPathConfiguration::default()
+            }
+        })?;
 
     // Remove site packages from the search path settings.
     let site_packages = case.root_path().join("site_packages");
-
-    case.update_options(Options {
-        environment: None,
-        ..Options::default()
+    case.update_search_path_settings(SearchPathConfiguration {
+        site_packages: None,
+        ..SearchPathConfiguration::default()
     })
     .expect("Search path settings to be valid");
 
@@ -880,63 +846,9 @@ fn remove_search_path() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[test]
-fn change_python_version_and_platform() -> anyhow::Result<()> {
-    let mut case = setup_with_options(
-        // `sys.last_exc` is a Python 3.12 only feature
-        // `os.getegid()` is Unix only
-        [(
-            "bar.py",
-            r#"
-import sys
-import os
-print(sys.last_exc, os.getegid())
-"#,
-        )],
-        |_root_path, _project_path| {
-            Some(Options {
-                environment: Some(EnvironmentOptions {
-                    python_version: Some(PythonVersion::PY311),
-                    python_platform: Some(PythonPlatform::Identifier("win32".to_string())),
-                    ..EnvironmentOptions::default()
-                }),
-                ..Options::default()
-            })
-        },
-    )?;
-
-    let diagnostics = case.db.check().context("Failed to check project.")?;
-
-    assert_eq!(diagnostics.len(), 2);
-    assert_eq!(
-        diagnostics[0].message(),
-        "Type `<module 'sys'>` has no attribute `last_exc`"
-    );
-    assert_eq!(
-        diagnostics[1].message(),
-        "Type `<module 'os'>` has no attribute `getegid`"
-    );
-
-    // Change the python version
-    case.update_options(Options {
-        environment: Some(EnvironmentOptions {
-            python_version: Some(PythonVersion::PY312),
-            python_platform: Some(PythonPlatform::Identifier("linux".to_string())),
-            ..EnvironmentOptions::default()
-        }),
-        ..Options::default()
-    })
-    .expect("Search path settings to be valid");
-
-    let diagnostics = case.db.check().context("Failed to check project.")?;
-    assert!(diagnostics.is_empty());
-
-    Ok(())
-}
-
 #[test]
 fn changed_versions_file() -> anyhow::Result<()> {
-    let mut case = setup_with_options(
+    let mut case = setup_with_search_paths(
         |root_path: &SystemPath, project_path: &SystemPath| {
             std::fs::write(project_path.join("bar.py").as_std_path(), "import sub.a")?;
             std::fs::create_dir_all(root_path.join("typeshed/stdlib").as_std_path())?;
@@ -948,14 +860,9 @@ fn changed_versions_file() -> anyhow::Result<()> {
 
             Ok(())
         },
-        |root_path, _project_path| {
-            Some(Options {
-                environment: Some(EnvironmentOptions {
-                    typeshed: Some(root_path.join("typeshed")),
-                    ..EnvironmentOptions::default()
-                }),
-                ..Options::default()
-            })
+        |root_path, _project_path| SearchPathConfiguration {
+            typeshed: Some(root_path.join("typeshed")),
+            ..SearchPathConfiguration::default()
         },
     )?;
 
@@ -1220,7 +1127,7 @@ mod unix {
         update_file(baz_original, "def baz(): print('Version 2')")
             .context("Failed to update bar/baz.py")?;
 
-        let changes = case.take_watch_changes(event_for_file("baz.py"));
+        let changes = case.take_watch_changes();
 
         case.apply_changes(changes);
 
@@ -1352,7 +1259,7 @@ mod unix {
     /// ```
     #[test]
     fn symlinked_module_search_path() -> anyhow::Result<()> {
-        let mut case = setup_with_options(
+        let mut case = setup_with_search_paths(
             |root: &SystemPath, project: &SystemPath| {
                 // Set up the symlink target.
                 let site_packages = root.join("site-packages");
@@ -1375,15 +1282,11 @@ mod unix {
 
                 Ok(())
             },
-            |_root, project| {
-                Some(Options {
-                    environment: Some(EnvironmentOptions {
-                        extra_paths: Some(vec![project.join(".venv/lib/python3.12/site-packages")]),
-                        python_version: Some(PythonVersion::PY312),
-                        ..EnvironmentOptions::default()
-                    }),
-                    ..Options::default()
-                })
+            |_root, project| SearchPathConfiguration {
+                site_packages: Some(SitePackages::Known(vec![
+                    project.join(".venv/lib/python3.12/site-packages")
+                ])),
+                ..SearchPathConfiguration::default()
             },
         )?;
 

crates/red_knot_project/src/combine.rs

@@ -1,190 +0,0 @@
-use std::{collections::HashMap, hash::BuildHasher};
-
-use red_knot_python_semantic::{PythonPlatform, PythonVersion, SitePackages};
-use ruff_db::system::SystemPathBuf;
-
-/// Combine two values, preferring the values in `self`.
-///
-/// The logic should follow that of Cargo's `config.toml`:
-///
-/// > If a key is specified in multiple config files, the values will get merged together.
-/// > Numbers, strings, and booleans will use the value in the deeper config directory taking
-/// > precedence over ancestor directories, where the home directory is the lowest priority.
-/// > Arrays will be joined together with higher precedence items being placed later in the
-/// > merged array.
-///
-/// ## uv Compatibility
-///
-/// The merging behavior differs from uv in that values with higher precedence in arrays
-/// are placed later in the merged array. This is because we want to support overriding
-/// earlier values and values from other configurations, including unsetting them.
-/// For example: patterns coming last in file inclusion and exclusion patterns
-/// allow overriding earlier patterns, matching the `gitignore` behavior.
-/// Generally speaking, it feels more intuitive if later values override earlier values
-/// than the other way around: `knot --exclude png --exclude "!important.png"`.
-///
-/// The main downside of this approach is that the ordering can be surprising in cases
-/// where the option has a "first match" semantic and not a "last match" wins.
-/// One such example is `extra-paths` where the semantics is given by Python:
-/// the module on the first matching search path wins.
-///
-/// ```toml
-/// [environment]
-/// extra-paths = ["b", "c"]
-/// ```
-///
-/// ```bash
-/// knot --extra-paths a
-/// ```
-///
-/// That's why a user might expect that this configuration results in `["a", "b", "c"]`,
-/// because the CLI has higher precedence. However, the current implementation results in a
-/// resolved extra search path of `["b", "c", "a"]`, which means `a` will be tried last.
-///
-/// There's an argument here that the user should be able to specify the order of the paths,
-/// because only then is the user in full control of where to insert the path when specyifing `extra-paths`
-/// in multiple sources.
-///
-/// ## Macro
-/// You can automatically derive `Combine` for structs with named fields by using `derive(ruff_macros::Combine)`.
-pub trait Combine {
-    #[must_use]
-    fn combine(mut self, other: Self) -> Self
-    where
-        Self: Sized,
-    {
-        self.combine_with(other);
-        self
-    }
-
-    fn combine_with(&mut self, other: Self);
-}
-
-impl<T> Combine for Option<T>
-where
-    T: Combine,
-{
-    fn combine(self, other: Self) -> Self
-    where
-        Self: Sized,
-    {
-        match (self, other) {
-            (Some(a), Some(b)) => Some(a.combine(b)),
-            (None, Some(b)) => Some(b),
-            (a, _) => a,
-        }
-    }
-
-    fn combine_with(&mut self, other: Self) {
-        match (self, other) {
-            (Some(a), Some(b)) => {
-                a.combine_with(b);
-            }
-            (a @ None, Some(b)) => {
-                *a = Some(b);
-            }
-            _ => {}
-        }
-    }
-}
-
-impl<T> Combine for Vec<T> {
-    fn combine_with(&mut self, mut other: Self) {
-        // `self` takes precedence over `other` but values with higher precedence must be placed after.
-        // Swap the vectors so that `other` is the one that gets extended, so that the values of `self` come after.
-        std::mem::swap(self, &mut other);
-        self.extend(other);
-    }
-}
-
-impl<K, V, S> Combine for HashMap<K, V, S>
-where
-    K: Eq + std::hash::Hash,
-    S: BuildHasher,
-{
-    fn combine_with(&mut self, mut other: Self) {
-        // `self` takes precedence over `other` but `extend` overrides existing values.
-        // Swap the hash maps so that `self` is the one that gets extended.
-        std::mem::swap(self, &mut other);
-        self.extend(other);
-    }
-}
-
-/// Implements [`Combine`] for a value that always returns `self` when combined with another value.
-macro_rules! impl_noop_combine {
-    ($name:ident) => {
-        impl Combine for $name {
-            #[inline(always)]
-            fn combine_with(&mut self, _other: Self) {}
-
-            #[inline(always)]
-            fn combine(self, _other: Self) -> Self {
-                self
-            }
-        }
-    };
-}
-
-impl_noop_combine!(SystemPathBuf);
-impl_noop_combine!(PythonPlatform);
-impl_noop_combine!(SitePackages);
-impl_noop_combine!(PythonVersion);
-
-// std types
-impl_noop_combine!(bool);
-impl_noop_combine!(usize);
-impl_noop_combine!(u8);
-impl_noop_combine!(u16);
-impl_noop_combine!(u32);
-impl_noop_combine!(u64);
-impl_noop_combine!(u128);
-impl_noop_combine!(isize);
-impl_noop_combine!(i8);
-impl_noop_combine!(i16);
-impl_noop_combine!(i32);
-impl_noop_combine!(i64);
-impl_noop_combine!(i128);
-impl_noop_combine!(String);
-
-#[cfg(test)]
-mod tests {
-    use crate::combine::Combine;
-    use std::collections::HashMap;
-
-    #[test]
-    fn combine_option() {
-        assert_eq!(Some(1).combine(Some(2)), Some(1));
-        assert_eq!(None.combine(Some(2)), Some(2));
-        assert_eq!(Some(1).combine(None), Some(1));
-    }
-
-    #[test]
-    fn combine_vec() {
-        assert_eq!(None.combine(Some(vec![1, 2, 3])), Some(vec![1, 2, 3]));
-        assert_eq!(Some(vec![1, 2, 3]).combine(None), Some(vec![1, 2, 3]));
-        assert_eq!(
-            Some(vec![1, 2, 3]).combine(Some(vec![4, 5, 6])),
-            Some(vec![4, 5, 6, 1, 2, 3])
-        );
-    }
-
-    #[test]
-    fn combine_map() {
-        let a: HashMap<u32, _> = HashMap::from_iter([(1, "a"), (2, "a"), (3, "a")]);
-        let b: HashMap<u32, _> = HashMap::from_iter([(0, "b"), (2, "b"), (5, "b")]);
-
-        assert_eq!(None.combine(Some(b.clone())), Some(b.clone()));
-        assert_eq!(Some(a.clone()).combine(None), Some(a.clone()));
-        assert_eq!(
-            Some(a).combine(Some(b)),
-            Some(HashMap::from_iter([
-                (0, "b"),
-                // The value from `a` takes precedence
-                (1, "a"),
-                (2, "a"),
-                (3, "a"),
-                (5, "b")
-            ]))
-        );
-    }
-}

crates/red_knot_project/src/metadata/options.rs

@@ -1,117 +0,0 @@
-use red_knot_python_semantic::{
-    ProgramSettings, PythonPlatform, PythonVersion, SearchPathSettings, SitePackages,
-};
-use ruff_db::system::{System, SystemPath, SystemPathBuf};
-use ruff_macros::Combine;
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-
-/// The options for the project.
-#[derive(Debug, Default, Clone, PartialEq, Eq, Combine, Serialize, Deserialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct Options {
-    pub environment: Option<EnvironmentOptions>,
-
-    pub src: Option<SrcOptions>,
-}
-
-impl Options {
-    pub(crate) fn from_toml_str(content: &str) -> Result<Self, KnotTomlError> {
-        let options = toml::from_str(content)?;
-        Ok(options)
-    }
-
-    pub(crate) fn to_program_settings(
-        &self,
-        project_root: &SystemPath,
-        system: &dyn System,
-    ) -> ProgramSettings {
-        let (python_version, python_platform) = self
-            .environment
-            .as_ref()
-            .map(|env| (env.python_version, env.python_platform.as_ref()))
-            .unwrap_or_default();
-
-        ProgramSettings {
-            python_version: python_version.unwrap_or_default(),
-            python_platform: python_platform.cloned().unwrap_or_default(),
-            search_paths: self.to_search_path_settings(project_root, system),
-        }
-    }
-
-    fn to_search_path_settings(
-        &self,
-        project_root: &SystemPath,
-        system: &dyn System,
-    ) -> SearchPathSettings {
-        let src_roots =
-            if let Some(src_root) = self.src.as_ref().and_then(|src| src.root.as_deref()) {
-                vec![src_root.to_path_buf()]
-            } else {
-                let src = project_root.join("src");
-
-                // Default to `src` and the project root if `src` exists and the root hasn't been specified.
-                if system.is_directory(&src) {
-                    vec![project_root.to_path_buf(), src]
-                } else {
-                    vec![project_root.to_path_buf()]
-                }
-            };
-
-        let (extra_paths, python, typeshed) = self
-            .environment
-            .as_ref()
-            .map(|env| {
-                (
-                    env.extra_paths.clone(),
-                    env.venv_path.clone(),
-                    env.typeshed.clone(),
-                )
-            })
-            .unwrap_or_default();
-
-        SearchPathSettings {
-            extra_paths: extra_paths.unwrap_or_default(),
-            src_roots,
-            typeshed,
-            site_packages: python
-                .map(|venv_path| SitePackages::Derived { venv_path })
-                .unwrap_or(SitePackages::Known(vec![])),
-        }
-    }
-}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, Combine, Serialize, Deserialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct EnvironmentOptions {
-    pub python_version: Option<PythonVersion>,
-
-    pub python_platform: Option<PythonPlatform>,
-
-    /// List of user-provided paths that should take first priority in the module resolution.
-    /// Examples in other type checkers are mypy's MYPYPATH environment variable,
-    /// or pyright's stubPath configuration setting.
-    pub extra_paths: Option<Vec<SystemPathBuf>>,
-
-    /// Optional path to a "typeshed" directory on disk for us to use for standard-library types.
-    /// If this is not provided, we will fallback to our vendored typeshed stubs for the stdlib,
-    /// bundled as a zip file in the binary
-    pub typeshed: Option<SystemPathBuf>,
-
-    // TODO: Rename to python, see https://github.com/astral-sh/ruff/issues/15530
-    /// The path to the user's `site-packages` directory, where third-party packages from ``PyPI`` are installed.
-    pub venv_path: Option<SystemPathBuf>,
-}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, Combine, Serialize, Deserialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct SrcOptions {
-    /// The root of the project, used for finding first-party modules.
-    pub root: Option<SystemPathBuf>,
-}
-
-#[derive(Error, Debug)]
-pub enum KnotTomlError {
-    #[error(transparent)]
-    TomlSyntax(#[from] toml::de::Error),
-}

crates/red_knot_project/src/snapshots/red_knot_project__metadata__tests__nested_projects_in_root_project.snap

@@ -1,14 +0,0 @@
----
-source: crates/red_knot_project/src/metadata.rs
-expression: root
----
-ProjectMetadata(
-  name: Name("project-root"),
-  root: "/app",
-  options: Options(
-    environment: None,
-    src: Some(SrcOptions(
-      root: Some("src"),
-    )),
-  ),
-)

crates/red_knot_project/src/snapshots/red_knot_project__metadata__tests__nested_projects_in_sub_project.snap

@@ -1,14 +0,0 @@
----
-source: crates/red_knot_project/src/metadata.rs
-expression: sub_project
----
-ProjectMetadata(
-  name: Name("nested-project"),
-  root: "/app/packages/a",
-  options: Options(
-    environment: None,
-    src: Some(SrcOptions(
-      root: Some("src"),
-    )),
-  ),
-)

crates/red_knot_project/src/snapshots/red_knot_project__metadata__tests__nested_projects_with_outer_knot_section.snap

@@ -1,18 +0,0 @@
----
-source: crates/red_knot_project/src/metadata.rs
-expression: root
----
-ProjectMetadata(
-  name: Name("project-root"),
-  root: "/app",
-  options: Options(
-    environment: Some(EnvironmentOptions(
-      r#python-version: Some("3.10"),
-      r#python-platform: None,
-      r#extra-paths: None,
-      typeshed: None,
-      r#venv-path: None,
-    )),
-    src: None,
-  ),
-)

crates/red_knot_project/src/snapshots/red_knot_project__metadata__tests__nested_projects_without_knot_sections.snap

@@ -1,12 +0,0 @@
----
-source: crates/red_knot_project/src/metadata.rs
-expression: sub_project
----
-ProjectMetadata(
-  name: Name("nested-project"),
-  root: "/app/packages/a",
-  options: Options(
-    environment: None,
-    src: None,
-  ),
-)

crates/red_knot_project/src/snapshots/red_knot_project__metadata__tests__project_with_knot_and_pyproject_toml.snap

@@ -1,14 +0,0 @@
----
-source: crates/red_knot_project/src/metadata.rs
-expression: root
----
-ProjectMetadata(
-  name: Name("super-app"),
-  root: "/app",
-  options: Options(
-    environment: None,
-    src: Some(SrcOptions(
-      root: Some("src"),
-    )),
-  ),
-)

crates/red_knot_project/src/snapshots/red_knot_project__metadata__tests__project_with_pyproject.snap

@@ -1,12 +0,0 @@
----
-source: crates/red_knot_project/src/metadata.rs
-expression: project
----
-ProjectMetadata(
-  name: Name("backend"),
-  root: "/app",
-  options: Options(
-    environment: None,
-    src: None,
-  ),
-)

crates/red_knot_project/src/snapshots/red_knot_project__metadata__tests__project_without_pyproject.snap

@@ -1,12 +0,0 @@
----
-source: crates/red_knot_project/src/metadata.rs
-expression: project
----
-ProjectMetadata(
-  name: Name("app"),
-  root: "/app",
-  options: Options(
-    environment: None,
-    src: None,
-  ),
-)

crates/red_knot_python_semantic/mdtest.py

@@ -1,214 +0,0 @@
-"""A runner for Markdown-based tests for Red Knot"""
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "rich",
-#     "watchfiles",
-# ]
-# ///
-
-from __future__ import annotations
-
-import json
-import os
-import subprocess
-from pathlib import Path
-from typing import Final, Literal, Never, assert_never
-
-from rich.console import Console
-from watchfiles import Change, watch
-
-CRATE_NAME: Final = "red_knot_python_semantic"
-CRATE_ROOT: Final = Path(__file__).resolve().parent
-MDTEST_DIR: Final = CRATE_ROOT / "resources" / "mdtest"
-
-
-class MDTestRunner:
-    mdtest_executable: Path | None
-    console: Console
-
-    def __init__(self) -> None:
-        self.mdtest_executable = None
-        self.console = Console()
-
-    def _run_cargo_test(self, *, message_format: Literal["human", "json"]) -> str:
-        return subprocess.check_output(
-            [
-                "cargo",
-                "test",
-                "--package",
-                CRATE_NAME,
-                "--no-run",
-                "--color=always",
-                "--message-format",
-                message_format,
-            ],
-            cwd=CRATE_ROOT,
-            env=dict(os.environ, CLI_COLOR="1"),
-            stderr=subprocess.STDOUT,
-            text=True,
-        )
-
-    def _recompile_tests(
-        self, status_message: str, *, message_on_success: bool = True
-    ) -> bool:
-        with self.console.status(status_message):
-            # Run it with 'human' format in case there are errors:
-            try:
-                self._run_cargo_test(message_format="human")
-            except subprocess.CalledProcessError as e:
-                print(e.output)
-                return False
-
-            # Run it again with 'json' format to find the mdtest executable:
-            json_output = self._run_cargo_test(message_format="json")
-
-            if json_output:
-                self._get_executable_path_from_json(json_output)
-
-        if message_on_success:
-            self.console.print("[dim]Tests compiled successfully[/dim]")
-        return True
-
-    def _get_executable_path_from_json(self, json_output: str) -> None:
-        for json_line in json_output.splitlines():
-            try:
-                data = json.loads(json_line)
-            except json.JSONDecodeError:
-                continue
-            if data.get("target", {}).get("name") == "mdtest":
-                self.mdtest_executable = Path(data["executable"])
-                break
-        else:
-            raise RuntimeError(
-                "Could not find mdtest executable after successful compilation"
-            )
-
-    def _run_mdtest(
-        self, arguments: list[str] | None = None, *, capture_output: bool = False
-    ) -> subprocess.CompletedProcess:
-        assert self.mdtest_executable is not None
-
-        arguments = arguments or []
-        return subprocess.run(
-            [self.mdtest_executable, *arguments],
-            cwd=CRATE_ROOT,
-            env=dict(os.environ, CLICOLOR_FORCE="1"),
-            capture_output=capture_output,
-            text=True,
-            check=False,
-        )
-
-    def _run_mdtests_for_file(self, markdown_file: Path) -> None:
-        path_mangled = (
-            markdown_file.as_posix()
-            .replace("/", "_")
-            .replace("-", "_")
-            .removesuffix(".md")
-        )
-        test_name = f"mdtest__{path_mangled}"
-
-        output = self._run_mdtest(["--exact", test_name], capture_output=True)
-
-        if output.returncode == 0:
-            if "running 0 tests\n" in output.stdout:
-                self.console.log(
-                    f"[yellow]Warning[/yellow]: No tests were executed with filter '{test_name}'"
-                )
-            else:
-                self.console.print(
-                    f"Test for [bold green]{markdown_file}[/bold green] succeeded"
-                )
-        else:
-            self.console.print()
-            self.console.rule(
-                f"Test for [bold red]{markdown_file}[/bold red] failed",
-                style="gray",
-            )
-            self._print_trimmed_cargo_test_output(
-                output.stdout + output.stderr, test_name
-            )
-
-    def _print_trimmed_cargo_test_output(self, output: str, test_name: str) -> None:
-        # Skip 'cargo test' boilerplate at the beginning:
-        lines = output.splitlines()
-        start_index = 0
-        for i, line in enumerate(lines):
-            if f"{test_name} stdout" in line:
-                start_index = i
-                break
-
-        for line in lines[start_index + 1 :]:
-            if "MDTEST_TEST_FILTER" in line:
-                continue
-            if line.strip() == "-" * 50:
-                # Skip 'cargo test' boilerplate at the end
-                break
-
-            print(line)
-
-    def watch(self) -> Never:
-        self._recompile_tests("Compiling tests...", message_on_success=False)
-        self.console.print("[dim]Ready to watch for changes...[/dim]")
-
-        for changes in watch(CRATE_ROOT):
-            new_md_files = set()
-            changed_md_files = set()
-            rust_code_has_changed = False
-
-            for change, path_str in changes:
-                path = Path(path_str)
-
-                if path.suffix == ".rs":
-                    rust_code_has_changed = True
-                    continue
-
-                if path.suffix != ".md":
-                    continue
-
-                try:
-                    relative_path = Path(path).relative_to(MDTEST_DIR)
-                except ValueError:
-                    continue
-
-                match change:
-                    case Change.added:
-                        # When saving a file, some editors (looking at you, Vim) might first
-                        # save the file with a temporary name (e.g. `file.md~`) and then rename
-                        # it to the final name. This creates a `deleted` and `added` change.
-                        # We treat those files as `changed` here.
-                        if (Change.deleted, path_str) in changes:
-                            changed_md_files.add(relative_path)
-                        else:
-                            new_md_files.add(relative_path)
-                    case Change.modified:
-                        changed_md_files.add(relative_path)
-                    case Change.deleted:
-                        # No need to do anything when a Markdown test is deleted
-                        pass
-                    case _ as unreachable:
-                        assert_never(unreachable)
-
-            if rust_code_has_changed:
-                if self._recompile_tests("Rust code has changed, recompiling tests..."):
-                    self._run_mdtest()
-            elif new_md_files:
-                files = " ".join(file.as_posix() for file in new_md_files)
-                self._recompile_tests(
-                    f"New Markdown test [yellow]{files}[/yellow] detected, recompiling tests..."
-                )
-
-            for path in new_md_files | changed_md_files:
-                self._run_mdtests_for_file(path)
-
-
-def main() -> None:
-    try:
-        runner = MDTestRunner()
-        runner.watch()
-    except KeyboardInterrupt:
-        print()
-
-
-if __name__ == "__main__":
-    main()

crates/red_knot_python_semantic/mdtest.py.lock

@@ -1,141 +0,0 @@
-version = 1
-requires-python = ">=3.11"
-
-[manifest]
-requirements = [
-    { name = "rich" },
-    { name = "watchfiles" },
-]
-
-[[package]]
-name = "anyio"
-version = "4.8.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "idna" },
-    { name = "sniffio" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a3/73/199a98fc2dae33535d6b8e8e6ec01f8c1d76c9adb096c6b7d64823038cde/anyio-4.8.0.tar.gz", hash = "sha256:1d9fe889df5212298c0c0723fa20479d1b94883a2df44bd3897aa91083316f7a", size = 181126 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/46/eb/e7f063ad1fec6b3178a3cd82d1a3c4de82cccf283fc42746168188e1cdd5/anyio-4.8.0-py3-none-any.whl", hash = "sha256:b5011f270ab5eb0abf13385f851315585cc37ef330dd88e27ec3d34d651fd47a", size = 96041 },
-]
-
-[[package]]
-name = "idna"
-version = "3.10"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
-]
-
-[[package]]
-name = "markdown-it-py"
-version = "3.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mdurl" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 },
-]
-
-[[package]]
-name = "mdurl"
-version = "0.1.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 },
-]
-
-[[package]]
-name = "pygments"
-version = "2.19.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 },
-]
-
-[[package]]
-name = "rich"
-version = "13.9.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "markdown-it-py" },
-    { name = "pygments" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424 },
-]
-
-[[package]]
-name = "sniffio"
-version = "1.3.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 },
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.12.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 },
-]
-
-[[package]]
-name = "watchfiles"
-version = "1.0.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f5/26/c705fc77d0a9ecdb9b66f1e2976d95b81df3cae518967431e7dbf9b5e219/watchfiles-1.0.4.tar.gz", hash = "sha256:6ba473efd11062d73e4f00c2b730255f9c1bdd73cd5f9fe5b5da8dbd4a717205", size = 94625 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0f/bb/8461adc4b1fed009546fb797fc0d5698dcfe5e289cb37e1b8f16a93cdc30/watchfiles-1.0.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:2a9f93f8439639dc244c4d2902abe35b0279102bca7bbcf119af964f51d53c19", size = 394869 },
-    { url = "https://files.pythonhosted.org/packages/55/88/9ebf36b3547176d1709c320de78c1fa3263a46be31b5b1267571d9102686/watchfiles-1.0.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9eea33ad8c418847dd296e61eb683cae1c63329b6d854aefcd412e12d94ee235", size = 384905 },
-    { url = "https://files.pythonhosted.org/packages/03/8a/04335ce23ef78d8c69f0913e8b20cf7d9233e3986543aeef95ef2d6e43d2/watchfiles-1.0.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:31f1a379c9dcbb3f09cf6be1b7e83b67c0e9faabed0471556d9438a4a4e14202", size = 449944 },
-    { url = "https://files.pythonhosted.org/packages/17/4e/c8d5dcd14fe637f4633616dabea8a4af0a10142dccf3b43e0f081ba81ab4/watchfiles-1.0.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ab594e75644421ae0a2484554832ca5895f8cab5ab62de30a1a57db460ce06c6", size = 456020 },
-    { url = "https://files.pythonhosted.org/packages/5e/74/3e91e09e1861dd7fbb1190ce7bd786700dc0fbc2ccd33bb9fff5de039229/watchfiles-1.0.4-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fc2eb5d14a8e0d5df7b36288979176fbb39672d45184fc4b1c004d7c3ce29317", size = 482983 },
-    { url = "https://files.pythonhosted.org/packages/a1/3d/e64de2d1ce4eb6a574fd78ce3a28c279da263be9ef3cfcab6f708df192f2/watchfiles-1.0.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f68d8e9d5a321163ddacebe97091000955a1b74cd43724e346056030b0bacee", size = 520320 },
-    { url = "https://files.pythonhosted.org/packages/2c/bd/52235f7063b57240c66a991696ed27e2a18bd6fcec8a1ea5a040b70d0611/watchfiles-1.0.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f9ce064e81fe79faa925ff03b9f4c1a98b0bbb4a1b8c1b015afa93030cb21a49", size = 500988 },
-    { url = "https://files.pythonhosted.org/packages/3a/b0/ff04194141a5fe650c150400dd9e42667916bc0f52426e2e174d779b8a74/watchfiles-1.0.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b77d5622ac5cc91d21ae9c2b284b5d5c51085a0bdb7b518dba263d0af006132c", size = 452573 },
-    { url = "https://files.pythonhosted.org/packages/3d/9d/966164332c5a178444ae6d165082d4f351bd56afd9c3ec828eecbf190e6a/watchfiles-1.0.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1941b4e39de9b38b868a69b911df5e89dc43767feeda667b40ae032522b9b5f1", size = 615114 },
-    { url = "https://files.pythonhosted.org/packages/94/df/f569ae4c1877f96ad4086c153a8eee5a19a3b519487bf5c9454a3438c341/watchfiles-1.0.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:4f8c4998506241dedf59613082d1c18b836e26ef2a4caecad0ec41e2a15e4226", size = 613076 },
-    { url = "https://files.pythonhosted.org/packages/15/ae/8ce5f29e65d5fa5790e3c80c289819c55e12be2e1b9f5b6a0e55e169b97d/watchfiles-1.0.4-cp311-cp311-win32.whl", hash = "sha256:4ebbeca9360c830766b9f0df3640b791be569d988f4be6c06d6fae41f187f105", size = 271013 },
-    { url = "https://files.pythonhosted.org/packages/a4/c6/79dc4a7c598a978e5fafa135090aaf7bbb03b8dec7bada437dfbe578e7ed/watchfiles-1.0.4-cp311-cp311-win_amd64.whl", hash = "sha256:05d341c71f3d7098920f8551d4df47f7b57ac5b8dad56558064c3431bdfc0b74", size = 284229 },
-    { url = "https://files.pythonhosted.org/packages/37/3d/928633723211753f3500bfb138434f080363b87a1b08ca188b1ce54d1e05/watchfiles-1.0.4-cp311-cp311-win_arm64.whl", hash = "sha256:32b026a6ab64245b584acf4931fe21842374da82372d5c039cba6bf99ef722f3", size = 276824 },
-    { url = "https://files.pythonhosted.org/packages/5b/1a/8f4d9a1461709756ace48c98f07772bc6d4519b1e48b5fa24a4061216256/watchfiles-1.0.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:229e6ec880eca20e0ba2f7e2249c85bae1999d330161f45c78d160832e026ee2", size = 391345 },
-    { url = "https://files.pythonhosted.org/packages/bc/d2/6750b7b3527b1cdaa33731438432e7238a6c6c40a9924049e4cebfa40805/watchfiles-1.0.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5717021b199e8353782dce03bd8a8f64438832b84e2885c4a645f9723bf656d9", size = 381515 },
-    { url = "https://files.pythonhosted.org/packages/4e/17/80500e42363deef1e4b4818729ed939aaddc56f82f4e72b2508729dd3c6b/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0799ae68dfa95136dde7c472525700bd48777875a4abb2ee454e3ab18e9fc712", size = 449767 },
-    { url = "https://files.pythonhosted.org/packages/10/37/1427fa4cfa09adbe04b1e97bced19a29a3462cc64c78630787b613a23f18/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:43b168bba889886b62edb0397cab5b6490ffb656ee2fcb22dec8bfeb371a9e12", size = 455677 },
-    { url = "https://files.pythonhosted.org/packages/c5/7a/39e9397f3a19cb549a7d380412fd9e507d4854eddc0700bfad10ef6d4dba/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fb2c46e275fbb9f0c92e7654b231543c7bbfa1df07cdc4b99fa73bedfde5c844", size = 482219 },
-    { url = "https://files.pythonhosted.org/packages/45/2d/7113931a77e2ea4436cad0c1690c09a40a7f31d366f79c6f0a5bc7a4f6d5/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:857f5fc3aa027ff5e57047da93f96e908a35fe602d24f5e5d8ce64bf1f2fc733", size = 518830 },
-    { url = "https://files.pythonhosted.org/packages/f9/1b/50733b1980fa81ef3c70388a546481ae5fa4c2080040100cd7bf3bf7b321/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55ccfd27c497b228581e2838d4386301227fc0cb47f5a12923ec2fe4f97b95af", size = 497997 },
-    { url = "https://files.pythonhosted.org/packages/2b/b4/9396cc61b948ef18943e7c85ecfa64cf940c88977d882da57147f62b34b1/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c11ea22304d17d4385067588123658e9f23159225a27b983f343fcffc3e796a", size = 452249 },
-    { url = "https://files.pythonhosted.org/packages/fb/69/0c65a5a29e057ad0dc691c2fa6c23b2983c7dabaa190ba553b29ac84c3cc/watchfiles-1.0.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:74cb3ca19a740be4caa18f238298b9d472c850f7b2ed89f396c00a4c97e2d9ff", size = 614412 },
-    { url = "https://files.pythonhosted.org/packages/7f/b9/319fcba6eba5fad34327d7ce16a6b163b39741016b1996f4a3c96b8dd0e1/watchfiles-1.0.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:c7cce76c138a91e720d1df54014a047e680b652336e1b73b8e3ff3158e05061e", size = 611982 },
-    { url = "https://files.pythonhosted.org/packages/f1/47/143c92418e30cb9348a4387bfa149c8e0e404a7c5b0585d46d2f7031b4b9/watchfiles-1.0.4-cp312-cp312-win32.whl", hash = "sha256:b045c800d55bc7e2cadd47f45a97c7b29f70f08a7c2fa13241905010a5493f94", size = 271822 },
-    { url = "https://files.pythonhosted.org/packages/ea/94/b0165481bff99a64b29e46e07ac2e0df9f7a957ef13bec4ceab8515f44e3/watchfiles-1.0.4-cp312-cp312-win_amd64.whl", hash = "sha256:c2acfa49dd0ad0bf2a9c0bb9a985af02e89345a7189be1efc6baa085e0f72d7c", size = 285441 },
-    { url = "https://files.pythonhosted.org/packages/11/de/09fe56317d582742d7ca8c2ca7b52a85927ebb50678d9b0fa8194658f536/watchfiles-1.0.4-cp312-cp312-win_arm64.whl", hash = "sha256:22bb55a7c9e564e763ea06c7acea24fc5d2ee5dfc5dafc5cfbedfe58505e9f90", size = 277141 },
-    { url = "https://files.pythonhosted.org/packages/08/98/f03efabec64b5b1fa58c0daab25c68ef815b0f320e54adcacd0d6847c339/watchfiles-1.0.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:8012bd820c380c3d3db8435e8cf7592260257b378b649154a7948a663b5f84e9", size = 390954 },
-    { url = "https://files.pythonhosted.org/packages/16/09/4dd49ba0a32a45813debe5fb3897955541351ee8142f586303b271a02b40/watchfiles-1.0.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa216f87594f951c17511efe5912808dfcc4befa464ab17c98d387830ce07b60", size = 381133 },
-    { url = "https://files.pythonhosted.org/packages/76/59/5aa6fc93553cd8d8ee75c6247763d77c02631aed21551a97d94998bf1dae/watchfiles-1.0.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62c9953cf85529c05b24705639ffa390f78c26449e15ec34d5339e8108c7c407", size = 449516 },
-    { url = "https://files.pythonhosted.org/packages/4c/aa/df4b6fe14b6317290b91335b23c96b488d365d65549587434817e06895ea/watchfiles-1.0.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7cf684aa9bba4cd95ecb62c822a56de54e3ae0598c1a7f2065d51e24637a3c5d", size = 454820 },
-    { url = "https://files.pythonhosted.org/packages/5e/71/185f8672f1094ce48af33252c73e39b48be93b761273872d9312087245f6/watchfiles-1.0.4-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f44a39aee3cbb9b825285ff979ab887a25c5d336e5ec3574f1506a4671556a8d", size = 481550 },
-    { url = "https://files.pythonhosted.org/packages/85/d7/50ebba2c426ef1a5cb17f02158222911a2e005d401caf5d911bfca58f4c4/watchfiles-1.0.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a38320582736922be8c865d46520c043bff350956dfc9fbaee3b2df4e1740a4b", size = 518647 },
-    { url = "https://files.pythonhosted.org/packages/f0/7a/4c009342e393c545d68987e8010b937f72f47937731225b2b29b7231428f/watchfiles-1.0.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39f4914548b818540ef21fd22447a63e7be6e24b43a70f7642d21f1e73371590", size = 497547 },
-    { url = "https://files.pythonhosted.org/packages/0f/7c/1cf50b35412d5c72d63b2bf9a4fffee2e1549a245924960dd087eb6a6de4/watchfiles-1.0.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f12969a3765909cf5dc1e50b2436eb2c0e676a3c75773ab8cc3aa6175c16e902", size = 452179 },
-    { url = "https://files.pythonhosted.org/packages/d6/a9/3db1410e1c1413735a9a472380e4f431ad9a9e81711cda2aaf02b7f62693/watchfiles-1.0.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:0986902677a1a5e6212d0c49b319aad9cc48da4bd967f86a11bde96ad9676ca1", size = 614125 },
-    { url = "https://files.pythonhosted.org/packages/f2/e1/0025d365cf6248c4d1ee4c3d2e3d373bdd3f6aff78ba4298f97b4fad2740/watchfiles-1.0.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:308ac265c56f936636e3b0e3f59e059a40003c655228c131e1ad439957592303", size = 611911 },
-    { url = "https://files.pythonhosted.org/packages/55/55/035838277d8c98fc8c917ac9beeb0cd6c59d675dc2421df5f9fcf44a0070/watchfiles-1.0.4-cp313-cp313-win32.whl", hash = "sha256:aee397456a29b492c20fda2d8961e1ffb266223625346ace14e4b6d861ba9c80", size = 271152 },
-    { url = "https://files.pythonhosted.org/packages/f0/e5/96b8e55271685ddbadc50ce8bc53aa2dff278fb7ac4c2e473df890def2dc/watchfiles-1.0.4-cp313-cp313-win_amd64.whl", hash = "sha256:d6097538b0ae5c1b88c3b55afa245a66793a8fec7ada6755322e465fb1a0e8cc", size = 285216 },
-]

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

@@ -100,7 +100,7 @@ def _(flag: bool):
     foo_3: LiteralString = "foo" * 1_000_000_000
     bar_3: str = foo_2  # fine
 
-    baz_1: str = repr(object())
+    baz_1: str = str()
     qux_1: LiteralString = baz_1  # error: [invalid-assignment]
 
     baz_2: LiteralString = "baz" * 1_000_000_000

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -34,21 +34,21 @@ c_instance = C(1)
 
 # TODO: should be `Literal["value set in __init__"]`, or `Unknown | Literal[…]` to allow
 # assignments to this unannotated attribute from other scopes.
-reveal_type(c_instance.pure_instance_variable1)  # revealed: @Todo(implicit instance attribute)
+reveal_type(c_instance.pure_instance_variable1)  # revealed: @Todo(instance attributes)
 
 # TODO: should be `int`
-reveal_type(c_instance.pure_instance_variable2)  # revealed: @Todo(implicit instance attribute)
+reveal_type(c_instance.pure_instance_variable2)  # revealed: @Todo(instance attributes)
 
 # TODO: should be `bytes`
-reveal_type(c_instance.pure_instance_variable3)  # revealed: @Todo(implicit instance attribute)
+reveal_type(c_instance.pure_instance_variable3)  # revealed: @Todo(instance attributes)
 
 # TODO: should be `bool`
-reveal_type(c_instance.pure_instance_variable4)  # revealed: @Todo(implicit instance attribute)
+reveal_type(c_instance.pure_instance_variable4)  # revealed: @Todo(instance attributes)
 
 # TODO: should be `str`
 # We probably don't want to emit a diagnostic for this being possibly undeclared/unbound.
 # mypy and pyright do not show an error here.
-reveal_type(c_instance.pure_instance_variable5)  # revealed: @Todo(implicit instance attribute)
+reveal_type(c_instance.pure_instance_variable5)  # revealed: @Todo(instance attributes)
 
 # TODO: If we choose to infer a precise `Literal[…]` type for the instance attribute (see
 # above), this should be an error: incompatible types in assignment. If we choose to infer
@@ -74,7 +74,7 @@ c_instance.pure_instance_variable4 = False
 # in general (we don't know what else happened to `c_instance` between the assignment and the use
 # here), but mypy and pyright support this. In conclusion, this could be `bool` but should probably
 # be `Literal[False]`.
-reveal_type(c_instance.pure_instance_variable4)  # revealed: @Todo(implicit instance attribute)
+reveal_type(c_instance.pure_instance_variable4)  # revealed: @Todo(instance attributes)
 ```
 
 #### Variable declared in class body and declared/bound in `__init__`
@@ -91,7 +91,8 @@ class C:
 
 c_instance = C()
 
-reveal_type(c_instance.pure_instance_variable)  # revealed: str
+# TODO: should be `str`
+reveal_type(c_instance.pure_instance_variable)  # revealed: @Todo(instance attributes)
 
 # TODO: we currently plan to emit a diagnostic here. Note that both mypy
 # and pyright show no error in this case! So we may reconsider this in
@@ -122,7 +123,7 @@ c_instance = C()
 c_instance.set_instance_variable()
 
 # TODO: should be `Literal["value set in method"]` or `Unknown | Literal[…]` (see above).
-reveal_type(c_instance.pure_instance_variable)  # revealed: @Todo(implicit instance attribute)
+reveal_type(c_instance.pure_instance_variable)  # revealed: @Todo(instance attributes)
 
 # TODO: We already show an error here, but the message might be improved?
 # error: [unresolved-attribute]
@@ -143,7 +144,8 @@ class C:
 
 c_instance = C()
 
-reveal_type(c_instance.pure_instance_variable)  # revealed: str
+# TODO: should be 'str'
+reveal_type(c_instance.pure_instance_variable)  # revealed: @Todo(instance attributes)
 
 # TODO: mypy and pyright do not show an error here, but we plan to emit a diagnostic.
 # The type could be changed to 'Unknown' if we decide to emit an error?
@@ -169,24 +171,17 @@ class C:
     pure_class_variable1: ClassVar[str] = "value in class body"
     pure_class_variable2: ClassVar = 1
 
-    def method(self):
-        # TODO: this should be an error
-        self.pure_class_variable1 = "value set through instance"
-
 reveal_type(C.pure_class_variable1)  # revealed: str
 
 # TODO: this should be `Literal[1]`, or `Unknown | Literal[1]`.
-reveal_type(C.pure_class_variable2)  # revealed: Unknown
+reveal_type(C.pure_class_variable2)  # revealed: @Todo(Unsupported or invalid type in a type expression)
 
 c_instance = C()
 
-# It is okay to access a pure class variable on an instance.
-reveal_type(c_instance.pure_class_variable1)  # revealed: str
+# TODO: This should be `str`. It is okay to access a pure class variable on an instance.
+reveal_type(c_instance.pure_class_variable1)  # revealed: @Todo(instance attributes)
 
-# TODO: Should be `Unknown | Literal[1]`.
-reveal_type(c_instance.pure_class_variable2)  # revealed: Unknown
-
-# error: [invalid-attribute-access] "Cannot assign to ClassVar `pure_class_variable1` from an instance of type `C`"
+# TODO: should raise an error. It is not allowed to reassign a pure class variable on an instance.
 c_instance.pure_class_variable1 = "value set on instance"
 
 C.pure_class_variable1 = "overwritten on class"
@@ -227,7 +222,7 @@ reveal_type(C.pure_class_variable)  # revealed: Unknown
 
 c_instance = C()
 # TODO: should be `Literal["overwritten on class"]`
-reveal_type(c_instance.pure_class_variable)  # revealed: @Todo(implicit instance attribute)
+reveal_type(c_instance.pure_class_variable)  # revealed: @Todo(instance attributes)
 
 # TODO: should raise an error.
 c_instance.pure_class_variable = "value set on instance"
@@ -244,38 +239,34 @@ attributes.
 
 ```py
 class C:
-    variable_with_class_default1: str = "value in class body"
-    variable_with_class_default2 = 1
+    variable_with_class_default: str = "value in class body"
 
     def instance_method(self):
-        self.variable_with_class_default1 = "value set in instance method"
+        self.variable_with_class_default = "value set in instance method"
 
-reveal_type(C.variable_with_class_default1)  # revealed: str
-
-# TODO: this should be `Unknown | Literal[1]`.
-reveal_type(C.variable_with_class_default2)  # revealed: Literal[1]
+reveal_type(C.variable_with_class_default)  # revealed: str
 
 c_instance = C()
 
-reveal_type(c_instance.variable_with_class_default1)  # revealed: str
-reveal_type(c_instance.variable_with_class_default2)  # revealed: Unknown | Literal[1]
+# TODO: should be `str`
+reveal_type(c_instance.variable_with_class_default)  # revealed: @Todo(instance attributes)
 
-c_instance.variable_with_class_default1 = "value set on instance"
+c_instance.variable_with_class_default = "value set on instance"
 
-reveal_type(C.variable_with_class_default1)  # revealed: str
+reveal_type(C.variable_with_class_default)  # revealed: str
 
 # TODO: Could be Literal["value set on instance"], or still `str` if we choose not to
 # narrow the type.
-reveal_type(c_instance.variable_with_class_default1)  # revealed: str
+reveal_type(c_instance.variable_with_class_default)  # revealed: @Todo(instance attributes)
 
-C.variable_with_class_default1 = "overwritten on class"
+C.variable_with_class_default = "overwritten on class"
 
 # TODO: Could be `Literal["overwritten on class"]`, or still `str` if we choose not to
 # narrow the type.
-reveal_type(C.variable_with_class_default1)  # revealed: str
+reveal_type(C.variable_with_class_default)  # revealed: str
 
 # TODO: should still be `Literal["value set on instance"]`, or `str`.
-reveal_type(c_instance.variable_with_class_default1)  # revealed: str
+reveal_type(c_instance.variable_with_class_default)  # revealed: @Todo(instance attributes)
 ```
 
 ## Union of attributes
@@ -446,8 +437,8 @@ functions are instances of that class:
 ```py path=a.py
 def f(): ...
 
-reveal_type(f.__defaults__)  # revealed: @Todo(full tuple[...] support) | None
-reveal_type(f.__kwdefaults__)  # revealed: @Todo(generics) | None
+reveal_type(f.__defaults__)  # revealed: @Todo(instance attributes)
+reveal_type(f.__kwdefaults__)  # revealed: @Todo(instance attributes)
 ```
 
 Some attributes are special-cased, however:
@@ -465,8 +456,8 @@ Most attribute accesses on int-literal types are delegated to `builtins.int`, si
 integers are instances of that class:
 
 ```py path=a.py
-reveal_type((2).bit_length)  # revealed: @Todo(bound method)
-reveal_type((2).denominator)  # revealed: @Todo(@property)
+reveal_type((2).bit_length)  # revealed: @Todo(instance attributes)
+reveal_type((2).denominator)  # revealed: @Todo(instance attributes)
 ```
 
 Some attributes are special-cased, however:
@@ -482,8 +473,8 @@ Most attribute accesses on bool-literal types are delegated to `builtins.bool`,
 bols are instances of that class:
 
 ```py path=a.py
-reveal_type(True.__and__)  # revealed: @Todo(bound method)
-reveal_type(False.__or__)  # revealed: @Todo(bound method)
+reveal_type(True.__and__)  # revealed: @Todo(instance attributes)
+reveal_type(False.__or__)  # revealed: @Todo(instance attributes)
 ```
 
 Some attributes are special-cased, however:
@@ -498,8 +489,8 @@ reveal_type(False.real)  # revealed: Literal[0]
 All attribute access on literal `bytes` types is currently delegated to `buitins.bytes`:
 
 ```py
-reveal_type(b"foo".join)  # revealed: @Todo(bound method)
-reveal_type(b"foo".endswith)  # revealed: @Todo(bound method)
+reveal_type(b"foo".join)  # revealed: @Todo(instance attributes)
+reveal_type(b"foo".endswith)  # revealed: @Todo(instance attributes)
 ```
 
 ## References

crates/red_knot_python_semantic/resources/mdtest/directives/assert_type.md

@@ -110,8 +110,10 @@ python-version = "3.10"
 from typing_extensions import assert_type
 
 def _(a: str | int):
-    assert_type(a, str | int)
-    assert_type(a, int | str)
+    assert_type(a, str | int)  # fine
+
+    # TODO: Order-independent union handling in type equivalence
+    assert_type(a, int | str)  # error: [type-assertion-failure]
 ```
 
 ## Intersections
@@ -133,6 +135,8 @@ def _(a: A):
     if isinstance(a, B) and not isinstance(a, C) and not isinstance(a, D):
         reveal_type(a)  # revealed: A & B & ~C & ~D
 
-        assert_type(a, Intersection[A, B, Not[C], Not[D]])
-        assert_type(a, Intersection[B, A, Not[D], Not[C]])
+        assert_type(a, Intersection[A, B, Not[C], Not[D]])  # fine
+
+        # TODO: Order-independent intersection handling in type equivalence
+        assert_type(a, Intersection[B, A, Not[D], Not[C]])  # error: [type-assertion-failure]
 ```

crates/red_knot_python_semantic/resources/mdtest/generics.md

@@ -17,8 +17,8 @@ box: MyBox[int] = MyBox(5)
 # TODO should emit a diagnostic here (str is not assignable to int)
 wrong_innards: MyBox[int] = MyBox("five")
 
-# TODO reveal int, do not leak the typevar
-reveal_type(box.data)  # revealed: T
+# TODO reveal int
+reveal_type(box.data)  # revealed: @Todo(instance attributes)
 
 reveal_type(MyBox.box_model_number)  # revealed: Literal[695]
 ```
@@ -39,9 +39,7 @@ class MySecureBox[T](MyBox[T]): ...
 secure_box: MySecureBox[int] = MySecureBox(5)
 reveal_type(secure_box)  # revealed: MySecureBox
 # TODO reveal int
-# The @Todo(…) is misleading here. We currently treat `MyBox[T]` as a dynamic base class because we
-# don't understand generics and therefore infer `Unknown` for the `MyBox[T]` base of `MySecureBox[T]`.
-reveal_type(secure_box.data)  # revealed: @Todo(instance attribute on class with dynamic base)
+reveal_type(secure_box.data)  # revealed: @Todo(instance attributes)
 ```
 
 ## Cyclical class definition

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

@@ -3,16 +3,17 @@
 ## Expression
 
 ```py
-from typing_extensions import Literal
+x = 0
+y = str()
+z = False
 
-def _(x: Literal[0], y: str, z: Literal[False]):
-    reveal_type(f"hello")  # revealed: Literal["hello"]
-    reveal_type(f"h {x}")  # revealed: Literal["h 0"]
-    reveal_type("one " f"single " f"literal")  # revealed: Literal["one single literal"]
-    reveal_type("first " f"second({x})" f" third")  # revealed: Literal["first second(0) third"]
-    reveal_type(f"-{y}-")  # revealed: str
-    reveal_type(f"-{y}-" f"--" "--")  # revealed: str
-    reveal_type(f"{z} == {False} is {True}")  # revealed: Literal["False == False is True"]
+reveal_type(f"hello")  # revealed: Literal["hello"]
+reveal_type(f"h {x}")  # revealed: Literal["h 0"]
+reveal_type("one " f"single " f"literal")  # revealed: Literal["one single literal"]
+reveal_type("first " f"second({x})" f" third")  # revealed: Literal["first second(0) third"]
+reveal_type(f"-{y}-")  # revealed: str
+reveal_type(f"-{y}-" f"--" "--")  # revealed: str
+reveal_type(f"{z} == {False} is {True}")  # revealed: Literal["False == False is True"]
 ```
 
 ## Conversion Flags

crates/red_knot_python_semantic/resources/mdtest/mro.md

@@ -396,10 +396,11 @@ class Foo: ...
 class BarCycle(FooCycle): ...  # error: [cyclic-class-definition]
 class Bar(Foo): ...
 
-# Avoid emitting the errors for these. The classes have cyclic superclasses,
+# TODO: can we avoid emitting the errors for these?
+# The classes have cyclic superclasses,
 # but are not themselves cyclic...
-class Baz(Bar, BarCycle): ...
-class Spam(Baz): ...
+class Baz(Bar, BarCycle): ...  # error: [cyclic-class-definition]
+class Spam(Baz): ...  # error: [cyclic-class-definition]
 
 reveal_type(FooCycle.__mro__)  # revealed: tuple[Literal[FooCycle], Unknown, Literal[object]]
 reveal_type(BarCycle.__mro__)  # revealed: tuple[Literal[BarCycle], Unknown, Literal[object]]

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

@@ -199,20 +199,24 @@ def f(
     if isinstance(a, bool):
         reveal_type(a)  # revealed: Never
     else:
-        reveal_type(a)  # revealed: P & AlwaysTruthy
+        # TODO: `bool` is final, so `& ~bool` is redundant here
+        reveal_type(a)  # revealed: P & AlwaysTruthy & ~bool
 
     if isinstance(b, bool):
         reveal_type(b)  # revealed: Never
     else:
-        reveal_type(b)  # revealed: P & AlwaysFalsy
+        # TODO: `bool` is final, so `& ~bool` is redundant here
+        reveal_type(b)  # revealed: P & AlwaysFalsy & ~bool
 
     if isinstance(c, bool):
         reveal_type(c)  # revealed: Never
     else:
-        reveal_type(c)  # revealed: P & ~AlwaysTruthy
+        # TODO: `bool` is final, so `& ~bool` is redundant here
+        reveal_type(c)  # revealed: P & ~AlwaysTruthy & ~bool
 
     if isinstance(d, bool):
         reveal_type(d)  # revealed: Never
     else:
-        reveal_type(d)  # revealed: P & ~AlwaysFalsy
+        # TODO: `bool` is final, so `& ~bool` is redundant here
+        reveal_type(d)  # revealed: P & ~AlwaysFalsy & ~bool
 ```

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

@@ -246,31 +246,3 @@ def _(x: type, y: type[int]):
     if issubclass(x, y):
         reveal_type(x)  # revealed: type[int]
 ```
-
-### Disjoint `type[]` types are narrowed to `Never`
-
-Here, `type[UsesMeta1]` and `type[UsesMeta2]` are disjoint because a common subclass of `UsesMeta1`
-and `UsesMeta2` could only exist if a common subclass of their metaclasses could exist. This is
-known to be impossible due to the fact that `Meta1` is marked as `@final`.
-
-```py
-from typing import final
-
-@final
-class Meta1(type): ...
-
-class Meta2(type): ...
-class UsesMeta1(metaclass=Meta1): ...
-class UsesMeta2(metaclass=Meta2): ...
-
-def _(x: type[UsesMeta1], y: type[UsesMeta2]):
-    if issubclass(x, y):
-        reveal_type(x)  # revealed: Never
-    else:
-        reveal_type(x)  # revealed: type[UsesMeta1]
-
-    if issubclass(y, x):
-        reveal_type(y)  # revealed: Never
-    else:
-        reveal_type(y)  # revealed: type[UsesMeta2]
-```

crates/red_knot_python_semantic/resources/mdtest/pep695_type_aliases.md

@@ -31,7 +31,7 @@ type IntOrStr = int | str
 # TODO: This should either fall back to the specified type from typeshed,
 # which is `Any`, or be the actual type of the runtime value expression
 # `int | str`, i.e. `types.UnionType`.
-reveal_type(IntOrStr.__value__)  # revealed: @Todo(@property)
+reveal_type(IntOrStr.__value__)  # revealed: @Todo(instance attributes)
 ```
 
 ## Invalid assignment
@@ -74,22 +74,5 @@ type ListOrSet[T] = list[T] | set[T]
 
 # TODO: Should be `tuple[typing.TypeVar | typing.ParamSpec | typing.TypeVarTuple, ...]`,
 # as specified in the `typeshed` stubs.
-reveal_type(ListOrSet.__type_params__)  # revealed: @Todo(@property)
-```
-
-## `TypeAliasType` properties
-
-Two `TypeAliasType`s are distinct and disjoint, even if they refer to the same type
-
-```py
-from knot_extensions import static_assert, is_equivalent_to, is_disjoint_from, TypeOf
-
-type Alias1 = int
-type Alias2 = int
-
-type TypeAliasType1 = TypeOf[Alias1]
-type TypeAliasType2 = TypeOf[Alias2]
-
-static_assert(not is_equivalent_to(TypeAliasType1, TypeAliasType2))
-static_assert(is_disjoint_from(TypeAliasType1, TypeAliasType2))
+reveal_type(ListOrSet.__type_params__)  # revealed: @Todo(instance attributes)
 ```

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

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

crates/red_knot_python_semantic/resources/mdtest/sys_version_info.md

@@ -117,9 +117,9 @@ properties on instance types:
 ```py path=b.py
 import sys
 
-reveal_type(sys.version_info.micro)  # revealed: @Todo(@property)
-reveal_type(sys.version_info.releaselevel)  # revealed: @Todo(@property)
-reveal_type(sys.version_info.serial)  # revealed: @Todo(@property)
+reveal_type(sys.version_info.micro)  # revealed: @Todo(instance attributes)
+reveal_type(sys.version_info.releaselevel)  # revealed: @Todo(instance attributes)
+reveal_type(sys.version_info.serial)  # revealed: @Todo(instance attributes)
 ```
 
 ## Accessing fields by index/slice

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

@@ -33,7 +33,7 @@ in strict mode.
 ```py
 def f(x: type):
     reveal_type(x)  # revealed: type
-    reveal_type(x.__repr__)  # revealed: @Todo(bound method)
+    reveal_type(x.__repr__)  # revealed: @Todo(instance attributes)
 
 class A: ...
 
@@ -48,7 +48,7 @@ x: type = A()  # error: [invalid-assignment]
 ```py
 def f(x: type[object]):
     reveal_type(x)  # revealed: type
-    reveal_type(x.__repr__)  # revealed: @Todo(bound method)
+    reveal_type(x.__repr__)  # revealed: @Todo(instance attributes)
 
 class A: ...
 

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_disjoint_from.md

@@ -1,310 +0,0 @@
-# Disjointness relation
-
-Two types `S` and `T` are disjoint if their intersection `S & T` is empty (equivalent to `Never`).
-This means that it is known that no possible runtime object inhabits both types simultaneously.
-
-## Basic builtin types
-
-```py
-from typing_extensions import Literal, LiteralString, Any
-from knot_extensions import Intersection, Not, TypeOf, is_disjoint_from, static_assert
-
-static_assert(is_disjoint_from(bool, str))
-static_assert(not is_disjoint_from(bool, bool))
-static_assert(not is_disjoint_from(bool, int))
-static_assert(not is_disjoint_from(bool, object))
-
-static_assert(not is_disjoint_from(Any, bool))
-static_assert(not is_disjoint_from(Any, Any))
-
-static_assert(not is_disjoint_from(LiteralString, LiteralString))
-static_assert(not is_disjoint_from(str, LiteralString))
-static_assert(not is_disjoint_from(str, type))
-static_assert(not is_disjoint_from(str, type[Any]))
-```
-
-## Class hierarchies
-
-```py
-from knot_extensions import is_disjoint_from, static_assert, Intersection, is_subtype_of
-from typing import final
-
-class A: ...
-class B1(A): ...
-class B2(A): ...
-
-# B1 and B2 are subclasses of A, so they are not disjoint from A:
-static_assert(not is_disjoint_from(A, B1))
-static_assert(not is_disjoint_from(A, B2))
-
-# The two subclasses B1 and B2 are also not disjoint ...
-static_assert(not is_disjoint_from(B1, B2))
-
-# ... because they could share a common subclass ...
-class C(B1, B2): ...
-
-# ... which lies in their intersection:
-static_assert(is_subtype_of(C, Intersection[B1, B2]))
-
-# However, if a class is marked final, it can not be subclassed ...
-@final
-class FinalSubclass(A): ...
-
-static_assert(not is_disjoint_from(FinalSubclass, A))
-
-# ... which makes it disjoint from B1, B2:
-static_assert(is_disjoint_from(B1, FinalSubclass))
-static_assert(is_disjoint_from(B2, FinalSubclass))
-```
-
-## Tuple types
-
-```py
-from typing_extensions import Literal
-from knot_extensions import TypeOf, is_disjoint_from, static_assert
-
-static_assert(is_disjoint_from(tuple[()], TypeOf[object]))
-static_assert(is_disjoint_from(tuple[()], TypeOf[Literal]))
-
-static_assert(is_disjoint_from(tuple[None], None))
-static_assert(is_disjoint_from(tuple[None], Literal[b"a"]))
-static_assert(is_disjoint_from(tuple[None], Literal["a"]))
-static_assert(is_disjoint_from(tuple[None], Literal[1]))
-static_assert(is_disjoint_from(tuple[None], Literal[True]))
-
-static_assert(is_disjoint_from(tuple[Literal[1]], tuple[Literal[2]]))
-static_assert(is_disjoint_from(tuple[Literal[1], Literal[2]], tuple[Literal[1]]))
-static_assert(is_disjoint_from(tuple[Literal[1], Literal[2]], tuple[Literal[1], Literal[3]]))
-
-static_assert(not is_disjoint_from(tuple[Literal[1], Literal[2]], tuple[Literal[1], int]))
-```
-
-## Unions
-
-```py
-from typing_extensions import Literal
-from knot_extensions import Intersection, is_disjoint_from, static_assert
-
-static_assert(is_disjoint_from(Literal[1, 2], Literal[3]))
-static_assert(is_disjoint_from(Literal[1, 2], Literal[3, 4]))
-
-static_assert(not is_disjoint_from(Literal[1, 2], Literal[2]))
-static_assert(not is_disjoint_from(Literal[1, 2], Literal[2, 3]))
-```
-
-## Intersections
-
-```py
-from typing_extensions import Literal, final
-from knot_extensions import Intersection, is_disjoint_from, static_assert
-
-@final
-class P: ...
-
-@final
-class Q: ...
-
-@final
-class R: ...
-
-# For three pairwise disjoint classes ...
-static_assert(is_disjoint_from(P, Q))
-static_assert(is_disjoint_from(P, R))
-static_assert(is_disjoint_from(Q, R))
-
-# ... their intersections are also disjoint:
-static_assert(is_disjoint_from(Intersection[P, Q], R))
-static_assert(is_disjoint_from(Intersection[P, R], Q))
-static_assert(is_disjoint_from(Intersection[Q, R], P))
-
-# On the other hand, for non-disjoint classes ...
-class X: ...
-class Y: ...
-class Z: ...
-
-static_assert(not is_disjoint_from(X, Y))
-static_assert(not is_disjoint_from(X, Z))
-static_assert(not is_disjoint_from(Y, Z))
-
-# ... their intersections are also not disjoint:
-static_assert(not is_disjoint_from(Intersection[X, Y], Z))
-static_assert(not is_disjoint_from(Intersection[X, Z], Y))
-static_assert(not is_disjoint_from(Intersection[Y, Z], X))
-```
-
-## Special types
-
-### `Never`
-
-`Never` is disjoint from every type, including itself.
-
-```py
-from typing_extensions import Never
-from knot_extensions import is_disjoint_from, static_assert
-
-static_assert(is_disjoint_from(Never, Never))
-static_assert(is_disjoint_from(Never, None))
-static_assert(is_disjoint_from(Never, int))
-static_assert(is_disjoint_from(Never, object))
-```
-
-### `None`
-
-```py
-from typing_extensions import Literal
-from knot_extensions import is_disjoint_from, static_assert
-
-static_assert(is_disjoint_from(None, Literal[True]))
-static_assert(is_disjoint_from(None, Literal[1]))
-static_assert(is_disjoint_from(None, Literal["test"]))
-static_assert(is_disjoint_from(None, Literal[b"test"]))
-static_assert(is_disjoint_from(None, LiteralString))
-static_assert(is_disjoint_from(None, int))
-static_assert(is_disjoint_from(None, type[object]))
-
-static_assert(not is_disjoint_from(None, None))
-static_assert(not is_disjoint_from(None, int | None))
-static_assert(not is_disjoint_from(None, object))
-```
-
-### Literals
-
-```py
-from typing_extensions import Literal, LiteralString
-from knot_extensions import TypeOf, is_disjoint_from, static_assert
-
-static_assert(is_disjoint_from(Literal[True], Literal[False]))
-static_assert(is_disjoint_from(Literal[True], Literal[1]))
-static_assert(is_disjoint_from(Literal[False], Literal[0]))
-
-static_assert(is_disjoint_from(Literal[1], Literal[2]))
-
-static_assert(is_disjoint_from(Literal["a"], Literal["b"]))
-
-static_assert(is_disjoint_from(Literal[b"a"], LiteralString))
-static_assert(is_disjoint_from(Literal[b"a"], Literal[b"b"]))
-static_assert(is_disjoint_from(Literal[b"a"], Literal["a"]))
-
-static_assert(is_disjoint_from(type[object], TypeOf[Literal]))
-static_assert(is_disjoint_from(type[str], LiteralString))
-
-static_assert(not is_disjoint_from(Literal[True], Literal[True]))
-static_assert(not is_disjoint_from(Literal[False], Literal[False]))
-static_assert(not is_disjoint_from(Literal[True], bool))
-static_assert(not is_disjoint_from(Literal[True], int))
-
-static_assert(not is_disjoint_from(Literal[1], Literal[1]))
-
-static_assert(not is_disjoint_from(Literal["a"], Literal["a"]))
-static_assert(not is_disjoint_from(Literal["a"], LiteralString))
-static_assert(not is_disjoint_from(Literal["a"], str))
-```
-
-### Class, module and function literals
-
-```py
-from types import ModuleType, FunctionType
-from knot_extensions import TypeOf, is_disjoint_from, static_assert
-
-class A: ...
-class B: ...
-
-type LiteralA = TypeOf[A]
-type LiteralB = TypeOf[B]
-
-# Class literals for different classes are always disjoint.
-# They are singleton types that only contain the class object itself.
-static_assert(is_disjoint_from(LiteralA, LiteralB))
-
-# The class A is a subclass of A, so A is not disjoint from type[A]:
-static_assert(not is_disjoint_from(LiteralA, type[A]))
-
-# The class A is disjoint from type[B] because it's not a subclass of B:
-static_assert(is_disjoint_from(LiteralA, type[B]))
-
-# However, type[A] is not disjoint from type[B], as there could be
-# classes that inherit from both A and B:
-static_assert(not is_disjoint_from(type[A], type[B]))
-
-import random
-import math
-
-static_assert(is_disjoint_from(TypeOf[random], TypeOf[math]))
-static_assert(not is_disjoint_from(TypeOf[random], ModuleType))
-static_assert(not is_disjoint_from(TypeOf[random], object))
-
-def f(): ...
-def g(): ...
-
-static_assert(is_disjoint_from(TypeOf[f], TypeOf[g]))
-static_assert(not is_disjoint_from(TypeOf[f], FunctionType))
-static_assert(not is_disjoint_from(TypeOf[f], object))
-```
-
-### `AlwaysTruthy` and `AlwaysFalsy`
-
-```py
-from knot_extensions import AlwaysFalsy, AlwaysTruthy, is_disjoint_from, static_assert
-
-static_assert(is_disjoint_from(None, AlwaysTruthy))
-static_assert(not is_disjoint_from(None, AlwaysFalsy))
-
-static_assert(is_disjoint_from(AlwaysFalsy, AlwaysTruthy))
-static_assert(not is_disjoint_from(str, AlwaysFalsy))
-static_assert(not is_disjoint_from(str, AlwaysTruthy))
-
-static_assert(is_disjoint_from(Literal[1, 2], AlwaysFalsy))
-static_assert(not is_disjoint_from(Literal[0, 1], AlwaysTruthy))
-```
-
-### Instance types versus `type[T]` types
-
-An instance type is disjoint from a `type[T]` type if the instance type is `@final` and the class of
-the instance type is not a subclass of `T`'s metaclass.
-
-```py
-from typing import final
-from knot_extensions import is_disjoint_from, static_assert
-
-@final
-class Foo: ...
-
-static_assert(is_disjoint_from(Foo, type[int]))
-static_assert(is_disjoint_from(type[object], Foo))
-static_assert(is_disjoint_from(type[dict], Foo))
-
-# Instance types can be disjoint from `type[]` types
-# even if the instance type is a subtype of `type`
-
-@final
-class Meta1(type): ...
-
-class UsesMeta1(metaclass=Meta1): ...
-
-static_assert(not is_disjoint_from(Meta1, type[UsesMeta1]))
-
-class Meta2(type): ...
-class UsesMeta2(metaclass=Meta2): ...
-
-static_assert(not is_disjoint_from(Meta2, type[UsesMeta2]))
-static_assert(is_disjoint_from(Meta1, type[UsesMeta2]))
-```
-
-### `type[T]` versus `type[S]`
-
-By the same token, `type[T]` is disjoint from `type[S]` if the metaclass of `T` is disjoint from the
-metaclass of `S`.
-
-```py
-from typing import final
-from knot_extensions import static_assert, is_disjoint_from
-
-@final
-class Meta1(type): ...
-
-class Meta2(type): ...
-class UsesMeta1(metaclass=Meta1): ...
-class UsesMeta2(metaclass=Meta2): ...
-
-static_assert(is_disjoint_from(type[UsesMeta1], type[UsesMeta2]))
-```

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_equivalent_to.md

@@ -32,56 +32,4 @@ static_assert(not is_equivalent_to(Literal[1, 0], Literal[1, 2]))
 static_assert(not is_equivalent_to(Literal[1, 2, 3], Literal[1, 2]))
 ```
 
-## Differently ordered intersections and unions are equivalent
-
-```py
-from knot_extensions import is_equivalent_to, static_assert, Intersection, Not
-
-class P: ...
-class Q: ...
-class R: ...
-class S: ...
-
-static_assert(is_equivalent_to(P | Q | R, P | R | Q))  # 1
-static_assert(is_equivalent_to(P | Q | R, Q | P | R))  # 2
-static_assert(is_equivalent_to(P | Q | R, Q | R | P))  # 3
-static_assert(is_equivalent_to(P | Q | R, R | P | Q))  # 4
-static_assert(is_equivalent_to(P | Q | R, R | Q | P))  # 5
-static_assert(is_equivalent_to(P | R | Q, Q | P | R))  # 6
-static_assert(is_equivalent_to(P | R | Q, Q | R | P))  # 7
-static_assert(is_equivalent_to(P | R | Q, R | P | Q))  # 8
-static_assert(is_equivalent_to(P | R | Q, R | Q | P))  # 9
-static_assert(is_equivalent_to(Q | P | R, Q | R | P))  # 10
-static_assert(is_equivalent_to(Q | P | R, R | P | Q))  # 11
-static_assert(is_equivalent_to(Q | P | R, R | Q | P))  # 12
-static_assert(is_equivalent_to(Q | R | P, R | P | Q))  # 13
-static_assert(is_equivalent_to(Q | R | P, R | Q | P))  # 14
-static_assert(is_equivalent_to(R | P | Q, R | Q | P))  # 15
-
-static_assert(is_equivalent_to(str | None, None | str))
-
-static_assert(is_equivalent_to(Intersection[P, Q], Intersection[Q, P]))
-static_assert(is_equivalent_to(Intersection[Q, Not[P]], Intersection[Not[P], Q]))
-static_assert(is_equivalent_to(Intersection[Q, R, Not[P]], Intersection[Not[P], R, Q]))
-static_assert(is_equivalent_to(Intersection[Q | R, Not[P | S]], Intersection[Not[S | P], R | Q]))
-```
-
-## Tuples containing equivalent but differently ordered unions/intersections are equivalent
-
-```py
-from knot_extensions import is_equivalent_to, TypeOf, static_assert, Intersection, Not
-from typing import Literal
-
-class P: ...
-class Q: ...
-class R: ...
-class S: ...
-
-static_assert(is_equivalent_to(tuple[P | Q], tuple[Q | P]))
-static_assert(is_equivalent_to(tuple[P | None], tuple[None | P]))
-static_assert(
-    is_equivalent_to(tuple[Intersection[P, Q] | Intersection[R, Not[S]]], tuple[Intersection[Not[S], R] | Intersection[Q, P]])
-)
-```
-
 [the equivalence relation]: https://typing.readthedocs.io/en/latest/spec/glossary.html#term-equivalent

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_fully_static.md

@@ -1,54 +0,0 @@
-# Fully-static types
-
-A type is fully static iff it does not contain any gradual forms.
-
-## Fully-static
-
-```py
-from typing_extensions import Literal, LiteralString, Never
-from knot_extensions import Intersection, Not, TypeOf, is_fully_static, static_assert
-
-static_assert(is_fully_static(Never))
-static_assert(is_fully_static(None))
-
-static_assert(is_fully_static(Literal[1]))
-static_assert(is_fully_static(Literal[True]))
-static_assert(is_fully_static(Literal["abc"]))
-static_assert(is_fully_static(Literal[b"abc"]))
-
-static_assert(is_fully_static(LiteralString))
-
-static_assert(is_fully_static(str))
-static_assert(is_fully_static(object))
-static_assert(is_fully_static(type))
-
-static_assert(is_fully_static(TypeOf[str]))
-static_assert(is_fully_static(TypeOf[Literal]))
-
-static_assert(is_fully_static(str | None))
-static_assert(is_fully_static(Intersection[str, Not[LiteralString]]))
-
-static_assert(is_fully_static(tuple[()]))
-static_assert(is_fully_static(tuple[int, object]))
-
-static_assert(is_fully_static(type[str]))
-static_assert(is_fully_static(type[object]))
-```
-
-## Non-fully-static
-
-```py
-from typing_extensions import Any, Literal, LiteralString
-from knot_extensions import Intersection, Not, TypeOf, Unknown, is_fully_static, static_assert
-
-static_assert(not is_fully_static(Any))
-static_assert(not is_fully_static(Unknown))
-
-static_assert(not is_fully_static(Any | str))
-static_assert(not is_fully_static(str | Unknown))
-static_assert(not is_fully_static(Intersection[Any, Not[LiteralString]]))
-
-static_assert(not is_fully_static(tuple[Any, ...]))
-static_assert(not is_fully_static(tuple[int, Any]))
-static_assert(not is_fully_static(type[Any]))
-```

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_gradual_equivalent_to.md

@@ -1,64 +0,0 @@
-# Gradual equivalence relation
-
-Two gradual types `A` and `B` are equivalent if all [materializations] of `A` are also
-materializations of `B`, and all materializations of `B` are also materializations of `A`.
-
-## Basic
-
-```py
-from typing import Any
-from typing_extensions import Literal, LiteralString, Never
-from knot_extensions import AlwaysFalsy, AlwaysTruthy, TypeOf, Unknown, is_gradual_equivalent_to, static_assert
-
-static_assert(is_gradual_equivalent_to(Any, Any))
-static_assert(is_gradual_equivalent_to(Unknown, Unknown))
-static_assert(is_gradual_equivalent_to(Any, Unknown))
-
-static_assert(is_gradual_equivalent_to(Never, Never))
-static_assert(is_gradual_equivalent_to(AlwaysTruthy, AlwaysTruthy))
-static_assert(is_gradual_equivalent_to(AlwaysFalsy, AlwaysFalsy))
-static_assert(is_gradual_equivalent_to(LiteralString, LiteralString))
-
-static_assert(is_gradual_equivalent_to(Literal[True], Literal[True]))
-static_assert(is_gradual_equivalent_to(Literal[False], Literal[False]))
-static_assert(is_gradual_equivalent_to(TypeOf[0:1:2], TypeOf[0:1:2]))
-
-static_assert(is_gradual_equivalent_to(TypeOf[str], TypeOf[str]))
-static_assert(is_gradual_equivalent_to(type, type[object]))
-
-static_assert(not is_gradual_equivalent_to(type, type[Any]))
-static_assert(not is_gradual_equivalent_to(type[object], type[Any]))
-```
-
-## Unions and intersections
-
-```py
-from typing import Any
-from knot_extensions import Intersection, Not, Unknown, is_gradual_equivalent_to, static_assert
-
-static_assert(is_gradual_equivalent_to(str | int, str | int))
-static_assert(is_gradual_equivalent_to(str | int | Any, str | int | Unknown))
-static_assert(is_gradual_equivalent_to(str | int, int | str))
-static_assert(
-    is_gradual_equivalent_to(Intersection[str, int, Not[bytes], Not[None]], Intersection[int, str, Not[None], Not[bytes]])
-)
-# TODO: `~type[Any]` shoudld be gradually equivalent to `~type[Unknown]`
-# error: [static-assert-error]
-static_assert(is_gradual_equivalent_to(Intersection[str | int, Not[type[Any]]], Intersection[int | str, Not[type[Unknown]]]))
-
-static_assert(not is_gradual_equivalent_to(str | int, int | str | bytes))
-static_assert(not is_gradual_equivalent_to(str | int | bytes, int | str | dict))
-```
-
-## Tuples
-
-```py
-from knot_extensions import Unknown, is_gradual_equivalent_to, static_assert
-
-static_assert(is_gradual_equivalent_to(tuple[str, Any], tuple[str, Unknown]))
-
-static_assert(not is_gradual_equivalent_to(tuple[str, int], tuple[str, int, bytes]))
-static_assert(not is_gradual_equivalent_to(tuple[str, int], tuple[int, str]))
-```
-
-[materializations]: https://typing.readthedocs.io/en/latest/spec/glossary.html#term-materialize

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_single_valued.md

@@ -1,25 +0,0 @@
-## Single-valued types
-
-A type is single-valued iff it is not empty and all inhabitants of it compare equal.
-
-```py
-from typing_extensions import Any, Literal, LiteralString, Never
-from knot_extensions import is_single_valued, static_assert
-
-static_assert(is_single_valued(None))
-static_assert(is_single_valued(Literal[True]))
-static_assert(is_single_valued(Literal[1]))
-static_assert(is_single_valued(Literal["abc"]))
-static_assert(is_single_valued(Literal[b"abc"]))
-
-static_assert(is_single_valued(tuple[()]))
-static_assert(is_single_valued(tuple[Literal[True], Literal[1]]))
-
-static_assert(not is_single_valued(str))
-static_assert(not is_single_valued(Never))
-static_assert(not is_single_valued(Any))
-
-static_assert(not is_single_valued(Literal[1, 2]))
-
-static_assert(not is_single_valued(tuple[None, int]))
-```

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_singleton.md

@@ -1,56 +0,0 @@
-# Singleton types
-
-A type is a singleton type iff it has exactly one inhabitant.
-
-## Basic
-
-```py
-from typing_extensions import Literal, Never
-from knot_extensions import is_singleton, static_assert
-
-static_assert(is_singleton(None))
-static_assert(is_singleton(Literal[True]))
-static_assert(is_singleton(Literal[False]))
-
-static_assert(is_singleton(type[bool]))
-
-static_assert(not is_singleton(Never))
-static_assert(not is_singleton(str))
-
-static_assert(not is_singleton(Literal[345]))
-static_assert(not is_singleton(Literal[1, 2]))
-
-static_assert(not is_singleton(tuple[()]))
-static_assert(not is_singleton(tuple[None]))
-static_assert(not is_singleton(tuple[None, Literal[True]]))
-```
-
-## `NoDefault`
-
-### 3.12
-
-```toml
-[environment]
-python-version = "3.12"
-```
-
-```py
-from typing_extensions import _NoDefaultType
-from knot_extensions import is_singleton, static_assert
-
-static_assert(is_singleton(_NoDefaultType))
-```
-
-### 3.13
-
-```toml
-[environment]
-python-version = "3.13"
-```
-
-```py
-from typing import _NoDefaultType
-from knot_extensions import is_singleton, static_assert
-
-static_assert(is_singleton(_NoDefaultType))
-```

crates/red_knot_python_semantic/resources/mdtest/type_properties/str_repr.md

@@ -1,27 +0,0 @@
-# `__str__` and `__repr__`
-
-```py
-from typing_extensions import Literal, LiteralString
-
-def _(
-    a: Literal[1],
-    b: Literal[True],
-    c: Literal[False],
-    d: Literal["ab'cd"],
-    e: LiteralString,
-    f: int,
-):
-    reveal_type(str(a))  # revealed: Literal["1"]
-    reveal_type(str(b))  # revealed: Literal["True"]
-    reveal_type(str(c))  # revealed: Literal["False"]
-    reveal_type(str(d))  # revealed: Literal["ab'cd"]
-    reveal_type(str(e))  # revealed: LiteralString
-    reveal_type(str(f))  # revealed: str
-
-    reveal_type(repr(a))  # revealed: Literal["1"]
-    reveal_type(repr(b))  # revealed: Literal["True"]
-    reveal_type(repr(c))  # revealed: Literal["False"]
-    reveal_type(repr(d))  # revealed: Literal["'ab\\'cd'"]
-    reveal_type(repr(e))  # revealed: LiteralString
-    reveal_type(repr(f))  # revealed: str
-```

crates/red_knot_python_semantic/resources/mdtest/type_properties/truthiness.md

@@ -1,47 +0,0 @@
-# Truthiness
-
-```py
-from typing_extensions import Literal, LiteralString
-from knot_extensions import AlwaysFalsy, AlwaysTruthy
-
-def _(
-    a: Literal[1],
-    b: Literal[-1],
-    c: Literal["foo"],
-    d: tuple[Literal[0]],
-    e: Literal[1, 2],
-    f: AlwaysTruthy,
-):
-    reveal_type(bool(a))  # revealed: Literal[True]
-    reveal_type(bool(b))  # revealed: Literal[True]
-    reveal_type(bool(c))  # revealed: Literal[True]
-    reveal_type(bool(d))  # revealed: Literal[True]
-    reveal_type(bool(e))  # revealed: Literal[True]
-    reveal_type(bool(f))  # revealed: Literal[True]
-
-def _(
-    a: tuple[()],
-    b: Literal[0],
-    c: Literal[""],
-    d: Literal[b""],
-    e: Literal[0, 0],
-    f: AlwaysFalsy,
-):
-    reveal_type(bool(a))  # revealed: Literal[False]
-    reveal_type(bool(b))  # revealed: Literal[False]
-    reveal_type(bool(c))  # revealed: Literal[False]
-    reveal_type(bool(d))  # revealed: Literal[False]
-    reveal_type(bool(e))  # revealed: Literal[False]
-    reveal_type(bool(f))  # revealed: Literal[False]
-
-def _(
-    a: str,
-    b: Literal[1, 0],
-    c: str | Literal[0],
-    d: str | Literal[1],
-):
-    reveal_type(bool(a))  # revealed: bool
-    reveal_type(bool(b))  # revealed: bool
-    reveal_type(bool(c))  # revealed: bool
-    reveal_type(bool(d))  # revealed: bool
-```

crates/red_knot_python_semantic/resources/mdtest/type_qualifiers/classvar.md

@@ -1,93 +0,0 @@
-# `typing.ClassVar`
-
-[`typing.ClassVar`] is a type qualifier that is used to indicate that a class variable may not be
-written to from instances of that class.
-
-This test makes sure that we discover the type qualifier while inferring types from an annotation.
-For more details on the semantics of pure class variables, see [this test](../attributes.md).
-
-## Basic
-
-```py
-from typing import ClassVar, Annotated
-
-class C:
-    a: ClassVar[int] = 1
-    b: Annotated[ClassVar[int], "the annotation for b"] = 1
-    c: ClassVar[Annotated[int, "the annotation for c"]] = 1
-    d: ClassVar = 1
-    e: "ClassVar[int]" = 1
-
-reveal_type(C.a)  # revealed: int
-reveal_type(C.b)  # revealed: int
-reveal_type(C.c)  # revealed: int
-# TODO: should be Unknown | Literal[1]
-reveal_type(C.d)  # revealed: Unknown
-reveal_type(C.e)  # revealed: int
-
-c = C()
-
-# error: [invalid-attribute-access]
-c.a = 2
-# error: [invalid-attribute-access]
-c.b = 2
-# error: [invalid-attribute-access]
-c.c = 2
-# error: [invalid-attribute-access]
-c.d = 2
-# error: [invalid-attribute-access]
-c.e = 2
-```
-
-## Conflicting type qualifiers
-
-We currently ignore conflicting qualifiers and simply union them, which is more conservative than
-intersecting them. This means that we consider `a` to be a `ClassVar` here:
-
-```py
-from typing import ClassVar
-
-def flag() -> bool:
-    return True
-
-class C:
-    if flag():
-        a: ClassVar[int] = 1
-    else:
-        a: str
-
-reveal_type(C.a)  # revealed: int | str
-
-c = C()
-
-# error: [invalid-attribute-access]
-c.a = 2
-```
-
-## Too many arguments
-
-```py
-class C:
-    # error: [invalid-type-form] "Type qualifier `typing.ClassVar` expects exactly one type parameter"
-    x: ClassVar[int, str] = 1
-```
-
-## Illegal `ClassVar` in type expression
-
-```py
-class C:
-    # error: [invalid-type-form] "Type qualifier `typing.ClassVar` is not allowed in type expressions (only in annotation expressions)"
-    x: ClassVar | int
-
-    # error: [invalid-type-form] "Type qualifier `typing.ClassVar` is not allowed in type expressions (only in annotation expressions)"
-    y: int | ClassVar[str]
-```
-
-## Used outside of a class
-
-```py
-# TODO: this should be an error
-x: ClassVar[int] = 1
-```
-
-[`typing.classvar`]: https://docs.python.org/3/library/typing.html#typing.ClassVar

crates/red_knot_python_semantic/src/db.rs

@@ -175,7 +175,7 @@ pub(crate) mod tests {
             db.write_files(self.files)
                 .context("Failed to write test files")?;
 
-            let mut search_paths = SearchPathSettings::new(vec![src_root]);
+            let mut search_paths = SearchPathSettings::new(src_root);
             search_paths.typeshed = self.custom_typeshed;
 
             Program::from_settings(

crates/red_knot_python_semantic/src/module_resolver/resolver.rs

@@ -168,7 +168,7 @@ impl SearchPaths {
 
         let SearchPathSettings {
             extra_paths,
-            src_roots,
+            src_root,
             typeshed,
             site_packages: site_packages_paths,
         } = settings;
@@ -186,10 +186,8 @@ impl SearchPaths {
             static_paths.push(SearchPath::extra(system, path)?);
         }
 
-        for src_root in src_roots {
-            tracing::debug!("Adding first-party search path '{src_root}'");
-            static_paths.push(SearchPath::first_party(system, src_root.to_path_buf())?);
-        }
+        tracing::debug!("Adding first-party search path '{src_root}'");
+        static_paths.push(SearchPath::first_party(system, src_root.to_path_buf())?);
 
         let (typeshed_versions, stdlib_path) = if let Some(typeshed) = typeshed {
             let typeshed = canonicalize(typeshed, system);
@@ -222,14 +220,8 @@ impl SearchPaths {
         static_paths.push(stdlib_path);
 
         let site_packages_paths = match site_packages_paths {
-            SitePackages::Derived { venv_path } => {
-                // TODO: We may want to warn here if the venv's python version is older
-                //  than the one resolved in the program settings because it indicates
-                //  that the `target-version` is incorrectly configured or that the
-                //  venv is out of date.
-                VirtualEnvironment::new(venv_path, system)
-                    .and_then(|venv| venv.site_packages_directories(system))?
-            }
+            SitePackages::Derived { venv_path } => VirtualEnvironment::new(venv_path, system)
+                .and_then(|venv| venv.site_packages_directories(system))?,
             SitePackages::Known(paths) => paths
                 .iter()
                 .map(|path| canonicalize(path, system))
@@ -1307,7 +1299,7 @@ mod tests {
                 python_platform: PythonPlatform::default(),
                 search_paths: SearchPathSettings {
                     extra_paths: vec![],
-                    src_roots: vec![src.clone()],
+                    src_root: src.clone(),
                     typeshed: Some(custom_typeshed),
                     site_packages: SitePackages::Known(vec![site_packages]),
                 },
@@ -1813,7 +1805,7 @@ not_a_directory
                 python_platform: PythonPlatform::default(),
                 search_paths: SearchPathSettings {
                     extra_paths: vec![],
-                    src_roots: vec![SystemPathBuf::from("/src")],
+                    src_root: SystemPathBuf::from("/src"),
                     typeshed: None,
                     site_packages: SitePackages::Known(vec![
                         venv_site_packages,

crates/red_knot_python_semantic/src/module_resolver/testing.rs

@@ -237,7 +237,7 @@ impl TestCaseBuilder<MockedTypeshed> {
                 python_platform,
                 search_paths: SearchPathSettings {
                     extra_paths: vec![],
-                    src_roots: vec![src.clone()],
+                    src_root: src.clone(),
                     typeshed: Some(typeshed.clone()),
                     site_packages: SitePackages::Known(vec![site_packages.clone()]),
                 },
@@ -295,7 +295,7 @@ impl TestCaseBuilder<VendoredTypeshed> {
                 python_platform,
                 search_paths: SearchPathSettings {
                     site_packages: SitePackages::Known(vec![site_packages.clone()]),
-                    ..SearchPathSettings::new(vec![src.clone()])
+                    ..SearchPathSettings::new(src.clone())
                 },
             },
         )

crates/red_knot_python_semantic/src/program.rs

@@ -103,7 +103,7 @@ pub struct SearchPathSettings {
     pub extra_paths: Vec<SystemPathBuf>,
 
     /// The root of the project, used for finding first-party modules.
-    pub src_roots: Vec<SystemPathBuf>,
+    pub src_root: SystemPathBuf,
 
     /// Optional path to a "custom typeshed" directory on disk for us to use for standard-library types.
     /// If this is not provided, we will fallback to our vendored typeshed stubs for the stdlib,
@@ -115,9 +115,9 @@ pub struct SearchPathSettings {
 }
 
 impl SearchPathSettings {
-    pub fn new(src_roots: Vec<SystemPathBuf>) -> Self {
+    pub fn new(src_root: SystemPathBuf) -> Self {
         Self {
-            src_roots,
+            src_root,
             extra_paths: vec![],
             typeshed: None,
             site_packages: SitePackages::Known(vec![]),
@@ -126,7 +126,7 @@ impl SearchPathSettings {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
 pub enum SitePackages {
     Derived {
         venv_path: SystemPathBuf,

crates/red_knot_python_semantic/src/semantic_index/ast_ids.rs

@@ -2,7 +2,7 @@ use rustc_hash::FxHashMap;
 
 use ruff_index::newtype_index;
 use ruff_python_ast as ast;
-use ruff_python_ast::ExprRef;
+use ruff_python_ast::ExpressionRef;
 
 use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey;
 use crate::semantic_index::semantic_index;
@@ -60,12 +60,12 @@ pub trait HasScopedUseId {
 
 impl HasScopedUseId for ast::ExprName {
     fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId {
-        let expression_ref = ExprRef::from(self);
+        let expression_ref = ExpressionRef::from(self);
         expression_ref.scoped_use_id(db, scope)
     }
 }
 
-impl HasScopedUseId for ast::ExprRef<'_> {
+impl HasScopedUseId for ast::ExpressionRef<'_> {
     fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId {
         let ast_ids = ast_ids(db, scope);
         ast_ids.use_id(*self)
@@ -91,7 +91,7 @@ macro_rules! impl_has_scoped_expression_id {
     ($ty: ty) => {
         impl HasScopedExpressionId for $ty {
             fn scoped_expression_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedExpressionId {
-                let expression_ref = ExprRef::from(self);
+                let expression_ref = ExpressionRef::from(self);
                 expression_ref.scoped_expression_id(db, scope)
             }
         }
@@ -132,7 +132,7 @@ impl_has_scoped_expression_id!(ast::ExprSlice);
 impl_has_scoped_expression_id!(ast::ExprIpyEscapeCommand);
 impl_has_scoped_expression_id!(ast::Expr);
 
-impl HasScopedExpressionId for ast::ExprRef<'_> {
+impl HasScopedExpressionId for ast::ExpressionRef<'_> {
     fn scoped_expression_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedExpressionId {
         let ast_ids = ast_ids(db, scope);
         ast_ids.expression_id(*self)
@@ -184,8 +184,8 @@ pub(crate) mod node_key {
     #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub(crate) struct ExpressionNodeKey(NodeKey);
 
-    impl From<ast::ExprRef<'_>> for ExpressionNodeKey {
-        fn from(value: ast::ExprRef<'_>) -> Self {
+    impl From<ast::ExpressionRef<'_>> for ExpressionNodeKey {
+        fn from(value: ast::ExpressionRef<'_>) -> Self {
             Self(NodeKey::from_node(value))
         }
     }

crates/red_knot_python_semantic/src/semantic_model.rs

@@ -1,7 +1,7 @@
 use ruff_db::files::{File, FilePath};
 use ruff_db::source::line_index;
 use ruff_python_ast as ast;
-use ruff_python_ast::{Expr, ExprRef};
+use ruff_python_ast::{Expr, ExpressionRef};
 use ruff_source_file::LineIndex;
 
 use crate::module_name::ModuleName;
@@ -48,7 +48,7 @@ pub trait HasTy {
     fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db>;
 }
 
-impl HasTy for ast::ExprRef<'_> {
+impl HasTy for ast::ExpressionRef<'_> {
     fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
         let index = semantic_index(model.db, model.file);
         let file_scope = index.expression_scope_id(*self);
@@ -64,7 +64,7 @@ macro_rules! impl_expression_has_ty {
         impl HasTy for $ty {
             #[inline]
             fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
-                let expression_ref = ExprRef::from(self);
+                let expression_ref = ExpressionRef::from(self);
                 expression_ref.ty(model)
             }
         }

crates/red_knot_python_semantic/src/types/diagnostic.rs

@@ -1,4 +1,5 @@
 use super::context::InferContext;
+use crate::declare_lint;
 use crate::lint::{Level, LintRegistryBuilder, LintStatus};
 use crate::suppression::FileSuppressionId;
 use crate::types::string_annotation::{
@@ -6,8 +7,7 @@ use crate::types::string_annotation::{
     IMPLICIT_CONCATENATED_STRING_TYPE_ANNOTATION, INVALID_SYNTAX_IN_FORWARD_ANNOTATION,
     RAW_STRING_TYPE_ANNOTATION,
 };
-use crate::types::{ClassLiteralType, KnownInstanceType, Type};
-use crate::{declare_lint, Db};
+use crate::types::{ClassLiteralType, Type};
 use ruff_db::diagnostic::{Diagnostic, DiagnosticId, Severity};
 use ruff_db::files::File;
 use ruff_python_ast::{self as ast, AnyNodeRef};
@@ -59,7 +59,6 @@ pub(crate) fn register_lints(registry: &mut LintRegistryBuilder) {
     registry.register_lint(&UNSUPPORTED_OPERATOR);
     registry.register_lint(&ZERO_STEPSIZE_IN_SLICE);
     registry.register_lint(&STATIC_ASSERT_ERROR);
-    registry.register_lint(&INVALID_ATTRIBUTE_ACCESS);
 
     // String annotations
     registry.register_lint(&BYTE_STRING_TYPE_ANNOTATION);
@@ -751,25 +750,6 @@ declare_lint! {
     }
 }
 
-declare_lint! {
-    /// ## What it does
-    /// Makes sure that instance attribute accesses are valid.
-    ///
-    /// ## Examples
-    /// ```python
-    /// class C:
-    ///   var: ClassVar[int] = 1
-    ///
-    /// C.var = 3  # okay
-    /// C().var = 3  # error: Cannot assign to class variable
-    /// ```
-    pub(crate) static INVALID_ATTRIBUTE_ACCESS = {
-        summary: "Invalid attribute access",
-        status: LintStatus::preview("1.0.0"),
-        default_level: Level::Error,
-    }
-}
-
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub struct TypeCheckDiagnostic {
     pub(crate) id: DiagnosticId,
@@ -1080,18 +1060,3 @@ pub(crate) fn report_base_with_incompatible_slots(context: &InferContext, node:
         format_args!("Class base has incompatible `__slots__`"),
     );
 }
-
-pub(crate) fn report_invalid_arguments_to_annotated<'db>(
-    db: &'db dyn Db,
-    context: &InferContext<'db>,
-    subscript: &ast::ExprSubscript,
-) {
-    context.report_lint(
-        &INVALID_TYPE_FORM,
-        subscript.into(),
-        format_args!(
-            "Special form `{}` expected at least 2 arguments (one type and at least one metadata element)",
-            KnownInstanceType::Annotated.repr(db)
-        ),
-    );
-}

crates/red_knot_python_semantic/src/types/infer.rs

@@ -51,10 +51,9 @@ use crate::semantic_index::SemanticIndex;
 use crate::stdlib::builtins_module_scope;
 use crate::types::call::{Argument, CallArguments};
 use crate::types::diagnostic::{
-    report_invalid_arguments_to_annotated, report_invalid_assignment, report_unresolved_module,
-    TypeCheckDiagnostics, CALL_NON_CALLABLE, CALL_POSSIBLY_UNBOUND_METHOD,
-    CONFLICTING_DECLARATIONS, CONFLICTING_METACLASS, CYCLIC_CLASS_DEFINITION, DIVISION_BY_ZERO,
-    DUPLICATE_BASE, INCONSISTENT_MRO, INVALID_ATTRIBUTE_ACCESS, INVALID_BASE,
+    report_invalid_assignment, report_unresolved_module, TypeCheckDiagnostics, CALL_NON_CALLABLE,
+    CALL_POSSIBLY_UNBOUND_METHOD, CONFLICTING_DECLARATIONS, CONFLICTING_METACLASS,
+    CYCLIC_CLASS_DEFINITION, DIVISION_BY_ZERO, DUPLICATE_BASE, INCONSISTENT_MRO, INVALID_BASE,
     INVALID_CONTEXT_MANAGER, INVALID_DECLARATION, INVALID_PARAMETER_DEFAULT, INVALID_TYPE_FORM,
     INVALID_TYPE_VARIABLE_CONSTRAINTS, POSSIBLY_UNBOUND_ATTRIBUTE, POSSIBLY_UNBOUND_IMPORT,
     UNDEFINED_REVEAL, UNRESOLVED_ATTRIBUTE, UNRESOLVED_IMPORT, UNSUPPORTED_OPERATOR,
@@ -62,13 +61,12 @@ use crate::types::diagnostic::{
 use crate::types::mro::MroErrorKind;
 use crate::types::unpacker::{UnpackResult, Unpacker};
 use crate::types::{
-    builtins_symbol, global_symbol, symbol, symbol_from_bindings, symbol_from_declarations,
-    todo_type, typing_extensions_symbol, Boundness, CallDunderResult, Class, ClassLiteralType,
-    DynamicType, FunctionType, InstanceType, IntersectionBuilder, IntersectionType,
-    IterationOutcome, KnownClass, KnownFunction, KnownInstanceType, MetaclassCandidate,
-    MetaclassErrorKind, SliceLiteralType, SubclassOfType, Symbol, SymbolAndQualifiers, Truthiness,
-    TupleType, Type, TypeAliasType, TypeAndQualifiers, TypeArrayDisplay, TypeQualifiers,
-    TypeVarBoundOrConstraints, TypeVarInstance, UnionBuilder, UnionType,
+    bindings_ty, builtins_symbol, declarations_ty, global_symbol, symbol, todo_type,
+    typing_extensions_symbol, Boundness, CallDunderResult, Class, ClassLiteralType, DynamicType,
+    FunctionType, InstanceType, IntersectionBuilder, IntersectionType, IterationOutcome,
+    KnownClass, KnownFunction, KnownInstanceType, MetaclassCandidate, MetaclassErrorKind,
+    SliceLiteralType, SubclassOfType, Symbol, Truthiness, TupleType, Type, TypeAliasType,
+    TypeArrayDisplay, TypeVarBoundOrConstraints, TypeVarInstance, UnionBuilder, UnionType,
 };
 use crate::unpack::Unpack;
 use crate::util::subscript::{PyIndex, PySlice};
@@ -115,7 +113,7 @@ fn infer_definition_types_cycle_recovery<'db>(
     let mut inference = TypeInference::empty(input.scope(db));
     let category = input.category(db);
     if category.is_declaration() {
-        inference.declarations.insert(input, Type::unknown().into());
+        inference.declarations.insert(input, Type::unknown());
     }
     if category.is_binding() {
         inference.bindings.insert(input, Type::unknown());
@@ -243,8 +241,8 @@ pub(crate) struct TypeInference<'db> {
     /// The types of every binding in this region.
     bindings: FxHashMap<Definition<'db>, Type<'db>>,
 
-    /// The types and type qualifiers of every declaration in this region.
-    declarations: FxHashMap<Definition<'db>, TypeAndQualifiers<'db>>,
+    /// The types of every declaration in this region.
+    declarations: FxHashMap<Definition<'db>, Type<'db>>,
 
     /// The definitions that are deferred.
     deferred: FxHashSet<Definition<'db>>,
@@ -283,7 +281,7 @@ impl<'db> TypeInference<'db> {
     }
 
     #[track_caller]
-    pub(crate) fn declaration_ty(&self, definition: Definition<'db>) -> TypeAndQualifiers<'db> {
+    pub(crate) fn declaration_ty(&self, definition: Definition<'db>) -> Type<'db> {
         self.declarations[&definition]
     }
 
@@ -320,7 +318,7 @@ enum DeclaredAndInferredType<'db> {
     AreTheSame(Type<'db>),
     /// Declared and inferred types might be different, we need to check assignability.
     MightBeDifferent {
-        declared_ty: TypeAndQualifiers<'db>,
+        declared_ty: Type<'db>,
         inferred_ty: Type<'db>,
     },
 }
@@ -565,9 +563,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             .filter_map(|(definition, ty)| {
                 // Filter out class literals that result from imports
                 if let DefinitionKind::Class(class) = definition.kind(self.db()) {
-                    ty.inner_ty()
-                        .into_class_literal()
-                        .map(|ty| (ty.class, class.node()))
+                    ty.into_class_literal().map(|ty| (ty.class, class.node()))
                 } else {
                     None
                 }
@@ -576,17 +572,16 @@ impl<'db> TypeInferenceBuilder<'db> {
         // Iterate through all class definitions in this scope.
         for (class, class_node) in class_definitions {
             // (1) Check that the class does not have a cyclic definition
-            if let Some(inheritance_cycle) = class.inheritance_cycle(self.db()) {
-                if inheritance_cycle.is_participant() {
-                    self.context.report_lint(
-                        &CYCLIC_CLASS_DEFINITION,
-                        class_node.into(),
-                        format_args!(
-                            "Cyclic definition of `{}` (class cannot inherit from itself)",
-                            class.name(self.db())
-                        ),
-                    );
-                }
+            if class.is_cyclically_defined(self.db()) {
+                self.context.report_lint(
+                    &CYCLIC_CLASS_DEFINITION,
+                    class_node.into(),
+                    format_args!(
+                        "Cyclic definition of `{}` or bases of `{}` (class cannot inherit from itself)",
+                        class.name(self.db()),
+                        class.name(self.db())
+                    ),
+                );
                 // Attempting to determine the MRO of a class or if the class has a metaclass conflict
                 // is impossible if the class is cyclically defined; there's nothing more to do here.
                 continue;
@@ -859,8 +854,8 @@ impl<'db> TypeInferenceBuilder<'db> {
         let use_def = self.index.use_def_map(binding.file_scope(self.db()));
         let declarations = use_def.declarations_at_binding(binding);
         let mut bound_ty = ty;
-        let declared_ty = symbol_from_declarations(self.db(), declarations)
-            .map(|SymbolAndQualifiers(s, _)| s.ignore_possibly_unbound().unwrap_or(Type::unknown()))
+        let declared_ty = declarations_ty(self.db(), declarations)
+            .map(|s| s.ignore_possibly_unbound().unwrap_or(Type::unknown()))
             .unwrap_or_else(|(ty, conflicting)| {
                 // TODO point out the conflicting declarations in the diagnostic?
                 let symbol_table = self.index.symbol_table(binding.file_scope(self.db()));
@@ -873,7 +868,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         conflicting.display(self.db())
                     ),
                 );
-                ty.inner_ty()
+                ty
             });
         if !bound_ty.is_assignable_to(self.db(), declared_ty) {
             report_invalid_assignment(&self.context, node, declared_ty, bound_ty);
@@ -884,20 +879,15 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.types.bindings.insert(binding, bound_ty);
     }
 
-    fn add_declaration(
-        &mut self,
-        node: AnyNodeRef,
-        declaration: Definition<'db>,
-        ty: TypeAndQualifiers<'db>,
-    ) {
+    fn add_declaration(&mut self, node: AnyNodeRef, declaration: Definition<'db>, ty: Type<'db>) {
         debug_assert!(declaration.is_declaration(self.db()));
         let use_def = self.index.use_def_map(declaration.file_scope(self.db()));
         let prior_bindings = use_def.bindings_at_declaration(declaration);
         // unbound_ty is Never because for this check we don't care about unbound
-        let inferred_ty = symbol_from_bindings(self.db(), prior_bindings)
+        let inferred_ty = bindings_ty(self.db(), prior_bindings)
             .ignore_possibly_unbound()
             .unwrap_or(Type::Never);
-        let ty = if inferred_ty.is_assignable_to(self.db(), ty.inner_ty()) {
+        let ty = if inferred_ty.is_assignable_to(self.db(), ty) {
             ty
         } else {
             self.context.report_lint(
@@ -905,11 +895,11 @@ impl<'db> TypeInferenceBuilder<'db> {
                 node,
                 format_args!(
                     "Cannot declare type `{}` for inferred type `{}`",
-                    ty.inner_ty().display(self.db()),
+                    ty.display(self.db()),
                     inferred_ty.display(self.db())
                 ),
             );
-            Type::unknown().into()
+            Type::unknown()
         };
         self.types.declarations.insert(declaration, ty);
     }
@@ -923,28 +913,23 @@ impl<'db> TypeInferenceBuilder<'db> {
         debug_assert!(definition.is_binding(self.db()));
         debug_assert!(definition.is_declaration(self.db()));
 
-        let (declared_ty, inferred_ty) = match *declared_and_inferred_ty {
-            DeclaredAndInferredType::AreTheSame(ty) => (ty.into(), ty),
+        let (declared_ty, inferred_ty) = match declared_and_inferred_ty {
+            DeclaredAndInferredType::AreTheSame(ty) => (ty, ty),
             DeclaredAndInferredType::MightBeDifferent {
                 declared_ty,
                 inferred_ty,
             } => {
-                if inferred_ty.is_assignable_to(self.db(), declared_ty.inner_ty()) {
+                if inferred_ty.is_assignable_to(self.db(), *declared_ty) {
                     (declared_ty, inferred_ty)
                 } else {
-                    report_invalid_assignment(
-                        &self.context,
-                        node,
-                        declared_ty.inner_ty(),
-                        inferred_ty,
-                    );
+                    report_invalid_assignment(&self.context, node, *declared_ty, *inferred_ty);
                     // if the assignment is invalid, fall back to assuming the annotation is correct
-                    (declared_ty, declared_ty.inner_ty())
+                    (declared_ty, declared_ty)
                 }
             }
         };
-        self.types.declarations.insert(definition, declared_ty);
-        self.types.bindings.insert(definition, inferred_ty);
+        self.types.declarations.insert(definition, *declared_ty);
+        self.types.bindings.insert(definition, *inferred_ty);
     }
 
     fn add_unknown_declaration_with_binding(
@@ -1235,7 +1220,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             let declared_and_inferred_ty = if let Some(default_ty) = default_ty {
                 if default_ty.is_assignable_to(self.db(), declared_ty) {
                     DeclaredAndInferredType::MightBeDifferent {
-                        declared_ty: declared_ty.into(),
+                        declared_ty,
                         inferred_ty: UnionType::from_elements(self.db(), [declared_ty, default_ty]),
                     }
                 } else if self.in_stub()
@@ -2081,7 +2066,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         );
 
         // Handle various singletons.
-        if let Type::Instance(InstanceType { class }) = declared_ty.inner_ty() {
+        if let Type::Instance(InstanceType { class }) = declared_ty {
             if class.is_known(self.db(), KnownClass::SpecialForm) {
                 if let Some(name_expr) = target.as_name_expr() {
                     if let Some(known_instance) = KnownInstanceType::try_from_file_and_name(
@@ -2089,7 +2074,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         self.file(),
                         &name_expr.id,
                     ) {
-                        declared_ty.inner = Type::KnownInstance(known_instance);
+                        declared_ty = Type::KnownInstance(known_instance);
                     }
                 }
             }
@@ -2098,7 +2083,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         if let Some(value) = value.as_deref() {
             let inferred_ty = self.infer_expression(value);
             let inferred_ty = if self.in_stub() && value.is_ellipsis_literal_expr() {
-                declared_ty.inner_ty()
+                declared_ty
             } else {
                 inferred_ty
             };
@@ -3310,9 +3295,9 @@ impl<'db> TypeInferenceBuilder<'db> {
         let use_def = self.index.use_def_map(file_scope_id);
 
         // If we're inferring types of deferred expressions, always treat them as public symbols
-        let inferred = if self.is_deferred() {
+        let bindings_ty = if self.is_deferred() {
             if let Some(symbol) = self.index.symbol_table(file_scope_id).symbol_id_by_name(id) {
-                symbol_from_bindings(self.db(), use_def.public_bindings(symbol))
+                bindings_ty(self.db(), use_def.public_bindings(symbol))
             } else {
                 assert!(
                     self.deferred_state.in_string_annotation(),
@@ -3322,10 +3307,10 @@ impl<'db> TypeInferenceBuilder<'db> {
             }
         } else {
             let use_id = name.scoped_use_id(self.db(), self.scope());
-            symbol_from_bindings(self.db(), use_def.bindings_at_use(use_id))
+            bindings_ty(self.db(), use_def.bindings_at_use(use_id))
         };
 
-        if let Symbol::Type(ty, Boundness::Bound) = inferred {
+        if let Symbol::Type(ty, Boundness::Bound) = bindings_ty {
             ty
         } else {
             match self.lookup_name(name) {
@@ -3334,12 +3319,12 @@ impl<'db> TypeInferenceBuilder<'db> {
                         report_possibly_unresolved_reference(&self.context, name);
                     }
 
-                    inferred
+                    bindings_ty
                         .ignore_possibly_unbound()
                         .map(|ty| UnionType::from_elements(self.db(), [ty, looked_up_ty]))
                         .unwrap_or(looked_up_ty)
                 }
-                Symbol::Unbound => match inferred {
+                Symbol::Unbound => match bindings_ty {
                     Symbol::Type(ty, Boundness::PossiblyUnbound) => {
                         report_possibly_unresolved_reference(&self.context, name);
                         ty
@@ -3406,33 +3391,14 @@ impl<'db> TypeInferenceBuilder<'db> {
     fn infer_attribute_expression(&mut self, attribute: &ast::ExprAttribute) -> Type<'db> {
         let ast::ExprAttribute {
             value,
-            attr,
+            attr: _,
             range: _,
             ctx,
         } = attribute;
 
         match ctx {
             ExprContext::Load => self.infer_attribute_load(attribute),
-            ExprContext::Store => {
-                let value_ty = self.infer_expression(value);
-
-                if let Type::Instance(instance) = value_ty {
-                    let instance_member = instance.class.instance_member(self.db(), attr);
-                    if instance_member.is_class_var() {
-                        self.context.report_lint(
-                            &INVALID_ATTRIBUTE_ACCESS,
-                            attribute.into(),
-                            format_args!(
-                                "Cannot assign to ClassVar `{attr}` from an instance of type `{ty}`",
-                                ty = value_ty.display(self.db()),
-                            ),
-                        );
-                    }
-                }
-
-                Type::Never
-            }
-            ExprContext::Del => {
+            ExprContext::Store | ExprContext::Del => {
                 self.infer_expression(value);
                 Type::Never
             }
@@ -4732,7 +4698,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         &mut self,
         annotation: &ast::Expr,
         deferred_state: DeferredExpressionState,
-    ) -> TypeAndQualifiers<'db> {
+    ) -> Type<'db> {
         let previous_deferred_state = std::mem::replace(&mut self.deferred_state, deferred_state);
         let annotation_ty = self.infer_annotation_expression_impl(annotation);
         self.deferred_state = previous_deferred_state;
@@ -4747,24 +4713,21 @@ impl<'db> TypeInferenceBuilder<'db> {
         &mut self,
         annotation: Option<&ast::Expr>,
         deferred_state: DeferredExpressionState,
-    ) -> Option<TypeAndQualifiers<'db>> {
+    ) -> Option<Type<'db>> {
         annotation.map(|expr| self.infer_annotation_expression(expr, deferred_state))
     }
 
     /// Implementation of [`infer_annotation_expression`].
     ///
     /// [`infer_annotation_expression`]: TypeInferenceBuilder::infer_annotation_expression
-    fn infer_annotation_expression_impl(
-        &mut self,
-        annotation: &ast::Expr,
-    ) -> TypeAndQualifiers<'db> {
+    fn infer_annotation_expression_impl(&mut self, annotation: &ast::Expr) -> Type<'db> {
         // https://typing.readthedocs.io/en/latest/spec/annotations.html#grammar-token-expression-grammar-annotation_expression
         let annotation_ty = match annotation {
             // String annotations: https://typing.readthedocs.io/en/latest/spec/annotations.html#string-annotations
             ast::Expr::StringLiteral(string) => self.infer_string_annotation_expression(string),
 
             // Annotation expressions also get special handling for `*args` and `**kwargs`.
-            ast::Expr::Starred(starred) => self.infer_starred_expression(starred).into(),
+            ast::Expr::Starred(starred) => self.infer_starred_expression(starred),
 
             ast::Expr::BytesLiteral(bytes) => {
                 self.context.report_lint(
@@ -4772,7 +4735,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     bytes.into(),
                     format_args!("Type expressions cannot use bytes literal"),
                 );
-                Type::unknown().into()
+                Type::unknown()
             }
 
             ast::Expr::FString(fstring) => {
@@ -4782,126 +4745,21 @@ impl<'db> TypeInferenceBuilder<'db> {
                     format_args!("Type expressions cannot use f-strings"),
                 );
                 self.infer_fstring_expression(fstring);
-                Type::unknown().into()
-            }
-
-            ast::Expr::Name(name) => match name.ctx {
-                ast::ExprContext::Load => {
-                    let name_expr_ty = self.infer_name_expression(name);
-                    match name_expr_ty {
-                        Type::KnownInstance(KnownInstanceType::ClassVar) => {
-                            TypeAndQualifiers::new(Type::unknown(), TypeQualifiers::CLASS_VAR)
-                        }
-                        Type::KnownInstance(KnownInstanceType::Final) => {
-                            TypeAndQualifiers::new(Type::unknown(), TypeQualifiers::FINAL)
-                        }
-                        _ => name_expr_ty
-                            .in_type_expression(self.db())
-                            .unwrap_or_else(|error| {
-                                error.into_fallback_type(&self.context, annotation)
-                            })
-                            .into(),
-                    }
-                }
-                ast::ExprContext::Invalid => Type::unknown().into(),
-                ast::ExprContext::Store | ast::ExprContext::Del => todo_type!().into(),
-            },
-
-            ast::Expr::Subscript(subscript @ ast::ExprSubscript { value, slice, .. }) => {
-                let value_ty = self.infer_expression(value);
-
-                let slice = &**slice;
-
-                match value_ty {
-                    Type::KnownInstance(KnownInstanceType::Annotated) => {
-                        // This branch is similar to the corresponding branch in `infer_parameterized_known_instance_type_expression`, but
-                        // `Annotated[…]` can appear both in annotation expressions and in type expressions, and needs to be handled slightly
-                        // differently in each case (calling either `infer_type_expression_*` or `infer_annotation_expression_*`).
-                        if let ast::Expr::Tuple(ast::ExprTuple {
-                            elts: arguments, ..
-                        }) = slice
-                        {
-                            if arguments.len() < 2 {
-                                report_invalid_arguments_to_annotated(
-                                    self.db(),
-                                    &self.context,
-                                    subscript,
-                                );
-                            }
-
-                            if let [inner_annotation, metadata @ ..] = &arguments[..] {
-                                for element in metadata {
-                                    self.infer_expression(element);
-                                }
-
-                                let inner_annotation_ty =
-                                    self.infer_annotation_expression_impl(inner_annotation);
-
-                                self.store_expression_type(slice, inner_annotation_ty.inner_ty());
-                                inner_annotation_ty
-                            } else {
-                                self.infer_type_expression(slice);
-                                Type::unknown().into()
-                            }
-                        } else {
-                            report_invalid_arguments_to_annotated(
-                                self.db(),
-                                &self.context,
-                                subscript,
-                            );
-                            self.infer_annotation_expression_impl(slice)
-                        }
-                    }
-                    Type::KnownInstance(
-                        known_instance @ (KnownInstanceType::ClassVar | KnownInstanceType::Final),
-                    ) => match slice {
-                        ast::Expr::Tuple(..) => {
-                            self.context.report_lint(
-                                &INVALID_TYPE_FORM,
-                                subscript.into(),
-                                format_args!(
-                                    "Type qualifier `{type_qualifier}` expects exactly one type parameter",
-                                    type_qualifier = known_instance.repr(self.db()),
-                                ),
-                            );
-                            Type::unknown().into()
-                        }
-                        _ => {
-                            let mut type_and_qualifiers =
-                                self.infer_annotation_expression_impl(slice);
-                            match known_instance {
-                                KnownInstanceType::ClassVar => {
-                                    type_and_qualifiers.add_qualifier(TypeQualifiers::CLASS_VAR);
-                                }
-                                KnownInstanceType::Final => {
-                                    type_and_qualifiers.add_qualifier(TypeQualifiers::FINAL);
-                                }
-                                _ => unreachable!(),
-                            }
-                            type_and_qualifiers
-                        }
-                    },
-                    _ => self
-                        .infer_subscript_type_expression_no_store(subscript, slice, value_ty)
-                        .into(),
-                }
+                Type::unknown()
             }
 
             // All other annotation expressions are (possibly) valid type expressions, so handle
             // them there instead.
-            type_expr => self.infer_type_expression_no_store(type_expr).into(),
+            type_expr => self.infer_type_expression_no_store(type_expr),
         };
 
-        self.store_expression_type(annotation, annotation_ty.inner_ty());
+        self.store_expression_type(annotation, annotation_ty);
 
         annotation_ty
     }
 
     /// Infer the type of a string annotation expression.
-    fn infer_string_annotation_expression(
-        &mut self,
-        string: &ast::ExprStringLiteral,
-    ) -> TypeAndQualifiers<'db> {
+    fn infer_string_annotation_expression(&mut self, string: &ast::ExprStringLiteral) -> Type<'db> {
         match parse_string_annotation(&self.context, string) {
             Some(parsed) => {
                 // String annotations are always evaluated in the deferred context.
@@ -4910,7 +4768,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     DeferredExpressionState::InStringAnnotation,
                 )
             }
-            None => Type::unknown().into(),
+            None => Type::unknown(),
         }
     }
 }
@@ -4997,7 +4855,16 @@ impl<'db> TypeInferenceBuilder<'db> {
 
                 let value_ty = self.infer_expression(value);
 
-                self.infer_subscript_type_expression_no_store(subscript, slice, value_ty)
+                match value_ty {
+                    Type::ClassLiteral(class_literal_ty) => {
+                        match class_literal_ty.class.known(self.db()) {
+                            Some(KnownClass::Tuple) => self.infer_tuple_type_expression(slice),
+                            Some(KnownClass::Type) => self.infer_subclass_of_type_expression(slice),
+                            _ => self.infer_subscript_type_expression(subscript, value_ty),
+                        }
+                    }
+                    _ => self.infer_subscript_type_expression(subscript, value_ty),
+                }
             }
 
             ast::Expr::BinOp(binary) => {
@@ -5113,22 +4980,6 @@ impl<'db> TypeInferenceBuilder<'db> {
         }
     }
 
-    fn infer_subscript_type_expression_no_store(
-        &mut self,
-        subscript: &ast::ExprSubscript,
-        slice: &ast::Expr,
-        value_ty: Type<'db>,
-    ) -> Type<'db> {
-        match value_ty {
-            Type::ClassLiteral(class_literal_ty) => match class_literal_ty.class.known(self.db()) {
-                Some(KnownClass::Tuple) => self.infer_tuple_type_expression(slice),
-                Some(KnownClass::Type) => self.infer_subclass_of_type_expression(slice),
-                _ => self.infer_subscript_type_expression(subscript, value_ty),
-            },
-            _ => self.infer_subscript_type_expression(subscript, value_ty),
-        }
-    }
-
     /// Infer the type of a string type expression.
     fn infer_string_type_expression(&mut self, string: &ast::ExprStringLiteral) -> Type<'db> {
         match parse_string_annotation(&self.context, string) {
@@ -5312,11 +5163,22 @@ impl<'db> TypeInferenceBuilder<'db> {
         let arguments_slice = &*subscript.slice;
         match known_instance {
             KnownInstanceType::Annotated => {
+                let report_invalid_arguments = || {
+                    self.context.report_lint(
+                        &INVALID_TYPE_FORM,
+                        subscript.into(),
+                        format_args!(
+                            "Special form `{}` expected at least 2 arguments (one type and at least one metadata element)",
+                            known_instance.repr(self.db())
+                        ),
+                    );
+                };
+
                 let ast::Expr::Tuple(ast::ExprTuple {
                     elts: arguments, ..
                 }) = arguments_slice
                 else {
-                    report_invalid_arguments_to_annotated(self.db(), &self.context, subscript);
+                    report_invalid_arguments();
 
                     // `Annotated[]` with less than two arguments is an error at runtime.
                     // However, we still treat `Annotated[T]` as `T` here for the purpose of
@@ -5326,7 +5188,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                 };
 
                 if arguments.len() < 2 {
-                    report_invalid_arguments_to_annotated(self.db(), &self.context, subscript);
+                    report_invalid_arguments();
                 }
 
                 let [type_expr, metadata @ ..] = &arguments[..] else {
@@ -5483,16 +5345,13 @@ impl<'db> TypeInferenceBuilder<'db> {
                 self.infer_type_expression(arguments_slice);
                 todo_type!("`NotRequired[]` type qualifier")
             }
-            KnownInstanceType::ClassVar | KnownInstanceType::Final => {
-                self.context.report_lint(
-                    &INVALID_TYPE_FORM,
-                    subscript.into(),
-                    format_args!(
-                        "Type qualifier `{}` is not allowed in type expressions (only in annotation expressions)",
-                        known_instance.repr(self.db())
-                    ),
-                );
-                self.infer_type_expression(arguments_slice)
+            KnownInstanceType::ClassVar => {
+                let ty = self.infer_type_expression(arguments_slice);
+                ty
+            }
+            KnownInstanceType::Final => {
+                self.infer_type_expression(arguments_slice);
+                todo_type!("`Final[]` type qualifier")
             }
             KnownInstanceType::Required => {
                 self.infer_type_expression(arguments_slice);

crates/red_knot_python_semantic/src/types/mro.rs

@@ -42,7 +42,7 @@ impl<'db> Mro<'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.inheritance_cycle(db).is_some() {
+        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.

crates/red_knot_python_semantic/src/types/property_tests.rs

@@ -26,107 +26,11 @@
 
 use std::sync::{Arc, Mutex, MutexGuard, OnceLock};
 
+use super::tests::Ty;
 use crate::db::tests::{setup_db, TestDb};
-use crate::types::{
-    builtins_symbol, known_module_symbol, IntersectionBuilder, KnownClass, KnownInstanceType,
-    SubclassOfType, TupleType, Type, UnionType,
-};
-use crate::KnownModule;
+use crate::types::{IntersectionBuilder, KnownClass, Type, UnionType};
 use quickcheck::{Arbitrary, Gen};
 
-/// A test representation of a type that can be transformed unambiguously into a real Type,
-/// given a db.
-#[derive(Debug, Clone, PartialEq)]
-pub(crate) enum Ty {
-    Never,
-    Unknown,
-    None,
-    Any,
-    IntLiteral(i64),
-    BooleanLiteral(bool),
-    StringLiteral(&'static str),
-    LiteralString,
-    BytesLiteral(&'static str),
-    // BuiltinInstance("str") corresponds to an instance of the builtin `str` class
-    BuiltinInstance(&'static str),
-    /// Members of the `abc` stdlib module
-    AbcInstance(&'static str),
-    AbcClassLiteral(&'static str),
-    TypingLiteral,
-    // BuiltinClassLiteral("str") corresponds to the builtin `str` class object itself
-    BuiltinClassLiteral(&'static str),
-    KnownClassInstance(KnownClass),
-    Union(Vec<Ty>),
-    Intersection {
-        pos: Vec<Ty>,
-        neg: Vec<Ty>,
-    },
-    Tuple(Vec<Ty>),
-    SubclassOfAny,
-    SubclassOfBuiltinClass(&'static str),
-    SubclassOfAbcClass(&'static str),
-    AlwaysTruthy,
-    AlwaysFalsy,
-}
-
-impl Ty {
-    pub(crate) fn into_type(self, db: &TestDb) -> Type<'_> {
-        match self {
-            Ty::Never => Type::Never,
-            Ty::Unknown => Type::unknown(),
-            Ty::None => Type::none(db),
-            Ty::Any => Type::any(),
-            Ty::IntLiteral(n) => Type::IntLiteral(n),
-            Ty::StringLiteral(s) => Type::string_literal(db, s),
-            Ty::BooleanLiteral(b) => Type::BooleanLiteral(b),
-            Ty::LiteralString => Type::LiteralString,
-            Ty::BytesLiteral(s) => Type::bytes_literal(db, s.as_bytes()),
-            Ty::BuiltinInstance(s) => builtins_symbol(db, s).expect_type().to_instance(db),
-            Ty::AbcInstance(s) => known_module_symbol(db, KnownModule::Abc, s)
-                .expect_type()
-                .to_instance(db),
-            Ty::AbcClassLiteral(s) => known_module_symbol(db, KnownModule::Abc, s).expect_type(),
-            Ty::TypingLiteral => Type::KnownInstance(KnownInstanceType::Literal),
-            Ty::BuiltinClassLiteral(s) => builtins_symbol(db, s).expect_type(),
-            Ty::KnownClassInstance(known_class) => known_class.to_instance(db),
-            Ty::Union(tys) => {
-                UnionType::from_elements(db, tys.into_iter().map(|ty| ty.into_type(db)))
-            }
-            Ty::Intersection { pos, neg } => {
-                let mut builder = IntersectionBuilder::new(db);
-                for p in pos {
-                    builder = builder.add_positive(p.into_type(db));
-                }
-                for n in neg {
-                    builder = builder.add_negative(n.into_type(db));
-                }
-                builder.build()
-            }
-            Ty::Tuple(tys) => {
-                let elements = tys.into_iter().map(|ty| ty.into_type(db));
-                TupleType::from_elements(db, elements)
-            }
-            Ty::SubclassOfAny => SubclassOfType::subclass_of_any(),
-            Ty::SubclassOfBuiltinClass(s) => SubclassOfType::from(
-                db,
-                builtins_symbol(db, s)
-                    .expect_type()
-                    .expect_class_literal()
-                    .class,
-            ),
-            Ty::SubclassOfAbcClass(s) => SubclassOfType::from(
-                db,
-                known_module_symbol(db, KnownModule::Abc, s)
-                    .expect_type()
-                    .expect_class_literal()
-                    .class,
-            ),
-            Ty::AlwaysTruthy => Type::AlwaysTruthy,
-            Ty::AlwaysFalsy => Type::AlwaysFalsy,
-        }
-    }
-}
-
 fn arbitrary_core_type(g: &mut Gen) -> Ty {
     // We could select a random integer here, but this would make it much less
     // likely to explore interesting edge cases:
@@ -301,7 +205,7 @@ macro_rules! type_property_test {
     ($test_name:ident, $db:ident, forall types $($types:ident),+ . $property:expr) => {
         #[quickcheck_macros::quickcheck]
         #[ignore]
-        fn $test_name($($types: super::Ty),+) -> bool {
+        fn $test_name($($types: crate::types::tests::Ty),+) -> bool {
             let db_cached = super::get_cached_db();
             let $db = &*db_cached;
             $(let $types = $types.into_type($db);)+
@@ -315,16 +219,15 @@ macro_rules! type_property_test {
     };
 }
 
-fn intersection<'db>(db: &'db TestDb, tys: impl IntoIterator<Item = Type<'db>>) -> Type<'db> {
-    let mut builder = IntersectionBuilder::new(db);
-    for ty in tys {
-        builder = builder.add_positive(ty);
-    }
-    builder.build()
+fn intersection<'db>(db: &'db TestDb, s: Type<'db>, t: Type<'db>) -> Type<'db> {
+    IntersectionBuilder::new(db)
+        .add_positive(s)
+        .add_positive(t)
+        .build()
 }
 
-fn union<'db>(db: &'db TestDb, tys: impl IntoIterator<Item = Type<'db>>) -> Type<'db> {
-    UnionType::from_elements(db, tys)
+fn union<'db>(db: &'db TestDb, s: Type<'db>, t: Type<'db>) -> Type<'db> {
+    UnionType::from_elements(db, [s, t])
 }
 
 mod stable {
@@ -350,12 +253,6 @@ mod stable {
         forall types s, t, u. s.is_equivalent_to(db, t) && t.is_equivalent_to(db, u) => s.is_equivalent_to(db, u)
     );
 
-    // Symmetry: If `S` is gradual equivalent to `T`, `T` is gradual equivalent to `S`.
-    type_property_test!(
-        gradual_equivalent_to_is_symmetric, db,
-        forall types s, t. s.is_gradual_equivalent_to(db, t) => t.is_gradual_equivalent_to(db, s)
-    );
-
     // A fully static type `T` is a subtype of itself.
     type_property_test!(
         subtype_of_is_reflexive, db,
@@ -368,12 +265,6 @@ mod stable {
         forall types s, t, u. s.is_subtype_of(db, t) && t.is_subtype_of(db, u) => s.is_subtype_of(db, u)
     );
 
-    // `S <: T` and `T <: S` implies that `S` is equivalent to `T`.
-    type_property_test!(
-        subtype_of_is_antisymmetric, db,
-        forall types s, t. s.is_subtype_of(db, t) && t.is_subtype_of(db, s) => s.is_equivalent_to(db, t)
-    );
-
     // `T` is not disjoint from itself, unless `T` is `Never`.
     type_property_test!(
         disjoint_from_is_irreflexive, db,
@@ -445,21 +336,7 @@ mod stable {
         all_fully_static_type_pairs_are_subtype_of_their_union, db,
         forall types s, t.
             s.is_fully_static(db) && t.is_fully_static(db)
-            => s.is_subtype_of(db, union(db, [s, t])) && t.is_subtype_of(db, union(db, [s, t]))
-    );
-
-    // A fully static type does not have any materializations.
-    // Thus, two equivalent (fully static) types are also gradual equivalent.
-    type_property_test!(
-        two_equivalent_types_are_also_gradual_equivalent, db,
-        forall types s, t. s.is_equivalent_to(db, t) => s.is_gradual_equivalent_to(db, t)
-    );
-
-    // Two gradual equivalent fully static types are also equivalent.
-    type_property_test!(
-        two_gradual_equivalent_fully_static_types_are_also_equivalent, db,
-        forall types s, t.
-            s.is_fully_static(db) && s.is_gradual_equivalent_to(db, t) => s.is_equivalent_to(db, t)
+            => s.is_subtype_of(db, union(db, s, t)) && t.is_subtype_of(db, union(db, s, t))
     );
 }
 
@@ -471,8 +348,6 @@ mod stable {
 /// tests to the `stable` section. In the meantime, it can still be useful to run these
 /// tests (using [`types::property_tests::flaky`]), to see if there are any new obvious bugs.
 mod flaky {
-    use itertools::Itertools;
-
     use super::{intersection, union};
 
     // Currently fails due to https://github.com/astral-sh/ruff/issues/14899
@@ -482,6 +357,13 @@ mod flaky {
         forall types t. t.is_assignable_to(db, t)
     );
 
+    // `S <: T` and `T <: S` implies that `S` is equivalent to `T`.
+    // This very often passes now, but occasionally flakes due to https://github.com/astral-sh/ruff/issues/15380
+    type_property_test!(
+        subtype_of_is_antisymmetric, db,
+        forall types s, t. s.is_subtype_of(db, t) && t.is_subtype_of(db, s) => s.is_equivalent_to(db, t)
+    );
+
     // Negating `T` twice is equivalent to `T`.
     type_property_test!(
         double_negation_is_identity, db,
@@ -505,7 +387,7 @@ mod flaky {
         all_fully_static_type_pairs_are_supertypes_of_their_intersection, db,
         forall types s, t.
             s.is_fully_static(db) && t.is_fully_static(db)
-            => intersection(db, [s, t]).is_subtype_of(db, s) && intersection(db, [s, t]).is_subtype_of(db, t)
+            => intersection(db, s, t).is_subtype_of(db, s) && intersection(db, s, t).is_subtype_of(db, t)
     );
 
     // And for non-fully-static types, the intersection of a pair of types
@@ -513,49 +395,13 @@ mod flaky {
     // Currently fails due to https://github.com/astral-sh/ruff/issues/14899
     type_property_test!(
         all_type_pairs_can_be_assigned_from_their_intersection, db,
-        forall types s, t. intersection(db, [s, t]).is_assignable_to(db, s) && intersection(db, [s, t]).is_assignable_to(db, t)
+        forall types s, t. intersection(db, s, t).is_assignable_to(db, s) && intersection(db, s, t).is_assignable_to(db, t)
     );
 
     // For *any* pair of types, whether fully static or not,
     // each of the pair should be assignable to the union of the two.
     type_property_test!(
         all_type_pairs_are_assignable_to_their_union, db,
-        forall types s, t. s.is_assignable_to(db, union(db, [s, t])) && t.is_assignable_to(db, union(db, [s, t]))
-    );
-
-    // Equal element sets of intersections implies equivalence
-    // flaky at least in part because of https://github.com/astral-sh/ruff/issues/15513
-    type_property_test!(
-        intersection_equivalence_not_order_dependent, db,
-        forall types s, t, u.
-            s.is_fully_static(db) && t.is_fully_static(db) && u.is_fully_static(db)
-            => [s, t, u]
-                .into_iter()
-                .permutations(3)
-                .map(|trio_of_types| intersection(db, trio_of_types))
-                .permutations(2)
-                .all(|vec_of_intersections| vec_of_intersections[0].is_equivalent_to(db, vec_of_intersections[1]))
-    );
-
-    // Equal element sets of unions implies equivalence
-    // flaky at laest in part because of https://github.com/astral-sh/ruff/issues/15513
-    type_property_test!(
-        union_equivalence_not_order_dependent, db,
-        forall types s, t, u.
-            s.is_fully_static(db) && t.is_fully_static(db) && u.is_fully_static(db)
-            => [s, t, u]
-                .into_iter()
-                .permutations(3)
-                .map(|trio_of_types| union(db, trio_of_types))
-                .permutations(2)
-                .all(|vec_of_unions| vec_of_unions[0].is_equivalent_to(db, vec_of_unions[1]))
-    );
-
-    // `S | T` is always a supertype of `S`.
-    // Thus, `S` is never disjoint from `S | T`.
-    type_property_test!(
-        constituent_members_of_union_is_not_disjoint_from_that_union, db,
-        forall types s, t.
-            !s.is_disjoint_from(db, union(db, [s, t])) && !t.is_disjoint_from(db, union(db, [s, t]))
+        forall types s, t. s.is_assignable_to(db, union(db, s, t)) && t.is_assignable_to(db, union(db, s, t))
     );
 }

crates/red_knot_python_semantic/src/types/type_ordering.rs

@@ -1,266 +0,0 @@
-use std::cmp::Ordering;
-
-use super::{
-    class_base::ClassBase, ClassLiteralType, DynamicType, InstanceType, KnownInstanceType,
-    TodoType, Type,
-};
-
-/// Return an [`Ordering`] that describes the canonical order in which two types should appear
-/// in an [`crate::types::IntersectionType`] or a [`crate::types::UnionType`] in order for them
-/// to be compared for equivalence.
-///
-/// Two unions with equal sets of elements will only compare equal if they have their element sets
-/// ordered the same way.
-///
-/// ## Why not just implement [`Ord`] on [`Type`]?
-///
-/// It would be fairly easy to slap `#[derive(PartialOrd, Ord)]` on [`Type`], and the ordering we
-/// create here is not user-facing. However, it doesn't really "make sense" for `Type` to implement
-/// [`Ord`] in terms of the semantics. There are many different ways in which you could plausibly
-/// sort a list of types; this is only one (somewhat arbitrary, at times) possible ordering.
-pub(super) fn union_elements_ordering<'db>(left: &Type<'db>, right: &Type<'db>) -> Ordering {
-    if left == right {
-        return Ordering::Equal;
-    }
-
-    match (left, right) {
-        (Type::Never, _) => Ordering::Less,
-        (_, Type::Never) => Ordering::Greater,
-
-        (Type::LiteralString, _) => Ordering::Less,
-        (_, Type::LiteralString) => Ordering::Greater,
-
-        (Type::BooleanLiteral(left), Type::BooleanLiteral(right)) => left.cmp(right),
-        (Type::BooleanLiteral(_), _) => Ordering::Less,
-        (_, Type::BooleanLiteral(_)) => Ordering::Greater,
-
-        (Type::IntLiteral(left), Type::IntLiteral(right)) => left.cmp(right),
-        (Type::IntLiteral(_), _) => Ordering::Less,
-        (_, Type::IntLiteral(_)) => Ordering::Greater,
-
-        (Type::StringLiteral(left), Type::StringLiteral(right)) => left.cmp(right),
-        (Type::StringLiteral(_), _) => Ordering::Less,
-        (_, Type::StringLiteral(_)) => Ordering::Greater,
-
-        (Type::BytesLiteral(left), Type::BytesLiteral(right)) => left.cmp(right),
-        (Type::BytesLiteral(_), _) => Ordering::Less,
-        (_, Type::BytesLiteral(_)) => Ordering::Greater,
-
-        (Type::SliceLiteral(left), Type::SliceLiteral(right)) => left.cmp(right),
-        (Type::SliceLiteral(_), _) => Ordering::Less,
-        (_, Type::SliceLiteral(_)) => Ordering::Greater,
-
-        (Type::FunctionLiteral(left), Type::FunctionLiteral(right)) => left.cmp(right),
-        (Type::FunctionLiteral(_), _) => Ordering::Less,
-        (_, Type::FunctionLiteral(_)) => Ordering::Greater,
-
-        (Type::Tuple(left), Type::Tuple(right)) => left.cmp(right),
-        (Type::Tuple(_), _) => Ordering::Less,
-        (_, Type::Tuple(_)) => Ordering::Greater,
-
-        (Type::ModuleLiteral(left), Type::ModuleLiteral(right)) => left.cmp(right),
-        (Type::ModuleLiteral(_), _) => Ordering::Less,
-        (_, Type::ModuleLiteral(_)) => Ordering::Greater,
-
-        (
-            Type::ClassLiteral(ClassLiteralType { class: left }),
-            Type::ClassLiteral(ClassLiteralType { class: right }),
-        ) => left.cmp(right),
-        (Type::ClassLiteral(_), _) => Ordering::Less,
-        (_, Type::ClassLiteral(_)) => Ordering::Greater,
-
-        (Type::SubclassOf(left), Type::SubclassOf(right)) => {
-            match (left.subclass_of(), right.subclass_of()) {
-                (ClassBase::Class(left), ClassBase::Class(right)) => left.cmp(&right),
-                (ClassBase::Class(_), _) => Ordering::Less,
-                (_, ClassBase::Class(_)) => Ordering::Greater,
-                (ClassBase::Dynamic(left), ClassBase::Dynamic(right)) => {
-                    dynamic_elements_ordering(left, right)
-                }
-            }
-        }
-
-        (Type::SubclassOf(_), _) => Ordering::Less,
-        (_, Type::SubclassOf(_)) => Ordering::Greater,
-        (
-            Type::Instance(InstanceType { class: left }),
-            Type::Instance(InstanceType { class: right }),
-        ) => left.cmp(right),
-
-        (Type::Instance(_), _) => Ordering::Less,
-        (_, Type::Instance(_)) => Ordering::Greater,
-
-        (Type::AlwaysTruthy, _) => Ordering::Less,
-        (_, Type::AlwaysTruthy) => Ordering::Greater,
-
-        (Type::AlwaysFalsy, _) => Ordering::Less,
-        (_, Type::AlwaysFalsy) => Ordering::Greater,
-
-        (Type::KnownInstance(left_instance), Type::KnownInstance(right_instance)) => {
-            match (left_instance, right_instance) {
-                (KnownInstanceType::Any, _) => Ordering::Less,
-                (_, KnownInstanceType::Any) => Ordering::Greater,
-
-                (KnownInstanceType::Tuple, _) => Ordering::Less,
-                (_, KnownInstanceType::Tuple) => Ordering::Greater,
-
-                (KnownInstanceType::AlwaysFalsy, _) => Ordering::Less,
-                (_, KnownInstanceType::AlwaysFalsy) => Ordering::Greater,
-
-                (KnownInstanceType::AlwaysTruthy, _) => Ordering::Less,
-                (_, KnownInstanceType::AlwaysTruthy) => Ordering::Greater,
-
-                (KnownInstanceType::Annotated, _) => Ordering::Less,
-                (_, KnownInstanceType::Annotated) => Ordering::Greater,
-
-                (KnownInstanceType::Callable, _) => Ordering::Less,
-                (_, KnownInstanceType::Callable) => Ordering::Greater,
-
-                (KnownInstanceType::ChainMap, _) => Ordering::Less,
-                (_, KnownInstanceType::ChainMap) => Ordering::Greater,
-
-                (KnownInstanceType::ClassVar, _) => Ordering::Less,
-                (_, KnownInstanceType::ClassVar) => Ordering::Greater,
-
-                (KnownInstanceType::Concatenate, _) => Ordering::Less,
-                (_, KnownInstanceType::Concatenate) => Ordering::Greater,
-
-                (KnownInstanceType::Counter, _) => Ordering::Less,
-                (_, KnownInstanceType::Counter) => Ordering::Greater,
-
-                (KnownInstanceType::DefaultDict, _) => Ordering::Less,
-                (_, KnownInstanceType::DefaultDict) => Ordering::Greater,
-
-                (KnownInstanceType::Deque, _) => Ordering::Less,
-                (_, KnownInstanceType::Deque) => Ordering::Greater,
-
-                (KnownInstanceType::Dict, _) => Ordering::Less,
-                (_, KnownInstanceType::Dict) => Ordering::Greater,
-
-                (KnownInstanceType::Final, _) => Ordering::Less,
-                (_, KnownInstanceType::Final) => Ordering::Greater,
-
-                (KnownInstanceType::FrozenSet, _) => Ordering::Less,
-                (_, KnownInstanceType::FrozenSet) => Ordering::Greater,
-
-                (KnownInstanceType::TypeGuard, _) => Ordering::Less,
-                (_, KnownInstanceType::TypeGuard) => Ordering::Greater,
-
-                (KnownInstanceType::List, _) => Ordering::Less,
-                (_, KnownInstanceType::List) => Ordering::Greater,
-
-                (KnownInstanceType::Literal, _) => Ordering::Less,
-                (_, KnownInstanceType::Literal) => Ordering::Greater,
-
-                (KnownInstanceType::LiteralString, _) => Ordering::Less,
-                (_, KnownInstanceType::LiteralString) => Ordering::Greater,
-
-                (KnownInstanceType::Optional, _) => Ordering::Less,
-                (_, KnownInstanceType::Optional) => Ordering::Greater,
-
-                (KnownInstanceType::OrderedDict, _) => Ordering::Less,
-                (_, KnownInstanceType::OrderedDict) => Ordering::Greater,
-
-                (KnownInstanceType::NoReturn, _) => Ordering::Less,
-                (_, KnownInstanceType::NoReturn) => Ordering::Greater,
-
-                (KnownInstanceType::Never, _) => Ordering::Less,
-                (_, KnownInstanceType::Never) => Ordering::Greater,
-
-                (KnownInstanceType::Set, _) => Ordering::Less,
-                (_, KnownInstanceType::Set) => Ordering::Greater,
-
-                (KnownInstanceType::Type, _) => Ordering::Less,
-                (_, KnownInstanceType::Type) => Ordering::Greater,
-
-                (KnownInstanceType::TypeAlias, _) => Ordering::Less,
-                (_, KnownInstanceType::TypeAlias) => Ordering::Greater,
-
-                (KnownInstanceType::Unknown, _) => Ordering::Less,
-                (_, KnownInstanceType::Unknown) => Ordering::Greater,
-
-                (KnownInstanceType::Not, _) => Ordering::Less,
-                (_, KnownInstanceType::Not) => Ordering::Greater,
-
-                (KnownInstanceType::Intersection, _) => Ordering::Less,
-                (_, KnownInstanceType::Intersection) => Ordering::Greater,
-
-                (KnownInstanceType::TypeOf, _) => Ordering::Less,
-                (_, KnownInstanceType::TypeOf) => Ordering::Greater,
-
-                (KnownInstanceType::Unpack, _) => Ordering::Less,
-                (_, KnownInstanceType::Unpack) => Ordering::Greater,
-
-                (KnownInstanceType::TypingSelf, _) => Ordering::Less,
-                (_, KnownInstanceType::TypingSelf) => Ordering::Greater,
-
-                (KnownInstanceType::Required, _) => Ordering::Less,
-                (_, KnownInstanceType::Required) => Ordering::Greater,
-
-                (KnownInstanceType::NotRequired, _) => Ordering::Less,
-                (_, KnownInstanceType::NotRequired) => Ordering::Greater,
-
-                (KnownInstanceType::TypeIs, _) => Ordering::Less,
-                (_, KnownInstanceType::TypeIs) => Ordering::Greater,
-
-                (KnownInstanceType::ReadOnly, _) => Ordering::Less,
-                (_, KnownInstanceType::ReadOnly) => Ordering::Greater,
-
-                (KnownInstanceType::Union, _) => Ordering::Less,
-                (_, KnownInstanceType::Union) => Ordering::Greater,
-
-                (
-                    KnownInstanceType::TypeAliasType(left),
-                    KnownInstanceType::TypeAliasType(right),
-                ) => left.cmp(right),
-                (KnownInstanceType::TypeAliasType(_), _) => Ordering::Less,
-                (_, KnownInstanceType::TypeAliasType(_)) => Ordering::Greater,
-
-                (KnownInstanceType::TypeVar(left), KnownInstanceType::TypeVar(right)) => {
-                    left.cmp(right)
-                }
-            }
-        }
-
-        (Type::KnownInstance(_), _) => Ordering::Less,
-        (_, Type::KnownInstance(_)) => Ordering::Greater,
-
-        (Type::Dynamic(left), Type::Dynamic(right)) => dynamic_elements_ordering(*left, *right),
-        (Type::Dynamic(_), _) => Ordering::Less,
-        (_, Type::Dynamic(_)) => Ordering::Greater,
-
-        (Type::Union(left), Type::Union(right)) => left.cmp(right),
-        (Type::Union(_), _) => Ordering::Less,
-        (_, Type::Union(_)) => Ordering::Greater,
-
-        (Type::Intersection(left), Type::Intersection(right)) => left.cmp(right),
-    }
-}
-
-/// Determine a canonical order for two instances of [`DynamicType`].
-fn dynamic_elements_ordering(left: DynamicType, right: DynamicType) -> Ordering {
-    match (left, right) {
-        (DynamicType::Any, _) => Ordering::Less,
-        (_, DynamicType::Any) => Ordering::Greater,
-
-        (DynamicType::Unknown, _) => Ordering::Less,
-        (_, DynamicType::Unknown) => Ordering::Greater,
-
-        #[cfg(debug_assertions)]
-        (DynamicType::Todo(left), DynamicType::Todo(right)) => match (left, right) {
-            (
-                TodoType::FileAndLine(left_file, left_line),
-                TodoType::FileAndLine(right_file, right_line),
-            ) => left_file
-                .cmp(right_file)
-                .then_with(|| left_line.cmp(&right_line)),
-            (TodoType::FileAndLine(..), _) => Ordering::Less,
-            (_, TodoType::FileAndLine(..)) => Ordering::Greater,
-
-            (TodoType::Message(left), TodoType::Message(right)) => left.cmp(right),
-        },
-
-        #[cfg(not(debug_assertions))]
-        (DynamicType::Todo(TodoType), DynamicType::Todo(TodoType)) => Ordering::Equal,
-    }
-}

crates/red_knot_server/Cargo.toml

@@ -11,7 +11,7 @@ repository = { workspace = true }
 license = { workspace = true }
 
 [dependencies]
-red_knot_project = { workspace = true }
+red_knot_workspace = { workspace = true }
 ruff_db = { workspace = true }
 ruff_notebook = { workspace = true }
 ruff_python_ast = { workspace = true }

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

@@ -2,7 +2,7 @@ use lsp_server::ErrorCode;
 use lsp_types::notification::DidChangeTextDocument;
 use lsp_types::DidChangeTextDocumentParams;
 
-use red_knot_project::watch::ChangeEvent;
+use red_knot_workspace::watch::ChangeEvent;
 
 use crate::server::api::traits::{NotificationHandler, SyncNotificationHandler};
 use crate::server::api::LSPResult;

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

@@ -1,7 +1,7 @@
 use lsp_server::ErrorCode;
 use lsp_types::notification::DidCloseTextDocument;
 use lsp_types::DidCloseTextDocumentParams;
-use red_knot_project::watch::ChangeEvent;
+use red_knot_workspace::watch::ChangeEvent;
 
 use crate::server::api::diagnostics::clear_diagnostics;
 use crate::server::api::traits::{NotificationHandler, SyncNotificationHandler};

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

@@ -1,7 +1,7 @@
 use lsp_types::notification::DidCloseNotebookDocument;
 use lsp_types::DidCloseNotebookDocumentParams;
 
-use red_knot_project::watch::ChangeEvent;
+use red_knot_workspace::watch::ChangeEvent;
 
 use crate::server::api::traits::{NotificationHandler, SyncNotificationHandler};
 use crate::server::api::LSPResult;

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

@@ -1,7 +1,7 @@
 use lsp_types::notification::DidOpenTextDocument;
 use lsp_types::DidOpenTextDocumentParams;
 
-use red_knot_project::watch::ChangeEvent;
+use red_knot_workspace::watch::ChangeEvent;
 use ruff_db::Db;
 
 use crate::server::api::traits::{NotificationHandler, SyncNotificationHandler};

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

@@ -2,7 +2,7 @@ use lsp_server::ErrorCode;
 use lsp_types::notification::DidOpenNotebookDocument;
 use lsp_types::DidOpenNotebookDocumentParams;
 
-use red_knot_project::watch::ChangeEvent;
+use red_knot_workspace::watch::ChangeEvent;
 use ruff_db::Db;
 
 use crate::edit::NotebookDocument;

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

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

crates/red_knot_server/src/server/api/traits.rs

@@ -5,7 +5,7 @@ use crate::session::{DocumentSnapshot, Session};
 
 use lsp_types::notification::Notification as LSPNotification;
 use lsp_types::request::Request;
-use red_knot_project::ProjectDatabase;
+use red_knot_workspace::db::ProjectDatabase;
 
 /// A supertrait for any server request handler.
 pub(super) trait RequestHandler {

crates/red_knot_server/src/session.rs

@@ -8,7 +8,8 @@ use std::sync::Arc;
 use anyhow::anyhow;
 use lsp_types::{ClientCapabilities, TextDocumentContentChangeEvent, Url};
 
-use red_knot_project::{ProjectDatabase, ProjectMetadata};
+use red_knot_workspace::db::ProjectDatabase;
+use red_knot_workspace::project::ProjectMetadata;
 use ruff_db::files::{system_path_to_file, File};
 use ruff_db::system::SystemPath;
 use ruff_db::Db;
@@ -68,7 +69,7 @@ impl Session {
             let system = LSPSystem::new(index.clone());
 
             // TODO(dhruvmanila): Get the values from the client settings
-            let metadata = ProjectMetadata::discover(system_path, &system)?;
+            let metadata = ProjectMetadata::discover(system_path, &system, None)?;
             // TODO(micha): Handle the case where the program settings are incorrect more gracefully.
             workspaces.insert(path, ProjectDatabase::new(metadata, system)?);
         }

crates/red_knot_test/README.md

@@ -257,21 +257,6 @@ x: int = "foo"  # error: [invalid-assignment]
 ```
 ````
 
-## Running the tests
-
-All Markdown-based tests are executed in a normal `cargo test` / `cargo run nextest` run. If you want to run the Markdown tests
-*only*, you can filter the tests using `mdtest__`:
-
-```bash
-cargo test -p red_knot_python_semantic -- mdtest__
-```
-
-Alternatively, you can use the `mdtest.py` runner which has a watch mode that will re-run corresponding tests when Markdown files change, and recompile automatically when Rust code changes:
-
-```bash
-uv -q run crates/red_knot_python_semantic/mdtest.py
-```
-
 ## Planned features
 
 There are some designed features that we intend for the test framework to have, but have not yet

crates/red_knot_test/src/db.rs

@@ -11,7 +11,7 @@ use ruff_db::{Db as SourceDb, Upcast};
 #[salsa::db]
 #[derive(Clone)]
 pub(crate) struct Db {
-    project_root: SystemPathBuf,
+    workspace_root: SystemPathBuf,
     storage: salsa::Storage<Self>,
     files: Files,
     system: TestSystem,
@@ -20,11 +20,11 @@ pub(crate) struct Db {
 }
 
 impl Db {
-    pub(crate) fn setup(project_root: SystemPathBuf) -> Self {
+    pub(crate) fn setup(workspace_root: SystemPathBuf) -> Self {
         let rule_selection = RuleSelection::from_registry(default_lint_registry());
 
         let db = Self {
-            project_root,
+            workspace_root,
             storage: salsa::Storage::default(),
             system: TestSystem::default(),
             vendored: red_knot_vendored::file_system().clone(),
@@ -33,7 +33,7 @@ impl Db {
         };
 
         db.memory_file_system()
-            .create_directory_all(&db.project_root)
+            .create_directory_all(&db.workspace_root)
             .unwrap();
 
         Program::from_settings(
@@ -41,7 +41,7 @@ impl Db {
             ProgramSettings {
                 python_version: PythonVersion::default(),
                 python_platform: PythonPlatform::default(),
-                search_paths: SearchPathSettings::new(vec![db.project_root.clone()]),
+                search_paths: SearchPathSettings::new(db.workspace_root.clone()),
             },
         )
         .expect("Invalid search path settings");
@@ -49,8 +49,8 @@ impl Db {
         db
     }
 
-    pub(crate) fn project_root(&self) -> &SystemPath {
-        &self.project_root
+    pub(crate) fn workspace_root(&self) -> &SystemPath {
+        &self.workspace_root
     }
 }
 

crates/red_knot_test/src/lib.rs

@@ -97,7 +97,7 @@ pub fn run(path: &Utf8Path, long_title: &str, short_title: &str, test_name: &str
 }
 
 fn run_test(db: &mut db::Db, test: &parser::MarkdownTest) -> Result<(), Failures> {
-    let project_root = db.project_root().to_path_buf();
+    let workspace_root = db.workspace_root().to_path_buf();
 
     let test_files: Vec<_> = test
         .files()
@@ -110,7 +110,7 @@ fn run_test(db: &mut db::Db, test: &parser::MarkdownTest) -> Result<(), Failures
                 matches!(embedded.lang, "py" | "pyi"),
                 "Non-Python files not supported yet."
             );
-            let full_path = project_root.join(embedded.path);
+            let full_path = workspace_root.join(embedded.path);
             db.write_file(&full_path, embedded.code).unwrap();
             let file = system_path_to_file(db, full_path).unwrap();
 

crates/red_knot_vendored/knot_extensions/knot_extensions.pyi

@@ -1,4 +1,4 @@
-from typing import Any, LiteralString, _SpecialForm
+from typing import _SpecialForm, Any, LiteralString
 
 # Special operations
 def static_assert(condition: object, msg: LiteralString | None = None) -> None: ...
@@ -18,10 +18,9 @@ TypeOf: _SpecialForm
 # Ideally, these would be annotated using `TypeForm`, but that has not been
 # standardized yet (https://peps.python.org/pep-0747).
 def is_equivalent_to(type_a: Any, type_b: Any) -> bool: ...
-def is_subtype_of(type_derived: Any, type_base: Any) -> bool: ...
+def is_subtype_of(type_derived: Any, typ_ebase: Any) -> bool: ...
 def is_assignable_to(type_target: Any, type_source: Any) -> bool: ...
 def is_disjoint_from(type_a: Any, type_b: Any) -> bool: ...
-def is_gradual_equivalent_to(type_a: Any, type_b: Any) -> bool: ...
 def is_fully_static(type: Any) -> bool: ...
 def is_singleton(type: Any) -> bool: ...
 def is_single_valued(type: Any) -> bool: ...

crates/red_knot_wasm/Cargo.toml

@@ -20,7 +20,7 @@ default = ["console_error_panic_hook"]
 
 [dependencies]
 red_knot_python_semantic = { workspace = true }
-red_knot_project = { workspace = true, default-features = false, features = ["deflate"] }
+red_knot_workspace = { workspace = true, default-features = false, features = ["deflate"] }
 
 ruff_db = { workspace = true, features = [] }
 ruff_notebook = { workspace = true }

crates/red_knot_wasm/src/lib.rs

@@ -3,9 +3,9 @@ use std::any::Any;
 use js_sys::Error;
 use wasm_bindgen::prelude::*;
 
-use red_knot_project::metadata::options::{EnvironmentOptions, Options};
-use red_knot_project::ProjectMetadata;
-use red_knot_project::{Db, ProjectDatabase};
+use red_knot_workspace::db::{Db, ProjectDatabase};
+use red_knot_workspace::project::settings::Configuration;
+use red_knot_workspace::project::ProjectMetadata;
 use ruff_db::diagnostic::Diagnostic;
 use ruff_db::files::{system_path_to_file, File};
 use ruff_db::system::walk_directory::WalkDirectoryBuilder;
@@ -42,17 +42,15 @@ impl Workspace {
     #[wasm_bindgen(constructor)]
     pub fn new(root: &str, settings: &Settings) -> Result<Workspace, Error> {
         let system = WasmSystem::new(SystemPath::new(root));
-
-        let mut workspace =
-            ProjectMetadata::discover(SystemPath::new(root), &system).map_err(into_error)?;
-
-        workspace.apply_cli_options(Options {
-            environment: Some(EnvironmentOptions {
+        let workspace = ProjectMetadata::discover(
+            SystemPath::new(root),
+            &system,
+            Some(&Configuration {
                 python_version: Some(settings.python_version.into()),
-                ..EnvironmentOptions::default()
+                ..Configuration::default()
             }),
-            ..Options::default()
-        });
+        )
+        .map_err(into_error)?;
 
         let db = ProjectDatabase::new(workspace, system.clone()).map_err(into_error)?;
 

crates/red_knot_workspace/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "red_knot_project"
+name = "red_knot_workspace"
 version = "0.0.0"
 edition.workspace = true
 rust-version.workspace = true
@@ -12,12 +12,12 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+red_knot_python_semantic = { workspace = true }
+
 ruff_cache = { workspace = true }
 ruff_db = { workspace = true, features = ["os", "cache", "serde"] }
-ruff_macros = { workspace = true }
 ruff_python_ast = { workspace = true, features = ["serde"] }
 ruff_text_size = { workspace = true }
-red_knot_python_semantic = { workspace = true, features = ["serde"] }
 red_knot_vendored = { workspace = true }
 
 anyhow = { workspace = true }
@@ -34,6 +34,7 @@ toml = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
+red_knot_python_semantic = { workspace = true, features = ["serde"] }
 ruff_db = { workspace = true, features = ["testing"] }
 glob = { workspace = true }
 insta = { workspace = true, features = ["redactions", "ron"] }