Keep public / insider docs requirements in sync

[red-knot] Add symbols defined by match statements (#12926 )
## Summary This PR adds symbols introduced by `match` statements. There are three patterns that introduces new symbols: * `as` pattern * Sequence pattern * Mapping pattern The recursive nature of the visitor makes sure that all symbols are added. ## Test Plan Add test case for all types of patterns that introduces a symbol.
2024-08-20 11:48:19 +05:30 · 2024-08-20 05:16:27 +00:00 · 2024-08-20 10:33:55 +05:30 · 2024-08-19 18:07:41 -05:00 · 2024-08-19 19:06:56 +01:00 · 2024-08-19 13:41:03 +02:00
62 changed files with 2229 additions and 697 deletions
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -6,6 +6,8 @@ exclude: |
    crates/red_knot_workspace/resources/.*|
    crates/ruff_linter/resources/.*|
    crates/ruff_linter/src/rules/.*/snapshots/.*|
+    crates/ruff_notebook/resources/.*|
+    crates/ruff_server/resources/.*|
    crates/ruff/resources/.*|
    crates/ruff_python_formatter/resources/.*|
    crates/ruff_python_formatter/tests/snapshots/.*|
@@ -15,7 +17,7 @@ exclude: |

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

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

  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.5.7
+    rev: v0.6.1
    hooks:
      - id: ruff-format
      - id: ruff
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -61,7 +61,7 @@ The following rules have been stabilized and are no longer in preview:
 - [`invalid-bytes-return-type`](https://docs.astral.sh/ruff/rules/invalid-bytes-return-type/) (`PLE0308`)
 - [`invalid-hash-return-type`](https://docs.astral.sh/ruff/rules/invalid-hash-return-type/) (`PLE0309`)
 - [`invalid-index-return-type`](https://docs.astral.sh/ruff/rules/invalid-index-return-type/) (`PLE0305`)
- [`invalid-length-return-type`](https://docs.astral.sh/ruff/rules/invalid-length-return-type/) (`E303`)
+- [`invalid-length-return-type`](https://docs.astral.sh/ruff/rules/invalid-length-return-type/) (`PLEE303`)
 - [`self-or-cls-assignment`](https://docs.astral.sh/ruff/rules/self-or-cls-assignment/) (`PLW0642`)
 - [`byte-string-usage`](https://docs.astral.sh/ruff/rules/byte-string-usage/) (`PYI057`)
 - [`duplicate-literal-member`](https://docs.astral.sh/ruff/rules/duplicate-literal-member/) (`PYI062`)
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,35 +2,6 @@

 Welcome! We're happy to have you here. Thank you in advance for your contribution to Ruff.

- [The Basics](#the-basics)
-    - [Prerequisites](#prerequisites)
-    - [Development](#development)
-    - [Project Structure](#project-structure)
-    - [Example: Adding a new lint rule](#example-adding-a-new-lint-rule)
-        - [Rule naming convention](#rule-naming-convention)
-        - [Rule testing: fixtures and snapshots](#rule-testing-fixtures-and-snapshots)
-    - [Example: Adding a new configuration option](#example-adding-a-new-configuration-option)
- [MkDocs](#mkdocs)
- [Release Process](#release-process)
-    - [Creating a new release](#creating-a-new-release)
- [Ecosystem CI](#ecosystem-ci)
- [Benchmarking and Profiling](#benchmarking-and-profiling)
-    - [CPython Benchmark](#cpython-benchmark)
-    - [Microbenchmarks](#microbenchmarks)
-        - [Benchmark-driven Development](#benchmark-driven-development)
-        - [PR Summary](#pr-summary)
-        - [Tips](#tips)
-    - [Profiling Projects](#profiling-projects)
-        - [Linux](#linux)
-        - [Mac](#mac)
- [`cargo dev`](#cargo-dev)
- [Subsystems](#subsystems)
-    - [Compilation Pipeline](#compilation-pipeline)
-    - [Import Categorization](#import-categorization)
-        - [Project root](#project-root)
-        - [Package root](#package-root)
-        - [Import categorization](#import-categorization-1)
-
 ## The Basics

 Ruff welcomes contributions in the form of pull requests.
@@ -333,22 +304,34 @@ even patch releases may contain [non-backwards-compatible changes](https://semve
 ### Creating a new release

 1. Install `uv`: `curl -LsSf https://astral.sh/uv/install.sh | sh`
+
 1. Run `./scripts/release.sh`; this command will:
+
    - Generate a temporary virtual environment with `rooster`
    - Generate a changelog entry in `CHANGELOG.md`
    - Update versions in `pyproject.toml` and `Cargo.toml`
    - Update references to versions in the `README.md` and documentation
    - Display contributors for the release
+
 1. The changelog should then be editorialized for consistency
+
    - Often labels will be missing from pull requests they will need to be manually organized into the proper section
    - Changes should be edited to be user-facing descriptions, avoiding internal details
+
 1. Highlight any breaking changes in `BREAKING_CHANGES.md`
+
 1. Run `cargo check`. This should update the lock file with new versions.
+
 1. Create a pull request with the changelog and version updates
+
 1. Merge the PR
+
 1. Run the [release workflow](https://github.com/astral-sh/ruff/actions/workflows/release.yml) with:
+
    - The new version number (without starting `v`)
+
 1. The release workflow will do the following:
+
    1. Build all the assets. If this fails (even though we tested in step 4), we haven't tagged or
        uploaded anything, you can restart after pushing a fix. If you just need to rerun the build,
        make sure you're [re-running all the failed
@@ -359,14 +342,25 @@ even patch releases may contain [non-backwards-compatible changes](https://semve
    1. Attach artifacts to draft GitHub release
    1. Trigger downstream repositories. This can fail non-catastrophically, as we can run any
        downstream jobs manually if needed.
+
 1. Verify the GitHub release:
+
    1. The Changelog should match the content of `CHANGELOG.md`
    1. Append the contributors from the `scripts/release.sh` script
+
 1. If needed, [update the schemastore](https://github.com/astral-sh/ruff/blob/main/scripts/update_schemastore.py).
+
    1. One can determine if an update is needed when
        `git diff old-version-tag new-version-tag -- ruff.schema.json` returns a non-empty diff.
    1. Once run successfully, you should follow the link in the output to create a PR.
-1. If needed, update the `ruff-lsp` and `ruff-vscode` repositories.
+
+1. If needed, update the [`ruff-lsp`](https://github.com/astral-sh/ruff-lsp) and
+    [`ruff-vscode`](https://github.com/astral-sh/ruff-vscode) repositories and follow
+    the release instructions in those repositories. `ruff-lsp` should always be updated
+    before `ruff-vscode`.
+
+    This step is generally not required for a patch release, but should always be done
+    for a minor release.

 ## Ecosystem CI

@@ -389,7 +383,7 @@ We have several ways of benchmarking and profiling Ruff:
 - Microbenchmarks which run the linter or the formatter on individual files. These run on pull requests.
 - Profiling the linter on either the microbenchmarks or entire projects

-> \[!NOTE\]
+> **Note**
 > When running benchmarks, ensure that your CPU is otherwise idle (e.g., close any background
 > applications, like web browsers). You may also want to switch your CPU to a "performance"
 > mode, if it exists, especially when benchmarking short-lived processes.
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -228,9 +228,9 @@ dependencies = [

 [[package]]
 name = "camino"
-version = "1.1.7"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0ec6b951b160caa93cc0c7b209e5a3bff7aae9062213451ac99493cd844c239"
+checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"

 [[package]]
 name = "cast"
@@ -270,6 +270,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"

+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
 [[package]]
 name = "chic"
 version = "1.2.2"
@@ -320,9 +326,9 @@ dependencies = [

 [[package]]
 name = "clap"
-version = "4.5.15"
+version = "4.5.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11d8838454fda655dafd3accb2b6e2bea645b9e4078abe84a22ceb947235c5cc"
+checksum = "ed6719fffa43d0d87e5fd8caeab59be1554fb028cd30edc88fc4369b17971019"
 dependencies = [
 "clap_builder",
 "clap_derive",
@@ -395,7 +401,7 @@ version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f8c93eb5f77c9050c7750e14f13ef1033a40a0aac70c6371535b6763a01438c"
 dependencies = [
- "nix",
+ "nix 0.28.0",
 "terminfo",
 "thiserror",
 "which",
@@ -612,12 +618,12 @@ checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"

 [[package]]
 name = "ctrlc"
-version = "3.4.4"
+version = "3.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "672465ae37dc1bc6380a6547a8883d5dd397b0f1faaad4f265726cc7042a5345"
+checksum = "90eeab0aa92f3f9b4e87f258c72b139c207d251f9cbc1080a0086b86a8870dd3"
 dependencies = [
- "nix",
- "windows-sys 0.52.0",
+ "nix 0.29.0",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@@ -1047,9 +1053,9 @@ dependencies = [

 [[package]]
 name = "indexmap"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3fc2e30ba82dd1b3911c8de1ffc143c74a914a14e99514d7637e3099df5ea0"
+checksum = "93ead53efc7ea8ed3cfb0c79fc8023fbb782a5432b52830b6518941cebe6505c"
 dependencies = [
 "equivalent",
 "hashbrown",
@@ -1215,9 +1221,9 @@ checksum = "8b23360e99b8717f20aaa4598f5a6541efbe30630039fbc7706cf954a87947ae"

 [[package]]
 name = "js-sys"
-version = "0.3.69"
+version = "0.3.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
 dependencies = [
 "wasm-bindgen",
 ]
@@ -1250,9 +1256,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.157"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "374af5f94e54fa97cf75e945cce8a6b201e88a1a07e688b47dfd2a59c66dbd86"

 [[package]]
 name = "libcst"
@@ -1388,6 +1394,16 @@ dependencies = [
 "libmimalloc-sys",
 ]

+[[package]]
+name = "minicov"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c71e683cd655513b99affab7d317deb690528255a0d5f717f1024093c12b169"
+dependencies = [
+ "cc",
+ "walkdir",
+]
+
 [[package]]
 name = "minimal-lexical"
 version = "0.2.1"
@@ -1438,7 +1454,19 @@ checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
 dependencies = [
 "bitflags 2.6.0",
 "cfg-if",
- "cfg_aliases",
+ "cfg_aliases 0.1.1",
+ "libc",
+]
+
+[[package]]
+name = "nix"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
+dependencies = [
+ "bitflags 2.6.0",
+ "cfg-if",
+ "cfg_aliases 0.2.1",
 "libc",
 ]

@@ -1525,9 +1553,9 @@ checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"

 [[package]]
 name = "ordermap"
-version = "0.5.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c81974681ab4f0cc9fe49cad56f821d1cc67a08cd2caa9b5d58b0adaa5dd36d"
+checksum = "61d7d835be600a7ac71b24e39c92fe6fad9e818b3c71bfc379e3ba65e327d77f"
 dependencies = [
 "indexmap",
 ]
@@ -1904,6 +1932,8 @@ dependencies = [
 "ruff_text_size",
 "rustc-hash 2.0.0",
 "salsa",
+ "smallvec",
+ "static_assertions",
 "tempfile",
 "tracing",
 "walkdir",
@@ -2799,9 +2829,9 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"

 [[package]]
 name = "serde"
-version = "1.0.206"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b3e4cd94123dd520a128bcd11e34d9e9e423e7e3e50425cb1b4b1e3549d0284"
+checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2"
 dependencies = [
 "serde_derive",
 ]
@@ -2819,9 +2849,9 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.206"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fabfb6138d2383ea8208cf98ccf69cdfb1aff4088460681d84189aa259762f97"
+checksum = "24008e81ff7613ed8e5ba0cfaf24e2c2f1e5b8a0495711e44fcd4882fca62bcf"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2841,9 +2871,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.124"
+version = "1.0.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66ad62847a56b3dba58cc891acd13884b9c61138d330c0d7b6181713d4fce38d"
+checksum = "83c8e735a073ccf5be70aa8066aa984eaf2fa000db6c8d0100ae605b366d31ed"
 dependencies = [
 "itoa",
 "memchr",
@@ -3002,9 +3032,9 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"

 [[package]]
 name = "syn"
-version = "2.0.74"
+version = "2.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fceb41e3d546d0bd83421d3409b1460cc7444cd389341a4c880fe7a042cb3d7"
+checksum = "f6af063034fc1935ede7be0122941bafa9bacb949334d090b77ca98b5817c7d9"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -3526,19 +3556,20 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
 dependencies = [
 "cfg-if",
+ "once_cell",
 "wasm-bindgen-macro",
 ]

 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
 dependencies = [
 "bumpalo",
 "log",
@@ -3551,9 +3582,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.42"
+version = "0.4.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
+checksum = "61e9300f63a621e96ed275155c108eb6f843b6a26d053f122ab69724559dc8ed"
 dependencies = [
 "cfg-if",
 "js-sys",
@@ -3563,9 +3594,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
 dependencies = [
 "quote",
 "wasm-bindgen-macro-support",
@@ -3573,9 +3604,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -3586,18 +3617,19 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"

 [[package]]
 name = "wasm-bindgen-test"
-version = "0.3.42"
+version = "0.3.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9bf62a58e0780af3e852044583deee40983e5886da43a271dd772379987667b"
+checksum = "68497a05fb21143a08a7d24fc81763384a3072ee43c44e86aad1744d6adef9d9"
 dependencies = [
 "console_error_panic_hook",
 "js-sys",
+ "minicov",
 "scoped-tls",
 "wasm-bindgen",
 "wasm-bindgen-futures",
@@ -3606,9 +3638,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-test-macro"
-version = "0.3.42"
+version = "0.3.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7f89739351a2e03cb94beb799d47fb2cac01759b40ec441f7de39b00cbf7ef0"
+checksum = "4b8220be1fa9e4c889b30fd207d4906657e7e90b12e0e6b0c8b8d8709f5de021"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/crates/red_knot_python_semantic/Cargo.toml
+++ b/crates/red_knot_python_semantic/Cargo.toml
@@ -29,6 +29,8 @@ salsa = { workspace = true }
 tracing = { workspace = true }
 rustc-hash = { workspace = true }
 hashbrown = { workspace = true }
+smallvec = { workspace = true }
+static_assertions = { workspace = true }

 [build-dependencies]
 path-slash = { workspace = true }
--- a/crates/red_knot_python_semantic/src/semantic_index.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index.rs
@@ -16,10 +16,9 @@ use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{
    FileScopeId, NodeWithScopeKey, NodeWithScopeRef, Scope, ScopeId, ScopedSymbolId, SymbolTable,
 };
+use crate::semantic_index::use_def::UseDefMap;
 use crate::Db;

-pub(crate) use self::use_def::UseDefMap;
-
 pub mod ast_ids;
 mod builder;
 pub mod definition;
@@ -27,6 +26,8 @@ pub mod expression;
 pub mod symbol;
 mod use_def;

+pub(crate) use self::use_def::{DefinitionWithConstraints, DefinitionWithConstraintsIterator};
+
 type SymbolMap = hashbrown::HashMap<ScopedSymbolId, (), ()>;

 /// Returns the semantic index for `file`.
@@ -310,12 +311,29 @@ mod tests {
    use ruff_text_size::{Ranged, TextRange};

    use crate::db::tests::TestDb;
-    use crate::semantic_index::ast_ids::HasScopedUseId;
-    use crate::semantic_index::definition::DefinitionKind;
-    use crate::semantic_index::symbol::{FileScopeId, Scope, ScopeKind, SymbolTable};
+    use crate::semantic_index::ast_ids::{HasScopedUseId, ScopedUseId};
+    use crate::semantic_index::definition::{Definition, DefinitionKind};
+    use crate::semantic_index::symbol::{
+        FileScopeId, Scope, ScopeKind, ScopedSymbolId, SymbolTable,
+    };
+    use crate::semantic_index::use_def::UseDefMap;
    use crate::semantic_index::{global_scope, semantic_index, symbol_table, use_def_map};
    use crate::Db;

+    impl UseDefMap<'_> {
+        fn first_public_definition(&self, symbol: ScopedSymbolId) -> Option<Definition<'_>> {
+            self.public_definitions(symbol)
+                .next()
+                .map(|constrained_definition| constrained_definition.definition)
+        }
+
+        fn first_use_definition(&self, use_id: ScopedUseId) -> Option<Definition<'_>> {
+            self.use_definitions(use_id)
+                .next()
+                .map(|constrained_definition| constrained_definition.definition)
+        }
+    }
+
    struct TestCase {
        db: TestDb,
        file: File,
@@ -374,9 +392,7 @@ mod tests {
        let foo = global_table.symbol_id_by_name("foo").unwrap();

        let use_def = use_def_map(&db, scope);
-        let [definition] = use_def.public_definitions(foo) else {
-            panic!("expected one definition");
-        };
+        let definition = use_def.first_public_definition(foo).unwrap();
        assert!(matches!(definition.node(&db), DefinitionKind::Import(_)));
    }

@@ -411,13 +427,13 @@ mod tests {
        );

        let use_def = use_def_map(&db, scope);
-        let [definition] = use_def.public_definitions(
-            global_table
-                .symbol_id_by_name("foo")
-                .expect("symbol to exist"),
-        ) else {
-            panic!("expected one definition");
-        };
+        let definition = use_def
+            .first_public_definition(
+                global_table
+                    .symbol_id_by_name("foo")
+                    .expect("symbol to exist"),
+            )
+            .unwrap();
        assert!(matches!(
            definition.node(&db),
            DefinitionKind::ImportFrom(_)
@@ -438,17 +454,34 @@ mod tests {
            "a symbol used but not defined in a scope should have only the used flag"
        );
        let use_def = use_def_map(&db, scope);
-        let [definition] =
-            use_def.public_definitions(global_table.symbol_id_by_name("x").expect("symbol exists"))
-        else {
-            panic!("expected one definition");
-        };
+        let definition = use_def
+            .first_public_definition(global_table.symbol_id_by_name("x").expect("symbol exists"))
+            .unwrap();
        assert!(matches!(
            definition.node(&db),
            DefinitionKind::Assignment(_)
        ));
    }

+    #[test]
+    fn augmented_assignment() {
+        let TestCase { db, file } = test_case("x += 1");
+        let scope = global_scope(&db, file);
+        let global_table = symbol_table(&db, scope);
+
+        assert_eq!(names(&global_table), vec!["x"]);
+
+        let use_def = use_def_map(&db, scope);
+        let definition = use_def
+            .first_public_definition(global_table.symbol_id_by_name("x").unwrap())
+            .unwrap();
+
+        assert!(matches!(
+            definition.node(&db),
+            DefinitionKind::AugmentedAssignment(_)
+        ));
+    }
+
    #[test]
    fn class_scope() {
        let TestCase { db, file } = test_case(
@@ -477,11 +510,9 @@ y = 2
        assert_eq!(names(&class_table), vec!["x"]);

        let use_def = index.use_def_map(class_scope_id);
-        let [definition] =
-            use_def.public_definitions(class_table.symbol_id_by_name("x").expect("symbol exists"))
-        else {
-            panic!("expected one definition");
-        };
+        let definition = use_def
+            .first_public_definition(class_table.symbol_id_by_name("x").expect("symbol exists"))
+            .unwrap();
        assert!(matches!(
            definition.node(&db),
            DefinitionKind::Assignment(_)
@@ -515,13 +546,13 @@ y = 2
        assert_eq!(names(&function_table), vec!["x"]);

        let use_def = index.use_def_map(function_scope_id);
-        let [definition] = use_def.public_definitions(
-            function_table
-                .symbol_id_by_name("x")
-                .expect("symbol exists"),
-        ) else {
-            panic!("expected one definition");
-        };
+        let definition = use_def
+            .first_public_definition(
+                function_table
+                    .symbol_id_by_name("x")
+                    .expect("symbol exists"),
+            )
+            .unwrap();
        assert!(matches!(
            definition.node(&db),
            DefinitionKind::Assignment(_)
@@ -557,26 +588,26 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):

        let use_def = index.use_def_map(function_scope_id);
        for name in ["a", "b", "c", "d"] {
-            let [definition] = use_def.public_definitions(
-                function_table
-                    .symbol_id_by_name(name)
-                    .expect("symbol exists"),
-            ) else {
-                panic!("Expected parameter definition for {name}");
-            };
+            let definition = use_def
+                .first_public_definition(
+                    function_table
+                        .symbol_id_by_name(name)
+                        .expect("symbol exists"),
+                )
+                .unwrap();
            assert!(matches!(
                definition.node(&db),
                DefinitionKind::ParameterWithDefault(_)
            ));
        }
        for name in ["args", "kwargs"] {
-            let [definition] = use_def.public_definitions(
-                function_table
-                    .symbol_id_by_name(name)
-                    .expect("symbol exists"),
-            ) else {
-                panic!("Expected parameter definition for {name}");
-            };
+            let definition = use_def
+                .first_public_definition(
+                    function_table
+                        .symbol_id_by_name(name)
+                        .expect("symbol exists"),
+                )
+                .unwrap();
            assert!(matches!(definition.node(&db), DefinitionKind::Parameter(_)));
        }
    }
@@ -605,22 +636,22 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):

        let use_def = index.use_def_map(lambda_scope_id);
        for name in ["a", "b", "c", "d"] {
-            let [definition] = use_def
-                .public_definitions(lambda_table.symbol_id_by_name(name).expect("symbol exists"))
-            else {
-                panic!("Expected parameter definition for {name}");
-            };
+            let definition = use_def
+                .first_public_definition(
+                    lambda_table.symbol_id_by_name(name).expect("symbol exists"),
+                )
+                .unwrap();
            assert!(matches!(
                definition.node(&db),
                DefinitionKind::ParameterWithDefault(_)
            ));
        }
        for name in ["args", "kwargs"] {
-            let [definition] = use_def
-                .public_definitions(lambda_table.symbol_id_by_name(name).expect("symbol exists"))
-            else {
-                panic!("Expected parameter definition for {name}");
-            };
+            let definition = use_def
+                .first_public_definition(
+                    lambda_table.symbol_id_by_name(name).expect("symbol exists"),
+                )
+                .unwrap();
            assert!(matches!(definition.node(&db), DefinitionKind::Parameter(_)));
        }
    }
@@ -691,9 +722,7 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
        let element_use_id =
            element.scoped_use_id(&db, comprehension_scope_id.to_scope_id(&db, file));

-        let [definition] = use_def.use_definitions(element_use_id) else {
-            panic!("expected one definition")
-        };
+        let definition = use_def.first_use_definition(element_use_id).unwrap();
        let DefinitionKind::Comprehension(comprehension) = definition.node(&db) else {
            panic!("expected generator definition")
        };
@@ -790,13 +819,13 @@ def func():
        assert_eq!(names(&func2_table), vec!["y"]);

        let use_def = index.use_def_map(FileScopeId::global());
-        let [definition] = use_def.public_definitions(
-            global_table
-                .symbol_id_by_name("func")
-                .expect("symbol exists"),
-        ) else {
-            panic!("expected one definition");
-        };
+        let definition = use_def
+            .first_public_definition(
+                global_table
+                    .symbol_id_by_name("func")
+                    .expect("symbol exists"),
+            )
+            .unwrap();
        assert!(matches!(definition.node(&db), DefinitionKind::Function(_)));
    }

@@ -897,9 +926,7 @@ class C[T]:
        };
        let x_use_id = x_use_expr_name.scoped_use_id(&db, scope);
        let use_def = use_def_map(&db, scope);
-        let [definition] = use_def.use_definitions(x_use_id) else {
-            panic!("expected one definition");
-        };
+        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")
        };
@@ -990,4 +1017,28 @@ def x():
            vec!["bar", "foo", "Test", "<module>"]
        );
    }
+
+    #[test]
+    fn match_stmt_symbols() {
+        let TestCase { db, file } = test_case(
+            "
+match subject:
+    case a: ...
+    case [b, c, *d]: ...
+    case e as f: ...
+    case {'x': g, **h}: ...
+    case Foo(i, z=j): ...
+    case k | l: ...
+    case _: ...
+",
+        );
+
+        let global_table = symbol_table(&db, global_scope(&db, file));
+
+        assert!(global_table.symbol_by_name("Foo").unwrap().is_used());
+        assert_eq!(
+            names(&global_table),
+            vec!["subject", "a", "b", "c", "d", "f", "e", "h", "g", "Foo", "i", "j", "k", "l"]
+        );
+    }
 }
--- a/crates/red_knot_python_semantic/src/semantic_index/builder.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/builder.rs
@@ -7,7 +7,8 @@ use ruff_db::parsed::ParsedModule;
 use ruff_index::IndexVec;
 use ruff_python_ast as ast;
 use ruff_python_ast::name::Name;
-use ruff_python_ast::visitor::{walk_expr, walk_stmt, Visitor};
+use ruff_python_ast::visitor::{walk_expr, walk_pattern, walk_stmt, Visitor};
+use ruff_python_ast::AnyParameterRef;

 use crate::ast_node_ref::AstNodeRef;
 use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey;
@@ -155,7 +156,7 @@ impl<'db> SemanticIndexBuilder<'db> {
        self.current_use_def_map_mut().restore(state);
    }

-    fn flow_merge(&mut self, state: &FlowSnapshot) {
+    fn flow_merge(&mut self, state: FlowSnapshot) {
        self.current_use_def_map_mut().merge(state);
    }

@@ -195,9 +196,16 @@ impl<'db> SemanticIndexBuilder<'db> {
        definition
    }

+    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(expression);
+
+        expression
+    }
+
    /// 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) {
+    fn add_standalone_expression(&mut self, expression_node: &ast::Expr) -> Expression<'db> {
        let expression = Expression::new(
            self.db,
            self.file,
@@ -210,6 +218,7 @@ impl<'db> SemanticIndexBuilder<'db> {
        );
        self.expressions_by_node
            .insert(expression_node.into(), expression);
+        expression
    }

    fn with_type_params(
@@ -301,6 +310,23 @@ impl<'db> SemanticIndexBuilder<'db> {
        }
    }

+    fn declare_parameter(&mut self, parameter: AnyParameterRef) {
+        let symbol =
+            self.add_or_update_symbol(parameter.name().id().clone(), SymbolFlags::IS_DEFINED);
+
+        let definition = self.add_definition(symbol, parameter);
+
+        if let AnyParameterRef::NonVariadic(with_default) = parameter {
+            // Insert a mapping from the parameter to the same definition.
+            // This ensures that calling `HasTy::ty` on the inner parameter returns
+            // a valid type (and doesn't panic)
+            self.definitions_by_node.insert(
+                DefinitionNodeRef::from(AnyParameterRef::Variadic(&with_default.parameter)).key(),
+                definition,
+            );
+        }
+    }
+
    pub(super) fn build(mut self) -> SemanticIndex<'db> {
        let module = self.module;
        self.visit_body(module.suite());
@@ -391,11 +417,7 @@ where

                        // Add symbols and definitions for the parameters to the function scope.
                        for parameter in &*function_def.parameters {
-                            let symbol = builder.add_or_update_symbol(
-                                parameter.name().id().clone(),
-                                SymbolFlags::IS_DEFINED,
-                            );
-                            builder.add_definition(symbol, parameter);
+                            builder.declare_parameter(parameter);
                        }

                        builder.visit_body(&function_def.body);
@@ -473,9 +495,24 @@ where
                self.visit_expr(&node.target);
                self.current_assignment = None;
            }
+            ast::Stmt::AugAssign(
+                aug_assign @ ast::StmtAugAssign {
+                    range: _,
+                    target,
+                    op: _,
+                    value,
+                },
+            ) => {
+                debug_assert!(self.current_assignment.is_none());
+                self.visit_expr(value);
+                self.current_assignment = Some(aug_assign.into());
+                self.visit_expr(target);
+                self.current_assignment = None;
+            }
            ast::Stmt::If(node) => {
                self.visit_expr(&node.test);
                let pre_if = self.flow_snapshot();
+                self.add_constraint(&node.test);
                self.visit_body(&node.body);
                let mut post_clauses: Vec<FlowSnapshot> = vec![];
                for clause in &node.elif_else_clauses {
@@ -488,7 +525,7 @@ where
                    self.visit_elif_else_clause(clause);
                }
                for post_clause_state in post_clauses {
-                    self.flow_merge(&post_clause_state);
+                    self.flow_merge(post_clause_state);
                }
                let has_else = node
                    .elif_else_clauses
@@ -497,7 +534,7 @@ where
                if !has_else {
                    // if there's no else clause, then it's possible we took none of the branches,
                    // and the pre_if state can reach here
-                    self.flow_merge(&pre_if);
+                    self.flow_merge(pre_if);
                }
            }
            ast::Stmt::While(node) => {
@@ -515,13 +552,13 @@ 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.flow_merge(pre_loop);
                self.visit_body(&node.orelse);

                // Breaking out of a while 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);
+                    self.flow_merge(break_state);
                }
            }
            ast::Stmt::Break(_) => {
@@ -540,12 +577,21 @@ where

        match expr {
            ast::Expr::Name(name_node @ ast::ExprName { id, ctx, .. }) => {
-                let flags = match ctx {
+                let mut flags = match ctx {
                    ast::ExprContext::Load => SymbolFlags::IS_USED,
                    ast::ExprContext::Store => SymbolFlags::IS_DEFINED,
                    ast::ExprContext::Del => SymbolFlags::IS_DEFINED,
                    ast::ExprContext::Invalid => SymbolFlags::empty(),
                };
+                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 {
@@ -561,6 +607,9 @@ where
                        Some(CurrentAssignment::AnnAssign(ann_assign)) => {
                            self.add_definition(symbol, ann_assign);
                        }
+                        Some(CurrentAssignment::AugAssign(aug_assign)) => {
+                            self.add_definition(symbol, aug_assign);
+                        }
                        Some(CurrentAssignment::Named(named)) => {
                            // TODO(dhruvmanila): If the current scope is a comprehension, then the
                            // named expression is implicitly nonlocal. This is yet to be
@@ -609,11 +658,7 @@ where
                // Add symbols and definitions for the parameters to the lambda scope.
                if let Some(parameters) = &lambda.parameters {
                    for parameter in &**parameters {
-                        let symbol = self.add_or_update_symbol(
-                            parameter.name().id().clone(),
-                            SymbolFlags::IS_DEFINED,
-                        );
-                        self.add_definition(symbol, parameter);
+                        self.declare_parameter(parameter);
                    }
                }

@@ -631,7 +676,7 @@ where
                let post_body = self.flow_snapshot();
                self.flow_restore(pre_if);
                self.visit_expr(orelse);
-                self.flow_merge(&post_body);
+                self.flow_merge(post_body);
            }
            ast::Expr::ListComp(
                list_comprehension @ ast::ExprListComp {
@@ -702,12 +747,32 @@ where
            self.visit_parameter(parameter);
        }
    }
+
+    fn visit_pattern(&mut self, pattern: &'ast ast::Pattern) {
+        if let ast::Pattern::MatchAs(ast::PatternMatchAs {
+            name: Some(name), ..
+        })
+        | ast::Pattern::MatchStar(ast::PatternMatchStar {
+            name: Some(name),
+            range: _,
+        })
+        | ast::Pattern::MatchMapping(ast::PatternMatchMapping {
+            rest: Some(name), ..
+        }) = pattern
+        {
+            // TODO(dhruvmanila): Add definition
+            self.add_or_update_symbol(name.id.clone(), SymbolFlags::IS_DEFINED);
+        }
+
+        walk_pattern(self, pattern);
+    }
 }

 #[derive(Copy, Clone, Debug)]
 enum CurrentAssignment<'a> {
    Assign(&'a ast::StmtAssign),
    AnnAssign(&'a ast::StmtAnnAssign),
+    AugAssign(&'a ast::StmtAugAssign),
    Named(&'a ast::ExprNamed),
    Comprehension {
        node: &'a ast::Comprehension,
@@ -727,6 +792,12 @@ impl<'a> From<&'a ast::StmtAnnAssign> for CurrentAssignment<'a> {
    }
 }

+impl<'a> From<&'a ast::StmtAugAssign> for CurrentAssignment<'a> {
+    fn from(value: &'a ast::StmtAugAssign) -> Self {
+        Self::AugAssign(value)
+    }
+}
+
 impl<'a> From<&'a ast::ExprNamed> for CurrentAssignment<'a> {
    fn from(value: &'a ast::ExprNamed) -> Self {
        Self::Named(value)
--- a/crates/red_knot_python_semantic/src/semantic_index/definition.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/definition.rs
@@ -44,6 +44,7 @@ pub(crate) enum DefinitionNodeRef<'a> {
    NamedExpression(&'a ast::ExprNamed),
    Assignment(AssignmentDefinitionNodeRef<'a>),
    AnnotatedAssignment(&'a ast::StmtAnnAssign),
+    AugmentedAssignment(&'a ast::StmtAugAssign),
    Comprehension(ComprehensionDefinitionNodeRef<'a>),
    Parameter(ast::AnyParameterRef<'a>),
 }
@@ -72,6 +73,12 @@ impl<'a> From<&'a ast::StmtAnnAssign> for DefinitionNodeRef<'a> {
    }
 }

+impl<'a> From<&'a ast::StmtAugAssign> for DefinitionNodeRef<'a> {
+    fn from(node: &'a ast::StmtAugAssign) -> Self {
+        Self::AugmentedAssignment(node)
+    }
+}
+
 impl<'a> From<&'a ast::Alias> for DefinitionNodeRef<'a> {
    fn from(node_ref: &'a ast::Alias) -> Self {
        Self::Import(node_ref)
@@ -151,6 +158,9 @@ impl DefinitionNodeRef<'_> {
            DefinitionNodeRef::AnnotatedAssignment(assign) => {
                DefinitionKind::AnnotatedAssignment(AstNodeRef::new(parsed, assign))
            }
+            DefinitionNodeRef::AugmentedAssignment(augmented_assignment) => {
+                DefinitionKind::AugmentedAssignment(AstNodeRef::new(parsed, augmented_assignment))
+            }
            DefinitionNodeRef::Comprehension(ComprehensionDefinitionNodeRef { node, first }) => {
                DefinitionKind::Comprehension(ComprehensionDefinitionKind {
                    node: AstNodeRef::new(parsed, node),
@@ -182,6 +192,7 @@ impl DefinitionNodeRef<'_> {
                target,
            }) => target.into(),
            Self::AnnotatedAssignment(node) => node.into(),
+            Self::AugmentedAssignment(node) => node.into(),
            Self::Comprehension(ComprehensionDefinitionNodeRef { node, first: _ }) => node.into(),
            Self::Parameter(node) => match node {
                ast::AnyParameterRef::Variadic(parameter) => parameter.into(),
@@ -200,6 +211,7 @@ pub enum DefinitionKind {
    NamedExpression(AstNodeRef<ast::ExprNamed>),
    Assignment(AssignmentDefinitionKind),
    AnnotatedAssignment(AstNodeRef<ast::StmtAnnAssign>),
+    AugmentedAssignment(AstNodeRef<ast::StmtAugAssign>),
    Comprehension(ComprehensionDefinitionKind),
    Parameter(AstNodeRef<ast::Parameter>),
    ParameterWithDefault(AstNodeRef<ast::ParameterWithDefault>),
@@ -248,6 +260,10 @@ impl AssignmentDefinitionKind {
    pub(crate) fn assignment(&self) -> &ast::StmtAssign {
        self.assignment.node()
    }
+
+    pub(crate) fn target(&self) -> &ast::ExprName {
+        self.target.node()
+    }
 }

 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
@@ -289,6 +305,12 @@ impl From<&ast::StmtAnnAssign> for DefinitionNodeKey {
    }
 }

+impl From<&ast::StmtAugAssign> for DefinitionNodeKey {
+    fn from(node: &ast::StmtAugAssign) -> Self {
+        Self(NodeKey::from_node(node))
+    }
+}
+
 impl From<&ast::Comprehension> for DefinitionNodeKey {
    fn from(node: &ast::Comprehension) -> Self {
        Self(NodeKey::from_node(node))
--- a/crates/red_knot_python_semantic/src/semantic_index/expression.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/expression.rs
@@ -21,7 +21,7 @@ pub(crate) struct Expression<'db> {
    /// The expression node.
    #[no_eq]
    #[return_ref]
-    pub(crate) node: AstNodeRef<ast::Expr>,
+    pub(crate) node_ref: AstNodeRef<ast::Expr>,

    #[no_eq]
    count: countme::Count<Expression<'static>>,
--- 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,4 +1,5 @@
-//! Build a map from each use of a symbol to the definitions visible from that use.
+//! 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:
 //!
@@ -6,7 +7,7 @@
 //! x = 1
 //! x = 2
 //! y = x
-//! if flag:
+//! if y is not None:
 //!     x = 3
 //! else:
 //!     x = 4
@@ -34,8 +35,8 @@
 //! [`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.
 //!
-//! The other 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
+//! 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?
 //!
@@ -53,42 +54,55 @@
 //! start.)
 //!
 //! So this means that the publicly-visible definitions of a symbol are the definitions still
-//! visible at the end of the scope.
+//! visible at the end of the scope; effectively we have an implicit "use" of every symbol at the
+//! end of the scope.
 //!
-//! The data structure we build to answer these two questions is the `UseDefMap`. It has a
+//! We also need to know, for a given definition of a symbol, what type-narrowing constraints apply
+//! to it. For instance, in this code sample:
+//!
+//! ```python
+//! x = 1 if flag else None
+//! if x is not None:
+//!     y = x
+//! ```
+//!
+//! 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
 //! `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.
+//! 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 and all the allocations that would entail, we don't
-//! actually store these "list of visible definitions" as a vector of [`Definition`] IDs. Instead,
-//! the values in `definitions_by_use` and `public_definitions` are a [`Definitions`] struct that
-//! keeps a [`Range`] into a third vector of [`Definition`] IDs, `all_definitions`. The trick with
-//! this representation is that it requires that the definitions visible at any given use of a
-//! symbol are stored sequentially in `all_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, 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: it might be unbound in the
-//! scope. (This isn't equivalent to "zero visible definitions", since we may go through an `if`
-//! that has a definition for the symbol, leaving us with one visible definition, but still also
-//! the "unbound" possibility, since we might not have taken the `if` branch.)
+//! There is another special kind of possible "definition" for a symbol: there might be a path from
+//! the scope entry to a given use in which the symbol is never bound.
 //!
 //! The simplest way to model "unbound" would be as an actual [`Definition`] itself: the initial
 //! visible [`Definition`] for each symbol in a scope. But actually modeling it this way would
-//! dramatically increase the number of [`Definition`] that Salsa must track. Since "unbound" is a
+//! 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, we can represent it more efficiently: we use the `may_be_unbound` boolean on the
-//! [`Definitions`] 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.
+//! 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 and definition
-//! as they are encountered by the
+//! 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 currently-visible definitions for that symbol. When we hit
-//! a use of a symbol, it records the currently-visible definitions for that symbol as the visible
-//! definitions for that use. When we reach the end of the scope, it records the currently-visible
-//! definitions 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 visible
 //! definitions, and may be unbound. When we see `x = 1`, we record that as the sole visible
@@ -98,10 +112,11 @@
 //!
 //! Then we hit the `if` branch. We visit the `test` node (`flag` in this case), since that will
 //! happen regardless. Then we take a pre-branch snapshot of the currently visible definitions for
-//! all symbols, which we'll need later. Then we go ahead and visit the `if` body. When we see `x =
-//! 3`, it replaces `x = 2` 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.
+//! 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
@@ -125,98 +140,142 @@
 //! (In the future we may have some other questions we want to answer as well, such as "is this
 //! definition used?", which will require tracking a bit more info in our map, e.g. a "used" bit
 //! for each [`Definition`] which is flipped to true when we record that definition for a use.)
+use self::symbol_state::{
+    ConstraintIdIterator, DefinitionIdWithConstraintsIterator, ScopedConstraintId,
+    ScopedDefinitionId, SymbolState,
+};
 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 std::ops::Range;

-/// All definitions that can reach a given use of a name.
+mod bitset;
+mod symbol_state;
+
+/// Applicable definitions and constraints for every use of a name.
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) struct UseDefMap<'db> {
-    // TODO store constraints with definitions for type narrowing
-    /// Definition IDs array for `definitions_by_use` and `public_definitions` to slice into.
-    all_definitions: Vec<Definition<'db>>,
+    /// Array of [`Definition`] in this scope.
+    all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,

-    /// Definitions that can reach a [`ScopedUseId`].
-    definitions_by_use: IndexVec<ScopedUseId, Definitions>,
+    /// Array of constraints (as [`Expression`]) in this scope.
+    all_constraints: IndexVec<ScopedConstraintId, Expression<'db>>,

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

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

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

-    pub(crate) fn public_definitions(&self, symbol: ScopedSymbolId) -> &[Definition<'db>] {
-        &self.all_definitions[self.public_definitions[symbol].definitions_range.clone()]
+    pub(crate) fn public_definitions(
+        &self,
+        symbol: ScopedSymbolId,
+    ) -> 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_definitions[symbol].may_be_unbound
+        self.public_definitions[symbol].may_be_unbound()
    }
 }

-/// Definitions visible for a symbol at a particular use (or end-of-scope).
-#[derive(Clone, Debug, PartialEq, Eq)]
-struct Definitions {
-    /// [`Range`] in `all_definitions` of the visible definition IDs.
-    definitions_range: Range<usize>,
-    /// Is the symbol possibly unbound at this point?
-    may_be_unbound: bool,
-}
-
-impl Definitions {
-    /// The default state of a symbol is "no definitions, may be unbound", aka definitely-unbound.
-    fn unbound() -> Self {
-        Self {
-            definitions_range: Range::default(),
-            may_be_unbound: true,
-        }
-    }
-}
-
-impl Default for Definitions {
-    fn default() -> Self {
-        Definitions::unbound()
-    }
-}
-
-/// A snapshot of the visible definitions for each symbol at a particular point in control flow.
-#[derive(Clone, Debug)]
-pub(super) struct FlowSnapshot {
-    definitions_by_symbol: IndexVec<ScopedSymbolId, Definitions>,
-}
-
 #[derive(Debug)]
+pub(crate) struct DefinitionWithConstraintsIterator<'map, 'db> {
+    all_definitions: &'map IndexVec<ScopedDefinitionId, Definition<'db>>,
+    all_constraints: &'map IndexVec<ScopedConstraintId, Expression<'db>>,
+    inner: DefinitionIdWithConstraintsIterator<'map>,
+}
+
+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| 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,
+                },
+            })
+    }
+}
+
+impl std::iter::FusedIterator for DefinitionWithConstraintsIterator<'_, '_> {}
+
+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, Expression<'db>>,
+    constraint_ids: ConstraintIdIterator<'map>,
+}
+
+impl<'map, 'db> Iterator for ConstraintsIterator<'map, 'db> {
+    type Item = Expression<'db>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.constraint_ids
+            .next()
+            .map(|constraint_id| self.all_constraints[constraint_id])
+    }
+}
+
+impl std::iter::FusedIterator for ConstraintsIterator<'_, '_> {}
+
+/// A snapshot of the definitions and constraints state at a particular point in control flow.
+#[derive(Clone, Debug)]
+pub(super) struct FlowSnapshot {
+    definitions_by_symbol: IndexVec<ScopedSymbolId, SymbolState>,
+}
+
+#[derive(Debug, Default)]
 pub(super) struct UseDefMapBuilder<'db> {
-    /// Definition IDs array for `definitions_by_use` and `definitions_by_symbol` to slice into.
-    all_definitions: Vec<Definition<'db>>,
+    /// Append-only array of [`Definition`]; None is unbound.
+    all_definitions: IndexVec<ScopedDefinitionId, Definition<'db>>,
+
+    /// Append-only array of constraints (as [`Expression`]).
+    all_constraints: IndexVec<ScopedConstraintId, Expression<'db>>,

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

    /// Currently visible definitions for each symbol.
-    definitions_by_symbol: IndexVec<ScopedSymbolId, Definitions>,
+    definitions_by_symbol: IndexVec<ScopedSymbolId, SymbolState>,
 }

 impl<'db> UseDefMapBuilder<'db> {
    pub(super) fn new() -> Self {
-        Self {
-            all_definitions: Vec::new(),
-            definitions_by_use: IndexVec::new(),
-            definitions_by_symbol: IndexVec::new(),
-        }
+        Self::default()
    }

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

@@ -227,13 +286,15 @@ impl<'db> UseDefMapBuilder<'db> {
    ) {
        // We have a new definition of a symbol; this replaces any previous definitions in this
        // path.
-        let def_idx = self.all_definitions.len();
-        self.all_definitions.push(definition);
-        self.definitions_by_symbol[symbol] = Definitions {
-            #[allow(clippy::range_plus_one)]
-            definitions_range: def_idx..(def_idx + 1),
-            may_be_unbound: false,
-        };
+        let def_id = self.all_definitions.push(definition);
+        self.definitions_by_symbol[symbol] = SymbolState::with(def_id);
+    }
+
+    pub(super) fn record_constraint(&mut self, constraint: Expression<'db>) {
+        let constraint_id = self.all_constraints.push(constraint);
+        for definitions in &mut self.definitions_by_symbol {
+            definitions.add_constraint(constraint_id);
+        }
    }

    pub(super) fn record_use(&mut self, symbol: ScopedSymbolId, use_id: ScopedUseId) {
@@ -265,15 +326,15 @@ impl<'db> UseDefMapBuilder<'db> {

        // If the snapshot we are restoring is missing some symbols we've recorded since, we need
        // to fill them in so the symbol IDs continue to line up. Since they don't exist in the
-        // snapshot, the correct state to fill them in with is "unbound", the default.
+        // snapshot, the correct state to fill them in with is "unbound".
        self.definitions_by_symbol
-            .resize(num_symbols, Definitions::unbound());
+            .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 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) {
+    pub(super) fn merge(&mut self, snapshot: FlowSnapshot) {
        // The tricky thing about merging two Ranges pointing into `all_definitions` is that if the
        // two Ranges aren't already adjacent in `all_definitions`, we will have to copy at least
        // one or the other of the ranges to the end of `all_definitions` so as to make them
@@ -287,66 +348,26 @@ impl<'db> UseDefMapBuilder<'db> {
        // greater than the number of known symbols in a previously-taken snapshot.
        debug_assert!(self.definitions_by_symbol.len() >= snapshot.definitions_by_symbol.len());

-        for (symbol_id, current) in self.definitions_by_symbol.iter_mut_enumerated() {
-            let Some(snapshot) = snapshot.definitions_by_symbol.get(symbol_id) else {
-                // Symbol not present in snapshot, so it's unbound from that path.
-                current.may_be_unbound = true;
-                continue;
-            };
-
-            // If the symbol can be unbound in either predecessor, it can be unbound post-merge.
-            current.may_be_unbound |= snapshot.may_be_unbound;
-
-            // Merge the definition ranges.
-            let current = &mut current.definitions_range;
-            let snapshot = &snapshot.definitions_range;
-
-            // We never create reversed ranges.
-            debug_assert!(current.end >= current.start);
-            debug_assert!(snapshot.end >= snapshot.start);
-
-            if current == snapshot {
-                // Ranges already identical, nothing to do.
-            } else if snapshot.is_empty() {
-                // Merging from an empty range; nothing to do.
-            } else if (*current).is_empty() {
-                // Merging to an empty range; just use the incoming range.
-                *current = snapshot.clone();
-            } else if snapshot.end >= current.start && snapshot.start <= current.end {
-                // Ranges are adjacent or overlapping, merge them in-place.
-                *current = current.start.min(snapshot.start)..current.end.max(snapshot.end);
-            } else if current.end == self.all_definitions.len() {
-                // Ranges are not adjacent or overlapping, `current` is at the end of
-                // `all_definitions`, we need to copy `snapshot` to the end so they are adjacent
-                // and can be merged into one range.
-                self.all_definitions.extend_from_within(snapshot.clone());
-                current.end = self.all_definitions.len();
-            } else if snapshot.end == self.all_definitions.len() {
-                // Ranges are not adjacent or overlapping, `snapshot` is at the end of
-                // `all_definitions`, we need to copy `current` to the end so they are adjacent and
-                // can be merged into one range.
-                self.all_definitions.extend_from_within(current.clone());
-                current.start = snapshot.start;
-                current.end = self.all_definitions.len();
+        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 {
-                // Ranges are not adjacent and neither one is at the end of `all_definitions`, we
-                // have to copy both to the end so they are adjacent and we can merge them.
-                let start = self.all_definitions.len();
-                self.all_definitions.extend_from_within(current.clone());
-                self.all_definitions.extend_from_within(snapshot.clone());
-                current.start = start;
-                current.end = self.all_definitions.len();
+                // Symbol not present in snapshot, so it's unbound from that path.
+                current.add_unbound();
            }
        }
    }

    pub(super) fn finish(mut self) -> UseDefMap<'db> {
        self.all_definitions.shrink_to_fit();
+        self.all_constraints.shrink_to_fit();
        self.definitions_by_symbol.shrink_to_fit();
        self.definitions_by_use.shrink_to_fit();

        UseDefMap {
            all_definitions: self.all_definitions,
+            all_constraints: self.all_constraints,
            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
@@ -0,0 +1,228 @@
+/// Ordered set of `u32`.
+///
+/// Uses an inline bit-set for small values (up to 64 * B), falls back to heap allocated vector of
+/// blocks for larger values.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(super) enum BitSet<const B: usize> {
+    /// Bit-set (in 64-bit blocks) for the first 64 * B entries.
+    Inline([u64; B]),
+
+    /// Overflow beyond 64 * B.
+    Heap(Vec<u64>),
+}
+
+impl<const B: usize> Default for BitSet<B> {
+    fn default() -> Self {
+        // B * 64 must fit in a u32, or else we have unusable bits; this assertion makes the
+        // truncating casts to u32 below safe. This would be better as a const assertion, but
+        // that's not possible on stable with const generic params. (B should never really be
+        // anywhere close to this large.)
+        assert!(B * 64 < (u32::MAX as usize));
+        // This implementation requires usize >= 32 bits.
+        static_assertions::const_assert!(usize::BITS >= 32);
+        Self::Inline([0; B])
+    }
+}
+
+impl<const B: usize> BitSet<B> {
+    /// Create and return a new [`BitSet`] with a single `value` inserted.
+    pub(super) fn with(value: u32) -> Self {
+        let mut bitset = Self::default();
+        bitset.insert(value);
+        bitset
+    }
+
+    /// 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;
+        match self {
+            Self::Inline(blocks) => {
+                let mut vec = blocks.to_vec();
+                vec.resize(num_blocks_needed as usize, 0);
+                *self = Self::Heap(vec);
+            }
+            Self::Heap(vec) => {
+                vec.resize(num_blocks_needed as usize, 0);
+            }
+        }
+    }
+
+    fn blocks_mut(&mut self) -> &mut [u64] {
+        match self {
+            Self::Inline(blocks) => blocks.as_mut_slice(),
+            Self::Heap(blocks) => blocks.as_mut_slice(),
+        }
+    }
+
+    fn blocks(&self) -> &[u64] {
+        match self {
+            Self::Inline(blocks) => blocks.as_slice(),
+            Self::Heap(blocks) => blocks.as_slice(),
+        }
+    }
+
+    /// Insert a value into the [`BitSet`].
+    ///
+    /// Return true if the value was newly inserted, false if already present.
+    pub(super) fn insert(&mut self, value: u32) -> bool {
+        let value_usize = value as usize;
+        let (block, index) = (value_usize / 64, value_usize % 64);
+        if block >= self.blocks().len() {
+            self.resize(value);
+        }
+        let blocks = self.blocks_mut();
+        let missing = blocks[block] & (1 << index) == 0;
+        blocks[block] |= 1 << index;
+        missing
+    }
+
+    /// Intersect in-place with another [`BitSet`].
+    pub(super) fn intersect(&mut self, other: &BitSet<B>) {
+        let my_blocks = self.blocks_mut();
+        let other_blocks = other.blocks();
+        let min_len = my_blocks.len().min(other_blocks.len());
+        for i in 0..min_len {
+            my_blocks[i] &= other_blocks[i];
+        }
+        for block in my_blocks.iter_mut().skip(min_len) {
+            *block = 0;
+        }
+    }
+
+    /// Return an iterator over the values (in ascending order) in this [`BitSet`].
+    pub(super) fn iter(&self) -> BitSetIterator<'_, B> {
+        let blocks = self.blocks();
+        BitSetIterator {
+            blocks,
+            current_block_index: 0,
+            current_block: blocks[0],
+        }
+    }
+}
+
+/// Iterator over values in a [`BitSet`].
+#[derive(Debug)]
+pub(super) struct BitSetIterator<'a, const B: usize> {
+    /// The blocks we are iterating over.
+    blocks: &'a [u64],
+
+    /// The index of the block we are currently iterating through.
+    current_block_index: usize,
+
+    /// The block we are currently iterating through (and zeroing as we go.)
+    current_block: u64,
+}
+
+impl<const B: usize> Iterator for BitSetIterator<'_, B> {
+    type Item = u32;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.current_block == 0 {
+            if self.current_block_index + 1 >= self.blocks.len() {
+                return None;
+            }
+            self.current_block_index += 1;
+            self.current_block = self.blocks[self.current_block_index];
+        }
+        let lowest_bit_set = self.current_block.trailing_zeros();
+        // reset the lowest set bit, without a data dependency on `lowest_bit_set`
+        self.current_block &= self.current_block.wrapping_sub(1);
+        // SAFETY: `lowest_bit_set` cannot be more than 64, `current_block_index` cannot be more
+        // than `B - 1`, and we check above that `B * 64 < u32::MAX`. So both `64 *
+        // current_block_index` and the final value here must fit in u32.
+        #[allow(clippy::cast_possible_truncation)]
+        Some(lowest_bit_set + (64 * self.current_block_index) as u32)
+    }
+}
+
+impl<const B: usize> std::iter::FusedIterator for BitSetIterator<'_, B> {}
+
+#[cfg(test)]
+mod tests {
+    use super::BitSet;
+
+    fn assert_bitset<const B: usize>(bitset: &BitSet<B>, contents: &[u32]) {
+        assert_eq!(bitset.iter().collect::<Vec<_>>(), contents);
+    }
+
+    #[test]
+    fn iter() {
+        let mut b = BitSet::<1>::with(3);
+        b.insert(27);
+        b.insert(6);
+        assert!(matches!(b, BitSet::Inline(_)));
+        assert_bitset(&b, &[3, 6, 27]);
+    }
+
+    #[test]
+    fn iter_overflow() {
+        let mut b = BitSet::<1>::with(140);
+        b.insert(100);
+        b.insert(129);
+        assert!(matches!(b, BitSet::Heap(_)));
+        assert_bitset(&b, &[100, 129, 140]);
+    }
+
+    #[test]
+    fn intersect() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(23);
+        b2.insert(5);
+
+        b1.intersect(&b2);
+        assert_bitset(&b1, &[4]);
+    }
+
+    #[test]
+    fn intersect_mixed_1() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(89);
+        b2.insert(5);
+
+        b1.intersect(&b2);
+        assert_bitset(&b1, &[4]);
+    }
+
+    #[test]
+    fn intersect_mixed_2() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(23);
+        b2.insert(89);
+
+        b1.intersect(&b2);
+        assert_bitset(&b1, &[4]);
+    }
+
+    #[test]
+    fn intersect_heap() {
+        let mut b1 = BitSet::<1>::with(4);
+        let mut b2 = BitSet::<1>::with(4);
+        b1.insert(89);
+        b2.insert(90);
+
+        b1.intersect(&b2);
+        assert_bitset(&b1, &[4]);
+    }
+
+    #[test]
+    fn intersect_heap_2() {
+        let mut b1 = BitSet::<1>::with(89);
+        let mut b2 = BitSet::<1>::with(89);
+        b1.insert(91);
+        b2.insert(90);
+
+        b1.intersect(&b2);
+        assert_bitset(&b1, &[89]);
+    }
+
+    #[test]
+    fn multiple_blocks() {
+        let mut b = BitSet::<2>::with(120);
+        b.insert(45);
+        assert!(matches!(b, BitSet::Inline(_)));
+        assert_bitset(&b, &[45, 120]);
+    }
+}
--- 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
@@ -0,0 +1,374 @@
+//! 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 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
+//! if x is not None:
+//!     if flag2:
+//!         x = 2 if flag else None
+//!     x
+//! ```
+//!
+//! The `x is not None` constraint dominates the final use of `x`, but it applies only to the first
+//! definition of `x`, not the second, so `None` is a possible value for `x`.
+//!
+//! 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
+//! if flag1:
+//!     x = 1 if flag2 else None
+//!     assert x is not None
+//! x
+//! ```
+//!
+//! From the point of view of the final use of `x`, the `x is not None` constraint no longer
+//! dominates, but it does dominate the `x = 1 if flag2 else None` definition, so we have to keep
+//! track of that.
+//!
+//! The data structures used here ([`BitSet`] and [`smallvec::SmallVec`]) optimize for keeping all
+//! data inline (avoiding lots of scattered allocations) in small-to-medium cases, and falling back
+//! to heap allocation to be able to scale to arbitrary numbers of definitions and constraints when
+//! needed.
+use super::bitset::{BitSet, BitSetIterator};
+use ruff_index::newtype_index;
+use smallvec::SmallVec;
+
+/// A newtype-index for a definition in a particular scope.
+#[newtype_index]
+pub(super) struct ScopedDefinitionId;
+
+/// A newtype-index for a constraint expression in a particular scope.
+#[newtype_index]
+pub(super) struct ScopedConstraintId;
+
+/// Can reference this * 64 total definitions inline; more will fall back to the heap.
+const INLINE_DEFINITION_BLOCKS: usize = 3;
+
+/// A [`BitSet`] of [`ScopedDefinitionId`], representing visible definitions of a symbol in a scope.
+type Definitions = BitSet<INLINE_DEFINITION_BLOCKS>;
+type DefinitionsIterator<'a> = BitSetIterator<'a, INLINE_DEFINITION_BLOCKS>;
+
+/// Can reference this * 64 total constraints inline; more will fall back to the heap.
+const INLINE_CONSTRAINT_BLOCKS: usize = 2;
+
+/// Can keep inline this many visible definitions per symbol at a given time; more will go to heap.
+const INLINE_VISIBLE_DEFINITIONS_PER_SYMBOL: usize = 4;
+
+/// 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>;
+
+/// Visible definitions and narrowing constraints for a single symbol at some point in control flow.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) struct SymbolState {
+    /// [`BitSet`]: which [`ScopedDefinitionId`] are visible for this symbol?
+    visible_definitions: Definitions,
+
+    /// For each definition, which [`ScopedConstraintId`] apply?
+    ///
+    /// This is a [`smallvec::SmallVec`] which should always have one [`BitSet`] of constraints per
+    /// definition in `visible_definitions`.
+    constraints: Constraints,
+
+    /// Could the symbol be unbound at this point?
+    may_be_unbound: bool,
+}
+
+/// A single [`ScopedDefinitionId`] with an iterator of its applicable [`ScopedConstraintId`].
+#[derive(Debug)]
+pub(super) struct DefinitionIdWithConstraints<'a> {
+    pub(super) definition: ScopedDefinitionId,
+    pub(super) constraint_ids: ConstraintIdIterator<'a>,
+}
+
+impl SymbolState {
+    /// Return a new [`SymbolState`] representing an unbound symbol.
+    pub(super) fn unbound() -> Self {
+        Self {
+            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.
+    pub(super) fn add_unbound(&mut self) {
+        self.may_be_unbound = true;
+    }
+
+    /// Add given constraint to all currently-visible definitions.
+    pub(super) fn add_constraint(&mut self, constraint_id: ScopedConstraintId) {
+        for bitset in &mut self.constraints {
+            bitset.insert(constraint_id.into());
+        }
+    }
+
+    /// Merge another [`SymbolState`] into this one.
+    pub(super) fn merge(&mut self, b: SymbolState) {
+        let mut a = Self {
+            visible_definitions: Definitions::default(),
+            constraints: Constraints::default(),
+            may_be_unbound: self.may_be_unbound || b.may_be_unbound,
+        };
+        std::mem::swap(&mut a, self);
+        let mut a_defs_iter = a.visible_definitions.iter();
+        let mut b_defs_iter = b.visible_definitions.iter();
+        let mut a_constraints_iter = a.constraints.into_iter();
+        let mut b_constraints_iter = b.constraints.into_iter();
+
+        let mut opt_a_def: Option<u32> = a_defs_iter.next();
+        let mut opt_b_def: Option<u32> = b_defs_iter.next();
+
+        // Iterate through the definitions from `a` and `b`, always processing the lower definition
+        // ID first, and pushing each definition onto the merged `SymbolState` with its
+        // constraints. If a definition is found in both `a` and `b`, push it with the intersection
+        // of the constraints from the two paths; a constraint that applies from only one possible
+        // path is irrelevant.
+
+        // Helper to push `def`, with constraints in `constraints_iter`, onto `self`.
+        let push = |def, constraints_iter: &mut ConstraintsIntoIterator, merged: &mut Self| {
+            merged.visible_definitions.insert(def);
+            // 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
+            // below), so the number of definitions and the number of constraint bitsets can never
+            // get out of sync.
+            let constraints = constraints_iter
+                .next()
+                .expect("definitions and constraints length mismatch");
+            merged.constraints.push(constraints);
+        };
+
+        loop {
+            match (opt_a_def, opt_b_def) {
+                (Some(a_def), Some(b_def)) => match a_def.cmp(&b_def) {
+                    std::cmp::Ordering::Less => {
+                        // Next definition ID is only in `a`, push it to `self` and advance `a`.
+                        push(a_def, &mut a_constraints_iter, self);
+                        opt_a_def = a_defs_iter.next();
+                    }
+                    std::cmp::Ordering::Greater => {
+                        // Next definition ID is only in `b`, push it to `self` and advance `b`.
+                        push(b_def, &mut b_constraints_iter, self);
+                        opt_b_def = b_defs_iter.next();
+                    }
+                    std::cmp::Ordering::Equal => {
+                        // Next definition is in both; push to `self` and intersect constraints.
+                        push(a_def, &mut b_constraints_iter, self);
+                        // 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 below), so the number of definitions
+                        // and the number of constraint bitsets can never get out of sync.
+                        let a_constraints = a_constraints_iter
+                            .next()
+                            .expect("definitions and constraints length mismatch");
+                        // If the same definition is visible through both paths, any constraint
+                        // that applies on only one path is irrelevant to the resulting type from
+                        // unioning the two paths, so we intersect the constraints.
+                        self.constraints
+                            .last_mut()
+                            .unwrap()
+                            .intersect(&a_constraints);
+                        opt_a_def = a_defs_iter.next();
+                        opt_b_def = b_defs_iter.next();
+                    }
+                },
+                (Some(a_def), None) => {
+                    // We've exhausted `b`, just push the def from `a` and move on to the next.
+                    push(a_def, &mut a_constraints_iter, self);
+                    opt_a_def = a_defs_iter.next();
+                }
+                (None, Some(b_def)) => {
+                    // We've exhausted `a`, just push the def from `b` and move on to the next.
+                    push(b_def, &mut b_constraints_iter, self);
+                    opt_b_def = b_defs_iter.next();
+                }
+                (None, None) => break,
+            }
+        }
+    }
+
+    /// 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.may_be_unbound
+    }
+}
+
+/// The default state of a symbol (if we've seen no definitions of it) is unbound.
+impl Default for SymbolState {
+    fn default() -> Self {
+        SymbolState::unbound()
+    }
+}
+
+#[derive(Debug)]
+pub(super) struct DefinitionIdWithConstraintsIterator<'a> {
+    definitions: DefinitionsIterator<'a>,
+    constraints: ConstraintsIterator<'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(DefinitionIdWithConstraints {
+                definition: ScopedDefinitionId::from_u32(def),
+                constraint_ids: ConstraintIdIterator {
+                    wrapped: constraints.iter(),
+                },
+            }),
+            // SAFETY: see above.
+            _ => unreachable!("definitions and constraints length mismatch"),
+        }
+    }
+}
+
+impl std::iter::FusedIterator for DefinitionIdWithConstraintsIterator<'_> {}
+
+#[derive(Debug)]
+pub(super) struct ConstraintIdIterator<'a> {
+    wrapped: BitSetIterator<'a, INLINE_CONSTRAINT_BLOCKS>,
+}
+
+impl Iterator for ConstraintIdIterator<'_> {
+    type Item = ScopedConstraintId;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.wrapped.next().map(ScopedConstraintId::from_u32)
+    }
+}
+
+impl std::iter::FusedIterator for ConstraintIdIterator<'_> {}
+
+#[cfg(test)]
+mod tests {
+    use super::{ScopedConstraintId, ScopedDefinitionId, SymbolState};
+
+    impl SymbolState {
+        pub(crate) fn assert(&self, may_be_unbound: bool, expected: &[&str]) {
+            assert_eq!(self.may_be_unbound(), may_be_unbound);
+            let actual = self
+                .visible_definitions()
+                .map(|def_id_with_constraints| {
+                    format!(
+                        "{}<{}>",
+                        def_id_with_constraints.definition.as_u32(),
+                        def_id_with_constraints
+                            .constraint_ids
+                            .map(ScopedConstraintId::as_u32)
+                            .map(|idx| idx.to_string())
+                            .collect::<Vec<_>>()
+                            .join(", ")
+                    )
+                })
+                .collect::<Vec<_>>();
+            assert_eq!(actual, expected);
+        }
+    }
+
+    #[test]
+    fn unbound() {
+        let cd = SymbolState::unbound();
+
+        cd.assert(true, &[]);
+    }
+
+    #[test]
+    fn with() {
+        let cd = SymbolState::with(ScopedDefinitionId::from_u32(0));
+
+        cd.assert(false, &["0<>"]);
+    }
+
+    #[test]
+    fn add_unbound() {
+        let mut cd = SymbolState::with(ScopedDefinitionId::from_u32(0));
+        cd.add_unbound();
+
+        cd.assert(true, &["0<>"]);
+    }
+
+    #[test]
+    fn add_constraint() {
+        let mut cd = SymbolState::with(ScopedDefinitionId::from_u32(0));
+        cd.add_constraint(ScopedConstraintId::from_u32(0));
+
+        cd.assert(false, &["0<0>"]);
+    }
+
+    #[test]
+    fn merge() {
+        // merging the same definition with the same constraint keeps the constraint
+        let mut cd0a = SymbolState::with(ScopedDefinitionId::from_u32(0));
+        cd0a.add_constraint(ScopedConstraintId::from_u32(0));
+
+        let mut cd0b = SymbolState::with(ScopedDefinitionId::from_u32(0));
+        cd0b.add_constraint(ScopedConstraintId::from_u32(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 cd1a = SymbolState::with(ScopedDefinitionId::from_u32(1));
+        cd1a.add_constraint(ScopedConstraintId::from_u32(1));
+
+        let mut cd1b = SymbolState::with(ScopedDefinitionId::from_u32(1));
+        cd1b.add_constraint(ScopedConstraintId::from_u32(2));
+
+        cd1a.merge(cd1b);
+        let cd1 = cd1a;
+        cd1.assert(false, &["1<>"]);
+
+        // merging a constrained definition with unbound keeps both
+        let mut cd2a = SymbolState::with(ScopedDefinitionId::from_u32(2));
+        cd2a.add_constraint(ScopedConstraintId::from_u32(3));
+
+        let cd2b = SymbolState::unbound();
+
+        cd2a.merge(cd2b);
+        let cd2 = cd2a;
+        cd2.assert(true, &["2<3>"]);
+
+        // merging different definitions keeps them each with their existing constraints
+        cd0.merge(cd2);
+        let cd = cd0;
+        cd.assert(true, &["0<0>", "2<3>"]);
+    }
+}
--- a/crates/red_knot_python_semantic/src/semantic_model.rs
+++ b/crates/red_knot_python_semantic/src/semantic_model.rs
@@ -1,7 +1,7 @@
 use ruff_db::files::{File, FilePath};
 use ruff_db::source::line_index;
 use ruff_python_ast as ast;
-use ruff_python_ast::{Expr, ExpressionRef, StmtClassDef};
+use ruff_python_ast::{Expr, ExpressionRef};
 use ruff_source_file::LineIndex;

 use crate::module_name::ModuleName;
@@ -147,29 +147,24 @@ impl HasTy for ast::Expr {
    }
 }

-impl HasTy for ast::StmtFunctionDef {
-    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
-        let index = semantic_index(model.db, model.file);
-        let definition = index.definition(self);
-        definition_ty(model.db, definition)
-    }
+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 definition = index.definition(self);
+                definition_ty(model.db, definition)
+            }
+        }
+    };
 }

-impl HasTy for StmtClassDef {
-    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
-        let index = semantic_index(model.db, model.file);
-        let definition = index.definition(self);
-        definition_ty(model.db, definition)
-    }
-}
-
-impl HasTy for ast::Alias {
-    fn ty<'db>(&self, model: &SemanticModel<'db>) -> Type<'db> {
-        let index = semantic_index(model.db, model.file);
-        let definition = index.definition(self);
-        definition_ty(model.db, definition)
-    }
-}
+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/types.rs
+++ b/crates/red_knot_python_semantic/src/types.rs
@@ -4,15 +4,22 @@ use ruff_python_ast::name::Name;
 use crate::builtins::builtins_scope;
 use crate::semantic_index::definition::Definition;
 use crate::semantic_index::symbol::{ScopeId, ScopedSymbolId};
-use crate::semantic_index::{global_scope, symbol_table, use_def_map};
+use crate::semantic_index::{
+    global_scope, symbol_table, use_def_map, DefinitionWithConstraints,
+    DefinitionWithConstraintsIterator,
+};
+use crate::types::narrow::narrowing_constraint;
 use crate::{Db, FxOrderSet};

 mod builder;
 mod display;
 mod infer;
+mod narrow;

-pub(crate) use self::builder::UnionBuilder;
-pub(crate) use self::infer::{infer_definition_types, infer_scope_types};
+pub(crate) use self::builder::{IntersectionBuilder, UnionBuilder};
+pub(crate) use self::infer::{
+    infer_definition_types, infer_expression_types, infer_scope_types, TypeInference,
+};

 /// Infer the public type of a symbol (its type as seen from outside its scope).
 pub(crate) fn symbol_ty<'db>(
@@ -82,10 +89,31 @@ pub(crate) fn definition_ty<'db>(db: &'db dyn Db, definition: Definition<'db>) -
 /// provide an `unbound_ty`.
 pub(crate) fn definitions_ty<'db>(
    db: &'db dyn Db,
-    definitions: &[Definition<'db>],
+    definitions_with_constraints: DefinitionWithConstraintsIterator<'_, 'db>,
    unbound_ty: Option<Type<'db>>,
 ) -> Type<'db> {
-    let def_types = definitions.iter().map(|def| definition_ty(db, *def));
+    let def_types = definitions_with_constraints.map(
+        |DefinitionWithConstraints {
+             definition,
+             constraints,
+         }| {
+            let mut constraint_tys =
+                constraints.filter_map(|test| narrowing_constraint(db, test, definition));
+            let definition_ty = definition_ty(db, definition);
+            if let Some(first_constraint_ty) = constraint_tys.next() {
+                let mut builder = IntersectionBuilder::new(db);
+                builder = builder
+                    .add_positive(definition_ty)
+                    .add_positive(first_constraint_ty);
+                for constraint_ty in constraint_tys {
+                    builder = builder.add_positive(constraint_ty);
+                }
+                builder.build()
+            } else {
+                definition_ty
+            }
+        },
+    );
    let mut all_types = unbound_ty.into_iter().chain(def_types);

    let Some(first) = all_types.next() else {
--- a/crates/red_knot_python_semantic/src/types/builder.rs
+++ b/crates/red_knot_python_semantic/src/types/builder.rs
@@ -65,7 +65,6 @@ impl<'db> UnionBuilder<'db> {
    }
 }

-#[allow(unused)]
 #[derive(Clone)]
 pub(crate) struct IntersectionBuilder<'db> {
    // Really this builds a union-of-intersections, because we always keep our set-theoretic types
@@ -78,8 +77,7 @@ pub(crate) struct IntersectionBuilder<'db> {
 }

 impl<'db> IntersectionBuilder<'db> {
-    #[allow(dead_code)]
-    fn new(db: &'db dyn Db) -> Self {
+    pub(crate) fn new(db: &'db dyn Db) -> Self {
        Self {
            db,
            intersections: vec![InnerIntersectionBuilder::new()],
@@ -93,8 +91,7 @@ impl<'db> IntersectionBuilder<'db> {
        }
    }

-    #[allow(dead_code)]
-    fn add_positive(mut self, ty: Type<'db>) -> Self {
+    pub(crate) fn add_positive(mut self, ty: Type<'db>) -> Self {
        if let Type::Union(union) = ty {
            // Distribute ourself over this union: for each union element, clone ourself and
            // intersect with that union element, then create a new union-of-intersections with all
@@ -122,8 +119,7 @@ impl<'db> IntersectionBuilder<'db> {
        }
    }

-    #[allow(dead_code)]
-    fn add_negative(mut self, ty: Type<'db>) -> Self {
+    pub(crate) fn add_negative(mut self, ty: Type<'db>) -> Self {
        // See comments above in `add_positive`; this is just the negated version.
        if let Type::Union(union) = ty {
            union
@@ -142,8 +138,7 @@ impl<'db> IntersectionBuilder<'db> {
        }
    }

-    #[allow(dead_code)]
-    fn build(mut self) -> Type<'db> {
+    pub(crate) fn build(mut self) -> Type<'db> {
        // Avoid allocating the UnionBuilder unnecessarily if we have just one intersection:
        if self.intersections.len() == 1 {
            self.intersections.pop().unwrap().build(self.db)
@@ -157,7 +152,6 @@ impl<'db> IntersectionBuilder<'db> {
    }
 }

-#[allow(unused)]
 #[derive(Debug, Clone, Default)]
 struct InnerIntersectionBuilder<'db> {
    positive: FxOrderSet<Type<'db>>,
@@ -223,6 +217,16 @@ impl<'db> InnerIntersectionBuilder<'db> {
            self.positive.retain(Type::is_unbound);
            self.negative.clear();
        }
+
+        // None intersects only with object
+        for pos in &self.positive {
+            if let Type::Instance(_) = pos {
+                // could be `object` type
+            } else {
+                self.negative.remove(&Type::None);
+                break;
+            }
+        }
    }

    fn build(mut self, db: &'db dyn Db) -> Type<'db> {
@@ -453,4 +457,15 @@ mod tests {

        assert_eq!(ty, Type::IntLiteral(1));
    }
+
+    #[test]
+    fn build_intersection_simplify_negative_none() {
+        let db = setup_db();
+        let ty = IntersectionBuilder::new(&db)
+            .add_negative(Type::None)
+            .add_positive(Type::IntLiteral(1))
+            .build();
+
+        assert_eq!(ty, Type::IntLiteral(1));
+    }
 }
--- a/crates/red_knot_python_semantic/src/types/infer.rs
+++ b/crates/red_knot_python_semantic/src/types/infer.rs
@@ -29,7 +29,7 @@ use salsa::plumbing::AsId;
 use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
 use ruff_python_ast as ast;
-use ruff_python_ast::{ExprContext, TypeParams};
+use ruff_python_ast::{Expr, ExprContext};

 use crate::builtins::builtins_scope;
 use crate::module_name::ModuleName;
@@ -294,11 +294,18 @@ impl<'db> TypeInferenceBuilder<'db> {
                );
            }
            DefinitionKind::Assignment(assignment) => {
-                self.infer_assignment_definition(assignment.assignment(), definition);
+                self.infer_assignment_definition(
+                    assignment.target(),
+                    assignment.assignment(),
+                    definition,
+                );
            }
            DefinitionKind::AnnotatedAssignment(annotated_assignment) => {
                self.infer_annotated_assignment_definition(annotated_assignment.node(), definition);
            }
+            DefinitionKind::AugmentedAssignment(augmented_assignment) => {
+                self.infer_augment_assignment_definition(augmented_assignment.node(), definition);
+            }
            DefinitionKind::NamedExpression(named_expression) => {
                self.infer_named_expression_definition(named_expression.node(), definition);
            }
@@ -319,7 +326,7 @@ impl<'db> TypeInferenceBuilder<'db> {
    }

    fn infer_region_expression(&mut self, expression: Expression<'db>) {
-        self.infer_expression(expression.node(self.db));
+        self.infer_expression(expression.node_ref(self.db));
    }

    fn infer_module(&mut self, module: &ast::ModModule) {
@@ -706,6 +713,7 @@ impl<'db> TypeInferenceBuilder<'db> {

    fn infer_assignment_definition(
        &mut self,
+        target: &ast::ExprName,
        assignment: &ast::StmtAssign,
        definition: Definition<'db>,
    ) {
@@ -715,6 +723,9 @@ impl<'db> TypeInferenceBuilder<'db> {
        let value_ty = self
            .types
            .expression_ty(assignment.value.scoped_ast_id(self.db, self.scope));
+        self.types
+            .expressions
+            .insert(target.scoped_ast_id(self.db, self.scope), value_ty);
        self.types.definitions.insert(definition, value_ty);
    }

@@ -755,15 +766,35 @@ impl<'db> TypeInferenceBuilder<'db> {
    }

    fn infer_augmented_assignment_statement(&mut self, assignment: &ast::StmtAugAssign) {
-        // TODO this should be a Definition
+        if assignment.target.is_name_expr() {
+            self.infer_definition(assignment);
+        } else {
+            // TODO currently we don't consider assignments to non-Names to be Definitions
+            self.infer_augment_assignment(assignment);
+        }
+    }
+
+    fn infer_augment_assignment_definition(
+        &mut self,
+        assignment: &ast::StmtAugAssign,
+        definition: Definition<'db>,
+    ) {
+        let target_ty = self.infer_augment_assignment(assignment);
+        self.types.definitions.insert(definition, target_ty);
+    }
+
+    fn infer_augment_assignment(&mut self, assignment: &ast::StmtAugAssign) -> Type<'db> {
        let ast::StmtAugAssign {
            range: _,
            target,
            op: _,
            value,
        } = assignment;
-        self.infer_expression(target);
        self.infer_expression(value);
+        self.infer_expression(target);
+
+        // TODO(dhruvmanila): Resolve the target type using the value type and the operator
+        Type::Unknown
    }

    fn infer_type_alias_statement(&mut self, type_alias_statement: &ast::StmtTypeAlias) {
@@ -999,6 +1030,9 @@ impl<'db> TypeInferenceBuilder<'db> {
            ast::Expr::NumberLiteral(literal) => self.infer_number_literal_expression(literal),
            ast::Expr::BooleanLiteral(literal) => self.infer_boolean_literal_expression(literal),
            ast::Expr::StringLiteral(literal) => self.infer_string_literal_expression(literal),
+            ast::Expr::BytesLiteral(bytes_literal) => {
+                self.infer_bytes_literal_expression(bytes_literal)
+            }
            ast::Expr::FString(fstring) => self.infer_fstring_expression(fstring),
            ast::Expr::EllipsisLiteral(literal) => self.infer_ellipsis_literal_expression(literal),
            ast::Expr::Tuple(tuple) => self.infer_tuple_expression(tuple),
@@ -1025,8 +1059,7 @@ impl<'db> TypeInferenceBuilder<'db> {
            ast::Expr::Yield(yield_expression) => self.infer_yield_expression(yield_expression),
            ast::Expr::YieldFrom(yield_from) => self.infer_yield_from_expression(yield_from),
            ast::Expr::Await(await_expression) => self.infer_await_expression(await_expression),
-
-            _ => todo!("expression type resolution for {:?}", expression),
+            Expr::IpyEscapeCommand(_) => todo!("Implement Ipy escape command support"),
        };

        let expr_id = expression.scoped_ast_id(self.db, self.scope);
@@ -1063,6 +1096,12 @@ impl<'db> TypeInferenceBuilder<'db> {
        Type::Unknown
    }

+    #[allow(clippy::unused_self)]
+    fn infer_bytes_literal_expression(&mut self, _literal: &ast::ExprBytesLiteral) -> Type<'db> {
+        // TODO
+        Type::Unknown
+    }
+
    fn infer_fstring_expression(&mut self, fstring: &ast::ExprFString) -> Type<'db> {
        let ast::ExprFString { range: _, value } = fstring;

@@ -1630,7 +1669,7 @@ impl<'db> TypeInferenceBuilder<'db> {
        Type::Unknown
    }

-    fn infer_type_parameters(&mut self, type_parameters: &TypeParams) {
+    fn infer_type_parameters(&mut self, type_parameters: &ast::TypeParams) {
        let ast::TypeParams {
            range: _,
            type_params,
@@ -1677,6 +1716,7 @@ impl<'db> TypeInferenceBuilder<'db> {
 #[cfg(test)]
 mod tests {
    use anyhow::Context;
+
    use ruff_db::files::{system_path_to_file, File};
    use ruff_db::parsed::parsed_module;
    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
@@ -2587,6 +2627,26 @@ mod tests {
        Ok(())
    }

+    #[test]
+    fn narrow_not_none() -> anyhow::Result<()> {
+        let mut db = setup_db();
+
+        db.write_dedented(
+            "/src/a.py",
+            "
+            x = None if flag else 1
+            y = 0
+            if x is not None:
+                y = x
+            ",
+        )?;
+
+        assert_public_ty(&db, "/src/a.py", "x", "Literal[1] | None");
+        assert_public_ty(&db, "/src/a.py", "y", "Literal[0, 1]");
+
+        Ok(())
+    }
+
    #[test]
    fn while_loop() -> anyhow::Result<()> {
        let mut db = setup_db();
@@ -2684,10 +2744,11 @@ mod tests {

    fn first_public_def<'db>(db: &'db TestDb, file: File, name: &str) -> Definition<'db> {
        let scope = global_scope(db, file);
-        *use_def_map(db, scope)
+        use_def_map(db, scope)
            .public_definitions(symbol_table(db, scope).symbol_id_by_name(name).unwrap())
-            .first()
+            .next()
            .unwrap()
+            .definition
    }

    #[test]
--- a/crates/red_knot_python_semantic/src/types/narrow.rs
+++ b/crates/red_knot_python_semantic/src/types/narrow.rs
@@ -0,0 +1,115 @@
+use crate::semantic_index::ast_ids::HasScopedAstId;
+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, TypeInference};
+use crate::Db;
+use ruff_python_ast as ast;
+use rustc_hash::FxHashMap;
+use std::sync::Arc;
+
+/// Return the type constraint that `test` (if true) would place on `definition`, if any.
+///
+/// For example, if we have this code:
+///
+/// ```python
+/// y = 1 if flag else None
+/// x = 1 if flag else None
+/// if x is not None:
+///     ...
+/// ```
+///
+/// The `test` expression `x is not None` places the constraint "not None" on the definition of
+/// `x`, so in that case we'd return `Some(Type::Intersection(negative=[Type::None]))`.
+///
+/// But if we called this with the same `test` expression, but the `definition` of `y`, no
+/// constraint is applied to that definition, so we'd just return `None`.
+pub(crate) fn narrowing_constraint<'db>(
+    db: &'db dyn Db,
+    test: Expression<'db>,
+    definition: Definition<'db>,
+) -> Option<Type<'db>> {
+    all_narrowing_constraints(db, test)
+        .get(&definition.symbol(db))
+        .copied()
+}
+
+#[salsa::tracked(return_ref)]
+fn all_narrowing_constraints<'db>(
+    db: &'db dyn Db,
+    test: Expression<'db>,
+) -> NarrowingConstraints<'db> {
+    NarrowingConstraintsBuilder::new(db, test).finish()
+}
+
+type NarrowingConstraints<'db> = FxHashMap<ScopedSymbolId, Type<'db>>;
+
+struct NarrowingConstraintsBuilder<'db> {
+    db: &'db dyn Db,
+    expression: Expression<'db>,
+    constraints: NarrowingConstraints<'db>,
+}
+
+impl<'db> NarrowingConstraintsBuilder<'db> {
+    fn new(db: &'db dyn Db, expression: Expression<'db>) -> Self {
+        Self {
+            db,
+            expression,
+            constraints: NarrowingConstraints::default(),
+        }
+    }
+
+    fn finish(mut self) -> NarrowingConstraints<'db> {
+        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 symbols(&self) -> Arc<SymbolTable> {
+        symbol_table(self.db, self.scope())
+    }
+
+    fn scope(&self) -> ScopeId<'db> {
+        self.expression.scope(self.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,
+            ops,
+            comparators,
+        } = expr_compare;
+
+        if let ast::Expr::Name(ast::ExprName {
+            range: _,
+            id,
+            ctx: _,
+        }) = left.as_ref()
+        {
+            // 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 = 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) {
+                    let ty = IntersectionBuilder::new(self.db)
+                        .add_negative(comp_ty)
+                        .build();
+                    self.constraints.insert(symbol, ty);
+                };
+                // TODO other comparison types
+            }
+        }
+    }
+}
--- a/crates/red_knot_workspace/Cargo.toml
+++ b/crates/red_knot_workspace/Cargo.toml
@@ -28,6 +28,7 @@ thiserror = { workspace = true }
 tracing = { workspace = true }

 [dev-dependencies]
+ruff_db = { workspace = true, features = ["testing"]}

 [lints]
 workspace = true
--- a/crates/red_knot_workspace/tests/check.rs
+++ b/crates/red_knot_workspace/tests/check.rs
@@ -1,9 +1,14 @@
-use red_knot_python_semantic::{ProgramSettings, PythonVersion, SearchPathSettings};
+use red_knot_python_semantic::{
+    HasTy, ProgramSettings, PythonVersion, SearchPathSettings, SemanticModel,
+};
 use red_knot_workspace::db::RootDatabase;
-use red_knot_workspace::lint::lint_semantic;
 use red_knot_workspace::workspace::WorkspaceMetadata;
-use ruff_db::files::system_path_to_file;
-use ruff_db::system::{OsSystem, SystemPathBuf};
+use ruff_db::files::{system_path_to_file, File};
+use ruff_db::parsed::parsed_module;
+use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
+use ruff_python_ast::visitor::source_order;
+use ruff_python_ast::visitor::source_order::SourceOrderVisitor;
+use ruff_python_ast::{Alias, Expr, Parameter, ParameterWithDefault, Stmt};
 use std::fs;
 use std::path::PathBuf;

@@ -28,17 +33,100 @@ fn setup_db(workspace_root: SystemPathBuf) -> anyhow::Result<RootDatabase> {
 #[allow(clippy::print_stdout)]
 fn corpus_no_panic() -> anyhow::Result<()> {
    let corpus = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("resources/test/corpus");
-    let system_corpus =
-        SystemPathBuf::from_path_buf(corpus.clone()).expect("corpus path to be UTF8");
-    let db = setup_db(system_corpus.clone())?;
+    let system_corpus = SystemPath::from_std_path(&corpus).expect("corpus path to be UTF8");
+    let db = setup_db(system_corpus.to_path_buf())?;

    for path in fs::read_dir(&corpus).expect("corpus to be a directory") {
        let path = path.expect("path to not be an error").path();
        println!("checking {path:?}");
        let path = SystemPathBuf::from_path_buf(path.clone()).expect("path to be UTF-8");
-        // this test is only asserting that we can run the lint without a panic
+        // this test is only asserting that we can pull every expression type without a panic
+        // (and some non-expressions that clearly define a single type)
        let file = system_path_to_file(&db, path).expect("file to exist");
-        lint_semantic(&db, file);
+
+        pull_types(&db, file);
    }
    Ok(())
 }
+
+fn pull_types(db: &RootDatabase, file: File) {
+    let mut visitor = PullTypesVisitor::new(db, file);
+
+    let ast = parsed_module(db, file);
+
+    visitor.visit_body(ast.suite());
+}
+
+struct PullTypesVisitor<'db> {
+    model: SemanticModel<'db>,
+}
+
+impl<'db> PullTypesVisitor<'db> {
+    fn new(db: &'db RootDatabase, file: File) -> Self {
+        Self {
+            model: SemanticModel::new(db, file),
+        }
+    }
+}
+
+impl SourceOrderVisitor<'_> for PullTypesVisitor<'_> {
+    fn visit_stmt(&mut self, stmt: &Stmt) {
+        match stmt {
+            Stmt::FunctionDef(function) => {
+                let _ty = function.ty(&self.model);
+            }
+            Stmt::ClassDef(class) => {
+                let _ty = class.ty(&self.model);
+            }
+            Stmt::AnnAssign(_)
+            | Stmt::Return(_)
+            | Stmt::Delete(_)
+            | Stmt::Assign(_)
+            | Stmt::AugAssign(_)
+            | Stmt::TypeAlias(_)
+            | Stmt::For(_)
+            | Stmt::While(_)
+            | Stmt::If(_)
+            | Stmt::With(_)
+            | Stmt::Match(_)
+            | Stmt::Raise(_)
+            | Stmt::Try(_)
+            | Stmt::Assert(_)
+            | Stmt::Import(_)
+            | Stmt::ImportFrom(_)
+            | Stmt::Global(_)
+            | Stmt::Nonlocal(_)
+            | Stmt::Expr(_)
+            | Stmt::Pass(_)
+            | Stmt::Break(_)
+            | Stmt::Continue(_)
+            | Stmt::IpyEscapeCommand(_) => {}
+        }
+
+        source_order::walk_stmt(self, stmt);
+    }
+
+    fn visit_expr(&mut self, expr: &Expr) {
+        let _ty = expr.ty(&self.model);
+
+        source_order::walk_expr(self, expr);
+    }
+
+    fn visit_parameter(&mut self, parameter: &Parameter) {
+        let _ty = parameter.ty(&self.model);
+
+        source_order::walk_parameter(self, parameter);
+    }
+
+    fn visit_parameter_with_default(&mut self, parameter_with_default: &ParameterWithDefault) {
+        let _ty = parameter_with_default.ty(&self.model);
+
+        source_order::walk_parameter_with_default(self, parameter_with_default);
+    }
+
+    fn visit_alias(&mut self, alias: &Alias) {
+        let _ty = alias.ty(&self.model);
+
+        source_order::walk_alias(self, alias);
+    }
+}
--- a/crates/ruff/tests/lint.rs
+++ b/crates/ruff/tests/lint.rs
@@ -1434,7 +1434,7 @@ def unused(x):

    insta::assert_snapshot!(test_code, @r###"

-    def unused(x):  # noqa: ANN001, ANN201, ARG001, D103
+    def unused(x):  # noqa: ANN001, ANN201, D103
        pass
    "###);

--- a/crates/ruff_linter/resources/test/fixtures/flake8_bugbear/B015.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_bugbear/B015.py
@@ -17,6 +17,11 @@ def test():
    1 in (1, 2)


+def test2():
+    1 in (1, 2)
+    return
+
+
 data = [x for x in [1, 2, 3] if x in (1, 2)]


--- a/crates/ruff_linter/resources/test/fixtures/pep8_naming/N817.py
+++ b/crates/ruff_linter/resources/test/fixtures/pep8_naming/N817.py
@@ -4,3 +4,7 @@ from mod import CamelCase as CC

 # OK depending on configured import convention
 import xml.etree.ElementTree as ET
+from xml.etree import ElementTree as ET
+
+# Always an error (relative import)
+from ..xml.eltree import ElementTree as ET
--- a/crates/ruff_linter/resources/test/fixtures/pylint/bad_staticmethod_argument.py
+++ b/crates/ruff_linter/resources/test/fixtures/pylint/bad_staticmethod_argument.py
@@ -42,3 +42,9 @@ class Foo:
    @classmethod
    def graze(cls, x, y, z):
        pass
+
+
+class Foo:
+    @staticmethod
+    def __new__(cls, x, y, z):  # OK, see https://docs.python.org/3/reference/datamodel.html#basic-customization
+        pass
--- a/crates/ruff_linter/resources/test/fixtures/pylint/self_or_cls_assignment.py
+++ b/crates/ruff_linter/resources/test/fixtures/pylint/self_or_cls_assignment.py
@@ -3,7 +3,7 @@ class Fruit:
    def list_fruits(cls) -> None:
        cls = "apple"  # PLW0642
        cls: Fruit = "apple"  # PLW0642
-        cls += "orange"  # PLW0642
+        cls += "orange"  # OK, augmented assignments are ignored
        *cls = "banana"  # PLW0642
        cls, blah = "apple", "orange"  # PLW0642
        blah, (cls, blah2) = "apple", ("orange", "banana")  # PLW0642
@@ -16,7 +16,7 @@ class Fruit:
    def print_color(self) -> None:
        self = "red"  # PLW0642
        self: Self = "red"  # PLW0642
-        self += "blue"  # PLW0642
+        self += "blue"  # OK, augmented assignments are ignored
        *self = "blue"  # PLW0642
        self, blah = "red", "blue"  # PLW0642
        blah, (self, blah2) = "apple", ("orange", "banana")  # PLW0642
--- a/crates/ruff_linter/resources/test/fixtures/ruff/RUF027_1.py
+++ b/crates/ruff_linter/resources/test/fixtures/ruff/RUF027_1.py
@@ -59,3 +59,12 @@ def negative_cases():
    # See https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles
    import logging
    logging.info("yet {another} non-f-string")
+
+    # See https://fastapi.tiangolo.com/tutorial/path-params/
+    from fastapi import FastAPI
+    app = FastAPI()
+    item_id = 42
+
+    @app.get("/items/{item_id}")
+    async def read_item(item_id):
+        return {"item_id": item_id}
--- a/crates/ruff_linter/resources/test/fixtures/ruff/RUF029.py
+++ b/crates/ruff_linter/resources/test/fixtures/ruff/RUF029.py
@@ -78,3 +78,13 @@ async def test():
 async def test() -> str:
    vals = [str(val) for val in await async_func(1)]
    return ",".join(vals)
+
+
+from fastapi import FastAPI
+
+app = FastAPI()
+
+
+@app.post("/count")
+async def fastapi_route(): # Ok: FastApi routes can be async without actually using await
+    return 1
--- a/crates/ruff_linter/resources/test/fixtures/ruff/RUF032.py
+++ b/crates/ruff_linter/resources/test/fixtures/ruff/RUF032.py
@@ -0,0 +1,120 @@
+import decimal
+
+# Tests with fully qualified import
+decimal.Decimal(0)
+
+decimal.Decimal(0.0)  # Should error
+
+decimal.Decimal("0.0")
+
+decimal.Decimal(10)
+
+decimal.Decimal(10.0)  # Should error
+
+decimal.Decimal("10.0")
+
+decimal.Decimal(-10)
+
+decimal.Decimal(-10.0)  # Should error
+
+decimal.Decimal("-10.0")
+
+a = 10.0
+
+decimal.Decimal(a)
+
+
+# Tests with relative import
+from decimal import Decimal
+
+
+val = Decimal(0)
+
+val = Decimal(0.0)  # Should error
+
+val = Decimal("0.0")
+
+val = Decimal(10)
+
+val = Decimal(10.0)  # Should error
+
+val = Decimal("10.0")
+
+val = Decimal(-10)
+
+val = Decimal(-10.0)  # Should error
+
+val = Decimal("-10.0")
+
+a = 10.0
+
+val = Decimal(a)
+
+
+# Tests with shadowed name
+class Decimal():
+    value: float | int | str
+
+    def __init__(self, value: float | int | str) -> None:
+        self.value = value
+
+
+val = Decimal(0.0)
+
+val = Decimal("0.0")
+
+val = Decimal(10.0)
+
+val = Decimal("10.0")
+
+val = Decimal(-10.0)
+
+val = Decimal("-10.0")
+
+a = 10.0
+
+val = Decimal(a)
+
+
+# Retest with fully qualified import
+
+val = decimal.Decimal(0.0)  # Should error
+
+val = decimal.Decimal("0.0")
+
+val = decimal.Decimal(10.0)  # Should error
+
+val = decimal.Decimal("10.0")
+
+val = decimal.Decimal(-10.0)  # Should error
+
+val = decimal.Decimal("-10.0")
+
+a = 10.0
+
+val = decimal.Decimal(a)
+
+
+class decimal():
+    class Decimal():
+        value: float | int | str
+
+        def __init__(self, value: float | int | str) -> None:
+            self.value = value
+
+
+val = decimal.Decimal(0.0)
+
+val = decimal.Decimal("0.0")
+
+val = decimal.Decimal(10.0)
+
+val = decimal.Decimal("10.0")
+
+val = decimal.Decimal(-10.0)
+
+val = decimal.Decimal("-10.0")
+
+a = 10.0
+
+val = decimal.Decimal(a)
--- a/crates/ruff_linter/src/checkers/ast/analyze/expression.rs
+++ b/crates/ruff_linter/src/checkers/ast/analyze/expression.rs
@@ -1011,6 +1011,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
            if checker.enabled(Rule::UnnecessaryIterableAllocationForFirstElement) {
                ruff::rules::unnecessary_iterable_allocation_for_first_element(checker, expr);
            }
+            if checker.enabled(Rule::DecimalFromFloatLiteral) {
+                ruff::rules::decimal_from_float_literal_syntax(checker, call);
+            }
            if checker.enabled(Rule::IntOnSlicedStr) {
                refurb::rules::int_on_sliced_str(checker, call);
            }
--- a/crates/ruff_linter/src/checkers/ast/analyze/statement.rs
+++ b/crates/ruff_linter/src/checkers/ast/analyze/statement.rs
@@ -1112,9 +1112,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
            }
        }
        Stmt::AugAssign(aug_assign @ ast::StmtAugAssign { target, .. }) => {
-            if checker.enabled(Rule::SelfOrClsAssignment) {
-                pylint::rules::self_or_cls_assignment(checker, target);
-            }
            if checker.enabled(Rule::GlobalStatement) {
                if let Expr::Name(ast::ExprName { id, .. }) = target.as_ref() {
                    pylint::rules::global_statement(checker, id);
--- a/crates/ruff_linter/src/codes.rs
+++ b/crates/ruff_linter/src/codes.rs
@@ -959,6 +959,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
        (Ruff, "029") => (RuleGroup::Preview, rules::ruff::rules::UnusedAsync),
        (Ruff, "030") => (RuleGroup::Preview, rules::ruff::rules::AssertWithPrintMessage),
        (Ruff, "031") => (RuleGroup::Preview, rules::ruff::rules::IncorrectlyParenthesizedTupleInSubscript),
+        (Ruff, "032") => (RuleGroup::Preview, rules::ruff::rules::DecimalFromFloatLiteral),
        (Ruff, "100") => (RuleGroup::Stable, rules::ruff::rules::UnusedNOQA),
        (Ruff, "101") => (RuleGroup::Stable, rules::ruff::rules::RedirectedNOQA),

--- a/crates/ruff_linter/src/rules/fastapi/rules/mod.rs
+++ b/crates/ruff_linter/src/rules/fastapi/rules/mod.rs
@@ -6,12 +6,15 @@ mod fastapi_non_annotated_dependency;
 mod fastapi_redundant_response_model;
 mod fastapi_unused_path_parameter;

-use ruff_python_ast::{Decorator, ExprCall, StmtFunctionDef};
+use ruff_python_ast as ast;
 use ruff_python_semantic::analyze::typing::resolve_assignment;
 use ruff_python_semantic::SemanticModel;

 /// Returns `true` if the function is a FastAPI route.
-pub(crate) fn is_fastapi_route(function_def: &StmtFunctionDef, semantic: &SemanticModel) -> bool {
+pub(crate) fn is_fastapi_route(
+    function_def: &ast::StmtFunctionDef,
+    semantic: &SemanticModel,
+) -> bool {
    return function_def
        .decorator_list
        .iter()
@@ -20,27 +23,29 @@ pub(crate) fn is_fastapi_route(function_def: &StmtFunctionDef, semantic: &Semant

 /// Returns `true` if the decorator is indicative of a FastAPI route.
 pub(crate) fn is_fastapi_route_decorator<'a>(
-    decorator: &'a Decorator,
+    decorator: &'a ast::Decorator,
    semantic: &'a SemanticModel,
-) -> Option<&'a ExprCall> {
+) -> Option<&'a ast::ExprCall> {
    let call = decorator.expression.as_call_expr()?;
-    let decorator_method = call.func.as_attribute_expr()?;
-    let method_name = &decorator_method.attr;
+    is_fastapi_route_call(call, semantic).then_some(call)
+}
+
+pub(crate) fn is_fastapi_route_call(call_expr: &ast::ExprCall, semantic: &SemanticModel) -> bool {
+    let ast::Expr::Attribute(ast::ExprAttribute { attr, value, .. }) = &*call_expr.func else {
+        return false;
+    };

    if !matches!(
-        method_name.as_str(),
+        attr.as_str(),
        "get" | "post" | "put" | "delete" | "patch" | "options" | "head" | "trace"
    ) {
-        return None;
+        return false;
    }

-    let qualified_name = resolve_assignment(&decorator_method.value, semantic)?;
-    if matches!(
-        qualified_name.segments(),
-        ["fastapi", "FastAPI" | "APIRouter"]
-    ) {
-        Some(call)
-    } else {
-        None
-    }
+    resolve_assignment(value, semantic).is_some_and(|qualified_name| {
+        matches!(
+            qualified_name.segments(),
+            ["fastapi", "FastAPI" | "APIRouter"]
+        )
+    })
 }
--- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/useless_comparison.rs
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/useless_comparison.rs
@@ -1,6 +1,7 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::Expr;
+use ruff_python_ast::{Expr, Stmt};
+use ruff_python_semantic::ScopeKind;
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -33,24 +34,34 @@ use super::super::helpers::at_last_top_level_expression_in_cell;
 /// ## References
 /// - [Python documentation: `assert` statement](https://docs.python.org/3/reference/simple_stmts.html#the-assert-statement)
 #[violation]
-pub struct UselessComparison;
+pub struct UselessComparison {
+    at: ComparisonLocationAt,
+}

 impl Violation for UselessComparison {
    #[derive_message_formats]
    fn message(&self) -> String {
-        format!(
-            "Pointless comparison. Did you mean to assign a value? \
-             Otherwise, prepend `assert` or remove it."
-        )
+        match self.at {
+            ComparisonLocationAt::MiddleBody => format!(
+                "Pointless comparison. Did you mean to assign a value? \
+                Otherwise, prepend `assert` or remove it."
+            ),
+            ComparisonLocationAt::EndOfFunction => format!(
+                "Pointless comparison at end of function scope. Did you mean \
+                to return the expression result?"
+            ),
+        }
    }
 }

 /// B015
 pub(crate) fn useless_comparison(checker: &mut Checker, expr: &Expr) {
    if expr.is_compare_expr() {
+        let semantic = checker.semantic();
+
        if checker.source_type.is_ipynb()
            && at_last_top_level_expression_in_cell(
-                checker.semantic(),
+                semantic,
                checker.locator(),
                checker.cell_offsets(),
            )
@@ -58,8 +69,34 @@ pub(crate) fn useless_comparison(checker: &mut Checker, expr: &Expr) {
            return;
        }

-        checker
-            .diagnostics
-            .push(Diagnostic::new(UselessComparison, expr.range()));
+        if let ScopeKind::Function(func_def) = semantic.current_scope().kind {
+            if func_def
+                .body
+                .last()
+                .and_then(Stmt::as_expr_stmt)
+                .is_some_and(|last_stmt| &*last_stmt.value == expr)
+            {
+                checker.diagnostics.push(Diagnostic::new(
+                    UselessComparison {
+                        at: ComparisonLocationAt::EndOfFunction,
+                    },
+                    expr.range(),
+                ));
+                return;
+            }
+        }
+
+        checker.diagnostics.push(Diagnostic::new(
+            UselessComparison {
+                at: ComparisonLocationAt::MiddleBody,
+            },
+            expr.range(),
+        ));
    }
 }
+
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+enum ComparisonLocationAt {
+    MiddleBody,
+    EndOfFunction,
+}
--- a/crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linterrulesflake8_bugbeartestsB015_B015.py.snap
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linterrulesflake8_bugbeartestsB015_B015.py.snap
@@ -1,5 +1,6 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
+assertion_line: 74
 ---
 B015.py:3:1: B015 Pointless comparison. Did you mean to assign a value? Otherwise, prepend `assert` or remove it.
  |
@@ -19,7 +20,7 @@ B015.py:7:1: B015 Pointless comparison. Did you mean to assign a value? Otherwis
  | ^^^^^^^^^^^ B015
  |

-B015.py:17:5: B015 Pointless comparison. Did you mean to assign a value? Otherwise, prepend `assert` or remove it.
+B015.py:17:5: B015 Pointless comparison at end of function scope. Did you mean to return the expression result?
   |
 15 |     assert 1 in (1, 2)
 16 | 
@@ -27,11 +28,17 @@ B015.py:17:5: B015 Pointless comparison. Did you mean to assign a value? Otherwi
   |     ^^^^^^^^^^^ B015
   |

-B015.py:24:5: B015 Pointless comparison. Did you mean to assign a value? Otherwise, prepend `assert` or remove it.
+B015.py:21:5: B015 Pointless comparison. Did you mean to assign a value? Otherwise, prepend `assert` or remove it.
   |
-23 | class TestClass:
-24 |     1 == 1
+20 | def test2():
+21 |     1 in (1, 2)
+   |     ^^^^^^^^^^^ B015
+22 |     return
+   |
+
+B015.py:29:5: B015 Pointless comparison. Did you mean to assign a value? Otherwise, prepend `assert` or remove it.
+   |
+28 | class TestClass:
+29 |     1 == 1
   |     ^^^^^^ B015
   |
-
-
--- a/crates/ruff_linter/src/rules/flake8_type_checking/rules/typing_only_runtime_import.rs
+++ b/crates/ruff_linter/src/rules/flake8_type_checking/rules/typing_only_runtime_import.rs
@@ -300,7 +300,7 @@ pub(crate) fn typing_only_runtime_import(
            // Categorize the import, using coarse-grained categorization.
            let import_type = match categorize(
                &qualified_name.to_string(),
-                0,
+                qualified_name.is_unresolved_import(),
                &checker.settings.src,
                checker.package(),
                checker.settings.isort.detect_same_package,
--- a/crates/ruff_linter/src/rules/flake8_unused_arguments/rules/unused_arguments.rs
+++ b/crates/ruff_linter/src/rules/flake8_unused_arguments/rules/unused_arguments.rs
@@ -344,6 +344,7 @@ pub(crate) fn unused_arguments(
            ) {
                function_type::FunctionType::Function => {
                    if checker.enabled(Argumentable::Function.rule_code())
+                        && !function_type::is_stub(function_def, checker.semantic())
                        && !visibility::is_overload(decorator_list, checker.semantic())
                    {
                        function(
--- a/crates/ruff_linter/src/rules/flake8_unused_arguments/snapshots/ruff_linterrulesflake8_unused_argumentstestsARG001_ARG.py.snap
+++ b/crates/ruff_linter/src/rules/flake8_unused_arguments/snapshots/ruff_linterrulesflake8_unused_argumentstestsARG001_ARG.py.snap
@@ -32,33 +32,3 @@ ARG.py:13:12: ARG001 Unused function argument: `x`
   |            ^ ARG001
 14 |     print("Hello, world!")
   |
-
-ARG.py:17:7: ARG001 Unused function argument: `self`
-   |
-17 | def f(self, x):
-   |       ^^^^ ARG001
-18 |     ...
-   |
-
-ARG.py:17:13: ARG001 Unused function argument: `x`
-   |
-17 | def f(self, x):
-   |             ^ ARG001
-18 |     ...
-   |
-
-ARG.py:21:7: ARG001 Unused function argument: `cls`
-   |
-21 | def f(cls, x):
-   |       ^^^ ARG001
-22 |     ...
-   |
-
-ARG.py:21:12: ARG001 Unused function argument: `x`
-   |
-21 | def f(cls, x):
-   |            ^ ARG001
-22 |     ...
-   |
-
-
--- a/crates/ruff_linter/src/rules/isort/categorize.rs
+++ b/crates/ruff_linter/src/rules/isort/categorize.rs
@@ -91,7 +91,7 @@ enum Reason<'a> {
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn categorize<'a>(
    module_name: &str,
-    level: u32,
+    is_relative: bool,
    src: &[PathBuf],
    package: Option<&Path>,
    detect_same_package: bool,
@@ -103,14 +103,14 @@ pub(crate) fn categorize<'a>(
 ) -> &'a ImportSection {
    let module_base = module_name.split('.').next().unwrap();
    let (mut import_type, mut reason) = {
-        if level == 0 && module_base == "__future__" {
+        if !is_relative && module_base == "__future__" {
            (&ImportSection::Known(ImportType::Future), Reason::Future)
        } else if no_sections {
            (
                &ImportSection::Known(ImportType::FirstParty),
                Reason::NoSections,
            )
-        } else if level > 0 {
+        } else if is_relative {
            (
                &ImportSection::Known(ImportType::LocalFolder),
                Reason::NonZeroLevel,
@@ -132,7 +132,7 @@ pub(crate) fn categorize<'a>(
                &ImportSection::Known(ImportType::FirstParty),
                Reason::SourceMatch(src),
            )
-        } else if level == 0 && module_name == "__main__" {
+        } else if !is_relative && module_name == "__main__" {
            (
                &ImportSection::Known(ImportType::FirstParty),
                Reason::KnownFirstParty,
@@ -190,7 +190,7 @@ pub(crate) fn categorize_imports<'a>(
    for (alias, comments) in block.import {
        let import_type = categorize(
            &alias.module_name(),
-            0,
+            false,
            src,
            package,
            detect_same_package,
@@ -210,7 +210,7 @@ pub(crate) fn categorize_imports<'a>(
    for (import_from, aliases) in block.import_from {
        let classification = categorize(
            &import_from.module_name(),
-            import_from.level,
+            import_from.level > 0,
            src,
            package,
            detect_same_package,
@@ -230,7 +230,7 @@ pub(crate) fn categorize_imports<'a>(
    for ((import_from, alias), aliases) in block.import_from_as {
        let classification = categorize(
            &import_from.module_name(),
-            import_from.level,
+            import_from.level > 0,
            src,
            package,
            detect_same_package,
@@ -250,7 +250,7 @@ pub(crate) fn categorize_imports<'a>(
    for (import_from, comments) in block.import_from_star {
        let classification = categorize(
            &import_from.module_name(),
-            import_from.level,
+            import_from.level > 0,
            src,
            package,
            detect_same_package,
--- a/crates/ruff_linter/src/rules/pep8_naming/rules/camelcase_imported_as_acronym.rs
+++ b/crates/ruff_linter/src/rules/pep8_naming/rules/camelcase_imported_as_acronym.rs
@@ -74,14 +74,7 @@ pub(crate) fn camelcase_imported_as_acronym(
        }

        // Ignore names that follow a community-agreed import convention.
-        if checker
-            .settings
-            .flake8_import_conventions
-            .aliases
-            .get(&*alias.name)
-            .map(String::as_str)
-            == Some(asname)
-        {
+        if is_ignored_because_of_import_convention(asname, stmt, alias, checker) {
            return None;
        }

@@ -97,3 +90,34 @@ pub(crate) fn camelcase_imported_as_acronym(
    }
    None
 }
+
+fn is_ignored_because_of_import_convention(
+    asname: &str,
+    stmt: &Stmt,
+    alias: &Alias,
+    checker: &Checker,
+) -> bool {
+    let full_name = if let Some(import_from) = stmt.as_import_from_stmt() {
+        // Never test relative imports for exclusion because we can't resolve the full-module name.
+        let Some(module) = import_from.module.as_ref() else {
+            return false;
+        };
+
+        if import_from.level != 0 {
+            return false;
+        }
+
+        std::borrow::Cow::Owned(format!("{module}.{}", alias.name))
+    } else {
+        std::borrow::Cow::Borrowed(&*alias.name)
+    };
+
+    // Ignore names that follow a community-agreed import convention.
+    checker
+        .settings
+        .flake8_import_conventions
+        .aliases
+        .get(&*full_name)
+        .map(String::as_str)
+        == Some(asname)
+}
--- a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linterrulespep8_namingtestsN817_N817.py.snap
+++ b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linterrulespep8_namingtestsN817_N817.py.snap
@@ -15,4 +15,9 @@ N817.py:2:17: N817 CamelCase `CamelCase` imported as acronym `CC`
  |                 ^^^^^^^^^^^^^^^ N817
  |

-
+N817.py:10:26: N817 CamelCase `ElementTree` imported as acronym `ET`
+   |
+ 9 | # Always an error (relative import)
+10 | from ..xml.eltree import ElementTree as ET
+   |                          ^^^^^^^^^^^^^^^^^ N817
+   |
--- a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linterrulespep8_namingtestscamelcase_imported_as_incorrect_convention.snap
+++ b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linterrulespep8_namingtestscamelcase_imported_as_incorrect_convention.snap
@@ -20,4 +20,22 @@ N817.py:6:8: N817 CamelCase `ElementTree` imported as acronym `ET`
 5 | # OK depending on configured import convention
 6 | import xml.etree.ElementTree as ET
  |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ N817
+7 | from xml.etree import ElementTree as ET
  |
+
+N817.py:7:23: N817 CamelCase `ElementTree` imported as acronym `ET`
+  |
+5 | # OK depending on configured import convention
+6 | import xml.etree.ElementTree as ET
+7 | from xml.etree import ElementTree as ET
+  |                       ^^^^^^^^^^^^^^^^^ N817
+8 | 
+9 | # Always an error (relative import)
+  |
+
+N817.py:10:26: N817 CamelCase `ElementTree` imported as acronym `ET`
+   |
+ 9 | # Always an error (relative import)
+10 | from ..xml.eltree import ElementTree as ET
+   |                          ^^^^^^^^^^^^^^^^^ N817
+   |
--- a/crates/ruff_linter/src/rules/perflint/rules/try_except_in_loop.rs
+++ b/crates/ruff_linter/src/rules/perflint/rules/try_except_in_loop.rs
@@ -15,21 +15,29 @@ use crate::settings::types::PythonVersion;
 /// Exception handling via `try`-`except` blocks incurs some performance
 /// overhead, regardless of whether an exception is raised.
 ///
-/// When possible, refactor your code to put the entire loop into the
-/// `try`-`except` block, rather than wrapping each iteration in a separate
-/// `try`-`except` block.
+/// To optimize your code, two techniques are possible:
+/// 1. Refactor your code to put the entire loop into the `try`-`except` block,
+///    rather than wrapping each iteration in a separate `try`-`except` block.
+/// 2. Use "Look Before You Leap" idioms that attempt to avoid exceptions
+///    being raised in the first place, avoiding the need to use `try`-`except`
+///    blocks in the first place.
 ///
 /// This rule is only enforced for Python versions prior to 3.11, which
-/// introduced "zero cost" exception handling.
+/// introduced "zero-cost" exception handling. However, note that even on
+/// Python 3.11 and newer, refactoring your code to avoid exception handling in
+/// tight loops can provide a significant speedup in some cases, as zero-cost
+/// exception handling is only zero-cost in the "happy path" where no exception
+/// is raised in the `try`-`except` block.
 ///
-/// Note that, as with all `perflint` rules, this is only intended as a
-/// micro-optimization, and will have a negligible impact on performance in
-/// most cases.
+/// As with all `perflint` rules, this is only intended as a
+/// micro-optimization. In many cases, it will have a negligible impact on
+/// performance.
 ///
 /// ## Example
 /// ```python
 /// string_numbers: list[str] = ["1", "2", "three", "4", "5"]
 ///
+/// # `try`/`except` that could be moved out of the loop:
 /// int_numbers: list[int] = []
 /// for num in string_numbers:
 ///     try:
@@ -37,6 +45,16 @@ use crate::settings::types::PythonVersion;
 ///     except ValueError as e:
 ///         print(f"Couldn't convert to integer: {e}")
 ///         break
+///
+/// # `try`/`except` used when "look before you leap" idioms could be used:
+/// number_names: dict[int, str] = {1: "one", 3: "three", 4: "four"}
+/// for number in range(5):
+///     try:
+///         name = number_names[number]
+///     except KeyError:
+///         continue
+///     else:
+///         print(f"The name of {number} is {name}")
 /// ```
 ///
 /// Use instead:
@@ -49,6 +67,12 @@ use crate::settings::types::PythonVersion;
 ///         int_numbers.append(int(num))
 /// except ValueError as e:
 ///     print(f"Couldn't convert to integer: {e}")
+///
+/// number_names: dict[int, str] = {1: "one", 3: "three", 4: "four"}
+/// for number in range(5):
+///     name = number_names.get(number)
+///     if name is not None:
+///         print(f"The name of {number} is {name}")
 /// ```
 ///
 /// ## Options
--- a/crates/ruff_linter/src/rules/pyflakes/rules/unused_import.rs
+++ b/crates/ruff_linter/src/rules/pyflakes/rules/unused_import.rs
@@ -6,8 +6,7 @@ use std::collections::BTreeMap;

 use ruff_diagnostics::{Applicability, Diagnostic, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast as ast;
-use ruff_python_ast::{Stmt, StmtImportFrom};
+use ruff_python_ast::{self as ast, Stmt};
 use ruff_python_semantic::{
    AnyImport, BindingKind, Exceptions, Imported, NodeId, Scope, SemanticModel, SubmoduleImport,
 };
@@ -218,10 +217,11 @@ enum UnusedImportContext {
    Other,
 }

-fn is_first_party(qualified_name: &str, level: u32, checker: &Checker) -> bool {
+fn is_first_party(import: &AnyImport, checker: &Checker) -> bool {
+    let qualified_name = import.qualified_name();
    let category = isort::categorize(
-        qualified_name,
-        level,
+        &qualified_name.to_string(),
+        qualified_name.is_unresolved_import(),
        &checker.settings.src,
        checker.package(),
        checker.settings.isort.detect_same_package,
@@ -343,13 +343,6 @@ pub(crate) fn unused_import(checker: &Checker, scope: &Scope, diagnostics: &mut
        let in_except_handler =
            exceptions.intersects(Exceptions::MODULE_NOT_FOUND_ERROR | Exceptions::IMPORT_ERROR);
        let multiple = bindings.len() > 1;
-        let level = match checker.semantic().statement(import_statement) {
-            Stmt::Import(_) => 0,
-            Stmt::ImportFrom(StmtImportFrom { level, .. }) => *level,
-            _ => {
-                continue;
-            }
-        };

        // pair each binding with context; divide them by how we want to fix them
        let (to_reexport, to_remove): (Vec<_>, Vec<_>) = bindings
@@ -357,9 +350,7 @@ pub(crate) fn unused_import(checker: &Checker, scope: &Scope, diagnostics: &mut
            .map(|binding| {
                let context = if in_except_handler {
                    UnusedImportContext::ExceptHandler
-                } else if in_init
-                    && is_first_party(&binding.import.qualified_name().to_string(), level, checker)
-                {
+                } else if in_init && is_first_party(&binding.import, checker) {
                    UnusedImportContext::DunderInitFirstParty {
                        dunder_all_count: DunderAllCount::from(dunder_all_exprs.len()),
                        submodule_import: binding.import.is_submodule_import(),
--- a/crates/ruff_linter/src/rules/pylint/rules/bad_staticmethod_argument.rs
+++ b/crates/ruff_linter/src/rules/pylint/rules/bad_staticmethod_argument.rs
@@ -91,13 +91,18 @@ pub(crate) fn bad_staticmethod_argument(
        return;
    };

-    if matches!(self_or_cls.name.as_str(), "self" | "cls") {
-        let diagnostic = Diagnostic::new(
-            BadStaticmethodArgument {
-                argument_name: self_or_cls.name.to_string(),
-            },
-            self_or_cls.range(),
-        );
-        diagnostics.push(diagnostic);
+    match (name.as_str(), self_or_cls.name.as_str()) {
+        ("__new__", "cls") => {
+            return;
+        }
+        (_, "self" | "cls") => {}
+        _ => return,
    }
+
+    diagnostics.push(Diagnostic::new(
+        BadStaticmethodArgument {
+            argument_name: self_or_cls.name.to_string(),
+        },
+        self_or_cls.range(),
+    ));
 }
--- a/crates/ruff_linter/src/rules/pylint/snapshots/ruff_linterrulespylinttestsPLW0642_self_or_cls_assignment.py.snap
+++ b/crates/ruff_linter/src/rules/pylint/snapshots/ruff_linterrulespylinttestsPLW0642_self_or_cls_assignment.py.snap
@@ -8,7 +8,7 @@ self_or_cls_assignment.py:4:9: PLW0642 Reassigned `cls` variable in class method
 4 |         cls = "apple"  # PLW0642
  |         ^^^ PLW0642
 5 |         cls: Fruit = "apple"  # PLW0642
-6 |         cls += "orange"  # PLW0642
+6 |         cls += "orange"  # OK, augmented assignments are ignored
  |
  = help: Consider using a different variable name

@@ -18,26 +18,15 @@ self_or_cls_assignment.py:5:9: PLW0642 Reassigned `cls` variable in class method
 4 |         cls = "apple"  # PLW0642
 5 |         cls: Fruit = "apple"  # PLW0642
  |         ^^^ PLW0642
-6 |         cls += "orange"  # PLW0642
+6 |         cls += "orange"  # OK, augmented assignments are ignored
 7 |         *cls = "banana"  # PLW0642
  |
  = help: Consider using a different variable name

-self_or_cls_assignment.py:6:9: PLW0642 Reassigned `cls` variable in class method
-  |
-4 |         cls = "apple"  # PLW0642
-5 |         cls: Fruit = "apple"  # PLW0642
-6 |         cls += "orange"  # PLW0642
-  |         ^^^ PLW0642
-7 |         *cls = "banana"  # PLW0642
-8 |         cls, blah = "apple", "orange"  # PLW0642
-  |
-  = help: Consider using a different variable name
-
 self_or_cls_assignment.py:7:10: PLW0642 Reassigned `cls` variable in class method
  |
 5 |         cls: Fruit = "apple"  # PLW0642
-6 |         cls += "orange"  # PLW0642
+6 |         cls += "orange"  # OK, augmented assignments are ignored
 7 |         *cls = "banana"  # PLW0642
  |          ^^^ PLW0642
 8 |         cls, blah = "apple", "orange"  # PLW0642
@@ -47,7 +36,7 @@ self_or_cls_assignment.py:7:10: PLW0642 Reassigned `cls` variable in class metho

 self_or_cls_assignment.py:8:9: PLW0642 Reassigned `cls` variable in class method
   |
- 6 |         cls += "orange"  # PLW0642
+ 6 |         cls += "orange"  # OK, augmented assignments are ignored
 7 |         *cls = "banana"  # PLW0642
 8 |         cls, blah = "apple", "orange"  # PLW0642
   |         ^^^ PLW0642
@@ -94,7 +83,7 @@ self_or_cls_assignment.py:17:9: PLW0642 Reassigned `self` variable in instance m
 17 |         self = "red"  # PLW0642
   |         ^^^^ PLW0642
 18 |         self: Self = "red"  # PLW0642
-19 |         self += "blue"  # PLW0642
+19 |         self += "blue"  # OK, augmented assignments are ignored
   |
   = help: Consider using a different variable name

@@ -104,26 +93,15 @@ self_or_cls_assignment.py:18:9: PLW0642 Reassigned `self` variable in instance m
 17 |         self = "red"  # PLW0642
 18 |         self: Self = "red"  # PLW0642
   |         ^^^^ PLW0642
-19 |         self += "blue"  # PLW0642
+19 |         self += "blue"  # OK, augmented assignments are ignored
 20 |         *self = "blue"  # PLW0642
   |
   = help: Consider using a different variable name

-self_or_cls_assignment.py:19:9: PLW0642 Reassigned `self` variable in instance method
-   |
-17 |         self = "red"  # PLW0642
-18 |         self: Self = "red"  # PLW0642
-19 |         self += "blue"  # PLW0642
-   |         ^^^^ PLW0642
-20 |         *self = "blue"  # PLW0642
-21 |         self, blah = "red", "blue"  # PLW0642
-   |
-   = help: Consider using a different variable name
-
 self_or_cls_assignment.py:20:10: PLW0642 Reassigned `self` variable in instance method
   |
 18 |         self: Self = "red"  # PLW0642
-19 |         self += "blue"  # PLW0642
+19 |         self += "blue"  # OK, augmented assignments are ignored
 20 |         *self = "blue"  # PLW0642
   |          ^^^^ PLW0642
 21 |         self, blah = "red", "blue"  # PLW0642
@@ -133,7 +111,7 @@ self_or_cls_assignment.py:20:10: PLW0642 Reassigned `self` variable in instance

 self_or_cls_assignment.py:21:9: PLW0642 Reassigned `self` variable in instance method
   |
-19 |         self += "blue"  # PLW0642
+19 |         self += "blue"  # OK, augmented assignments are ignored
 20 |         *self = "blue"  # PLW0642
 21 |         self, blah = "red", "blue"  # PLW0642
   |         ^^^^ PLW0642
--- a/crates/ruff_linter/src/rules/ruff/mod.rs
+++ b/crates/ruff_linter/src/rules/ruff/mod.rs
@@ -57,6 +57,7 @@ mod tests {
    #[test_case(Rule::UnusedAsync, Path::new("RUF029.py"))]
    #[test_case(Rule::AssertWithPrintMessage, Path::new("RUF030.py"))]
    #[test_case(Rule::IncorrectlyParenthesizedTupleInSubscript, Path::new("RUF031.py"))]
+    #[test_case(Rule::DecimalFromFloatLiteral, Path::new("RUF032.py"))]
    #[test_case(Rule::RedirectedNOQA, Path::new("RUF101.py"))]
    fn rules(rule_code: Rule, path: &Path) -> Result<()> {
        let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());
--- a/crates/ruff_linter/src/rules/ruff/rules/decimal_from_float_literal.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/decimal_from_float_literal.rs
@@ -0,0 +1,85 @@
+use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
+use ruff_macros::{derive_message_formats, violation};
+use ruff_python_ast::{self as ast};
+use ruff_python_codegen::Stylist;
+use ruff_text_size::{Ranged, TextRange};
+
+use crate::checkers::ast::Checker;
+
+/// ## What it does
+/// Checks for `Decimal` calls passing a float literal.
+///
+/// ## Why is this bad?
+/// Float literals have limited precision that can lead to unexpected results.
+/// The `Decimal` class is designed to handle numbers with fixed-point precision,
+/// so a string literal should be used instead.
+///
+/// ## Example
+///
+/// ```python
+/// num = Decimal(1.2345)
+/// ```
+///
+/// Use instead:
+/// ```python
+/// num = Decimal("1.2345")
+/// ```
+///
+/// ## Fix Safety
+/// This rule's fix is marked as unsafe because it changes the underlying value
+/// of the `Decimal` instance that is constructed. This can lead to unexpected
+/// behavior if your program relies on the previous value (whether deliberately or not).
+#[violation]
+pub struct DecimalFromFloatLiteral;
+
+impl AlwaysFixableViolation for DecimalFromFloatLiteral {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        format!("`Decimal()` called with float literal argument")
+    }
+
+    fn fix_title(&self) -> String {
+        "Use a string literal instead".to_string()
+    }
+}
+
+/// RUF032: `Decimal()` called with float literal argument
+pub(crate) fn decimal_from_float_literal_syntax(checker: &mut Checker, call: &ast::ExprCall) {
+    let Some(arg) = call.arguments.args.first() else {
+        return;
+    };
+
+    if !is_arg_float_literal(arg) {
+        return;
+    }
+
+    if checker
+        .semantic()
+        .resolve_qualified_name(call.func.as_ref())
+        .is_some_and(|qualified_name| matches!(qualified_name.segments(), ["decimal", "Decimal"]))
+    {
+        let diagnostic =
+            Diagnostic::new(DecimalFromFloatLiteral, arg.range()).with_fix(fix_float_literal(
+                arg.range(),
+                &checker.generator().expr(arg),
+                checker.stylist(),
+            ));
+        checker.diagnostics.push(diagnostic);
+    }
+}
+
+fn is_arg_float_literal(arg: &ast::Expr) -> bool {
+    match arg {
+        ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
+            value: ast::Number::Float(_),
+            ..
+        }) => true,
+        ast::Expr::UnaryOp(ast::ExprUnaryOp { operand, .. }) => is_arg_float_literal(operand),
+        _ => false,
+    }
+}
+
+fn fix_float_literal(range: TextRange, float_literal: &str, stylist: &Stylist) -> Fix {
+    let content = format!("{quote}{float_literal}{quote}", quote = stylist.quote());
+    Fix::unsafe_edit(Edit::range_replacement(content, range))
+}
--- a/crates/ruff_linter/src/rules/ruff/rules/missing_fstring_syntax.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/missing_fstring_syntax.rs
@@ -4,7 +4,7 @@ use ruff_python_ast as ast;
 use ruff_python_literal::format::FormatSpec;
 use ruff_python_parser::parse_expression;
 use ruff_python_semantic::analyze::logging::is_logger_candidate;
-use ruff_python_semantic::SemanticModel;
+use ruff_python_semantic::{Modules, SemanticModel};
 use ruff_source_file::Locator;
 use ruff_text_size::{Ranged, TextRange};

@@ -12,6 +12,7 @@ use memchr::memchr2_iter;
 use rustc_hash::FxHashSet;

 use crate::checkers::ast::Checker;
+use crate::rules::fastapi::rules::is_fastapi_route_call;

 /// ## What it does
 /// Searches for strings that look like they were meant to be f-strings, but are missing an `f` prefix.
@@ -34,7 +35,7 @@ use crate::checkers::ast::Checker;
 /// 5. The string references variables that are not in scope, or it doesn't capture variables at all.
 /// 6. Any format specifiers in the potential f-string are invalid.
 /// 7. The string is part of a function call that is known to expect a template string rather than an
-///    evaluated f-string: for example, a `logging` call or a [`gettext`] call
+///    evaluated f-string: for example, a [`logging`] call, a [`gettext`] call, or a [`fastAPI` path].
 ///
 /// ## Example
 ///
@@ -53,6 +54,7 @@ use crate::checkers::ast::Checker;
 ///
 /// [`logging`]: https://docs.python.org/3/howto/logging-cookbook.html#using-particular-formatting-styles-throughout-your-application
 /// [`gettext`]: https://docs.python.org/3/library/gettext.html
+/// [`fastAPI` path]: https://fastapi.tiangolo.com/tutorial/path-params/
 #[violation]
 pub struct MissingFStringSyntax;

@@ -81,11 +83,13 @@ pub(crate) fn missing_fstring_syntax(checker: &mut Checker, literal: &ast::Strin
    }

    let logger_objects = &checker.settings.logger_objects;
+    let fastapi_seen = semantic.seen_module(Modules::FASTAPI);

    // We also want to avoid:
    // - Expressions inside `gettext()` calls
    // - Expressions passed to logging calls (since the `logging` module evaluates them lazily:
    //   https://docs.python.org/3/howto/logging-cookbook.html#using-particular-formatting-styles-throughout-your-application)
+    // - `fastAPI` paths: https://fastapi.tiangolo.com/tutorial/path-params/
    // - Expressions where a method is immediately called on the string literal
    if semantic
        .current_expressions()
@@ -94,6 +98,7 @@ pub(crate) fn missing_fstring_syntax(checker: &mut Checker, literal: &ast::Strin
            is_method_call_on_literal(call_expr, literal)
                || is_gettext(call_expr, semantic)
                || is_logger_candidate(&call_expr.func, semantic, logger_objects)
+                || (fastapi_seen && is_fastapi_route_call(call_expr, semantic))
        })
    {
        return;
--- a/crates/ruff_linter/src/rules/ruff/rules/mod.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/mod.rs
@@ -3,6 +3,7 @@ pub(crate) use assert_with_print_message::*;
 pub(crate) use assignment_in_assert::*;
 pub(crate) use asyncio_dangling_task::*;
 pub(crate) use collection_literal_concatenation::*;
+pub(crate) use decimal_from_float_literal::*;
 pub(crate) use default_factory_kwarg::*;
 pub(crate) use explicit_f_string_type_conversion::*;
 pub(crate) use function_call_in_dataclass_default::*;
@@ -36,6 +37,7 @@ mod assignment_in_assert;
 mod asyncio_dangling_task;
 mod collection_literal_concatenation;
 mod confusables;
+mod decimal_from_float_literal;
 mod default_factory_kwarg;
 mod explicit_f_string_type_conversion;
 mod function_call_in_dataclass_default;
--- a/crates/ruff_linter/src/rules/ruff/rules/unused_async.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/unused_async.rs
@@ -4,8 +4,10 @@ use ruff_python_ast::identifier::Identifier;
 use ruff_python_ast::visitor::source_order;
 use ruff_python_ast::{self as ast, AnyNodeRef, Expr, Stmt};
 use ruff_python_semantic::analyze::function_type::is_stub;
+use ruff_python_semantic::Modules;

 use crate::checkers::ast::Checker;
+use crate::rules::fastapi::rules::is_fastapi_route;

 /// ## What it does
 /// Checks for functions declared `async` that do not await or otherwise use features requiring the
@@ -173,6 +175,12 @@ pub(crate) fn unused_async(
        return;
    }

+    if checker.semantic().seen_module(Modules::FASTAPI)
+        && is_fastapi_route(function_def, checker.semantic())
+    {
+        return;
+    }
+
    let found_await_or_async = {
        let mut visitor = AsyncExprVisitor::default();
        source_order::walk_body(&mut visitor, body);
--- a/crates/ruff_linter/src/rules/ruff/snapshots/ruff_linterrulesrufftestsRUF032_RUF032.py.snap
+++ b/crates/ruff_linter/src/rules/ruff/snapshots/ruff_linterrulesrufftestsRUF032_RUF032.py.snap
@@ -0,0 +1,191 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+RUF032.py:6:17: RUF032 [*] `Decimal()` called with float literal argument
+  |
+4 | decimal.Decimal(0)
+5 | 
+6 | decimal.Decimal(0.0)  # Should error
+  |                 ^^^ RUF032
+7 | 
+8 | decimal.Decimal("0.0")
+  |
+  = help: Use a string literal instead
+
+ℹ Unsafe fix
+3 3 | # Tests with fully qualified import
+4 4 | decimal.Decimal(0)
+5 5 | 
+6   |-decimal.Decimal(0.0)  # Should error
+  6 |+decimal.Decimal("0.0")  # Should error
+7 7 | 
+8 8 | decimal.Decimal("0.0")
+9 9 | 
+
+RUF032.py:12:17: RUF032 [*] `Decimal()` called with float literal argument
+   |
+10 | decimal.Decimal(10)
+11 | 
+12 | decimal.Decimal(10.0)  # Should error
+   |                 ^^^^ RUF032
+13 | 
+14 | decimal.Decimal("10.0")
+   |
+   = help: Use a string literal instead
+
+ℹ Unsafe fix
+9  9  | 
+10 10 | decimal.Decimal(10)
+11 11 | 
+12    |-decimal.Decimal(10.0)  # Should error
+   12 |+decimal.Decimal("10.0")  # Should error
+13 13 | 
+14 14 | decimal.Decimal("10.0")
+15 15 | 
+
+RUF032.py:18:17: RUF032 [*] `Decimal()` called with float literal argument
+   |
+16 | decimal.Decimal(-10)
+17 | 
+18 | decimal.Decimal(-10.0)  # Should error
+   |                 ^^^^^ RUF032
+19 | 
+20 | decimal.Decimal("-10.0")
+   |
+   = help: Use a string literal instead
+
+ℹ Unsafe fix
+15 15 | 
+16 16 | decimal.Decimal(-10)
+17 17 | 
+18    |-decimal.Decimal(-10.0)  # Should error
+   18 |+decimal.Decimal("-10.0")  # Should error
+19 19 | 
+20 20 | decimal.Decimal("-10.0")
+21 21 | 
+
+RUF032.py:33:15: RUF032 [*] `Decimal()` called with float literal argument
+   |
+31 | val = Decimal(0)
+32 | 
+33 | val = Decimal(0.0)  # Should error
+   |               ^^^ RUF032
+34 | 
+35 | val = Decimal("0.0")
+   |
+   = help: Use a string literal instead
+
+ℹ Unsafe fix
+30 30 | 
+31 31 | val = Decimal(0)
+32 32 | 
+33    |-val = Decimal(0.0)  # Should error
+   33 |+val = Decimal("0.0")  # Should error
+34 34 | 
+35 35 | val = Decimal("0.0")
+36 36 | 
+
+RUF032.py:39:15: RUF032 [*] `Decimal()` called with float literal argument
+   |
+37 | val = Decimal(10)
+38 | 
+39 | val = Decimal(10.0)  # Should error
+   |               ^^^^ RUF032
+40 | 
+41 | val = Decimal("10.0")
+   |
+   = help: Use a string literal instead
+
+ℹ Unsafe fix
+36 36 | 
+37 37 | val = Decimal(10)
+38 38 | 
+39    |-val = Decimal(10.0)  # Should error
+   39 |+val = Decimal("10.0")  # Should error
+40 40 | 
+41 41 | val = Decimal("10.0")
+42 42 | 
+
+RUF032.py:45:15: RUF032 [*] `Decimal()` called with float literal argument
+   |
+43 | val = Decimal(-10)
+44 | 
+45 | val = Decimal(-10.0)  # Should error
+   |               ^^^^^ RUF032
+46 | 
+47 | val = Decimal("-10.0")
+   |
+   = help: Use a string literal instead
+
+ℹ Unsafe fix
+42 42 | 
+43 43 | val = Decimal(-10)
+44 44 | 
+45    |-val = Decimal(-10.0)  # Should error
+   45 |+val = Decimal("-10.0")  # Should error
+46 46 | 
+47 47 | val = Decimal("-10.0")
+48 48 | 
+
+RUF032.py:81:23: RUF032 [*] `Decimal()` called with float literal argument
+   |
+79 | # Retest with fully qualified import
+80 | 
+81 | val = decimal.Decimal(0.0)  # Should error
+   |                       ^^^ RUF032
+82 | 
+83 | val = decimal.Decimal("0.0")
+   |
+   = help: Use a string literal instead
+
+ℹ Unsafe fix
+78 78 | 
+79 79 | # Retest with fully qualified import
+80 80 | 
+81    |-val = decimal.Decimal(0.0)  # Should error
+   81 |+val = decimal.Decimal("0.0")  # Should error
+82 82 | 
+83 83 | val = decimal.Decimal("0.0")
+84 84 | 
+
+RUF032.py:85:23: RUF032 [*] `Decimal()` called with float literal argument
+   |
+83 | val = decimal.Decimal("0.0")
+84 | 
+85 | val = decimal.Decimal(10.0)  # Should error
+   |                       ^^^^ RUF032
+86 | 
+87 | val = decimal.Decimal("10.0")
+   |
+   = help: Use a string literal instead
+
+ℹ Unsafe fix
+82 82 | 
+83 83 | val = decimal.Decimal("0.0")
+84 84 | 
+85    |-val = decimal.Decimal(10.0)  # Should error
+   85 |+val = decimal.Decimal("10.0")  # Should error
+86 86 | 
+87 87 | val = decimal.Decimal("10.0")
+88 88 | 
+
+RUF032.py:89:23: RUF032 [*] `Decimal()` called with float literal argument
+   |
+87 | val = decimal.Decimal("10.0")
+88 | 
+89 | val = decimal.Decimal(-10.0)  # Should error
+   |                       ^^^^^ RUF032
+90 | 
+91 | val = decimal.Decimal("-10.0")
+   |
+   = help: Use a string literal instead
+
+ℹ Unsafe fix
+86 86 | 
+87 87 | val = decimal.Decimal("10.0")
+88 88 | 
+89    |-val = decimal.Decimal(-10.0)  # Should error
+   89 |+val = decimal.Decimal("-10.0")  # Should error
+90 90 | 
+91 91 | val = decimal.Decimal("-10.0")
+92 92 |
--- a/crates/ruff_workspace/src/options.rs
+++ b/crates/ruff_workspace/src/options.rs
@@ -47,7 +47,7 @@ pub struct Options {
    /// This setting will override even the `RUFF_CACHE_DIR` environment
    /// variable, if set.
    #[option(
-        default = ".ruff_cache",
+        default = r#"".ruff_cache""#,
        value_type = "str",
        example = r#"cache-dir = "~/.cache/ruff""#
    )]
@@ -553,7 +553,7 @@ pub struct LintCommonOptions {
    /// default expression matches `_`, `__`, and `_var`, but not `_var_`.
    #[option(
        default = r#""^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$""#,
-        value_type = "re.Pattern",
+        value_type = "str",
        example = r#"
            # Only ignore variables named "_".
            dummy-variable-rgx = "^_$"
@@ -1171,7 +1171,7 @@ pub struct Flake8CopyrightOptions {
    /// - `Copyright (C) 2021-2023`
    /// - `Copyright (C) 2021, 2023`
    #[option(
-        default = r#"(?i)Copyright\s+((?:\(C\)|©)\s+)?\d{4}((-|,\s)\d{4})*"#,
+        default = r#""(?i)Copyright\s+((?:\(C\)|©)\s+)?\d{4}((-|,\s)\d{4})*""#,
        value_type = "str",
        example = r#"notice-rgx = "(?i)Copyright \\(C\\) \\d{4}""#
    )]
@@ -2029,7 +2029,7 @@ pub struct IsortOptions {
    /// this to "closest-to-furthest" is equivalent to isort's
    /// `reverse-relative = true`.
    #[option(
-        default = r#"furthest-to-closest"#,
+        default = r#""furthest-to-closest""#,
        value_type = r#""furthest-to-closest" | "closest-to-furthest""#,
        example = r#"
            relative-imports-order = "closest-to-furthest"
@@ -2146,7 +2146,7 @@ pub struct IsortOptions {

    /// Define a default section for any imports that don't fit into the specified [`section-order`](#lint_isort_section-order).
    #[option(
-        default = r#"third-party"#,
+        default = r#""third-party""#,
        value_type = "str",
        example = r#"
            default-section = "first-party"
@@ -2660,8 +2660,8 @@ pub struct PycodestyleOptions {
    pub max_doc_length: Option<LineLength>,

    /// Whether line-length violations (`E501`) should be triggered for
-    /// comments starting with [`task-tags`](#lint_task-tags) (by default: \["TODO", "FIXME",
-    /// and "XXX"\]).
+    /// comments starting with [`task-tags`](#lint_task-tags) (by default: "TODO", "FIXME",
+    /// and "XXX").
    #[option(
        default = "false",
        value_type = "bool",
@@ -3059,7 +3059,7 @@ pub struct FormatOptions {
    ///
    /// See [`indent-width`](#indent-width) to configure the number of spaces per indentation and the tab width.
    #[option(
-        default = "space",
+        default = r#""space""#,
        value_type = r#""space" | "tab""#,
        example = r#"
            # Use tabs instead of 4 space indentation.
@@ -3092,7 +3092,7 @@ pub struct FormatOptions {
    /// a mixture of single and double quotes and can't migrate to the `double` or `single` style.
    /// The quote style `preserve` leaves the quotes of all strings unchanged.
    #[option(
-        default = r#"double"#,
+        default = r#""double""#,
        value_type = r#""double" | "single" | "preserve""#,
        example = r#"
            # Prefer single quotes over double quotes.
@@ -3136,7 +3136,7 @@ pub struct FormatOptions {
    /// * `cr-lf`: Line endings will be converted to `\r\n`. The default line ending on Windows.
    /// * `native`: Line endings will be converted to `\n` on Unix and `\r\n` on Windows.
    #[option(
-        default = r#"auto"#,
+        default = r#""auto""#,
        value_type = r#""auto" | "lf" | "cr-lf" | "native""#,
        example = r#"
            # Use `\n` line endings for all files
--- a/docs/requirements-insiders.txt
+++ b/docs/requirements-insiders.txt
@@ -1,8 +1,2 @@
-PyYAML==6.0.2
-black==24.8.0
-mkdocs==1.6.0
+-r requirements.txt
 mkdocs-material @ git+ssh://git@github.com/astral-sh/mkdocs-material-insiders.git@38c0b8187325c3bab386b666daf3518ac036f2f4
-mkdocs-redirects==1.2.1
-mdformat==0.7.17
-mdformat-mkdocs==3.0.0
-mdformat-admon==2.0.6
--- a/mkdocs.template.yml
+++ b/mkdocs.template.yml
@@ -71,3 +71,8 @@ not_in_nav: |
 extra:
  analytics:
    provider: fathom
+validation:
+  omitted_files: warn
+  absolute_links: warn
+  unrecognized_links: warn
+  anchors: warn
--- a/playground/.eslintrc
+++ b/playground/.eslintrc
@@ -1,6 +1,6 @@
 {
  "parser": "@typescript-eslint/parser",
-  "plugins": ["@typescript-eslint", "prettier"],
+  "plugins": ["@typescript-eslint"],
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/eslint-recommended",
@@ -9,8 +9,7 @@
    "plugin:react/jsx-runtime",
    "plugin:react-hooks/recommended",
    "plugin:import/recommended",
-    "plugin:import/typescript",
-    "plugin:prettier/recommended"
+    "plugin:import/typescript"
  ],
  "rules": {
    // Disable some recommended rules that we don't want to enforce.
--- a/playground/api/package-lock.json
+++ b/playground/api/package-lock.json
@@ -16,7 +16,7 @@
        "@cloudflare/workers-types": "^4.20230801.0",
        "miniflare": "^3.20230801.1",
        "typescript": "^5.1.6",
-        "wrangler": "3.70.0"
+        "wrangler": "3.72.0"
      }
    },
    "node_modules/@cloudflare/kv-asset-handler": {
@@ -118,15 +118,19 @@
      }
    },
    "node_modules/@cloudflare/workers-shared": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workers-shared/-/workers-shared-0.1.0.tgz",
-      "integrity": "sha512-SyD4iw6jM4anZaG+ujgVETV4fulF2KHBOW31eavbVN7TNpk2l4aJgwY1YSPK00IKSWsoQuH2TigR446KuT5lqQ==",
-      "dev": true
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workers-shared/-/workers-shared-0.2.0.tgz",
+      "integrity": "sha512-tIWLooWkBMuoKRk72lr6YrEtVlVdUTtAGVmPOnUroMrnri/9YLx+mVawL0/egDgSGmPbmvkdBFsUGRuI+aZmxg==",
+      "dev": true,
+      "license": "MIT OR Apache-2.0",
+      "engines": {
+        "node": ">=16.7.0"
+      }
    },
    "node_modules/@cloudflare/workers-types": {
-      "version": "4.20240806.0",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workers-types/-/workers-types-4.20240806.0.tgz",
-      "integrity": "sha512-8lvgrwXGTZEBsUQJ8YUnMk72Anh9omwr6fqWLw/EwVgcw1nQxs/bfdadBEbdP48l9fWXjE4E5XERLUrrFuEpsg==",
+      "version": "4.20240815.0",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workers-types/-/workers-types-4.20240815.0.tgz",
+      "integrity": "sha512-H/IXCOahT1lr4RKzsiCkyjM7+LCPLtl2wjxyLG8xMTNERR0XuD1Vcfns6TraE0cd5+IcKe7j3rpzBlSCjZ+61A==",
      "dev": true,
      "license": "MIT OR Apache-2.0"
    },
@@ -1111,9 +1115,9 @@
      }
    },
    "node_modules/miniflare": {
-      "version": "3.20240806.0",
-      "resolved": "https://registry.npmjs.org/miniflare/-/miniflare-3.20240806.0.tgz",
-      "integrity": "sha512-jDsXBJOLUVpIQXHsluX3xV0piDxXolTCsxdje2Ex2LTC9PsSoBIkMwvCmnCxe9wpJJCq8rb0UMyeEn3KOF3LOw==",
+      "version": "3.20240806.1",
+      "resolved": "https://registry.npmjs.org/miniflare/-/miniflare-3.20240806.1.tgz",
+      "integrity": "sha512-wJq3YQYx9k83L2CNYtxvwWvXSi+uHrC6aFoXYSbzhxIDlUWvMEqippj+3HeKLgsggC31nHJab3b1Pifg9IxIFQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -1599,21 +1603,21 @@
      }
    },
    "node_modules/wrangler": {
-      "version": "3.70.0",
-      "resolved": "https://registry.npmjs.org/wrangler/-/wrangler-3.70.0.tgz",
-      "integrity": "sha512-aMtCEXmH02SIxbxOFGGuJ8ZemmG9W+IcNRh5D4qIKgzSxqy0mt9mRoPNPSv1geGB2/8YAyeLGPf+tB4lxz+ssg==",
+      "version": "3.72.0",
+      "resolved": "https://registry.npmjs.org/wrangler/-/wrangler-3.72.0.tgz",
+      "integrity": "sha512-9sryHTCtCj48vUC5y/M3Dsx02U1bT6mK9E41TXBCpSJgWh8UvWG/xgmu2dY93Mqj9aJIvK/kwwIBRlNFRwF7Hw==",
      "dev": true,
      "license": "MIT OR Apache-2.0",
      "dependencies": {
        "@cloudflare/kv-asset-handler": "0.3.4",
-        "@cloudflare/workers-shared": "0.1.0",
+        "@cloudflare/workers-shared": "0.2.0",
        "@esbuild-plugins/node-globals-polyfill": "^0.2.3",
        "@esbuild-plugins/node-modules-polyfill": "^0.2.2",
        "blake3-wasm": "^2.1.5",
        "chokidar": "^3.5.3",
        "date-fns": "^3.6.0",
        "esbuild": "0.17.19",
-        "miniflare": "3.20240806.0",
+        "miniflare": "3.20240806.1",
        "nanoid": "^3.3.3",
        "path-to-regexp": "^6.2.0",
        "resolve": "^1.22.8",
--- a/playground/api/package.json
+++ b/playground/api/package.json
@@ -5,7 +5,7 @@
    "@cloudflare/workers-types": "^4.20230801.0",
    "miniflare": "^3.20230801.1",
    "typescript": "^5.1.6",
-    "wrangler": "3.70.0"
+    "wrangler": "3.72.0"
  },
  "private": true,
  "scripts": {
--- a/playground/package-lock.json
+++ b/playground/package-lock.json
@@ -26,7 +26,6 @@
        "eslint": "^8.30.0",
        "eslint-config-prettier": "^9.0.0",
        "eslint-plugin-import": "^2.29.1",
-        "eslint-plugin-prettier": "^5.0.0",
        "eslint-plugin-react": "^7.31.11",
        "eslint-plugin-react-hooks": "^4.6.0",
        "postcss": "^8.4.20",
@@ -650,18 +649,6 @@
        "node": ">= 8"
      }
    },
-    "node_modules/@pkgr/core": {
-      "version": "0.1.1",
-      "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.1.1.tgz",
-      "integrity": "sha512-cq8o4cWH0ibXh9VGi5P20Tu9XF/0fFXl9EUinr9QfTM7a7p0oTA4iJRCQWppXR1Pg8dSM0UCItCkPwsk9qWWYA==",
-      "dev": true,
-      "engines": {
-        "node": "^12.20.0 || ^14.18.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/unts"
-      }
-    },
    "node_modules/@rollup/rollup-android-arm-eabi": {
      "version": "4.13.0",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.13.0.tgz",
@@ -1096,17 +1083,17 @@
      }
    },
    "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.0.1.tgz",
-      "integrity": "sha512-5g3Y7GDFsJAnY4Yhvk8sZtFfV6YNF2caLzjrRPUBzewjPCaj0yokePB4LJSobyCzGMzjZZYFbwuzbfDHlimXbQ==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.1.0.tgz",
+      "integrity": "sha512-LlNBaHFCEBPHyD4pZXb35mzjGkuGKXU5eeCA1SxvHfiRES0E82dOounfVpL4DCqYvJEKab0bZIA0gCRpdLKkCw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@eslint-community/regexpp": "^4.10.0",
-        "@typescript-eslint/scope-manager": "8.0.1",
-        "@typescript-eslint/type-utils": "8.0.1",
-        "@typescript-eslint/utils": "8.0.1",
-        "@typescript-eslint/visitor-keys": "8.0.1",
+        "@typescript-eslint/scope-manager": "8.1.0",
+        "@typescript-eslint/type-utils": "8.1.0",
+        "@typescript-eslint/utils": "8.1.0",
+        "@typescript-eslint/visitor-keys": "8.1.0",
        "graphemer": "^1.4.0",
        "ignore": "^5.3.1",
        "natural-compare": "^1.4.0",
@@ -1130,16 +1117,16 @@
      }
    },
    "node_modules/@typescript-eslint/parser": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.0.1.tgz",
-      "integrity": "sha512-5IgYJ9EO/12pOUwiBKFkpU7rS3IU21mtXzB81TNwq2xEybcmAZrE9qwDtsb5uQd9aVO9o0fdabFyAmKveXyujg==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.1.0.tgz",
+      "integrity": "sha512-U7iTAtGgJk6DPX9wIWPPOlt1gO57097G06gIcl0N0EEnNw8RGD62c+2/DiP/zL7KrkqnnqF7gtFGR7YgzPllTA==",
      "dev": true,
      "license": "BSD-2-Clause",
      "dependencies": {
-        "@typescript-eslint/scope-manager": "8.0.1",
-        "@typescript-eslint/types": "8.0.1",
-        "@typescript-eslint/typescript-estree": "8.0.1",
-        "@typescript-eslint/visitor-keys": "8.0.1",
+        "@typescript-eslint/scope-manager": "8.1.0",
+        "@typescript-eslint/types": "8.1.0",
+        "@typescript-eslint/typescript-estree": "8.1.0",
+        "@typescript-eslint/visitor-keys": "8.1.0",
        "debug": "^4.3.4"
      },
      "engines": {
@@ -1159,14 +1146,14 @@
      }
    },
    "node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.0.1.tgz",
-      "integrity": "sha512-NpixInP5dm7uukMiRyiHjRKkom5RIFA4dfiHvalanD2cF0CLUuQqxfg8PtEUo9yqJI2bBhF+pcSafqnG3UBnRQ==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.1.0.tgz",
+      "integrity": "sha512-DsuOZQji687sQUjm4N6c9xABJa7fjvfIdjqpSIIVOgaENf2jFXiM9hIBZOL3hb6DHK9Nvd2d7zZnoMLf9e0OtQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "@typescript-eslint/types": "8.0.1",
-        "@typescript-eslint/visitor-keys": "8.0.1"
+        "@typescript-eslint/types": "8.1.0",
+        "@typescript-eslint/visitor-keys": "8.1.0"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -1177,14 +1164,14 @@
      }
    },
    "node_modules/@typescript-eslint/type-utils": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.0.1.tgz",
-      "integrity": "sha512-+/UT25MWvXeDX9YaHv1IS6KI1fiuTto43WprE7pgSMswHbn1Jm9GEM4Txp+X74ifOWV8emu2AWcbLhpJAvD5Ng==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.1.0.tgz",
+      "integrity": "sha512-oLYvTxljVvsMnldfl6jIKxTaU7ok7km0KDrwOt1RHYu6nxlhN3TIx8k5Q52L6wR33nOwDgM7VwW1fT1qMNfFIA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "@typescript-eslint/typescript-estree": "8.0.1",
-        "@typescript-eslint/utils": "8.0.1",
+        "@typescript-eslint/typescript-estree": "8.1.0",
+        "@typescript-eslint/utils": "8.1.0",
        "debug": "^4.3.4",
        "ts-api-utils": "^1.3.0"
      },
@@ -1202,9 +1189,9 @@
      }
    },
    "node_modules/@typescript-eslint/types": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.0.1.tgz",
-      "integrity": "sha512-PpqTVT3yCA/bIgJ12czBuE3iBlM3g4inRSC5J0QOdQFAn07TYrYEQBBKgXH1lQpglup+Zy6c1fxuwTk4MTNKIw==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.1.0.tgz",
+      "integrity": "sha512-q2/Bxa0gMOu/2/AKALI0tCKbG2zppccnRIRCW6BaaTlRVaPKft4oVYPp7WOPpcnsgbr0qROAVCVKCvIQ0tbWog==",
      "dev": true,
      "license": "MIT",
      "engines": {
@@ -1216,14 +1203,14 @@
      }
    },
    "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.0.1.tgz",
-      "integrity": "sha512-8V9hriRvZQXPWU3bbiUV4Epo7EvgM6RTs+sUmxp5G//dBGy402S7Fx0W0QkB2fb4obCF8SInoUzvTYtc3bkb5w==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.1.0.tgz",
+      "integrity": "sha512-NTHhmufocEkMiAord/g++gWKb0Fr34e9AExBRdqgWdVBaKoei2dIyYKD9Q0jBnvfbEA5zaf8plUFMUH6kQ0vGg==",
      "dev": true,
      "license": "BSD-2-Clause",
      "dependencies": {
-        "@typescript-eslint/types": "8.0.1",
-        "@typescript-eslint/visitor-keys": "8.0.1",
+        "@typescript-eslint/types": "8.1.0",
+        "@typescript-eslint/visitor-keys": "8.1.0",
        "debug": "^4.3.4",
        "globby": "^11.1.0",
        "is-glob": "^4.0.3",
@@ -1271,16 +1258,16 @@
      }
    },
    "node_modules/@typescript-eslint/utils": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.0.1.tgz",
-      "integrity": "sha512-CBFR0G0sCt0+fzfnKaciu9IBsKvEKYwN9UZ+eeogK1fYHg4Qxk1yf/wLQkLXlq8wbU2dFlgAesxt8Gi76E8RTA==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.1.0.tgz",
+      "integrity": "sha512-ypRueFNKTIFwqPeJBfeIpxZ895PQhNyH4YID6js0UoBImWYoSjBsahUn9KMiJXh94uOjVBgHD9AmkyPsPnFwJA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@eslint-community/eslint-utils": "^4.4.0",
-        "@typescript-eslint/scope-manager": "8.0.1",
-        "@typescript-eslint/types": "8.0.1",
-        "@typescript-eslint/typescript-estree": "8.0.1"
+        "@typescript-eslint/scope-manager": "8.1.0",
+        "@typescript-eslint/types": "8.1.0",
+        "@typescript-eslint/typescript-estree": "8.1.0"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -1294,13 +1281,13 @@
      }
    },
    "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.0.1.tgz",
-      "integrity": "sha512-W5E+o0UfUcK5EgchLZsyVWqARmsM7v54/qEq6PY3YI5arkgmCzHiuk0zKSJJbm71V0xdRna4BGomkCTXz2/LkQ==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.1.0.tgz",
+      "integrity": "sha512-ba0lNI19awqZ5ZNKh6wCModMwoZs457StTebQ0q1NP58zSi2F6MOZRXwfKZy+jB78JNJ/WH8GSh2IQNzXX8Nag==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "@typescript-eslint/types": "8.0.1",
+        "@typescript-eslint/types": "8.1.0",
        "eslint-visitor-keys": "^3.4.3"
      },
      "engines": {
@@ -2453,37 +2440,6 @@
        "semver": "bin/semver.js"
      }
    },
-    "node_modules/eslint-plugin-prettier": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.2.1.tgz",
-      "integrity": "sha512-gH3iR3g4JfF+yYPaJYkN7jEl9QbweL/YfkoRlNnuIEHEz1vHVlCmWOS+eGGiRuzHQXdJFCOTxRgvju9b8VUmrw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "prettier-linter-helpers": "^1.0.0",
-        "synckit": "^0.9.1"
-      },
-      "engines": {
-        "node": "^14.18.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint-plugin-prettier"
-      },
-      "peerDependencies": {
-        "@types/eslint": ">=8.0.0",
-        "eslint": ">=8.0.0",
-        "eslint-config-prettier": "*",
-        "prettier": ">=3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/eslint": {
-          "optional": true
-        },
-        "eslint-config-prettier": {
-          "optional": true
-        }
-      }
-    },
    "node_modules/eslint-plugin-react": {
      "version": "7.35.0",
      "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.35.0.tgz",
@@ -2663,12 +2619,6 @@
      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
      "dev": true
    },
-    "node_modules/fast-diff": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.3.0.tgz",
-      "integrity": "sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==",
-      "dev": true
-    },
    "node_modules/fast-glob": {
      "version": "3.3.0",
      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.0.tgz",
@@ -4215,18 +4165,6 @@
        "url": "https://github.com/prettier/prettier?sponsor=1"
      }
    },
-    "node_modules/prettier-linter-helpers": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz",
-      "integrity": "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==",
-      "dev": true,
-      "dependencies": {
-        "fast-diff": "^1.1.2"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
    "node_modules/prop-types": {
      "version": "15.8.1",
      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
@@ -4297,9 +4235,9 @@
      "dev": true
    },
    "node_modules/react-resizable-panels": {
-      "version": "2.0.23",
-      "resolved": "https://registry.npmjs.org/react-resizable-panels/-/react-resizable-panels-2.0.23.tgz",
-      "integrity": "sha512-8ZKTwTU11t/FYwiwhMdtZYYyFxic5U5ysRu2YwfkAgDbUJXFvnWSJqhnzkSlW+mnDoNAzDCrJhdOSXBPA76wug==",
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/react-resizable-panels/-/react-resizable-panels-2.1.0.tgz",
+      "integrity": "sha512-k2gGjGyCNF9xq8gVkkHBK1mlWv6xetPtvRdEtD914gTdhJcy02TLF0xMPuVLlGRuLoWGv7Gd/O1rea2KIQb3Qw==",
      "license": "MIT",
      "peerDependencies": {
        "react": "^16.14.0 || ^17.0.0 || ^18.0.0",
@@ -4808,27 +4746,10 @@
        "url": "https://github.com/sponsors/ljharb"
      }
    },
-    "node_modules/synckit": {
-      "version": "0.9.1",
-      "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.9.1.tgz",
-      "integrity": "sha512-7gr8p9TQP6RAHusBOSLs46F4564ZrjV8xFmw5zCmgmhGUcw2hxsShhJ6CEiHQMgPDwAQ1fWHPM0ypc4RMAig4A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@pkgr/core": "^0.1.0",
-        "tslib": "^2.6.2"
-      },
-      "engines": {
-        "node": "^14.18.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/unts"
-      }
-    },
    "node_modules/tailwindcss": {
-      "version": "3.4.9",
-      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.9.tgz",
-      "integrity": "sha512-1SEOvRr6sSdV5IDf9iC+NU4dhwdqzF4zKKq3sAbasUWHEM6lsMhX+eNN5gkPx1BvLFEnZQEUFbXnGj8Qlp83Pg==",
+      "version": "3.4.10",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.10.tgz",
+      "integrity": "sha512-KWZkVPm7yJRhdu4SRSl9d4AK2wM3a50UsvgHZO7xY77NQr2V+fIrEuoDGQcbvswWvFGbS2f6e+jC/6WJm1Dl0w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -4932,12 +4853,6 @@
        "strip-bom": "^3.0.0"
      }
    },
-    "node_modules/tslib": {
-      "version": "2.6.2",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz",
-      "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==",
-      "dev": true
-    },
    "node_modules/type-check": {
      "version": "0.4.0",
      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
@@ -5111,14 +5026,14 @@
      "dev": true
    },
    "node_modules/vite": {
-      "version": "5.4.0",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.0.tgz",
-      "integrity": "sha512-5xokfMX0PIiwCMCMb9ZJcMyh5wbBun0zUzKib+L65vAZ8GY9ePZMXxFrHbr/Kyll2+LSCY7xtERPpxkBDKngwg==",
+      "version": "5.4.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.1.tgz",
+      "integrity": "sha512-1oE6yuNXssjrZdblI9AfBbHCC41nnyoVoEZxQnID6yvQZAFBzxxkqoFLtHUMkYunL8hwOLEjgTuxpkRxvba3kA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "esbuild": "^0.21.3",
-        "postcss": "^8.4.40",
+        "postcss": "^8.4.41",
        "rollup": "^4.13.0"
      },
      "bin": {
--- a/playground/package.json
+++ b/playground/package.json
@@ -33,7 +33,6 @@
    "eslint": "^8.30.0",
    "eslint-config-prettier": "^9.0.0",
    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-prettier": "^5.0.0",
    "eslint-plugin-react": "^7.31.11",
    "eslint-plugin-react-hooks": "^4.6.0",
    "postcss": "^8.4.20",
--- a/playground/src/Editor/Chrome.tsx
+++ b/playground/src/Editor/Chrome.tsx
@@ -3,7 +3,7 @@ import Header from "./Header";
 import { persist, persistLocal, restore, stringify } from "./settings";
 import { useTheme } from "./theme";
 import { default as Editor, Source } from "./Editor";
-import initRuff, { Workspace } from "../pkg/ruff_wasm";
+import initRuff, { Workspace } from "../pkg";
 import { loader } from "@monaco-editor/react";
 import { setupMonaco } from "./setupMonaco";
 import { DEFAULT_PYTHON_SOURCE } from "../constants";
--- a/playground/src/Editor/Editor.tsx
+++ b/playground/src/Editor/Editor.tsx
@@ -1,6 +1,6 @@
 import { useDeferredValue, useMemo, useState } from "react";
 import { Panel, PanelGroup } from "react-resizable-panels";
-import { Diagnostic, Workspace } from "../pkg/ruff_wasm";
+import { Diagnostic, Workspace } from "../pkg";
 import { ErrorMessage } from "./ErrorMessage";
 import PrimarySideBar from "./PrimarySideBar";
 import { HorizontalResizeHandle } from "./ResizeHandle";
--- a/playground/src/Editor/SourceEditor.tsx
+++ b/playground/src/Editor/SourceEditor.tsx
@@ -5,7 +5,7 @@
 import Editor, { BeforeMount, Monaco } from "@monaco-editor/react";
 import { MarkerSeverity, MarkerTag } from "monaco-editor";
 import { useCallback, useEffect, useRef } from "react";
-import { Diagnostic } from "../pkg/ruff_wasm";
+import { Diagnostic } from "../pkg";
 import { Theme } from "./theme";

 export default function SourceEditor({
@@ -83,7 +83,10 @@ export default function SourceEditor({
                  }
                : undefined,
            }));
-          return { actions, dispose: () => {} };
+          return {
+            actions,
+            dispose: () => {},
+          };
        },
      },
    );
--- a/ruff.schema.json
+++ b/ruff.schema.json
@@ -2430,7 +2430,7 @@
      "type": "object",
      "properties": {
        "ignore-overlong-task-comments": {
-          "description": "Whether line-length violations (`E501`) should be triggered for comments starting with [`task-tags`](#lint_task-tags) (by default: \\[\"TODO\", \"FIXME\", and \"XXX\"\\]).",
+          "description": "Whether line-length violations (`E501`) should be triggered for comments starting with [`task-tags`](#lint_task-tags) (by default: \"TODO\", \"FIXME\", and \"XXX\").",
          "type": [
            "boolean",
            "null"
@@ -3738,6 +3738,7 @@
        "RUF03",
        "RUF030",
        "RUF031",
+        "RUF032",
        "RUF1",
        "RUF10",
        "RUF100",
Author	SHA1	Message	Date
Dhruv Manilawala	2f9602e16e	Keep public / insider docs requirements in sync	2024-08-20 11:48:19 +05:30
Dhruv Manilawala	1a8f29ea41	[red-knot] Add symbols defined by `match` statements (#12926 ) ## Summary This PR adds symbols introduced by `match` statements. There are three patterns that introduces new symbols: * `as` pattern * Sequence pattern * Mapping pattern The recursive nature of the visitor makes sure that all symbols are added. ## Test Plan Add test case for all types of patterns that introduces a symbol.	2024-08-20 05:16:27 +00:00
Dhruv Manilawala	aefaddeae7	[red-knot] Add definition for augmented assignment (#12892 ) ## Summary This PR adds definition for augmented assignment. This is similar to annotated assignment in terms of implementation. An augmented assignment should also record a use of the variable but that's a TODO for now. ## Test Plan Add test case to validate that a definition is added.	2024-08-20 10:33:55 +05:30
Mathieu Kniewallner	df09045176	docs: add stricter validation options (#12998 ) ## Summary Applying the same change as done in https://github.com/astral-sh/uv/pull/6096. Note that in `uv` repository, this [broke the docs build](https://github.com/astral-sh/uv/pull/6096#issuecomment-2290151150) because `anchors` is `mdkocs` 1.6+ only, and insiders used 1.5.0 while public dependencies used 1.6.0, but in this repository, both use 1.6.0 ([public](`049cda2ff3/docs/requirements.txt (L3)`), [insiders](`049cda2ff3/docs/requirements-insiders.txt (L3)`)), so this should not be an issue to have in the template. Contrarily to `uv` repository, no violations were reported here, but this could prevent adding some in the future. ## Test Plan Local run of the documentation + `mkdocs build --strict`.	2024-08-19 18:07:41 -05:00
Alex Waygood	049cda2ff3	`flake8-type-checking`: Always recognise relative imports as first-party (#12994 )	2024-08-19 19:06:56 +01:00
renovate[bot]	358792f2c9	Update pre-commit dependencies (#12978 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> Co-authored-by: Alex Waygood <alex.waygood@gmail.com>	2024-08-19 13:41:03 +02:00
Alex Waygood	e6d5a7af37	Add the `testing` feature of `ruff_db` as a dev-dependency for `ruff_workspace` (#12985 )	2024-08-19 10:22:01 +00:00
Mathieu Kniewallner	f5bff82e70	docs(contributing): remove TOC (#12903 ) Co-authored-by: Micha Reiser <micha@reiser.io>	2024-08-19 09:38:08 +00:00
Alex Waygood	ab44152eb5	Improve release instructions for when `ruff-lsp` and `ruff-vscode` updates are required (#12952 )	2024-08-19 10:29:16 +01:00
Ken Baskett	f4c8c7eb70	[ruff] Implement check for Decimal called with a float literal (RUF032) (#12909 ) Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com> Co-authored-by: Micha Reiser <micha@reiser.io>	2024-08-19 09:22:19 +00:00
InSync	65de8f2c9b	Quote default values consistently (#12981 ) Co-authored-by: Micha Reiser <micha@reiser.io>	2024-08-19 08:02:55 +00:00
renovate[bot]	e6226436fd	Update NPM Development dependencies (#12976 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> Co-authored-by: Micha Reiser <micha@reiser.io>	2024-08-19 07:44:21 +00:00
renovate[bot]	0345d46759	Update dependency react-resizable-panels to v2.1.0 (#12977 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2024-08-19 09:40:48 +02:00
renovate[bot]	4d0d3b00cb	Update rust-wasm-bindgen monorepo (#12975 )	2024-08-18 20:44:00 -04:00
renovate[bot]	2be1c4ff04	Update Rust crate syn to v2.0.75 (#12974 )	2024-08-18 20:43:54 -04:00
renovate[bot]	edd86d5603	Update Rust crate serde_json to v1.0.125 (#12973 )	2024-08-18 20:43:48 -04:00
renovate[bot]	78ad7959ca	Update Rust crate serde to v1.0.208 (#12972 )	2024-08-18 20:43:42 -04:00
renovate[bot]	d72ecd6ded	Update Rust crate ordermap to v0.5.2 (#12971 )	2024-08-18 20:43:37 -04:00
renovate[bot]	8617a508bd	Update Rust crate libc to v0.2.157 (#12970 )	2024-08-18 20:43:31 -04:00
renovate[bot]	c88bd4e884	Update Rust crate ctrlc to v3.4.5 (#12969 )	2024-08-18 20:43:24 -04:00
renovate[bot]	fbcda90316	Update Rust crate camino to v1.1.9 (#12967 )	2024-08-18 20:43:18 -04:00
renovate[bot]	169d4390cb	Update Rust crate clap to v4.5.16 (#12968 )	2024-08-18 20:43:05 -04:00
Charlie Marsh	80ade591df	Ignore unused arguments on stub functions (#12966 ) ## Summary We already enforce this logic for the other `ARG` rules. I'm guessing this was an oversight. Closes https://github.com/astral-sh/ruff/issues/12963.	2024-08-18 19:21:33 -04:00
Steve C	4881d32c80	[`pylint`] - remove AugAssign errors from `self-cls-assignment` (`W0642`) (#12957 )	2024-08-18 15:31:09 +00:00
Steve C	81a2220ce1	[`pylint`] - Allow `__new__` methods to have `cls` as their first argument even if decorated with `@staticmethod` for `bad-staticmethod-argument` (`PLW0211`) (#12958 )	2024-08-18 16:30:22 +01:00
Aaron Gokaslan	900e98b584	Fix CHANGELOG.md typo (#12955 )	2024-08-17 17:43:07 +01:00
Alex Waygood	f9d8189670	[`perflint`] Improve docs for `try-except-in-loop` (`PERF203`) (#12947 )	2024-08-17 16:00:15 +01:00
TomerBin	52ba94191a	[`ruff`] Reduce FastAPI false positives in `unused-async` (`RUF029`) (#12938 )	2024-08-17 14:25:14 +00:00
Micha Reiser	96802d6a7f	[`pep8-naming`] Don't flag `from` imports following conventional import names (`N817`) (#12946 ) Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>	2024-08-17 12:05:42 +00:00
Micha Reiser	dd0a7ec73e	Pull all types in corpus tests (#12919 )	2024-08-17 11:59:55 +00:00
Daniel Sonbolian	25f5ae44c4	[flake8_bugbear] message based on expression location [B015] (#12944 )	2024-08-17 13:54:19 +02:00
Alex Waygood	251efe5c41	[`ruff`] Ignore `fstring-missing-syntax` (`RUF027`) for `fastAPI` paths (#12939 ) ## Summary As suggested by @MichaReiser in https://github.com/astral-sh/ruff/pull/12886#pullrequestreview-2237679793, this adds an exemption to `RUF027` for `fastAPI` paths, which require template strings rather than eagerly evaluated f-strings. ## Test Plan I added a fixture that causes Ruff to emit a false-positive error on `main` but no longer does with this PR.	2024-08-17 11:10:34 +01:00
Carl Meyer	6359e55383	[red-knot] type narrowing (#12706 ) Extend the `UseDefMap` to also track which constraints (provided by e.g. `if` tests) apply to each visible definition. Uses a custom `BitSet` and `BitSetArray` to track which constraints apply to which definitions, while keeping data inline as much as possible.	2024-08-16 16:34:13 -07:00