Add methods to iter over format spec elements

Add Iterator impl for StringLike parts
2024-05-13 14:17:23 +05:30 · 2024-05-13 13:48:54 +05:30
400 changed files with 4388 additions and 10132 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,10 +1,3 @@
 [alias]
 dev = "run --package ruff_dev --bin ruff_dev"
 benchmark = "bench -p ruff_benchmark --bench linter --bench formatter --"
-
-# statically link the C runtime so the executable does not depend on
-# that shared/dynamic library.
-#
-# See: https://github.com/astral-sh/ruff/issues/11503
-[target.'cfg(all(target_env="msvc", target_os = "windows"))']
-rustflags = ["-C", "target-feature=+crt-static"]
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -15,6 +15,3 @@

 # Script for fuzzing the parser
 /scripts/fuzz-parser/ @AlexWaygood
-
-# red-knot
-/crates/red_knot/ @carljm @MichaReiser
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -167,9 +167,6 @@ jobs:
      - uses: Swatinem/rust-cache@v2
      - name: "Run tests"
        shell: bash
-        env:
-          # Workaround for <https://github.com/nextest-rs/nextest/issues/1493>.
-          RUSTUP_WINDOWS_PATH_ADD_BIN: 1
        run: |
          cargo nextest run --all-features --profile ci
          cargo test --all-features --doc
--- a/.github/workflows/sync_typeshed.yaml
+++ b/.github/workflows/sync_typeshed.yaml
@@ -1,80 +0,0 @@
-name: Sync typeshed
-
-on:
-  workflow_dispatch:
-  schedule:
-    # Run on the 1st and the 15th of every month:
-    - cron: "0 0 1,15 * *"
-
-env:
-  FORCE_COLOR: 1
-  GH_TOKEN: ${{ github.token }}
-
-jobs:
-  sync:
-    name: Sync typeshed
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    # Don't run the cron job on forks:
-    if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        name: Checkout Ruff
-        with:
-          path: ruff
-      - uses: actions/checkout@v4
-        name: Checkout typeshed
-        with:
-          repository: python/typeshed
-          path: typeshed
-      - name: Setup git
-        run: |
-          git config --global user.name typeshedbot
-          git config --global user.email '<>'
-      - name: Sync typeshed
-        id: sync
-        run: |
-          rm -rf ruff/crates/red_knot/vendor/typeshed
-          mkdir ruff/crates/red_knot/vendor/typeshed
-          cp typeshed/README.md ruff/crates/red_knot/vendor/typeshed
-          cp typeshed/LICENSE ruff/crates/red_knot/vendor/typeshed
-          cp -r typeshed/stdlib ruff/crates/red_knot/vendor/typeshed/stdlib
-          rm -rf ruff/crates/red_knot/vendor/typeshed/stdlib/@tests
-          git -C typeshed rev-parse HEAD > ruff/crates/red_knot/vendor/typeshed/source_commit.txt
-      - name: Commit the changes
-        id: commit
-        if: ${{ steps.sync.outcome == 'success' }}
-        run: |
-          cd ruff
-          git checkout -b typeshedbot/sync-typeshed
-          git add .
-          git diff --staged --quiet || git commit -m "Sync typeshed. Source commit: https://github.com/python/typeshed/commit/$(git -C ../typeshed rev-parse HEAD)"
-      - name: Create a PR
-        if: ${{ steps.sync.outcome == 'success' && steps.commit.outcome == 'success' }}
-        run: |
-          cd ruff
-          git push --force origin typeshedbot/sync-typeshed
-          gh pr list --repo $GITHUB_REPOSITORY --head typeshedbot/sync-typeshed --json id --jq length | grep 1 && exit 0 # exit if there is existing pr
-          gh pr create --title "Sync vendored typeshed stubs" --body "Close and reopen this PR to trigger CI" --label "internal"
-
-  create-issue-on-failure:
-    name: Create an issue if the typeshed sync failed
-    runs-on: ubuntu-latest
-    needs: [sync]
-    if: ${{ github.repository == 'astral-sh/ruff' && always() && github.event_name == 'schedule' && needs.sync.result == 'failure' }}
-    permissions:
-      issues: write
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            await github.rest.issues.create({
-              owner: "astral-sh",
-              repo: "ruff",
-              title: `Automated typeshed sync failed on ${new Date().toDateString()}`,
-              body: "Runs are listed here: https://github.com/astral-sh/ruff/actions/workflows/sync_typeshed.yaml",
-            })
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -1,5 +0,0 @@
-{
-    "recommendations": [
-        "rust-lang.rust-analyzer"
-    ]
-}
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,6 +0,0 @@
-{
-    "rust-analyzer.check.extraArgs": [
-        "--all-features"
-    ],
-    "rust-analyzer.check.command": "clippy",
-}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,130 +1,5 @@
 # Changelog

