Separate TOC from the navigation

2024-09-05 16:08:53 +05:30
225 changed files with 2231 additions and 13036 deletions
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -45,7 +45,7 @@ repos:
          )$

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

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

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

-## 0.6.6
-
-### Preview features
-
- \[`refurb`\] Skip `slice-to-remove-prefix-or-suffix` (`FURB188`) when non-trivial slice steps are present ([#13405](https://github.com/astral-sh/ruff/pull/13405))
- Add a subcommand to generate dependency graphs ([#13402](https://github.com/astral-sh/ruff/pull/13402))
-
-### Formatter
-
- Fix placement of inline parameter comments ([#13379](https://github.com/astral-sh/ruff/pull/13379))
-
-### Server
-
- Fix off-by one error in the `LineIndex::offset` calculation ([#13407](https://github.com/astral-sh/ruff/pull/13407))
-
-### Bug fixes
-
- \[`fastapi`\] Respect FastAPI aliases in route definitions ([#13394](https://github.com/astral-sh/ruff/pull/13394))
- \[`pydocstyle`\] Respect word boundaries when detecting function signature in docs ([#13388](https://github.com/astral-sh/ruff/pull/13388))
-
-### Documentation
-
- Add backlinks to rule overview linter ([#13368](https://github.com/astral-sh/ruff/pull/13368))
- Fix documentation for editor vim plugin ALE ([#13348](https://github.com/astral-sh/ruff/pull/13348))
- Fix rendering of `FURB188` docs ([#13406](https://github.com/astral-sh/ruff/pull/13406))
-
-## 0.6.5
-
-### Preview features
-
- \[`pydoclint`\] Ignore `DOC201` when function name is "**new**" ([#13300](https://github.com/astral-sh/ruff/pull/13300))
- \[`refurb`\] Implement `slice-to-remove-prefix-or-suffix` (`FURB188`) ([#13256](https://github.com/astral-sh/ruff/pull/13256))
-
-### Rule changes
-
- \[`eradicate`\] Ignore script-comments with multiple end-tags (`ERA001`) ([#13283](https://github.com/astral-sh/ruff/pull/13283))
- \[`pyflakes`\] Improve error message for `UndefinedName` when a builtin was added in a newer version than specified in Ruff config (`F821`) ([#13293](https://github.com/astral-sh/ruff/pull/13293))
-
-### Server
-
- Add support for extensionless Python files for server ([#13326](https://github.com/astral-sh/ruff/pull/13326))
- Fix configuration inheritance for configurations specified in the LSP settings ([#13285](https://github.com/astral-sh/ruff/pull/13285))
-
-### Bug fixes
-
- \[`ruff`\] Handle unary operators in `decimal-from-float-literal` (`RUF032`) ([#13275](https://github.com/astral-sh/ruff/pull/13275))
-
-### CLI
-
- Only include rules with diagnostics in SARIF metadata ([#13268](https://github.com/astral-sh/ruff/pull/13268))
-
-### Playground
-
- Add "Copy as pyproject.toml/ruff.toml" and "Paste from TOML" ([#13328](https://github.com/astral-sh/ruff/pull/13328))
- Fix errors not shown for restored snippet on page load ([#13262](https://github.com/astral-sh/ruff/pull/13262))
-
-## 0.6.4
-
-### Preview features
-
- \[`flake8-builtins`\] Use dynamic builtins list based on Python version ([#13172](https://github.com/astral-sh/ruff/pull/13172))
- \[`pydoclint`\] Permit yielding `None` in `DOC402` and `DOC403` ([#13148](https://github.com/astral-sh/ruff/pull/13148))
- \[`pylint`\] Update diagnostic message for `PLW3201` ([#13194](https://github.com/astral-sh/ruff/pull/13194))
- \[`ruff`\] Implement `post-init-default` (`RUF033`) ([#13192](https://github.com/astral-sh/ruff/pull/13192))
- \[`ruff`\] Implement useless if-else (`RUF034`) ([#13218](https://github.com/astral-sh/ruff/pull/13218))
-
-### Rule changes
-
- \[`flake8-pyi`\] Respect `pep8_naming.classmethod-decorators` settings when determining if a method is a classmethod in `custom-type-var-return-type` (`PYI019`) ([#13162](https://github.com/astral-sh/ruff/pull/13162))
- \[`flake8-pyi`\] Teach various rules that annotations might be stringized ([#12951](https://github.com/astral-sh/ruff/pull/12951))
- \[`pylint`\] Avoid `no-self-use` for `attrs`-style validators ([#13166](https://github.com/astral-sh/ruff/pull/13166))
- \[`pylint`\] Recurse into subscript subexpressions when searching for list/dict lookups (`PLR1733`, `PLR1736`) ([#13186](https://github.com/astral-sh/ruff/pull/13186))
- \[`pyupgrade`\] Detect `aiofiles.open` calls in `UP015` ([#13173](https://github.com/astral-sh/ruff/pull/13173))
- \[`pyupgrade`\] Mark `sys.version_info[0] < 3` and similar comparisons as outdated (`UP036`) ([#13175](https://github.com/astral-sh/ruff/pull/13175))
-
-### CLI
-
- Enrich messages of SARIF results ([#13180](https://github.com/astral-sh/ruff/pull/13180))
- Handle singular case for incompatible rules warning in `ruff format` output ([#13212](https://github.com/astral-sh/ruff/pull/13212))
-
-### Bug fixes
-
- \[`pydocstyle`\] Improve heuristics for detecting Google-style docstrings ([#13142](https://github.com/astral-sh/ruff/pull/13142))
- \[`refurb`\] Treat `sep` arguments with effects as unsafe removals (`FURB105`) ([#13165](https://github.com/astral-sh/ruff/pull/13165))
-
 ## 0.6.3

 ### Preview features
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -161,21 +161,6 @@ version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"

-[[package]]
-name = "assert_fs"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7efdb1fdb47602827a342857666feb372712cbc64b414172bd6b167a02927674"
-dependencies = [
- "anstyle",
- "doc-comment",
- "globwalk",
- "predicates",
- "predicates-core",
- "predicates-tree",
- "tempfile",
-]
-
 [[package]]
 name = "autocfg"
 version = "1.2.0"
@@ -209,15 +194,6 @@ version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"

-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
 [[package]]
 name = "bstr"
 version = "1.10.0"
@@ -255,9 +231,6 @@ name = "camino"
 version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
-dependencies = [
- "serde",
-]

 [[package]]
 name = "cast"
@@ -538,15 +511,6 @@ dependencies = [
 "rustc-hash 1.1.0",
 ]

-[[package]]
-name = "cpufeatures"
-version = "0.2.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51e852e6dc9a5bed1fae92dd2375037bf2b768725bf3be87811edee3249d09ad"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "crc32fast"
 version = "1.4.0"
@@ -652,16 +616,6 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"

-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
 [[package]]
 name = "ctrlc"
 version = "3.4.5"
@@ -740,22 +694,6 @@ version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"

-[[package]]
-name = "difflib"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "crypto-common",
-]
-
 [[package]]
 name = "dirs"
 version = "4.0.0"
@@ -797,12 +735,6 @@ dependencies = [
 "windows-sys 0.48.0",
 ]

-[[package]]
-name = "doc-comment"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
-
 [[package]]
 name = "drop_bomb"
 version = "0.1.5"
@@ -947,16 +879,6 @@ dependencies = [
 "libc",
 ]

-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
-]
-
 [[package]]
 name = "getopts"
 version = "0.2.21"
@@ -998,17 +920,6 @@ dependencies = [
 "regex-syntax 0.8.3",
 ]

-[[package]]
-name = "globwalk"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bf760ebf69878d9fd8f110c89703d90ce35095324d1f1edcb595c63945ee757"
-dependencies = [
- "bitflags 2.6.0",
- "ignore",
- "walkdir",
-]
-
 [[package]]
 name = "half"
 version = "2.4.1"
@@ -1201,8 +1112,6 @@ dependencies = [
 "globset",
 "lazy_static",
 "linked-hash-map",
- "pest",
- "pest_derive",
 "regex",
 "serde",
 "similar",
@@ -1798,51 +1707,6 @@ version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"

-[[package]]
-name = "pest"
-version = "2.7.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd53dff83f26735fdc1ca837098ccf133605d794cdae66acfc2bfac3ec809d95"
-dependencies = [
- "memchr",
- "thiserror",
- "ucd-trie",
-]
-
-[[package]]
-name = "pest_derive"
-version = "2.7.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a548d2beca6773b1c244554d36fcf8548a8a58e74156968211567250e48e49a"
-dependencies = [
- "pest",
- "pest_generator",
-]
-
-[[package]]
-name = "pest_generator"
-version = "2.7.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c93a82e8d145725dcbaf44e5ea887c8a869efdcc28706df2d08c69e17077183"
-dependencies = [
- "pest",
- "pest_meta",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "pest_meta"
-version = "2.7.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a941429fea7e08bedec25e4f6785b6ffaacc6b755da98df5ef3e7dcf4a124c4f"
-dependencies = [
- "once_cell",
- "pest",
- "sha2",
-]
-
 [[package]]
 name = "phf"
 version = "0.11.2"
@@ -1905,33 +1769,6 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"

-[[package]]
-name = "predicates"
-version = "3.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e9086cc7640c29a356d1a29fd134380bee9d8f79a17410aa76e7ad295f42c97"
-dependencies = [
- "anstyle",
- "difflib",
- "predicates-core",
-]
-
-[[package]]
-name = "predicates-core"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae8177bee8e75d6846599c6b9ff679ed51e882816914eec639944d7c9aa11931"
-
-[[package]]
-name = "predicates-tree"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41b740d195ed3166cd147c8047ec98db0e22ec019eb8eeb76d343b795304fb13"
-dependencies = [
- "predicates-core",
- "termtree",
-]
-
 [[package]]
 name = "pretty_assertions"
 version = "1.4.0"
@@ -2099,7 +1936,6 @@ dependencies = [
 "smallvec",
 "static_assertions",
 "tempfile",
- "test-case",
 "thiserror",
 "tracing",
 "walkdir",
@@ -2255,11 +2091,10 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.6.6"
+version = "0.6.3"
 dependencies = [
 "anyhow",
 "argfile",
- "assert_fs",
 "bincode",
 "bitflags 2.6.0",
 "cachedir",
@@ -2269,9 +2104,7 @@ dependencies = [
 "clearscreen",
 "colored",
 "filetime",
- "globwalk",
 "ignore",
- "indoc",
 "insta",
 "insta-cmd",
 "is-macro",
@@ -2283,9 +2116,7 @@ dependencies = [
 "rayon",
 "regex",
 "ruff_cache",
- "ruff_db",
 "ruff_diagnostics",
- "ruff_graph",
 "ruff_linter",
 "ruff_macros",
 "ruff_notebook",
@@ -2368,7 +2199,6 @@ dependencies = [
 "ruff_text_size",
 "rustc-hash 2.0.0",
 "salsa",
- "serde",
 "tempfile",
 "thiserror",
 "tracing",
@@ -2444,23 +2274,6 @@ dependencies = [
 "unicode-width",
 ]

-[[package]]
-name = "ruff_graph"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "clap",
- "red_knot_python_semantic",
- "ruff_cache",
- "ruff_db",
- "ruff_linter",
- "ruff_macros",
- "ruff_python_ast",
- "salsa",
- "schemars",
- "serde",
-]
-
 [[package]]
 name = "ruff_index"
 version = "0.0.0"
@@ -2471,7 +2284,7 @@ dependencies = [

 [[package]]
 name = "ruff_linter"
-version = "0.6.6"
+version = "0.6.3"
 dependencies = [
 "aho-corasick",
 "annotate-snippets 0.9.2",
@@ -2791,7 +2604,7 @@ dependencies = [

 [[package]]
 name = "ruff_wasm"
-version = "0.6.6"
+version = "0.6.3"
 dependencies = [
 "console_error_panic_hook",
 "console_log",
@@ -2834,7 +2647,6 @@ dependencies = [
 "regex",
 "ruff_cache",
 "ruff_formatter",
- "ruff_graph",
 "ruff_linter",
 "ruff_macros",
 "ruff_python_ast",
@@ -3123,17 +2935,6 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -3289,12 +3090,6 @@ dependencies = [
 "phf_codegen",
 ]

-[[package]]
-name = "termtree"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
-
 [[package]]
 name = "test-case"
 version = "3.3.1"
@@ -3540,18 +3335,6 @@ version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a"

-[[package]]
-name = "typenum"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
-
-[[package]]
-name = "ucd-trie"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
-
 [[package]]
 name = "unic-char-property"
 version = "0.9.0"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,7 +17,6 @@ ruff_cache = { path = "crates/ruff_cache" }
 ruff_db = { path = "crates/ruff_db" }
 ruff_diagnostics = { path = "crates/ruff_diagnostics" }
 ruff_formatter = { path = "crates/ruff_formatter" }
-ruff_graph = { path = "crates/ruff_graph" }
 ruff_index = { path = "crates/ruff_index" }
 ruff_linter = { path = "crates/ruff_linter" }
 ruff_macros = { path = "crates/ruff_macros" }
@@ -43,7 +42,6 @@ red_knot_workspace = { path = "crates/red_knot_workspace" }
 aho-corasick = { version = "1.1.3" }
 annotate-snippets = { version = "0.9.2", features = ["color"] }
 anyhow = { version = "1.0.80" }
-assert_fs = { version = "1.1.0" }
 argfile = { version = "0.2.0" }
 bincode = { version = "1.3.3" }
 bitflags = { version = "2.5.0" }
@@ -70,7 +68,6 @@ fern = { version = "0.6.1" }
 filetime = { version = "0.2.23" }
 glob = { version = "0.3.1" }
 globset = { version = "0.4.14" }
-globwalk = { version = "0.9.1" }
 hashbrown = "0.14.3"
 ignore = { version = "0.4.22" }
 imara-diff = { version = "0.1.5" }
--- a/README.md
+++ b/README.md
@@ -136,8 +136,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"

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

 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -170,7 +170,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
  # Ruff version.
-  rev: v0.6.6
+  rev: v0.6.3
  hooks:
    # Run the linter.
    - id: ruff
--- a/crates/red_knot_python_semantic/Cargo.toml
+++ b/crates/red_knot_python_semantic/Cargo.toml
@@ -33,7 +33,6 @@ rustc-hash = { workspace = true }
 hashbrown = { workspace = true }
 smallvec = { workspace = true }
 static_assertions = { workspace = true }
-test-case = { workspace = true }

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

 pub use db::Db;
 pub use module_name::ModuleName;
-pub use module_resolver::{
-    resolve_module, system_module_search_paths, vendored_typeshed_stubs, Module,
-};
+pub use module_resolver::{resolve_module, system_module_search_paths, vendored_typeshed_stubs};
 pub use program::{Program, ProgramSettings, SearchPathSettings, SitePackages};
 pub use python_version::PythonVersion;
 pub use semantic_model::{HasTy, SemanticModel};

 pub mod ast_node_ref;
+mod builtins;
 mod db;
 mod module_name;
 mod module_resolver;
@@ -21,7 +20,7 @@ mod python_version;
 pub mod semantic_index;
 mod semantic_model;
 pub(crate) mod site_packages;
-mod stdlib;
 pub mod types;

 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;
+type FxOrderMap<K, V> = ordermap::map::OrderMap<K, V, BuildHasherDefault<FxHasher>>;
--- a/crates/red_knot_python_semantic/src/module_resolver/mod.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/mod.rs
@@ -1,6 +1,6 @@
 use std::iter::FusedIterator;

-pub use module::Module;
+pub(crate) use module::Module;
 pub use resolver::resolve_module;
 pub(crate) use resolver::{file_to_module, SearchPaths};
 use ruff_db::system::SystemPath;
--- a/crates/red_knot_python_semantic/src/module_resolver/path.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/path.rs
@@ -59,10 +59,6 @@ impl ModulePath {
        self.relative_path.push(component);
    }

-    pub(crate) fn pop(&mut self) -> bool {
-        self.relative_path.pop()
-    }
-
    #[must_use]
    pub(super) fn is_directory(&self, resolver: &ResolverContext) -> bool {
        let ModulePath {
--- a/crates/red_knot_python_semantic/src/module_resolver/resolver.rs
+++ b/crates/red_knot_python_semantic/src/module_resolver/resolver.rs
@@ -569,16 +569,24 @@ fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(SearchPath, File, Mod

                package_path.push(module_name);

-                // Check for a regular package first (highest priority)
-                package_path.push("__init__");
-                if let Some(regular_package) = resolve_file_module(&package_path, &resolver_state) {
-                    return Some((search_path.clone(), regular_package, ModuleKind::Package));
+                // Must be a `__init__.pyi` or `__init__.py` or it isn't a package.
+                let kind = if package_path.is_directory(&resolver_state) {
+                    package_path.push("__init__");
+                    ModuleKind::Package
+                } else {
+                    ModuleKind::Module
+                };
+
+                // TODO Implement full https://peps.python.org/pep-0561/#type-checker-module-resolution-order resolution
+                if let Some(stub) = package_path.with_pyi_extension().to_file(&resolver_state) {
+                    return Some((search_path.clone(), stub, kind));
                }

-                // Check for a file module next
-                package_path.pop();
-                if let Some(file_module) = resolve_file_module(&package_path, &resolver_state) {
-                    return Some((search_path.clone(), file_module, ModuleKind::Module));
+                if let Some(module) = package_path
+                    .with_py_extension()
+                    .and_then(|path| path.to_file(&resolver_state))
+                {
+                    return Some((search_path.clone(), module, kind));
                }

                // For regular packages, don't search the next search path. All files of that
@@ -599,23 +607,6 @@ fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(SearchPath, File, Mod
    None
 }

-/// If `module` exists on disk with either a `.pyi` or `.py` extension,
-/// return the [`File`] corresponding to that path.
-///
-/// `.pyi` files take priority, as they always have priority when
-/// resolving modules.
-fn resolve_file_module(module: &ModulePath, resolver_state: &ResolverContext) -> Option<File> {
-    // Stubs have precedence over source files
-    module
-        .with_pyi_extension()
-        .to_file(resolver_state)
-        .or_else(|| {
-            module
-                .with_py_extension()
-                .and_then(|path| path.to_file(resolver_state))
-        })
-}
-
 fn resolve_package<'a, 'db, I>(
    module_search_path: &SearchPath,
    components: I,
@@ -642,10 +633,7 @@ where

        if is_regular_package {
            in_namespace_package = false;
-        } else if package_path.is_directory(resolver_state)
-            // Pure modules hide namespace packages with the same name
-            && resolve_file_module(&package_path, resolver_state).is_none()
-        {
+        } else if package_path.is_directory(resolver_state) {
            // A directory without an `__init__.py` is a namespace package, continue with the next folder.
            in_namespace_package = true;
        } else if in_namespace_package {
@@ -1103,25 +1091,6 @@ mod tests {
        );
    }

-    #[test]
-    fn single_file_takes_priority_over_namespace_package() {
-        //const SRC: &[FileSpec] = &[("foo.py", "x = 1")];
-        const SRC: &[FileSpec] = &[("foo.py", "x = 1"), ("foo/bar.py", "x = 2")];
-
-        let TestCase { db, src, .. } = TestCaseBuilder::new().with_src_files(SRC).build();
-
-        let foo_module_name = ModuleName::new_static("foo").unwrap();
-        let foo_bar_module_name = ModuleName::new_static("foo.bar").unwrap();
-
-        // `foo.py` takes priority over the `foo` namespace package
-        let foo_module = resolve_module(&db, foo_module_name.clone()).unwrap();
-        assert_eq!(foo_module.file().path(&db), &src.join("foo.py"));
-
-        // `foo.bar` isn't recognised as a module
-        let foo_bar_module = resolve_module(&db, foo_bar_module_name.clone());
-        assert_eq!(foo_bar_module, None);
-    }
-
    #[test]
    fn typing_stub_over_module() {
        const SRC: &[FileSpec] = &[("foo.py", "print('Hello, world!')"), ("foo.pyi", "x: int")];
--- a/crates/red_knot_python_semantic/src/semantic_index.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index.rs
@@ -21,15 +21,12 @@ use crate::Db;

 pub mod ast_ids;
 mod builder;
-pub(crate) mod constraint;
 pub mod definition;
 pub mod expression;
 pub mod symbol;
 mod use_def;

-pub(crate) use self::use_def::{
-    BindingWithConstraints, BindingWithConstraintsIterator, DeclarationsIterator,
-};
+pub(crate) use self::use_def::{DefinitionWithConstraints, DefinitionWithConstraintsIterator};

 type SymbolMap = hashbrown::HashMap<ScopedSymbolId, (), ()>;

@@ -115,9 +112,6 @@ pub(crate) struct SemanticIndex<'db> {
    /// Note: We should not depend on this map when analysing other files or
    /// changing a file invalidates all dependents.
    ast_ids: IndexVec<FileScopeId, AstIds>,
-
-    /// Flags about the global scope (code usage impacting inference)
-    has_future_annotations: bool,
 }

 impl<'db> SemanticIndex<'db> {
@@ -218,12 +212,6 @@ impl<'db> SemanticIndex<'db> {
    pub(crate) fn node_scope(&self, node: NodeWithScopeRef) -> FileScopeId {
        self.scopes_by_node[&node.node_key()]
    }
-
-    /// Checks if there is an import of `__future__.annotations` in the global scope, which affects
-    /// the logic for type inference.
-    pub(super) fn has_future_annotations(&self) -> bool {
-        self.has_future_annotations
-    }
 }

 pub struct AncestorsIter<'a> {
@@ -337,16 +325,16 @@ mod tests {
    use crate::Db;

    impl UseDefMap<'_> {
-        fn first_public_binding(&self, symbol: ScopedSymbolId) -> Option<Definition<'_>> {
-            self.public_bindings(symbol)
+        fn first_public_definition(&self, symbol: ScopedSymbolId) -> Option<Definition<'_>> {
+            self.public_definitions(symbol)
                .next()
-                .map(|constrained_binding| constrained_binding.binding)
+                .map(|constrained_definition| constrained_definition.definition)
        }

-        fn first_binding_at_use(&self, use_id: ScopedUseId) -> Option<Definition<'_>> {
-            self.bindings_at_use(use_id)
+        fn first_use_definition(&self, use_id: ScopedUseId) -> Option<Definition<'_>> {
+            self.use_definitions(use_id)
                .next()
-                .map(|constrained_binding| constrained_binding.binding)
+                .map(|constrained_definition| constrained_definition.definition)
        }
    }

@@ -408,8 +396,8 @@ mod tests {
        let foo = global_table.symbol_id_by_name("foo").unwrap();

        let use_def = use_def_map(&db, scope);
-        let binding = use_def.first_public_binding(foo).unwrap();
-        assert!(matches!(binding.kind(&db), DefinitionKind::Import(_)));
+        let definition = use_def.first_public_definition(foo).unwrap();
+        assert!(matches!(definition.node(&db), DefinitionKind::Import(_)));
    }

    #[test]
@@ -438,19 +426,22 @@ mod tests {
        assert!(
            global_table
                .symbol_by_name("foo")
-                .is_some_and(|symbol| { symbol.is_bound() && !symbol.is_used() }),
+                .is_some_and(|symbol| { symbol.is_defined() && !symbol.is_used() }),
            "symbols that are defined get the defined flag"
        );

        let use_def = use_def_map(&db, scope);
-        let binding = use_def
-            .first_public_binding(
+        let definition = use_def
+            .first_public_definition(
                global_table
                    .symbol_id_by_name("foo")
                    .expect("symbol to exist"),
            )
            .unwrap();
-        assert!(matches!(binding.kind(&db), DefinitionKind::ImportFrom(_)));
+        assert!(matches!(
+            definition.node(&db),
+            DefinitionKind::ImportFrom(_)
+        ));
    }

    #[test]
@@ -463,14 +454,17 @@ mod tests {
        assert!(
            global_table
                .symbol_by_name("foo")
-                .is_some_and(|symbol| { !symbol.is_bound() && symbol.is_used() }),
-            "a symbol used but not bound in a scope should have only the used flag"
+                .is_some_and(|symbol| { !symbol.is_defined() && symbol.is_used() }),
+            "a symbol used but not defined in a scope should have only the used flag"
        );
        let use_def = use_def_map(&db, scope);
-        let binding = use_def
-            .first_public_binding(global_table.symbol_id_by_name("x").expect("symbol exists"))
+        let definition = use_def
+            .first_public_definition(global_table.symbol_id_by_name("x").expect("symbol exists"))
            .unwrap();
-        assert!(matches!(binding.kind(&db), DefinitionKind::Assignment(_)));
+        assert!(matches!(
+            definition.node(&db),
+            DefinitionKind::Assignment(_)
+        ));
    }

    #[test]
@@ -482,12 +476,12 @@ mod tests {
        assert_eq!(names(&global_table), vec!["x"]);

        let use_def = use_def_map(&db, scope);
-        let binding = use_def
-            .first_public_binding(global_table.symbol_id_by_name("x").unwrap())
+        let definition = use_def
+            .first_public_definition(global_table.symbol_id_by_name("x").unwrap())
            .unwrap();

        assert!(matches!(
-            binding.kind(&db),
+            definition.node(&db),
            DefinitionKind::AugmentedAssignment(_)
        ));
    }
@@ -520,10 +514,13 @@ y = 2
        assert_eq!(names(&class_table), vec!["x"]);

        let use_def = index.use_def_map(class_scope_id);
-        let binding = use_def
-            .first_public_binding(class_table.symbol_id_by_name("x").expect("symbol exists"))
+        let definition = use_def
+            .first_public_definition(class_table.symbol_id_by_name("x").expect("symbol exists"))
            .unwrap();
-        assert!(matches!(binding.kind(&db), DefinitionKind::Assignment(_)));
+        assert!(matches!(
+            definition.node(&db),
+            DefinitionKind::Assignment(_)
+        ));
    }

    #[test]
@@ -553,14 +550,17 @@ y = 2
        assert_eq!(names(&function_table), vec!["x"]);

        let use_def = index.use_def_map(function_scope_id);
-        let binding = use_def
-            .first_public_binding(
+        let definition = use_def
+            .first_public_definition(
                function_table
                    .symbol_id_by_name("x")
                    .expect("symbol exists"),
            )
            .unwrap();
-        assert!(matches!(binding.kind(&db), DefinitionKind::Assignment(_)));
+        assert!(matches!(
+            definition.node(&db),
+            DefinitionKind::Assignment(_)
+        ));
    }

    #[test]
@@ -592,27 +592,27 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):

        let use_def = index.use_def_map(function_scope_id);
        for name in ["a", "b", "c", "d"] {
-            let binding = use_def
-                .first_public_binding(
+            let definition = use_def
+                .first_public_definition(
                    function_table
                        .symbol_id_by_name(name)
                        .expect("symbol exists"),
                )
                .unwrap();
            assert!(matches!(
-                binding.kind(&db),
+                definition.node(&db),
                DefinitionKind::ParameterWithDefault(_)
            ));
        }
        for name in ["args", "kwargs"] {
-            let binding = use_def
-                .first_public_binding(
+            let definition = use_def
+                .first_public_definition(
                    function_table
                        .symbol_id_by_name(name)
                        .expect("symbol exists"),
                )
                .unwrap();
-            assert!(matches!(binding.kind(&db), DefinitionKind::Parameter(_)));
+            assert!(matches!(definition.node(&db), DefinitionKind::Parameter(_)));
        }
    }

@@ -640,19 +640,23 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):

        let use_def = index.use_def_map(lambda_scope_id);
        for name in ["a", "b", "c", "d"] {
-            let binding = use_def
-                .first_public_binding(lambda_table.symbol_id_by_name(name).expect("symbol exists"))
+            let definition = use_def
+                .first_public_definition(
+                    lambda_table.symbol_id_by_name(name).expect("symbol exists"),
+                )
                .unwrap();
            assert!(matches!(
-                binding.kind(&db),
+                definition.node(&db),
                DefinitionKind::ParameterWithDefault(_)
            ));
        }
        for name in ["args", "kwargs"] {
-            let binding = use_def
-                .first_public_binding(lambda_table.symbol_id_by_name(name).expect("symbol exists"))
+            let definition = use_def
+                .first_public_definition(
+                    lambda_table.symbol_id_by_name(name).expect("symbol exists"),
+                )
                .unwrap();
-            assert!(matches!(binding.kind(&db), DefinitionKind::Parameter(_)));
+            assert!(matches!(definition.node(&db), DefinitionKind::Parameter(_)));
        }
    }

@@ -690,15 +694,15 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):

        let use_def = index.use_def_map(comprehension_scope_id);
        for name in ["x", "y"] {
-            let binding = use_def
-                .first_public_binding(
+            let definition = use_def
+                .first_public_definition(
                    comprehension_symbol_table
                        .symbol_id_by_name(name)
                        .expect("symbol exists"),
                )
                .unwrap();
            assert!(matches!(
-                binding.kind(&db),
+                definition.node(&db),
                DefinitionKind::Comprehension(_)
            ));
        }
@@ -737,8 +741,8 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
        let element_use_id =
            element.scoped_use_id(&db, comprehension_scope_id.to_scope_id(&db, file));

-        let binding = use_def.first_binding_at_use(element_use_id).unwrap();
-        let DefinitionKind::Comprehension(comprehension) = binding.kind(&db) else {
+        let definition = use_def.first_use_definition(element_use_id).unwrap();
+        let DefinitionKind::Comprehension(comprehension) = definition.node(&db) else {
            panic!("expected generator definition")
        };
        let target = comprehension.target();
@@ -817,10 +821,12 @@ with item1 as x, item2 as y:

        let use_def = index.use_def_map(FileScopeId::global());
        for name in ["x", "y"] {
-            let binding = use_def
-                .first_public_binding(global_table.symbol_id_by_name(name).expect("symbol exists"))
-                .expect("Expected with item definition for {name}");
-            assert!(matches!(binding.kind(&db), DefinitionKind::WithItem(_)));
+            let Some(definition) = use_def.first_public_definition(
+                global_table.symbol_id_by_name(name).expect("symbol exists"),
+            ) else {
+                panic!("Expected with item definition for {name}");
+            };
+            assert!(matches!(definition.node(&db), DefinitionKind::WithItem(_)));
        }
    }

@@ -840,10 +846,12 @@ with context() as (x, y):

        let use_def = index.use_def_map(FileScopeId::global());
        for name in ["x", "y"] {
-            let binding = use_def
-                .first_public_binding(global_table.symbol_id_by_name(name).expect("symbol exists"))
-                .expect("Expected with item definition for {name}");
-            assert!(matches!(binding.kind(&db), DefinitionKind::WithItem(_)));
+            let Some(definition) = use_def.first_public_definition(
+                global_table.symbol_id_by_name(name).expect("symbol exists"),
+            ) else {
+                panic!("Expected with item definition for {name}");
+            };
+            assert!(matches!(definition.node(&db), DefinitionKind::WithItem(_)));
        }
    }

@@ -880,14 +888,14 @@ def func():
        assert_eq!(names(&func2_table), vec!["y"]);

        let use_def = index.use_def_map(FileScopeId::global());
-        let binding = use_def
-            .first_public_binding(
+        let definition = use_def
+            .first_public_definition(
                global_table
                    .symbol_id_by_name("func")
                    .expect("symbol exists"),
            )
            .unwrap();
-        assert!(matches!(binding.kind(&db), DefinitionKind::Function(_)));
+        assert!(matches!(definition.node(&db), DefinitionKind::Function(_)));
    }

    #[test]
@@ -955,7 +963,7 @@ class C[T]:
        assert!(
            ann_table
                .symbol_by_name("T")
-                .is_some_and(|s| s.is_bound() && !s.is_used()),
+                .is_some_and(|s| s.is_defined() && !s.is_used()),
            "type parameters are defined by the scope that introduces them"
        );

@@ -987,8 +995,8 @@ class C[T]:
        };
        let x_use_id = x_use_expr_name.scoped_use_id(&db, scope);
        let use_def = use_def_map(&db, scope);
-        let binding = use_def.first_binding_at_use(x_use_id).unwrap();
-        let DefinitionKind::Assignment(assignment) = binding.kind(&db) else {
+        let definition = use_def.first_use_definition(x_use_id).unwrap();
+        let DefinitionKind::Assignment(assignment) = definition.node(&db) else {
            panic!("should be an assignment definition")
        };
        let ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
@@ -1036,7 +1044,7 @@ class C[T]:
        }

        let TestCase { db, file } = test_case(
-            r"
+            r#"
 class Test:
    def foo():
        def bar():
@@ -1045,7 +1053,7 @@ class Test:
        pass

 def x():
-    pass",
+    pass"#,
        );

        let index = semantic_index(&db, file);
@@ -1118,10 +1126,12 @@ match subject:
            ("k", 0),
            ("l", 1),
        ] {
-            let binding = use_def
-                .first_public_binding(global_table.symbol_id_by_name(name).expect("symbol exists"))
+            let definition = use_def
+                .first_public_definition(
+                    global_table.symbol_id_by_name(name).expect("symbol exists"),
+                )
                .expect("Expected with item definition for {name}");
-            if let DefinitionKind::MatchPattern(pattern) = binding.kind(&db) {
+            if let DefinitionKind::MatchPattern(pattern) = definition.node(&db) {
                assert_eq!(pattern.index(), expected_index);
            } else {
                panic!("Expected match pattern definition for {name}");
@@ -1148,10 +1158,12 @@ match 1:

        let use_def = use_def_map(&db, global_scope_id);
        for (name, expected_index) in [("first", 0), ("second", 0)] {
-            let binding = use_def
-                .first_public_binding(global_table.symbol_id_by_name(name).expect("symbol exists"))
+            let definition = use_def
+                .first_public_definition(
+                    global_table.symbol_id_by_name(name).expect("symbol exists"),
+                )
                .expect("Expected with item definition for {name}");
-            if let DefinitionKind::MatchPattern(pattern) = binding.kind(&db) {
+            if let DefinitionKind::MatchPattern(pattern) = definition.node(&db) {
                assert_eq!(pattern.index(), expected_index);
            } else {
                panic!("Expected match pattern definition for {name}");
@@ -1168,11 +1180,11 @@ match 1:
        assert_eq!(&names(&global_table), &["a", "x"]);

        let use_def = use_def_map(&db, scope);
-        let binding = use_def
-            .first_public_binding(global_table.symbol_id_by_name("x").unwrap())
+        let definition = use_def
+            .first_public_definition(global_table.symbol_id_by_name("x").unwrap())
            .unwrap();

-        assert!(matches!(binding.kind(&db), DefinitionKind::For(_)));
+        assert!(matches!(definition.node(&db), DefinitionKind::For(_)));
    }

    #[test]
@@ -1184,15 +1196,15 @@ match 1:
        assert_eq!(&names(&global_table), &["a", "x", "y"]);

        let use_def = use_def_map(&db, scope);
-        let x_binding = use_def
-            .first_public_binding(global_table.symbol_id_by_name("x").unwrap())
+        let x_definition = use_def
+            .first_public_definition(global_table.symbol_id_by_name("x").unwrap())
            .unwrap();
-        let y_binding = use_def
-            .first_public_binding(global_table.symbol_id_by_name("y").unwrap())
+        let y_definition = use_def
+            .first_public_definition(global_table.symbol_id_by_name("y").unwrap())
            .unwrap();

-        assert!(matches!(x_binding.kind(&db), DefinitionKind::For(_)));
-        assert!(matches!(y_binding.kind(&db), DefinitionKind::For(_)));
+        assert!(matches!(x_definition.node(&db), DefinitionKind::For(_)));
+        assert!(matches!(y_definition.node(&db), DefinitionKind::For(_)));
    }

    #[test]
@@ -1204,10 +1216,10 @@ match 1:
        assert_eq!(&names(&global_table), &["e", "a", "b", "c", "d"]);

        let use_def = use_def_map(&db, scope);
-        let binding = use_def
-            .first_public_binding(global_table.symbol_id_by_name("a").unwrap())
+        let definition = use_def
+            .first_public_definition(global_table.symbol_id_by_name("a").unwrap())
            .unwrap();

-        assert!(matches!(binding.kind(&db), DefinitionKind::For(_)));
+        assert!(matches!(definition.node(&db), DefinitionKind::For(_)));
    }
 }
--- a/crates/red_knot_python_semantic/src/semantic_index/builder.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/builder.rs
@@ -19,18 +19,14 @@ use crate::semantic_index::definition::{
 };
 use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{
-    FileScopeId, NodeWithScopeKey, NodeWithScopeRef, Scope, ScopeId, ScopedSymbolId,
+    FileScopeId, NodeWithScopeKey, NodeWithScopeRef, Scope, ScopeId, ScopedSymbolId, SymbolFlags,
    SymbolTableBuilder,
 };
 use crate::semantic_index::use_def::{FlowSnapshot, UseDefMapBuilder};
 use crate::semantic_index::SemanticIndex;
 use crate::Db;

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

 pub(super) struct SemanticIndexBuilder<'db> {
    // Builder state
@@ -45,9 +41,6 @@ pub(super) struct SemanticIndexBuilder<'db> {
    /// Flow states at each `break` in the current loop.
    loop_break_states: Vec<FlowSnapshot>,

-    /// Flags about the file's global scope
-    has_future_annotations: bool,
-
    // Semantic Index fields
    scopes: IndexVec<FileScopeId, Scope>,
    scope_ids_by_scope: IndexVec<FileScopeId, ScopeId<'db>>,
@@ -71,8 +64,6 @@ impl<'db> SemanticIndexBuilder<'db> {
            current_match_case: None,
            loop_break_states: vec![],

-            has_future_annotations: false,
-
            scopes: IndexVec::new(),
            symbol_tables: IndexVec::new(),
            ast_ids: IndexVec::new(),
@@ -174,95 +165,49 @@ impl<'db> SemanticIndexBuilder<'db> {
        self.current_use_def_map_mut().merge(state);
    }

-    fn add_symbol(&mut self, name: Name) -> ScopedSymbolId {
-        let (symbol_id, added) = self.current_symbol_table().add_symbol(name);
+    fn add_or_update_symbol(&mut self, name: Name, flags: SymbolFlags) -> ScopedSymbolId {
+        let symbol_table = self.current_symbol_table();
+        let (symbol_id, added) = symbol_table.add_or_update_symbol(name, flags);
        if added {
-            self.current_use_def_map_mut().add_symbol(symbol_id);
+            let use_def_map = self.current_use_def_map_mut();
+            use_def_map.add_symbol(symbol_id);
        }
        symbol_id
    }

-    fn mark_symbol_bound(&mut self, id: ScopedSymbolId) {
-        self.current_symbol_table().mark_symbol_bound(id);
-    }
-
-    fn mark_symbol_used(&mut self, id: ScopedSymbolId) {
-        self.current_symbol_table().mark_symbol_used(id);
-    }
-
    fn add_definition<'a>(
        &mut self,
        symbol: ScopedSymbolId,
        definition_node: impl Into<DefinitionNodeRef<'a>>,
    ) -> Definition<'db> {
        let definition_node: DefinitionNodeRef<'_> = definition_node.into();
-        #[allow(unsafe_code)]
-        // SAFETY: `definition_node` is guaranteed to be a child of `self.module`
-        let kind = unsafe { definition_node.into_owned(self.module.clone()) };
-        let category = kind.category();
        let definition = Definition::new(
            self.db,
            self.file,
            self.current_scope(),
            symbol,
-            kind,
+            #[allow(unsafe_code)]
+            unsafe {
+                definition_node.into_owned(self.module.clone())
+            },
            countme::Count::default(),
        );

-        let existing_definition = self
-            .definitions_by_node
+        self.definitions_by_node
            .insert(definition_node.key(), definition);
-        debug_assert_eq!(existing_definition, None);
-
-        if category.is_binding() {
-            self.mark_symbol_bound(symbol);
-        }
-
-        let use_def = self.current_use_def_map_mut();
-        match category {
-            DefinitionCategory::DeclarationAndBinding => {
-                use_def.record_declaration_and_binding(symbol, definition);
-            }
-            DefinitionCategory::Declaration => use_def.record_declaration(symbol, definition),
-            DefinitionCategory::Binding => use_def.record_binding(symbol, definition),
-        }
+        self.current_use_def_map_mut()
+            .record_definition(symbol, definition);

        definition
    }

-    fn add_expression_constraint(&mut self, constraint_node: &ast::Expr) -> Expression<'db> {
+    fn add_constraint(&mut self, constraint_node: &ast::Expr) -> Expression<'db> {
        let expression = self.add_standalone_expression(constraint_node);
-        self.current_use_def_map_mut()
-            .record_constraint(Constraint::Expression(expression));
+        self.current_use_def_map_mut().record_constraint(expression);

        expression
    }

-    fn add_pattern_constraint(
-        &mut self,
-        subject: &ast::Expr,
-        pattern: &ast::Pattern,
-    ) -> PatternConstraint<'db> {
-        #[allow(unsafe_code)]
-        let (subject, pattern) = unsafe {
-            (
-                AstNodeRef::new(self.module.clone(), subject),
-                AstNodeRef::new(self.module.clone(), pattern),
-            )
-        };
-        let pattern_constraint = PatternConstraint::new(
-            self.db,
-            self.file,
-            self.current_scope(),
-            subject,
-            pattern,
-            countme::Count::default(),
-        );
-        self.current_use_def_map_mut()
-            .record_constraint(Constraint::Pattern(pattern_constraint));
-        pattern_constraint
-    }
-
    /// Record an expression that needs to be a Salsa ingredient, because we need to infer its type
    /// standalone (type narrowing tests, RHS of an assignment.)
    fn add_standalone_expression(&mut self, expression_node: &ast::Expr) -> Expression<'db> {
@@ -307,13 +252,10 @@ impl<'db> SemanticIndexBuilder<'db> {
                        ..
                    }) => (name, &None, default),
                };
-                let symbol = self.add_symbol(name.id.clone());
-                // TODO create Definition for PEP 695 typevars
-                // note that the "bound" on the typevar is a totally different thing than whether
-                // or not a name is "bound" by a typevar declaration; the latter is always true.
-                self.mark_symbol_bound(symbol);
-                if let Some(bounds) = bound {
-                    self.visit_expr(bounds);
+                // TODO create Definition for typevars
+                self.add_or_update_symbol(name.id.clone(), SymbolFlags::IS_DEFINED);
+                if let Some(bound) = bound {
+                    self.visit_expr(bound);
                }
                if let Some(default) = default {
                    self.visit_expr(default);
@@ -330,23 +272,11 @@ impl<'db> SemanticIndexBuilder<'db> {
        nested_scope
    }

-    /// This method does several things:
-    /// - It pushes a new scope onto the stack for visiting
-    ///   a list/dict/set comprehension or generator expression
-    /// - Inside that scope, it visits a list of [`Comprehension`] nodes,
-    ///   assumed to be the "generators" that compose a comprehension
-    ///   (that is, the `for x in y` and `for y in z` parts of `x for x in y for y in z`).
-    /// - Inside that scope, it also calls a closure for visiting the outer `elt`
-    ///   of a list/dict/set comprehension or generator expression
-    /// - It then pops the new scope off the stack
+    /// Visit a list of [`Comprehension`] nodes, assumed to be the "generators" that compose a
+    /// comprehension (that is, the `for x in y` and `for y in z` parts of `x for x in y for y in z`.)
    ///
    /// [`Comprehension`]: ast::Comprehension
-    fn with_generators_scope(
-        &mut self,
-        scope: NodeWithScopeRef,
-        generators: &'db [ast::Comprehension],
-        visit_outer_elt: impl FnOnce(&mut Self),
-    ) {
+    fn visit_generators(&mut self, scope: NodeWithScopeRef, generators: &'db [ast::Comprehension]) {
        let mut generators_iter = generators.iter();

        let Some(generator) = generators_iter.next() else {
@@ -385,13 +315,11 @@ impl<'db> SemanticIndexBuilder<'db> {
                self.visit_expr(expr);
            }
        }
-
-        visit_outer_elt(self);
-        self.pop_scope();
    }

    fn declare_parameter(&mut self, parameter: AnyParameterRef) {
-        let symbol = self.add_symbol(parameter.name().id().clone());
+        let symbol =
+            self.add_or_update_symbol(parameter.name().id().clone(), SymbolFlags::IS_DEFINED);

        let definition = self.add_definition(symbol, parameter);

@@ -399,11 +327,10 @@ impl<'db> SemanticIndexBuilder<'db> {
            // Insert a mapping from the parameter to the same definition.
            // This ensures that calling `HasTy::ty` on the inner parameter returns
            // a valid type (and doesn't panic)
-            let existing_definition = self.definitions_by_node.insert(
+            self.definitions_by_node.insert(
                DefinitionNodeRef::from(AnyParameterRef::Variadic(&with_default.parameter)).key(),
                definition,
            );
-            debug_assert_eq!(existing_definition, None);
        }
    }

@@ -455,7 +382,6 @@ impl<'db> SemanticIndexBuilder<'db> {
            scopes_by_expression: self.scopes_by_expression,
            scopes_by_node: self.scopes_by_node,
            use_def_maps,
-            has_future_annotations: self.has_future_annotations,
        }
    }
 }
@@ -503,7 +429,8 @@ where
                // The symbol for the function name itself has to be evaluated
                // at the end to match the runtime evaluation of parameter defaults
                // and return-type annotations.
-                let symbol = self.add_symbol(function_def.name.id.clone());
+                let symbol = self
+                    .add_or_update_symbol(function_def.name.id.clone(), SymbolFlags::IS_DEFINED);
                self.add_definition(symbol, function_def);
            }
            ast::Stmt::ClassDef(class) => {
@@ -511,7 +438,8 @@ where
                    self.visit_decorator(decorator);
                }

-                let symbol = self.add_symbol(class.name.id.clone());
+                let symbol =
+                    self.add_or_update_symbol(class.name.id.clone(), SymbolFlags::IS_DEFINED);
                self.add_definition(symbol, class);

                self.with_type_params(
@@ -537,7 +465,7 @@ where
                        Name::new(alias.name.id.split('.').next().unwrap())
                    };

-                    let symbol = self.add_symbol(symbol_name);
+                    let symbol = self.add_or_update_symbol(symbol_name, SymbolFlags::IS_DEFINED);
                    self.add_definition(symbol, alias);
                }
            }
@@ -549,16 +477,8 @@ where
                        &alias.name.id
                    };

-                    // Look for imports `from __future__ import annotations`, ignore `as ...`
-                    // We intentionally don't enforce the rules about location of `__future__`
-                    // imports here, we assume the user's intent was to apply the `__future__`
-                    // import, so we still check using it (and will also emit a diagnostic about a
-                    // miss-placed `__future__` import.)
-                    self.has_future_annotations |= alias.name.id == "annotations"
-                        && node.module.as_deref() == Some("__future__");
-
-                    let symbol = self.add_symbol(symbol_name.clone());
-
+                    let symbol =
+                        self.add_or_update_symbol(symbol_name.clone(), SymbolFlags::IS_DEFINED);
                    self.add_definition(symbol, ImportFromDefinitionNodeRef { node, alias_index });
                }
            }
@@ -574,6 +494,7 @@ where
            }
            ast::Stmt::AnnAssign(node) => {
                debug_assert!(self.current_assignment.is_none());
+                // TODO deferred annotation visiting
                self.visit_expr(&node.annotation);
                if let Some(value) = &node.value {
                    self.visit_expr(value);
@@ -599,7 +520,7 @@ where
            ast::Stmt::If(node) => {
                self.visit_expr(&node.test);
                let pre_if = self.flow_snapshot();
-                self.add_expression_constraint(&node.test);
+                self.add_constraint(&node.test);
                self.visit_body(&node.body);
                let mut post_clauses: Vec<FlowSnapshot> = vec![];
                for clause in &node.elif_else_clauses {
@@ -624,23 +545,14 @@ where
                    self.flow_merge(pre_if);
                }
            }
-            ast::Stmt::While(ast::StmtWhile {
-                test,
-                body,
-                orelse,
-                range: _,
-            }) => {
-                self.visit_expr(test);
+            ast::Stmt::While(node) => {
+                self.visit_expr(&node.test);

                let pre_loop = self.flow_snapshot();

                // Save aside any break states from an outer loop
                let saved_break_states = std::mem::take(&mut self.loop_break_states);
-
-                // TODO: definitions created inside the body should be fully visible
-                // to other statements/expressions inside the body --Alex/Carl
-                self.visit_body(body);
-
+                self.visit_body(&node.body);
                // Get the break states from the body of this loop, and restore the saved outer
                // ones.
                let break_states =
@@ -649,7 +561,7 @@ where
                // We may execute the `else` clause without ever executing the body, so merge in
                // the pre-loop state before visiting `else`.
                self.flow_merge(pre_loop);
-                self.visit_body(orelse);
+                self.visit_body(&node.orelse);

                // Breaking out of a while loop bypasses the `else` clause, so merge in the break
                // states after visiting `else`.
@@ -683,35 +595,15 @@ where
                    orelse,
                },
            ) => {
+                // TODO add control flow similar to `ast::Stmt::While` above
                self.add_standalone_expression(iter);
                self.visit_expr(iter);
-
-                let pre_loop = self.flow_snapshot();
-                let saved_break_states = std::mem::take(&mut self.loop_break_states);
-
                debug_assert!(self.current_assignment.is_none());
                self.current_assignment = Some(for_stmt.into());
                self.visit_expr(target);
                self.current_assignment = None;
-
-                // TODO: Definitions created by loop variables
-                // (and definitions created inside the body)
-                // are fully visible to other statements/expressions inside the body --Alex/Carl
                self.visit_body(body);
-
-                let break_states =
-                    std::mem::replace(&mut self.loop_break_states, saved_break_states);
-
-                // We may execute the `else` clause without ever executing the body, so merge in
-                // the pre-loop state before visiting `else`.
-                self.flow_merge(pre_loop);
                self.visit_body(orelse);
-
-                // Breaking out of a `for` loop bypasses the `else` clause, so merge in the break
-                // states after visiting `else`.
-                for break_state in break_states {
-                    self.flow_merge(break_state);
-                }
            }
            ast::Stmt::Match(ast::StmtMatch {
                subject,
@@ -720,74 +612,9 @@ where
            }) => {
                self.add_standalone_expression(subject);
                self.visit_expr(subject);
-
-                let after_subject = self.flow_snapshot();
-                let Some((first, remaining)) = cases.split_first() else {
-                    return;
-                };
-                self.add_pattern_constraint(subject, &first.pattern);
-                self.visit_match_case(first);
-
-                let mut post_case_snapshots = vec![];
-                for case in remaining {
-                    post_case_snapshots.push(self.flow_snapshot());
-                    self.flow_restore(after_subject.clone());
-                    self.add_pattern_constraint(subject, &case.pattern);
+                for case in cases {
                    self.visit_match_case(case);
                }
-                for post_clause_state in post_case_snapshots {
-                    self.flow_merge(post_clause_state);
-                }
-                if !cases
-                    .last()
-                    .is_some_and(|case| case.guard.is_none() && case.pattern.is_wildcard())
-                {
-                    self.flow_merge(after_subject);
-                }
-            }
-            ast::Stmt::Try(ast::StmtTry {
-                body,
-                handlers,
-                orelse,
-                finalbody,
-                is_star,
-                range: _,
-            }) => {
-                self.visit_body(body);
-
-                for except_handler in handlers {
-                    let ast::ExceptHandler::ExceptHandler(except_handler) = except_handler;
-                    let ast::ExceptHandlerExceptHandler {
-                        name: symbol_name,
-                        type_: handled_exceptions,
-                        body: handler_body,
-                        range: _,
-                    } = except_handler;
-
-                    if let Some(handled_exceptions) = handled_exceptions {
-                        self.visit_expr(handled_exceptions);
-                    }
-
-                    // If `handled_exceptions` above was `None`, it's something like `except as e:`,
-                    // which is invalid syntax. However, it's still pretty obvious here that the user
-                    // *wanted* `e` to be bound, so we should still create a definition here nonetheless.
-                    if let Some(symbol_name) = symbol_name {
-                        let symbol = self.add_symbol(symbol_name.id.clone());
-
-                        self.add_definition(
-                            symbol,
-                            DefinitionNodeRef::ExceptHandler(ExceptHandlerDefinitionNodeRef {
-                                handler: except_handler,
-                                is_star: *is_star,
-                            }),
-                        );
-                    }
-
-                    self.visit_body(handler_body);
-                }
-
-                self.visit_body(orelse);
-                self.visit_body(finalbody);
            }
            _ => {
                walk_stmt(self, stmt);
@@ -802,18 +629,23 @@ where

        match expr {
            ast::Expr::Name(name_node @ ast::ExprName { id, ctx, .. }) => {
-                let (is_use, is_definition) = match (ctx, self.current_assignment) {
-                    (ast::ExprContext::Store, Some(CurrentAssignment::AugAssign(_))) => {
-                        // For augmented assignment, the target expression is also used.
-                        (true, true)
-                    }
-                    (ast::ExprContext::Load, _) => (true, false),
-                    (ast::ExprContext::Store, _) => (false, true),
-                    (ast::ExprContext::Del, _) => (false, true),
-                    (ast::ExprContext::Invalid, _) => (false, false),
+                let mut flags = match ctx {
+                    ast::ExprContext::Load => SymbolFlags::IS_USED,
+                    ast::ExprContext::Store => SymbolFlags::IS_DEFINED,
+                    ast::ExprContext::Del => SymbolFlags::IS_DEFINED,
+                    ast::ExprContext::Invalid => SymbolFlags::empty(),
                };
-                let symbol = self.add_symbol(id.clone());
-                if is_definition {
+                if matches!(
+                    self.current_assignment,
+                    Some(CurrentAssignment::AugAssign(_))
+                ) && !ctx.is_invalid()
+                {
+                    // For augmented assignment, the target expression is also used, so we should
+                    // record that as a use.
+                    flags |= SymbolFlags::IS_USED;
+                }
+                let symbol = self.add_or_update_symbol(id.clone(), flags);
+                if flags.contains(SymbolFlags::IS_DEFINED) {
                    match self.current_assignment {
                        Some(CurrentAssignment::Assign(assignment)) => {
                            self.add_definition(
@@ -836,7 +668,6 @@ where
                                ForStmtDefinitionNodeRef {
                                    iterable: &node.iter,
                                    target: name_node,
-                                    is_async: node.is_async,
                                },
                            );
                        }
@@ -853,7 +684,6 @@ where
                                    iterable: &node.iter,
                                    target: name_node,
                                    first,
-                                    is_async: node.is_async,
                                },
                            );
                        }
@@ -870,8 +700,7 @@ where
                    }
                }

-                if is_use {
-                    self.mark_symbol_used(symbol);
+                if flags.contains(SymbolFlags::IS_USED) {
                    let use_id = self.current_ast_ids().record_use(expr);
                    self.current_use_def_map_mut().record_use(symbol, use_id);
                }
@@ -908,7 +737,6 @@ where
                }

                self.visit_expr(lambda.body.as_ref());
-                self.pop_scope();
            }
            ast::Expr::If(ast::ExprIf {
                body, test, orelse, ..
@@ -929,33 +757,30 @@ where
                    elt, generators, ..
                },
            ) => {
-                self.with_generators_scope(
+                self.visit_generators(
                    NodeWithScopeRef::ListComprehension(list_comprehension),
                    generators,
-                    |builder| builder.visit_expr(elt),
                );
+                self.visit_expr(elt);
            }
            ast::Expr::SetComp(
                set_comprehension @ ast::ExprSetComp {
                    elt, generators, ..
                },
            ) => {
-                self.with_generators_scope(
+                self.visit_generators(
                    NodeWithScopeRef::SetComprehension(set_comprehension),
                    generators,
-                    |builder| builder.visit_expr(elt),
                );
+                self.visit_expr(elt);
            }
            ast::Expr::Generator(
                generator @ ast::ExprGenerator {
                    elt, generators, ..
                },
            ) => {
-                self.with_generators_scope(
-                    NodeWithScopeRef::GeneratorExpression(generator),
-                    generators,
-                    |builder| builder.visit_expr(elt),
-                );
+                self.visit_generators(NodeWithScopeRef::GeneratorExpression(generator), generators);
+                self.visit_expr(elt);
            }
            ast::Expr::DictComp(
                dict_comprehension @ ast::ExprDictComp {
@@ -965,19 +790,28 @@ where
                    ..
                },
            ) => {
-                self.with_generators_scope(
+                self.visit_generators(
                    NodeWithScopeRef::DictComprehension(dict_comprehension),
                    generators,
-                    |builder| {
-                        builder.visit_expr(key);
-                        builder.visit_expr(value);
-                    },
                );
+                self.visit_expr(key);
+                self.visit_expr(value);
            }
            _ => {
                walk_expr(self, expr);
            }
        }
+
+        if matches!(
+            expr,
+            ast::Expr::Lambda(_)
+                | ast::Expr::ListComp(_)
+                | ast::Expr::SetComp(_)
+                | ast::Expr::Generator(_)
+                | ast::Expr::DictComp(_)
+        ) {
+            self.pop_scope();
+        }
    }

    fn visit_parameters(&mut self, parameters: &'ast ast::Parameters) {
@@ -1006,7 +840,7 @@ where
            range: _,
        }) = pattern
        {
-            let symbol = self.add_symbol(name.id().clone());
+            let symbol = self.add_or_update_symbol(name.id().clone(), SymbolFlags::IS_DEFINED);
            let state = self.current_match_case.as_ref().unwrap();
            self.add_definition(
                symbol,
@@ -1027,7 +861,7 @@ where
            rest: Some(name), ..
        }) = pattern
        {
-            let symbol = self.add_symbol(name.id().clone());
+            let symbol = self.add_or_update_symbol(name.id().clone(), SymbolFlags::IS_DEFINED);
            let state = self.current_match_case.as_ref().unwrap();
            self.add_definition(
                symbol,
--- a/crates/red_knot_python_semantic/src/semantic_index/constraint.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/constraint.rs
@@ -1,39 +0,0 @@
-use ruff_db::files::File;
-use ruff_python_ast as ast;
-
-use crate::ast_node_ref::AstNodeRef;
-use crate::db::Db;
-use crate::semantic_index::expression::Expression;
-use crate::semantic_index::symbol::{FileScopeId, ScopeId};
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub(crate) enum Constraint<'db> {
-    Expression(Expression<'db>),
-    Pattern(PatternConstraint<'db>),
-}
-
-#[salsa::tracked]
-pub(crate) struct PatternConstraint<'db> {
-    #[id]
-    pub(crate) file: File,
-
-    #[id]
-    pub(crate) file_scope: FileScopeId,
-
-    #[no_eq]
-    #[return_ref]
-    pub(crate) subject: AstNodeRef<ast::Expr>,
-
-    #[no_eq]
-    #[return_ref]
-    pub(crate) pattern: AstNodeRef<ast::Pattern>,
-
-    #[no_eq]
-    count: countme::Count<PatternConstraint<'static>>,
-}
-
-impl<'db> PatternConstraint<'db> {
-    pub(crate) fn scope(self, db: &'db dyn Db) -> ScopeId<'db> {
-        self.file_scope(db).to_scope_id(db, self.file(db))
-    }
-}
--- a/crates/red_knot_python_semantic/src/semantic_index/definition.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/definition.rs
@@ -23,7 +23,7 @@ pub struct Definition<'db> {

    #[no_eq]
    #[return_ref]
-    pub(crate) kind: DefinitionKind,
+    pub(crate) node: DefinitionKind,

    #[no_eq]
    count: countme::Count<Definition<'static>>,
@@ -33,18 +33,6 @@ impl<'db> Definition<'db> {
    pub(crate) fn scope(self, db: &'db dyn Db) -> ScopeId<'db> {
        self.file_scope(db).to_scope_id(db, self.file(db))
    }
-
-    pub(crate) fn category(self, db: &'db dyn Db) -> DefinitionCategory {
-        self.kind(db).category()
-    }
-
-    pub(crate) fn is_declaration(self, db: &'db dyn Db) -> bool {
-        self.kind(db).category().is_declaration()
-    }
-
-    pub(crate) fn is_binding(self, db: &'db dyn Db) -> bool {
-        self.kind(db).category().is_binding()
-    }
 }

 #[derive(Copy, Clone, Debug)]
@@ -62,7 +50,6 @@ pub(crate) enum DefinitionNodeRef<'a> {
    Parameter(ast::AnyParameterRef<'a>),
    WithItem(WithItemDefinitionNodeRef<'a>),
    MatchPattern(MatchPatternDefinitionNodeRef<'a>),
-    ExceptHandler(ExceptHandlerDefinitionNodeRef<'a>),
 }

 impl<'a> From<&'a ast::StmtFunctionDef> for DefinitionNodeRef<'a> {
@@ -165,13 +152,6 @@ pub(crate) struct WithItemDefinitionNodeRef<'a> {
 pub(crate) struct ForStmtDefinitionNodeRef<'a> {
    pub(crate) iterable: &'a ast::Expr,
    pub(crate) target: &'a ast::ExprName,
-    pub(crate) is_async: bool,
-}
-
-#[derive(Copy, Clone, Debug)]
-pub(crate) struct ExceptHandlerDefinitionNodeRef<'a> {
-    pub(crate) handler: &'a ast::ExceptHandlerExceptHandler,
-    pub(crate) is_star: bool,
 }

 #[derive(Copy, Clone, Debug)]
@@ -179,7 +159,6 @@ pub(crate) struct ComprehensionDefinitionNodeRef<'a> {
    pub(crate) iterable: &'a ast::Expr,
    pub(crate) target: &'a ast::ExprName,
    pub(crate) first: bool,
-    pub(crate) is_async: bool,
 }

 #[derive(Copy, Clone, Debug)]
@@ -227,25 +206,20 @@ impl DefinitionNodeRef<'_> {
            DefinitionNodeRef::AugmentedAssignment(augmented_assignment) => {
                DefinitionKind::AugmentedAssignment(AstNodeRef::new(parsed, augmented_assignment))
            }
-            DefinitionNodeRef::For(ForStmtDefinitionNodeRef {
-                iterable,
-                target,
-                is_async,
-            }) => DefinitionKind::For(ForStmtDefinitionKind {
-                iterable: AstNodeRef::new(parsed.clone(), iterable),
-                target: AstNodeRef::new(parsed, target),
-                is_async,
-            }),
+            DefinitionNodeRef::For(ForStmtDefinitionNodeRef { iterable, target }) => {
+                DefinitionKind::For(ForStmtDefinitionKind {
+                    iterable: AstNodeRef::new(parsed.clone(), iterable),
+                    target: AstNodeRef::new(parsed, target),
+                })
+            }
            DefinitionNodeRef::Comprehension(ComprehensionDefinitionNodeRef {
                iterable,
                target,
                first,
-                is_async,
            }) => DefinitionKind::Comprehension(ComprehensionDefinitionKind {
                iterable: AstNodeRef::new(parsed.clone(), iterable),
                target: AstNodeRef::new(parsed, target),
                first,
-                is_async,
            }),
            DefinitionNodeRef::Parameter(parameter) => match parameter {
                ast::AnyParameterRef::Variadic(parameter) => {
@@ -270,13 +244,6 @@ impl DefinitionNodeRef<'_> {
                identifier: AstNodeRef::new(parsed, identifier),
                index,
            }),
-            DefinitionNodeRef::ExceptHandler(ExceptHandlerDefinitionNodeRef {
-                handler,
-                is_star,
-            }) => DefinitionKind::ExceptHandler(ExceptHandlerDefinitionKind {
-                handler: AstNodeRef::new(parsed.clone(), handler),
-                is_star,
-            }),
        }
    }

@@ -298,7 +265,6 @@ impl DefinitionNodeRef<'_> {
            Self::For(ForStmtDefinitionNodeRef {
                iterable: _,
                target,
-                is_async: _,
            }) => target.into(),
            Self::Comprehension(ComprehensionDefinitionNodeRef { target, .. }) => target.into(),
            Self::Parameter(node) => match node {
@@ -309,46 +275,10 @@ impl DefinitionNodeRef<'_> {
            Self::MatchPattern(MatchPatternDefinitionNodeRef { identifier, .. }) => {
                identifier.into()
            }
-            Self::ExceptHandler(ExceptHandlerDefinitionNodeRef { handler, .. }) => handler.into(),
        }
    }
 }

-#[derive(Clone, Copy, Debug)]
-pub(crate) enum DefinitionCategory {
-    /// A Definition which binds a value to a name (e.g. `x = 1`).
-    Binding,
-    /// A Definition which declares the upper-bound of acceptable types for this name (`x: int`).
-    Declaration,
-    /// A Definition which both declares a type and binds a value (e.g. `x: int = 1`).
-    DeclarationAndBinding,
-}
-
-impl DefinitionCategory {
-    /// True if this definition establishes a "declared type" for the symbol.
-    ///
-    /// If so, any assignments reached by this definition are in error if they assign a value of a
-    /// type not assignable to the declared type.
-    ///
-    /// Annotations establish a declared type. So do function and class definitions, and imports.
-    pub(crate) fn is_declaration(self) -> bool {
-        matches!(
-            self,
-            DefinitionCategory::Declaration | DefinitionCategory::DeclarationAndBinding
-        )
-    }
-
-    /// True if this definition assigns a value to the symbol.
-    ///
-    /// False only for annotated assignments without a RHS.
-    pub(crate) fn is_binding(self) -> bool {
-        matches!(
-            self,
-            DefinitionCategory::Binding | DefinitionCategory::DeclarationAndBinding
-        )
-    }
-}
-
 #[derive(Clone, Debug)]
 pub enum DefinitionKind {
    Import(AstNodeRef<ast::Alias>),
@@ -365,52 +295,6 @@ pub enum DefinitionKind {
    ParameterWithDefault(AstNodeRef<ast::ParameterWithDefault>),
    WithItem(WithItemDefinitionKind),
    MatchPattern(MatchPatternDefinitionKind),
-    ExceptHandler(ExceptHandlerDefinitionKind),
-}
-
-impl DefinitionKind {
-    pub(crate) fn category(&self) -> DefinitionCategory {
-        match self {
-            // functions, classes, and imports always bind, and we consider them declarations
-            DefinitionKind::Function(_)
-            | DefinitionKind::Class(_)
-            | DefinitionKind::Import(_)
-            | DefinitionKind::ImportFrom(_) => DefinitionCategory::DeclarationAndBinding,
-            // a parameter always binds a value, but is only a declaration if annotated
-            DefinitionKind::Parameter(parameter) => {
-                if parameter.annotation.is_some() {
-                    DefinitionCategory::DeclarationAndBinding
-                } else {
-                    DefinitionCategory::Binding
-                }
-            }
-            // presence of a default is irrelevant, same logic as for a no-default parameter
-            DefinitionKind::ParameterWithDefault(parameter_with_default) => {
-                if parameter_with_default.parameter.annotation.is_some() {
-                    DefinitionCategory::DeclarationAndBinding
-                } else {
-                    DefinitionCategory::Binding
-                }
-            }
-            // annotated assignment is always a declaration, only a binding if there is a RHS
-            DefinitionKind::AnnotatedAssignment(ann_assign) => {
-                if ann_assign.value.is_some() {
-                    DefinitionCategory::DeclarationAndBinding
-                } else {
-                    DefinitionCategory::Declaration
-                }
-            }
-            // all of these bind values without declaring a type
-            DefinitionKind::NamedExpression(_)
-            | DefinitionKind::Assignment(_)
-            | DefinitionKind::AugmentedAssignment(_)
-            | DefinitionKind::For(_)
-            | DefinitionKind::Comprehension(_)
-            | DefinitionKind::WithItem(_)
-            | DefinitionKind::MatchPattern(_)
-            | DefinitionKind::ExceptHandler(_) => DefinitionCategory::Binding,
-        }
-    }
 }

 #[derive(Clone, Debug)]
@@ -436,7 +320,6 @@ pub struct ComprehensionDefinitionKind {
    iterable: AstNodeRef<ast::Expr>,
    target: AstNodeRef<ast::ExprName>,
    first: bool,
-    is_async: bool,
 }

 impl ComprehensionDefinitionKind {
@@ -451,10 +334,6 @@ impl ComprehensionDefinitionKind {
    pub(crate) fn is_first(&self) -> bool {
        self.first
    }
-
-    pub(crate) fn is_async(&self) -> bool {
-        self.is_async
-    }
 }

 #[derive(Clone, Debug)]
@@ -509,7 +388,6 @@ impl WithItemDefinitionKind {
 pub struct ForStmtDefinitionKind {
    iterable: AstNodeRef<ast::Expr>,
    target: AstNodeRef<ast::ExprName>,
-    is_async: bool,
 }

 impl ForStmtDefinitionKind {
@@ -520,30 +398,6 @@ impl ForStmtDefinitionKind {
    pub(crate) fn target(&self) -> &ast::ExprName {
        self.target.node()
    }
-
-    pub(crate) fn is_async(&self) -> bool {
-        self.is_async
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct ExceptHandlerDefinitionKind {
-    handler: AstNodeRef<ast::ExceptHandlerExceptHandler>,
-    is_star: bool,
-}
-
-impl ExceptHandlerDefinitionKind {
-    pub(crate) fn node(&self) -> &ast::ExceptHandlerExceptHandler {
-        self.handler.node()
-    }
-
-    pub(crate) fn handled_exceptions(&self) -> Option<&ast::Expr> {
-        self.node().type_.as_deref()
-    }
-
-    pub(crate) fn is_star(&self) -> bool {
-        self.is_star
-    }
 }

 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
@@ -614,9 +468,3 @@ impl From<&ast::Identifier> for DefinitionNodeKey {
        Self(NodeKey::from_node(identifier))
    }
 }
-
-impl From<&ast::ExceptHandlerExceptHandler> for DefinitionNodeKey {
-    fn from(handler: &ast::ExceptHandlerExceptHandler) -> Self {
-        Self(NodeKey::from_node(handler))
-    }
-}
--- a/crates/red_knot_python_semantic/src/semantic_index/symbol.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/symbol.rs
@@ -44,16 +44,16 @@ impl Symbol {
    }

    /// Is the symbol defined in its containing scope?
-    pub fn is_bound(&self) -> bool {
-        self.flags.contains(SymbolFlags::IS_BOUND)
+    pub fn is_defined(&self) -> bool {
+        self.flags.contains(SymbolFlags::IS_DEFINED)
    }
 }

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

-    pub(super) fn add_symbol(&mut self, name: Name) -> (ScopedSymbolId, bool) {
+    pub(super) fn add_or_update_symbol(
+        &mut self,
+        name: Name,
+        flags: SymbolFlags,
+    ) -> (ScopedSymbolId, bool) {
        let hash = SymbolTable::hash_name(&name);
        let entry = self
            .table
@@ -281,9 +285,15 @@ impl SymbolTableBuilder {
            .from_hash(hash, |id| self.table.symbols[*id].name() == &name);

        match entry {
-            RawEntryMut::Occupied(entry) => (*entry.key(), false),
+            RawEntryMut::Occupied(entry) => {
+                let symbol = &mut self.table.symbols[*entry.key()];
+                symbol.insert_flags(flags);
+
+                (*entry.key(), false)
+            }
            RawEntryMut::Vacant(entry) => {
-                let symbol = Symbol::new(name);
+                let mut symbol = Symbol::new(name);
+                symbol.insert_flags(flags);

                let id = self.table.symbols.push(symbol);
                entry.insert_with_hasher(hash, id, (), |id| {
@@ -294,14 +304,6 @@ impl SymbolTableBuilder {
        }
    }

-    pub(super) fn mark_symbol_bound(&mut self, id: ScopedSymbolId) {
-        self.table.symbols[id].insert_flags(SymbolFlags::IS_BOUND);
-    }
-
-    pub(super) fn mark_symbol_used(&mut self, id: ScopedSymbolId) {
-        self.table.symbols[id].insert_flags(SymbolFlags::IS_USED);
-    }
-
    pub(super) fn finish(mut self) -> SymbolTable {
        self.table.shrink_to_fit();
        self.table
--- a/crates/red_knot_python_semantic/src/semantic_index/use_def.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/use_def.rs
@@ -1,79 +1,5 @@
-//! First, some terminology:
-//!
-//! * A "binding" gives a new value to a variable. This includes many different Python statements
-//!   (assignment statements of course, but also imports, `def` and `class` statements, `as`
-//!   clauses in `with` and `except` statements, match patterns, and others) and even one
-//!   expression kind (named expressions). It notably does not include annotated assignment
-//!   statements without a right-hand side value; these do not assign any new value to the
-//!   variable. We consider function parameters to be bindings as well, since (from the perspective
-//!   of the function's internal scope), a function parameter begins the scope bound to a value.
-//!
-//! * A "declaration" establishes an upper bound type for the values that a variable may be
-//!   permitted to take on. Annotated assignment statements (with or without an RHS value) are
-//!   declarations; annotated function parameters are also declarations. We consider `def` and
-//!   `class` statements to also be declarations, so as to prohibit accidentally shadowing them.
-//!
-//! Annotated assignments with a right-hand side, and annotated function parameters, are both
-//! bindings and declarations.
-//!
-//! We use [`Definition`] as the universal term (and Salsa tracked struct) encompassing both
-//! bindings and declarations. (This sacrifices a bit of type safety in exchange for improved
-//! performance via fewer Salsa tracked structs and queries, since most declarations -- typed
-//! parameters and annotated assignments with RHS -- are both bindings and declarations.)
-//!
-//! At any given use of a variable, we can ask about both its "declared type" and its "inferred
-//! type". These may be different, but the inferred type must always be assignable to the declared
-//! type; that is, the declared type is always wider, and the inferred type may be more precise. If
-//! we see an invalid assignment, we emit a diagnostic and abandon our inferred type, deferring to
-//! the declared type (this allows an explicit annotation to override bad inference, without a
-//! cast), maintaining the invariant.
-//!
-//! The **inferred type** represents the most precise type we believe encompasses all possible
-//! values for the variable at a given use. It is based on a union of the bindings which can reach
-//! that use through some control flow path, and the narrowing constraints that control flow must
-//! have passed through between the binding and the use. For example, in this code:
-//!
-//! ```python
-//! x = 1 if flag else None
-//! if x is not None:
-//!     use(x)
-//! ```
-//!
-//! For the use of `x` on the third line, the inferred type should be `Literal[1]`. This is based
-//! on the binding on the first line, which assigns the type `Literal[1] | None`, and the narrowing
-//! constraint on the second line, which rules out the type `None`, since control flow must pass
-//! through this constraint to reach the use in question.
-//!
-//! The **declared type** represents the code author's declaration (usually through a type
-//! annotation) that a given variable should not be assigned any type outside the declared type. In
-//! our model, declared types are also control-flow-sensitive; we allow the code author to
-//! explicitly re-declare the same variable with a different type. So for a given binding of a
-//! variable, we will want to ask which declarations of that variable can reach that binding, in
-//! order to determine whether the binding is permitted, or should be a type error. For example:
-//!
-//! ```python
-//! from pathlib import Path
-//! def f(path: str):
-//!     path: Path = Path(path)
-//! ```
-//!
-//! In this function, the initial declared type of `path` is `str`, meaning that the assignment
-//! `path = Path(path)` would be a type error, since it assigns to `path` a value whose type is not
-//! assignable to `str`. This is the purpose of declared types: they prevent accidental assignment
-//! of the wrong type to a variable.
-//!
-//! But in some cases it is useful to "shadow" or "re-declare" a variable with a new type, and we
-//! permit this, as long as it is done with an explicit re-annotation. So `path: Path =
-//! Path(path)`, with the explicit `: Path` annotation, is permitted.
-//!
-//! The general rule is that whatever declaration(s) can reach a given binding determine the
-//! validity of that binding. If there is a path in which the symbol is not declared, that is a
-//! declaration of `Unknown`. If multiple declarations can reach a binding, we union them, but by
-//! default we also issue a type error, since this implicit union of declared types may hide an
-//! error.
-//!
-//! To support type inference, we build a map from each use of a symbol to the bindings live at
-//! that use, and the type narrowing constraints that apply to each binding.
+//! Build a map from each use of a symbol to the definitions visible from that use, and the
+//! type-narrowing constraints that apply to each definition.
 //!
 //! Let's take this code sample:
 //!
@@ -81,157 +7,148 @@
 //! x = 1
 //! x = 2
 //! y = x
-//! if flag:
+//! if y is not None:
 //!     x = 3
 //! else:
 //!     x = 4
 //! z = x
 //! ```
 //!
-//! In this snippet, we have four bindings of `x` (the statements assigning `1`, `2`, `3`, and `4`
-//! to it), and two uses of `x` (the `y = x` and `z = x` assignments). The first binding of `x`
-//! does not reach any use, because it's immediately replaced by the second binding, before any use
-//! happens. (A linter could thus flag the statement `x = 1` as likely superfluous.)
+//! In this snippet, we have four definitions of `x` (the statements assigning `1`, `2`, `3`,
+//! and `4` to it), and two uses of `x` (the `y = x` and `z = x` assignments). The first
+//! [`Definition`] of `x` is never visible to any use, because it's immediately replaced by the
+//! second definition, before any use happens. (A linter could thus flag the statement `x = 1`
+//! as likely superfluous.)
 //!
-//! The first use of `x` has one live binding: the assignment `x = 2`.
+//! The first use of `x` has one definition visible to it: the assignment `x = 2`.
 //!
 //! Things get a bit more complex when we have branches. We will definitely take either the `if` or
-//! the `else` branch. Thus, the second use of `x` has two live bindings: `x = 3` and `x = 4`. The
-//! `x = 2` assignment is no longer visible, because it must be replaced by either `x = 3` or `x =
-//! 4`, no matter which branch was taken. We don't know which branch was taken, so we must consider
-//! both bindings as live, which means eventually we would (in type inference) look at these two
-//! bindings and infer a type of `Literal[3, 4]` -- the union of `Literal[3]` and `Literal[4]` --
-//! for the second use of `x`.
+//! the `else` branch. Thus, the second use of `x` has two definitions visible to it: `x = 3` and
+//! `x = 4`. The `x = 2` definition is no longer visible, because it must be replaced by either `x
+//! = 3` or `x = 4`, no matter which branch was taken. We don't know which branch was taken, so we
+//! must consider both definitions as visible, which means eventually we would (in type inference)
+//! look at these two definitions and infer a type of `Literal[3, 4]` -- the union of `Literal[3]`
+//! and `Literal[4]` -- for the second use of `x`.
 //!
 //! So that's one question our use-def map needs to answer: given a specific use of a symbol, which
-//! binding(s) can reach that use. In [`AstIds`](crate::semantic_index::ast_ids::AstIds) we number
-//! all uses (that means a `Name` node with `Load` context) so we have a `ScopedUseId` to
-//! efficiently represent each use.
+//! definition(s) is/are visible from that use. In
+//! [`AstIds`](crate::semantic_index::ast_ids::AstIds) we number all uses (that means a `Name` node
+//! with `Load` context) so we have a `ScopedUseId` to efficiently represent each use.
 //!
-//! We also need to know, for a given definition of a symbol, what type narrowing constraints apply
+//! Another case we need to handle is when a symbol is referenced from a different scope (the most
+//! obvious example of this is an import). We call this "public" use of a symbol. So the other
+//! question we need to be able to answer is, what are the publicly-visible definitions of each
+//! symbol?
+//!
+//! Technically, public use of a symbol could also occur from any point in control flow of the
+//! scope where the symbol is defined (via inline imports and import cycles, in the case of an
+//! import, or via a function call partway through the local scope that ends up using a symbol from
+//! the scope via a global or nonlocal reference.) But modeling this fully accurately requires
+//! whole-program analysis that isn't tractable for an efficient incremental compiler, since it
+//! means a given symbol could have a different type every place it's referenced throughout the
+//! program, depending on the shape of arbitrarily-sized call/import graphs. So we follow other
+//! Python type-checkers in making the simplifying assumption that usually the scope will finish
+//! execution before its symbols are made visible to other scopes; for instance, most imports will
+//! import from a complete module, not a partially-executed module. (We may want to get a little
+//! smarter than this in the future, in particular for closures, but for now this is where we
+//! start.)
+//!
+//! So this means that the publicly-visible definitions of a symbol are the definitions still
+//! visible at the end of the scope; effectively we have an implicit "use" of every symbol at the
+//! end of the scope.
+//!
+//! We also need to know, for a given definition of a symbol, what type-narrowing constraints apply
 //! to it. For instance, in this code sample:
 //!
 //! ```python
 //! x = 1 if flag else None
 //! if x is not None:
-//!     use(x)
+//!     y = x
 //! ```
 //!
-//! At the use of `x`, the live binding of `x` is `1 if flag else None`, which would infer as the
-//! type `Literal[1] | None`. But the constraint `x is not None` dominates this use, which means we
-//! can rule out the possibility that `x` is `None` here, which should give us the type
-//! `Literal[1]` for this use.
-//!
-//! For declared types, we need to be able to answer the question "given a binding to a symbol,
-//! which declarations of that symbol can reach the binding?" This allows us to emit a diagnostic
-//! if the binding is attempting to bind a value of a type that is not assignable to the declared
-//! type for that symbol, at that point in control flow.
-//!
-//! We also need to know, given a declaration of a symbol, what the inferred type of that symbol is
-//! at that point. This allows us to emit a diagnostic in a case like `x = "foo"; x: int`. The
-//! binding `x = "foo"` occurs before the declaration `x: int`, so according to our
-//! control-flow-sensitive interpretation of declarations, the assignment is not an error. But the
-//! declaration is an error, since it would violate the "inferred type must be assignable to
-//! declared type" rule.
-//!
-//! Another case we need to handle is when a symbol is referenced from a different scope (for
-//! example, an import or a nonlocal reference). We call this "public" use of a symbol. For public
-//! use of a symbol, we prefer the declared type, if there are any declarations of that symbol; if
-//! not, we fall back to the inferred type. So we also need to know which declarations and bindings
-//! can reach the end of the scope.
-//!
-//! Technically, public use of a symbol could occur from any point in control flow of the scope
-//! where the symbol is defined (via inline imports and import cycles, in the case of an import, or
-//! via a function call partway through the local scope that ends up using a symbol from the scope
-//! via a global or nonlocal reference.) But modeling this fully accurately requires whole-program
-//! analysis that isn't tractable for an efficient analysis, since it means a given symbol could
-//! have a different type every place it's referenced throughout the program, depending on the
-//! shape of arbitrarily-sized call/import graphs. So we follow other Python type checkers in
-//! making the simplifying assumption that usually the scope will finish execution before its
-//! symbols are made visible to other scopes; for instance, most imports will import from a
-//! complete module, not a partially-executed module. (We may want to get a little smarter than
-//! this in the future for some closures, but for now this is where we start.)
+//! At the use of `x` in `y = x`, the visible definition of `x` is `1 if flag else None`, which
+//! would infer as the type `Literal[1] | None`. But the constraint `x is not None` dominates this
+//! use, which means we can rule out the possibility that `x` is `None` here, which should give us
+//! the type `Literal[1]` for this use.
 //!
 //! The data structure we build to answer these questions is the `UseDefMap`. It has a
-//! `bindings_by_use` vector of [`SymbolBindings`] indexed by [`ScopedUseId`], a
-//! `declarations_by_binding` vector of [`SymbolDeclarations`] indexed by [`ScopedDefinitionId`], a
-//! `bindings_by_declaration` vector of [`SymbolBindings`] indexed by [`ScopedDefinitionId`], and
-//! `public_bindings` and `public_definitions` vectors indexed by [`ScopedSymbolId`]. The values in
-//! each of these vectors are (in principle) a list of live bindings at that use/definition, or at
-//! the end of the scope for that symbol, with a list of the dominating constraints for each
-//! binding.
+//! `definitions_by_use` vector indexed by [`ScopedUseId`] and a `public_definitions` vector
+//! indexed by [`ScopedSymbolId`]. The values in each of these vectors are (in principle) a list of
+//! visible definitions at that use, or at the end of the scope for that symbol, with a list of the
+//! dominating constraints for each of those definitions.
 //!
 //! In order to avoid vectors-of-vectors-of-vectors and all the allocations that would entail, we
 //! don't actually store these "list of visible definitions" as a vector of [`Definition`].
-//! Instead, [`SymbolBindings`] and [`SymbolDeclarations`] are structs which use bit-sets to track
-//! definitions (and constraints, in the case of bindings) in terms of [`ScopedDefinitionId`] and
-//! [`ScopedConstraintId`], which are indices into the `all_definitions` and `all_constraints`
-//! indexvecs in the [`UseDefMap`].
+//! Instead, the values in `definitions_by_use` and `public_definitions` are a [`SymbolState`]
+//! struct which uses bit-sets to track definitions and constraints in terms of
+//! [`ScopedDefinitionId`] and [`ScopedConstraintId`], which are indices into the `all_definitions`
+//! and `all_constraints` indexvecs in the [`UseDefMap`].
 //!
 //! There is another special kind of possible "definition" for a symbol: there might be a path from
 //! the scope entry to a given use in which the symbol is never bound.
 //!
-//! The simplest way to model "unbound" would be as a "binding" itself: the initial "binding" for
-//! each symbol in a scope. But actually modeling it this way would unnecessarily increase the
-//! number of [`Definition`]s that Salsa must track. Since "unbound" is special in that all symbols
-//! share it, and it doesn't have any additional per-symbol state, and constraints are irrelevant
-//! to it, we can represent it more efficiently: we use the `may_be_unbound` boolean on the
-//! [`SymbolBindings`] struct. If this flag is `true` for a use of a symbol, it means the symbol
-//! has a path to the use in which it is never bound. If this flag is `false`, it means we've
-//! eliminated the possibility of unbound: every control flow path to the use includes a binding
-//! for this symbol.
+//! The simplest way to model "unbound" would be as an actual [`Definition`] itself: the initial
+//! visible [`Definition`] for each symbol in a scope. But actually modeling it this way would
+//! unnecessarily increase the number of [`Definition`] that Salsa must track. Since "unbound" is a
+//! special definition in that all symbols share it, and it doesn't have any additional per-symbol
+//! state, and constraints are irrelevant to it, we can represent it more efficiently: we use the
+//! `may_be_unbound` boolean on the [`SymbolState`] struct. If this flag is `true`, it means the
+//! symbol/use really has one additional visible "definition", which is the unbound state. If this
+//! flag is `false`, it means we've eliminated the possibility of unbound: every path we've
+//! followed includes a definition for this symbol.
 //!
 //! To build a [`UseDefMap`], the [`UseDefMapBuilder`] is notified of each new use, definition, and
 //! constraint as they are encountered by the
 //! [`SemanticIndexBuilder`](crate::semantic_index::builder::SemanticIndexBuilder) AST visit. For
-//! each symbol, the builder tracks the `SymbolState` (`SymbolBindings` and `SymbolDeclarations`)
-//! for that symbol. When we hit a use or definition of a symbol, we record the necessary parts of
-//! the current state for that symbol that we need for that use or definition. When we reach the
-//! end of the scope, it records the state for each symbol as the public definitions of that
-//! symbol.
+//! each symbol, the builder tracks the `SymbolState` for that symbol. When we hit a use of a
+//! symbol, it records the current state for that symbol for that use. When we reach the end of the
+//! scope, it records the state for each symbol as the public definitions of that symbol.
 //!
-//! Let's walk through the above example. Initially we record for `x` that it has no bindings, and
-//! may be unbound. When we see `x = 1`, we record that as the sole live binding of `x`, and flip
-//! `may_be_unbound` to `false`. Then we see `x = 2`, and we replace `x = 1` as the sole live
-//! binding of `x`. When we get to `y = x`, we record that the live bindings for that use of `x`
-//! are just the `x = 2` definition.
+//! Let's walk through the above example. Initially we record for `x` that it has no visible
+//! definitions, and may be unbound. When we see `x = 1`, we record that as the sole visible
+//! definition of `x`, and flip `may_be_unbound` to `false`. Then we see `x = 2`, and it replaces
+//! `x = 1` as the sole visible definition of `x`. When we get to `y = x`, we record that the
+//! visible definitions for that use of `x` are just the `x = 2` definition.
 //!
 //! Then we hit the `if` branch. We visit the `test` node (`flag` in this case), since that will
-//! happen regardless. Then we take a pre-branch snapshot of the current state for all symbols,
-//! which we'll need later. Then we record `flag` as a possible constraint on the current binding
-//! (`x = 2`), and go ahead and visit the `if` body. When we see `x = 3`, it replaces `x = 2`
-//! (constrained by `flag`) as the sole live binding of `x`. At the end of the `if` body, we take
-//! another snapshot of the current symbol state; we'll call this the post-if-body snapshot.
+//! happen regardless. Then we take a pre-branch snapshot of the currently visible definitions for
+//! all symbols, which we'll need later. Then we record `flag` as a possible constraint on the
+//! currently visible definition (`x = 2`), and go ahead and visit the `if` body. When we see `x =
+//! 3`, it replaces `x = 2` (constrained by `flag`) as the sole visible definition of `x`. At the
+//! end of the `if` body, we take another snapshot of the currently-visible definitions; we'll call
+//! this the post-if-body snapshot.
 //!
 //! Now we need to visit the `else` clause. The conditions when entering the `else` clause should
 //! be the pre-if conditions; if we are entering the `else` clause, we know that the `if` test
 //! failed and we didn't execute the `if` body. So we first reset the builder to the pre-if state,
-//! using the snapshot we took previously (meaning we now have `x = 2` as the sole binding for `x`
-//! again), then visit the `else` clause, where `x = 4` replaces `x = 2` as the sole live binding
-//! of `x`.
+//! using the snapshot we took previously (meaning we now have `x = 2` as the sole visible
+//! definition for `x` again), then visit the `else` clause, where `x = 4` replaces `x = 2` as the
+//! sole visible definition of `x`.
 //!
 //! Now we reach the end of the if/else, and want to visit the following code. The state here needs
 //! to reflect that we might have gone through the `if` branch, or we might have gone through the
 //! `else` branch, and we don't know which. So we need to "merge" our current builder state
-//! (reflecting the end-of-else state, with `x = 4` as the only live binding) with our post-if-body
-//! snapshot (which has `x = 3` as the only live binding). The result of this merge is that we now
-//! have two live bindings of `x`: `x = 3` and `x = 4`.
+//! (reflecting the end-of-else state, with `x = 4` as the only visible definition) with our
+//! post-if-body snapshot (which has `x = 3` as the only visible definition). The result of this
+//! merge is that we now have two visible definitions of `x`: `x = 3` and `x = 4`.
 //!
 //! The [`UseDefMapBuilder`] itself just exposes methods for taking a snapshot, resetting to a
 //! snapshot, and merging a snapshot into the current state. The logic using these methods lives in
 //! [`SemanticIndexBuilder`](crate::semantic_index::builder::SemanticIndexBuilder), e.g. where it
 //! visits a `StmtIf` node.
+//!
+//! (In the future we may have some other questions we want to answer as well, such as "is this
+//! definition used?", which will require tracking a bit more info in our map, e.g. a "used" bit
+//! for each [`Definition`] which is flipped to true when we record that definition for a use.)
 use self::symbol_state::{
-    BindingIdWithConstraintsIterator, ConstraintIdIterator, DeclarationIdIterator,
-    ScopedConstraintId, ScopedDefinitionId, SymbolBindings, SymbolDeclarations, SymbolState,
+    ConstraintIdIterator, DefinitionIdWithConstraintsIterator, ScopedConstraintId,
+    ScopedDefinitionId, SymbolState,
 };
 use crate::semantic_index::ast_ids::ScopedUseId;
 use crate::semantic_index::definition::Definition;
+use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::ScopedSymbolId;
 use ruff_index::IndexVec;
-use rustc_hash::FxHashMap;
-
-use super::constraint::Constraint;

 mod bitset;
 mod symbol_state;
@@ -242,135 +159,63 @@ pub(crate) struct UseDefMap<'db> {
    /// Array of [`Definition`] in this scope.
    all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,

-    /// Array of [`Constraint`] in this scope.
-    all_constraints: IndexVec<ScopedConstraintId, Constraint<'db>>,
+    /// Array of constraints (as [`Expression`]) in this scope.
+    all_constraints: IndexVec<ScopedConstraintId, Expression<'db>>,

-    /// [`SymbolBindings`] reaching a [`ScopedUseId`].
-    bindings_by_use: IndexVec<ScopedUseId, SymbolBindings>,
-
-    /// [`SymbolBindings`] or [`SymbolDeclarations`] reaching a given [`Definition`].
-    ///
-    /// If the definition is a binding (only) -- `x = 1` for example -- then we need
-    /// [`SymbolDeclarations`] to know whether this binding is permitted by the live declarations.
-    ///
-    /// If the definition is a declaration (only) -- `x: int` for example -- then we need
-    /// [`SymbolBindings`] to know whether this declaration is consistent with the previously
-    /// inferred type.
-    ///
-    /// If the definition is both a declaration and a binding -- `x: int = 1` for example -- then
-    /// we don't actually need anything here, all we'll need to validate is that our own RHS is a
-    /// valid assignment to our own annotation.
-    definitions_by_definition: FxHashMap<Definition<'db>, SymbolDefinitions>,
+    /// [`SymbolState`] visible at a [`ScopedUseId`].
+    definitions_by_use: IndexVec<ScopedUseId, SymbolState>,

    /// [`SymbolState`] visible at end of scope for each symbol.
-    public_symbols: IndexVec<ScopedSymbolId, SymbolState>,
+    public_definitions: IndexVec<ScopedSymbolId, SymbolState>,
 }

 impl<'db> UseDefMap<'db> {
-    pub(crate) fn bindings_at_use(
+    pub(crate) fn use_definitions(
        &self,
        use_id: ScopedUseId,
-    ) -> BindingWithConstraintsIterator<'_, 'db> {
-        self.bindings_iterator(&self.bindings_by_use[use_id])
+    ) -> DefinitionWithConstraintsIterator<'_, 'db> {
+        DefinitionWithConstraintsIterator {
+            all_definitions: &self.all_definitions,
+            all_constraints: &self.all_constraints,
+            inner: self.definitions_by_use[use_id].visible_definitions(),
+        }
    }

    pub(crate) fn use_may_be_unbound(&self, use_id: ScopedUseId) -> bool {
-        self.bindings_by_use[use_id].may_be_unbound()
+        self.definitions_by_use[use_id].may_be_unbound()
    }

-    pub(crate) fn public_bindings(
+    pub(crate) fn public_definitions(
        &self,
        symbol: ScopedSymbolId,
-    ) -> BindingWithConstraintsIterator<'_, 'db> {
-        self.bindings_iterator(self.public_symbols[symbol].bindings())
+    ) -> DefinitionWithConstraintsIterator<'_, 'db> {
+        DefinitionWithConstraintsIterator {
+            all_definitions: &self.all_definitions,
+            all_constraints: &self.all_constraints,
+            inner: self.public_definitions[symbol].visible_definitions(),
+        }
    }

    pub(crate) fn public_may_be_unbound(&self, symbol: ScopedSymbolId) -> bool {
-        self.public_symbols[symbol].may_be_unbound()
+        self.public_definitions[symbol].may_be_unbound()
    }
-
-    pub(crate) fn bindings_at_declaration(
-        &self,
-        declaration: Definition<'db>,
-    ) -> BindingWithConstraintsIterator<'_, 'db> {
-        if let SymbolDefinitions::Bindings(bindings) = &self.definitions_by_definition[&declaration]
-        {
-            self.bindings_iterator(bindings)
-        } else {
-            unreachable!("Declaration has non-Bindings in definitions_by_definition");
-        }
-    }
-
-    pub(crate) fn declarations_at_binding(
-        &self,
-        binding: Definition<'db>,
-    ) -> DeclarationsIterator<'_, 'db> {
-        if let SymbolDefinitions::Declarations(declarations) =
-            &self.definitions_by_definition[&binding]
-        {
-            self.declarations_iterator(declarations)
-        } else {
-            unreachable!("Binding has non-Declarations in definitions_by_definition");
-        }
-    }
-
-    pub(crate) fn public_declarations(
-        &self,
-        symbol: ScopedSymbolId,
-    ) -> DeclarationsIterator<'_, 'db> {
-        let declarations = self.public_symbols[symbol].declarations();
-        self.declarations_iterator(declarations)
-    }
-
-    pub(crate) fn has_public_declarations(&self, symbol: ScopedSymbolId) -> bool {
-        !self.public_symbols[symbol].declarations().is_empty()
-    }
-
-    fn bindings_iterator<'a>(
-        &'a self,
-        bindings: &'a SymbolBindings,
-    ) -> BindingWithConstraintsIterator<'a, 'db> {
-        BindingWithConstraintsIterator {
-            all_definitions: &self.all_definitions,
-            all_constraints: &self.all_constraints,
-            inner: bindings.iter(),
-        }
-    }
-
-    fn declarations_iterator<'a>(
-        &'a self,
-        declarations: &'a SymbolDeclarations,
-    ) -> DeclarationsIterator<'a, 'db> {
-        DeclarationsIterator {
-            all_definitions: &self.all_definitions,
-            inner: declarations.iter(),
-            may_be_undeclared: declarations.may_be_undeclared(),
-        }
-    }
-}
-
-/// Either live bindings or live declarations for a symbol.
-#[derive(Debug, PartialEq, Eq)]
-enum SymbolDefinitions {
-    Bindings(SymbolBindings),
-    Declarations(SymbolDeclarations),
 }

 #[derive(Debug)]
-pub(crate) struct BindingWithConstraintsIterator<'map, 'db> {
+pub(crate) struct DefinitionWithConstraintsIterator<'map, 'db> {
    all_definitions: &'map IndexVec<ScopedDefinitionId, Definition<'db>>,
-    all_constraints: &'map IndexVec<ScopedConstraintId, Constraint<'db>>,
-    inner: BindingIdWithConstraintsIterator<'map>,
+    all_constraints: &'map IndexVec<ScopedConstraintId, Expression<'db>>,
+    inner: DefinitionIdWithConstraintsIterator<'map>,
 }

-impl<'map, 'db> Iterator for BindingWithConstraintsIterator<'map, 'db> {
-    type Item = BindingWithConstraints<'map, 'db>;
+impl<'map, 'db> Iterator for DefinitionWithConstraintsIterator<'map, 'db> {
+    type Item = DefinitionWithConstraints<'map, 'db>;

    fn next(&mut self) -> Option<Self::Item> {
        self.inner
            .next()
-            .map(|def_id_with_constraints| BindingWithConstraints {
-                binding: self.all_definitions[def_id_with_constraints.definition],
+            .map(|def_id_with_constraints| DefinitionWithConstraints {
+                definition: self.all_definitions[def_id_with_constraints.definition],
                constraints: ConstraintsIterator {
                    all_constraints: self.all_constraints,
                    constraint_ids: def_id_with_constraints.constraint_ids,
@@ -379,20 +224,20 @@ impl<'map, 'db> Iterator for BindingWithConstraintsIterator<'map, 'db> {
    }
 }

-impl std::iter::FusedIterator for BindingWithConstraintsIterator<'_, '_> {}
+impl std::iter::FusedIterator for DefinitionWithConstraintsIterator<'_, '_> {}

-pub(crate) struct BindingWithConstraints<'map, 'db> {
-    pub(crate) binding: Definition<'db>,
+pub(crate) struct DefinitionWithConstraints<'map, 'db> {
+    pub(crate) definition: Definition<'db>,
    pub(crate) constraints: ConstraintsIterator<'map, 'db>,
 }

 pub(crate) struct ConstraintsIterator<'map, 'db> {
-    all_constraints: &'map IndexVec<ScopedConstraintId, Constraint<'db>>,
+    all_constraints: &'map IndexVec<ScopedConstraintId, Expression<'db>>,
    constraint_ids: ConstraintIdIterator<'map>,
 }

 impl<'map, 'db> Iterator for ConstraintsIterator<'map, 'db> {
-    type Item = Constraint<'db>;
+    type Item = Expression<'db>;

    fn next(&mut self) -> Option<Self::Item> {
        self.constraint_ids
@@ -403,50 +248,25 @@ impl<'map, 'db> Iterator for ConstraintsIterator<'map, 'db> {

 impl std::iter::FusedIterator for ConstraintsIterator<'_, '_> {}

-pub(crate) struct DeclarationsIterator<'map, 'db> {
-    all_definitions: &'map IndexVec<ScopedDefinitionId, Definition<'db>>,
-    inner: DeclarationIdIterator<'map>,
-    may_be_undeclared: bool,
-}
-
-impl DeclarationsIterator<'_, '_> {
-    pub(crate) fn may_be_undeclared(&self) -> bool {
-        self.may_be_undeclared
-    }
-}
-
-impl<'map, 'db> Iterator for DeclarationsIterator<'map, 'db> {
-    type Item = Definition<'db>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner.next().map(|def_id| self.all_definitions[def_id])
-    }
-}
-
-impl std::iter::FusedIterator for DeclarationsIterator<'_, '_> {}
-
 /// A snapshot of the definitions and constraints state at a particular point in control flow.
 #[derive(Clone, Debug)]
 pub(super) struct FlowSnapshot {
-    symbol_states: IndexVec<ScopedSymbolId, SymbolState>,
+    definitions_by_symbol: IndexVec<ScopedSymbolId, SymbolState>,
 }

 #[derive(Debug, Default)]
 pub(super) struct UseDefMapBuilder<'db> {
-    /// Append-only array of [`Definition`].
+    /// Append-only array of [`Definition`]; None is unbound.
    all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,

-    /// Append-only array of [`Constraint`].
-    all_constraints: IndexVec<ScopedConstraintId, Constraint<'db>>,
+    /// Append-only array of constraints (as [`Expression`]).
+    all_constraints: IndexVec<ScopedConstraintId, Expression<'db>>,

-    /// Live bindings at each so-far-recorded use.
-    bindings_by_use: IndexVec<ScopedUseId, SymbolBindings>,
+    /// Visible definitions at each so-far-recorded use.
+    definitions_by_use: IndexVec<ScopedUseId, SymbolState>,

-    /// Live bindings or declarations for each so-far-recorded definition.
-    definitions_by_definition: FxHashMap<Definition<'db>, SymbolDefinitions>,
-
-    /// Currently live bindings and declarations for each symbol.
-    symbol_states: IndexVec<ScopedSymbolId, SymbolState>,
+    /// Currently visible definitions for each symbol.
+    definitions_by_symbol: IndexVec<ScopedSymbolId, SymbolState>,
 }

 impl<'db> UseDefMapBuilder<'db> {
@@ -455,104 +275,86 @@ impl<'db> UseDefMapBuilder<'db> {
    }

    pub(super) fn add_symbol(&mut self, symbol: ScopedSymbolId) {
-        let new_symbol = self.symbol_states.push(SymbolState::undefined());
+        let new_symbol = self.definitions_by_symbol.push(SymbolState::unbound());
        debug_assert_eq!(symbol, new_symbol);
    }

-    pub(super) fn record_binding(&mut self, symbol: ScopedSymbolId, binding: Definition<'db>) {
-        let def_id = self.all_definitions.push(binding);
-        let symbol_state = &mut self.symbol_states[symbol];
-        self.definitions_by_definition.insert(
-            binding,
-            SymbolDefinitions::Declarations(symbol_state.declarations().clone()),
-        );
-        symbol_state.record_binding(def_id);
-    }
-
-    pub(super) fn record_constraint(&mut self, constraint: Constraint<'db>) {
-        let constraint_id = self.all_constraints.push(constraint);
-        for state in &mut self.symbol_states {
-            state.record_constraint(constraint_id);
-        }
-    }
-
-    pub(super) fn record_declaration(
-        &mut self,
-        symbol: ScopedSymbolId,
-        declaration: Definition<'db>,
-    ) {
-        let def_id = self.all_definitions.push(declaration);
-        let symbol_state = &mut self.symbol_states[symbol];
-        self.definitions_by_definition.insert(
-            declaration,
-            SymbolDefinitions::Bindings(symbol_state.bindings().clone()),
-        );
-        symbol_state.record_declaration(def_id);
-    }
-
-    pub(super) fn record_declaration_and_binding(
+    pub(super) fn record_definition(
        &mut self,
        symbol: ScopedSymbolId,
        definition: Definition<'db>,
    ) {
-        // We don't need to store anything in self.definitions_by_definition.
+        // We have a new definition of a symbol; this replaces any previous definitions in this
+        // path.
        let def_id = self.all_definitions.push(definition);
-        let symbol_state = &mut self.symbol_states[symbol];
-        symbol_state.record_declaration(def_id);
-        symbol_state.record_binding(def_id);
+        self.definitions_by_symbol[symbol] = SymbolState::with(def_id);
+    }
+
+    pub(super) fn record_constraint(&mut self, constraint: Expression<'db>) {
+        let constraint_id = self.all_constraints.push(constraint);
+        for definitions in &mut self.definitions_by_symbol {
+            definitions.add_constraint(constraint_id);
+        }
    }

    pub(super) fn record_use(&mut self, symbol: ScopedSymbolId, use_id: ScopedUseId) {
-        // We have a use of a symbol; clone the current bindings for that symbol, and record them
-        // as the live bindings for this use.
+        // We have a use of a symbol; clone the currently visible definitions for that symbol, and
+        // record them as the visible definitions for this use.
        let new_use = self
-            .bindings_by_use
-            .push(self.symbol_states[symbol].bindings().clone());
+            .definitions_by_use
+            .push(self.definitions_by_symbol[symbol].clone());
        debug_assert_eq!(use_id, new_use);
    }

    /// Take a snapshot of the current visible-symbols state.
    pub(super) fn snapshot(&self) -> FlowSnapshot {
        FlowSnapshot {
-            symbol_states: self.symbol_states.clone(),
+            definitions_by_symbol: self.definitions_by_symbol.clone(),
        }
    }

-    /// Restore the current builder symbols state to the given snapshot.
+    /// Restore the current builder visible-definitions state to the given snapshot.
    pub(super) fn restore(&mut self, snapshot: FlowSnapshot) {
-        // We never remove symbols from `symbol_states` (it's an IndexVec, and the symbol
+        // We never remove symbols from `definitions_by_symbol` (it's an IndexVec, and the symbol
        // IDs must line up), so the current number of known symbols must always be equal to or
        // greater than the number of known symbols in a previously-taken snapshot.
-        let num_symbols = self.symbol_states.len();
-        debug_assert!(num_symbols >= snapshot.symbol_states.len());
+        let num_symbols = self.definitions_by_symbol.len();
+        debug_assert!(num_symbols >= snapshot.definitions_by_symbol.len());

        // Restore the current visible-definitions state to the given snapshot.
-        self.symbol_states = snapshot.symbol_states;
+        self.definitions_by_symbol = snapshot.definitions_by_symbol;

        // If the snapshot we are restoring is missing some symbols we've recorded since, we need
        // to fill them in so the symbol IDs continue to line up. Since they don't exist in the
-        // snapshot, the correct state to fill them in with is "undefined".
-        self.symbol_states
-            .resize(num_symbols, SymbolState::undefined());
+        // snapshot, the correct state to fill them in with is "unbound".
+        self.definitions_by_symbol
+            .resize(num_symbols, SymbolState::unbound());
    }

    /// Merge the given snapshot into the current state, reflecting that we might have taken either
-    /// path to get here. The new state for each symbol should include definitions from both the
-    /// prior state and the snapshot.
+    /// path to get here. The new visible-definitions state for each symbol should include
+    /// definitions from both the prior state and the snapshot.
    pub(super) fn merge(&mut self, snapshot: FlowSnapshot) {
-        // We never remove symbols from `symbol_states` (it's an IndexVec, and the symbol
+        // The tricky thing about merging two Ranges pointing into `all_definitions` is that if the
+        // two Ranges aren't already adjacent in `all_definitions`, we will have to copy at least
+        // one or the other of the ranges to the end of `all_definitions` so as to make them
+        // adjacent. We can't ever move things around in `all_definitions` because previously
+        // recorded uses may still have ranges pointing to any part of it; all we can do is append.
+        // It's possible we may end up with some old entries in `all_definitions` that nobody is
+        // pointing to, but that's OK.
+
+        // We never remove symbols from `definitions_by_symbol` (it's an IndexVec, and the symbol
        // IDs must line up), so the current number of known symbols must always be equal to or
        // greater than the number of known symbols in a previously-taken snapshot.
-        debug_assert!(self.symbol_states.len() >= snapshot.symbol_states.len());
+        debug_assert!(self.definitions_by_symbol.len() >= snapshot.definitions_by_symbol.len());

-        let mut snapshot_definitions_iter = snapshot.symbol_states.into_iter();
-        for current in &mut self.symbol_states {
+        let mut snapshot_definitions_iter = snapshot.definitions_by_symbol.into_iter();
+        for current in &mut self.definitions_by_symbol {
            if let Some(snapshot) = snapshot_definitions_iter.next() {
                current.merge(snapshot);
            } else {
-                // Symbol not present in snapshot, so it's unbound/undeclared from that path.
-                current.set_may_be_unbound();
-                current.set_may_be_undeclared();
+                // Symbol not present in snapshot, so it's unbound from that path.
+                current.add_unbound();
            }
        }
    }
@@ -560,16 +362,14 @@ impl<'db> UseDefMapBuilder<'db> {
    pub(super) fn finish(mut self) -> UseDefMap<'db> {
        self.all_definitions.shrink_to_fit();
        self.all_constraints.shrink_to_fit();
-        self.symbol_states.shrink_to_fit();
-        self.bindings_by_use.shrink_to_fit();
-        self.definitions_by_definition.shrink_to_fit();
+        self.definitions_by_symbol.shrink_to_fit();
+        self.definitions_by_use.shrink_to_fit();

        UseDefMap {
            all_definitions: self.all_definitions,
            all_constraints: self.all_constraints,
-            bindings_by_use: self.bindings_by_use,
-            public_symbols: self.symbol_states,
-            definitions_by_definition: self.definitions_by_definition,
+            definitions_by_use: self.definitions_by_use,
+            public_definitions: self.definitions_by_symbol,
        }
    }
 }
--- a/crates/red_knot_python_semantic/src/semantic_index/use_def/bitset.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/use_def/bitset.rs
@@ -32,25 +32,17 @@ impl<const B: usize> BitSet<B> {
        bitset
    }

-    pub(super) fn is_empty(&self) -> bool {
-        self.blocks().iter().all(|&b| b == 0)
-    }
-
    /// Convert from Inline to Heap, if needed, and resize the Heap vector, if needed.
    fn resize(&mut self, value: u32) {
        let num_blocks_needed = (value / 64) + 1;
-        self.resize_blocks(num_blocks_needed as usize);
-    }
-
-    fn resize_blocks(&mut self, num_blocks_needed: usize) {
        match self {
            Self::Inline(blocks) => {
                let mut vec = blocks.to_vec();
-                vec.resize(num_blocks_needed, 0);
+                vec.resize(num_blocks_needed as usize, 0);
                *self = Self::Heap(vec);
            }
            Self::Heap(vec) => {
-                vec.resize(num_blocks_needed, 0);
+                vec.resize(num_blocks_needed as usize, 0);
            }
        }
    }
@@ -97,19 +89,6 @@ impl<const B: usize> BitSet<B> {
        }
    }

-    /// Union in-place with another [`BitSet`].
-    pub(super) fn union(&mut self, other: &BitSet<B>) {
-        let mut max_len = self.blocks().len();
-        let other_len = other.blocks().len();
-        if other_len > max_len {
-            max_len = other_len;
-            self.resize_blocks(max_len);
-        }
-        for (my_block, other_block) in self.blocks_mut().iter_mut().zip(other.blocks()) {
-            *my_block |= other_block;
-        }
-    }
-
    /// Return an iterator over the values (in ascending order) in this [`BitSet`].
    pub(super) fn iter(&self) -> BitSetIterator<'_, B> {
        let blocks = self.blocks();
@@ -239,59 +218,6 @@ mod tests {
        assert_bitset(&b1, &[89]);
    }

-    #[test]
-    fn union() {
-        let mut b1 = BitSet::<1>::with(2);
-        let b2 = BitSet::<1>::with(4);
-
-        b1.union(&b2);
-        assert_bitset(&b1, &[2, 4]);
-    }
-
-    #[test]
-    fn union_mixed_1() {
-        let mut b1 = BitSet::<1>::with(4);
-        let mut b2 = BitSet::<1>::with(4);
-        b1.insert(89);
-        b2.insert(5);
-
-        b1.union(&b2);
-        assert_bitset(&b1, &[4, 5, 89]);
-    }
-
-    #[test]
-    fn union_mixed_2() {
-        let mut b1 = BitSet::<1>::with(4);
-        let mut b2 = BitSet::<1>::with(4);
-        b1.insert(23);
-        b2.insert(89);
-
-        b1.union(&b2);
-        assert_bitset(&b1, &[4, 23, 89]);
-    }
-
-    #[test]
-    fn union_heap() {
-        let mut b1 = BitSet::<1>::with(4);
-        let mut b2 = BitSet::<1>::with(4);
-        b1.insert(89);
-        b2.insert(90);
-
-        b1.union(&b2);
-        assert_bitset(&b1, &[4, 89, 90]);
-    }
-
-    #[test]
-    fn union_heap_2() {
-        let mut b1 = BitSet::<1>::with(89);
-        let mut b2 = BitSet::<1>::with(89);
-        b1.insert(91);
-        b2.insert(90);
-
-        b1.union(&b2);
-        assert_bitset(&b1, &[89, 90, 91]);
-    }
-
    #[test]
    fn multiple_blocks() {
        let mut b = BitSet::<2>::with(120);
@@ -299,11 +225,4 @@ mod tests {
        assert!(matches!(b, BitSet::Inline(_)));
        assert_bitset(&b, &[45, 120]);
    }
-
-    #[test]
-    fn empty() {
-        let b = BitSet::<1>::default();
-
-        assert!(b.is_empty());
-    }
 }
--- a/crates/red_knot_python_semantic/src/semantic_index/use_def/symbol_state.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/use_def/symbol_state.rs
@@ -1,13 +1,13 @@
-//! Track live bindings per symbol, applicable constraints per binding, and live declarations.
+//! Track visible definitions of a symbol, and applicable constraints per definition.
 //!
 //! These data structures operate entirely on scope-local newtype-indices for definitions and
 //! constraints, referring to their location in the `all_definitions` and `all_constraints`
 //! indexvecs in [`super::UseDefMapBuilder`].
 //!
-//! We need to track arbitrary associations between bindings and constraints, not just a single set
-//! of currently dominating constraints (where "dominating" means "control flow must have passed
-//! through it to reach this point"), because we can have dominating constraints that apply to some
-//! bindings but not others, as in this code:
+//! We need to track arbitrary associations between definitions and constraints, not just a single
+//! set of currently dominating constraints (where "dominating" means "control flow must have
+//! passed through it to reach this point"), because we can have dominating constraints that apply
+//! to some definitions but not others, as in this code:
 //!
 //! ```python
 //! x = 1 if flag else None
@@ -18,11 +18,11 @@
 //! ```
 //!
 //! The `x is not None` constraint dominates the final use of `x`, but it applies only to the first
-//! binding of `x`, not the second, so `None` is a possible value for `x`.
+//! definition of `x`, not the second, so `None` is a possible value for `x`.
 //!
-//! And we can't just track, for each binding, an index into a list of dominating constraints,
-//! either, because we can have bindings which are still visible, but subject to constraints that
-//! are no longer dominating, as in this code:
+//! And we can't just track, for each definition, an index into a list of dominating constraints,
+//! either, because we can have definitions which are still visible, but subject to constraints
+//! that are no longer dominating, as in this code:
 //!
 //! ```python
 //! x = 0
@@ -33,16 +33,13 @@
 //! ```
 //!
 //! From the point of view of the final use of `x`, the `x is not None` constraint no longer
-//! dominates, but it does dominate the `x = 1 if flag2 else None` binding, so we have to keep
+//! dominates, but it does dominate the `x = 1 if flag2 else None` definition, so we have to keep
 //! track of that.
 //!
 //! The data structures used here ([`BitSet`] and [`smallvec::SmallVec`]) optimize for keeping all
 //! data inline (avoiding lots of scattered allocations) in small-to-medium cases, and falling back
-//! to heap allocation to be able to scale to arbitrary numbers of live bindings and constraints
-//! when needed.
-//!
-//! Tracking live declarations is simpler, since constraints are not involved, but otherwise very
-//! similar to tracking live bindings.
+//! to heap allocation to be able to scale to arbitrary numbers of definitions and constraints when
+//! needed.
 use super::bitset::{BitSet, BitSetIterator};
 use ruff_index::newtype_index;
 use smallvec::SmallVec;
@@ -56,200 +53,93 @@ pub(super) struct ScopedDefinitionId;
 pub(super) struct ScopedConstraintId;

 /// Can reference this * 64 total definitions inline; more will fall back to the heap.
-const INLINE_BINDING_BLOCKS: usize = 3;
+const INLINE_DEFINITION_BLOCKS: usize = 3;

-/// A [`BitSet`] of [`ScopedDefinitionId`], representing live bindings of a symbol in a scope.
-type Bindings = BitSet<INLINE_BINDING_BLOCKS>;
-type BindingsIterator<'a> = BitSetIterator<'a, INLINE_BINDING_BLOCKS>;
-
-/// Can reference this * 64 total declarations inline; more will fall back to the heap.
-const INLINE_DECLARATION_BLOCKS: usize = 3;
-
-/// A [`BitSet`] of [`ScopedDefinitionId`], representing live declarations of a symbol in a scope.
-type Declarations = BitSet<INLINE_DECLARATION_BLOCKS>;
-type DeclarationsIterator<'a> = BitSetIterator<'a, INLINE_DECLARATION_BLOCKS>;
+/// A [`BitSet`] of [`ScopedDefinitionId`], representing visible definitions of a symbol in a scope.
+type Definitions = BitSet<INLINE_DEFINITION_BLOCKS>;
+type DefinitionsIterator<'a> = BitSetIterator<'a, INLINE_DEFINITION_BLOCKS>;

 /// Can reference this * 64 total constraints inline; more will fall back to the heap.
 const INLINE_CONSTRAINT_BLOCKS: usize = 2;

-/// Can keep inline this many live bindings per symbol at a given time; more will go to heap.
-const INLINE_BINDINGS_PER_SYMBOL: usize = 4;
+/// Can keep inline this many visible definitions per symbol at a given time; more will go to heap.
+const INLINE_VISIBLE_DEFINITIONS_PER_SYMBOL: usize = 4;

-/// One [`BitSet`] of applicable [`ScopedConstraintId`] per live binding.
-type InlineConstraintArray = [BitSet<INLINE_CONSTRAINT_BLOCKS>; INLINE_BINDINGS_PER_SYMBOL];
+/// One [`BitSet`] of applicable [`ScopedConstraintId`] per visible definition.
+type InlineConstraintArray =
+    [BitSet<INLINE_CONSTRAINT_BLOCKS>; INLINE_VISIBLE_DEFINITIONS_PER_SYMBOL];
 type Constraints = SmallVec<InlineConstraintArray>;
 type ConstraintsIterator<'a> = std::slice::Iter<'a, BitSet<INLINE_CONSTRAINT_BLOCKS>>;
 type ConstraintsIntoIterator = smallvec::IntoIter<InlineConstraintArray>;

-/// Live declarations for a single symbol at some point in control flow.
+/// Visible definitions and narrowing constraints for a single symbol at some point in control flow.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub(super) struct SymbolDeclarations {
-    /// [`BitSet`]: which declarations (as [`ScopedDefinitionId`]) can reach the current location?
-    live_declarations: Declarations,
+pub(super) struct SymbolState {
+    /// [`BitSet`]: which [`ScopedDefinitionId`] are visible for this symbol?
+    visible_definitions: Definitions,

-    /// Could the symbol be un-declared at this point?
-    may_be_undeclared: bool,
-}
-
-impl SymbolDeclarations {
-    fn undeclared() -> Self {
-        Self {
-            live_declarations: Declarations::default(),
-            may_be_undeclared: true,
-        }
-    }
-
-    /// Record a newly-encountered declaration for this symbol.
-    fn record_declaration(&mut self, declaration_id: ScopedDefinitionId) {
-        self.live_declarations = Declarations::with(declaration_id.into());
-        self.may_be_undeclared = false;
-    }
-
-    /// Add undeclared as a possibility for this symbol.
-    fn set_may_be_undeclared(&mut self) {
-        self.may_be_undeclared = true;
-    }
-
-    /// Return an iterator over live declarations for this symbol.
-    pub(super) fn iter(&self) -> DeclarationIdIterator {
-        DeclarationIdIterator {
-            inner: self.live_declarations.iter(),
-        }
-    }
-
-    pub(super) fn is_empty(&self) -> bool {
-        self.live_declarations.is_empty()
-    }
-
-    pub(super) fn may_be_undeclared(&self) -> bool {
-        self.may_be_undeclared
-    }
-}
-
-/// Live bindings and narrowing constraints for a single symbol at some point in control flow.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(super) struct SymbolBindings {
-    /// [`BitSet`]: which bindings (as [`ScopedDefinitionId`]) can reach the current location?
-    live_bindings: Bindings,
-
-    /// For each live binding, which [`ScopedConstraintId`] apply?
+    /// For each definition, which [`ScopedConstraintId`] apply?
    ///
    /// This is a [`smallvec::SmallVec`] which should always have one [`BitSet`] of constraints per
-    /// binding in `live_bindings`.
+    /// definition in `visible_definitions`.
    constraints: Constraints,

    /// Could the symbol be unbound at this point?
    may_be_unbound: bool,
 }

-impl SymbolBindings {
-    fn unbound() -> Self {
+/// A single [`ScopedDefinitionId`] with an iterator of its applicable [`ScopedConstraintId`].
+#[derive(Debug)]
+pub(super) struct DefinitionIdWithConstraints<'a> {
+    pub(super) definition: ScopedDefinitionId,
+    pub(super) constraint_ids: ConstraintIdIterator<'a>,
+}
+
+impl SymbolState {
+    /// Return a new [`SymbolState`] representing an unbound symbol.
+    pub(super) fn unbound() -> Self {
        Self {
-            live_bindings: Bindings::default(),
+            visible_definitions: Definitions::default(),
            constraints: Constraints::default(),
            may_be_unbound: true,
        }
    }

+    /// Return a new [`SymbolState`] representing a symbol with a single visible definition.
+    pub(super) fn with(definition_id: ScopedDefinitionId) -> Self {
+        let mut constraints = Constraints::with_capacity(1);
+        constraints.push(BitSet::default());
+        Self {
+            visible_definitions: Definitions::with(definition_id.into()),
+            constraints,
+            may_be_unbound: false,
+        }
+    }
+
    /// Add Unbound as a possibility for this symbol.
-    fn set_may_be_unbound(&mut self) {
+    pub(super) fn add_unbound(&mut self) {
        self.may_be_unbound = true;
    }

-    /// Record a newly-encountered binding for this symbol.
-    pub(super) fn record_binding(&mut self, binding_id: ScopedDefinitionId) {
-        // The new binding replaces all previous live bindings in this path, and has no
-        // constraints.
-        self.live_bindings = Bindings::with(binding_id.into());
-        self.constraints = Constraints::with_capacity(1);
-        self.constraints.push(BitSet::default());
-        self.may_be_unbound = false;
-    }
-
-    /// Add given constraint to all live bindings.
-    pub(super) fn record_constraint(&mut self, constraint_id: ScopedConstraintId) {
+    /// Add given constraint to all currently-visible definitions.
+    pub(super) fn add_constraint(&mut self, constraint_id: ScopedConstraintId) {
        for bitset in &mut self.constraints {
            bitset.insert(constraint_id.into());
        }
    }

-    /// Iterate over currently live bindings for this symbol.
-    pub(super) fn iter(&self) -> BindingIdWithConstraintsIterator {
-        BindingIdWithConstraintsIterator {
-            definitions: self.live_bindings.iter(),
-            constraints: self.constraints.iter(),
-        }
-    }
-
-    pub(super) fn may_be_unbound(&self) -> bool {
-        self.may_be_unbound
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(super) struct SymbolState {
-    declarations: SymbolDeclarations,
-    bindings: SymbolBindings,
-}
-
-impl SymbolState {
-    /// Return a new [`SymbolState`] representing an unbound, undeclared symbol.
-    pub(super) fn undefined() -> Self {
-        Self {
-            declarations: SymbolDeclarations::undeclared(),
-            bindings: SymbolBindings::unbound(),
-        }
-    }
-
-    /// Add Unbound as a possibility for this symbol.
-    pub(super) fn set_may_be_unbound(&mut self) {
-        self.bindings.set_may_be_unbound();
-    }
-
-    /// Record a newly-encountered binding for this symbol.
-    pub(super) fn record_binding(&mut self, binding_id: ScopedDefinitionId) {
-        self.bindings.record_binding(binding_id);
-    }
-
-    /// Add given constraint to all live bindings.
-    pub(super) fn record_constraint(&mut self, constraint_id: ScopedConstraintId) {
-        self.bindings.record_constraint(constraint_id);
-    }
-
-    /// Add undeclared as a possibility for this symbol.
-    pub(super) fn set_may_be_undeclared(&mut self) {
-        self.declarations.set_may_be_undeclared();
-    }
-
-    /// Record a newly-encountered declaration of this symbol.
-    pub(super) fn record_declaration(&mut self, declaration_id: ScopedDefinitionId) {
-        self.declarations.record_declaration(declaration_id);
-    }
-
    /// Merge another [`SymbolState`] into this one.
    pub(super) fn merge(&mut self, b: SymbolState) {
        let mut a = Self {
-            bindings: SymbolBindings {
-                live_bindings: Bindings::default(),
-                constraints: Constraints::default(),
-                may_be_unbound: self.bindings.may_be_unbound || b.bindings.may_be_unbound,
-            },
-            declarations: SymbolDeclarations {
-                live_declarations: self.declarations.live_declarations.clone(),
-                may_be_undeclared: self.declarations.may_be_undeclared
-                    || b.declarations.may_be_undeclared,
-            },
+            visible_definitions: Definitions::default(),
+            constraints: Constraints::default(),
+            may_be_unbound: self.may_be_unbound || b.may_be_unbound,
        };
-
        std::mem::swap(&mut a, self);
-        self.declarations
-            .live_declarations
-            .union(&b.declarations.live_declarations);
-
-        let mut a_defs_iter = a.bindings.live_bindings.iter();
-        let mut b_defs_iter = b.bindings.live_bindings.iter();
-        let mut a_constraints_iter = a.bindings.constraints.into_iter();
-        let mut b_constraints_iter = b.bindings.constraints.into_iter();
+        let mut a_defs_iter = a.visible_definitions.iter();
+        let mut b_defs_iter = b.visible_definitions.iter();
+        let mut a_constraints_iter = a.constraints.into_iter();
+        let mut b_constraints_iter = b.constraints.into_iter();

        let mut opt_a_def: Option<u32> = a_defs_iter.next();
        let mut opt_b_def: Option<u32> = b_defs_iter.next();
@@ -262,7 +152,7 @@ impl SymbolState {

        // Helper to push `def`, with constraints in `constraints_iter`, onto `self`.
        let push = |def, constraints_iter: &mut ConstraintsIntoIterator, merged: &mut Self| {
-            merged.bindings.live_bindings.insert(def);
+            merged.visible_definitions.insert(def);
            // SAFETY: we only ever create SymbolState with either no definitions and no constraint
            // bitsets (`::unbound`) or one definition and one constraint bitset (`::with`), and
            // `::merge` always pushes one definition and one constraint bitset together (just
@@ -271,7 +161,7 @@ impl SymbolState {
            let constraints = constraints_iter
                .next()
                .expect("definitions and constraints length mismatch");
-            merged.bindings.constraints.push(constraints);
+            merged.constraints.push(constraints);
        };

        loop {
@@ -301,8 +191,7 @@ impl SymbolState {
                        // If the same definition is visible through both paths, any constraint
                        // that applies on only one path is irrelevant to the resulting type from
                        // unioning the two paths, so we intersect the constraints.
-                        self.bindings
-                            .constraints
+                        self.constraints
                            .last_mut()
                            .unwrap()
                            .intersect(&a_constraints);
@@ -325,49 +214,40 @@ impl SymbolState {
        }
    }

-    pub(super) fn bindings(&self) -> &SymbolBindings {
-        &self.bindings
-    }
-
-    pub(super) fn declarations(&self) -> &SymbolDeclarations {
-        &self.declarations
+    /// Get iterator over visible definitions with constraints.
+    pub(super) fn visible_definitions(&self) -> DefinitionIdWithConstraintsIterator {
+        DefinitionIdWithConstraintsIterator {
+            definitions: self.visible_definitions.iter(),
+            constraints: self.constraints.iter(),
+        }
    }

    /// Could the symbol be unbound?
    pub(super) fn may_be_unbound(&self) -> bool {
-        self.bindings.may_be_unbound()
+        self.may_be_unbound
    }
 }

-/// The default state of a symbol, if we've seen no definitions of it, is undefined (that is,
-/// both unbound and undeclared).
+/// The default state of a symbol (if we've seen no definitions of it) is unbound.
 impl Default for SymbolState {
    fn default() -> Self {
-        SymbolState::undefined()
+        SymbolState::unbound()
    }
 }

-/// A single binding (as [`ScopedDefinitionId`]) with an iterator of its applicable
-/// [`ScopedConstraintId`].
 #[derive(Debug)]
-pub(super) struct BindingIdWithConstraints<'a> {
-    pub(super) definition: ScopedDefinitionId,
-    pub(super) constraint_ids: ConstraintIdIterator<'a>,
-}
-
-#[derive(Debug)]
-pub(super) struct BindingIdWithConstraintsIterator<'a> {
-    definitions: BindingsIterator<'a>,
+pub(super) struct DefinitionIdWithConstraintsIterator<'a> {
+    definitions: DefinitionsIterator<'a>,
    constraints: ConstraintsIterator<'a>,
 }

-impl<'a> Iterator for BindingIdWithConstraintsIterator<'a> {
-    type Item = BindingIdWithConstraints<'a>;
+impl<'a> Iterator for DefinitionIdWithConstraintsIterator<'a> {
+    type Item = DefinitionIdWithConstraints<'a>;

    fn next(&mut self) -> Option<Self::Item> {
        match (self.definitions.next(), self.constraints.next()) {
            (None, None) => None,
-            (Some(def), Some(constraints)) => Some(BindingIdWithConstraints {
+            (Some(def), Some(constraints)) => Some(DefinitionIdWithConstraints {
                definition: ScopedDefinitionId::from_u32(def),
                constraint_ids: ConstraintIdIterator {
                    wrapped: constraints.iter(),
@@ -379,7 +259,7 @@ impl<'a> Iterator for BindingIdWithConstraintsIterator<'a> {
    }
 }

-impl std::iter::FusedIterator for BindingIdWithConstraintsIterator<'_> {}
+impl std::iter::FusedIterator for DefinitionIdWithConstraintsIterator<'_> {}

 #[derive(Debug)]
 pub(super) struct ConstraintIdIterator<'a> {
@@ -396,193 +276,99 @@ impl Iterator for ConstraintIdIterator<'_> {

 impl std::iter::FusedIterator for ConstraintIdIterator<'_> {}

-#[derive(Debug)]
-pub(super) struct DeclarationIdIterator<'a> {
-    inner: DeclarationsIterator<'a>,
-}
-
-impl<'a> Iterator for DeclarationIdIterator<'a> {
-    type Item = ScopedDefinitionId;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner.next().map(ScopedDefinitionId::from_u32)
-    }
-}
-
-impl std::iter::FusedIterator for DeclarationIdIterator<'_> {}
-
 #[cfg(test)]
 mod tests {
    use super::{ScopedConstraintId, ScopedDefinitionId, SymbolState};

-    fn assert_bindings(symbol: &SymbolState, may_be_unbound: bool, expected: &[&str]) {
-        assert_eq!(symbol.may_be_unbound(), may_be_unbound);
-        let actual = symbol
-            .bindings()
-            .iter()
-            .map(|def_id_with_constraints| {
-                format!(
-                    "{}<{}>",
-                    def_id_with_constraints.definition.as_u32(),
-                    def_id_with_constraints
-                        .constraint_ids
-                        .map(ScopedConstraintId::as_u32)
-                        .map(|idx| idx.to_string())
-                        .collect::<Vec<_>>()
-                        .join(", ")
-                )
-            })
-            .collect::<Vec<_>>();
-        assert_eq!(actual, expected);
-    }
-
-    pub(crate) fn assert_declarations(
-        symbol: &SymbolState,
-        may_be_undeclared: bool,
-        expected: &[u32],
-    ) {
-        assert_eq!(symbol.declarations.may_be_undeclared(), may_be_undeclared);
-        let actual = symbol
-            .declarations()
-            .iter()
-            .map(ScopedDefinitionId::as_u32)
-            .collect::<Vec<_>>();
-        assert_eq!(actual, expected);
+    impl SymbolState {
+        pub(crate) fn assert(&self, may_be_unbound: bool, expected: &[&str]) {
+            assert_eq!(self.may_be_unbound(), may_be_unbound);
+            let actual = self
+                .visible_definitions()
+                .map(|def_id_with_constraints| {
+                    format!(
+                        "{}<{}>",
+                        def_id_with_constraints.definition.as_u32(),
+                        def_id_with_constraints
+                            .constraint_ids
+                            .map(ScopedConstraintId::as_u32)
+                            .map(|idx| idx.to_string())
+                            .collect::<Vec<_>>()
+                            .join(", ")
+                    )
+                })
+                .collect::<Vec<_>>();
+            assert_eq!(actual, expected);
+        }
    }

    #[test]
    fn unbound() {
-        let sym = SymbolState::undefined();
+        let cd = SymbolState::unbound();

-        assert_bindings(&sym, true, &[]);
+        cd.assert(true, &[]);
    }

    #[test]
    fn with() {
-        let mut sym = SymbolState::undefined();
-        sym.record_binding(ScopedDefinitionId::from_u32(0));
+        let cd = SymbolState::with(ScopedDefinitionId::from_u32(0));

-        assert_bindings(&sym, false, &["0<>"]);
+        cd.assert(false, &["0<>"]);
    }

    #[test]
-    fn set_may_be_unbound() {
-        let mut sym = SymbolState::undefined();
-        sym.record_binding(ScopedDefinitionId::from_u32(0));
-        sym.set_may_be_unbound();
+    fn add_unbound() {
+        let mut cd = SymbolState::with(ScopedDefinitionId::from_u32(0));
+        cd.add_unbound();

-        assert_bindings(&sym, true, &["0<>"]);
+        cd.assert(true, &["0<>"]);
    }

    #[test]
-    fn record_constraint() {
-        let mut sym = SymbolState::undefined();
-        sym.record_binding(ScopedDefinitionId::from_u32(0));
-        sym.record_constraint(ScopedConstraintId::from_u32(0));
+    fn add_constraint() {
+        let mut cd = SymbolState::with(ScopedDefinitionId::from_u32(0));
+        cd.add_constraint(ScopedConstraintId::from_u32(0));

-        assert_bindings(&sym, false, &["0<0>"]);
+        cd.assert(false, &["0<0>"]);
    }

    #[test]
    fn merge() {
        // merging the same definition with the same constraint keeps the constraint
-        let mut sym0a = SymbolState::undefined();
-        sym0a.record_binding(ScopedDefinitionId::from_u32(0));
-        sym0a.record_constraint(ScopedConstraintId::from_u32(0));
+        let mut cd0a = SymbolState::with(ScopedDefinitionId::from_u32(0));
+        cd0a.add_constraint(ScopedConstraintId::from_u32(0));

-        let mut sym0b = SymbolState::undefined();
-        sym0b.record_binding(ScopedDefinitionId::from_u32(0));
-        sym0b.record_constraint(ScopedConstraintId::from_u32(0));
+        let mut cd0b = SymbolState::with(ScopedDefinitionId::from_u32(0));
+        cd0b.add_constraint(ScopedConstraintId::from_u32(0));

-        sym0a.merge(sym0b);
-        let mut sym0 = sym0a;
-        assert_bindings(&sym0, false, &["0<0>"]);
+        cd0a.merge(cd0b);
+        let mut cd0 = cd0a;
+        cd0.assert(false, &["0<0>"]);

        // merging the same definition with differing constraints drops all constraints
-        let mut sym1a = SymbolState::undefined();
-        sym1a.record_binding(ScopedDefinitionId::from_u32(1));
-        sym1a.record_constraint(ScopedConstraintId::from_u32(1));
+        let mut cd1a = SymbolState::with(ScopedDefinitionId::from_u32(1));
+        cd1a.add_constraint(ScopedConstraintId::from_u32(1));

-        let mut sym1b = SymbolState::undefined();
-        sym1b.record_binding(ScopedDefinitionId::from_u32(1));
-        sym1b.record_constraint(ScopedConstraintId::from_u32(2));
+        let mut cd1b = SymbolState::with(ScopedDefinitionId::from_u32(1));
+        cd1b.add_constraint(ScopedConstraintId::from_u32(2));

-        sym1a.merge(sym1b);
-        let sym1 = sym1a;
-        assert_bindings(&sym1, false, &["1<>"]);
+        cd1a.merge(cd1b);
+        let cd1 = cd1a;
+        cd1.assert(false, &["1<>"]);

        // merging a constrained definition with unbound keeps both
-        let mut sym2a = SymbolState::undefined();
-        sym2a.record_binding(ScopedDefinitionId::from_u32(2));
-        sym2a.record_constraint(ScopedConstraintId::from_u32(3));
+        let mut cd2a = SymbolState::with(ScopedDefinitionId::from_u32(2));
+        cd2a.add_constraint(ScopedConstraintId::from_u32(3));

-        let sym2b = SymbolState::undefined();
+        let cd2b = SymbolState::unbound();

-        sym2a.merge(sym2b);
-        let sym2 = sym2a;
-        assert_bindings(&sym2, true, &["2<3>"]);
+        cd2a.merge(cd2b);
+        let cd2 = cd2a;
+        cd2.assert(true, &["2<3>"]);

        // merging different definitions keeps them each with their existing constraints
-        sym0.merge(sym2);
-        let sym = sym0;
-        assert_bindings(&sym, true, &["0<0>", "2<3>"]);
-    }
-
-    #[test]
-    fn no_declaration() {
-        let sym = SymbolState::undefined();
-
-        assert_declarations(&sym, true, &[]);
-    }
-
-    #[test]
-    fn record_declaration() {
-        let mut sym = SymbolState::undefined();
-        sym.record_declaration(ScopedDefinitionId::from_u32(1));
-
-        assert_declarations(&sym, false, &[1]);
-    }
-
-    #[test]
-    fn record_declaration_override() {
-        let mut sym = SymbolState::undefined();
-        sym.record_declaration(ScopedDefinitionId::from_u32(1));
-        sym.record_declaration(ScopedDefinitionId::from_u32(2));
-
-        assert_declarations(&sym, false, &[2]);
-    }
-
-    #[test]
-    fn record_declaration_merge() {
-        let mut sym = SymbolState::undefined();
-        sym.record_declaration(ScopedDefinitionId::from_u32(1));
-
-        let mut sym2 = SymbolState::undefined();
-        sym2.record_declaration(ScopedDefinitionId::from_u32(2));
-
-        sym.merge(sym2);
-
-        assert_declarations(&sym, false, &[1, 2]);
-    }
-
-    #[test]
-    fn record_declaration_merge_partial_undeclared() {
-        let mut sym = SymbolState::undefined();
-        sym.record_declaration(ScopedDefinitionId::from_u32(1));
-
-        let sym2 = SymbolState::undefined();
-
-        sym.merge(sym2);
-
-        assert_declarations(&sym, true, &[1]);
-    }
-
-    #[test]
-    fn set_may_be_undeclared() {
-        let mut sym = SymbolState::undefined();
-        sym.record_declaration(ScopedDefinitionId::from_u32(0));
-        sym.set_may_be_undeclared();
-
-        assert_declarations(&sym, true, &[0]);
+        cd0.merge(cd2);
+        let cd = cd0;
+        cd.assert(true, &["0<0>", "2<3>"]);
    }
 }
--- a/crates/red_knot_python_semantic/src/semantic_model.rs
+++ b/crates/red_knot_python_semantic/src/semantic_model.rs
@@ -8,7 +8,7 @@ use crate::module_name::ModuleName;
 use crate::module_resolver::{resolve_module, Module};
 use crate::semantic_index::ast_ids::HasScopedAstId;
 use crate::semantic_index::semantic_index;
-use crate::types::{binding_ty, global_symbol_ty, infer_scope_types, Type};
+use crate::types::{definition_ty, global_symbol_ty_by_name, infer_scope_types, Type};
 use crate::Db;

 pub struct SemanticModel<'db> {
@@ -40,7 +40,7 @@ impl<'db> SemanticModel<'db> {
    }

    pub fn global_symbol_ty(&self, module: &Module, symbol_name: &str) -> Type<'db> {
-        global_symbol_ty(self.db, module.file(), symbol_name)
+        global_symbol_ty_by_name(self.db, module.file(), symbol_name)
    }
 }

@@ -147,24 +147,24 @@ impl HasTy for ast::Expr {
    }
 }

-macro_rules! impl_binding_has_ty {
+macro_rules! impl_definition_has_ty {
    ($ty: ty) => {
        impl HasTy for $ty {
            #[inline]
            fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
                let index = semantic_index(model.db, model.file);
-                let binding = index.definition(self);
-                binding_ty(model.db, binding)
+                let definition = index.definition(self);
+                definition_ty(model.db, definition)
            }
        }
    };
 }

-impl_binding_has_ty!(ast::StmtFunctionDef);
-impl_binding_has_ty!(ast::StmtClassDef);
-impl_binding_has_ty!(ast::Alias);
-impl_binding_has_ty!(ast::Parameter);
-impl_binding_has_ty!(ast::ParameterWithDefault);
+impl_definition_has_ty!(ast::StmtFunctionDef);
+impl_definition_has_ty!(ast::StmtClassDef);
+impl_definition_has_ty!(ast::Alias);
+impl_definition_has_ty!(ast::Parameter);
+impl_definition_has_ty!(ast::ParameterWithDefault);

 #[cfg(test)]
 mod tests {
--- a/crates/red_knot_python_semantic/src/stdlib.rs
+++ b/crates/red_knot_python_semantic/src/stdlib.rs
@@ -1,87 +0,0 @@
-use crate::module_name::ModuleName;
-use crate::module_resolver::resolve_module;
-use crate::semantic_index::global_scope;
-use crate::semantic_index::symbol::ScopeId;
-use crate::types::{global_symbol_ty, Type};
-use crate::Db;
-
-/// Enumeration of various core stdlib modules, for which we have dedicated Salsa queries.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum CoreStdlibModule {
-    Builtins,
-    Types,
-    Typeshed,
-    TypingExtensions,
-}
-
-impl CoreStdlibModule {
-    fn name(self) -> ModuleName {
-        let module_name = match self {
-            Self::Builtins => "builtins",
-            Self::Types => "types",
-            Self::Typeshed => "_typeshed",
-            Self::TypingExtensions => "typing_extensions",
-        };
-        ModuleName::new_static(module_name)
-            .unwrap_or_else(|| panic!("{module_name} should be a valid module name!"))
-    }
-}
-
-/// Lookup the type of `symbol` in a given core module
-///
-/// Returns `Unbound` if the given core module cannot be resolved for some reason
-fn core_module_symbol_ty<'db>(
-    db: &'db dyn Db,
-    core_module: CoreStdlibModule,
-    symbol: &str,
-) -> Type<'db> {
-    resolve_module(db, core_module.name())
-        .map(|module| global_symbol_ty(db, module.file(), symbol))
-        .unwrap_or(Type::Unbound)
-}
-
-/// Lookup the type of `symbol` in the builtins namespace.
-///
-/// Returns `Unbound` if the `builtins` module isn't available for some reason.
-#[inline]
-pub(crate) fn builtins_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::Builtins, symbol)
-}
-
-/// Lookup the type of `symbol` in the `types` module namespace.
-///
-/// Returns `Unbound` if the `types` module isn't available for some reason.
-#[inline]
-pub(crate) fn types_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::Types, symbol)
-}
-
-/// Lookup the type of `symbol` in the `_typeshed` module namespace.
-///
-/// Returns `Unbound` if the `_typeshed` module isn't available for some reason.
-#[inline]
-pub(crate) fn typeshed_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::Typeshed, symbol)
-}
-
-/// Lookup the type of `symbol` in the `typing_extensions` module namespace.
-///
-/// Returns `Unbound` if the `typing_extensions` module isn't available for some reason.
-#[inline]
-pub(crate) fn typing_extensions_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::TypingExtensions, symbol)
-}
-
-/// Get the scope of a core stdlib module.
-///
-/// Can return `None` if a custom typeshed is used that is missing the core module in question.
-fn core_module_scope(db: &dyn Db, core_module: CoreStdlibModule) -> Option<ScopeId<'_>> {
-    resolve_module(db, core_module.name()).map(|module| global_scope(db, module.file()))
-}
-
-/// Get the `builtins` module scope.
-///
-/// Can return `None` if a custom typeshed is used that is missing `builtins.pyi`.
-pub(crate) fn builtins_module_scope(db: &dyn Db) -> Option<ScopeId<'_>> {
-    core_module_scope(db, CoreStdlibModule::Builtins)
-}
--- a/crates/red_knot_python_semantic/src/types.rs
+++ b/crates/red_knot_python_semantic/src/types.rs
--- a/crates/red_knot_python_semantic/src/types/builder.rs
+++ b/crates/red_knot_python_semantic/src/types/builder.rs
@@ -25,10 +25,13 @@
 //!   * No type in an intersection can be a supertype of any other type in the intersection (just
 //!     eliminate the supertype from the intersection).
 //!   * An intersection containing two non-overlapping types should simplify to [`Type::Never`].
-use crate::types::{builtins_symbol_ty, IntersectionType, Type, UnionType};
+
+use crate::types::{IntersectionType, Type, UnionType};
 use crate::{Db, FxOrderSet};
 use ordermap::set::MutableValues;

+use super::builtins_symbol_ty_by_name;
+
 pub(crate) struct UnionBuilder<'db> {
    elements: FxOrderSet<Type<'db>>,
    db: &'db dyn Db,
@@ -46,23 +49,10 @@ impl<'db> UnionBuilder<'db> {
    pub(crate) fn add(mut self, ty: Type<'db>) -> Self {
        match ty {
            Type::Union(union) => {
-                for element in union.elements(self.db) {
-                    self = self.add(*element);
-                }
+                self.elements.extend(union.elements(self.db));
            }
            Type::Never => {}
            _ => {
-                let mut remove = vec![];
-                for element in &self.elements {
-                    if ty.is_subtype_of(self.db, *element) {
-                        return self;
-                    } else if element.is_subtype_of(self.db, ty) {
-                        remove.push(*element);
-                    }
-                }
-                for element in remove {
-                    self.elements.remove(&element);
-                }
                self.elements.insert(ty);
            }
        }
@@ -78,7 +68,7 @@ impl<'db> UnionBuilder<'db> {
        if let Some(true_index) = self.elements.get_index_of(&Type::BooleanLiteral(true)) {
            if self.elements.contains(&Type::BooleanLiteral(false)) {
                *self.elements.get_index_mut2(true_index).unwrap() =
-                    builtins_symbol_ty(self.db, "bool");
+                    builtins_symbol_ty_by_name(self.db, "bool");
                self.elements.remove(&Type::BooleanLiteral(false));
            }
        }
@@ -182,12 +172,11 @@ impl<'db> IntersectionBuilder<'db> {
        if self.intersections.len() == 1 {
            self.intersections.pop().unwrap().build(self.db)
        } else {
-            UnionType::from_elements(
-                self.db,
-                self.intersections
-                    .into_iter()
-                    .map(|inner| inner.build(self.db)),
-            )
+            let mut builder = UnionBuilder::new(self.db);
+            for inner in self.intersections {
+                builder = builder.add(inner.build(self.db));
+            }
+            builder.build()
        }
    }
 }
@@ -285,11 +274,11 @@ impl<'db> InnerIntersectionBuilder<'db> {

 #[cfg(test)]
 mod tests {
-    use super::{IntersectionBuilder, IntersectionType, Type, UnionType};
+    use super::{IntersectionBuilder, IntersectionType, Type, UnionBuilder, UnionType};
    use crate::db::tests::TestDb;
    use crate::program::{Program, SearchPathSettings};
    use crate::python_version::PythonVersion;
-    use crate::types::{builtins_symbol_ty, UnionBuilder};
+    use crate::types::builtins_symbol_ty_by_name;
    use crate::ProgramSettings;
    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};

@@ -324,7 +313,11 @@ mod tests {
        let db = setup_db();
        let t0 = Type::IntLiteral(0);
        let t1 = Type::IntLiteral(1);
-        let union = UnionType::from_elements(&db, [t0, t1]).expect_union();
+        let union = UnionBuilder::new(&db)
+            .add(t0)
+            .add(t1)
+            .build()
+            .expect_union();

        assert_eq!(union.elements_vec(&db), &[t0, t1]);
    }
@@ -333,7 +326,8 @@ mod tests {
    fn build_union_single() {
        let db = setup_db();
        let t0 = Type::IntLiteral(0);
-        let ty = UnionType::from_elements(&db, [t0]);
+        let ty = UnionBuilder::new(&db).add(t0).build();
+
        assert_eq!(ty, t0);
    }

@@ -341,6 +335,7 @@ mod tests {
    fn build_union_empty() {
        let db = setup_db();
        let ty = UnionBuilder::new(&db).build();
+
        assert_eq!(ty, Type::Never);
    }

@@ -348,24 +343,36 @@ mod tests {
    fn build_union_never() {
        let db = setup_db();
        let t0 = Type::IntLiteral(0);
-        let ty = UnionType::from_elements(&db, [t0, Type::Never]);
+        let ty = UnionBuilder::new(&db).add(t0).add(Type::Never).build();
+
        assert_eq!(ty, t0);
    }

    #[test]
    fn build_union_bool() {
        let db = setup_db();
-        let bool_ty = builtins_symbol_ty(&db, "bool");
+        let bool_ty = builtins_symbol_ty_by_name(&db, "bool");

        let t0 = Type::BooleanLiteral(true);
        let t1 = Type::BooleanLiteral(true);
        let t2 = Type::BooleanLiteral(false);
        let t3 = Type::IntLiteral(17);

-        let union = UnionType::from_elements(&db, [t0, t1, t3]).expect_union();
+        let union = UnionBuilder::new(&db)
+            .add(t0)
+            .add(t1)
+            .add(t3)
+            .build()
+            .expect_union();
        assert_eq!(union.elements_vec(&db), &[t0, t3]);
+        let union = UnionBuilder::new(&db)
+            .add(t0)
+            .add(t1)
+            .add(t2)
+            .add(t3)
+            .build()
+            .expect_union();

-        let union = UnionType::from_elements(&db, [t0, t1, t2, t3]).expect_union();
        assert_eq!(union.elements_vec(&db), &[bool_ty, t3]);
    }

@@ -375,30 +382,16 @@ mod tests {
        let t0 = Type::IntLiteral(0);
        let t1 = Type::IntLiteral(1);
        let t2 = Type::IntLiteral(2);
-        let u1 = UnionType::from_elements(&db, [t0, t1]);
-        let union = UnionType::from_elements(&db, [u1, t2]).expect_union();
+        let u1 = UnionBuilder::new(&db).add(t0).add(t1).build();
+        let union = UnionBuilder::new(&db)
+            .add(u1)
+            .add(t2)
+            .build()
+            .expect_union();

        assert_eq!(union.elements_vec(&db), &[t0, t1, t2]);
    }

-    #[test]
-    fn build_union_simplify_subtype() {
-        let db = setup_db();
-        let t0 = builtins_symbol_ty(&db, "str").to_instance(&db);
-        let t1 = Type::LiteralString;
-        let t2 = Type::Unknown;
-        let u0 = UnionType::from_elements(&db, [t0, t1]);
-        let u1 = UnionType::from_elements(&db, [t1, t0]);
-        let u2 = UnionType::from_elements(&db, [t0, t1, t2]);
-
-        assert_eq!(u0, t0);
-        assert_eq!(u1, t0);
-        assert_eq!(u2.expect_union().elements_vec(&db), &[t0, t2]);
-    }
-
-    #[test]
-    fn build_union_no_simplify_any() {}
-
    impl<'db> IntersectionType<'db> {
        fn pos_vec(self, db: &'db TestDb) -> Vec<Type<'db>> {
            self.positive(db).into_iter().copied().collect()
@@ -470,7 +463,7 @@ mod tests {
        let t0 = Type::IntLiteral(0);
        let t1 = Type::IntLiteral(1);
        let ta = Type::Any;
-        let u0 = UnionType::from_elements(&db, [t0, t1]);
+        let u0 = UnionBuilder::new(&db).add(t0).add(t1).build();

        let union = IntersectionBuilder::new(&db)
            .add_positive(ta)
--- a/crates/red_knot_python_semantic/src/types/display.rs
+++ b/crates/red_knot_python_semantic/src/types/display.rs
@@ -1,20 +1,19 @@
 //! Display implementations for types.

-use std::fmt::{self, Display, Formatter};
+use std::fmt::{Display, Formatter};

-use ruff_db::display::FormatterJoinExtension;
 use ruff_python_ast::str::Quote;
 use ruff_python_literal::escape::AsciiEscape;

 use crate::types::{IntersectionType, Type, UnionType};
-use crate::Db;
-use rustc_hash::FxHashMap;
+use crate::{Db, FxOrderMap};

 impl<'db> Type<'db> {
-    pub fn display(&self, db: &'db dyn Db) -> DisplayType {
+    pub fn display(&'db self, db: &'db dyn Db) -> DisplayType<'db> {
        DisplayType { ty: self, db }
    }
-    fn representation(self, db: &'db dyn Db) -> DisplayRepresentation<'db> {
+
+    fn representation(&'db self, db: &'db dyn Db) -> DisplayRepresentation<'db> {
        DisplayRepresentation { db, ty: self }
    }
 }
@@ -26,7 +25,7 @@ pub struct DisplayType<'db> {
 }

 impl Display for DisplayType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let representation = self.ty.representation(self.db);
        if matches!(
            self.ty,
@@ -36,7 +35,6 @@ impl Display for DisplayType<'_> {
                | Type::BytesLiteral(_)
                | Type::Class(_)
                | Type::Function(_)
-                | Type::RevealTypeFunction(_)
        ) {
            write!(f, "Literal[{representation}]",)
        } else {
@@ -45,9 +43,9 @@ impl Display for DisplayType<'_> {
    }
 }

-impl fmt::Debug for DisplayType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        Display::fmt(self, f)
+impl std::fmt::Debug for DisplayType<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
    }
 }

@@ -55,12 +53,12 @@ impl fmt::Debug for DisplayType<'_> {
 /// `Literal[<repr>]` or `Literal[<repr1>, <repr2>]` for literal types or as `<repr>` for
 /// non literals
 struct DisplayRepresentation<'db> {
-    ty: Type<'db>,
+    ty: &'db Type<'db>,
    db: &'db dyn Db,
 }

-impl Display for DisplayRepresentation<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+impl std::fmt::Display for DisplayRepresentation<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self.ty {
            Type::Any => f.write_str("Any"),
            Type::Never => f.write_str("Never"),
@@ -73,13 +71,11 @@ impl Display for DisplayRepresentation<'_> {
            // TODO functions and classes should display using a fully qualified name
            Type::Class(class) => f.write_str(class.name(self.db)),
            Type::Instance(class) => f.write_str(class.name(self.db)),
-            Type::Function(function) | Type::RevealTypeFunction(function) => {
-                f.write_str(function.name(self.db))
-            }
+            Type::Function(function) => f.write_str(function.name(self.db)),
            Type::Union(union) => union.display(self.db).fmt(f),
            Type::Intersection(intersection) => intersection.display(self.db).fmt(f),
-            Type::IntLiteral(n) => n.fmt(f),
-            Type::BooleanLiteral(boolean) => f.write_str(if boolean { "True" } else { "False" }),
+            Type::IntLiteral(n) => write!(f, "{n}"),
+            Type::BooleanLiteral(boolean) => f.write_str(if *boolean { "True" } else { "False" }),
            Type::StringLiteral(string) => {
                write!(f, r#""{}""#, string.value(self.db).replace('"', r#"\""#))
            }
@@ -90,16 +86,6 @@ impl Display for DisplayRepresentation<'_> {

                escape.bytes_repr().write(f)
            }
-            Type::Tuple(tuple) => {
-                f.write_str("tuple[")?;
-                let elements = tuple.elements(self.db);
-                if elements.is_empty() {
-                    f.write_str("()")?;
-                } else {
-                    elements.display(self.db).fmt(f)?;
-                }
-                f.write_str("]")
-            }
        }
    }
 }
@@ -116,11 +102,11 @@ struct DisplayUnionType<'db> {
 }

 impl Display for DisplayUnionType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let elements = self.ty.elements(self.db);

        // Group literal types by kind.
-        let mut grouped_literals = FxHashMap::default();
+        let mut grouped_literals = FxOrderMap::default();

        for element in elements {
            if let Ok(literal_kind) = LiteralTypeKind::try_from(*element) {
@@ -131,26 +117,42 @@ impl Display for DisplayUnionType<'_> {
            }
        }

-        let mut join = f.join(" | ");
+        let mut first = true;

-        for element in elements {
-            if let Ok(literal_kind) = LiteralTypeKind::try_from(*element) {
+        // Print all types, but write all literals together (while preserving their position).
+        for ty in elements {
+            if let Ok(literal_kind) = LiteralTypeKind::try_from(*ty) {
                let Some(mut literals) = grouped_literals.remove(&literal_kind) else {
                    continue;
                };
+
+                if !first {
+                    f.write_str(" | ")?;
+                };
+
+                f.write_str("Literal[")?;
+
                if literal_kind == LiteralTypeKind::IntLiteral {
                    literals.sort_unstable_by_key(|ty| ty.expect_int_literal());
                }
-                join.entry(&DisplayLiteralGroup {
-                    literals,
-                    db: self.db,
-                });
-            } else {
-                join.entry(&element.display(self.db));
-            }
-        }

-        join.finish()?;
+                for (i, literal_ty) in literals.iter().enumerate() {
+                    if i > 0 {
+                        f.write_str(", ")?;
+                    }
+                    literal_ty.representation(self.db).fmt(f)?;
+                }
+                f.write_str("]")?;
+            } else {
+                if !first {
+                    f.write_str(" | ")?;
+                };
+
+                ty.display(self.db).fmt(f)?;
+            }
+
+            first = false;
+        }

        debug_assert!(grouped_literals.is_empty());

@@ -158,24 +160,9 @@ impl Display for DisplayUnionType<'_> {
    }
 }

-impl fmt::Debug for DisplayUnionType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        Display::fmt(self, f)
-    }
-}
-
-struct DisplayLiteralGroup<'db> {
-    literals: Vec<Type<'db>>,
-    db: &'db dyn Db,
-}
-
-impl Display for DisplayLiteralGroup<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_str("Literal[")?;
-        f.join(", ")
-            .entries(self.literals.iter().map(|ty| ty.representation(self.db)))
-            .finish()?;
-        f.write_str("]")
+impl std::fmt::Debug for DisplayUnionType<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
    }
 }

@@ -194,7 +181,7 @@ impl TryFrom<Type<'_>> for LiteralTypeKind {
    fn try_from(value: Type<'_>) -> Result<Self, Self::Error> {
        match value {
            Type::Class(_) => Ok(Self::Class),
-            Type::Function(_) | Type::RevealTypeFunction(_) => Ok(Self::Function),
+            Type::Function(_) => Ok(Self::Function),
            Type::IntLiteral(_) => Ok(Self::IntLiteral),
            Type::StringLiteral(_) => Ok(Self::StringLiteral),
            Type::BytesLiteral(_) => Ok(Self::BytesLiteral),
@@ -215,77 +202,31 @@ struct DisplayIntersectionType<'db> {
 }

 impl Display for DisplayIntersectionType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let tys = self
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let mut first = true;
+        for (neg, ty) in self
            .ty
            .positive(self.db)
            .iter()
-            .map(|&ty| DisplayMaybeNegatedType {
-                ty,
-                db: self.db,
-                negated: false,
-            })
-            .chain(
-                self.ty
-                    .negative(self.db)
-                    .iter()
-                    .map(|&ty| DisplayMaybeNegatedType {
-                        ty,
-                        db: self.db,
-                        negated: true,
-                    }),
-            );
-        f.join(" & ").entries(tys).finish()
-    }
-}
-
-impl fmt::Debug for DisplayIntersectionType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        Display::fmt(self, f)
-    }
-}
-
-struct DisplayMaybeNegatedType<'db> {
-    ty: Type<'db>,
-    db: &'db dyn Db,
-    negated: bool,
-}
-
-impl<'db> Display for DisplayMaybeNegatedType<'db> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        if self.negated {
-            f.write_str("~")?;
+            .map(|ty| (false, ty))
+            .chain(self.ty.negative(self.db).iter().map(|ty| (true, ty)))
+        {
+            if !first {
+                f.write_str(" & ")?;
+            };
+            first = false;
+            if neg {
+                f.write_str("~")?;
+            };
+            write!(f, "{}", ty.display(self.db))?;
        }
-        self.ty.display(self.db).fmt(f)
+        Ok(())
    }
 }

-pub(crate) trait TypeArrayDisplay<'db> {
-    fn display(&self, db: &'db dyn Db) -> DisplayTypeArray;
-}
-
-impl<'db> TypeArrayDisplay<'db> for Box<[Type<'db>]> {
-    fn display(&self, db: &'db dyn Db) -> DisplayTypeArray {
-        DisplayTypeArray { types: self, db }
-    }
-}
-
-impl<'db> TypeArrayDisplay<'db> for Vec<Type<'db>> {
-    fn display(&self, db: &'db dyn Db) -> DisplayTypeArray {
-        DisplayTypeArray { types: self, db }
-    }
-}
-
-pub(crate) struct DisplayTypeArray<'b, 'db> {
-    types: &'b [Type<'db>],
-    db: &'db dyn Db,
-}
-
-impl<'db> Display for DisplayTypeArray<'_, 'db> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.join(", ")
-            .entries(self.types.iter().map(|ty| ty.display(self.db)))
-            .finish()
+impl std::fmt::Debug for DisplayIntersectionType<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
    }
 }

@@ -295,7 +236,9 @@ mod tests {
    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};

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

    fn setup_db() -> TestDb {
@@ -337,23 +280,26 @@ mod tests {
        )?;
        let mod_file = system_path_to_file(&db, "src/main.py").expect("Expected file to exist.");

-        let union_elements = &[
+        let vec: Vec<Type<'_>> = vec![
            Type::Unknown,
            Type::IntLiteral(-1),
-            global_symbol_ty(&db, mod_file, "A"),
+            global_symbol_ty_by_name(&db, mod_file, "A"),
            Type::StringLiteral(StringLiteralType::new(&db, Box::from("A"))),
            Type::BytesLiteral(BytesLiteralType::new(&db, Box::from([0]))),
            Type::BytesLiteral(BytesLiteralType::new(&db, Box::from([7]))),
            Type::IntLiteral(0),
            Type::IntLiteral(1),
            Type::StringLiteral(StringLiteralType::new(&db, Box::from("B"))),
-            global_symbol_ty(&db, mod_file, "foo"),
-            global_symbol_ty(&db, mod_file, "bar"),
-            global_symbol_ty(&db, mod_file, "B"),
+            global_symbol_ty_by_name(&db, mod_file, "foo"),
+            global_symbol_ty_by_name(&db, mod_file, "bar"),
+            global_symbol_ty_by_name(&db, mod_file, "B"),
            Type::BooleanLiteral(true),
            Type::None,
        ];
-        let union = UnionType::from_elements(&db, union_elements).expect_union();
+        let builder = vec.iter().fold(UnionBuilder::new(&db), |builder, literal| {
+            builder.add(*literal)
+        });
+        let union = builder.build().expect_union();
        let display = format!("{}", union.display(&db));
        assert_eq!(
            display,
--- a/crates/red_knot_python_semantic/src/types/infer.rs
+++ b/crates/red_knot_python_semantic/src/types/infer.rs
--- a/crates/red_knot_python_semantic/src/types/narrow.rs
+++ b/crates/red_knot_python_semantic/src/types/narrow.rs
@@ -1,10 +1,9 @@
 use crate::semantic_index::ast_ids::HasScopedAstId;
-use crate::semantic_index::constraint::{Constraint, PatternConstraint};
 use crate::semantic_index::definition::Definition;
 use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{ScopeId, ScopedSymbolId, SymbolTable};
 use crate::semantic_index::symbol_table;
-use crate::types::{infer_expression_types, IntersectionBuilder, Type};
+use crate::types::{infer_expression_types, IntersectionBuilder, Type, TypeInference};
 use crate::Db;
 use ruff_python_ast as ast;
 use rustc_hash::FxHashMap;
@@ -28,114 +27,62 @@ use std::sync::Arc;
 /// constraint is applied to that definition, so we'd just return `None`.
 pub(crate) fn narrowing_constraint<'db>(
    db: &'db dyn Db,
-    constraint: Constraint<'db>,
+    test: Expression<'db>,
    definition: Definition<'db>,
 ) -> Option<Type<'db>> {
-    match constraint {
-        Constraint::Expression(expression) => {
-            all_narrowing_constraints_for_expression(db, expression)
-                .get(&definition.symbol(db))
-                .copied()
-        }
-        Constraint::Pattern(pattern) => all_narrowing_constraints_for_pattern(db, pattern)
-            .get(&definition.symbol(db))
-            .copied(),
-    }
+    all_narrowing_constraints(db, test)
+        .get(&definition.symbol(db))
+        .copied()
 }

 #[salsa::tracked(return_ref)]
-fn all_narrowing_constraints_for_pattern<'db>(
+fn all_narrowing_constraints<'db>(
    db: &'db dyn Db,
-    pattern: PatternConstraint<'db>,
+    test: Expression<'db>,
 ) -> NarrowingConstraints<'db> {
-    NarrowingConstraintsBuilder::new(db, Constraint::Pattern(pattern)).finish()
-}
-
-#[salsa::tracked(return_ref)]
-fn all_narrowing_constraints_for_expression<'db>(
-    db: &'db dyn Db,
-    expression: Expression<'db>,
-) -> NarrowingConstraints<'db> {
-    NarrowingConstraintsBuilder::new(db, Constraint::Expression(expression)).finish()
+    NarrowingConstraintsBuilder::new(db, test).finish()
 }

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

 struct NarrowingConstraintsBuilder<'db> {
    db: &'db dyn Db,
-    constraint: Constraint<'db>,
+    expression: Expression<'db>,
    constraints: NarrowingConstraints<'db>,
 }

 impl<'db> NarrowingConstraintsBuilder<'db> {
-    fn new(db: &'db dyn Db, constraint: Constraint<'db>) -> Self {
+    fn new(db: &'db dyn Db, expression: Expression<'db>) -> Self {
        Self {
            db,
-            constraint,
+            expression,
            constraints: NarrowingConstraints::default(),
        }
    }

    fn finish(mut self) -> NarrowingConstraints<'db> {
-        match self.constraint {
-            Constraint::Expression(expression) => self.evaluate_expression_constraint(expression),
-            Constraint::Pattern(pattern) => self.evaluate_pattern_constraint(pattern),
+        if let ast::Expr::Compare(expr_compare) = self.expression.node_ref(self.db).node() {
+            self.add_expr_compare(expr_compare);
        }
+        // TODO other test expression kinds

        self.constraints.shrink_to_fit();
        self.constraints
    }

-    fn evaluate_expression_constraint(&mut self, expression: Expression<'db>) {
-        if let ast::Expr::Compare(expr_compare) = expression.node_ref(self.db).node() {
-            self.add_expr_compare(expr_compare, expression);
-        }
-        // TODO other test expression kinds
-    }
-
-    fn evaluate_pattern_constraint(&mut self, pattern: PatternConstraint<'db>) {
-        let subject = pattern.subject(self.db);
-
-        match pattern.pattern(self.db).node() {
-            ast::Pattern::MatchValue(_) => {
-                // TODO
-            }
-            ast::Pattern::MatchSingleton(singleton_pattern) => {
-                self.add_match_pattern_singleton(subject, singleton_pattern);
-            }
-            ast::Pattern::MatchSequence(_) => {
-                // TODO
-            }
-            ast::Pattern::MatchMapping(_) => {
-                // TODO
-            }
-            ast::Pattern::MatchClass(_) => {
-                // TODO
-            }
-            ast::Pattern::MatchStar(_) => {
-                // TODO
-            }
-            ast::Pattern::MatchAs(_) => {
-                // TODO
-            }
-            ast::Pattern::MatchOr(_) => {
-                // TODO
-            }
-        }
-    }
-
    fn symbols(&self) -> Arc<SymbolTable> {
        symbol_table(self.db, self.scope())
    }

    fn scope(&self) -> ScopeId<'db> {
-        match self.constraint {
-            Constraint::Expression(expression) => expression.scope(self.db),
-            Constraint::Pattern(pattern) => pattern.scope(self.db),
-        }
+        self.expression.scope(self.db)
    }

-    fn add_expr_compare(&mut self, expr_compare: &ast::ExprCompare, expression: Expression<'db>) {
+    fn inference(&self) -> &'db TypeInference<'db> {
+        infer_expression_types(self.db, self.expression)
+    }
+
+    fn add_expr_compare(&mut self, expr_compare: &ast::ExprCompare) {
        let ast::ExprCompare {
            range: _,
            left,
@@ -152,7 +99,7 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
            // SAFETY: we should always have a symbol for every Name node.
            let symbol = self.symbols().symbol_id_by_name(id).unwrap();
            let scope = self.scope();
-            let inference = infer_expression_types(self.db, expression);
+            let inference = self.inference();
            for (op, comparator) in std::iter::zip(&**ops, &**comparators) {
                let comp_ty = inference.expression_ty(comparator.scoped_ast_id(self.db, scope));
                if matches!(op, ast::CmpOp::IsNot) {
@@ -165,22 +112,4 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
            }
        }
    }
-
-    fn add_match_pattern_singleton(
-        &mut self,
-        subject: &ast::Expr,
-        pattern: &ast::PatternMatchSingleton,
-    ) {
-        if let Some(ast::ExprName { id, .. }) = subject.as_name_expr() {
-            // SAFETY: we should always have a symbol for every Name node.
-            let symbol = self.symbols().symbol_id_by_name(id).unwrap();
-
-            let ty = match pattern.value {
-                ast::Singleton::None => Type::None,
-                ast::Singleton::True => Type::BooleanLiteral(true),
-                ast::Singleton::False => Type::BooleanLiteral(false),
-            };
-            self.constraints.insert(symbol, ty);
-        }
-    }
 }
--- a/crates/red_knot_python_semantic/vendor/typeshed/source_commit.txt
+++ b/crates/red_knot_python_semantic/vendor/typeshed/source_commit.txt
@@ -1 +1 @@
-9e506eb5e8fc2823db8c60ad561b1145ff114947
+23d867efb2df6de5600f64656f1aa8a83e06109e
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/VERSIONS
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/VERSIONS
@@ -41,7 +41,7 @@ _json: 3.0-
 _locale: 3.0-
 _lsprof: 3.0-
 _markupbase: 3.0-
-_msi: 3.0-3.12
+_msi: 3.0-
 _operator: 3.4-
 _osx_support: 3.0-
 _posixsubprocess: 3.2-
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_curses.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_curses.pyi
@@ -493,7 +493,7 @@ class _CursesWindow:
    def instr(self, y: int, x: int, n: int = ...) -> bytes: ...
    def is_linetouched(self, line: int, /) -> bool: ...
    def is_wintouched(self) -> bool: ...
-    def keypad(self, yes: bool, /) -> None: ...
+    def keypad(self, yes: bool) -> None: ...
    def leaveok(self, yes: bool) -> None: ...
    def move(self, new_y: int, new_x: int) -> None: ...
    def mvderwin(self, y: int, x: int) -> None: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_locale.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_locale.pyi
@@ -1,38 +1,17 @@
 import sys
 from _typeshed import StrPath
-from typing import Final, Literal, TypedDict, type_check_only
+from collections.abc import Mapping

-@type_check_only
-class _LocaleConv(TypedDict):
-    decimal_point: str
-    grouping: list[int]
-    thousands_sep: str
-    int_curr_symbol: str
-    currency_symbol: str
-    p_cs_precedes: Literal[0, 1, 127]
-    n_cs_precedes: Literal[0, 1, 127]
-    p_sep_by_space: Literal[0, 1, 127]
-    n_sep_by_space: Literal[0, 1, 127]
-    mon_decimal_point: str
-    frac_digits: int
-    int_frac_digits: int
-    mon_thousands_sep: str
-    mon_grouping: list[int]
-    positive_sign: str
-    negative_sign: str
-    p_sign_posn: Literal[0, 1, 2, 3, 4, 127]
-    n_sign_posn: Literal[0, 1, 2, 3, 4, 127]
-
-LC_CTYPE: Final[int]
-LC_COLLATE: Final[int]
-LC_TIME: Final[int]
-LC_MONETARY: Final[int]
-LC_NUMERIC: Final[int]
-LC_ALL: Final[int]
-CHAR_MAX: Final = 127
+LC_CTYPE: int
+LC_COLLATE: int
+LC_TIME: int
+LC_MONETARY: int
+LC_NUMERIC: int
+LC_ALL: int
+CHAR_MAX: int

 def setlocale(category: int, locale: str | None = None, /) -> str: ...
-def localeconv() -> _LocaleConv: ...
+def localeconv() -> Mapping[str, int | str | list[int]]: ...

 if sys.version_info >= (3, 11):
    def getencoding() -> str: ...
@@ -46,67 +25,67 @@ def strxfrm(string: str, /) -> str: ...
 if sys.platform != "win32":
    LC_MESSAGES: int

-    ABDAY_1: Final[int]
-    ABDAY_2: Final[int]
-    ABDAY_3: Final[int]
-    ABDAY_4: Final[int]
-    ABDAY_5: Final[int]
-    ABDAY_6: Final[int]
-    ABDAY_7: Final[int]
+    ABDAY_1: int
+    ABDAY_2: int
+    ABDAY_3: int
+    ABDAY_4: int
+    ABDAY_5: int
+    ABDAY_6: int
+    ABDAY_7: int

-    ABMON_1: Final[int]
-    ABMON_2: Final[int]
-    ABMON_3: Final[int]
-    ABMON_4: Final[int]
-    ABMON_5: Final[int]
-    ABMON_6: Final[int]
-    ABMON_7: Final[int]
-    ABMON_8: Final[int]
-    ABMON_9: Final[int]
-    ABMON_10: Final[int]
-    ABMON_11: Final[int]
-    ABMON_12: Final[int]
+    ABMON_1: int
+    ABMON_2: int
+    ABMON_3: int
+    ABMON_4: int
+    ABMON_5: int
+    ABMON_6: int
+    ABMON_7: int
+    ABMON_8: int
+    ABMON_9: int
+    ABMON_10: int
+    ABMON_11: int
+    ABMON_12: int

-    DAY_1: Final[int]
-    DAY_2: Final[int]
-    DAY_3: Final[int]
-    DAY_4: Final[int]
-    DAY_5: Final[int]
-    DAY_6: Final[int]
-    DAY_7: Final[int]
+    DAY_1: int
+    DAY_2: int
+    DAY_3: int
+    DAY_4: int
+    DAY_5: int
+    DAY_6: int
+    DAY_7: int

-    ERA: Final[int]
-    ERA_D_T_FMT: Final[int]
-    ERA_D_FMT: Final[int]
-    ERA_T_FMT: Final[int]
+    ERA: int
+    ERA_D_T_FMT: int
+    ERA_D_FMT: int
+    ERA_T_FMT: int

-    MON_1: Final[int]
-    MON_2: Final[int]
-    MON_3: Final[int]
-    MON_4: Final[int]
-    MON_5: Final[int]
-    MON_6: Final[int]
-    MON_7: Final[int]
-    MON_8: Final[int]
-    MON_9: Final[int]
-    MON_10: Final[int]
-    MON_11: Final[int]
-    MON_12: Final[int]
+    MON_1: int
+    MON_2: int
+    MON_3: int
+    MON_4: int
+    MON_5: int
+    MON_6: int
+    MON_7: int
+    MON_8: int
+    MON_9: int
+    MON_10: int
+    MON_11: int
+    MON_12: int

-    CODESET: Final[int]
-    D_T_FMT: Final[int]
-    D_FMT: Final[int]
-    T_FMT: Final[int]
-    T_FMT_AMPM: Final[int]
-    AM_STR: Final[int]
-    PM_STR: Final[int]
+    CODESET: int
+    D_T_FMT: int
+    D_FMT: int
+    T_FMT: int
+    T_FMT_AMPM: int
+    AM_STR: int
+    PM_STR: int

-    RADIXCHAR: Final[int]
-    THOUSEP: Final[int]
-    YESEXPR: Final[int]
-    NOEXPR: Final[int]
-    CRNCYSTR: Final[int]
-    ALT_DIGITS: Final[int]
+    RADIXCHAR: int
+    THOUSEP: int
+    YESEXPR: int
+    NOEXPR: int
+    CRNCYSTR: int
+    ALT_DIGITS: int

    def nl_langinfo(key: int, /) -> str: ...

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_winapi.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_winapi.pyi
@@ -99,20 +99,6 @@ if sys.platform == "win32":
    SEC_RESERVE: Final = 0x4000000
    SEC_WRITECOMBINE: Final = 0x40000000

-    if sys.version_info >= (3, 13):
-        STARTF_FORCEOFFFEEDBACK: Final = 0x80
-        STARTF_FORCEONFEEDBACK: Final = 0x40
-        STARTF_PREVENTPINNING: Final = 0x2000
-        STARTF_RUNFULLSCREEN: Final = 0x20
-        STARTF_TITLEISAPPID: Final = 0x1000
-        STARTF_TITLEISLINKNAME: Final = 0x800
-        STARTF_UNTRUSTEDSOURCE: Final = 0x8000
-        STARTF_USECOUNTCHARS: Final = 0x8
-        STARTF_USEFILLATTRIBUTE: Final = 0x10
-        STARTF_USEHOTKEY: Final = 0x200
-        STARTF_USEPOSITION: Final = 0x4
-        STARTF_USESIZE: Final = 0x2
-
    STARTF_USESHOWWINDOW: Final = 0x1
    STARTF_USESTDHANDLES: Final = 0x100

@@ -264,20 +250,6 @@ if sys.platform == "win32":
        def cancel(self) -> None: ...
        def getbuffer(self) -> bytes | None: ...

-    if sys.version_info >= (3, 13):
-        def BatchedWaitForMultipleObjects(
-            handle_seq: Sequence[int], wait_all: bool, milliseconds: int = 0xFFFFFFFF
-        ) -> list[int]: ...
-        def CreateEventW(security_attributes: int, manual_reset: bool, initial_state: bool, name: str | None) -> int: ...
-        def CreateMutexW(security_attributes: int, initial_owner: bool, name: str) -> int: ...
-        def GetLongPathName(path: str) -> str: ...
-        def GetShortPathName(path: str) -> str: ...
-        def OpenEventW(desired_access: int, inherit_handle: bool, name: str) -> int: ...
-        def OpenMutexW(desired_access: int, inherit_handle: bool, name: str) -> int: ...
-        def ReleaseMutex(mutex: int) -> None: ...
-        def ResetEvent(event: int) -> None: ...
-        def SetEvent(event: int) -> None: ...
-
    if sys.version_info >= (3, 12):
        def CopyFile2(existing_file_name: str, new_file_name: str, flags: int, progress_routine: int | None = None) -> int: ...
        def NeedCurrentDirectoryForExePath(exe_name: str, /) -> bool: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/builtins.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/builtins.pyi
@@ -1,4 +1,3 @@
-# ruff: noqa: PYI036 # This is the module declaring BaseException
 import _ast
 import _typeshed
 import sys
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/codecs.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/codecs.pyi
@@ -80,7 +80,7 @@ class _Encoder(Protocol):
    def __call__(self, input: str, errors: str = ..., /) -> tuple[bytes, int]: ...  # signature of Codec().encode

 class _Decoder(Protocol):
-    def __call__(self, input: ReadableBuffer, errors: str = ..., /) -> tuple[str, int]: ...  # signature of Codec().decode
+    def __call__(self, input: bytes, errors: str = ..., /) -> tuple[str, int]: ...  # signature of Codec().decode

 class _StreamReader(Protocol):
    def __call__(self, stream: _ReadableStream, errors: str = ..., /) -> StreamReader: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/copy.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/copy.pyi
@@ -1,15 +1,16 @@
 import sys
 from typing import Any, Protocol, TypeVar
-from typing_extensions import Self
+from typing_extensions import ParamSpec, Self

 __all__ = ["Error", "copy", "deepcopy"]

 _T = TypeVar("_T")
-_SR = TypeVar("_SR", bound=_SupportsReplace)
+_SR = TypeVar("_SR", bound=_SupportsReplace[Any])
+_P = ParamSpec("_P")

-class _SupportsReplace(Protocol):
+class _SupportsReplace(Protocol[_P]):
    # In reality doesn't support args, but there's no other great way to express this.
-    def __replace__(self, *args: Any, **kwargs: Any) -> Self: ...
+    def __replace__(self, *args: _P.args, **kwargs: _P.kwargs) -> Self: ...

 # None in CPython but non-None in Jython
 PyStringMap: Any
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/dist.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/dist.pyi
@@ -270,7 +270,7 @@ class Distribution:
    def has_data_files(self) -> bool: ...
    def is_pure(self) -> bool: ...

-    # Default getter methods generated in __init__ from self.metadata._METHOD_BASENAMES
+    # Getter methods generated in __init__
    def get_name(self) -> str: ...
    def get_version(self) -> str: ...
    def get_fullname(self) -> str: ...
@@ -292,26 +292,3 @@ class Distribution:
    def get_requires(self) -> list[str]: ...
    def get_provides(self) -> list[str]: ...
    def get_obsoletes(self) -> list[str]: ...
-
-    # Default attributes generated in __init__ from self.display_option_names
-    help_commands: bool | Literal[0]
-    name: str | Literal[0]
-    version: str | Literal[0]
-    fullname: str | Literal[0]
-    author: str | Literal[0]
-    author_email: str | Literal[0]
-    maintainer: str | Literal[0]
-    maintainer_email: str | Literal[0]
-    contact: str | Literal[0]
-    contact_email: str | Literal[0]
-    url: str | Literal[0]
-    license: str | Literal[0]
-    licence: str | Literal[0]
-    description: str | Literal[0]
-    long_description: str | Literal[0]
-    platforms: str | list[str] | Literal[0]
-    classifiers: str | list[str] | Literal[0]
-    keywords: str | list[str] | Literal[0]
-    provides: list[str] | Literal[0]
-    requires: list[str] | Literal[0]
-    obsoletes: list[str] | Literal[0]
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/doctest.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/doctest.pyi
@@ -1,10 +1,9 @@
-import sys
 import types
 import unittest
 from _typeshed import ExcInfo
 from collections.abc import Callable
-from typing import Any, ClassVar, NamedTuple
-from typing_extensions import Self, TypeAlias
+from typing import Any, NamedTuple
+from typing_extensions import TypeAlias

 __all__ = [
    "register_optionflag",
@@ -42,22 +41,9 @@ __all__ = [
    "debug",
 ]

-# MyPy errors on conditionals within named tuples.
-
-if sys.version_info >= (3, 13):
-    class TestResults(NamedTuple):
-        def __new__(cls, failed: int, attempted: int, *, skipped: int = 0) -> Self: ...  # type: ignore[misc]
-        skipped: int
-        failed: int
-        attempted: int
-        _fields: ClassVar = ("failed", "attempted")  # type: ignore[misc]
-        __match_args__ = ("failed", "attempted")  # type: ignore[misc]
-        __doc__: None  # type: ignore[misc]
-
-else:
-    class TestResults(NamedTuple):
-        failed: int
-        attempted: int
+class TestResults(NamedTuple):
+    failed: int
+    attempted: int

 OPTIONFLAGS_BY_NAME: dict[str, int]

@@ -148,8 +134,6 @@ class DocTestRunner:
    original_optionflags: int
    tries: int
    failures: int
-    if sys.version_info >= (3, 13):
-        skips: int
    test: DocTest
    def __init__(self, checker: OutputChecker | None = None, verbose: bool | None = None, optionflags: int = 0) -> None: ...
    def report_start(self, out: _Out, test: DocTest, example: Example) -> None: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/_header_value_parser.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/_header_value_parser.pyi
@@ -16,10 +16,6 @@ TOKEN_ENDS: Final[set[str]]
 ASPECIALS: Final[set[str]]
 ATTRIBUTE_ENDS: Final[set[str]]
 EXTENDED_ATTRIBUTE_ENDS: Final[set[str]]
-# Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
-NLSET: Final[set[str]]
-# Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
-SPECIALSNL: Final[set[str]]

 def quote_string(value: Any) -> str: ...

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/_policybase.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/_policybase.pyi
@@ -3,34 +3,12 @@ from collections.abc import Callable
 from email.errors import MessageDefect
 from email.header import Header
 from email.message import Message
+from typing import Any
 from typing_extensions import Self

 class _PolicyBase:
-    def __init__(
-        self,
-        *,
-        max_line_length: int | None = 78,
-        linesep: str = "\n",
-        cte_type: str = "8bit",
-        raise_on_defect: bool = False,
-        mangle_from_: bool = ...,  # default depends on sub-class
-        message_factory: Callable[[Policy], Message] | None = None,
-        # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
-        verify_generated_headers: bool = True,
-    ) -> None: ...
-    def clone(
-        self,
-        *,
-        max_line_length: int | None = ...,
-        linesep: str = ...,
-        cte_type: str = ...,
-        raise_on_defect: bool = ...,
-        mangle_from_: bool = ...,
-        message_factory: Callable[[Policy], Message] | None = ...,
-        # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
-        verify_generated_headers: bool = ...,
-    ) -> Self: ...
-    def __add__(self, other: Policy) -> Self: ...
+    def __add__(self, other: Any) -> Self: ...
+    def clone(self, **kw: Any) -> Self: ...

 class Policy(_PolicyBase, metaclass=ABCMeta):
    max_line_length: int | None
@@ -39,9 +17,16 @@ class Policy(_PolicyBase, metaclass=ABCMeta):
    raise_on_defect: bool
    mangle_from_: bool
    message_factory: Callable[[Policy], Message] | None
-    # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
-    verify_generated_headers: bool
-
+    def __init__(
+        self,
+        *,
+        max_line_length: int | None = 78,
+        linesep: str = "\n",
+        cte_type: str = "8bit",
+        raise_on_defect: bool = False,
+        mangle_from_: bool = False,
+        message_factory: Callable[[Policy], Message] | None = None,
+    ) -> None: ...
    def handle_defect(self, obj: Message, defect: MessageDefect) -> None: ...
    def register_defect(self, obj: Message, defect: MessageDefect) -> None: ...
    def header_max_count(self, name: str) -> int | None: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/errors.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/errors.pyi
@@ -7,9 +7,6 @@ class BoundaryError(MessageParseError): ...
 class MultipartConversionError(MessageError, TypeError): ...
 class CharsetError(MessageError): ...

-# Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
-class HeaderWriteError(MessageError): ...
-
 class MessageDefect(ValueError):
    def __init__(self, line: str | None = None) -> None: ...

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/utils.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/utils.pyi
@@ -30,12 +30,20 @@ _PDTZ: TypeAlias = tuple[int, int, int, int, int, int, int, int, int, int | None
 def quote(str: str) -> str: ...
 def unquote(str: str) -> str: ...

-# `strict` parameter added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
-def parseaddr(addr: str | list[str], *, strict: bool = True) -> tuple[str, str]: ...
+if sys.version_info >= (3, 13):
+    def parseaddr(addr: str | list[str], *, strict: bool = True) -> tuple[str, str]: ...
+
+else:
+    def parseaddr(addr: str) -> tuple[str, str]: ...
+
 def formataddr(pair: tuple[str | None, str], charset: str | Charset = "utf-8") -> str: ...

-# `strict` parameter added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
-def getaddresses(fieldvalues: Iterable[str], *, strict: bool = True) -> list[tuple[str, str]]: ...
+if sys.version_info >= (3, 13):
+    def getaddresses(fieldvalues: Iterable[str], *, strict: bool = True) -> list[tuple[str, str]]: ...
+
+else:
+    def getaddresses(fieldvalues: Iterable[str]) -> list[tuple[str, str]]: ...
+
@overload
 def parsedate(data: None) -> None: ...
@overload
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/io.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/io.pyi
@@ -84,6 +84,7 @@ class RawIOBase(IOBase):
    def read(self, size: int = -1, /) -> bytes | None: ...

 class BufferedIOBase(IOBase):
+    raw: RawIOBase  # This is not part of the BufferedIOBase API and may not exist on some implementations.
    def detach(self) -> RawIOBase: ...
    def readinto(self, buffer: WriteableBuffer, /) -> int: ...
    def write(self, buffer: ReadableBuffer, /) -> int: ...
@@ -118,13 +119,11 @@ class BytesIO(BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible d
    def read1(self, size: int | None = -1, /) -> bytes: ...

 class BufferedReader(BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
-    raw: RawIOBase
    def __enter__(self) -> Self: ...
    def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
    def peek(self, size: int = 0, /) -> bytes: ...

 class BufferedWriter(BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
-    raw: RawIOBase
    def __enter__(self) -> Self: ...
    def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
    def write(self, buffer: ReadableBuffer, /) -> int: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/subprocess.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/subprocess.pyi
@@ -2582,11 +2582,6 @@ else:
 def list2cmdline(seq: Iterable[StrOrBytesPath]) -> str: ...  # undocumented

 if sys.platform == "win32":
-    if sys.version_info >= (3, 13):
-        from _winapi import STARTF_FORCEOFFFEEDBACK, STARTF_FORCEONFEEDBACK
-
-        __all__ += ["STARTF_FORCEOFFFEEDBACK", "STARTF_FORCEONFEEDBACK"]
-
    class STARTUPINFO:
        def __init__(
            self,
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tempfile.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tempfile.pyi
@@ -253,11 +253,11 @@ class _TemporaryFileWrapper(IO[AnyStr]):
    def truncate(self, size: int | None = ...) -> int: ...
    def writable(self) -> bool: ...
    @overload
-    def write(self: _TemporaryFileWrapper[str], s: str, /) -> int: ...
+    def write(self: _TemporaryFileWrapper[str], s: str) -> int: ...
    @overload
-    def write(self: _TemporaryFileWrapper[bytes], s: ReadableBuffer, /) -> int: ...
+    def write(self: _TemporaryFileWrapper[bytes], s: ReadableBuffer) -> int: ...
    @overload
-    def write(self, s: AnyStr, /) -> int: ...
+    def write(self, s: AnyStr) -> int: ...
    @overload
    def writelines(self: _TemporaryFileWrapper[str], lines: Iterable[str]) -> None: ...
    @overload
--- a/crates/red_knot_workspace/resources/test/corpus/67_with_non_name_target.py
+++ b/crates/red_knot_workspace/resources/test/corpus/67_with_non_name_target.py
@@ -1,2 +0,0 @@
-with foo() as self.bar:
-    pass
--- a/crates/ruff/Cargo.toml
+++ b/crates/ruff/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.6.6"
+version = "0.6.3"
 publish = true
 authors = { workspace = true }
 edition = { workspace = true }
@@ -14,9 +14,7 @@ default-run = "ruff"

 [dependencies]
 ruff_cache = { workspace = true }
-ruff_db = { workspace = true }
 ruff_diagnostics = { workspace = true }
-ruff_graph = { workspace = true, features = ["serde", "clap"] }
 ruff_linter = { workspace = true, features = ["clap"] }
 ruff_macros = { workspace = true }
 ruff_notebook = { workspace = true }
@@ -38,7 +36,6 @@ clap_complete_command = { workspace = true }
 clearscreen = { workspace = true }
 colored = { workspace = true }
 filetime = { workspace = true }
-globwalk = { workspace = true }
 ignore = { workspace = true }
 is-macro = { workspace = true }
 itertools = { workspace = true }
@@ -62,11 +59,8 @@ wild = { workspace = true }
 [dev-dependencies]
 # Enable test rules during development
 ruff_linter = { workspace = true, features = ["clap", "test-rules"] }
-
-assert_fs = { workspace = true }
 # Avoid writing colored snapshots when running tests from the terminal
 colored = { workspace = true, features = ["no-color"] }
-indoc = { workspace = true }
 insta = { workspace = true, features = ["filters", "json"] }
 insta-cmd = { workspace = true }
 tempfile = { workspace = true }
--- a/crates/ruff/src/args.rs
+++ b/crates/ruff/src/args.rs
@@ -7,11 +7,13 @@ use std::sync::Arc;

 use anyhow::{anyhow, bail};
 use clap::builder::{TypedValueParser, ValueParserFactory};
-use clap::{command, Parser, Subcommand};
+use clap::{command, Parser};
 use colored::Colorize;
 use path_absolutize::path_dedot;
 use regex::Regex;
-use ruff_graph::Direction;
+use rustc_hash::FxHashMap;
+use toml;
+
 use ruff_linter::line_width::LineLength;
 use ruff_linter::logging::LogLevel;
 use ruff_linter::registry::Rule;
@@ -25,8 +27,6 @@ use ruff_text_size::TextRange;
 use ruff_workspace::configuration::{Configuration, RuleSelection};
 use ruff_workspace::options::{Options, PycodestyleOptions};
 use ruff_workspace::resolver::ConfigurationTransformer;
-use rustc_hash::FxHashMap;
-use toml;

 /// All configuration options that can be passed "globally",
 /// i.e., can be passed to all subcommands
@@ -132,9 +132,6 @@ pub enum Command {
    Format(FormatCommand),
    /// Run the language server.
    Server(ServerCommand),
-    /// Run analysis over Python source code.
-    #[clap(subcommand)]
-    Analyze(AnalyzeCommand),
    /// Display Ruff's version
    Version {
        #[arg(long, value_enum, default_value = "text")]
@@ -142,32 +139,6 @@ pub enum Command {
    },
 }

-#[derive(Debug, Subcommand)]
-pub enum AnalyzeCommand {
-    /// Generate a map of Python file dependencies or dependents.
-    Graph(AnalyzeGraphCommand),
-}
-
-#[derive(Clone, Debug, clap::Parser)]
-pub struct AnalyzeGraphCommand {
-    /// List of files or directories to include.
-    #[clap(help = "List of files or directories to include [default: .]")]
-    pub files: Vec<PathBuf>,
-    /// The direction of the import map. By default, generates a dependency map, i.e., a map from
-    /// file to files that it depends on. Use `--direction dependents` to generate a map from file
-    /// to files that depend on it.
-    #[clap(long, value_enum, default_value_t)]
-    pub direction: Direction,
-    /// Attempt to detect imports from string literals.
-    #[clap(long)]
-    pub detect_string_imports: bool,
-    /// Enable preview mode. Use `--no-preview` to disable.
-    #[arg(long, overrides_with("no_preview"))]
-    preview: bool,
-    #[clap(long, overrides_with("preview"), hide = true)]
-    no_preview: bool,
-}
-
 // The `Parser` derive is for ruff_dev, for ruff `Args` would be sufficient
 #[derive(Clone, Debug, clap::Parser)]
 #[allow(clippy::struct_excessive_bools)]
@@ -729,7 +700,6 @@ impl CheckCommand {
            output_format: resolve_output_format(self.output_format)?,
            show_fixes: resolve_bool_arg(self.show_fixes, self.no_show_fixes),
            extension: self.extension,
-            ..ExplicitConfigOverrides::default()
        };

        let config_args = ConfigArguments::from_cli_arguments(global_options, cli_overrides)?;
@@ -762,33 +732,8 @@ impl FormatCommand {
            target_version: self.target_version,
            cache_dir: self.cache_dir,
            extension: self.extension,
-            ..ExplicitConfigOverrides::default()
-        };

-        let config_args = ConfigArguments::from_cli_arguments(global_options, cli_overrides)?;
-        Ok((format_arguments, config_args))
-    }
-}
-
-impl AnalyzeGraphCommand {
-    /// Partition the CLI into command-line arguments and configuration
-    /// overrides.
-    pub fn partition(
-        self,
-        global_options: GlobalConfigArgs,
-    ) -> anyhow::Result<(AnalyzeGraphArgs, ConfigArguments)> {
-        let format_arguments = AnalyzeGraphArgs {
-            files: self.files,
-            direction: self.direction,
-        };
-
-        let cli_overrides = ExplicitConfigOverrides {
-            detect_string_imports: if self.detect_string_imports {
-                Some(true)
-            } else {
-                None
-            },
-            preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
+            // Unsupported on the formatter CLI, but required on `Overrides`.
            ..ExplicitConfigOverrides::default()
        };

@@ -951,7 +896,7 @@ A `--config` flag must either be a path to a `.toml` configuration file
        // the user was trying to pass in a path to a configuration file
        // or some inline TOML.
        // We want to display the most helpful error to the user as possible.
-        if Path::new(value)
+        if std::path::Path::new(value)
            .extension()
            .map_or(false, |ext| ext.eq_ignore_ascii_case("toml"))
        {
@@ -1211,13 +1156,6 @@ impl LineColumnParseError {
    }
 }

-/// CLI settings that are distinct from configuration (commands, lists of files, etc.).
-#[derive(Clone, Debug)]
-pub struct AnalyzeGraphArgs {
-    pub files: Vec<PathBuf>,
-    pub direction: Direction,
-}
-
 /// Configuration overrides provided via dedicated CLI flags:
 /// `--line-length`, `--respect-gitignore`, etc.
 #[derive(Clone, Default)]
@@ -1249,7 +1187,6 @@ struct ExplicitConfigOverrides {
    output_format: Option<OutputFormat>,
    show_fixes: Option<bool>,
    extension: Option<Vec<ExtensionPair>>,
-    detect_string_imports: Option<bool>,
 }

 impl ConfigurationTransformer for ExplicitConfigOverrides {
@@ -1334,9 +1271,6 @@ impl ConfigurationTransformer for ExplicitConfigOverrides {
        if let Some(extension) = &self.extension {
            config.extension = Some(extension.iter().cloned().collect());
        }
-        if let Some(detect_string_imports) = &self.detect_string_imports {
-            config.analyze.detect_string_imports = Some(*detect_string_imports);
-        }

        config
    }
--- a/crates/ruff/src/commands/analyze_graph.rs
+++ b/crates/ruff/src/commands/analyze_graph.rs
@@ -1,224 +0,0 @@
-use crate::args::{AnalyzeGraphArgs, ConfigArguments};
-use crate::resolve::resolve;
-use crate::{resolve_default_files, ExitStatus};
-use anyhow::Result;
-use log::{debug, warn};
-use path_absolutize::CWD;
-use ruff_db::system::{SystemPath, SystemPathBuf};
-use ruff_graph::{Direction, ImportMap, ModuleDb, ModuleImports};
-use ruff_linter::{warn_user, warn_user_once};
-use ruff_python_ast::{PySourceType, SourceType};
-use ruff_workspace::resolver::{python_files_in_path, ResolvedFile};
-use rustc_hash::FxHashMap;
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex};
-
-/// Generate an import map.
-pub(crate) fn analyze_graph(
-    args: AnalyzeGraphArgs,
-    config_arguments: &ConfigArguments,
-) -> Result<ExitStatus> {
-    // Construct the "default" settings. These are used when no `pyproject.toml`
-    // files are present, or files are injected from outside the hierarchy.
-    let pyproject_config = resolve(config_arguments, None)?;
-    if pyproject_config.settings.analyze.preview.is_disabled() {
-        warn_user!("`ruff analyze graph` is experimental and may change without warning");
-    }
-
-    // Write all paths relative to the current working directory.
-    let root =
-        SystemPathBuf::from_path_buf(CWD.clone()).expect("Expected a UTF-8 working directory");
-
-    // Find all Python files.
-    let files = resolve_default_files(args.files, false);
-    let (paths, resolver) = python_files_in_path(&files, &pyproject_config, config_arguments)?;
-
-    if paths.is_empty() {
-        warn_user_once!("No Python files found under the given path(s)");
-        return Ok(ExitStatus::Success);
-    }
-
-    // Resolve all package roots.
-    let package_roots = resolver
-        .package_roots(
-            &paths
-                .iter()
-                .flatten()
-                .map(ResolvedFile::path)
-                .collect::<Vec<_>>(),
-        )
-        .into_iter()
-        .map(|(path, package)| (path.to_path_buf(), package.map(Path::to_path_buf)))
-        .collect::<FxHashMap<_, _>>();
-
-    // Create a database from the source roots.
-    let db = ModuleDb::from_src_roots(
-        package_roots
-            .values()
-            .filter_map(|package| package.as_deref())
-            .filter_map(|package| package.parent())
-            .map(Path::to_path_buf)
-            .filter_map(|path| SystemPathBuf::from_path_buf(path).ok()),
-    )?;
-
-    // Create a cache for resolved globs.
-    let glob_resolver = Arc::new(Mutex::new(GlobResolver::default()));
-
-    // Collect and resolve the imports for each file.
-    let result = Arc::new(Mutex::new(Vec::new()));
-    let inner_result = Arc::clone(&result);
-
-    rayon::scope(move |scope| {
-        for resolved_file in paths {
-            let Ok(resolved_file) = resolved_file else {
-                continue;
-            };
-
-            let path = resolved_file.into_path();
-            let package = path
-                .parent()
-                .and_then(|parent| package_roots.get(parent))
-                .and_then(Clone::clone);
-
-            // Resolve the per-file settings.
-            let settings = resolver.resolve(&path);
-            let string_imports = settings.analyze.detect_string_imports;
-            let include_dependencies = settings.analyze.include_dependencies.get(&path).cloned();
-
-            // Ignore non-Python files.
-            let source_type = match settings.analyze.extension.get(&path) {
-                None => match SourceType::from(&path) {
-                    SourceType::Python(source_type) => source_type,
-                    SourceType::Toml(_) => {
-                        debug!("Ignoring TOML file: {}", path.display());
-                        continue;
-                    }
-                },
-                Some(language) => PySourceType::from(language),
-            };
-            if matches!(source_type, PySourceType::Ipynb) {
-                debug!("Ignoring Jupyter notebook: {}", path.display());
-                continue;
-            }
-
-            // Convert to system paths.
-            let Ok(package) = package.map(SystemPathBuf::from_path_buf).transpose() else {
-                warn!("Failed to convert package to system path");
-                continue;
-            };
-            let Ok(path) = SystemPathBuf::from_path_buf(path) else {
-                warn!("Failed to convert path to system path");
-                continue;
-            };
-
-            let db = db.snapshot();
-            let root = root.clone();
-            let result = inner_result.clone();
-            let glob_resolver = glob_resolver.clone();
-            scope.spawn(move |_| {
-                // Identify any imports via static analysis.
-                let mut imports =
-                    ruff_graph::generate(&path, package.as_deref(), string_imports, &db)
-                        .unwrap_or_else(|err| {
-                            warn!("Failed to generate import map for {path}: {err}");
-                            ModuleImports::default()
-                        });
-
-                debug!("Discovered {} imports for {}", imports.len(), path);
-
-                // Append any imports that were statically defined in the configuration.
-                if let Some((root, globs)) = include_dependencies {
-                    let mut glob_resolver = glob_resolver.lock().unwrap();
-                    imports.extend(glob_resolver.resolve(root, globs));
-                }
-
-                // Convert the path (and imports) to be relative to the working directory.
-                let path = path
-                    .strip_prefix(&root)
-                    .map(SystemPath::to_path_buf)
-                    .unwrap_or(path);
-                let imports = imports.relative_to(&root);
-
-                result.lock().unwrap().push((path, imports));
-            });
-        }
-    });
-
-    // Collect the results.
-    let imports = Arc::into_inner(result).unwrap().into_inner()?;
-
-    // Generate the import map.
-    let import_map = match args.direction {
-        Direction::Dependencies => ImportMap::from_iter(imports),
-        Direction::Dependents => ImportMap::reverse(imports),
-    };
-
-    // Print to JSON.
-    println!("{}", serde_json::to_string_pretty(&import_map)?);
-
-    Ok(ExitStatus::Success)
-}
-
-/// A resolver for glob sets.
-#[derive(Default, Debug)]
-struct GlobResolver {
-    cache: GlobCache,
-}
-
-impl GlobResolver {
-    /// Resolve a set of globs, anchored at a given root.
-    fn resolve(&mut self, root: PathBuf, globs: Vec<String>) -> Vec<SystemPathBuf> {
-        if let Some(cached) = self.cache.get(&root, &globs) {
-            return cached.clone();
-        }
-
-        let walker = match globwalk::GlobWalkerBuilder::from_patterns(&root, &globs)
-            .file_type(globwalk::FileType::FILE)
-            .build()
-        {
-            Ok(walker) => walker,
-            Err(err) => {
-                warn!("Failed to read glob walker: {err}");
-                return Vec::new();
-            }
-        };
-
-        let mut paths = Vec::new();
-        for entry in walker {
-            let entry = match entry {
-                Ok(entry) => entry,
-                Err(err) => {
-                    warn!("Failed to read glob entry: {err}");
-                    continue;
-                }
-            };
-            let path = match SystemPathBuf::from_path_buf(entry.into_path()) {
-                Ok(path) => path,
-                Err(err) => {
-                    warn!("Failed to convert path to system path: {}", err.display());
-                    continue;
-                }
-            };
-            paths.push(path);
-        }
-
-        self.cache.insert(root, globs, paths.clone());
-        paths
-    }
-}
-
-/// A cache for resolved globs.
-#[derive(Default, Debug)]
-struct GlobCache(FxHashMap<PathBuf, FxHashMap<Vec<String>, Vec<SystemPathBuf>>>);
-
-impl GlobCache {
-    /// Insert a resolved glob.
-    fn insert(&mut self, root: PathBuf, globs: Vec<String>, paths: Vec<SystemPathBuf>) {
-        self.0.entry(root).or_default().insert(globs, paths);
-    }
-
-    /// Get a resolved glob.
-    fn get(&self, root: &Path, globs: &[String]) -> Option<&Vec<SystemPathBuf>> {
-        self.0.get(root).and_then(|map| map.get(globs))
-    }
-}
--- a/crates/ruff/src/commands/mod.rs
+++ b/crates/ruff/src/commands/mod.rs
@@ -1,5 +1,4 @@
 pub(crate) mod add_noqa;
-pub(crate) mod analyze_graph;
 pub(crate) mod check;
 pub(crate) mod check_stdin;
 pub(crate) mod clean;
--- a/crates/ruff/src/lib.rs
+++ b/crates/ruff/src/lib.rs
@@ -20,9 +20,7 @@ use ruff_linter::settings::types::OutputFormat;
 use ruff_linter::{fs, warn_user, warn_user_once};
 use ruff_workspace::Settings;

-use crate::args::{
-    AnalyzeCommand, AnalyzeGraphCommand, Args, CheckCommand, Command, FormatCommand,
-};
+use crate::args::{Args, CheckCommand, Command, FormatCommand};
 use crate::printer::{Flags as PrinterFlags, Printer};

 pub mod args;
@@ -188,7 +186,6 @@ pub fn run(
        Command::Check(args) => check(args, global_options),
        Command::Format(args) => format(args, global_options),
        Command::Server(args) => server(args),
-        Command::Analyze(AnalyzeCommand::Graph(args)) => analyze_graph(args, global_options),
    }
 }

@@ -202,15 +199,6 @@ fn format(args: FormatCommand, global_options: GlobalConfigArgs) -> Result<ExitS
    }
 }

-fn analyze_graph(
-    args: AnalyzeGraphCommand,
-    global_options: GlobalConfigArgs,
-) -> Result<ExitStatus> {
-    let (cli, config_arguments) = args.partition(global_options)?;
-
-    commands::analyze_graph::analyze_graph(cli, &config_arguments)
-}
-
 fn server(args: ServerCommand) -> Result<ExitStatus> {
    let four = NonZeroUsize::new(4).unwrap();

--- a/crates/ruff/tests/analyze_graph.rs
+++ b/crates/ruff/tests/analyze_graph.rs
@@ -1,263 +0,0 @@
-//! Tests the interaction of the `analyze graph` command.
-
-#![cfg(not(target_arch = "wasm32"))]
-#![cfg(not(windows))]
-
-use assert_fs::prelude::*;
-use std::process::Command;
-use std::str;
-
-use anyhow::Result;
-use assert_fs::fixture::ChildPath;
-use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
-use tempfile::TempDir;
-
-fn command() -> Command {
-    let mut command = Command::new(get_cargo_bin("ruff"));
-    command.arg("analyze");
-    command.arg("graph");
-    command.arg("--preview");
-    command
-}
-
-const INSTA_FILTERS: &[(&str, &str)] = &[
-    // Rewrite Windows output to Unix output
-    (r"\\", "/"),
-];
-
-#[test]
-fn dependencies() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let root = ChildPath::new(tempdir.path());
-
-    root.child("ruff").child("__init__.py").write_str("")?;
-    root.child("ruff")
-        .child("a.py")
-        .write_str(indoc::indoc! {r#"
-        import ruff.b
-    "#})?;
-    root.child("ruff")
-        .child("b.py")
-        .write_str(indoc::indoc! {r#"
-        from ruff import c
-    "#})?;
-    root.child("ruff")
-        .child("c.py")
-        .write_str(indoc::indoc! {r#"
-        from . import d
-    "#})?;
-    root.child("ruff")
-        .child("d.py")
-        .write_str(indoc::indoc! {r#"
-        from .e import f
-    "#})?;
-    root.child("ruff")
-        .child("e.py")
-        .write_str(indoc::indoc! {r#"
-        def f(): pass
-    "#})?;
-
-    insta::with_settings!({
-        filters => INSTA_FILTERS.to_vec(),
-    }, {
-        assert_cmd_snapshot!(command().current_dir(&root), @r###"
-            success: true
-            exit_code: 0
-            ----- stdout -----
-            {
-              "ruff/__init__.py": [],
-              "ruff/a.py": [
-                "ruff/b.py"
-              ],
-              "ruff/b.py": [
-                "ruff/c.py"
-              ],
-              "ruff/c.py": [
-                "ruff/d.py"
-              ],
-              "ruff/d.py": [
-                "ruff/e.py"
-              ],
-              "ruff/e.py": []
-            }
-
-            ----- stderr -----
-            "###);
-    });
-
-    Ok(())
-}
-
-#[test]
-fn dependents() -> Result<()> {
-    let tempdir = TempDir::new()?;
-
-    let root = ChildPath::new(tempdir.path());
-
-    root.child("ruff").child("__init__.py").write_str("")?;
-    root.child("ruff")
-        .child("a.py")
-        .write_str(indoc::indoc! {r#"
-        import ruff.b
-    "#})?;
-    root.child("ruff")
-        .child("b.py")
-        .write_str(indoc::indoc! {r#"
-        from ruff import c
-    "#})?;
-    root.child("ruff")
-        .child("c.py")
-        .write_str(indoc::indoc! {r#"
-        from . import d
-    "#})?;
-    root.child("ruff")
-        .child("d.py")
-        .write_str(indoc::indoc! {r#"
-        from .e import f
-    "#})?;
-    root.child("ruff")
-        .child("e.py")
-        .write_str(indoc::indoc! {r#"
-        def f(): pass
-    "#})?;
-
-    insta::with_settings!({
-        filters => INSTA_FILTERS.to_vec(),
-    }, {
-        assert_cmd_snapshot!(command().arg("--direction").arg("dependents").current_dir(&root), @r###"
-            success: true
-            exit_code: 0
-            ----- stdout -----
-            {
-              "ruff/__init__.py": [],
-              "ruff/a.py": [],
-              "ruff/b.py": [
-                "ruff/a.py"
-              ],
-              "ruff/c.py": [
-                "ruff/b.py"
-              ],
-              "ruff/d.py": [
-                "ruff/c.py"
-              ],
-              "ruff/e.py": [
-                "ruff/d.py"
-              ]
-            }
-
-            ----- stderr -----
-            "###);
-    });
-
-    Ok(())
-}
-
-#[test]
-fn string_detection() -> Result<()> {
-    let tempdir = TempDir::new()?;
-
-    let root = ChildPath::new(tempdir.path());
-
-    root.child("ruff").child("__init__.py").write_str("")?;
-    root.child("ruff")
-        .child("a.py")
-        .write_str(indoc::indoc! {r#"
-        import ruff.b
-    "#})?;
-    root.child("ruff")
-        .child("b.py")
-        .write_str(indoc::indoc! {r#"
-        import importlib
-
-        importlib.import_module("ruff.c")
-    "#})?;
-    root.child("ruff").child("c.py").write_str("")?;
-
-    insta::with_settings!({
-        filters => INSTA_FILTERS.to_vec(),
-    }, {
-        assert_cmd_snapshot!(command().current_dir(&root), @r###"
-            success: true
-            exit_code: 0
-            ----- stdout -----
-            {
-              "ruff/__init__.py": [],
-              "ruff/a.py": [
-                "ruff/b.py"
-              ],
-              "ruff/b.py": [],
-              "ruff/c.py": []
-            }
-
-            ----- stderr -----
-            "###);
-    });
-
-    insta::with_settings!({
-        filters => INSTA_FILTERS.to_vec(),
-    }, {
-        assert_cmd_snapshot!(command().arg("--detect-string-imports").current_dir(&root), @r###"
-            success: true
-            exit_code: 0
-            ----- stdout -----
-            {
-              "ruff/__init__.py": [],
-              "ruff/a.py": [
-                "ruff/b.py"
-              ],
-              "ruff/b.py": [
-                "ruff/c.py"
-              ],
-              "ruff/c.py": []
-            }
-
-            ----- stderr -----
-            "###);
-    });
-
-    Ok(())
-}
-
-#[test]
-fn globs() -> Result<()> {
-    let tempdir = TempDir::new()?;
-
-    let root = ChildPath::new(tempdir.path());
-
-    root.child("ruff.toml").write_str(indoc::indoc! {r#"
-        [analyze]
-        include-dependencies = { "ruff/a.py" = ["ruff/b.py"], "ruff/b.py" = ["ruff/*.py"] }
-    "#})?;
-
-    root.child("ruff").child("__init__.py").write_str("")?;
-    root.child("ruff").child("a.py").write_str("")?;
-    root.child("ruff").child("b.py").write_str("")?;
-    root.child("ruff").child("c.py").write_str("")?;
-
-    insta::with_settings!({
-        filters => INSTA_FILTERS.to_vec(),
-    }, {
-        assert_cmd_snapshot!(command().current_dir(&root), @r###"
-        success: true
-        exit_code: 0
-        ----- stdout -----
-        {
-          "ruff/__init__.py": [],
-          "ruff/a.py": [
-            "ruff/b.py"
-          ],
-          "ruff/b.py": [
-            "ruff/__init__.py",
-            "ruff/a.py",
-            "ruff/b.py",
-            "ruff/c.py"
-          ],
-          "ruff/c.py": []
-        }
-
-        ----- stderr -----
-        "###);
-    });
-
-    Ok(())
-}
--- a/crates/ruff/tests/format.rs
+++ b/crates/ruff/tests/format.rs
@@ -326,18 +326,18 @@ fn docstring_options() -> Result<()> {
    let ruff_toml = tempdir.path().join("ruff.toml");
    fs::write(
        &ruff_toml,
-        r"
+        r#"
 [format]
 docstring-code-format = true
 docstring-code-line-length = 20
-",
+"#,
    )?;

    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
        .args(["format", "--config"])
        .arg(&ruff_toml)
        .arg("-")
-        .pass_stdin(r"
+        .pass_stdin(r#"
 def f(x):
    '''
    Something about `f`. And an example:
@@ -357,7 +357,7 @@ def f(x):
    >>> foo, bar, quux = this_is_a_long_line(lion, hippo, lemur, bear)
    '''
    pass
-"), @r###"
+"#), @r###"
    success: true
    exit_code: 0
    ----- stdout -----
@@ -509,9 +509,9 @@ fn syntax_error() -> Result<()> {

    fs::write(
        tempdir.path().join("main.py"),
-        r"
+        r#"
 from module import =
-",
+"#,
    )?;

    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
@@ -1945,10 +1945,11 @@ fn range_end_only() {
 def foo(arg1, arg2,):
    print("Should format this" )

-"#), @r#"
+"#), @r###"
    success: true
    exit_code: 0
    ----- stdout -----
+
    def foo(
        arg1,
        arg2,
@@ -1957,7 +1958,7 @@ def foo(arg1, arg2,):


    ----- stderr -----
-    "#);
+    "###);
 }

 #[test]
--- a/crates/ruff/tests/integration_test.rs
+++ b/crates/ruff/tests/integration_test.rs
@@ -158,15 +158,15 @@ fn check_default_files() -> Result<()> {
    let tempdir = TempDir::new()?;
    fs::write(
        tempdir.path().join("foo.py"),
-        r"
+        r#"
 import foo   # unused import
-",
+"#,
    )?;
    fs::write(
        tempdir.path().join("bar.py"),
-        r"
+        r#"
 import bar   # unused import
-",
+"#,
    )?;

    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
@@ -906,10 +906,10 @@ fn full_output_preview_config() -> Result<()> {
    let pyproject_toml = tempdir.path().join("pyproject.toml");
    fs::write(
        &pyproject_toml,
-        r"
+        r#"
 [tool.ruff]
 preview = true
-",
+"#,
    )?;
    let mut cmd = RuffCheck::default().config(&pyproject_toml).build();
    assert_cmd_snapshot!(cmd.pass_stdin("l = 1"), @r###"
--- a/crates/ruff/tests/snapshots/show_settings__display_default_settings.snap
+++ b/crates/ruff/tests/snapshots/show_settings__display_default_settings.snap
@@ -200,7 +200,7 @@ linter.safety_table.forced_unsafe = []
 linter.target_version = Py37
 linter.preview = disabled
 linter.explicit_preview_rules = false
-linter.extension = ExtensionMapping({})
+linter.extension.mapping = {}
 linter.allowed_confusables = []
 linter.builtins = []
 linter.dummy_variable_rgx = ^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$
@@ -388,10 +388,4 @@ formatter.magic_trailing_comma = respect
 formatter.docstring_code_format = disabled
 formatter.docstring_code_line_width = dynamic

-# Analyze Settings
-analyze.preview = disabled
-analyze.detect_string_imports = false
-analyze.extension = ExtensionMapping({})
-analyze.include_dependencies = {}
-
 ----- stderr -----
--- a/crates/ruff_benchmark/benches/linter.rs
+++ b/crates/ruff_benchmark/benches/linter.rs
@@ -28,24 +28,6 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 #[global_allocator]
 static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;

-// Disable decay after 10s because it can show up as *random* slow allocations
-// in benchmarks. We don't need purging in benchmarks because it isn't important
-// to give unallocated pages back to the OS.
-// https://jemalloc.net/jemalloc.3.html#opt.dirty_decay_ms
-#[cfg(all(
-    not(target_os = "windows"),
-    not(target_os = "openbsd"),
-    any(
-        target_arch = "x86_64",
-        target_arch = "aarch64",
-        target_arch = "powerpc64"
-    )
-))]
-#[allow(non_upper_case_globals)]
-#[export_name = "_rjem_malloc_conf"]
-#[allow(unsafe_code)]
-pub static _rjem_malloc_conf: &[u8] = b"dirty_decay_ms:-1,muzzy_decay_ms:-1\0";
-
 fn create_test_cases() -> Result<Vec<TestCase>, TestFileDownloadError> {
    Ok(vec![
        TestCase::fast(TestFile::try_download("numpy/globals.py", "https://raw.githubusercontent.com/numpy/numpy/89d64415e349ca75a25250f22b874aa16e5c0973/numpy/_globals.py")?),
--- a/crates/ruff_benchmark/benches/red_knot.rs
+++ b/crates/ruff_benchmark/benches/red_knot.rs
@@ -32,6 +32,7 @@ static EXPECTED_DIAGNOSTICS: &[&str] = &[
    "Use double quotes for strings",
    "Use double quotes for strings",
    "Use double quotes for strings",
+    "/src/tomllib/_parser.py:628:75: Name 'e' used when not defined.",
 ];

 fn get_test_file(name: &str) -> TestFile {
--- a/crates/ruff_db/Cargo.toml
+++ b/crates/ruff_db/Cargo.toml
@@ -26,7 +26,6 @@ filetime = { workspace = true }
 ignore = { workspace = true, optional = true }
 matchit = { workspace = true }
 salsa = { workspace = true }
-serde = { workspace = true, optional = true }
 path-slash = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
@@ -48,6 +47,5 @@ tempfile = { workspace = true }
 [features]
 cache = ["ruff_cache"]
 os = ["ignore"]
-serde = ["dep:serde", "camino/serde1"]
 # Exposes testing utilities.
 testing = ["tracing-subscriber", "tracing-tree"]
--- a/crates/ruff_db/src/display.rs
+++ b/crates/ruff_db/src/display.rs
@@ -1,52 +0,0 @@
-use std::fmt::{self, Display, Formatter};
-
-pub trait FormatterJoinExtension<'b> {
-    fn join<'a>(&'a mut self, separator: &'static str) -> Join<'a, 'b>;
-}
-
-impl<'b> FormatterJoinExtension<'b> for Formatter<'b> {
-    fn join<'a>(&'a mut self, separator: &'static str) -> Join<'a, 'b> {
-        Join {
-            fmt: self,
-            separator,
-            result: fmt::Result::Ok(()),
-            seen_first: false,
-        }
-    }
-}
-
-pub struct Join<'a, 'b> {
-    fmt: &'a mut Formatter<'b>,
-    separator: &'static str,
-    result: fmt::Result,
-    seen_first: bool,
-}
-
-impl<'a, 'b> Join<'a, 'b> {
-    pub fn entry(&mut self, item: &dyn Display) -> &mut Self {
-        if self.seen_first {
-            self.result = self
-                .result
-                .and_then(|()| self.fmt.write_str(self.separator));
-        } else {
-            self.seen_first = true;
-        }
-        self.result = self.result.and_then(|()| item.fmt(self.fmt));
-        self
-    }
-
-    pub fn entries<I, F>(&mut self, items: I) -> &mut Self
-    where
-        I: IntoIterator<Item = F>,
-        F: Display,
-    {
-        for item in items {
-            self.entry(&item);
-        }
-        self
-    }
-
-    pub fn finish(&mut self) -> fmt::Result {
-        self.result
-    }
-}
--- a/crates/ruff_db/src/lib.rs
+++ b/crates/ruff_db/src/lib.rs
@@ -6,7 +6,6 @@ use crate::files::Files;
 use crate::system::System;
 use crate::vendored::VendoredFileSystem;

-pub mod display;
 pub mod file_revision;
 pub mod files;
 pub mod parsed;
--- a/crates/ruff_db/src/system/os.rs
+++ b/crates/ruff_db/src/system/os.rs
@@ -16,7 +16,7 @@ use super::walk_directory::{
 };

 /// A system implementation that uses the OS file system.
-#[derive(Default, Debug, Clone)]
+#[derive(Default, Debug)]
 pub struct OsSystem {
    inner: Arc<OsSystemInner>,
 }
--- a/crates/ruff_db/src/system/path.rs
+++ b/crates/ruff_db/src/system/path.rs
@@ -593,27 +593,6 @@ impl ruff_cache::CacheKey for SystemPathBuf {
    }
 }

-#[cfg(feature = "serde")]
-impl serde::Serialize for SystemPath {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.0.serialize(serializer)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for SystemPathBuf {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.0.serialize(serializer)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for SystemPathBuf {
-    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        Utf8PathBuf::deserialize(deserializer).map(SystemPathBuf)
-    }
-}
-
 /// A slice of a virtual path on [`System`](super::System) (akin to [`str`]).
 #[repr(transparent)]
 pub struct SystemVirtualPath(str);
--- a/crates/ruff_dev/src/generate_docs.rs
+++ b/crates/ruff_dev/src/generate_docs.rs
@@ -6,7 +6,6 @@ use std::fs;
 use std::path::PathBuf;

 use anyhow::Result;
-use itertools::Itertools;
 use regex::{Captures, Regex};
 use strum::IntoEnumIterator;

@@ -34,26 +33,7 @@ pub(crate) fn main(args: &Args) -> Result<()> {

            let (linter, _) = Linter::parse_code(&rule.noqa_code().to_string()).unwrap();
            if linter.url().is_some() {
-                let common_prefix: String = match linter.common_prefix() {
-                    "" => linter
-                        .upstream_categories()
-                        .unwrap()
-                        .iter()
-                        .map(|c| c.prefix)
-                        .join("-"),
-                    prefix => prefix.to_string(),
-                };
-                let anchor = format!(
-                    "{}-{}",
-                    linter.name().to_lowercase(),
-                    common_prefix.to_lowercase()
-                );
-
-                output.push_str(&format!(
-                    "Derived from the **[{}](../rules.md#{})** linter.",
-                    linter.name(),
-                    anchor
-                ));
+                output.push_str(&format!("Derived from the **{}** linter.", linter.name()));
                output.push('\n');
                output.push('\n');
            }
--- a/crates/ruff_graph/Cargo.toml
+++ b/crates/ruff_graph/Cargo.toml
@@ -1,31 +0,0 @@
-[package]
-name = "ruff_graph"
-version = "0.1.0"
-edition.workspace = true
-rust-version.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-repository.workspace = true
-authors.workspace = true
-license.workspace = true
-
-[dependencies]
-red_knot_python_semantic = { workspace = true }
-ruff_cache = { workspace = true }
-ruff_db = { workspace = true, features = ["os", "serde"] }
-ruff_linter = { workspace = true }
-ruff_macros = { workspace = true }
-ruff_python_ast = { workspace = true }
-
-anyhow = { workspace = true }
-clap = { workspace = true, optional = true }
-salsa = { workspace = true }
-schemars = { workspace = true, optional = true }
-serde = { workspace = true, optional = true }
-
-[lints]
-workspace = true
-
-[package.metadata.cargo-shear]
-# Used via `CacheKey` macro expansion.
-ignored = ["ruff_cache"]
--- a/crates/ruff_graph/src/collector.rs
+++ b/crates/ruff_graph/src/collector.rs
@@ -1,111 +0,0 @@
-use red_knot_python_semantic::ModuleName;
-use ruff_python_ast::visitor::source_order::{walk_body, walk_expr, walk_stmt, SourceOrderVisitor};
-use ruff_python_ast::{self as ast, Expr, ModModule, Stmt};
-
-/// Collect all imports for a given Python file.
-#[derive(Default, Debug)]
-pub(crate) struct Collector<'a> {
-    /// The path to the current module.
-    module_path: Option<&'a [String]>,
-    /// Whether to detect imports from string literals.
-    string_imports: bool,
-    /// The collected imports from the Python AST.
-    imports: Vec<CollectedImport>,
-}
-
-impl<'a> Collector<'a> {
-    pub(crate) fn new(module_path: Option<&'a [String]>, string_imports: bool) -> Self {
-        Self {
-            module_path,
-            string_imports,
-            imports: Vec::new(),
-        }
-    }
-
-    #[must_use]
-    pub(crate) fn collect(mut self, module: &ModModule) -> Vec<CollectedImport> {
-        walk_body(&mut self, &module.body);
-        self.imports
-    }
-}
-
-impl<'ast> SourceOrderVisitor<'ast> for Collector<'_> {
-    fn visit_stmt(&mut self, stmt: &'ast Stmt) {
-        match stmt {
-            Stmt::ImportFrom(ast::StmtImportFrom {
-                names,
-                module,
-                level,
-                range: _,
-            }) => {
-                let module = module.as_deref();
-                let level = *level;
-                for alias in names {
-                    let mut components = vec![];
-
-                    if level > 0 {
-                        // If we're resolving a relative import, we must have a module path.
-                        let Some(module_path) = self.module_path else {
-                            return;
-                        };
-
-                        // Start with the containing module.
-                        components.extend(module_path.iter().map(String::as_str));
-
-                        // Remove segments based on the number of dots.
-                        for _ in 0..level {
-                            if components.is_empty() {
-                                return;
-                            }
-                            components.pop();
-                        }
-                    }
-
-                    // Add the module path.
-                    if let Some(module) = module {
-                        components.extend(module.split('.'));
-                    }
-
-                    // Add the alias name.
-                    components.push(alias.name.as_str());
-
-                    if let Some(module_name) = ModuleName::from_components(components) {
-                        self.imports.push(CollectedImport::ImportFrom(module_name));
-                    }
-                }
-            }
-            Stmt::Import(ast::StmtImport { names, range: _ }) => {
-                for alias in names {
-                    if let Some(module_name) = ModuleName::new(alias.name.as_str()) {
-                        self.imports.push(CollectedImport::Import(module_name));
-                    }
-                }
-            }
-            _ => {
-                walk_stmt(self, stmt);
-            }
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &'ast Expr) {
-        if self.string_imports {
-            if let Expr::StringLiteral(ast::ExprStringLiteral { value, range: _ }) = expr {
-                // Determine whether the string literal "looks like" an import statement: contains
-                // a dot, and consists solely of valid Python identifiers.
-                let value = value.to_str();
-                if let Some(module_name) = ModuleName::new(value) {
-                    self.imports.push(CollectedImport::Import(module_name));
-                }
-            }
-            walk_expr(self, expr);
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(crate) enum CollectedImport {
-    /// The import was part of an `import` statement.
-    Import(ModuleName),
-    /// The import was part of an `import from` statement.
-    ImportFrom(ModuleName),
-}
--- a/crates/ruff_graph/src/db.rs
+++ b/crates/ruff_graph/src/db.rs
@@ -1,94 +0,0 @@
-use anyhow::Result;
-use red_knot_python_semantic::{Db, Program, ProgramSettings, PythonVersion, SearchPathSettings};
-use ruff_db::files::{File, Files};
-use ruff_db::system::{OsSystem, System, SystemPathBuf};
-use ruff_db::vendored::VendoredFileSystem;
-use ruff_db::{Db as SourceDb, Upcast};
-
-#[salsa::db]
-#[derive(Default)]
-pub struct ModuleDb {
-    storage: salsa::Storage<Self>,
-    files: Files,
-    system: OsSystem,
-    vendored: VendoredFileSystem,
-}
-
-impl ModuleDb {
-    /// Initialize a [`ModuleDb`] from the given source root.
-    pub fn from_src_roots(mut src_roots: impl Iterator<Item = SystemPathBuf>) -> Result<Self> {
-        let search_paths = {
-            // Use the first source root.
-            let src_root = src_roots
-                .next()
-                .ok_or_else(|| anyhow::anyhow!("No source roots provided"))?;
-
-            let mut search_paths = SearchPathSettings::new(src_root.to_path_buf());
-
-            // Add the remaining source roots as extra paths.
-            for src_root in src_roots {
-                search_paths.extra_paths.push(src_root.to_path_buf());
-            }
-
-            search_paths
-        };
-
-        let db = Self::default();
-        Program::from_settings(
-            &db,
-            &ProgramSettings {
-                target_version: PythonVersion::default(),
-                search_paths,
-            },
-        )?;
-
-        Ok(db)
-    }
-
-    /// Create a snapshot of the current database.
-    #[must_use]
-    pub fn snapshot(&self) -> Self {
-        Self {
-            storage: self.storage.clone(),
-            system: self.system.clone(),
-            vendored: self.vendored.clone(),
-            files: self.files.snapshot(),
-        }
-    }
-}
-
-impl Upcast<dyn SourceDb> for ModuleDb {
-    fn upcast(&self) -> &(dyn SourceDb + 'static) {
-        self
-    }
-    fn upcast_mut(&mut self) -> &mut (dyn SourceDb + 'static) {
-        self
-    }
-}
-
-#[salsa::db]
-impl SourceDb for ModuleDb {
-    fn vendored(&self) -> &VendoredFileSystem {
-        &self.vendored
-    }
-
-    fn system(&self) -> &dyn System {
-        &self.system
-    }
-
-    fn files(&self) -> &Files {
-        &self.files
-    }
-}
-
-#[salsa::db]
-impl Db for ModuleDb {
-    fn is_file_open(&self, file: File) -> bool {
-        !file.path(self).is_vendored_path()
-    }
-}
-
-#[salsa::db]
-impl salsa::Database for ModuleDb {
-    fn salsa_event(&self, _event: &dyn Fn() -> salsa::Event) {}
-}
--- a/crates/ruff_graph/src/lib.rs
+++ b/crates/ruff_graph/src/lib.rs
@@ -1,125 +0,0 @@
-use crate::collector::Collector;
-pub use crate::db::ModuleDb;
-use crate::resolver::Resolver;
-pub use crate::settings::{AnalyzeSettings, Direction};
-use anyhow::Result;
-use red_knot_python_semantic::SemanticModel;
-use ruff_db::files::system_path_to_file;
-use ruff_db::parsed::parsed_module;
-use ruff_db::system::{SystemPath, SystemPathBuf};
-use ruff_python_ast::helpers::to_module_path;
-use serde::{Deserialize, Serialize};
-use std::collections::{BTreeMap, BTreeSet};
-
-mod collector;
-mod db;
-mod resolver;
-mod settings;
-
-#[derive(Debug, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct ModuleImports(BTreeSet<SystemPathBuf>);
-
-impl ModuleImports {
-    /// Insert a file path into the module imports.
-    pub fn insert(&mut self, path: SystemPathBuf) {
-        self.0.insert(path);
-    }
-
-    /// Extend the module imports with additional file paths.
-    pub fn extend(&mut self, paths: impl IntoIterator<Item = SystemPathBuf>) {
-        self.0.extend(paths);
-    }
-
-    /// Returns `true` if the module imports are empty.
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-
-    /// Returns the number of module imports.
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    /// Convert the file paths to be relative to a given path.
-    #[must_use]
-    pub fn relative_to(self, path: &SystemPath) -> Self {
-        Self(
-            self.0
-                .into_iter()
-                .map(|import| {
-                    import
-                        .strip_prefix(path)
-                        .map(SystemPath::to_path_buf)
-                        .unwrap_or(import)
-                })
-                .collect(),
-        )
-    }
-}
-
-#[derive(Debug, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct ImportMap(BTreeMap<SystemPathBuf, ModuleImports>);
-
-impl ImportMap {
-    /// Insert a module's imports into the map.
-    pub fn insert(&mut self, path: SystemPathBuf, imports: ModuleImports) {
-        self.0.insert(path, imports);
-    }
-
-    /// Reverse the [`ImportMap`], e.g., to convert from dependencies to dependents.
-    #[must_use]
-    pub fn reverse(imports: impl IntoIterator<Item = (SystemPathBuf, ModuleImports)>) -> Self {
-        let mut reverse = ImportMap::default();
-        for (path, imports) in imports {
-            for import in imports.0 {
-                reverse.0.entry(import).or_default().insert(path.clone());
-            }
-            reverse.0.entry(path).or_default();
-        }
-        reverse
-    }
-}
-
-impl FromIterator<(SystemPathBuf, ModuleImports)> for ImportMap {
-    fn from_iter<I: IntoIterator<Item = (SystemPathBuf, ModuleImports)>>(iter: I) -> Self {
-        let mut map = ImportMap::default();
-        for (path, imports) in iter {
-            map.0.entry(path).or_default().0.extend(imports.0);
-        }
-        map
-    }
-}
-
-/// Generate the module imports for a given Python file.
-pub fn generate(
-    path: &SystemPath,
-    package: Option<&SystemPath>,
-    string_imports: bool,
-    db: &ModuleDb,
-) -> Result<ModuleImports> {
-    // Read and parse the source code.
-    let file = system_path_to_file(db, path)?;
-    let parsed = parsed_module(db, file);
-    let module_path =
-        package.and_then(|package| to_module_path(package.as_std_path(), path.as_std_path()));
-    let model = SemanticModel::new(db, file);
-
-    // Collect the imports.
-    let imports = Collector::new(module_path.as_deref(), string_imports).collect(parsed.syntax());
-
-    // Resolve the imports.
-    let mut resolved_imports = ModuleImports::default();
-    for import in imports {
-        let Some(resolved) = Resolver::new(&model).resolve(import) else {
-            continue;
-        };
-        let Some(path) = resolved.as_system_path() else {
-            continue;
-        };
-        resolved_imports.insert(path.to_path_buf());
-    }
-
-    Ok(resolved_imports)
-}
--- a/crates/ruff_graph/src/resolver.rs
+++ b/crates/ruff_graph/src/resolver.rs
@@ -1,39 +0,0 @@
-use red_knot_python_semantic::SemanticModel;
-use ruff_db::files::FilePath;
-
-use crate::collector::CollectedImport;
-
-/// Collect all imports for a given Python file.
-pub(crate) struct Resolver<'a> {
-    semantic: &'a SemanticModel<'a>,
-}
-
-impl<'a> Resolver<'a> {
-    /// Initialize a [`Resolver`] with a given [`SemanticModel`].
-    pub(crate) fn new(semantic: &'a SemanticModel<'a>) -> Self {
-        Self { semantic }
-    }
-
-    /// Resolve the [`CollectedImport`] into a [`FilePath`].
-    pub(crate) fn resolve(&self, import: CollectedImport) -> Option<&'a FilePath> {
-        match import {
-            CollectedImport::Import(import) => self
-                .semantic
-                .resolve_module(import)
-                .map(|module| module.file().path(self.semantic.db())),
-            CollectedImport::ImportFrom(import) => {
-                // Attempt to resolve the member (e.g., given `from foo import bar`, look for `foo.bar`).
-                let parent = import.parent();
-                self.semantic
-                    .resolve_module(import)
-                    .map(|module| module.file().path(self.semantic.db()))
-                    .or_else(|| {
-                        // Attempt to resolve the module (e.g., given `from foo import bar`, look for `foo`).
-                        self.semantic
-                            .resolve_module(parent?)
-                            .map(|module| module.file().path(self.semantic.db()))
-                    })
-            }
-        }
-    }
-}
--- a/crates/ruff_graph/src/settings.rs
+++ b/crates/ruff_graph/src/settings.rs
@@ -1,52 +0,0 @@
-use ruff_linter::display_settings;
-use ruff_linter::settings::types::{ExtensionMapping, PreviewMode};
-use ruff_macros::CacheKey;
-use std::collections::BTreeMap;
-use std::fmt;
-use std::path::PathBuf;
-
-#[derive(Debug, Default, Clone, CacheKey)]
-pub struct AnalyzeSettings {
-    pub preview: PreviewMode,
-    pub detect_string_imports: bool,
-    pub include_dependencies: BTreeMap<PathBuf, (PathBuf, Vec<String>)>,
-    pub extension: ExtensionMapping,
-}
-
-impl fmt::Display for AnalyzeSettings {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(f, "\n# Analyze Settings")?;
-        display_settings! {
-            formatter = f,
-            namespace = "analyze",
-            fields = [
-                self.preview,
-                self.detect_string_imports,
-                self.extension | debug,
-                self.include_dependencies | debug,
-            ]
-        }
-        Ok(())
-    }
-}
-
-#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, CacheKey)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
-pub enum Direction {
-    /// Construct a map from module to its dependencies (i.e., the modules that it imports).
-    #[default]
-    Dependencies,
-    /// Construct a map from module to its dependents (i.e., the modules that import it).
-    Dependents,
-}
-
-impl fmt::Display for Direction {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Dependencies => write!(f, "\"dependencies\""),
-            Self::Dependents => write!(f, "\"dependents\""),
-        }
-    }
-}
--- a/crates/ruff_linter/Cargo.toml
+++ b/crates/ruff_linter/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.6.6"
+version = "0.6.3"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -73,7 +73,7 @@ unicode-normalization = { workspace = true }
 url = { workspace = true }

 [dev-dependencies]
-insta = { workspace = true, features = ["filters", "json", "redactions"] }
+insta = { workspace = true }
 test-case = { workspace = true }
 # Disable colored output in tests
 colored = { workspace = true, features = ["no-color"] }
--- a/crates/ruff_linter/resources/test/fixtures/eradicate/ERA001.py
+++ b/crates/ruff_linter/resources/test/fixtures/eradicate/ERA001.py
@@ -57,18 +57,7 @@ dictionary = {
 # ]
 # ///

-# Script tag with multiple closing tags (OK)
-# /// script
-# [tool.uv]
-# extra-index-url = ["https://pypi.org/simple", """\
-# https://example.com/
-# ///
-# """
-# ]
-# ///
-print(1)
-
-# Script tag without a closing tag (Error)
+# Script tag without a closing tag (OK)

 # /// script
 # requires-python = ">=3.11"
--- a/crates/ruff_linter/resources/test/fixtures/fastapi/FAST003.py
+++ b/crates/ruff_linter/resources/test/fixtures/fastapi/FAST003.py
@@ -1,6 +1,4 @@
-from typing import Annotated
-
-from fastapi import FastAPI, Path
+from fastapi import FastAPI

 app = FastAPI()

@@ -84,11 +82,6 @@ async def read_thing(
    return {"query": query}


-@app.get("/books/{name}/{title}")
-async def read_thing(*, author: Annotated[str, Path(alias="author_name")], title: str):
-    return {"author": author, "title": title}
-
-
 # OK
@app.get("/things/{thing_id}")
 async def read_thing(thing_id: int, query: str):
@@ -125,11 +118,6 @@ async def read_thing(*, author: str, title: str):
    return {"author": author, "title": title}


-@app.get("/books/{name}/{title}")
-async def read_thing(*, author: Annotated[str, Path(alias="name")], title: str):
-    return {"author": author, "title": title}
-
-
 # Ignored
@app.get("/things/{thing-id}")
 async def read_thing(query: str):
@@ -143,4 +131,4 @@ async def read_thing(query: str):

@app.get("/things/{thing_id=}")
 async def read_thing(query: str):
-    return {"query": query}
+    return {"query": query}
--- a/crates/ruff_linter/resources/test/fixtures/pydoclint/DOC201_google.py
+++ b/crates/ruff_linter/resources/test/fixtures/pydoclint/DOC201_google.py
@@ -207,10 +207,3 @@ def foo(s: str) -> str | None:
        s (str): A string.
    """
    return None
-
-
-class Spam:
-    # OK
-    def __new__(cls) -> 'Spam':
-        """New!!"""
-        return cls()
--- a/crates/ruff_linter/resources/test/fixtures/pydocstyle/D402.py
+++ b/crates/ruff_linter/resources/test/fixtures/pydocstyle/D402.py
@@ -1,8 +0,0 @@
-def foo():
-    """Returns foo()."""
-
-def foo():
-    """"Use prefix_foo()."""
-
-def foo():
-    """"Use this function; foo()."""
--- a/crates/ruff_linter/resources/test/fixtures/pylint/bad_dunder_method_name.py
+++ b/crates/ruff_linter/resources/test/fixtures/pylint/bad_dunder_method_name.py
@@ -94,9 +94,6 @@ class Apples:
    def __mro_entries__(self, bases):
        pass

-    # Removed with Python 3
-    def __unicode__(self):
-        pass

 def __foo_bar__():  # this is not checked by the [bad-dunder-name] rule
    ...
--- a/crates/ruff_linter/resources/test/fixtures/refurb/FURB188.py
+++ b/crates/ruff_linter/resources/test/fixtures/refurb/FURB188.py
@@ -1,172 +0,0 @@
-# Test suite from Refurb
-# See https://github.com/dosisod/refurb/blob/db02242b142285e615a664a8d3324470bb711306/test/data/err_188.py
-
-# these should match
-
-def remove_extension_via_slice(filename: str) -> str:
-    if filename.endswith(".txt"):
-        filename = filename[:-4]
-
-    return filename
-
-
-def remove_extension_via_slice_len(filename: str, extension: str) -> str:
-    if filename.endswith(extension):
-        filename = filename[:-len(extension)]
-
-    return filename
-
-
-def remove_extension_via_ternary(filename: str) -> str:
-    return filename[:-4] if filename.endswith(".txt") else filename
-
-
-def remove_extension_via_ternary_with_len(filename: str, extension: str) -> str:
-    return filename[:-len(extension)] if filename.endswith(extension) else filename
-
-
-def remove_prefix(filename: str) -> str:
-    return filename[4:] if filename.startswith("abc-") else filename
-
-
-def remove_prefix_via_len(filename: str, prefix: str) -> str:
-    return filename[len(prefix):] if filename.startswith(prefix) else filename
-
-
-# these should not
-
-def remove_extension_with_mismatched_len(filename: str) -> str:
-    if filename.endswith(".txt"):
-        filename = filename[:3]
-
-    return filename
-
-
-def remove_extension_assign_to_different_var(filename: str) -> str:
-    if filename.endswith(".txt"):
-        other_var = filename[:-4]
-
-    return filename
-
-
-def remove_extension_with_multiple_stmts(filename: str) -> str:
-    if filename.endswith(".txt"):
-        print("do some work")
-
-        filename = filename[:-4]
-
-    if filename.endswith(".txt"):
-        filename = filename[:-4]
-
-        print("do some work")
-
-    return filename
-
-
-def remove_extension_from_unrelated_var(filename: str) -> str:
-    xyz = "abc.txt"
-
-    if filename.endswith(".txt"):
-        filename = xyz[:-4]
-
-    return filename
-
-
-def remove_extension_in_elif(filename: str) -> str:
-    if filename:
-        pass
-
-    elif filename.endswith(".txt"):
-        filename = filename[:-4]
-
-    return filename
-
-
-def remove_extension_in_multiple_elif(filename: str) -> str:
-    if filename:
-        pass
-
-    elif filename:
-        pass
-
-    elif filename.endswith(".txt"):
-        filename = filename[:-4]
-
-    return filename
-
-
-def remove_extension_in_if_with_else(filename: str) -> str:
-    if filename.endswith(".txt"):
-        filename = filename[:-4]
-
-    else:
-        pass
-
-    return filename
-
-
-def remove_extension_ternary_name_mismatch(filename: str):
-    xyz = ""
-
-    _ = xyz[:-4] if filename.endswith(".txt") else filename
-    _ = filename[:-4] if xyz.endswith(".txt") else filename
-    _ = filename[:-4] if filename.endswith(".txt") else xyz
-
-
-def remove_extension_slice_amount_mismatch(filename: str) -> None:
-    extension = ".txt"
-
-    _ = filename[:-1] if filename.endswith(".txt") else filename
-    _ = filename[:-1] if filename.endswith(extension) else filename
-    _ = filename[:-len("")] if filename.endswith(extension) else filename
-
-
-def remove_prefix_size_mismatch(filename: str) -> str:
-    return filename[3:] if filename.startswith("abc-") else filename
-
-
-def remove_prefix_name_mismatch(filename: str) -> None:
-    xyz = ""
-
-    _ = xyz[4:] if filename.startswith("abc-") else filename
-    _ = filename[4:] if xyz.startswith("abc-") else filename
-    _ = filename[4:] if filename.startswith("abc-") else xyz
-
-# ---- End of refurb test suite ---- #
-
-# ---- Begin ruff specific test suite --- #
-
-# these should be linted
-
-def remove_suffix_multiple_attribute_expr() -> None:
-    import foo.bar
-
-    SUFFIX = "suffix"
-
-    x = foo.bar.baz[:-len(SUFFIX)] if foo.bar.baz.endswith(SUFFIX) else foo.bar.baz
-
-def remove_prefix_comparable_literal_expr() -> None:
-    return ("abc" "def")[3:] if ("abc" "def").startswith("abc") else "abc" "def"
-
-def shadow_builtins(filename: str, extension: str) -> None:
-    from builtins import len as builtins_len
-
-    return filename[:-builtins_len(extension)] if filename.endswith(extension) else filename
-
-def okay_steps():
-    text = "!x!y!z"
-    if text.startswith("!"):
-        text = text[1::1]
-    if text.startswith("!"):
-        text = text[1::True]
-    if text.startswith("!"):
-        text = text[1::None]
-    print(text)
-
-
-# this should be skipped
-def ignore_step():
-    text = "!x!y!z"
-    if text.startswith("!"):
-        text = text[1::2]
-    print(text)
--- a/crates/ruff_linter/resources/test/fixtures/ruff/RUF032.py
+++ b/crates/ruff_linter/resources/test/fixtures/ruff/RUF032.py
@@ -50,13 +50,6 @@ a = 10.0

 val = Decimal(a)

-# See https://github.com/astral-sh/ruff/issues/13258
-val = Decimal(~4.0) # Skip
-
-val = Decimal(++4.0) # Suggest `Decimal("4.0")`
-
-val = Decimal(-+--++--4.0) # Suggest `Decimal("-4.0")` 
-

 # Tests with shadowed name
 class Decimal():
--- a/crates/ruff_linter/resources/test/fixtures/ruff/RUF034.py
+++ b/crates/ruff_linter/resources/test/fixtures/ruff/RUF034.py
@@ -1,11 +0,0 @@
-# Valid
-x = 1 if True else 2
-
-# Invalid
-x = 1 if True else 1
-
-# Invalid
-x = "a" if True else "a"
-
-# Invalid
-x = 0.1 if False else 0.1
--- a/crates/ruff_linter/src/checkers/ast/analyze/expression.rs
+++ b/crates/ruff_linter/src/checkers/ast/analyze/expression.rs
@@ -1404,12 +1404,6 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
            if checker.enabled(Rule::IfExpInsteadOfOrOperator) {
                refurb::rules::if_exp_instead_of_or_operator(checker, if_exp);
            }
-            if checker.enabled(Rule::UselessIfElse) {
-                ruff::rules::useless_if_else(checker, if_exp);
-            }
-            if checker.enabled(Rule::SliceToRemovePrefixOrSuffix) {
-                refurb::rules::slice_to_remove_affix_expr(checker, if_exp);
-            }
        }
        Expr::ListComp(
            comp @ ast::ExprListComp {
--- a/crates/ruff_linter/src/checkers/ast/analyze/statement.rs
+++ b/crates/ruff_linter/src/checkers/ast/analyze/statement.rs
@@ -1178,9 +1178,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
            if checker.enabled(Rule::CheckAndRemoveFromSet) {
                refurb::rules::check_and_remove_from_set(checker, if_);
            }
-            if checker.enabled(Rule::SliceToRemovePrefixOrSuffix) {
-                refurb::rules::slice_to_remove_affix_stmt(checker, if_);
-            }
            if checker.enabled(Rule::TooManyBooleanExpressions) {
                pylint::rules::too_many_boolean_expressions(checker, if_);
            }
--- a/crates/ruff_linter/src/checkers/ast/analyze/unresolved_references.rs
+++ b/crates/ruff_linter/src/checkers/ast/analyze/unresolved_references.rs
@@ -1,6 +1,5 @@
 use ruff_diagnostics::Diagnostic;
 use ruff_python_semantic::Exceptions;
-use ruff_python_stdlib::builtins::version_builtin_was_added;

 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
@@ -36,12 +35,9 @@ pub(crate) fn unresolved_references(checker: &mut Checker) {
                    }
                }

-                let symbol_name = reference.name(checker.locator);
-
                checker.diagnostics.push(Diagnostic::new(
                    pyflakes::rules::UndefinedName {
-                        name: symbol_name.to_string(),
-                        minor_version_builtin_added: version_builtin_was_added(symbol_name),
+                        name: reference.name(checker.locator).to_string(),
                    },
                    reference.range(),
                ));
--- a/crates/ruff_linter/src/checkers/ast/mod.rs
+++ b/crates/ruff_linter/src/checkers/ast/mod.rs
@@ -1951,25 +1951,20 @@ impl<'a> Checker<'a> {
    }

    fn bind_builtins(&mut self) {
-        let mut bind_builtin = |builtin| {
-            // Add the builtin to the scope.
-            let binding_id = self.semantic.push_builtin();
-            let scope = self.semantic.global_scope_mut();
-            scope.add(builtin, binding_id);
-        };
-
        let standard_builtins = python_builtins(
            self.settings.target_version.minor(),
            self.source_type.is_ipynb(),
        );
-        for builtin in standard_builtins {
-            bind_builtin(builtin);
-        }
-        for builtin in MAGIC_GLOBALS {
-            bind_builtin(builtin);
-        }
-        for builtin in &self.settings.builtins {
-            bind_builtin(builtin);
+        for builtin in standard_builtins
+            .iter()
+            .chain(MAGIC_GLOBALS.iter())
+            .copied()
+            .chain(self.settings.builtins.iter().map(String::as_str))
+        {
+            // Add the builtin to the scope.
+            let binding_id = self.semantic.push_builtin();
+            let scope = self.semantic.global_scope_mut();
+            scope.add(builtin, binding_id);
        }
    }

--- a/crates/ruff_linter/src/checkers/tokens.rs
+++ b/crates/ruff_linter/src/checkers/tokens.rs
@@ -63,7 +63,7 @@ pub(crate) fn check_tokens(
            ruff::rules::ambiguous_unicode_character_comment(
                &mut diagnostics,
                locator,
-                range,
+                *range,
                settings,
            );
        }
@@ -154,13 +154,7 @@ pub(crate) fn check_tokens(
        Rule::ShebangNotFirstLine,
        Rule::ShebangMissingPython,
    ]) {
-        flake8_executable::rules::from_tokens(
-            &mut diagnostics,
-            path,
-            locator,
-            comment_ranges,
-            settings,
-        );
+        flake8_executable::rules::from_tokens(&mut diagnostics, path, locator, comment_ranges);
    }

    if settings.rules.any_enabled(&[
--- a/crates/ruff_linter/src/codes.rs
+++ b/crates/ruff_linter/src/codes.rs
@@ -961,7 +961,6 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
        (Ruff, "031") => (RuleGroup::Preview, rules::ruff::rules::IncorrectlyParenthesizedTupleInSubscript),
        (Ruff, "032") => (RuleGroup::Preview, rules::ruff::rules::DecimalFromFloatLiteral),
        (Ruff, "033") => (RuleGroup::Preview, rules::ruff::rules::PostInitDefault),
-        (Ruff, "034") => (RuleGroup::Preview, rules::ruff::rules::UselessIfElse),
        (Ruff, "100") => (RuleGroup::Stable, rules::ruff::rules::UnusedNOQA),
        (Ruff, "101") => (RuleGroup::Stable, rules::ruff::rules::RedirectedNOQA),

@@ -1067,7 +1066,6 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
        (Refurb, "180") => (RuleGroup::Preview, rules::refurb::rules::MetaClassABCMeta),
        (Refurb, "181") => (RuleGroup::Stable, rules::refurb::rules::HashlibDigestHex),
        (Refurb, "187") => (RuleGroup::Stable, rules::refurb::rules::ListReverseCopy),
-        (Refurb, "188") => (RuleGroup::Preview, rules::refurb::rules::SliceToRemovePrefixOrSuffix),
        (Refurb, "192") => (RuleGroup::Preview, rules::refurb::rules::SortedMinMax),

        // flake8-logging
--- a/crates/ruff_linter/src/logging.rs
+++ b/crates/ruff_linter/src/logging.rs
@@ -152,8 +152,6 @@ pub fn set_up_logging(level: LogLevel) -> Result<()> {
        })
        .level(level.level_filter())
        .level_for("globset", log::LevelFilter::Warn)
-        .level_for("red_knot_python_semantic", log::LevelFilter::Warn)
-        .level_for("salsa", log::LevelFilter::Warn)
        .chain(std::io::stderr())
        .apply()?;
    Ok(())
--- a/crates/ruff_linter/src/message/sarif.rs
+++ b/crates/ruff_linter/src/message/sarif.rs
@@ -1,9 +1,9 @@
-use std::collections::HashSet;
 use std::io::Write;

 use anyhow::Result;
 use serde::{Serialize, Serializer};
 use serde_json::json;
+use strum::IntoEnumIterator;

 use ruff_source_file::OneIndexed;

@@ -27,10 +27,6 @@ impl Emitter for SarifEmitter {
            .map(SarifResult::from_message)
            .collect::<Result<Vec<_>>>()?;

-        let unique_rules: HashSet<_> = results.iter().filter_map(|result| result.rule).collect();
-        let mut rules: Vec<SarifRule> = unique_rules.into_iter().map(SarifRule::from).collect();
-        rules.sort_by(|a, b| a.code.cmp(&b.code));
-
        let output = json!({
            "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
            "version": "2.1.0",
@@ -39,7 +35,7 @@ impl Emitter for SarifEmitter {
                    "driver": {
                        "name": "ruff",
                        "informationUri": "https://github.com/astral-sh/ruff",
-                        "rules": rules,
+                        "rules": Rule::iter().map(SarifRule::from).collect::<Vec<_>>(),
                        "version": VERSION.to_string(),
                    }
                },
@@ -186,6 +182,7 @@ impl Serialize for SarifResult {

 #[cfg(test)]
 mod tests {
+
    use crate::message::tests::{
        capture_emitter_output, create_messages, create_syntax_error_messages,
    };
@@ -212,11 +209,16 @@ mod tests {
    #[test]
    fn test_results() {
        let content = get_output();
-        let value = serde_json::from_str::<serde_json::Value>(&content).unwrap();
-
-        insta::assert_json_snapshot!(value, {
-            ".runs[0].tool.driver.version" => "[VERSION]",
-            ".runs[0].results[].locations[].physicalLocation.artifactLocation.uri" => "[URI]",
-        });
+        let sarif = serde_json::from_str::<serde_json::Value>(content.as_str()).unwrap();
+        let rules = sarif["runs"][0]["tool"]["driver"]["rules"]
+            .as_array()
+            .unwrap();
+        let results = sarif["runs"][0]["results"].as_array().unwrap();
+        assert_eq!(results.len(), 3);
+        assert_eq!(
+            results[0]["message"]["text"].as_str().unwrap(),
+            "`os` imported but unused"
+        );
+        assert!(rules.len() > 3);
    }
 }
--- a/crates/ruff_linter/src/message/snapshots/ruff_lintermessagesariftestsresults.snap
+++ b/crates/ruff_linter/src/message/snapshots/ruff_lintermessagesariftestsresults.snap
@@ -1,146 +0,0 @@
---
-source: crates/ruff_linter/src/message/sarif.rs
-expression: value
---
-{
-  "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
-  "runs": [
-    {
-      "results": [
-        {
-          "level": "error",
-          "locations": [
-            {
-              "physicalLocation": {
-                "artifactLocation": {
-                  "uri": "[URI]"
-                },
-                "region": {
-                  "endColumn": 10,
-                  "endLine": 1,
-                  "startColumn": 8,
-                  "startLine": 1
-                }
-              }
-            }
-          ],
-          "message": {
-            "text": "`os` imported but unused"
-          },
-          "ruleId": "F401"
-        },
-        {
-          "level": "error",
-          "locations": [
-            {
-              "physicalLocation": {
-                "artifactLocation": {
-                  "uri": "[URI]"
-                },
-                "region": {
-                  "endColumn": 6,
-                  "endLine": 6,
-                  "startColumn": 5,
-                  "startLine": 6
-                }
-              }
-            }
-          ],
-          "message": {
-            "text": "Local variable `x` is assigned to but never used"
-          },
-          "ruleId": "F841"
-        },
-        {
-          "level": "error",
-          "locations": [
-            {
-              "physicalLocation": {
-                "artifactLocation": {
-                  "uri": "[URI]"
-                },
-                "region": {
-                  "endColumn": 5,
-                  "endLine": 1,
-                  "startColumn": 4,
-                  "startLine": 1
-                }
-              }
-            }
-          ],
-          "message": {
-            "text": "Undefined name `a`"
-          },
-          "ruleId": "F821"
-        }
-      ],
-      "tool": {
-        "driver": {
-          "informationUri": "https://github.com/astral-sh/ruff",
-          "name": "ruff",
-          "rules": [
-            {
-              "fullDescription": {
-                "text": "## What it does\nChecks for unused imports.\n\n## Why is this bad?\nUnused imports add a performance overhead at runtime, and risk creating\nimport cycles. They also increase the cognitive load of reading the code.\n\nIf an import statement is used to check for the availability or existence\nof a module, consider using `importlib.util.find_spec` instead.\n\nIf an import statement is used to re-export a symbol as part of a module's\npublic interface, consider using a \"redundant\" import alias, which\ninstructs Ruff (and other tools) to respect the re-export, and avoid\nmarking it as unused, as in:\n\n```python\nfrom module import member as member\n```\n\nAlternatively, you can use `__all__` to declare a symbol as part of the module's\ninterface, as in:\n\n```python\n# __init__.py\nimport some_module\n\n__all__ = [\"some_module\"]\n```\n\n## Fix safety\n\nFixes to remove unused imports are safe, except in `__init__.py` files.\n\nApplying fixes to `__init__.py` files is currently in preview. The fix offered depends on the\ntype of the unused import. Ruff will suggest a safe fix to export first-party imports with\neither a redundant alias or, if already present in the file, an `__all__` entry. If multiple\n`__all__` declarations are present, Ruff will not offer a fix. Ruff will suggest an unsafe fix\nto remove third-party and standard library imports -- the fix is unsafe because the module's\ninterface changes.\n\n## Example\n\n```python\nimport numpy as np  # unused import\n\n\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nUse instead:\n\n```python\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nTo check the availability of a module, use `importlib.util.find_spec`:\n\n```python\nfrom importlib.util import find_spec\n\nif find_spec(\"numpy\") is not None:\n    print(\"numpy is installed\")\nelse:\n    print(\"numpy is not installed\")\n```\n\n## Options\n- `lint.ignore-init-module-imports`\n\n## References\n- [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)\n- [Python documentation: `importlib.util.find_spec`](https://docs.python.org/3/library/importlib.html#importlib.util.find_spec)\n- [Typing documentation: interface conventions](https://typing.readthedocs.io/en/latest/source/libraries.html#library-interface-public-and-private-symbols)\n"
-              },
-              "help": {
-                "text": "`{name}` imported but unused; consider using `importlib.util.find_spec` to test for availability"
-              },
-              "helpUri": "https://docs.astral.sh/ruff/rules/unused-import",
-              "id": "F401",
-              "properties": {
-                "id": "F401",
-                "kind": "Pyflakes",
-                "name": "unused-import",
-                "problem.severity": "error"
-              },
-              "shortDescription": {
-                "text": "`{name}` imported but unused; consider using `importlib.util.find_spec` to test for availability"
-              }
-            },
-            {
-              "fullDescription": {
-                "text": "## What it does\nChecks for uses of undefined names.\n\n## Why is this bad?\nAn undefined name is likely to raise `NameError` at runtime.\n\n## Example\n```python\ndef double():\n    return n * 2  # raises `NameError` if `n` is undefined when `double` is called\n```\n\nUse instead:\n```python\ndef double(n):\n    return n * 2\n```\n\n## Options\n- [`target-version`]: Can be used to configure which symbols Ruff will understand\n  as being available in the `builtins` namespace.\n\n## References\n- [Python documentation: Naming and binding](https://docs.python.org/3/reference/executionmodel.html#naming-and-binding)\n"
-              },
-              "help": {
-                "text": "Undefined name `{name}`. {tip}"
-              },
-              "helpUri": "https://docs.astral.sh/ruff/rules/undefined-name",
-              "id": "F821",
-              "properties": {
-                "id": "F821",
-                "kind": "Pyflakes",
-                "name": "undefined-name",
-                "problem.severity": "error"
-              },
-              "shortDescription": {
-                "text": "Undefined name `{name}`. {tip}"
-              }
-            },
-            {
-              "fullDescription": {
-                "text": "## What it does\nChecks for the presence of unused variables in function scopes.\n\n## Why is this bad?\nA variable that is defined but not used is likely a mistake, and should\nbe removed to avoid confusion.\n\nIf a variable is intentionally defined-but-not-used, it should be\nprefixed with an underscore, or some other value that adheres to the\n[`lint.dummy-variable-rgx`] pattern.\n\nUnder [preview mode](https://docs.astral.sh/ruff/preview), this rule also\ntriggers on unused unpacked assignments (for example, `x, y = foo()`).\n\n## Example\n```python\ndef foo():\n    x = 1\n    y = 2\n    return x\n```\n\nUse instead:\n```python\ndef foo():\n    x = 1\n    return x\n```\n\n## Options\n- `lint.dummy-variable-rgx`\n"
-              },
-              "help": {
-                "text": "Local variable `{name}` is assigned to but never used"
-              },
-              "helpUri": "https://docs.astral.sh/ruff/rules/unused-variable",
-              "id": "F841",
-              "properties": {
-                "id": "F841",
-                "kind": "Pyflakes",
-                "name": "unused-variable",
-                "problem.severity": "error"
-              },
-              "shortDescription": {
-                "text": "Local variable `{name}` is assigned to but never used"
-              }
-            }
-          ],
-          "version": "[VERSION]"
-        }
-      }
-    }
-  ],
-  "version": "2.1.0"
-}
--- a/crates/ruff_linter/src/noqa.rs
+++ b/crates/ruff_linter/src/noqa.rs
@@ -361,7 +361,7 @@ impl<'a> FileNoqaDirectives<'a> {
        let mut lines = vec![];

        for range in comment_ranges {
-            match ParsedFileExemption::try_extract(&contents[range]) {
+            match ParsedFileExemption::try_extract(&contents[*range]) {
                Err(err) => {
                    #[allow(deprecated)]
                    let line = locator.compute_line_index(range.start());
@@ -403,7 +403,7 @@ impl<'a> FileNoqaDirectives<'a> {
                    };

                    lines.push(FileNoqaDirectiveLine {
-                        range,
+                        range: *range,
                        parsed_file_exemption: exemption,
                        matches,
                    });
@@ -922,7 +922,7 @@ impl<'a> NoqaDirectives<'a> {
        let mut directives = Vec::new();

        for range in comment_ranges {
-            match Directive::try_extract(locator.slice(range), range.start()) {
+            match Directive::try_extract(locator.slice(*range), range.start()) {
                Err(err) => {
                    #[allow(deprecated)]
                    let line = locator.compute_line_index(range.start());
--- a/crates/ruff_linter/src/rules/eradicate/rules/commented_out_code.rs
+++ b/crates/ruff_linter/src/rules/eradicate/rules/commented_out_code.rs
@@ -1,9 +1,9 @@
-use crate::settings::LinterSettings;
 use ruff_diagnostics::{Diagnostic, Edit, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_trivia::CommentRanges;
-use ruff_source_file::{Locator, UniversalNewlineIterator};
-use ruff_text_size::TextRange;
+use ruff_source_file::Locator;
+
+use crate::settings::LinterSettings;

 use super::super::detection::comment_contains_code;

@@ -50,110 +50,40 @@ pub(crate) fn commented_out_code(
    comment_ranges: &CommentRanges,
    settings: &LinterSettings,
 ) {
-    let mut comments = comment_ranges.into_iter().peekable();
-    // Iterate over all comments in the document.
-    while let Some(range) = comments.next() {
-        let line = locator.line(range.start());
+    // Skip comments within `/// script` tags.
+    let mut in_script_tag = false;

-        if is_script_tag_start(line) {
-            if skip_script_comments(range, &mut comments, locator) {
-                continue;
+    // Iterate over all comments in the document.
+    for range in comment_ranges {
+        let line = locator.lines(*range);
+
+        // Detect `/// script` tags.
+        if in_script_tag {
+            if is_script_tag_end(line) {
+                in_script_tag = false;
            }
+        } else {
+            if is_script_tag_start(line) {
+                in_script_tag = true;
+            }
+        }
+
+        // Skip comments within `/// script` tags.
+        if in_script_tag {
+            continue;
        }

        // Verify that the comment is on its own line, and that it contains code.
        if is_own_line_comment(line) && comment_contains_code(line, &settings.task_tags[..]) {
-            let mut diagnostic = Diagnostic::new(CommentedOutCode, range);
+            let mut diagnostic = Diagnostic::new(CommentedOutCode, *range);
            diagnostic.set_fix(Fix::display_only_edit(Edit::range_deletion(
-                locator.full_lines_range(range),
+                locator.full_lines_range(*range),
            )));
            diagnostics.push(diagnostic);
        }
    }
 }

-/// Parses the rest of a [PEP 723](https://peps.python.org/pep-0723/)
-/// script comment and moves `comments` past the script comment's end unless
-/// the script comment is invalid.
-///
-/// Returns `true` if it is a valid script comment.
-fn skip_script_comments<I>(
-    script_start: TextRange,
-    comments: &mut std::iter::Peekable<I>,
-    locator: &Locator,
-) -> bool
-where
-    I: Iterator<Item = TextRange>,
-{
-    let line_end = locator.full_line_end(script_start.end());
-    let rest = locator.after(line_end);
-    let mut end_offset = None;
-    let mut lines = UniversalNewlineIterator::with_offset(rest, line_end).peekable();
-
-    while let Some(line) = lines.next() {
-        let Some(content) = script_line_content(&line) else {
-            break;
-        };
-
-        if content == "///" {
-            // > Precedence for an ending line # /// is given when the next line is not a valid
-            // > embedded content line as described above.
-            // > For example, the following is a single fully valid block:
-            // > ```python
-            // > # /// some-toml
-            // > # embedded-csharp = """
-            // > # /// <summary>
-            // > # /// text
-            // > # ///
-            // > # /// </summary>
-            // > # public class MyClass { }
-            // > # """
-            // > # ///
-            // ````
-            if lines.next().is_some_and(|line| is_valid_script_line(&line)) {
-                continue;
-            }
-            end_offset = Some(line.full_end());
-            break;
-        }
-    }
-
-    // > Unclosed blocks MUST be ignored.
-    let Some(end_offset) = end_offset else {
-        return false;
-    };
-
-    // Skip over all script-comments.
-    while let Some(comment) = comments.peek() {
-        if comment.start() >= end_offset {
-            break;
-        }
-
-        comments.next();
-    }
-
-    true
-}
-
-fn script_line_content(line: &str) -> Option<&str> {
-    let Some(rest) = line.strip_prefix('#') else {
-        // Not a comment
-        return None;
-    };
-
-    // An empty line
-    if rest.is_empty() {
-        return Some("");
-    }
-
-    // > If there are characters after the # then the first character MUST be a space.
-    rest.strip_prefix(' ')
-}
-
-fn is_valid_script_line(line: &str) -> bool {
-    script_line_content(line).is_some()
-}
-
 /// Returns `true` if line contains an own-line comment.
 fn is_own_line_comment(line: &str) -> bool {
    for char in line.chars() {
@@ -174,77 +104,9 @@ fn is_script_tag_start(line: &str) -> bool {
    line == "# /// script"
 }

-#[cfg(test)]
-mod tests {
-    use crate::rules::eradicate::rules::commented_out_code::skip_script_comments;
-    use ruff_python_parser::parse_module;
-    use ruff_python_trivia::CommentRanges;
-    use ruff_source_file::Locator;
-    use ruff_text_size::TextSize;
-    #[test]
-    fn script_comment() {
-        let code = r#"
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#   "requests<3",
-#   "rich",
-# ]
-# ///
-
-a = 10 # abc
-        "#;
-
-        let parsed = parse_module(code).unwrap();
-        let locator = Locator::new(code);
-
-        let comments = CommentRanges::from(parsed.tokens());
-        let mut comments = comments.into_iter().peekable();
-
-        let script_start = code.find("# /// script").unwrap();
-        let script_start_range = locator.full_line_range(TextSize::try_from(script_start).unwrap());
-
-        let valid = skip_script_comments(script_start_range, &mut comments, &Locator::new(code));
-
-        assert!(valid);
-
-        let next_comment = comments.next();
-
-        assert!(next_comment.is_some());
-        assert_eq!(&code[next_comment.unwrap()], "# abc");
-    }
-
-    #[test]
-    fn script_comment_end_precedence() {
-        let code = r#"
-# /// script
-# [tool.uv]
-# extra-index-url = ["https://pypi.org/simple", """\
-# https://example.com/
-# ///
-# """
-# ]
-# ///
-
-a = 10 # abc
-        "#;
-
-        let parsed = parse_module(code).unwrap();
-        let locator = Locator::new(code);
-
-        let comments = CommentRanges::from(parsed.tokens());
-        let mut comments = comments.into_iter().peekable();
-
-        let script_start = code.find("# /// script").unwrap();
-        let script_start_range = locator.full_line_range(TextSize::try_from(script_start).unwrap());
-
-        let valid = skip_script_comments(script_start_range, &mut comments, &Locator::new(code));
-
-        assert!(valid);
-
-        let next_comment = comments.next();
-
-        assert!(next_comment.is_some());
-        assert_eq!(&code[next_comment.unwrap()], "# abc");
-    }
+/// Returns `true` if the line appears to start a script tag.
+///
+/// See: <https://peps.python.org/pep-0723/>
+fn is_script_tag_end(line: &str) -> bool {
+    line == "# ///"
 }
--- a/crates/ruff_linter/src/rules/eradicate/snapshots/ruff_linterruleseradicatetestsERA001_ERA001.py.snap
+++ b/crates/ruff_linter/src/rules/eradicate/snapshots/ruff_linterruleseradicatetestsERA001_ERA001.py.snap
@@ -321,38 +321,3 @@ ERA001.py:47:1: ERA001 Found commented-out code
 48 47 | # ///
 49 48 | 
 50 49 | # Script tag (OK)
-
-ERA001.py:75:1: ERA001 Found commented-out code
-   |
-73 | # /// script
-74 | # requires-python = ">=3.11"
-75 | # dependencies = [
-   | ^^^^^^^^^^^^^^^^^^ ERA001
-76 | #   "requests<3",
-77 | #   "rich",
-   |
-   = help: Remove commented-out code
-
-ℹ Display-only fix
-72 72 | 
-73 73 | # /// script
-74 74 | # requires-python = ">=3.11"
-75    |-# dependencies = [
-76 75 | #   "requests<3",
-77 76 | #   "rich",
-78 77 | # ]
-
-ERA001.py:78:1: ERA001 Found commented-out code
-   |
-76 | #   "requests<3",
-77 | #   "rich",
-78 | # ]
-   | ^^^ ERA001
-   |
-   = help: Remove commented-out code
-
-ℹ Display-only fix
-75 75 | # dependencies = [
-76 76 | #   "requests<3",
-77 77 | #   "rich",
-78    |-# ]
--- a/crates/ruff_linter/src/rules/fastapi/rules/fastapi_unused_path_parameter.rs
+++ b/crates/ruff_linter/src/rules/fastapi/rules/fastapi_unused_path_parameter.rs
@@ -6,8 +6,7 @@ use ruff_diagnostics::Fix;
 use ruff_diagnostics::{Diagnostic, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast as ast;
-use ruff_python_ast::{Expr, Parameter, ParameterWithDefault};
-use ruff_python_semantic::{Modules, SemanticModel};
+use ruff_python_semantic::Modules;
 use ruff_python_stdlib::identifiers::is_identifier;
 use ruff_text_size::{Ranged, TextSize};

@@ -142,10 +141,7 @@ pub(crate) fn fastapi_unused_path_parameter(
        .args
        .iter()
        .chain(function_def.parameters.kwonlyargs.iter())
-        .map(|ParameterWithDefault { parameter, .. }| {
-            parameter_alias(parameter, checker.semantic())
-                .unwrap_or_else(|| parameter.name.as_str())
-        })
+        .map(|arg| arg.parameter.name.as_str())
        .collect();

    // Check if any of the path parameters are not in the function signature.
@@ -194,52 +190,6 @@ pub(crate) fn fastapi_unused_path_parameter(
    checker.diagnostics.extend(diagnostics);
 }

-/// Extract the expected in-route name for a given parameter, if it has an alias.
-/// For example, given `document_id: Annotated[str, Path(alias="documentId")]`, returns `"documentId"`.
-fn parameter_alias<'a>(parameter: &'a Parameter, semantic: &SemanticModel) -> Option<&'a str> {
-    let Some(annotation) = &parameter.annotation else {
-        return None;
-    };
-
-    let Expr::Subscript(subscript) = annotation.as_ref() else {
-        return None;
-    };
-
-    let Expr::Tuple(tuple) = subscript.slice.as_ref() else {
-        return None;
-    };
-
-    let Some(Expr::Call(path)) = tuple.elts.get(1) else {
-        return None;
-    };
-
-    // Find the `alias` keyword argument.
-    let alias = path
-        .arguments
-        .find_keyword("alias")
-        .map(|alias| &alias.value)?;
-
-    // Ensure that it's a literal string.
-    let Expr::StringLiteral(alias) = alias else {
-        return None;
-    };
-
-    // Verify that the subscript was a `typing.Annotated`.
-    if !semantic.match_typing_expr(&subscript.value, "Annotated") {
-        return None;
-    }
-
-    // Verify that the call was a `fastapi.Path`.
-    if !semantic
-        .resolve_qualified_name(&path.func)
-        .is_some_and(|qualified_name| matches!(qualified_name.segments(), ["fastapi", "Path"]))
-    {
-        return None;
-    }
-
-    Some(alias.value.to_str())
-}
-
 /// An iterator to extract parameters from FastAPI route paths.
 ///
 /// The iterator yields tuples of the parameter name and the range of the parameter in the input,
--- a/crates/ruff_linter/src/rules/fastapi/snapshots/ruff_linterrulesfastapitestsfast-api-unused-path-parameter_FAST003.py.snap
+++ b/crates/ruff_linter/src/rules/fastapi/snapshots/ruff_linterrulesfastapitestsfast-api-unused-path-parameter_FAST003.py.snap
@@ -1,342 +1,323 @@
 ---
 source: crates/ruff_linter/src/rules/fastapi/mod.rs
 ---
-FAST003.py:9:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
-   |
- 8 | # Errors
- 9 | @app.get("/things/{thing_id}")
-   |                   ^^^^^^^^^^ FAST003
-10 | async def read_thing(query: str):
-11 |     return {"query": query}
-   |
-   = help: Add `thing_id` to function signature
+FAST003.py:7:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
+  |
+6 | # Errors
+7 | @app.get("/things/{thing_id}")
+  |                   ^^^^^^^^^^ FAST003
+8 | async def read_thing(query: str):
+9 |     return {"query": query}
+  |
+  = help: Add `thing_id` to function signature

 ℹ Unsafe fix
-7  7  | 
-8  8  | # Errors
-9  9  | @app.get("/things/{thing_id}")
-10    |-async def read_thing(query: str):
-   10 |+async def read_thing(query: str, thing_id):
-11 11 |     return {"query": query}
-12 12 | 
-13 13 | 
+5 5 | 
+6 6 | # Errors
+7 7 | @app.get("/things/{thing_id}")
+8   |-async def read_thing(query: str):
+  8 |+async def read_thing(query: str, thing_id):
+9 9 |     return {"query": query}
+10 10 | 
+11 11 | 

-FAST003.py:14:23: FAST003 [*] Parameter `isbn` appears in route path, but not in `read_thing` signature
+FAST003.py:12:23: FAST003 [*] Parameter `isbn` appears in route path, but not in `read_thing` signature
   |
-14 | @app.get("/books/isbn-{isbn}")
+12 | @app.get("/books/isbn-{isbn}")
   |                       ^^^^^^ FAST003
-15 | async def read_thing():
-16 |     ...
+13 | async def read_thing():
+14 |     ...
   |
   = help: Add `isbn` to function signature

 ℹ Unsafe fix
-12 12 | 
-13 13 | 
-14 14 | @app.get("/books/isbn-{isbn}")
-15    |-async def read_thing():
-   15 |+async def read_thing(isbn):
-16 16 |     ...
-17 17 | 
-18 18 | 
+10 10 | 
+11 11 | 
+12 12 | @app.get("/books/isbn-{isbn}")
+13    |-async def read_thing():
+   13 |+async def read_thing(isbn):
+14 14 |     ...
+15 15 | 
+16 16 | 

-FAST003.py:19:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
+FAST003.py:17:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
   |
-19 | @app.get("/things/{thing_id:path}")
+17 | @app.get("/things/{thing_id:path}")
   |                   ^^^^^^^^^^^^^^^ FAST003
-20 | async def read_thing(query: str):
-21 |     return {"query": query}
+18 | async def read_thing(query: str):
+19 |     return {"query": query}
   |
   = help: Add `thing_id` to function signature

 ℹ Unsafe fix
-17 17 | 
-18 18 | 
-19 19 | @app.get("/things/{thing_id:path}")
-20    |-async def read_thing(query: str):
-   20 |+async def read_thing(query: str, thing_id):
-21 21 |     return {"query": query}
-22 22 | 
-23 23 | 
+15 15 | 
+16 16 | 
+17 17 | @app.get("/things/{thing_id:path}")
+18    |-async def read_thing(query: str):
+   18 |+async def read_thing(query: str, thing_id):
+19 19 |     return {"query": query}
+20 20 | 
+21 21 | 

-FAST003.py:24:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
+FAST003.py:22:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
   |
-24 | @app.get("/things/{thing_id : path}")
+22 | @app.get("/things/{thing_id : path}")
   |                   ^^^^^^^^^^^^^^^^^ FAST003
-25 | async def read_thing(query: str):
-26 |     return {"query": query}
+23 | async def read_thing(query: str):
+24 |     return {"query": query}
   |
   = help: Add `thing_id` to function signature

 ℹ Unsafe fix
-22 22 | 
-23 23 | 
-24 24 | @app.get("/things/{thing_id : path}")
-25    |-async def read_thing(query: str):
-   25 |+async def read_thing(query: str, thing_id):
-26 26 |     return {"query": query}
-27 27 | 
-28 28 | 
+20 20 | 
+21 21 | 
+22 22 | @app.get("/things/{thing_id : path}")
+23    |-async def read_thing(query: str):
+   23 |+async def read_thing(query: str, thing_id):
+24 24 |     return {"query": query}
+25 25 | 
+26 26 | 

-FAST003.py:29:27: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
+FAST003.py:27:27: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
   |
-29 | @app.get("/books/{author}/{title}")
+27 | @app.get("/books/{author}/{title}")
   |                           ^^^^^^^ FAST003
-30 | async def read_thing(author: str):
-31 |     return {"author": author}
+28 | async def read_thing(author: str):
+29 |     return {"author": author}
   |
   = help: Add `title` to function signature

 ℹ Unsafe fix
-27 27 | 
-28 28 | 
-29 29 | @app.get("/books/{author}/{title}")
-30    |-async def read_thing(author: str):
-   30 |+async def read_thing(author: str, title):
-31 31 |     return {"author": author}
-32 32 | 
-33 33 | 
+25 25 | 
+26 26 | 
+27 27 | @app.get("/books/{author}/{title}")
+28    |-async def read_thing(author: str):
+   28 |+async def read_thing(author: str, title):
+29 29 |     return {"author": author}
+30 30 | 
+31 31 | 

-FAST003.py:34:18: FAST003 [*] Parameter `author_name` appears in route path, but not in `read_thing` signature
+FAST003.py:32:18: FAST003 [*] Parameter `author_name` appears in route path, but not in `read_thing` signature
   |
-34 | @app.get("/books/{author_name}/{title}")
+32 | @app.get("/books/{author_name}/{title}")
   |                  ^^^^^^^^^^^^^ FAST003
-35 | async def read_thing():
-36 |     ...
+33 | async def read_thing():
+34 |     ...
   |
   = help: Add `author_name` to function signature

 ℹ Unsafe fix
-32 32 | 
-33 33 | 
-34 34 | @app.get("/books/{author_name}/{title}")
-35    |-async def read_thing():
-   35 |+async def read_thing(author_name):
-36 36 |     ...
-37 37 | 
-38 38 | 
+30 30 | 
+31 31 | 
+32 32 | @app.get("/books/{author_name}/{title}")
+33    |-async def read_thing():
+   33 |+async def read_thing(author_name):
+34 34 |     ...
+35 35 | 
+36 36 | 

-FAST003.py:34:32: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
+FAST003.py:32:32: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
   |
-34 | @app.get("/books/{author_name}/{title}")
+32 | @app.get("/books/{author_name}/{title}")
   |                                ^^^^^^^ FAST003
-35 | async def read_thing():
-36 |     ...
+33 | async def read_thing():
+34 |     ...
   |
   = help: Add `title` to function signature

 ℹ Unsafe fix
-32 32 | 
-33 33 | 
-34 34 | @app.get("/books/{author_name}/{title}")
-35    |-async def read_thing():
-   35 |+async def read_thing(title):
-36 36 |     ...
-37 37 | 
-38 38 | 
+30 30 | 
+31 31 | 
+32 32 | @app.get("/books/{author_name}/{title}")
+33    |-async def read_thing():
+   33 |+async def read_thing(title):
+34 34 |     ...
+35 35 | 
+36 36 | 

-FAST003.py:39:18: FAST003 Parameter `author` appears in route path, but only as a positional-only argument in `read_thing` signature
+FAST003.py:37:18: FAST003 Parameter `author` appears in route path, but only as a positional-only argument in `read_thing` signature
   |
-39 | @app.get("/books/{author}/{title}")
+37 | @app.get("/books/{author}/{title}")
   |                  ^^^^^^^^ FAST003
-40 | async def read_thing(author: str, title: str, /):
-41 |     return {"author": author, "title": title}
+38 | async def read_thing(author: str, title: str, /):
+39 |     return {"author": author, "title": title}
   |

-FAST003.py:39:27: FAST003 Parameter `title` appears in route path, but only as a positional-only argument in `read_thing` signature
+FAST003.py:37:27: FAST003 Parameter `title` appears in route path, but only as a positional-only argument in `read_thing` signature
   |
-39 | @app.get("/books/{author}/{title}")
+37 | @app.get("/books/{author}/{title}")
   |                           ^^^^^^^ FAST003
-40 | async def read_thing(author: str, title: str, /):
-41 |     return {"author": author, "title": title}
+38 | async def read_thing(author: str, title: str, /):
+39 |     return {"author": author, "title": title}
   |

-FAST003.py:44:27: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
+FAST003.py:42:27: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
   |
-44 | @app.get("/books/{author}/{title}/{page}")
+42 | @app.get("/books/{author}/{title}/{page}")
   |                           ^^^^^^^ FAST003
-45 | async def read_thing(
-46 |     author: str,
+43 | async def read_thing(
+44 |     author: str,
   |
   = help: Add `title` to function signature

 ℹ Unsafe fix
-44 44 | @app.get("/books/{author}/{title}/{page}")
-45 45 | async def read_thing(
-46 46 |     author: str,
-47    |-    query: str,
-   47 |+    query: str, title,
-48 48 | ): ...
-49 49 | 
-50 50 | 
+42 42 | @app.get("/books/{author}/{title}/{page}")
+43 43 | async def read_thing(
+44 44 |     author: str,
+45    |-    query: str,
+   45 |+    query: str, title,
+46 46 | ): ...
+47 47 | 
+48 48 | 

-FAST003.py:44:35: FAST003 [*] Parameter `page` appears in route path, but not in `read_thing` signature
+FAST003.py:42:35: FAST003 [*] Parameter `page` appears in route path, but not in `read_thing` signature
   |
-44 | @app.get("/books/{author}/{title}/{page}")
+42 | @app.get("/books/{author}/{title}/{page}")
   |                                   ^^^^^^ FAST003
-45 | async def read_thing(
-46 |     author: str,
+43 | async def read_thing(
+44 |     author: str,
   |
   = help: Add `page` to function signature

 ℹ Unsafe fix
-44 44 | @app.get("/books/{author}/{title}/{page}")
-45 45 | async def read_thing(
-46 46 |     author: str,
-47    |-    query: str,
-   47 |+    query: str, page,
-48 48 | ): ...
-49 49 | 
-50 50 | 
+42 42 | @app.get("/books/{author}/{title}/{page}")
+43 43 | async def read_thing(
+44 44 |     author: str,
+45    |-    query: str,
+   45 |+    query: str, page,
+46 46 | ): ...
+47 47 | 
+48 48 | 

-FAST003.py:51:18: FAST003 [*] Parameter `author` appears in route path, but not in `read_thing` signature
+FAST003.py:49:18: FAST003 [*] Parameter `author` appears in route path, but not in `read_thing` signature
   |
-51 | @app.get("/books/{author}/{title}")
+49 | @app.get("/books/{author}/{title}")
   |                  ^^^^^^^^ FAST003
-52 | async def read_thing():
-53 |     ...
+50 | async def read_thing():
+51 |     ...
   |
   = help: Add `author` to function signature

 ℹ Unsafe fix
-49 49 | 
-50 50 | 
-51 51 | @app.get("/books/{author}/{title}")
-52    |-async def read_thing():
-   52 |+async def read_thing(author):
-53 53 |     ...
-54 54 | 
-55 55 | 
+47 47 | 
+48 48 | 
+49 49 | @app.get("/books/{author}/{title}")
+50    |-async def read_thing():
+   50 |+async def read_thing(author):
+51 51 |     ...
+52 52 | 
+53 53 | 

-FAST003.py:51:27: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
+FAST003.py:49:27: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
   |
-51 | @app.get("/books/{author}/{title}")
+49 | @app.get("/books/{author}/{title}")
   |                           ^^^^^^^ FAST003
-52 | async def read_thing():
-53 |     ...
+50 | async def read_thing():
+51 |     ...
   |
   = help: Add `title` to function signature

 ℹ Unsafe fix
-49 49 | 
-50 50 | 
-51 51 | @app.get("/books/{author}/{title}")
-52    |-async def read_thing():
-   52 |+async def read_thing(title):
-53 53 |     ...
-54 54 | 
-55 55 | 
+47 47 | 
+48 48 | 
+49 49 | @app.get("/books/{author}/{title}")
+50    |-async def read_thing():
+   50 |+async def read_thing(title):
+51 51 |     ...
+52 52 | 
+53 53 | 

-FAST003.py:56:27: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
+FAST003.py:54:27: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
   |
-56 | @app.get("/books/{author}/{title}")
+54 | @app.get("/books/{author}/{title}")
   |                           ^^^^^^^ FAST003
-57 | async def read_thing(*, author: str):
-58 |     ...
+55 | async def read_thing(*, author: str):
+56 |     ...
   |
   = help: Add `title` to function signature

 ℹ Unsafe fix
-54 54 | 
-55 55 | 
-56 56 | @app.get("/books/{author}/{title}")
-57    |-async def read_thing(*, author: str):
-   57 |+async def read_thing(title, *, author: str):
-58 58 |     ...
-59 59 | 
-60 60 | 
+52 52 | 
+53 53 | 
+54 54 | @app.get("/books/{author}/{title}")
+55    |-async def read_thing(*, author: str):
+   55 |+async def read_thing(title, *, author: str):
+56 56 |     ...
+57 57 | 
+58 58 | 

-FAST003.py:61:27: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
+FAST003.py:59:27: FAST003 [*] Parameter `title` appears in route path, but not in `read_thing` signature
   |
-61 | @app.get("/books/{author}/{title}")
+59 | @app.get("/books/{author}/{title}")
   |                           ^^^^^^^ FAST003
-62 | async def read_thing(hello, /, *, author: str):
-63 |     ...
+60 | async def read_thing(hello, /, *, author: str):
+61 |     ...
   |
   = help: Add `title` to function signature

 ℹ Unsafe fix
-59 59 | 
-60 60 | 
-61 61 | @app.get("/books/{author}/{title}")
-62    |-async def read_thing(hello, /, *, author: str):
-   62 |+async def read_thing(hello, /, title, *, author: str):
-63 63 |     ...
-64 64 | 
-65 65 | 
+57 57 | 
+58 58 | 
+59 59 | @app.get("/books/{author}/{title}")
+60    |-async def read_thing(hello, /, *, author: str):
+   60 |+async def read_thing(hello, /, title, *, author: str):
+61 61 |     ...
+62 62 | 
+63 63 | 

-FAST003.py:66:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
+FAST003.py:64:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
   |
-66 | @app.get("/things/{thing_id}")
+64 | @app.get("/things/{thing_id}")
   |                   ^^^^^^^^^^ FAST003
-67 | async def read_thing(
-68 |         query: str,
+65 | async def read_thing(
+66 |         query: str,
   |
   = help: Add `thing_id` to function signature

 ℹ Unsafe fix
-65 65 | 
-66 66 | @app.get("/things/{thing_id}")
-67 67 | async def read_thing(
-68    |-        query: str,
-   68 |+        query: str, thing_id,
-69 69 | ):
-70 70 |     return {"query": query}
-71 71 | 
+63 63 | 
+64 64 | @app.get("/things/{thing_id}")
+65 65 | async def read_thing(
+66    |-        query: str,
+   66 |+        query: str, thing_id,
+67 67 | ):
+68 68 |     return {"query": query}
+69 69 | 

-FAST003.py:73:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
+FAST003.py:71:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
   |
-73 | @app.get("/things/{thing_id}")
+71 | @app.get("/things/{thing_id}")
   |                   ^^^^^^^^^^ FAST003
-74 | async def read_thing(
-75 |         query: str = "default",
+72 | async def read_thing(
+73 |         query: str = "default",
   |
   = help: Add `thing_id` to function signature

 ℹ Unsafe fix
-72 72 | 
-73 73 | @app.get("/things/{thing_id}")
-74 74 | async def read_thing(
-75    |-        query: str = "default",
-   75 |+        thing_id, query: str = "default",
-76 76 | ):
-77 77 |     return {"query": query}
-78 78 | 
+70 70 | 
+71 71 | @app.get("/things/{thing_id}")
+72 72 | async def read_thing(
+73    |-        query: str = "default",
+   73 |+        thing_id, query: str = "default",
+74 74 | ):
+75 75 |     return {"query": query}
+76 76 | 

-FAST003.py:80:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
+FAST003.py:78:19: FAST003 [*] Parameter `thing_id` appears in route path, but not in `read_thing` signature
   |
-80 | @app.get("/things/{thing_id}")
+78 | @app.get("/things/{thing_id}")
   |                   ^^^^^^^^^^ FAST003
-81 | async def read_thing(
-82 |         *, query: str = "default",
+79 | async def read_thing(
+80 |         *, query: str = "default",
   |
   = help: Add `thing_id` to function signature

 ℹ Unsafe fix
-79 79 | 
-80 80 | @app.get("/things/{thing_id}")
-81 81 | async def read_thing(
-82    |-        *, query: str = "default",
-   82 |+        thing_id, *, query: str = "default",
-83 83 | ):
-84 84 |     return {"query": query}
-85 85 | 
-
-FAST003.py:87:18: FAST003 [*] Parameter `name` appears in route path, but not in `read_thing` signature
-   |
-87 | @app.get("/books/{name}/{title}")
-   |                  ^^^^^^ FAST003
-88 | async def read_thing(*, author: Annotated[str, Path(alias="author_name")], title: str):
-89 |     return {"author": author, "title": title}
-   |
-   = help: Add `name` to function signature
-
-ℹ Unsafe fix
-85 85 | 
-86 86 | 
-87 87 | @app.get("/books/{name}/{title}")
-88    |-async def read_thing(*, author: Annotated[str, Path(alias="author_name")], title: str):
-   88 |+async def read_thing(name, *, author: Annotated[str, Path(alias="author_name")], title: str):
-89 89 |     return {"author": author, "title": title}
-90 90 | 
-91 91 |
+77 77 | 
+78 78 | @app.get("/things/{thing_id}")
+79 79 | async def read_thing(
+80    |-        *, query: str = "default",
+   80 |+        thing_id, *, query: str = "default",
+81 81 | ):
+82 82 |     return {"query": query}
+83 83 |
--- a/crates/ruff_linter/src/rules/flake8_executable/rules/mod.rs
+++ b/crates/ruff_linter/src/rules/flake8_executable/rules/mod.rs
@@ -1,8 +1,5 @@
 use std::path::Path;

-use crate::codes::Rule;
-use crate::comments::shebang::ShebangDirective;
-use crate::settings::LinterSettings;
 use ruff_diagnostics::Diagnostic;
 use ruff_python_trivia::CommentRanges;
 use ruff_source_file::Locator;
@@ -12,6 +9,8 @@ pub(crate) use shebang_missing_python::*;
 pub(crate) use shebang_not_executable::*;
 pub(crate) use shebang_not_first_line::*;

+use crate::comments::shebang::ShebangDirective;
+
 mod shebang_leading_whitespace;
 mod shebang_missing_executable_file;
 mod shebang_missing_python;
@@ -23,39 +22,34 @@ pub(crate) fn from_tokens(
    path: &Path,
    locator: &Locator,
    comment_ranges: &CommentRanges,
-    settings: &LinterSettings,
 ) {
    let mut has_any_shebang = false;
    for range in comment_ranges {
-        let comment = locator.slice(range);
+        let comment = locator.slice(*range);
        if let Some(shebang) = ShebangDirective::try_extract(comment) {
            has_any_shebang = true;

-            if let Some(diagnostic) = shebang_missing_python(range, &shebang) {
+            if let Some(diagnostic) = shebang_missing_python(*range, &shebang) {
                diagnostics.push(diagnostic);
            }

-            if settings.rules.enabled(Rule::ShebangNotExecutable) {
-                if let Some(diagnostic) = shebang_not_executable(path, range) {
-                    diagnostics.push(diagnostic);
-                }
-            }
-
-            if let Some(diagnostic) = shebang_leading_whitespace(range, locator) {
+            if let Some(diagnostic) = shebang_not_executable(path, *range) {
                diagnostics.push(diagnostic);
            }

-            if let Some(diagnostic) = shebang_not_first_line(range, locator) {
+            if let Some(diagnostic) = shebang_leading_whitespace(*range, locator) {
+                diagnostics.push(diagnostic);
+            }
+
+            if let Some(diagnostic) = shebang_not_first_line(*range, locator) {
                diagnostics.push(diagnostic);
            }
        }
    }

    if !has_any_shebang {
-        if settings.rules.enabled(Rule::ShebangMissingExecutableFile) {
-            if let Some(diagnostic) = shebang_missing_executable_file(path) {
-                diagnostics.push(diagnostic);
-            }
+        if let Some(diagnostic) = shebang_missing_executable_file(path) {
+            diagnostics.push(diagnostic);
        }
    }
 }
--- a/crates/ruff_linter/src/rules/flake8_pyi/rules/type_comment_in_stub.rs
+++ b/crates/ruff_linter/src/rules/flake8_pyi/rules/type_comment_in_stub.rs
@@ -41,10 +41,10 @@ pub(crate) fn type_comment_in_stub(
    comment_ranges: &CommentRanges,
 ) {
    for range in comment_ranges {
-        let comment = locator.slice(range);
+        let comment = locator.slice(*range);

        if TYPE_COMMENT_REGEX.is_match(comment) && !TYPE_IGNORE_REGEX.is_match(comment) {
-            diagnostics.push(Diagnostic::new(TypeCommentInStub, range));
+            diagnostics.push(Diagnostic::new(TypeCommentInStub, *range));
        }
    }
 }
--- a/crates/ruff_linter/src/rules/isort/rules/add_required_imports.rs
+++ b/crates/ruff_linter/src/rules/isort/rules/add_required_imports.rs
@@ -35,9 +35,6 @@ use crate::settings::LinterSettings;
 ///
 /// import typing
 /// ```
-///
-/// ## Options
-/// - `lint.isort.required-imports`
 #[violation]
 pub struct MissingRequiredImport(pub String);

--- a/crates/ruff_linter/src/rules/pydoclint/rules/check_docstring.rs
+++ b/crates/ruff_linter/src/rules/pydoclint/rules/check_docstring.rs
@@ -741,10 +741,6 @@ fn returns_documented(
        || (matches!(convention, Some(Convention::Google)) && starts_with_returns(docstring))
 }

-fn should_document_returns(function_def: &ast::StmtFunctionDef) -> bool {
-    !matches!(function_def.name.as_str(), "__new__")
-}
-
 fn starts_with_yields(docstring: &Docstring) -> bool {
    if let Some(first_word) = docstring.body().as_str().split(' ').next() {
        return matches!(first_word, "Yield" | "Yields");
@@ -872,9 +868,7 @@ pub(crate) fn check_docstring(

    // DOC201
    if checker.enabled(Rule::DocstringMissingReturns) {
-        if should_document_returns(function_def)
-            && !returns_documented(docstring, &docstring_sections, convention)
-        {
+        if !returns_documented(docstring, &docstring_sections, convention) {
            let extra_property_decorators = checker.settings.pydocstyle.property_decorators();
            if !definition.is_property(extra_property_decorators, semantic) {
                if let Some(body_return) = body_entries.returns.first() {
--- a/crates/ruff_linter/src/rules/pydocstyle/mod.rs
+++ b/crates/ruff_linter/src/rules/pydocstyle/mod.rs
@@ -49,7 +49,6 @@ mod tests {
    #[test_case(Rule::OverIndentation, Path::new("D.py"))]
    #[test_case(Rule::OverIndentation, Path::new("D208.py"))]
    #[test_case(Rule::NoSignature, Path::new("D.py"))]
-    #[test_case(Rule::NoSignature, Path::new("D402.py"))]
    #[test_case(Rule::SurroundingWhitespace, Path::new("D.py"))]
    #[test_case(Rule::DocstringStartsWithThis, Path::new("D.py"))]
    #[test_case(Rule::UnderIndentation, Path::new("D.py"))]
--- a/crates/ruff_linter/src/rules/pydocstyle/rules/no_signature.rs
+++ b/crates/ruff_linter/src/rules/pydocstyle/rules/no_signature.rs
@@ -66,25 +66,7 @@ pub(crate) fn no_signature(checker: &mut Checker, docstring: &Docstring) {
    // a function named `foo`).
    if first_line
        .match_indices(function.name.as_str())
-        .any(|(index, _)| {
-            // The function name must be preceded by a word boundary.
-            let preceded_by_word_boundary = first_line[..index]
-                .chars()
-                .next_back()
-                .map_or(true, |c| matches!(c, ' ' | '\t' | ';' | ','));
-            if !preceded_by_word_boundary {
-                return false;
-            }
-
-            // The function name must be followed by an open parenthesis.
-            let followed_by_open_parenthesis =
-                first_line[index + function.name.len()..].starts_with('(');
-            if !followed_by_open_parenthesis {
-                return false;
-            }
-
-            true
-        })
+        .any(|(index, _)| first_line[index + function.name.len()..].starts_with('('))
    {
        checker
            .diagnostics
--- a/crates/ruff_linter/src/rules/pydocstyle/rules/triple_quotes.rs
+++ b/crates/ruff_linter/src/rules/pydocstyle/rules/triple_quotes.rs
@@ -67,7 +67,9 @@ impl Violation for TripleSingleQuotes {
 pub(crate) fn triple_quotes(checker: &mut Checker, docstring: &Docstring) {
    let leading_quote = docstring.leading_quote();

-    let prefixes = leading_quote.trim_end_matches(['\'', '"']).to_owned();
+    let prefixes = leading_quote
+        .trim_end_matches(|c| c == '\'' || c == '"')
+        .to_owned();

    let expected_quote = if docstring.body().contains("\"\"\"") {
        if docstring.body().contains("\'\'\'") {
--- a/crates/ruff_linter/src/rules/pydocstyle/snapshots/ruff_linterrulespydocstyletestsD402_D402.py.snap
+++ b/crates/ruff_linter/src/rules/pydocstyle/snapshots/ruff_linterrulespydocstyletestsD402_D402.py.snap
@@ -1,18 +0,0 @@
---
-source: crates/ruff_linter/src/rules/pydocstyle/mod.rs
---
-D402.py:2:5: D402 First line should not be the function's signature
-  |
-1 | def foo():
-2 |     """Returns foo()."""
-  |     ^^^^^^^^^^^^^^^^^^^^ D402
-3 | 
-4 | def foo():
-  |
-
-D402.py:8:5: D402 First line should not be the function's signature
-  |
-7 | def foo():
-8 |     """"Use this function; foo()."""
-  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ D402
-  |
--- a/crates/ruff_linter/src/rules/pyflakes/mod.rs
+++ b/crates/ruff_linter/src/rules/pyflakes/mod.rs
@@ -208,18 +208,6 @@ mod tests {
        Ok(())
    }

-    #[test]
-    fn f821_with_builtin_added_on_new_py_version_but_old_target_version_specified() {
-        let diagnostics = test_snippet(
-            "PythonFinalizationError",
-            &LinterSettings {
-                target_version: crate::settings::types::PythonVersion::Py312,
-                ..LinterSettings::for_rule(Rule::UndefinedName)
-            },
-        );
-        assert_messages!(diagnostics);
-    }
-
    #[test_case(Rule::UnusedVariable, Path::new("F841_4.py"))]
    #[test_case(Rule::UnusedImport, Path::new("__init__.py"))]
    #[test_case(Rule::UnusedImport, Path::new("F401_24/__init__.py"))]
--- a/crates/ruff_linter/src/rules/pyflakes/rules/undefined_name.rs
+++ b/crates/ruff_linter/src/rules/pyflakes/rules/undefined_name.rs
@@ -19,35 +19,17 @@ use ruff_macros::{derive_message_formats, violation};
 ///     return n * 2
 /// ```
 ///
-/// ## Options
-/// - [`target-version`]: Can be used to configure which symbols Ruff will understand
-///   as being available in the `builtins` namespace.
-///
 /// ## References
 /// - [Python documentation: Naming and binding](https://docs.python.org/3/reference/executionmodel.html#naming-and-binding)
 #[violation]
 pub struct UndefinedName {
    pub(crate) name: String,
-    pub(crate) minor_version_builtin_added: Option<u8>,
 }

 impl Violation for UndefinedName {
    #[derive_message_formats]
    fn message(&self) -> String {
-        let UndefinedName {
-            name,
-            minor_version_builtin_added,
-        } = self;
-        let tip = minor_version_builtin_added.map(|version_added| {
-            format!(
-                r#"Consider specifying `requires-python = ">= 3.{version_added}"` or `tool.ruff.target-version = "py3{version_added}"` in your `pyproject.toml` file."#
-            )
-        });
-
-        if let Some(tip) = tip {
-            format!("Undefined name `{name}`. {tip}")
-        } else {
-            format!("Undefined name `{name}`")
-        }
+        let UndefinedName { name } = self;
+        format!("Undefined name `{name}`")
    }
 }
--- a/Show More
+++ b/Show More