-## 0.4.7
-
-### Preview features
-
- \[`flake8-pyi`\] Implement `PYI064` ([#11325](https://github.com/astral-sh/ruff/pull/11325))
- \[`flake8-pyi`\] Implement `PYI066` ([#11541](https://github.com/astral-sh/ruff/pull/11541))
- \[`flake8-pyi`\] Implement `PYI057` ([#11486](https://github.com/astral-sh/ruff/pull/11486))
- \[`pyflakes`\] Add option to enable F822 in `__init__.py` files ([#11370](https://github.com/astral-sh/ruff/pull/11370))
-
-### Formatter
-
- Fix incorrect placement of trailing stub function comments ([#11632](https://github.com/astral-sh/ruff/pull/11632))
-
-### Server
-
- Respect file exclusions in `ruff server` ([#11590](https://github.com/astral-sh/ruff/pull/11590))
- Add support for documents not exist on disk ([#11588](https://github.com/astral-sh/ruff/pull/11588))
- Add Vim and Kate setup guide for `ruff server` ([#11615](https://github.com/astral-sh/ruff/pull/11615))
-
-### Bug fixes
-
- Avoid removing newlines between docstring headers and rST blocks ([#11609](https://github.com/astral-sh/ruff/pull/11609))
- Infer indentation with imports when logical indent is absent ([#11608](https://github.com/astral-sh/ruff/pull/11608))
- Use char index rather than position for indent slice ([#11645](https://github.com/astral-sh/ruff/pull/11645))
- \[`flake8-comprehension`\] Strip parentheses around generators in `C400` ([#11607](https://github.com/astral-sh/ruff/pull/11607))
- Mark `repeated-isinstance-calls` as unsafe on Python 3.10 and later ([#11622](https://github.com/astral-sh/ruff/pull/11622))
-
-## 0.4.6
-
-### Breaking changes
-
- Use project-relative paths when calculating GitLab fingerprints ([#11532](https://github.com/astral-sh/ruff/pull/11532))
- Bump minimum supported Windows version to Windows 10 ([#11613](https://github.com/astral-sh/ruff/pull/11613))
-
-### Preview features
-
- \[`flake8-async`\] Sleep with >24 hour interval should usually sleep forever (`ASYNC116`) ([#11498](https://github.com/astral-sh/ruff/pull/11498))
-
-### Rule changes
-
- \[`numpy`\] Add missing functions to NumPy 2.0 migration rule ([#11528](https://github.com/astral-sh/ruff/pull/11528))
- \[`mccabe`\] Consider irrefutable pattern similar to `if .. else` for `C901` ([#11565](https://github.com/astral-sh/ruff/pull/11565))
- Consider `match`-`case` statements for `C901`, `PLR0912`, and `PLR0915` ([#11521](https://github.com/astral-sh/ruff/pull/11521))
- Remove empty strings when converting to f-string (`UP032`) ([#11524](https://github.com/astral-sh/ruff/pull/11524))
- \[`flake8-bandit`\] `request-without-timeout` should warn for `requests.request` ([#11548](https://github.com/astral-sh/ruff/pull/11548))
- \[`flake8-self`\] Ignore sunder accesses in `flake8-self` rules ([#11546](https://github.com/astral-sh/ruff/pull/11546))
- \[`pyupgrade`\] Lint for `TypeAliasType` usages (`UP040`) ([#11530](https://github.com/astral-sh/ruff/pull/11530))
-
-### Server
-
- Respect excludes in `ruff server` configuration discovery ([#11551](https://github.com/astral-sh/ruff/pull/11551))
- Use default settings if initialization options is empty or not provided ([#11566](https://github.com/astral-sh/ruff/pull/11566))
- `ruff server` correctly treats `.pyi` files as stub files ([#11535](https://github.com/astral-sh/ruff/pull/11535))
- `ruff server` searches for configuration in parent directories ([#11537](https://github.com/astral-sh/ruff/pull/11537))
- `ruff server`: An empty code action filter no longer returns notebook source actions ([#11526](https://github.com/astral-sh/ruff/pull/11526))
-
-### Bug fixes
-
- \[`flake8-logging-format`\] Fix autofix title in `logging-warn` (`G010`) ([#11514](https://github.com/astral-sh/ruff/pull/11514))
- \[`refurb`\] Avoid recommending `operator.itemgetter` with dependence on lambda arguments ([#11574](https://github.com/astral-sh/ruff/pull/11574))
- \[`flake8-simplify`\] Avoid recommending context manager in `__enter__` implementations ([#11575](https://github.com/astral-sh/ruff/pull/11575))
- Create intermediary directories for `--output-file` ([#11550](https://github.com/astral-sh/ruff/pull/11550))
- Propagate reads on global variables ([#11584](https://github.com/astral-sh/ruff/pull/11584))
- Treat all `singledispatch` arguments as runtime-required ([#11523](https://github.com/astral-sh/ruff/pull/11523))
-
-## 0.4.5
-
-### Ruff's language server is now in Beta
-
-`v0.4.5` marks the official Beta release of `ruff server`, an integrated language server built into Ruff.
-`ruff server` supports the same feature set as `ruff-lsp`, powering linting, formatting, and
-code fixes in Ruff's editor integrations -- but with superior performance and
-no installation required. We'd love your feedback!
-
-You can enable `ruff server` in the [VS Code extension](https://github.com/astral-sh/ruff-vscode?tab=readme-ov-file#enabling-the-rust-based-language-server) today.
-
-To read more about this exciting milestone, check out our [blog post](https://astral.sh/blog/ruff-v0.4.5)!
-
-### Rule changes
-
- \[`flake8-future-annotations`\] Reword `future-rewritable-type-annotation` (`FA100`) message ([#11381](https://github.com/astral-sh/ruff/pull/11381))
- \[`pycodestyle`\] Consider soft keywords for `E27` rules ([#11446](https://github.com/astral-sh/ruff/pull/11446))
- \[`pyflakes`\] Recommend adding unused import bindings to `__all__` ([#11314](https://github.com/astral-sh/ruff/pull/11314))
- \[`pyflakes`\] Update documentation and deprecate `ignore_init_module_imports` ([#11436](https://github.com/astral-sh/ruff/pull/11436))
- \[`pyupgrade`\] Mark quotes as unnecessary for non-evaluated annotations ([#11485](https://github.com/astral-sh/ruff/pull/11485))
-
-### Formatter
-
- Avoid multiline quotes warning with `quote-style = preserve` ([#11490](https://github.com/astral-sh/ruff/pull/11490))
-
-### Server
-
- Support Jupyter Notebook files ([#11206](https://github.com/astral-sh/ruff/pull/11206))
- Support `noqa` comment code actions ([#11276](https://github.com/astral-sh/ruff/pull/11276))
- Fix automatic configuration reloading ([#11492](https://github.com/astral-sh/ruff/pull/11492))
- Fix several issues with configuration in Neovim and Helix ([#11497](https://github.com/astral-sh/ruff/pull/11497))
-
-### CLI
-
- Add `--output-format` as a CLI option for `ruff config` ([#11438](https://github.com/astral-sh/ruff/pull/11438))
-
-### Bug fixes
-
- Avoid `PLE0237` for property with setter ([#11377](https://github.com/astral-sh/ruff/pull/11377))
- Avoid `TCH005` for `if` stmt with `elif`/`else` block ([#11376](https://github.com/astral-sh/ruff/pull/11376))
- Avoid flagging `__future__` annotations as required for non-evaluated type annotations ([#11414](https://github.com/astral-sh/ruff/pull/11414))
- Check for ruff executable in 'bin' directory as installed by 'pip install --target'. ([#11450](https://github.com/astral-sh/ruff/pull/11450))
- Sort edits prior to deduplicating in quotation fix ([#11452](https://github.com/astral-sh/ruff/pull/11452))
- Treat escaped newline as valid sequence ([#11465](https://github.com/astral-sh/ruff/pull/11465))
- \[`flake8-pie`\] Preserve parentheses in `unnecessary-dict-kwargs` ([#11372](https://github.com/astral-sh/ruff/pull/11372))
- \[`pylint`\] Ignore `__slots__` with dynamic values ([#11488](https://github.com/astral-sh/ruff/pull/11488))
- \[`pylint`\] Remove `try` body from branch counting ([#11487](https://github.com/astral-sh/ruff/pull/11487))
- \[`refurb`\] Respect operator precedence in `FURB110` ([#11464](https://github.com/astral-sh/ruff/pull/11464))
-
-### Documentation
-
- Add `--preview` to the README ([#11395](https://github.com/astral-sh/ruff/pull/11395))
- Add Python 3.13 to list of allowed Python versions ([#11411](https://github.com/astral-sh/ruff/pull/11411))
- Simplify Neovim setup documentation ([#11489](https://github.com/astral-sh/ruff/pull/11489))
- Update CONTRIBUTING.md to reflect the new parser ([#11434](https://github.com/astral-sh/ruff/pull/11434))
- Update server documentation with new migration guide ([#11499](https://github.com/astral-sh/ruff/pull/11499))
- \[`pycodestyle`\] Clarify motivation for `E713` and `E714` ([#11483](https://github.com/astral-sh/ruff/pull/11483))
- \[`pyflakes`\] Update docs to describe WAI behavior (F541) ([#11362](https://github.com/astral-sh/ruff/pull/11362))
- \[`pylint`\] Clearly indicate what is counted as a branch ([#11423](https://github.com/astral-sh/ruff/pull/11423))
-
 ## 0.4.4

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

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

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

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

@@ -639,11 +637,11 @@ Otherwise, follow the instructions from the linux section.
 `cargo dev` is a shortcut for `cargo run --package ruff_dev --bin ruff_dev`. You can run some useful
 utils with it:

- `cargo dev print-ast <file>`: Print the AST of a python file using Ruff's
-    [Python parser](https://github.com/astral-sh/ruff/tree/main/crates/ruff_python_parser).
-    For `if True: pass # comment`, you can see the syntax tree, the byte offsets for start and
-    stop of each node and also how the `:` token, the comment and whitespace are not represented
-    anymore:
+- `cargo dev print-ast <file>`: Print the AST of a python file using the
+    [RustPython parser](https://github.com/astral-sh/ruff/tree/main/crates/ruff_python_parser) that is
+    mainly used in Ruff. For `if True: pass # comment`, you can see the syntax tree, the byte offsets
+    for start and stop of each node and also how the `:` token, the comment and whitespace are not
+    represented anymore:

 ```text
 [
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -129,9 +129,9 @@ dependencies = [

 [[package]]
 name = "anyhow"
-version = "1.0.86"
+version = "1.0.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
+checksum = "25bdb32cbbdce2b519a9cd7df3a678443100e265d5e25ca763b7572a5104f5f3"

 [[package]]
 name = "argfile"
@@ -886,6 +886,12 @@ version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"

+[[package]]
+name = "hexf-parse"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
+
 [[package]]
 name = "home"
 version = "0.5.9"
@@ -1171,10 +1177,40 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
-name = "libc"
-version = "0.2.155"
+name = "lexical-parse-float"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "683b3a5ebd0130b8fb52ba0bdc718cc56815b6a097e28ae5a6997d0ad17dc05f"
+dependencies = [
+ "lexical-parse-integer",
+ "lexical-util",
+ "static_assertions",
+]
+
+[[package]]
+name = "lexical-parse-integer"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d0994485ed0c312f6d965766754ea177d07f9c00c9b82a5ee62ed5b47945ee9"
+dependencies = [
+ "lexical-util",
+ "static_assertions",
+]
+
+[[package]]
+name = "lexical-util"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5255b9ff16ff898710eb9eb63cb39248ea8a5bb036bea8085b1a767ff6c4e3fc"
+dependencies = [
+ "static_assertions",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.154"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae743338b92ff9146ce83992f766a31066a91a8c84a45e0e9f21e7cf6de6d346"

 [[package]]
 name = "libcst"
@@ -1203,9 +1239,9 @@ dependencies = [

 [[package]]
 name = "libmimalloc-sys"
-version = "0.1.38"
+version = "0.1.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e7bb23d733dfcc8af652a78b7bf232f0e967710d044732185e561e47c0336b6"
+checksum = "81eb4061c0582dedea1cbc7aff2240300dd6982e0239d1c99e65c1dbf4a30ba7"
 dependencies = [
 "cc",
 "libc",
@@ -1264,7 +1300,8 @@ dependencies = [
 [[package]]
 name = "lsp-types"
 version = "0.95.1"
-source = "git+https://github.com/astral-sh/lsp-types.git?rev=3512a9f#3512a9f33eadc5402cfab1b8f7340824c8ca1439"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e34d33a8e9b006cd3fc4fe69a921affa097bae4bb65f76271f4644f9a334365"
 dependencies = [
 "bitflags 1.3.2",
 "serde",
@@ -1302,9 +1339,9 @@ checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"

 [[package]]
 name = "mimalloc"
-version = "0.1.42"
+version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9186d86b79b52f4a77af65604b51225e8db1d6ee7e3f41aec1e40829c71a176"
+checksum = "9f41a2280ded0da56c8cf898babb86e8f10651a34adcfff190ae9a1159c6908d"
 dependencies = [
 "libmimalloc-sys",
 ]
@@ -1461,9 +1498,9 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"

 [[package]]
 name = "parking_lot"
-version = "0.12.3"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
+checksum = "7e4af0ca4f6caed20e900d564c242b8e5d4903fdacf31d3daf527b66fe6f42fb"
 dependencies = [
 "lock_api",
 "parking_lot_core",
@@ -1670,9 +1707,9 @@ dependencies = [

 [[package]]
 name = "proc-macro2"
-version = "1.0.84"
+version = "1.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec96c6a92621310b51366f1e28d05ef11489516e93be030060e5fc12024a49d6"
+checksum = "8ad3d49ab951a01fbaafe34f2ec74122942fe18a3f9814c3268f1bb72042131b"
 dependencies = [
 "unicode-ident",
 ]
@@ -1903,7 +1940,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.4.7"
+version = "0.4.4"
 dependencies = [
 "anyhow",
 "argfile",
@@ -2064,7 +2101,7 @@ dependencies = [

 [[package]]
 name = "ruff_linter"
-version = "0.4.7"
+version = "0.4.4"
 dependencies = [
 "aho-corasick",
 "annotate-snippets 0.9.2",
@@ -2241,7 +2278,9 @@ name = "ruff_python_literal"
 version = "0.0.0"
 dependencies = [
 "bitflags 2.5.0",
+ "hexf-parse",
 "itertools 0.12.1",
+ "lexical-parse-float",
 "ruff_python_ast",
 "unic-ucd-category",
 ]
@@ -2329,7 +2368,6 @@ version = "0.2.2"
 dependencies = [
 "anyhow",
 "crossbeam",
- "globset",
 "insta",
 "jod-thread",
 "libc",
@@ -2339,7 +2377,6 @@ dependencies = [
 "ruff_diagnostics",
 "ruff_formatter",
 "ruff_linter",
- "ruff_notebook",
 "ruff_python_ast",
 "ruff_python_codegen",
 "ruff_python_formatter",
@@ -2518,9 +2555,9 @@ dependencies = [

 [[package]]
 name = "schemars"
-version = "0.8.21"
+version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09c024468a378b7e36765cd36702b7a90cc3cba11654f6685c8f233408e89e92"
+checksum = "fc6e7ed6919cb46507fb01ff1654309219f62b4d603822501b0b80d42f6f21ef"
 dependencies = [
 "dyn-clone",
 "schemars_derive",
@@ -2530,9 +2567,9 @@ dependencies = [

 [[package]]
 name = "schemars_derive"
-version = "0.8.21"
+version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1eee588578aff73f856ab961cd2f79e36bc45d7ded33a7562adba4667aecc0e"
+checksum = "185f2b7aa7e02d418e453790dde16890256bbd2bcd04b7dc5348811052b53f49"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2560,9 +2597,9 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"

 [[package]]
 name = "serde"
-version = "1.0.203"
+version = "1.0.201"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
+checksum = "780f1cebed1629e4753a1a38a3c72d30b97ec044f0aef68cb26650a3c5cf363c"
 dependencies = [
 "serde_derive",
 ]
@@ -2580,9 +2617,9 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.203"
+version = "1.0.201"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
+checksum = "c5e405930b9796f1c00bee880d03fc7e0bb4b9a11afc776885ffe84320da2865"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2707,9 +2744,9 @@ checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"

 [[package]]
 name = "smol_str"
-version = "0.2.2"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead"
+checksum = "e6845563ada680337a52d43bb0b29f396f2d911616f6573012645b9e3d048a49"
 dependencies = [
 "serde",
 ]
@@ -2777,9 +2814,9 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"

 [[package]]
 name = "syn"
-version = "2.0.66"
+version = "2.0.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c42f3f41a2de00b01c0aaad383c5a45241efc8b2d1eda5661812fda5f3cdcff5"
+checksum = "bf5be731623ca1a1fb7d8be6f261a3be6d3e2337b8a1f97be944d020c8fcb704"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2867,18 +2904,18 @@ dependencies = [

 [[package]]
 name = "thiserror"
-version = "1.0.61"
+version = "1.0.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+checksum = "579e9083ca58dd9dcf91a9923bb9054071b9ebbd800b342194c9feb0ee89fc18"
 dependencies = [
 "thiserror-impl",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "1.0.61"
+version = "1.0.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+checksum = "e2470041c06ec3ac1ab38d0356a6119054dedaea53e12fbefc0de730a1c08524"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,28 +12,6 @@ authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
 license = "MIT"

 [workspace.dependencies]
-ruff = { path = "crates/ruff" }
-ruff_cache = { path = "crates/ruff_cache" }
-ruff_diagnostics = { path = "crates/ruff_diagnostics" }
-ruff_formatter = { path = "crates/ruff_formatter" }
-ruff_index = { path = "crates/ruff_index" }
-ruff_linter = { path = "crates/ruff_linter" }
-ruff_macros = { path = "crates/ruff_macros" }
-ruff_notebook = { path = "crates/ruff_notebook" }
-ruff_python_ast = { path = "crates/ruff_python_ast" }
-ruff_python_codegen = { path = "crates/ruff_python_codegen" }
-ruff_python_formatter = { path = "crates/ruff_python_formatter" }
-ruff_python_index = { path = "crates/ruff_python_index" }
-ruff_python_literal = { path = "crates/ruff_python_literal" }
-ruff_python_parser = { path = "crates/ruff_python_parser" }
-ruff_python_semantic = { path = "crates/ruff_python_semantic" }
-ruff_python_stdlib = { path = "crates/ruff_python_stdlib" }
-ruff_python_trivia = { path = "crates/ruff_python_trivia" }
-ruff_server = { path = "crates/ruff_server" }
-ruff_source_file = { path = "crates/ruff_source_file" }
-ruff_text_size = { path = "crates/ruff_text_size" }
-ruff_workspace = { path = "crates/ruff_workspace" }
-
 aho-corasick = { version = "1.1.3" }
 annotate-snippets = { version = "0.9.2", features = ["color"] }
 anyhow = { version = "1.0.80" }
@@ -62,6 +40,7 @@ filetime = { version = "0.2.23" }
 glob = { version = "0.3.1" }
 globset = { version = "0.4.14" }
 hashbrown = "0.14.3"
+hexf-parse = { version = "0.2.1" }
 ignore = { version = "0.4.22" }
 imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
@@ -75,11 +54,12 @@ is-wsl = { version = "0.4.0" }
 itertools = { version = "0.12.1" }
 js-sys = { version = "0.3.69" }
 jod-thread = { version = "0.1.2" }
+lexical-parse-float = { version = "0.8.0", features = ["format"] }
 libc = { version = "0.2.153" }
 libcst = { version = "1.1.0", default-features = false }
 log = { version = "0.4.17" }
 lsp-server = { version = "0.7.6" }
-lsp-types = { git = "https://github.com/astral-sh/lsp-types.git", rev = "3512a9f", features = ["proposed"] }
+lsp-types = { version = "0.95.0", features = ["proposed"] }
 matchit = { version = "0.8.1" }
 memchr = { version = "2.7.1" }
 mimalloc = { version = "0.1.39" }
--- a/README.md
+++ b/README.md
@@ -152,7 +152,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
  # Ruff version.
-  rev: v0.4.7
+  rev: v0.4.4
  hooks:
    # Run the linter.
    - id: ruff
@@ -266,11 +266,6 @@ The remaining configuration options can be provided through a catch-all `--confi
 ruff check --config "lint.per-file-ignores = {'some_file.py' = ['F841']}"
 ```

-To opt in to the latest lint rules, formatter style changes, interface updates, and more, enable
-[preview mode](https://docs.astral.sh/ruff/rules/) by setting `preview = true` in your configuration
-file or passing `--preview` on the command line. Preview mode enables a collection of unstable
-features that may change prior to stabilization.
-
 See `ruff help` for more on Ruff's top-level commands, or `ruff help check` and `ruff help format`
 for more on the linting and formatting commands, respectively.

@@ -408,7 +403,6 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [Dagster](https://github.com/dagster-io/dagster)
 - Databricks ([MLflow](https://github.com/mlflow/mlflow))
 - [FastAPI](https://github.com/tiangolo/fastapi)
- [Godot](https://github.com/godotengine/godot)
 - [Gradio](https://github.com/gradio-app/gradio)
 - [Great Expectations](https://github.com/great-expectations/great_expectations)
 - [HTTPX](https://github.com/encode/httpx)
@@ -434,7 +428,6 @@ Ruff is used by a number of major open-source projects and companies, including:
 - Modern Treasury ([Python SDK](https://github.com/Modern-Treasury/modern-treasury-python))
 - Mozilla ([Firefox](https://github.com/mozilla/gecko-dev))
 - [Mypy](https://github.com/python/mypy)
- [Nautobot](https://github.com/nautobot/nautobot)
 - Netflix ([Dispatch](https://github.com/Netflix/dispatch))
 - [Neon](https://github.com/neondatabase/neon)
 - [Nokia](https://nokia.com/)
--- a/crates/red_knot/Cargo.toml
+++ b/crates/red_knot/Cargo.toml
@@ -12,11 +12,11 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-ruff_python_parser = { workspace = true }
-ruff_python_ast = { workspace = true }
-ruff_text_size = { workspace = true }
-ruff_index = { workspace = true }
-ruff_notebook = { workspace = true }
+ruff_python_parser = { path = "../ruff_python_parser" }
+ruff_python_ast = { path = "../ruff_python_ast" }
+ruff_text_size = { path = "../ruff_text_size" }
+ruff_index = { path = "../ruff_index" }
+ruff_notebook = { path = "../ruff_notebook" }

 anyhow = { workspace = true }
 bitflags = { workspace = true }
--- a/crates/red_knot/README.md
+++ b/crates/red_knot/README.md
@@ -6,4 +6,13 @@ The Red Knot crate contains code working towards multifile analysis, type infere

 Red Knot vendors [typeshed](https://github.com/python/typeshed)'s stubs for the standard library. The vendored stubs can be found in `crates/red_knot/vendor/typeshed`. The file `crates/red_knot/vendor/typeshed/source_commit.txt` tells you the typeshed commit that our vendored stdlib stubs currently correspond to.

-The typeshed stubs are updated every two weeks via an automated PR using the `sync_typeshed.yaml` workflow in the `.github/workflows` directory. This workflow can also be triggered at any time via [workflow dispatch](https://docs.github.com/en/actions/using-workflows/manually-running-a-workflow#running-a-workflow).
+Updating the vendored stubs is currently done manually. On a Unix machine, follow the following steps (if you have a typeshed clone in a `typeshed` directory, and a Ruff clone in a `ruff` directory):
+
+```shell
+rm -rf ruff/crates/red_knot/vendor/typeshed
+mkdir ruff/crates/red_knot/vendor/typeshed
+cp typeshed/README.md ruff/crates/red_knot/vendor/typeshed
+cp typeshed/LICENSE ruff/crates/red_knot/vendor/typeshed
+cp -r typeshed/stdlib ruff/crates/red_knot/vendor/typeshed/stdlib
+git -C typeshed rev-parse HEAD > ruff/crates/red_knot/vendor/typeshed/source_commit.txt
+```
--- a/crates/red_knot/src/ast_ids.rs
+++ b/crates/red_knot/src/ast_ids.rs
@@ -275,7 +275,10 @@ pub struct TypedNodeKey<N: AstNode> {

 impl<N: AstNode> TypedNodeKey<N> {
    pub fn from_node(node: &N) -> Self {
-        let inner = NodeKey::from_node(node.as_any_node_ref());
+        let inner = NodeKey {
+            kind: node.as_any_node_ref().kind(),
+            range: node.range(),
+        };
        Self {
            inner,
            _marker: PhantomData,
@@ -349,12 +352,6 @@ pub struct NodeKey {
 }

 impl NodeKey {
-    pub fn from_node(node: AnyNodeRef) -> Self {
-        NodeKey {
-            kind: node.kind(),
-            range: node.range(),
-        }
-    }
    pub fn resolve<'a>(&self, root: AnyNodeRef<'a>) -> Option<AnyNodeRef<'a>> {
        // We need to do a binary search here. Only traverse into a node if the range is withint the node
        let mut visitor = FindNodeKeyVisitor {
--- a/crates/red_knot/src/module.rs
+++ b/crates/red_knot/src/module.rs
@@ -12,15 +12,11 @@ use crate::files::FileId;
 use crate::symbols::Dependency;
 use crate::FxDashMap;

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

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

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

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

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

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

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

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

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

@@ -179,10 +159,9 @@ impl std::fmt::Display for ModuleName {

 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
 pub enum ModuleKind {
-    /// A single-file module (e.g. `foo.py` or `foo.pyi`)
    Module,

-    /// A python package (`foo/__init__.py` or `foo/__init__.pyi`)
+    /// A python package (a `__init__.py` or `__init__.pyi` file)
    Package,
 }

@@ -202,12 +181,10 @@ impl ModuleSearchPath {
        }
    }

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

-    /// Return the location of the search path on the file system
    pub fn path(&self) -> &Path {
        &self.inner.path
    }
@@ -254,11 +231,9 @@ pub struct ModuleData {
 // Queries
 //////////////////////////////////////////////////////

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

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

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

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

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

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

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

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

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

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

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

        // Path has been inserted by `resolved`
-        Ok(Some(module))
+        Ok(Some(module_id))
    } else {
        // This path is for a module with the same name but in a module search path with a lower priority.
        // Ignore it.
@@ -394,22 +369,19 @@ pub fn set_module_search_paths(db: &mut dyn SemanticDb, search_paths: Vec<Module
    jar.module_resolver = ModuleResolver::new(search_paths);
 }

-/// Adds a module located at `path` to the resolver.
+/// Adds a module to the resolver.
 ///
 /// Returns `None` if the path doesn't resolve to a module.
 ///
-/// Returns `Some(module, other_modules)`, where `module` is the resolved module
-/// with file location `path`, and `other_modules` is a `Vec` of `ModuleData` instances.
-/// Each element in `other_modules` provides information regarding a single module that needs
-/// re-resolving because it was part of a namespace package and might now resolve differently.
-///
+/// Returns `Some` with the id of the module and the ids of the modules that need re-resolving
+/// because they were part of a namespace package and might now resolve differently.
 /// Note: This won't work with salsa because `Path` is not an ingredient.
 pub fn add_module(db: &mut dyn SemanticDb, path: &Path) -> Option<(Module, Vec<Arc<ModuleData>>)> {
    // No locking is required because we're holding a mutable reference to `modules`.

    // TODO This needs tests

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

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

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

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

    Some((module, removed))
@@ -464,10 +436,10 @@ pub struct ModuleResolver {

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

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

    /// Lookup from absolute path to module.
@@ -487,27 +459,24 @@ impl ModuleResolver {
        }
    }

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

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

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

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

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

-        module_data
+        module
    }
 }

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

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

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

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

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

    /// A sub-package in a namespace package. A namespace package is a package without an `__init__.py`.
--- a/crates/red_knot/src/program/mod.rs
+++ b/crates/red_knot/src/program/mod.rs
@@ -42,7 +42,7 @@ impl Program {

        let (source, semantic, lint) = self.jars_mut();
        for change in aggregated_changes.iter() {
-            semantic.module_resolver.remove_module_by_file(change.id);
+            semantic.module_resolver.remove_module(change.id);
            semantic.symbol_tables.remove(&change.id);
            source.sources.remove(&change.id);
            source.parsed.remove(&change.id);
--- a/crates/red_knot/src/symbols.rs
+++ b/crates/red_knot/src/symbols.rs
@@ -236,7 +236,6 @@ pub struct SymbolTable {
    scopes_by_node: FxHashMap<NodeKey, ScopeId>,
    /// dependencies of this module
    dependencies: Vec<Dependency>,
-    flow_graph: FlowGraph,
 }

 impl SymbolTable {
@@ -246,7 +245,6 @@ impl SymbolTable {
            table: SymbolTable::new(),
            scopes: vec![root_scope_id],
            current_definition: None,
-            current_flow_node: FlowGraph::start(),
        };
        builder.visit_body(&module.body);
        builder.table
@@ -259,7 +257,6 @@ impl SymbolTable {
            defs: FxHashMap::default(),
            scopes_by_node: FxHashMap::default(),
            dependencies: Vec::new(),
-            flow_graph: FlowGraph::new(),
        };
        table.scopes_by_id.push(Scope {
            name: Name::new("<module>"),
@@ -277,23 +274,6 @@ impl SymbolTable {
        &self.dependencies
    }

-    /// Return an iterator over all definitions of `symbol_id` reachable from `use_expr`. The value
-    /// of `symbol_id` in `use_expr` must originate from one of the iterated definitions (or from
-    /// an external reassignment of the name outside of this scope).
-    pub(crate) fn reachable_definitions(
-        &self,
-        symbol_id: SymbolId,
-        use_expr: &ast::Expr,
-    ) -> ReachableDefinitionsIterator {
-        let node_key = NodeKey::from_node(use_expr.into());
-        let flow_node_id = self.flow_graph.ast_to_flow[&node_key];
-        ReachableDefinitionsIterator {
-            table: self,
-            flow_node_id,
-            symbol_id,
-        }
-    }
-
    pub(crate) const fn root_scope_id() -> ScopeId {
        ScopeId::from_usize(0)
    }
@@ -543,72 +523,11 @@ where
    }
 }

-pub(crate) struct ReachableDefinitionsIterator<'a> {
-    table: &'a SymbolTable,
-    flow_node_id: FlowNodeId,
-    symbol_id: SymbolId,
-}
-
-impl<'a> Iterator for ReachableDefinitionsIterator<'a> {
-    type Item = Definition;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            match &self.table.flow_graph.flow_nodes_by_id[self.flow_node_id] {
-                FlowNode::Start => return None,
-                FlowNode::Definition(def_node) => {
-                    self.flow_node_id = def_node.predecessor;
-                    if def_node.symbol_id == self.symbol_id {
-                        return Some(def_node.definition.clone());
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl<'a> FusedIterator for ReachableDefinitionsIterator<'a> {}
-
-#[newtype_index]
-struct FlowNodeId;
-
-#[derive(Debug)]
-enum FlowNode {
-    Start,
-    Definition(DefinitionFlowNode),
-}
-
-#[derive(Debug)]
-struct DefinitionFlowNode {
-    symbol_id: SymbolId,
-    definition: Definition,
-    predecessor: FlowNodeId,
-}
-
-#[derive(Debug, Default)]
-struct FlowGraph {
-    flow_nodes_by_id: IndexVec<FlowNodeId, FlowNode>,
-    ast_to_flow: FxHashMap<NodeKey, FlowNodeId>,
-}
-
-impl FlowGraph {
-    fn new() -> Self {
-        let mut graph = FlowGraph::default();
-        graph.flow_nodes_by_id.push(FlowNode::Start);
-        graph
-    }
-
-    fn start() -> FlowNodeId {
-        FlowNodeId::from_usize(0)
-    }
-}
-
 struct SymbolTableBuilder {
    table: SymbolTable,
    scopes: Vec<ScopeId>,
    /// the definition whose target(s) we are currently walking
    current_definition: Option<Definition>,
-    current_flow_node: FlowNodeId,
 }

 impl SymbolTableBuilder {
@@ -627,16 +546,7 @@ impl SymbolTableBuilder {
            .defs
            .entry(symbol_id)
            .or_default()
-            .push(definition.clone());
-        self.current_flow_node = self
-            .table
-            .flow_graph
-            .flow_nodes_by_id
-            .push(FlowNode::Definition(DefinitionFlowNode {
-                definition,
-                symbol_id,
-                predecessor: self.current_flow_node,
-            }));
+            .push(definition);
        symbol_id
    }

@@ -651,7 +561,6 @@ impl SymbolTableBuilder {
            self.table
                .add_child_scope(self.cur_scope(), name, kind, definition, defining_symbol);
        self.scopes.push(scope_id);
-        self.current_flow_node = FlowGraph::start();
        scope_id
    }

@@ -715,10 +624,6 @@ impl PreorderVisitor<'_> for SymbolTableBuilder {
                }
            }
        }
-        self.table
-            .flow_graph
-            .ast_to_flow
-            .insert(NodeKey::from_node(expr.into()), self.current_flow_node);
        ast::visitor::preorder::walk_expr(self, expr);
    }

@@ -861,13 +766,15 @@ impl DerefMut for SymbolTablesStorage {

 #[cfg(test)]
 mod tests {
-    use crate::symbols::{ScopeKind, SymbolFlags, SymbolTable};
+    use textwrap::dedent;
+
+    use crate::parse::Parsed;
+    use crate::symbols::ScopeKind;
+
+    use super::{SymbolFlags, SymbolId, SymbolIterator, SymbolTable};

    mod from_ast {
-        use crate::parse::Parsed;
-        use crate::symbols::{Definition, ScopeKind, SymbolId, SymbolIterator, SymbolTable};
-        use ruff_python_ast as ast;
-        use textwrap::dedent;
+        use super::*;

        fn parse(code: &str) -> Parsed {
            Parsed::from_text(&dedent(code))
@@ -1114,35 +1021,6 @@ mod tests {
            assert_eq!(func_scope.name(), "C");
            assert_eq!(names(table.symbols_for_scope(func_scope_id)), vec!["x"]);
        }
-
-        #[test]
-        fn reachability_trivial() {
-            let parsed = parse("x = 1; x");
-            let ast = parsed.ast();
-            let table = SymbolTable::from_ast(ast);
-            let x_sym = table
-                .root_symbol_id_by_name("x")
-                .expect("x symbol should exist");
-            let ast::Stmt::Expr(ast::StmtExpr { value: x_use, .. }) = &ast.body[1] else {
-                panic!("should be an expr")
-            };
-            let x_defs: Vec<_> = table.reachable_definitions(x_sym, x_use).collect();
-            assert_eq!(x_defs.len(), 1);
-            let Definition::Assignment(node_key) = &x_defs[0] else {
-                panic!("def should be an assignment")
-            };
-            let Some(def_node) = node_key.resolve(ast.into()) else {
-                panic!("node key should resolve")
-            };
-            let ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
-                value: ast::Number::Int(num),
-                ..
-            }) = &*def_node.value
-            else {
-                panic!("should be a number literal")
-            };
-            assert_eq!(*num, 1);
-        }
    }

    #[test]
--- a/crates/red_knot/src/types.rs
+++ b/crates/red_knot/src/types.rs
@@ -2,10 +2,7 @@
 use crate::ast_ids::NodeKey;
 use crate::db::{QueryResult, SemanticDb, SemanticJar};
 use crate::files::FileId;
-use crate::module::{Module, ModuleName};
-use crate::symbols::{
-    resolve_global_symbol, symbol_table, GlobalSymbolId, ScopeId, ScopeKind, SymbolId,
-};
+use crate::symbols::{symbol_table, GlobalSymbolId, ScopeId, ScopeKind, SymbolId};
 use crate::{FxDashMap, FxIndexSet, Name};
 use ruff_index::{newtype_index, IndexVec};
 use rustc_hash::FxHashMap;
@@ -28,15 +25,12 @@ pub enum Type {
    Unbound,
    /// a specific function object
    Function(FunctionTypeId),
-    /// a specific module object
-    Module(ModuleTypeId),
    /// a specific class object
    Class(ClassTypeId),
    /// the set of Python objects with the given class in their __class__'s method resolution order
    Instance(ClassTypeId),
    Union(UnionTypeId),
    Intersection(IntersectionTypeId),
-    IntLiteral(i64),
    // TODO protocols, callable types, overloads, generics, type vars
 }

@@ -52,39 +46,6 @@ impl Type {
    pub const fn is_unknown(&self) -> bool {
        matches!(self, Type::Unknown)
    }
-
-    pub fn get_member(&self, db: &dyn SemanticDb, name: &Name) -> QueryResult<Option<Type>> {
-        match self {
-            Type::Any => todo!("attribute lookup on Any type"),
-            Type::Never => todo!("attribute lookup on Never type"),
-            Type::Unknown => todo!("attribute lookup on Unknown type"),
-            Type::Unbound => todo!("attribute lookup on Unbound type"),
-            Type::Function(_) => todo!("attribute lookup on Function type"),
-            Type::Module(module_id) => module_id.get_member(db, name),
-            Type::Class(class_id) => class_id.get_class_member(db, name),
-            Type::Instance(_) => {
-                // TODO MRO? get_own_instance_member, get_instance_member
-                todo!("attribute lookup on Instance type")
-            }
-            Type::Union(union_id) => {
-                let jar: &SemanticJar = db.jar()?;
-                let _todo_union_ref = jar.type_store.get_union(*union_id);
-                // TODO perform the get_member on each type in the union
-                // TODO return the union of those results
-                // TODO if any of those results is `None` then include Unknown in the result union
-                todo!("attribute lookup on Union type")
-            }
-            Type::Intersection(_) => {
-                // TODO perform the get_member on each type in the intersection
-                // TODO return the intersection of those results
-                todo!("attribute lookup on Intersection type")
-            }
-            Type::IntLiteral(_) => {
-                // TODO raise error
-                Ok(Some(Type::Unknown))
-            }
-        }
-    }
 }

 impl From<FunctionTypeId> for Type {
@@ -375,31 +336,6 @@ impl FunctionTypeId {
    }
 }

-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-pub struct ModuleTypeId {
-    module: Module,
-    file_id: FileId,
-}
-
-impl ModuleTypeId {
-    fn module(self, db: &dyn SemanticDb) -> QueryResult<ModuleStoreRef> {
-        let jar: &SemanticJar = db.jar()?;
-        Ok(jar.type_store.add_or_get_module(self.file_id).downgrade())
-    }
-
-    pub(crate) fn name(self, db: &dyn SemanticDb) -> QueryResult<ModuleName> {
-        self.module.name(db)
-    }
-
-    fn get_member(self, db: &dyn SemanticDb, name: &Name) -> QueryResult<Option<Type>> {
-        if let Some(symbol_id) = resolve_global_symbol(db, self.name(db)?, name)? {
-            Ok(Some(infer_symbol_type(db, symbol_id)?))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
 pub struct ClassTypeId {
    file_id: FileId,
@@ -453,13 +389,7 @@ impl ClassTypeId {
        }
    }

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

 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
@@ -599,10 +529,6 @@ impl std::fmt::Display for DisplayType<'_> {
            Type::Never => f.write_str("Never"),
            Type::Unknown => f.write_str("Unknown"),
            Type::Unbound => f.write_str("Unbound"),
-            Type::Module(module_id) => {
-                // NOTE: something like this?: "<module 'module-name' from 'path-from-fileid'>"
-                todo!("{module_id:?}")
-            }
            // TODO functions and classes should display using a fully qualified name
            Type::Class(class_id) => {
                f.write_str("Literal[")?;
@@ -621,7 +547,6 @@ impl std::fmt::Display for DisplayType<'_> {
                .get_module(int_id.file_id)
                .get_intersection(int_id.intersection_id)
                .display(f, self.store),
-            Type::IntLiteral(n) => write!(f, "Literal[{n}]"),
        }
    }
 }
--- a/crates/red_knot/src/types/infer.rs
+++ b/crates/red_knot/src/types/infer.rs
@@ -5,14 +5,13 @@ use ruff_python_ast::AstNode;

 use crate::db::{QueryResult, SemanticDb, SemanticJar};

-use crate::module::{resolve_module, ModuleName};
+use crate::module::ModuleName;
 use crate::parse::parse;
 use crate::symbols::{
-    resolve_global_symbol, symbol_table, Definition, GlobalSymbolId, ImportDefinition,
-    ImportFromDefinition,
+    resolve_global_symbol, symbol_table, Definition, GlobalSymbolId, ImportFromDefinition,
 };
-use crate::types::{ModuleTypeId, Type};
-use crate::{FileId, Name};
+use crate::types::Type;
+use crate::FileId;

 // FIXME: Figure out proper dead-lock free synchronisation now that this takes `&db` instead of `&mut db`.
 #[tracing::instrument(level = "trace", skip(db))]
@@ -47,15 +46,6 @@ pub fn infer_definition_type(
    let file_id = symbol.file_id;

    match definition {
-        Definition::Import(ImportDefinition {
-            module: module_name,
-        }) => {
-            if let Some(module) = resolve_module(db, module_name.clone())? {
-                Ok(Type::Module(ModuleTypeId { module, file_id }))
-            } else {
-                Ok(Type::Unknown)
-            }
-        }
        Definition::ImportFrom(ImportFromDefinition {
            module,
            name,
@@ -124,20 +114,10 @@ pub fn infer_definition_type(
            let parsed = parse(db.upcast(), file_id)?;
            let ast = parsed.ast();
            let node = node_key.resolve_unwrap(ast.as_any_node_ref());
-            // TODO handle unpacking assignment correctly (here and for AnnotatedAssignment case, below)
+            // TODO handle unpacking assignment correctly
            infer_expr_type(db, file_id, &node.value)
        }
-        Definition::AnnotatedAssignment(node_key) => {
-            let parsed = parse(db.upcast(), file_id)?;
-            let ast = parsed.ast();
-            let node = node_key.resolve_unwrap(ast.as_any_node_ref());
-            // TODO actually look at the annotation
-            let Some(value) = &node.value else {
-                return Ok(Type::Unknown);
-            };
-            // TODO handle unpacking assignment correctly (here and for Assignment case, above)
-            infer_expr_type(db, file_id, value)
-        }
+        _ => todo!("other kinds of definitions"),
    }
 }

@@ -145,16 +125,6 @@ fn infer_expr_type(db: &dyn SemanticDb, file_id: FileId, expr: &ast::Expr) -> Qu
    // TODO cache the resolution of the type on the node
    let symbols = symbol_table(db, file_id)?;
    match expr {
-        ast::Expr::NumberLiteral(ast::ExprNumberLiteral { value, .. }) => {
-            match value {
-                ast::Number::Int(n) => {
-                    // TODO support big int literals
-                    Ok(n.as_i64().map(Type::IntLiteral).unwrap_or(Type::Unknown))
-                }
-                // TODO builtins.float or builtins.complex
-                _ => Ok(Type::Unknown),
-            }
-        }
        ast::Expr::Name(name) => {
            // TODO look up in the correct scope, don't assume global
            if let Some(symbol_id) = symbols.root_symbol_id_by_name(&name.id) {
@@ -163,13 +133,6 @@ fn infer_expr_type(db: &dyn SemanticDb, file_id: FileId, expr: &ast::Expr) -> Qu
                Ok(Type::Unknown)
            }
        }
-        ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
-            let value_type = infer_expr_type(db, file_id, value)?;
-            let attr_name = &Name::new(&attr.id);
-            value_type
-                .get_member(db, attr_name)
-                .map(|ty| ty.unwrap_or(Type::Unknown))
-        }
        _ => todo!("full expression type resolution"),
    }
 }
@@ -326,66 +289,4 @@ mod tests {

        Ok(())
    }
-
-    #[test]
-    fn resolve_module_member() -> anyhow::Result<()> {
-        let case = create_test()?;
-        let db = &case.db;
-
-        let a_path = case.src.path().join("a.py");
-        let b_path = case.src.path().join("b.py");
-        std::fs::write(a_path, "import b; D = b.C")?;
-        std::fs::write(b_path, "class C: pass")?;
-        let a_file = resolve_module(db, ModuleName::new("a"))?
-            .expect("module should be found")
-            .path(db)?
-            .file();
-        let a_syms = symbol_table(db, a_file)?;
-        let d_sym = a_syms
-            .root_symbol_id_by_name("D")
-            .expect("D symbol should be found");
-
-        let ty = infer_symbol_type(
-            db,
-            GlobalSymbolId {
-                file_id: a_file,
-                symbol_id: d_sym,
-            },
-        )?;
-
-        let jar = HasJar::<SemanticJar>::jar(db)?;
-        assert!(matches!(ty, Type::Class(_)));
-        assert_eq!(format!("{}", ty.display(&jar.type_store)), "Literal[C]");
-        Ok(())
-    }
-
-    #[test]
-    fn resolve_literal() -> anyhow::Result<()> {
-        let case = create_test()?;
-        let db = &case.db;
-
-        let path = case.src.path().join("a.py");
-        std::fs::write(path, "x = 1")?;
-        let file = resolve_module(db, ModuleName::new("a"))?
-            .expect("module should be found")
-            .path(db)?
-            .file();
-        let syms = symbol_table(db, file)?;
-        let x_sym = syms
-            .root_symbol_id_by_name("x")
-            .expect("x symbol should be found");
-
-        let ty = infer_symbol_type(
-            db,
-            GlobalSymbolId {
-                file_id: file,
-                symbol_id: x_sym,
-            },
-        )?;
-
-        let jar = HasJar::<SemanticJar>::jar(db)?;
-        assert!(matches!(ty, Type::IntLiteral(_)));
-        assert_eq!(format!("{}", ty.display(&jar.type_store)), "Literal[1]");
-        Ok(())
-    }
 }
--- a/crates/red_knot/vendor/typeshed/source_commit.txt
+++ b/crates/red_knot/vendor/typeshed/source_commit.txt
@@ -1 +1 @@
-a9d7e861f7a46ae7acd56569326adef302e10f29
+2d33fe212221a05661c0db5215a91cf3d7b7f072
--- a/crates/red_knot/vendor/typeshed/stdlib/_typeshed/importlib.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/_typeshed/importlib.pyi
@@ -1,18 +0,0 @@
-# Implicit protocols used in importlib.
-# We intentionally omit deprecated and optional methods.
-
-from collections.abc import Sequence
-from importlib.machinery import ModuleSpec
-from types import ModuleType
-from typing import Protocol
-
-__all__ = ["LoaderProtocol", "MetaPathFinderProtocol", "PathEntryFinderProtocol"]
-
-class LoaderProtocol(Protocol):
-    def load_module(self, fullname: str, /) -> ModuleType: ...
-
-class MetaPathFinderProtocol(Protocol):
-    def find_spec(self, fullname: str, path: Sequence[str] | None, target: ModuleType | None = ..., /) -> ModuleSpec | None: ...
-
-class PathEntryFinderProtocol(Protocol):
-    def find_spec(self, fullname: str, target: ModuleType | None = ..., /) -> ModuleSpec | None: ...
--- a/crates/red_knot/vendor/typeshed/stdlib/builtins.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/builtins.pyi
@@ -31,7 +31,7 @@ from _typeshed import (
 )
 from collections.abc import Awaitable, Callable, Iterable, Iterator, MutableSet, Reversible, Set as AbstractSet, Sized
 from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
-from types import CellType, CodeType, TracebackType
+from types import CodeType, TracebackType, _Cell

 # mypy crashes if any of {ByteString, Sequence, MutableSequence, Mapping, MutableMapping} are imported from collections.abc in builtins.pyi
 from typing import (  # noqa: Y022
@@ -951,7 +951,7 @@ class tuple(Sequence[_T_co]):
 class function:
    # Make sure this class definition stays roughly in line with `types.FunctionType`
    @property
-    def __closure__(self) -> tuple[CellType, ...] | None: ...
+    def __closure__(self) -> tuple[_Cell, ...] | None: ...
    __code__: CodeType
    __defaults__: tuple[Any, ...] | None
    __dict__: dict[str, Any]
@@ -1333,7 +1333,7 @@ if sys.version_info >= (3, 11):
        locals: Mapping[str, object] | None = None,
        /,
        *,
-        closure: tuple[CellType, ...] | None = None,
+        closure: tuple[_Cell, ...] | None = None,
    ) -> None: ...

 else:
@@ -1794,7 +1794,7 @@ def __import__(
    fromlist: Sequence[str] = (),
    level: int = 0,
 ) -> types.ModuleType: ...
-def __build_class__(func: Callable[[], CellType | Any], name: str, /, *bases: Any, metaclass: Any = ..., **kwds: Any) -> Any: ...
+def __build_class__(func: Callable[[], _Cell | Any], name: str, /, *bases: Any, metaclass: Any = ..., **kwds: Any) -> Any: ...

 if sys.version_info >= (3, 10):
    from types import EllipsisType
--- a/crates/red_knot/vendor/typeshed/stdlib/dbm/init.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/dbm/init.pyi
@@ -1,5 +1,3 @@
-import sys
-from _typeshed import StrOrBytesPath
 from collections.abc import Iterator, MutableMapping
 from types import TracebackType
 from typing import Literal
@@ -93,10 +91,5 @@ class _error(Exception): ...

 error: tuple[type[_error], type[OSError]]

-if sys.version_info >= (3, 11):
-    def whichdb(filename: StrOrBytesPath) -> str | None: ...
-    def open(file: StrOrBytesPath, flag: _TFlags = "r", mode: int = 0o666) -> _Database: ...
-
-else:
-    def whichdb(filename: str) -> str | None: ...
-    def open(file: str, flag: _TFlags = "r", mode: int = 0o666) -> _Database: ...
+def whichdb(filename: str) -> str | None: ...
+def open(file: str, flag: _TFlags = "r", mode: int = 0o666) -> _Database: ...
--- a/crates/red_knot/vendor/typeshed/stdlib/dbm/dumb.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/dbm/dumb.pyi
@@ -1,5 +1,3 @@
-import sys
-from _typeshed import StrOrBytesPath
 from collections.abc import Iterator, MutableMapping
 from types import TracebackType
 from typing_extensions import Self, TypeAlias
@@ -30,8 +28,4 @@ class _Database(MutableMapping[_KeyType, bytes]):
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...

-if sys.version_info >= (3, 11):
-    def open(file: StrOrBytesPath, flag: str = "c", mode: int = 0o666) -> _Database: ...
-
-else:
-    def open(file: str, flag: str = "c", mode: int = 0o666) -> _Database: ...
+def open(file: str, flag: str = "c", mode: int = 0o666) -> _Database: ...
--- a/crates/red_knot/vendor/typeshed/stdlib/dbm/gnu.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/dbm/gnu.pyi
@@ -1,5 +1,5 @@
 import sys
-from _typeshed import ReadOnlyBuffer, StrOrBytesPath
+from _typeshed import ReadOnlyBuffer
 from types import TracebackType
 from typing import TypeVar, overload
 from typing_extensions import Self, TypeAlias
@@ -38,7 +38,4 @@ if sys.platform != "win32":
        __new__: None  # type: ignore[assignment]
        __init__: None  # type: ignore[assignment]

-    if sys.version_info >= (3, 11):
-        def open(filename: StrOrBytesPath, flags: str = "r", mode: int = 0o666, /) -> _gdbm: ...
-    else:
-        def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _gdbm: ...
+    def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _gdbm: ...
--- a/crates/red_knot/vendor/typeshed/stdlib/dbm/ndbm.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/dbm/ndbm.pyi
@@ -1,5 +1,5 @@
 import sys
-from _typeshed import ReadOnlyBuffer, StrOrBytesPath
+from _typeshed import ReadOnlyBuffer
 from types import TracebackType
 from typing import TypeVar, overload
 from typing_extensions import Self, TypeAlias
@@ -34,7 +34,4 @@ if sys.platform != "win32":
        __new__: None  # type: ignore[assignment]
        __init__: None  # type: ignore[assignment]

-    if sys.version_info >= (3, 11):
-        def open(filename: StrOrBytesPath, flags: str = "r", mode: int = 0o666, /) -> _dbm: ...
-    else:
-        def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _dbm: ...
+    def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _dbm: ...
--- a/crates/red_knot/vendor/typeshed/stdlib/importlib/abc.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/importlib/abc.pyi
@@ -64,7 +64,7 @@ class SourceLoader(ResourceLoader, ExecutionLoader, metaclass=ABCMeta):

 # The base classes differ starting in 3.10:
 if sys.version_info >= (3, 10):
-    # Please keep in sync with _typeshed.importlib.MetaPathFinderProtocol
+    # Please keep in sync with sys._MetaPathFinder
    class MetaPathFinder(metaclass=ABCMeta):
        if sys.version_info < (3, 12):
            def find_module(self, fullname: str, path: Sequence[str] | None) -> Loader | None: ...
@@ -85,7 +85,7 @@ if sys.version_info >= (3, 10):
        def find_spec(self, fullname: str, target: types.ModuleType | None = ...) -> ModuleSpec | None: ...

 else:
-    # Please keep in sync with _typeshed.importlib.MetaPathFinderProtocol
+    # Please keep in sync with sys._MetaPathFinder
    class MetaPathFinder(Finder):
        def find_module(self, fullname: str, path: Sequence[str] | None) -> Loader | None: ...
        def invalidate_caches(self) -> None: ...
--- a/crates/red_knot/vendor/typeshed/stdlib/importlib/util.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/importlib/util.pyi
@@ -3,7 +3,6 @@ import importlib.machinery
 import sys
 import types
 from _typeshed import ReadableBuffer, StrOrBytesPath
-from _typeshed.importlib import LoaderProtocol
 from collections.abc import Callable
 from typing import Any
 from typing_extensions import ParamSpec
@@ -24,13 +23,13 @@ def source_from_cache(path: str) -> str: ...
 def decode_source(source_bytes: ReadableBuffer) -> str: ...
 def find_spec(name: str, package: str | None = None) -> importlib.machinery.ModuleSpec | None: ...
 def spec_from_loader(
-    name: str, loader: LoaderProtocol | None, *, origin: str | None = None, is_package: bool | None = None
+    name: str, loader: importlib.abc.Loader | None, *, origin: str | None = None, is_package: bool | None = None
 ) -> importlib.machinery.ModuleSpec | None: ...
 def spec_from_file_location(
    name: str,
    location: StrOrBytesPath | None = None,
    *,
-    loader: LoaderProtocol | None = None,
+    loader: importlib.abc.Loader | None = None,
    submodule_search_locations: list[str] | None = ...,
 ) -> importlib.machinery.ModuleSpec | None: ...
 def module_from_spec(spec: importlib.machinery.ModuleSpec) -> types.ModuleType: ...
--- a/crates/red_knot/vendor/typeshed/stdlib/pkgutil.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/pkgutil.pyi
@@ -1,7 +1,7 @@
 import sys
 from _typeshed import SupportsRead
-from _typeshed.importlib import LoaderProtocol, MetaPathFinderProtocol, PathEntryFinderProtocol
 from collections.abc import Callable, Iterable, Iterator
+from importlib.abc import Loader, MetaPathFinder, PathEntryFinder
 from typing import IO, Any, NamedTuple, TypeVar
 from typing_extensions import deprecated

@@ -23,7 +23,7 @@ if sys.version_info < (3, 12):
 _PathT = TypeVar("_PathT", bound=Iterable[str])

 class ModuleInfo(NamedTuple):
-    module_finder: MetaPathFinderProtocol | PathEntryFinderProtocol
+    module_finder: MetaPathFinder | PathEntryFinder
    name: str
    ispkg: bool

@@ -37,11 +37,11 @@ if sys.version_info < (3, 12):
        def __init__(self, fullname: str, file: IO[str], filename: str, etc: tuple[str, str, int]) -> None: ...

@deprecated("Use importlib.util.find_spec() instead. Will be removed in Python 3.14.")
-def find_loader(fullname: str) -> LoaderProtocol | None: ...
-def get_importer(path_item: str) -> PathEntryFinderProtocol | None: ...
+def find_loader(fullname: str) -> Loader | None: ...
+def get_importer(path_item: str) -> PathEntryFinder | None: ...
@deprecated("Use importlib.util.find_spec() instead. Will be removed in Python 3.14.")
-def get_loader(module_or_name: str) -> LoaderProtocol | None: ...
-def iter_importers(fullname: str = "") -> Iterator[MetaPathFinderProtocol | PathEntryFinderProtocol]: ...
+def get_loader(module_or_name: str) -> Loader | None: ...
+def iter_importers(fullname: str = "") -> Iterator[MetaPathFinder | PathEntryFinder]: ...
 def iter_modules(path: Iterable[str] | None = None, prefix: str = "") -> Iterator[ModuleInfo]: ...
 def read_code(stream: SupportsRead[bytes]) -> Any: ...  # undocumented
 def walk_packages(
--- a/crates/red_knot/vendor/typeshed/stdlib/shelve.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/shelve.pyi
@@ -1,5 +1,3 @@
-import sys
-from _typeshed import StrOrBytesPath
 from collections.abc import Iterator, MutableMapping
 from dbm import _TFlags
 from types import TracebackType
@@ -43,17 +41,6 @@ class BsdDbShelf(Shelf[_VT]):
    def last(self) -> tuple[str, _VT]: ...

 class DbfilenameShelf(Shelf[_VT]):
-    if sys.version_info >= (3, 11):
-        def __init__(
-            self, filename: StrOrBytesPath, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False
-        ) -> None: ...
-    else:
-        def __init__(self, filename: str, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False) -> None: ...
+    def __init__(self, filename: str, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False) -> None: ...

-if sys.version_info >= (3, 11):
-    def open(
-        filename: StrOrBytesPath, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False
-    ) -> Shelf[Any]: ...
-
-else:
-    def open(filename: str, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False) -> Shelf[Any]: ...
+def open(filename: str, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False) -> Shelf[Any]: ...
--- a/crates/red_knot/vendor/typeshed/stdlib/socket.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/socket.pyi
@@ -474,13 +474,6 @@ if sys.version_info >= (3, 12):
            ETHERTYPE_VLAN as ETHERTYPE_VLAN,
        )

-    if sys.platform == "linux":
-        from _socket import ETH_P_ALL as ETH_P_ALL
-
-    if sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin":
-        # FreeBSD >= 14.0
-        from _socket import PF_DIVERT as PF_DIVERT
-
 # Re-exported from errno
 EBADF: int
 EAGAIN: int
@@ -532,9 +525,6 @@ class AddressFamily(IntEnum):
            AF_BLUETOOTH = 32
    if sys.platform == "win32" and sys.version_info >= (3, 12):
        AF_HYPERV = 34
-    if sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin" and sys.version_info >= (3, 12):
-        # FreeBSD >= 14.0
-        AF_DIVERT = 44

 AF_INET = AddressFamily.AF_INET
 AF_INET6 = AddressFamily.AF_INET6
@@ -587,9 +577,6 @@ if sys.platform != "win32" or sys.version_info >= (3, 9):

 if sys.platform == "win32" and sys.version_info >= (3, 12):
    AF_HYPERV = AddressFamily.AF_HYPERV
-if sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin" and sys.version_info >= (3, 12):
-    # FreeBSD >= 14.0
-    AF_DIVERT = AddressFamily.AF_DIVERT

 class SocketKind(IntEnum):
    SOCK_STREAM = 1
--- a/crates/red_knot/vendor/typeshed/stdlib/sys/init.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/sys/init.pyi
@@ -1,8 +1,9 @@
 import sys
 from _typeshed import OptExcInfo, ProfileFunction, TraceFunction, structseq
-from _typeshed.importlib import MetaPathFinderProtocol, PathEntryFinderProtocol
 from builtins import object as _object
 from collections.abc import AsyncGenerator, Callable, Sequence
+from importlib.abc import PathEntryFinder
+from importlib.machinery import ModuleSpec
 from io import TextIOWrapper
 from types import FrameType, ModuleType, TracebackType
 from typing import Any, Final, Literal, NoReturn, Protocol, TextIO, TypeVar, final
@@ -14,6 +15,10 @@ _T = TypeVar("_T")
 _ExitCode: TypeAlias = str | int | None
 _OptExcInfo: TypeAlias = OptExcInfo  # noqa: Y047  # TODO: obsolete, remove fall 2022 or later

+# Intentionally omits one deprecated and one optional method of `importlib.abc.MetaPathFinder`
+class _MetaPathFinder(Protocol):
+    def find_spec(self, fullname: str, path: Sequence[str] | None, target: ModuleType | None = ..., /) -> ModuleSpec | None: ...
+
 # ----- sys variables -----
 if sys.platform != "win32":
    abiflags: str
@@ -39,13 +44,13 @@ if sys.version_info >= (3, 12):
    last_exc: BaseException  # or undefined.
 maxsize: int
 maxunicode: int
-meta_path: list[MetaPathFinderProtocol]
+meta_path: list[_MetaPathFinder]
 modules: dict[str, ModuleType]
 if sys.version_info >= (3, 10):
    orig_argv: list[str]
 path: list[str]
-path_hooks: list[Callable[[str], PathEntryFinderProtocol]]
-path_importer_cache: dict[str, PathEntryFinderProtocol | None]
+path_hooks: list[Callable[[str], PathEntryFinder]]
+path_importer_cache: dict[str, PathEntryFinder | None]
 platform: str
 if sys.version_info >= (3, 9):
    platlibdir: str
--- a/crates/red_knot/vendor/typeshed/stdlib/tempfile.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/tempfile.pyi
@@ -374,11 +374,7 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
    def readlines(self, hint: int = ..., /) -> list[AnyStr]: ...  # type: ignore[override]
    def seek(self, offset: int, whence: int = ...) -> int: ...
    def tell(self) -> int: ...
-    if sys.version_info >= (3, 11):
-        def truncate(self, size: int | None = None) -> int: ...
-    else:
-        def truncate(self, size: int | None = None) -> None: ...  # type: ignore[override]
-
+    def truncate(self, size: int | None = None) -> None: ...  # type: ignore[override]
    @overload
    def write(self: SpooledTemporaryFile[str], s: str) -> int: ...
    @overload
--- a/crates/red_knot/vendor/typeshed/stdlib/types.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/types.pyi
@@ -1,6 +1,5 @@
 import sys
 from _typeshed import SupportsKeysAndGetItem
-from _typeshed.importlib import LoaderProtocol
 from collections.abc import (
    AsyncGenerator,
    Awaitable,
@@ -17,7 +16,7 @@ from collections.abc import (
 from importlib.machinery import ModuleSpec

 # pytype crashes if types.MappingProxyType inherits from collections.abc.Mapping instead of typing.Mapping
-from typing import Any, ClassVar, Literal, Mapping, TypeVar, final, overload  # noqa: Y022
+from typing import Any, ClassVar, Literal, Mapping, Protocol, TypeVar, final, overload  # noqa: Y022
 from typing_extensions import ParamSpec, Self, TypeVarTuple, deprecated

 __all__ = [
@@ -65,11 +64,18 @@ _T2 = TypeVar("_T2")
 _KT = TypeVar("_KT")
 _VT_co = TypeVar("_VT_co", covariant=True)

+@final
+class _Cell:
+    def __new__(cls, contents: object = ..., /) -> Self: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    cell_contents: Any
+
 # Make sure this class definition stays roughly in line with `builtins.function`
@final
 class FunctionType:
    @property
-    def __closure__(self) -> tuple[CellType, ...] | None: ...
+    def __closure__(self) -> tuple[_Cell, ...] | None: ...
    __code__: CodeType
    __defaults__: tuple[Any, ...] | None
    __dict__: dict[str, Any]
@@ -92,7 +98,7 @@ class FunctionType:
        globals: dict[str, Any],
        name: str | None = ...,
        argdefs: tuple[object, ...] | None = ...,
-        closure: tuple[CellType, ...] | None = ...,
+        closure: tuple[_Cell, ...] | None = ...,
    ) -> Self: ...
    def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
    @overload
@@ -312,12 +318,15 @@ class SimpleNamespace:
    def __setattr__(self, name: str, value: Any, /) -> None: ...
    def __delattr__(self, name: str, /) -> None: ...

+class _LoaderProtocol(Protocol):
+    def load_module(self, fullname: str, /) -> ModuleType: ...
+
 class ModuleType:
    __name__: str
    __file__: str | None
    @property
    def __dict__(self) -> dict[str, Any]: ...  # type: ignore[override]
-    __loader__: LoaderProtocol | None
+    __loader__: _LoaderProtocol | None
    __package__: str | None
    __path__: MutableSequence[str]
    __spec__: ModuleSpec | None
@@ -327,12 +336,6 @@ class ModuleType:
    # using `builtins.__import__` or `importlib.import_module` less painful
    def __getattr__(self, name: str) -> Any: ...

-@final
-class CellType:
-    def __new__(cls, contents: object = ..., /) -> Self: ...
-    __hash__: ClassVar[None]  # type: ignore[assignment]
-    cell_contents: Any
-
 _YieldT_co = TypeVar("_YieldT_co", covariant=True)
 _SendT_contra = TypeVar("_SendT_contra", contravariant=True)
 _ReturnT_co = TypeVar("_ReturnT_co", covariant=True)
@@ -402,7 +405,7 @@ class CoroutineType(Coroutine[_YieldT_co, _SendT_contra, _ReturnT_co]):
@final
 class MethodType:
    @property
-    def __closure__(self) -> tuple[CellType, ...] | None: ...  # inherited from the added function
+    def __closure__(self) -> tuple[_Cell, ...] | None: ...  # inherited from the added function
    @property
    def __defaults__(self) -> tuple[Any, ...] | None: ...  # inherited from the added function
    @property
@@ -567,6 +570,8 @@ def coroutine(func: Callable[_P, Generator[Any, Any, _R]]) -> Callable[_P, Await
@overload
 def coroutine(func: _Fn) -> _Fn: ...

+CellType = _Cell
+
 if sys.version_info >= (3, 9):
    class GenericAlias:
        @property
--- a/crates/red_knot/vendor/typeshed/stdlib/typing.pyi
+++ b/crates/red_knot/vendor/typeshed/stdlib/typing.pyi
@@ -8,6 +8,7 @@ import typing_extensions
 from _collections_abc import dict_items, dict_keys, dict_values
 from _typeshed import IdentityFunction, ReadableBuffer, SupportsKeysAndGetItem
 from abc import ABCMeta, abstractmethod
+from contextlib import AbstractAsyncContextManager, AbstractContextManager
 from re import Match as Match, Pattern as Pattern
 from types import (
    BuiltinFunctionType,
@@ -23,10 +24,10 @@ from types import (
 )
 from typing_extensions import Never as _Never, ParamSpec as _ParamSpec

-if sys.version_info >= (3, 9):
-    from types import GenericAlias
 if sys.version_info >= (3, 10):
    from types import UnionType
+if sys.version_info >= (3, 9):
+    from types import GenericAlias

 __all__ = [
    "AbstractSet",
@@ -401,8 +402,8 @@ class Reversible(Iterable[_T_co], Protocol[_T_co]):
    def __reversed__(self) -> Iterator[_T_co]: ...

 _YieldT_co = TypeVar("_YieldT_co", covariant=True)
-_SendT_contra = TypeVar("_SendT_contra", contravariant=True, default=None)
-_ReturnT_co = TypeVar("_ReturnT_co", covariant=True, default=None)
+_SendT_contra = TypeVar("_SendT_contra", contravariant=True)
+_ReturnT_co = TypeVar("_ReturnT_co", covariant=True)

 class Generator(Iterator[_YieldT_co], Generic[_YieldT_co, _SendT_contra, _ReturnT_co]):
    def __next__(self) -> _YieldT_co: ...
@@ -427,28 +428,24 @@ class Generator(Iterator[_YieldT_co], Generic[_YieldT_co, _SendT_contra, _Return
    @property
    def gi_yieldfrom(self) -> Generator[Any, Any, Any] | None: ...

-# NOTE: Prior to Python 3.13 these aliases are lacking the second _ExitT_co parameter
-if sys.version_info >= (3, 13):
-    from contextlib import AbstractAsyncContextManager as AsyncContextManager, AbstractContextManager as ContextManager
-else:
-    from contextlib import AbstractAsyncContextManager, AbstractContextManager
+# NOTE: Technically we would like this to be able to accept a second parameter as well, just
+#   like it's counterpart in contextlib, however `typing._SpecialGenericAlias` enforces the
+#   correct number of arguments at runtime, so we would be hiding runtime errors.
+@runtime_checkable
+class ContextManager(AbstractContextManager[_T_co, bool | None], Protocol[_T_co]): ...

-    @runtime_checkable
-    class ContextManager(AbstractContextManager[_T_co, bool | None], Protocol[_T_co]): ...
-
-    @runtime_checkable
-    class AsyncContextManager(AbstractAsyncContextManager[_T_co, bool | None], Protocol[_T_co]): ...
+# NOTE: Technically we would like this to be able to accept a second parameter as well, just
+#   like it's counterpart in contextlib, however `typing._SpecialGenericAlias` enforces the
+#   correct number of arguments at runtime, so we would be hiding runtime errors.
+@runtime_checkable
+class AsyncContextManager(AbstractAsyncContextManager[_T_co, bool | None], Protocol[_T_co]): ...

@runtime_checkable
 class Awaitable(Protocol[_T_co]):
    @abstractmethod
    def __await__(self) -> Generator[Any, Any, _T_co]: ...

-# Non-default variations to accommodate couroutines, and `AwaitableGenerator` having a 4th type parameter.
-_SendT_contra_nd = TypeVar("_SendT_contra_nd", contravariant=True)
-_ReturnT_co_nd = TypeVar("_ReturnT_co_nd", covariant=True)
-
-class Coroutine(Awaitable[_ReturnT_co_nd], Generic[_YieldT_co, _SendT_contra_nd, _ReturnT_co_nd]):
+class Coroutine(Awaitable[_ReturnT_co], Generic[_YieldT_co, _SendT_contra, _ReturnT_co]):
    __name__: str
    __qualname__: str
    @property
@@ -460,7 +457,7 @@ class Coroutine(Awaitable[_ReturnT_co_nd], Generic[_YieldT_co, _SendT_contra_nd,
    @property
    def cr_running(self) -> bool: ...
    @abstractmethod
-    def send(self, value: _SendT_contra_nd, /) -> _YieldT_co: ...
+    def send(self, value: _SendT_contra, /) -> _YieldT_co: ...
    @overload
    @abstractmethod
    def throw(
@@ -476,9 +473,9 @@ class Coroutine(Awaitable[_ReturnT_co_nd], Generic[_YieldT_co, _SendT_contra_nd,
 # The parameters correspond to Generator, but the 4th is the original type.
@type_check_only
 class AwaitableGenerator(
-    Awaitable[_ReturnT_co_nd],
-    Generator[_YieldT_co, _SendT_contra_nd, _ReturnT_co_nd],
-    Generic[_YieldT_co, _SendT_contra_nd, _ReturnT_co_nd, _S],
+    Awaitable[_ReturnT_co],
+    Generator[_YieldT_co, _SendT_contra, _ReturnT_co],
+    Generic[_YieldT_co, _SendT_contra, _ReturnT_co, _S],
    metaclass=ABCMeta,
 ): ...

--- a/crates/ruff/Cargo.toml
+++ b/crates/ruff/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.4.7"
+version = "0.4.4"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -13,17 +13,17 @@ readme = "../../README.md"
 default-run = "ruff"

 [dependencies]
-ruff_cache = { workspace = true }
-ruff_diagnostics = { workspace = true }
-ruff_linter = { workspace = true, features = ["clap"] }
-ruff_macros = { workspace = true }
-ruff_notebook = { workspace = true }
-ruff_python_ast = { workspace = true }
-ruff_python_formatter = { workspace = true }
-ruff_server = { workspace = true }
-ruff_source_file = { workspace = true }
-ruff_text_size = { workspace = true }
-ruff_workspace = { workspace = true }
+ruff_cache = { path = "../ruff_cache" }
+ruff_diagnostics = { path = "../ruff_diagnostics" }
+ruff_linter = { path = "../ruff_linter", features = ["clap"] }
+ruff_macros = { path = "../ruff_macros" }
+ruff_notebook = { path = "../ruff_notebook" }
+ruff_python_ast = { path = "../ruff_python_ast" }
+ruff_python_formatter = { path = "../ruff_python_formatter" }
+ruff_server = { path = "../ruff_server" }
+ruff_source_file = { path = "../ruff_source_file" }
+ruff_text_size = { path = "../ruff_text_size" }
+ruff_workspace = { path = "../ruff_workspace" }

 anyhow = { workspace = true }
 argfile = { workspace = true }
@@ -60,7 +60,7 @@ wild = { workspace = true }

 [dev-dependencies]
 # Enable test rules during development
-ruff_linter = { workspace = true, features = ["clap", "test-rules"] }
+ruff_linter = { path = "../ruff_linter", features = ["clap", "test-rules"] }
 # Avoid writing colored snapshots when running tests from the terminal
 colored = { workspace = true, features = ["no-color"] }
 insta = { workspace = true, features = ["filters", "json"] }
--- a/crates/ruff/src/args.rs
+++ b/crates/ruff/src/args.rs
@@ -111,13 +111,7 @@ pub enum Command {
        output_format: HelpFormat,
    },
    /// List or describe the available configuration options.
-    Config {
-        /// Config key to show
-        option: Option<String>,
-        /// Output format
-        #[arg(long, value_enum, default_value = "text")]
-        output_format: HelpFormat,
-    },
+    Config { option: Option<String> },
    /// List all supported upstream linters.
    Linter {
        /// Output format
--- a/crates/ruff/src/commands/config.rs
+++ b/crates/ruff/src/commands/config.rs
@@ -1,38 +1,19 @@
 use anyhow::{anyhow, Result};

-use crate::args::HelpFormat;
-
 use ruff_workspace::options::Options;
 use ruff_workspace::options_base::OptionsMetadata;

 #[allow(clippy::print_stdout)]
-pub(crate) fn config(key: Option<&str>, format: HelpFormat) -> Result<()> {
+pub(crate) fn config(key: Option<&str>) -> Result<()> {
    match key {
-        None => {
-            let metadata = Options::metadata();
-            match format {
-                HelpFormat::Text => {
-                    println!("{metadata}");
-                }
-
-                HelpFormat::Json => {
-                    println!("{}", &serde_json::to_string_pretty(&metadata)?);
-                }
-            }
-        }
+        None => print!("{}", Options::metadata()),
        Some(key) => match Options::metadata().find(key) {
            None => {
                return Err(anyhow!("Unknown option: {key}"));
            }
-            Some(entry) => match format {
-                HelpFormat::Text => {
-                    print!("{entry}");
-                }
-
-                HelpFormat::Json => {
-                    println!("{}", &serde_json::to_string_pretty(&entry)?);
-                }
-            },
+            Some(entry) => {
+                print!("{entry}");
+            }
        },
    }
    Ok(())
--- a/crates/ruff/src/commands/format.rs
+++ b/crates/ruff/src/commands/format.rs
@@ -857,20 +857,12 @@ pub(super) fn warn_incompatible_formatter_settings(resolver: &Resolver) {

        if setting.linter.rules.enabled(Rule::BadQuotesMultilineString)
            && setting.linter.flake8_quotes.multiline_quotes == Quote::Single
-            && matches!(
-                setting.formatter.quote_style,
-                QuoteStyle::Single | QuoteStyle::Double
-            )
        {
            warn_user_once!("The `flake8-quotes.multiline-quotes=\"single\"` option is incompatible with the formatter. We recommend disabling `Q001` when using the formatter, which enforces double quotes for multiline strings. Alternatively, set the `flake8-quotes.multiline-quotes` option to `\"double\"`.`");
        }

        if setting.linter.rules.enabled(Rule::BadQuotesDocstring)
            && setting.linter.flake8_quotes.docstring_quotes == Quote::Single
-            && matches!(
-                setting.formatter.quote_style,
-                QuoteStyle::Single | QuoteStyle::Double
-            )
        {
            warn_user_once!("The `flake8-quotes.multiline-quotes=\"single\"` option is incompatible with the formatter. We recommend disabling `Q002` when using the formatter, which enforces double quotes for docstrings. Alternatively, set the `flake8-quotes.docstring-quotes` option to `\"double\"`.`");
        }
--- a/crates/ruff/src/lib.rs
+++ b/crates/ruff/src/lib.rs
@@ -180,11 +180,8 @@ pub fn run(
            }
            Ok(ExitStatus::Success)
        }
-        Command::Config {
-            option,
-            output_format,
-        } => {
-            commands::config::config(option.as_deref(), output_format)?;
+        Command::Config { option } => {
+            commands::config::config(option.as_deref())?;
            Ok(ExitStatus::Success)
        }
        Command::Linter { output_format } => {
@@ -237,9 +234,6 @@ pub fn check(args: CheckCommand, global_options: GlobalConfigArgs) -> Result<Exi
    let mut writer: Box<dyn Write> = match cli.output_file {
        Some(path) if !cli.watch => {
            colored::control::set_override(false);
-            if let Some(parent) = path.parent() {
-                std::fs::create_dir_all(parent)?;
-            }
            let file = File::create(path)?;
            Box::new(BufWriter::new(file))
        }
--- a/crates/ruff/tests/config.rs
+++ b/crates/ruff/tests/config.rs
@@ -1,55 +0,0 @@
-//! Tests for the `ruff config` subcommand.
-use std::process::Command;
-
-use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
-
-const BIN_NAME: &str = "ruff";
-
-#[test]
-fn lint_select() {
-    assert_cmd_snapshot!(
-        Command::new(get_cargo_bin(BIN_NAME)).arg("config").arg("lint.select"), @r###"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    A list of rule codes or prefixes to enable. Prefixes can specify exact
-    rules (like `F841`), entire categories (like `F`), or anything in
-    between.
-
-    When breaking ties between enabled and disabled rules (via `select` and
-    `ignore`, respectively), more specific prefixes override less
-    specific prefixes.
-
-    Default value: ["E4", "E7", "E9", "F"]
-    Type: list[RuleSelector]
-    Example usage:
-    ```toml
-    # On top of the defaults (`E4`, E7`, `E9`, and `F`), enable flake8-bugbear (`B`) and flake8-quotes (`Q`).
-    select = ["E4", "E7", "E9", "F", "B", "Q"]
-    ```
-
-    ----- stderr -----
-    "###
-    );
-}
-
-#[test]
-fn lint_select_json() {
-    assert_cmd_snapshot!(
-        Command::new(get_cargo_bin(BIN_NAME)).arg("config").arg("lint.select").arg("--output-format").arg("json"), @r###"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    {
-      "doc": "A list of rule codes or prefixes to enable. Prefixes can specify exact\nrules (like `F841`), entire categories (like `F`), or anything in\nbetween.\n\nWhen breaking ties between enabled and disabled rules (via `select` and\n`ignore`, respectively), more specific prefixes override less\nspecific prefixes.",
-      "default": "[\"E4\", \"E7\", \"E9\", \"F\"]",
-      "value_type": "list[RuleSelector]",
-      "scope": null,
-      "example": "# On top of the defaults (`E4`, E7`, `E9`, and `F`), enable flake8-bugbear (`B`) and flake8-quotes (`Q`).\nselect = [\"E4\", \"E7\", \"E9\", \"F\", \"B\", \"Q\"]",
-      "deprecated": null
-    }
-
-    ----- stderr -----
-    "###
-    );
-}
--- a/crates/ruff/tests/format.rs
+++ b/crates/ruff/tests/format.rs
@@ -1038,48 +1038,6 @@ def say_hy(name: str):
    Ok(())
 }

-#[test]
-fn valid_linter_options_preserve() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(
-        &ruff_toml,
-        r#"
-[lint]
-select = ["Q"]
-
-[lint.flake8-quotes]
-inline-quotes = "single"
-docstring-quotes = "single"
-multiline-quotes = "single"
-
-[format]
-quote-style = "preserve"
-"#,
-    )?;
-
-    let test_path = tempdir.path().join("test.py");
-    fs::write(
-        &test_path,
-        r#"
-def say_hy(name: str):
-        print(f"Hy {name}")"#,
-    )?;
-
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(["format", "--no-cache", "--config"])
-        .arg(&ruff_toml)
-        .arg(test_path), @r###"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    1 file reformatted
-
-    ----- stderr -----
-    "###);
-    Ok(())
-}
-
 #[test]
 fn all_rules_default_options() -> Result<()> {
    let tempdir = TempDir::new()?;
--- a/crates/ruff/tests/integration_test.rs
+++ b/crates/ruff/tests/integration_test.rs
@@ -1414,7 +1414,7 @@ fn check_input_from_argfile() -> Result<()> {
    fs::write(&file_a_path, b"import os")?;
    fs::write(&file_b_path, b"print('hello, world!')")?;

-    // Create the input file for argfile to expand
+    // Create a the input file for argfile to expand
    let input_file_path = tempdir.path().join("file_paths.txt");
    fs::write(
        &input_file_path,
--- a/crates/ruff/tests/snapshots/integration_test__rule_f401.snap
+++ b/crates/ruff/tests/snapshots/integration_test__rule_f401.snap
@@ -34,29 +34,12 @@ marking it as unused, as in:
 from module import member as member
 ```

-Alternatively, you can use `__all__` to declare a symbol as part of the module's
-interface, as in:
-
-```python
-# __init__.py
-import some_module
-
-__all__ = ["some_module"]
-```
-
 ## Fix safety

-Fixes to remove unused imports are safe, except in `__init__.py` files.
-
-Applying fixes to `__init__.py` files is currently in preview. The fix offered depends on the
-type of the unused import. Ruff will suggest a safe fix to export first-party imports with
-either a redundant alias or, if already present in the file, an `__all__` entry. If multiple
-`__all__` declarations are present, Ruff will not offer a fix. Ruff will suggest an unsafe fix
-to remove third-party and standard library imports -- the fix is unsafe because the module's
-interface changes.
+When `ignore_init_module_imports` is disabled, fixes can remove for unused imports in `__init__` files.
+These fixes are considered unsafe because they can change the public interface.

 ## Example
-
 ```python
 import numpy as np  # unused import

@@ -66,14 +49,12 @@ def area(radius):
 ```

 Use instead:
-
 ```python
 def area(radius):
    return 3.14 * radius**2
 ```

 To check the availability of a module, use `importlib.util.find_spec`:
-
 ```python
 from importlib.util import find_spec

--- a/crates/ruff_benchmark/Cargo.toml
+++ b/crates/ruff_benchmark/Cargo.toml
@@ -38,14 +38,14 @@ serde_json = { workspace = true }
 url = { workspace = true }
 ureq = { workspace = true }
 criterion = { workspace = true, default-features = false }
-codspeed-criterion-compat = { workspace = true, default-features = false, optional = true }
+codspeed-criterion-compat = { workspace = true, default-features = false, optional = true}

 [dev-dependencies]
-ruff_linter = { workspace = true }
-ruff_python_ast = { workspace = true }
-ruff_python_formatter = { workspace = true }
-ruff_python_index = { workspace = true }
-ruff_python_parser = { workspace = true }
+ruff_linter = { path = "../ruff_linter" }
+ruff_python_ast = { path = "../ruff_python_ast" }
+ruff_python_formatter = { path = "../ruff_python_formatter" }
+ruff_python_index = { path = "../ruff_python_index" }
+ruff_python_parser = { path = "../ruff_python_parser" }

 [lints]
 workspace = true
--- a/crates/ruff_benchmark/benches/linter.rs
+++ b/crates/ruff_benchmark/benches/linter.rs
@@ -10,7 +10,7 @@ use ruff_linter::settings::{flags, LinterSettings};
 use ruff_linter::source_kind::SourceKind;
 use ruff_linter::{registry::Rule, RuleSelector};
 use ruff_python_ast::PySourceType;
-use ruff_python_parser::{parse_program_tokens, tokenize, Mode};
+use ruff_python_parser::{lexer, parse_program_tokens, Mode};

 #[cfg(target_os = "windows")]
 #[global_allocator]
@@ -55,30 +55,29 @@ fn benchmark_linter(mut group: BenchmarkGroup, settings: &LinterSettings) {
            &case,
            |b, case| {
                // Tokenize the source.
-                let tokens = tokenize(case.code(), Mode::Module);
+                let tokens: Vec<_> = lexer::lex(case.code(), Mode::Module).collect();

                // Parse the source.
                let ast = parse_program_tokens(tokens.clone(), case.code(), false).unwrap();

-                b.iter_batched(
-                    || (ast.clone(), tokens.clone()),
-                    |(ast, tokens)| {
-                        let path = case.path();
-                        let result = lint_only(
-                            &path,
-                            None,
-                            settings,
-                            flags::Noqa::Enabled,
-                            &SourceKind::Python(case.code().to_string()),
-                            PySourceType::from(path.as_path()),
-                            ParseSource::Precomputed { tokens, ast },
-                        );
+                b.iter(|| {
+                    let path = case.path();
+                    let result = lint_only(
+                        &path,
+                        None,
+                        settings,
+                        flags::Noqa::Enabled,
+                        &SourceKind::Python(case.code().to_string()),
+                        PySourceType::from(path.as_path()),
+                        ParseSource::Precomputed {
+                            tokens: &tokens,
+                            ast: &ast,
+                        },
+                    );

-                        // Assert that file contains no parse errors
-                        assert_eq!(result.error, None);
-                    },
-                    criterion::BatchSize::SmallInput,
-                );
+                    // Assert that file contains no parse errors
+                    assert_eq!(result.error, None);
+                });
            },
        );
    }
--- a/crates/ruff_cache/Cargo.toml
+++ b/crates/ruff_cache/Cargo.toml
@@ -19,7 +19,7 @@ filetime = { workspace = true }
 seahash = { workspace = true }

 [dev-dependencies]
-ruff_macros = { workspace = true }
+ruff_macros = { path = "../ruff_macros" }

 [lints]
 workspace = true
--- a/crates/ruff_dev/Cargo.toml
+++ b/crates/ruff_dev/Cargo.toml
@@ -11,18 +11,18 @@ repository = { workspace = true }
 license = { workspace = true }

 [dependencies]
-ruff = { workspace = true }
-ruff_diagnostics = { workspace = true }
-ruff_formatter = { workspace = true }
-ruff_linter = { workspace = true, features = ["schemars"] }
-ruff_notebook = { workspace = true }
-ruff_python_ast = { workspace = true }
-ruff_python_codegen = { workspace = true }
-ruff_python_formatter = { workspace = true }
-ruff_python_parser = { workspace = true }
-ruff_python_stdlib = { workspace = true }
-ruff_python_trivia = { workspace = true }
-ruff_workspace = { workspace = true, features = ["schemars"] }
+ruff = { path = "../ruff" }
+ruff_diagnostics = { path = "../ruff_diagnostics" }
+ruff_formatter = { path = "../ruff_formatter" }
+ruff_linter = { path = "../ruff_linter", features = ["schemars"] }
+ruff_notebook = { path = "../ruff_notebook" }
+ruff_python_ast = { path = "../ruff_python_ast" }
+ruff_python_codegen = { path = "../ruff_python_codegen" }
+ruff_python_formatter = { path = "../ruff_python_formatter" }
+ruff_python_parser = { path = "../ruff_python_parser" }
+ruff_python_stdlib = { path = "../ruff_python_stdlib" }
+ruff_python_trivia = { path = "../ruff_python_trivia" }
+ruff_workspace = { path = "../ruff_workspace", features = ["schemars"] }

 anyhow = { workspace = true }
 clap = { workspace = true, features = ["wrap_help"] }
--- a/crates/ruff_diagnostics/Cargo.toml
+++ b/crates/ruff_diagnostics/Cargo.toml
@@ -14,7 +14,7 @@ license = { workspace = true }
 doctest = false

 [dependencies]
-ruff_text_size = { workspace = true }
+ruff_text_size = { path = "../ruff_text_size" }

 anyhow = { workspace = true }
 log = { workspace = true }
--- a/crates/ruff_formatter/Cargo.toml
+++ b/crates/ruff_formatter/Cargo.toml
@@ -11,9 +11,9 @@ repository = { workspace = true }
 license = { workspace = true }

 [dependencies]
-ruff_cache = { workspace = true }
-ruff_macros = { workspace = true }
-ruff_text_size = { workspace = true }
+ruff_cache = { path = "../ruff_cache" }
+ruff_macros = { path = "../ruff_macros" }
+ruff_text_size = { path = "../ruff_text_size" }

 drop_bomb = { workspace = true }
 rustc-hash = { workspace = true }
--- a/crates/ruff_formatter/src/lib.rs
+++ b/crates/ruff_formatter/src/lib.rs
@@ -553,6 +553,11 @@ impl PrintedRange {
    pub fn source_range(&self) -> TextRange {
        self.source_range
    }
+
+    #[must_use]
+    pub fn with_code(self, code: String) -> Self {
+        Self { code, ..self }
+    }
 }

 /// Public return type of the formatter
@@ -775,6 +780,10 @@ where
        self.item = item;
        self
    }
+
+    pub fn into_item(self) -> T {
+        self.item
+    }
 }

 impl<T, R, C> Format<C> for FormatOwnedWithRule<T, R, C>
--- a/crates/ruff_index/Cargo.toml
+++ b/crates/ruff_index/Cargo.toml
@@ -14,7 +14,7 @@ license = { workspace = true }
 doctest = false

 [dependencies]
-ruff_macros = { workspace = true }
+ruff_macros = { path = "../ruff_macros" }

 [dev-dependencies]
 static_assertions = { workspace = true }
--- a/crates/ruff_linter/Cargo.toml
+++ b/crates/ruff_linter/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.4.7"
+version = "0.4.4"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -13,20 +13,20 @@ license = { workspace = true }
 [lib]

 [dependencies]
-ruff_cache = { workspace = true }
-ruff_diagnostics = { workspace = true, features = ["serde"] }
-ruff_notebook = { workspace = true }
-ruff_macros = { workspace = true }
-ruff_python_ast = { workspace = true, features = ["serde"] }
-ruff_python_codegen = { workspace = true }
-ruff_python_index = { workspace = true }
-ruff_python_literal = { workspace = true }
-ruff_python_semantic = { workspace = true }
-ruff_python_stdlib = { workspace = true }
-ruff_python_trivia = { workspace = true }
-ruff_python_parser = { workspace = true }
-ruff_source_file = { workspace = true, features = ["serde"] }
-ruff_text_size = { workspace = true }
+ruff_cache = { path = "../ruff_cache" }
+ruff_diagnostics = { path = "../ruff_diagnostics", features = ["serde"] }
+ruff_notebook = { path = "../ruff_notebook" }
+ruff_macros = { path = "../ruff_macros" }
+ruff_python_ast = { path = "../ruff_python_ast", features = ["serde"] }
+ruff_python_codegen = { path = "../ruff_python_codegen" }
+ruff_python_index = { path = "../ruff_python_index" }
+ruff_python_literal = { path = "../ruff_python_literal" }
+ruff_python_semantic = { path = "../ruff_python_semantic" }
+ruff_python_stdlib = { path = "../ruff_python_stdlib" }
+ruff_python_trivia = { path = "../ruff_python_trivia" }
+ruff_python_parser = { path = "../ruff_python_parser" }
+ruff_source_file = { path = "../ruff_source_file", features = ["serde"] }
+ruff_text_size = { path = "../ruff_text_size" }

 aho-corasick = { workspace = true }
 annotate-snippets = { workspace = true, features = ["color"] }
--- a/crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC116.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC116.py
@@ -1,57 +0,0 @@
-# type: ignore
-# ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger.
-import math
-from math import inf
-
-
-async def import_trio():
-    import trio
-
-    # These examples are probably not meant to ever wake up:
-    await trio.sleep(100000)  # error: 116, "async"
-
-    # 'inf literal' overflow trick
-    await trio.sleep(1e999)  # error: 116, "async"
-
-    await trio.sleep(86399)
-    await trio.sleep(86400)
-    await trio.sleep(86400.01)  # error: 116, "async"
-    await trio.sleep(86401)  # error: 116, "async"
-
-    await trio.sleep(-1)  # will raise a runtime error
-    await trio.sleep(0)  # handled by different check
-
-    # these ones _definitely_ never wake up (TODO)
-    await trio.sleep(float("inf"))
-    await trio.sleep(math.inf)
-    await trio.sleep(inf)
-
-    # don't require inf to be in math (TODO)
-    await trio.sleep(np.inf)
-
-    # don't evaluate expressions (TODO)
-    one_day = 86401
-    await trio.sleep(86400 + 1)
-    await trio.sleep(60 * 60 * 24 + 1)
-    await trio.sleep(foo())
-    await trio.sleep(one_day)
-    await trio.sleep(86400 + foo())
-    await trio.sleep(86400 + ...)
-    await trio.sleep("hello")
-    await trio.sleep(...)
-
-
-def not_async_fun():
-    import trio
-
-    # does not require the call to be awaited, nor in an async fun
-    trio.sleep(86401)  # error: 116, "async"
-    # also checks that we don't break visit_Call
-    trio.run(trio.sleep(86401))  # error: 116, "async"
-
-
-async def import_from_trio():
-    from trio import sleep
-
-    # catch from import
-    await sleep(86401)  # error: 116, "async"
--- a/crates/ruff_linter/resources/test/fixtures/flake8_comprehensions/C400.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_comprehensions/C400.py
@@ -11,11 +11,6 @@ x = list(
    x for x in range(3)
 )

-# Strip parentheses from inner generators.
-list((2 * x for x in range(3)))
-list(((2 * x for x in range(3))))
-list((((2 * x for x in range(3)))))
-
 # Not built-in list.
 def list(*args, **kwargs):
    return None
--- a/crates/ruff_linter/resources/test/fixtures/flake8_future_annotations/ok_quoted_type.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_future_annotations/ok_quoted_type.py
@@ -1,7 +0,0 @@
-def main() -> None:
-    a_list: list[str] | None = []
-    a_list.append("hello")
-
-
-def hello(y: "dict[str, int] | None") -> None:
-    del y
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI006.pyi
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI006.pyi
@@ -14,7 +14,5 @@ if sys.version_info <= (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for v
 if sys.version_info <= (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons

 if sys.version_info > (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons
-elif sys.version_info > (3, 11): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons

 if python_version > (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons
-elif python_version == (3, 11): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI057.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI057.py
@@ -1,10 +0,0 @@
-import typing
-import collections.abc
-import foo
-from typing import ByteString
-from collections.abc import ByteString
-from foo import ByteString
-
-a: typing.ByteString
-b: collections.abc.ByteString
-c: foo.ByteString
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI057.pyi
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI057.pyi
@@ -1,10 +0,0 @@
-import typing
-import collections.abc
-import foo
-from typing import ByteString
-from collections.abc import ByteString
-from foo import ByteString
-
-a: typing.ByteString
-b: collections.abc.ByteString
-c: foo.ByteString
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI064.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI064.py
@@ -1,21 +0,0 @@
-from typing import Final, Literal
-
-x: Final[Literal[True]] = True  # PYI064
-y: Final[Literal[None]] = None  # PYI064
-z: Final[Literal[  # PYI064
-    "this is a really long literal, that won't be rendered in the issue text"
-]] = "this is a really long literal, that won't be rendered in the issue text"
-
-# This should be fixable, and marked as safe
-w1: Final[Literal[123]]  # PYI064
-
-# This should not be fixable
-w2: Final[Literal[123]] = "random value"  # PYI064
-
-n1: Final[Literal[True, False]] = True # No issue here
-n2: Literal[True] = True  # No issue here
-
-PlatformName = Literal["linux", "macos", "windows"]
-PLATFORMS: Final[set[PlatformName]] = {"linux", "macos", "windows"}  # No issue here
-
-foo: Final[{1, 2, 3}] = {1, 2, 3}  # No issue here
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI064.pyi
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI064.pyi
@@ -1,19 +0,0 @@
-from typing import Final, Literal
-
-x: Final[Literal[True]]  # PYI064
-y: Final[Literal[None]] = None  # PYI064
-z: Final[Literal["this is a really long literal, that won't be rendered in the issue text"]]  # PYI064
-
-# This should be fixable, and marked as safe
-w1: Final[Literal[123]]  # PYI064
-
-# This should not be fixable
-w2: Final[Literal[123]] = "random value"  # PYI064
-
-n1: Final[Literal[True, False]] # No issue here
-n2: Literal[True]  # No issue here
-
-PlatformName = Literal["linux", "macos", "windows"]
-PLATFORMS: Final[set[PlatformName]] = {"linux", "macos", "windows"}  # No issue here
-
-foo: Final[{1, 2, 3}] = {1, 2, 3}  # No issue here
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI066.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI066.py
@@ -1,54 +0,0 @@
-import sys
-
-if sys.version_info < (3, 10):  # Y066 When using if/else with sys.version_info, put the code for new Python versions first, e.g. "if sys.version_info >= (3, 10)"
-    def foo(x): ...
-else:
-    def foo(x, *, bar=True): ...
-
-if sys.version_info < (3, 8):  # Y066 When using if/else with sys.version_info, put the code for new Python versions first, e.g. "if sys.version_info >= (3, 8)"
-    def bar(x): ...
-elif sys.version_info < (3, 9):  # Y066 When using if/else with sys.version_info, put the code for new Python versions first, e.g. "if sys.version_info >= (3, 9)"
-    def bar(x, *, bar=True): ...
-elif sys.version_info < (3, 11):  # Y066 When using if/else with sys.version_info, put the code for new Python versions first, e.g. "if sys.version_info >= (3, 10)"
-    def bar(x, *, bar=True, baz=False): ...
-else:
-    def bar(x, *, bar=True, baz=False, qux=1): ...
-
-
-if sys.version_info >= (3, 5):
-    ...
-elif sys.version_info < (3, 9):  # Y066 When using if/else with sys.version_info, put the code for new Python versions first, e.g. "if sys.version_info >= (3, 10)"
-    ...
-else:
-    ...
-
-# Negative cases
-
-if sys.version_info[0] == 2: ...
-if sys.version_info[:1] == (2,): ...
-if sys.version_info[:1] == (True,): ...
-if sys.version_info < ('3', '0'): ...
-if sys.version_info >= (3, 4, 3): ...
-if sys.version_info == (3, 4): ...
-if sys.version_info < (3, 5): ...
-if sys.version_info >= (3, 5): ...
-if (2, 7) <= sys.version_info < (3, 5): ...
-
-
-if sys.version_info >= (3, 5):
-    ...
-else:
-    ...
-
-if sys.version_info >= (3, 10):
-    def foo1(x, *, bar=True, baz=False): ...
-elif sys.version_info >= (3, 9):
-    def foo1(x, *, bar=True): ...
-else:
-    def foo1(x): ...
-
-if sys.version_info < (3, 9):
-    def foo2(x): ...
-elif sys.version_info < (3, 10):
-    def foo2(x, *, bar=True): ...
-# no else case, no raise
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI066.pyi
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI066.pyi
@@ -1,54 +0,0 @@
-import sys
-
-if sys.version_info < (3, 10):  # Y066 When using if/else with sys.version_info, put the code for new Python versions first, e.g. "if sys.version_info >= (3, 10)"
-    def foo(x): ...
-else:
-    def foo(x, *, bar=True): ...
-
-if sys.version_info < (3, 8):  # Y066 When using if/else with sys.version_info, put the code for new Python versions first, e.g. "if sys.version_info >= (3, 8)"
-    def bar(x): ...
-elif sys.version_info < (3, 9):  # Y066 When using if/else with sys.version_info, put the code for new Python versions first, e.g. "if sys.version_info >= (3, 9)"
-    def bar(x, *, bar=True): ...
-elif sys.version_info < (3, 11):  # Y066 When using if/else with sys.version_info, put the code for new Python versions first, e.g. "if sys.version_info >= (3, 10)"
-    def bar(x, *, bar=True, baz=False): ...
-else:
-    def bar(x, *, bar=True, baz=False, qux=1): ...
-
-
-if sys.version_info >= (3, 5):
-    ...
-elif sys.version_info < (3, 9):  # Y066 When using if/else with sys.version_info, put the code for new Python versions first, e.g. "if sys.version_info >= (3, 10)"
-    ...
-else:
-    ...
-
-# Negative cases
-
-if sys.version_info[0] == 2: ...
-if sys.version_info[:1] == (2,): ...
-if sys.version_info[:1] == (True,): ...
-if sys.version_info < ('3', '0'): ...
-if sys.version_info >= (3, 4, 3): ...
-if sys.version_info == (3, 4): ...
-if sys.version_info < (3, 5): ...
-if sys.version_info >= (3, 5): ...
-if (2, 7) <= sys.version_info < (3, 5): ...
-
-
-if sys.version_info >= (3, 5):
-    ...
-else:
-    ...
-
-if sys.version_info >= (3, 10):
-    def foo1(x, *, bar=True, baz=False): ...
-elif sys.version_info >= (3, 9):
-    def foo1(x, *, bar=True): ...
-else:
-    def foo1(x): ...
-
-if sys.version_info < (3, 9):
-    def foo2(x): ...
-elif sys.version_info < (3, 10):
-    def foo2(x, *, bar=True): ...
-# no else case, no raise
--- a/crates/ruff_linter/resources/test/fixtures/flake8_self/SLF001.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_self/SLF001.py
@@ -77,8 +77,3 @@ print(foo._asdict())
 import os

 os._exit()
-
-
-from enum import Enum
-
-Enum._missing_(1)  # OK
--- a/crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM115.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM115.py
@@ -46,15 +46,3 @@ with contextlib.ExitStack() as exit_stack:
 # OK (quick one-liner to clear file contents)
 open("filename", "w").close()
 pathlib.Path("filename").open("w").close()
-
-
-# OK (custom context manager)
-class MyFile:
-    def __init__(self, filename: str):
-        self.filename = filename
-
-    def __enter__(self):
-        self.file = open(self.filename)
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.file.close()
--- a/crates/ruff_linter/resources/test/fixtures/flake8_type_checking/quote.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_type_checking/quote.py
@@ -90,10 +90,3 @@ def f():

    def func() -> DataFrame[[DataFrame[_P, _R]], DataFrame[_P, _R]]:
        ...
-
-
-def f():
-    from pandas import DataFrame, Series
-
-    def func(self) -> DataFrame | list[Series]:
-        pass
--- a/crates/ruff_linter/resources/test/fixtures/flake8_type_checking/singledispatch.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_type_checking/singledispatch.py
@@ -2,7 +2,6 @@
 from __future__ import annotations

 from functools import singledispatch
-from pathlib import Path
 from typing import TYPE_CHECKING

 from numpy import asarray
@@ -33,24 +32,3 @@ def _(a: spmatrix) -> spmatrix:

 def _(a: DataFrame) -> DataFrame:
    return a
-
-
-@singledispatch
-def process_path(a: int | str, p: Path) -> int:
-    """Convert arg to array or leaves it as sparse matrix."""
-    msg = f"Unhandled type {type(a)}"
-    raise NotImplementedError(msg)
-
-
-@process_path.register
-def _(a: int, p: Path) -> int:
-    return asarray(a)
-
-
-@process_path.register
-def _(a: str, p: Path) -> int:
-    return a
-
-
-def _(a: DataFrame, p: Path) -> DataFrame:
-    return a
--- a/crates/ruff_linter/resources/test/fixtures/isort/two_space.py
+++ b/crates/ruff_linter/resources/test/fixtures/isort/two_space.py
@@ -1,10 +0,0 @@
-# If the file doesn't contain a logical indent token, we should still detect two-space indentation on imports.
-from math import (
-  sin,
-  tan,
-  cos,
-  nan,
-  pi,
-)
-
-del sin, cos, tan, pi, nan
--- a/crates/ruff_linter/resources/test/fixtures/numpy/NPY201.py
+++ b/crates/ruff_linter/resources/test/fixtures/numpy/NPY201.py
@@ -106,11 +106,3 @@ def func():
    np.who()

    np.row_stack(([1,2], [3,4]))
-
-    np.alltrue([True, True])
-
-    np.anytrue([True, False])
-
-    np.cumproduct([1, 2, 3])
-
-    np.product([1, 2, 3])
--- a/crates/ruff_linter/resources/test/fixtures/pycodestyle/E27.py
+++ b/crates/ruff_linter/resources/test/fixtures/pycodestyle/E27.py
@@ -63,16 +63,3 @@ if (a and
 #: Okay
 def f():
 	return 1
-
-# Soft keywords
-
-#: E271
-type  Number = int
-
-#: E273
-type	Number = int
-
-#: E275
-match(foo):
-    case(1):
-        pass
--- a/crates/ruff_linter/resources/test/fixtures/pycodestyle/W605_0.py
+++ b/crates/ruff_linter/resources/test/fixtures/pycodestyle/W605_0.py
@@ -46,15 +46,3 @@ regex = '\\\_'

 #: W605:1:7
 u'foo\ bar'
-
-#: W605:1:13
-(
-    "foo \
-    bar \. baz"
-)
-
-#: W605:1:6
-"foo \. bar \t"
-
-#: W605:1:13
-"foo \t bar \."
--- a/crates/ruff_linter/resources/test/fixtures/pydocstyle/sphinx.py
+++ b/crates/ruff_linter/resources/test/fixtures/pydocstyle/sphinx.py
@@ -1,67 +0,0 @@
-def func():
-    """
-    Example:
-
-    .. code-block:: python
-
-        import foo
-    """
-
-
-def func():
-    """
-    Example:
-
-
-    .. code-block:: python
-
-        import foo
-    """
-
-
-def func():
-    """
-    Example:
-
-
-
-    .. code-block:: python
-
-        import foo
-    """
-
-
-def func():
-    """
-    Example
-    -------
-
-    .. code-block:: python
-
-        import foo
-    """
-
-
-def func():
-    """
-    Example
-    -------
-
-
-    .. code-block:: python
-
-        import foo
-    """
-
-
-def func():
-    """
-    Example
-    -------
-
-
-
-    .. code-block:: python
-
-        import foo
-    """
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/init.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/init.py
@@ -1,4 +1,4 @@
-"""__init__.py with nonempty __all__
+"""__init__.py with __all__

 Unused stdlib and third party imports are unsafe removals

@@ -33,10 +33,10 @@ from . import aliased as aliased  # Ok: is redundant alias
 from . import exported  # Ok: is exported in __all__


-from . import unused  # F401: add to __all__
+# from . import unused # F401: add to __all__


-from . import renamed as bees  # F401: add to __all__
+# from . import renamed as bees # F401: add to __all__


 __all__ = ["argparse", "exported"]
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/aliased.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/aliased.py
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/exported.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/exported.py
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/renamed.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/renamed.py
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/unused.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/unused.py
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/used.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_25__all_nonempty/used.py
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_26__all_empty/init.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_26__all_empty/init.py
@@ -1,11 +0,0 @@
-"""__init__.py with empty __all__
-"""
-
-
-from . import unused  # F401: add to __all__
-
-
-from . import renamed as bees  # F401: add to __all__
-
-
-__all__ = []
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_26__all_empty/renamed.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_26__all_empty/renamed.py
@@ -1 +0,0 @@
-# empty module imported by __init__.py for test fixture
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_26__all_empty/unused.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_26__all_empty/unused.py
@@ -1 +0,0 @@
-# empty module imported by __init__.py for test fixture
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_27__all_mistyped/init.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_27__all_mistyped/init.py
@@ -1,11 +0,0 @@
-"""__init__.py with mis-typed __all__
-"""
-
-
-from . import unused  # F401: recommend add to all w/o fix
-
-
-from . import renamed as bees  # F401: recommend add to all w/o fix
-
-
-__all__ = None
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_27__all_mistyped/renamed.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_27__all_mistyped/renamed.py
@@ -1 +0,0 @@
-# empty module imported by __init__.py for test fixture
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_27__all_mistyped/unused.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_27__all_mistyped/unused.py
@@ -1 +0,0 @@
-# empty module imported by __init__.py for test fixture
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_28__all_multiple/init.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_28__all_multiple/init.py
@@ -1,8 +0,0 @@
-"""__init__.py with multiple imports added to all in one edit
-"""
-
-
-from . import unused, renamed as bees  # F401: add to __all__
-
-
-__all__ = [];
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_28__all_multiple/renamed.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_28__all_multiple/renamed.py
@@ -1 +0,0 @@
-# empty module imported by __init__.py for test fixture
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_28__all_multiple/unused.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_28__all_multiple/unused.py
@@ -1 +0,0 @@
-# empty module imported by __init__.py for test fixture
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_29__all_conditional/init.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_29__all_conditional/init.py
@@ -1,16 +0,0 @@
-"""__init__.py with __all__ populated by conditional plus-eq
-
-multiple __all__ so cannot offer a fix to add to them
-"""
-
-import sys
-
-from . import unused, exported, renamed as bees
-
-if sys.version_info > (3, 9):
-    from . import also_exported
-
-__all__ = ["exported"]
-
-if sys.version_info >= (3, 9):
-    __all__ += ["also_exported"]
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_29__all_conditional/also_exported.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_29__all_conditional/also_exported.py
@@ -1 +0,0 @@
-# empty module imported by __init__.py for test fixture
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_29__all_conditional/exported.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_29__all_conditional/exported.py
@@ -1 +0,0 @@
-# empty module imported by __init__.py for test fixture
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_29__all_conditional/renamed.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_29__all_conditional/renamed.py
@@ -1 +0,0 @@
-# empty module imported by __init__.py for test fixture
--- a/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_29__all_conditional/unused.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyflakes/F401_29__all_conditional/unused.py
@@ -1 +0,0 @@
-# empty module imported by __init__.py for test fixture
--- a/crates/ruff_linter/resources/test/fixtures/pylint/non_slot_assignment.py
+++ b/crates/ruff_linter/resources/test/fixtures/pylint/non_slot_assignment.py
@@ -82,16 +82,3 @@ class Foo:
    @qux.setter
    def qux(self, value):
        self.bar = value / 2
-
-
-class StudentG:
-    names = ("surname",)
-    __slots__ = (*names, "a")
-
-    def __init__(self, name, surname):
-        self.name = name
-        self.surname = surname  # [assigning-non-slot]
-        self.setup()
-
-    def setup(self):
-        pass
--- a/crates/ruff_linter/resources/test/fixtures/pylint/too_many_branches.py
+++ b/crates/ruff_linter/resources/test/fixtures/pylint/too_many_branches.py
@@ -21,8 +21,6 @@ def wrong(): # [too-many-branches]
        pass
    try:
        pass
-    except Exception:
-        pass
    finally:
        pass
    if 2:
@@ -58,8 +56,6 @@ def good():
        pass
    try:
        pass
-    except Exception:
-        pass
    finally:
        pass
    if 1:
@@ -94,8 +90,6 @@ def with_statement_wrong():
            pass
        try:
            pass
-        except Exception:
-            pass
        finally:
            pass
        if 2:
--- a/crates/ruff_linter/resources/test/fixtures/pyupgrade/UP031_0.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyupgrade/UP031_0.py
@@ -29,11 +29,6 @@ print("%#o" % (123,))

 print("brace {} %s" % (1,))

-print((
-    "foo %s "
-    "bar %s" % (x, y)
-))
-
 print(
  "%s" % (
    "trailing comma",
@@ -57,6 +52,10 @@ print("%(ab)s" % {"a" "b": 1})

 print("%(a)s" % {"a"  :  1})

+print((
+    "foo %s "
+    "bar %s" % (x, y)
+))

 print(
    "foo %(foo)s "
--- a/crates/ruff_linter/resources/test/fixtures/pyupgrade/UP037_0.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyupgrade/UP037_0.py
--- a/crates/ruff_linter/resources/test/fixtures/pyupgrade/UP037_1.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyupgrade/UP037_1.py
@@ -1,14 +0,0 @@
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from typing import Tuple
-
-
-def foo():
-    # UP037
-    x: "Tuple[int, int]" = (0, 0)
-    print(x)
-
-
-# OK
-X: "Tuple[int, int]" = (0, 0)
--- a/crates/ruff_linter/resources/test/fixtures/pyupgrade/UP040.py
+++ b/crates/ruff_linter/resources/test/fixtures/pyupgrade/UP040.py
@@ -51,37 +51,3 @@ x: int = 1
 # type alias.
 T = typing.TypeVar["T"]
 Decorator: TypeAlias = typing.Callable[[T], T]
-
-
-from typing import TypeVar, Annotated, TypeAliasType
-
-from annotated_types import Gt, SupportGt
-
-
-# https://github.com/astral-sh/ruff/issues/11422
-T = TypeVar("T")
-PositiveList = TypeAliasType(
-    "PositiveList", list[Annotated[T, Gt(0)]], type_params=(T,)
-)
-
-# Bound
-T = TypeVar("T", bound=SupportGt)
-PositiveList = TypeAliasType(
-    "PositiveList", list[Annotated[T, Gt(0)]], type_params=(T,)
-)
-
-# Multiple bounds
-T1 = TypeVar("T1", bound=SupportGt)
-T2 = TypeVar("T2")
-T3 = TypeVar("T3")
-Tuple3 = TypeAliasType("Tuple3", tuple[T1, T2, T3], type_params=(T1, T2, T3))
-
-# No type_params
-PositiveInt = TypeAliasType("PositiveInt", Annotated[int, Gt(0)])
-PositiveInt = TypeAliasType("PositiveInt", Annotated[int, Gt(0)], type_params=())
-
-# OK: Other name
-T = TypeVar("T", bound=SupportGt)
-PositiveList = TypeAliasType(
-    "PositiveList2", list[Annotated[T, Gt(0)]], type_params=(T,)
-)
--- a/crates/ruff_linter/resources/test/fixtures/refurb/FURB110.py
+++ b/crates/ruff_linter/resources/test/fixtures/refurb/FURB110.py
@@ -38,12 +38,3 @@ z = (
    else
    y
 )
-
-# FURB110
-z = (
-    x
-    if x
-    else y
-    if y > 0
-    else None
-)
--- a/crates/ruff_linter/resources/test/fixtures/refurb/FURB118.py
+++ b/crates/ruff_linter/resources/test/fixtures/refurb/FURB118.py
@@ -60,7 +60,6 @@ op_itemgetter = lambda x, y: (x[0], y[0])
 op_itemgetter = lambda x: ()
 op_itemgetter = lambda x: (*x[0], x[1])
 op_itemgetter = lambda x: (x[0],)
-op_itemgetter = lambda x: x[x]


 def op_neg3(x, y):
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dhruv Manilawala	ce4d4ae6ac	Add methods to iter over format spec elements	2024-05-13 14:17:23 +05:30
Dhruv Manilawala	128414cd95	Add `Iterator` impl for `StringLike` parts	2024-05-13 13:48:54 +05:30
				`@@ -1 +0,0 @@`
				`# empty module imported by __init__.py for test fixture`