Make preview part of the selector API

Per discussion at https://github.com/astral-sh/ruff/discussions/6998

<!--
Thank you for contributing to Ruff! To help us out with reviewing,
please consider the following:

- Does this pull request include a summary of the change? (See below.)
- Does this pull request include a descriptive title?
- Does this pull request include references to any relevant issues?
-->

## Summary

<!-- What's the purpose of the change? What does it do, and why? -->

Adds a `--preview` and `--no-preview` option to the CLI for `ruff check`
and corresponding settings. The CLI options are hidden for now.

Available in the settings as `preview = true` or `preview = false`.

Does not include environment variable configuration, although we may add
it in the future.

## Test Plan

<!-- How was it tested? -->

`cargo build`

Future work will build on this setting, such as toggling the mode during
a test.

.github/workflows/benchmark.yaml

@@ -1,136 +0,0 @@
-name: Benchmark
-
-on:
-  pull_request:
-    paths:
-      - "Cargo.toml"
-      - "Cargo.lock"
-      - "rust-toolchain"
-      - "crates/**"
-      - "!crates/ruff_dev"
-      - "!crates/ruff_shrinking"
-
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
-jobs:
-  run-benchmark:
-    if: github.event_name == 'pull_request'
-    name: "Run | ${{ matrix.os }}"
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-
-    steps:
-      - name: "PR - Checkout Branch"
-        uses: actions/checkout@v3
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-
-      - name: "PR - Install Rust toolchain"
-        run: rustup show
-
-      - uses: Swatinem/rust-cache@v2
-
-      - name: "PR - Build benchmarks"
-        run: cargo bench -p ruff_benchmark --no-run
-
-      - name: "PR - Run benchmarks"
-        run: cargo benchmark --save-baseline=pr
-
-      - name: "Main - Checkout Branch"
-        uses: actions/checkout@v3
-        with:
-          clean: false
-          ref: main
-
-      - name: "Main - Install Rust toolchain"
-        run: rustup show
-
-      - name: "Main - Build benchmarks"
-        run: cargo bench -p ruff_benchmark --no-run
-
-      - name: "Main - Run benchmarks"
-        run: cargo benchmark --save-baseline=main
-
-      - name: "Upload benchmark results"
-        uses: actions/upload-artifact@v3
-        with:
-          name: benchmark-results-${{ matrix.os }}
-          path: ./target/criterion
-
-      # Cleanup
-      - name: Remove Criterion Artifact
-        uses: JesseTG/rm@v1.0.3
-        with:
-          path: ./target/criterion
-
-  benchmark-compare:
-    if: github.event_name == 'pull_request'
-    runs-on: ubuntu-latest
-    name: Compare
-    needs:
-      - run-benchmark
-
-    steps:
-      - name: "Install Rust toolchain"
-        run: rustup show
-
-      - name: "Install critcmp"
-        uses: taiki-e/install-action@v2
-        with:
-          tool: critcmp
-
-      - name: "Linux | Download PR benchmark results"
-        uses: actions/download-artifact@v3
-        with:
-          name: benchmark-results-ubuntu-latest
-          path: ./target/criterion
-
-      - name: "Linux | Compare benchmark results"
-        shell: bash
-        run: |
-          echo "### Benchmark" >> summary.md
-          echo "#### Linux" >> summary.md
-          echo "\`\`\`" >> summary.md
-          critcmp main pr >> summary.md
-          echo "\`\`\`" >> summary.md
-          echo "" >> summary.md
-
-      - name: "Linux | Cleanup benchmark results"
-        run: rm -rf ./target/criterion
-
-      - name: "Windows | Download PR benchmark results"
-        uses: actions/download-artifact@v3
-        with:
-          name: benchmark-results-windows-latest
-          path: ./target/criterion
-
-      - name: "Windows | Compare benchmark results"
-        shell: bash
-        run: |
-          echo "#### Windows" >> summary.md
-          echo "\`\`\`" >> summary.md
-          critcmp main pr >> summary.md
-          echo "\`\`\`" >> summary.md
-          echo "" >> summary.md
-
-          echo ${{ github.event.pull_request.number }} > pr-number
-
-          cat summary.md > $GITHUB_STEP_SUMMARY
-
-      - uses: actions/upload-artifact@v3
-        name: Upload PR Number
-        with:
-          name: pr-number
-          path: pr-number
-
-      - uses: actions/upload-artifact@v3
-        name: Upload Summary
-        with:
-          name: summary
-          path: summary.md

.github/workflows/ci.yaml

@@ -30,7 +30,7 @@ jobs:
         with:
           fetch-depth: 0
 
-      - uses: tj-actions/changed-files@v37
+      - uses: tj-actions/changed-files@v38
         id: changed
         with:
           files_yaml: |
@@ -341,3 +341,28 @@ jobs:
         run: cat target/progress_projects_stats.txt > $GITHUB_STEP_SUMMARY
       - name: "Remove checkouts from cache"
         run: rm -r target/progress_projects
+
+  benchmarks:
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Checkout Branch"
+        uses: actions/checkout@v3
+
+      - name: "Install Rust toolchain"
+        run: rustup show
+
+      - name: "Install codspeed"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-codspeed
+
+      - uses: Swatinem/rust-cache@v2
+
+      - name: "Build benchmarks"
+        run: cargo codspeed build --features codspeed -p ruff_benchmark
+
+      - name: "Run benchmarks"
+        uses: CodSpeedHQ/action@v1
+        with:
+          run: cargo codspeed run
+          token: ${{ secrets.CODSPEED_TOKEN }}

.github/workflows/docs.yaml

@@ -40,7 +40,7 @@ jobs:
         run: mkdocs build --strict -f mkdocs.generated.yml
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.0.2
+        uses: cloudflare/wrangler-action@v3.1.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/playground.yaml

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

.github/workflows/pr-comment.yaml

@@ -2,7 +2,7 @@ name: PR Check Comment
 
 on:
   workflow_run:
-    workflows: [CI, Benchmark]
+    workflows: [CI]
     types: [completed]
   workflow_dispatch:
     inputs:
@@ -43,42 +43,34 @@ jobs:
           path: pr/ecosystem
           if_no_artifact_found: ignore
 
-      - uses: dawidd6/action-download-artifact@v2
-        name: "Download Benchmark Result"
-        id: download-benchmark-result
-        if: steps.pr-number.outputs.pr-number
-        with:
-          name: summary
-          workflow: benchmark.yaml
-          pr: ${{ steps.pr-number.outputs.pr-number }}
-          path: pr/benchmark
-          if_no_artifact_found: ignore
-
       - name: Generate Comment
         id: generate-comment
-        if: steps.download-ecosystem-result.outputs.found_artifact == 'true' || steps.download-benchmark-result.outputs.found_artifact == 'true'
+        if: steps.download-ecosystem-result.outputs.found_artifact == 'true'
         run: |
+          echo '## PR Check Results' >> comment.txt
+
+          echo "### Ecosystem" >> comment.txt
+          cat pr/ecosystem/ecosystem-result >> comment.txt
+          echo "" >> comment.txt
+
           echo 'comment<<EOF' >> $GITHUB_OUTPUT
-          echo '## PR Check Results' >> $GITHUB_OUTPUT
-
-          if [[ -f pr/ecosystem/ecosystem-result ]]
-          then
-            echo "### Ecosystem" >> $GITHUB_OUTPUT
-            cat pr/ecosystem/ecosystem-result >> $GITHUB_OUTPUT
-            echo "" >> $GITHUB_OUTPUT
-          fi
-
-          if [[ -f pr/benchmark/summary.md ]]
-          then
-            cat pr/benchmark/summary.md >> $GITHUB_OUTPUT
-          fi
-
+          cat comment.txt >> $GITHUB_OUTPUT
           echo 'EOF' >> $GITHUB_OUTPUT
 
-      - name: Create or update comment
-        if: steps.generate-comment.outputs.comment
-        uses: thollander/actions-comment-pull-request@v2
+      - name: Find Comment
+        uses: peter-evans/find-comment@v2
+        if: steps.generate-comment.outcome == 'success'
+        id: find-comment
         with:
-          pr_number: ${{ steps.pr-number.outputs.pr-number }}
-          message: ${{ steps.generate-comment.outputs.comment }}
-          comment_tag: PR Check Results
+          issue-number: ${{ steps.pr-number.outputs.pr-number }}
+          comment-author: "github-actions[bot]"
+          body-includes: PR Check Results
+
+      - name: Create or update comment
+        if: steps.find-comment.outcome == 'success'
+        uses: peter-evans/create-or-update-comment@v3
+        with:
+          comment-id: ${{ steps.find-comment.outputs.comment-id }}
+          issue-number: ${{ steps.pr-number.outputs.pr-number }}
+          body-path: comment.txt
+          edit-mode: replace

Cargo.lock

@@ -414,6 +414,28 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "codspeed"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aeec2fbed4969dc38b5ca201115dd5c2614b8ef78e0a7221dd5f0977fb1552b"
+dependencies = [
+ "colored",
+ "libc",
+ "serde_json",
+]
+
+[[package]]
+name = "codspeed-criterion-compat"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b13f0a08d40ce7c95bdf288f725b975e62fcadfa8ba152340943bab6de43af7"
+dependencies = [
+ "codspeed",
+ "colored",
+ "criterion",
+]
+
 [[package]]
 name = "colorchoice"
 version = "1.0.0"
@@ -588,9 +610,9 @@ dependencies = [
 
 [[package]]
 name = "darling"
-version = "0.20.1"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0558d22a7b463ed0241e993f76f09f30b126687447751a8638587b864e4b3944"
+checksum = "0209d94da627ab5605dcccf08bb18afa5009cfbef48d8a8b7d7bdbc79be25c5e"
 dependencies = [
  "darling_core",
  "darling_macro",
@@ -598,9 +620,9 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.20.1"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab8bfa2e259f8ee1ce5e97824a3c55ec4404a0d772ca7fa96bf19f0752a046eb"
+checksum = "177e3443818124b357d8e76f53be906d60937f0d3a90773a664fa63fa253e621"
 dependencies = [
  "fnv",
  "ident_case",
@@ -612,15 +634,24 @@ dependencies = [
 
 [[package]]
 name = "darling_macro"
-version = "0.20.1"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29a358ff9f12ec09c3e61fef9b5a9902623a695a46a917b07f269bff1445611a"
+checksum = "836a9bbc7ad63342d6d6e7b815ccab164bc77a2d95d84bc3117a8c0d5c98e2d5"
 dependencies = [
  "darling_core",
  "quote",
  "syn 2.0.23",
 ]
 
+[[package]]
+name = "deranged"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2696e8a945f658fd14dc3b87242e6b80cd0f36ff04ea560fa39082368847946"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "diff"
 version = "0.1.13"
@@ -812,15 +843,20 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.285"
+version = "0.0.286"
 dependencies = [
  "anyhow",
  "clap",
  "colored",
  "configparser",
+ "itertools",
+ "log",
  "once_cell",
+ "pep440_rs",
+ "pretty_assertions",
  "regex",
  "ruff",
+ "ruff_workspace",
  "rustc-hash",
  "serde",
  "serde_json",
@@ -876,8 +912,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -1042,6 +1080,7 @@ checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
 dependencies = [
  "equivalent",
  "hashbrown 0.14.0",
+ "serde",
 ]
 
 [[package]]
@@ -2064,7 +2103,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.285"
+version = "0.0.286"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -2072,11 +2111,9 @@ dependencies = [
  "chrono",
  "clap",
  "colored",
- "dirs 5.0.1",
  "fern",
  "glob",
  "globset",
- "ignore",
  "imperative",
  "insta",
  "is-macro",
@@ -2116,7 +2153,6 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_with",
- "shellexpand",
  "similar",
  "smallvec",
  "strum",
@@ -2128,6 +2164,7 @@ dependencies = [
  "typed-arena",
  "unicode-width",
  "unicode_names2",
+ "uuid",
  "wsl",
 ]
 
@@ -2135,6 +2172,7 @@ dependencies = [
 name = "ruff_benchmark"
 version = "0.0.0"
 dependencies = [
+ "codspeed-criterion-compat",
  "criterion",
  "mimalloc",
  "once_cell",
@@ -2164,7 +2202,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_cli"
-version = "0.0.285"
+version = "0.0.286"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -2182,6 +2220,7 @@ dependencies = [
  "glob",
  "ignore",
  "insta",
+ "is-macro",
  "itertools",
  "itoa",
  "log",
@@ -2193,6 +2232,7 @@ dependencies = [
  "ruff",
  "ruff_cache",
  "ruff_diagnostics",
+ "ruff_formatter",
  "ruff_macros",
  "ruff_python_ast",
  "ruff_python_formatter",
@@ -2200,6 +2240,7 @@ dependencies = [
  "ruff_python_trivia",
  "ruff_source_file",
  "ruff_text_size",
+ "ruff_workspace",
  "rustc-hash",
  "serde",
  "serde_json",
@@ -2207,7 +2248,9 @@ dependencies = [
  "similar",
  "strum",
  "tempfile",
+ "thiserror",
  "tikv-jemallocator",
+ "tracing",
  "ureq",
  "walkdir",
  "wild",
@@ -2240,6 +2283,7 @@ dependencies = [
  "ruff_python_parser",
  "ruff_python_stdlib",
  "ruff_python_trivia",
+ "ruff_workspace",
  "schemars",
  "serde",
  "serde_json",
@@ -2340,6 +2384,7 @@ dependencies = [
  "insta",
  "is-macro",
  "itertools",
+ "memchr",
  "once_cell",
  "ruff_formatter",
  "ruff_python_ast",
@@ -2399,6 +2444,7 @@ dependencies = [
  "ruff_text_size",
  "rustc-hash",
  "static_assertions",
+ "test-case",
  "tiny-keccak",
  "unic-emoji-char",
  "unic-ucd-ident",
@@ -2497,18 +2543,48 @@ dependencies = [
  "log",
  "ruff",
  "ruff_diagnostics",
+ "ruff_formatter",
  "ruff_python_ast",
  "ruff_python_codegen",
  "ruff_python_formatter",
  "ruff_python_index",
  "ruff_python_parser",
  "ruff_source_file",
+ "ruff_text_size",
+ "ruff_workspace",
  "serde",
  "serde-wasm-bindgen",
  "wasm-bindgen",
  "wasm-bindgen-test",
 ]
 
+[[package]]
+name = "ruff_workspace"
+version = "0.0.0"
+dependencies = [
+ "anyhow",
+ "colored",
+ "dirs 5.0.1",
+ "glob",
+ "globset",
+ "ignore",
+ "itertools",
+ "log",
+ "path-absolutize",
+ "pep440_rs",
+ "regex",
+ "ruff",
+ "ruff_cache",
+ "ruff_macros",
+ "rustc-hash",
+ "schemars",
+ "serde",
+ "shellexpand",
+ "strum",
+ "tempfile",
+ "toml",
+]
+
 [[package]]
 name = "rust-stemmers"
 version = "1.2.0"
@@ -2691,9 +2767,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.100"
+version = "1.0.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f1e14e89be7aa4c4b78bdbdc9eb5bf8517829a600ae8eaa39a6e1d960b5185c"
+checksum = "693151e1ac27563d6dbcec9dee9fbd5da8539b20fa14ad3752b2e6d363ace360"
 dependencies = [
  "itoa",
  "ryu",
@@ -2720,25 +2796,26 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.0.0"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f02d8aa6e3c385bf084924f660ce2a3a6bd333ba55b35e8590b321f35d88513"
+checksum = "1ca3b16a3d82c4088f343b7480a93550b3eabe1a358569c2dfe38bbcead07237"
 dependencies = [
  "base64",
  "chrono",
  "hex",
  "indexmap 1.9.3",
+ "indexmap 2.0.0",
  "serde",
  "serde_json",
  "serde_with_macros",
- "time 0.3.22",
+ "time 0.3.26",
 ]
 
 [[package]]
 name = "serde_with_macros"
-version = "3.0.0"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edc7d5d3932fb12ce722ee5e64dd38c504efba37567f0c402f6ca728c3b8b070"
+checksum = "2e6be15c453eb305019bfa438b1593c731f36a289a7853f7707ee29e870b3b3c"
 dependencies = [
  "darling",
  "proc-macro2",
@@ -3023,10 +3100,11 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.22"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea9e1b3cf1243ae005d9e74085d4d542f3125458f3a81af210d901dcd7411efd"
+checksum = "a79d09ac6b08c1ab3906a2f7cc2e81a0e27c7ae89c63812df75e52bef0751e07"
 dependencies = [
+ "deranged",
  "itoa",
  "serde",
  "time-core",
@@ -3041,9 +3119,9 @@ checksum = "7300fbefb4dadc1af235a9cef3737cea692a9d97e1b9cbcd4ebdae6f8868e6fb"
 
 [[package]]
 name = "time-macros"
-version = "0.2.9"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "372950940a5f07bf38dbe211d7283c9e6d7327df53794992d293e534c733d09b"
+checksum = "75c65469ed6b3a4809d987a41eb1dc918e9bc1d92211cbad7ae82931846f7451"
 dependencies = [
  "time-core",
 ]
@@ -3344,9 +3422,26 @@ checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
 
 [[package]]
 name = "uuid"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d023da39d1fde5a8a3fe1f3e01ca9632ada0a63e9797de55a879d6e2236277be"
+checksum = "79daa5ed5740825c40b389c5e50312b9c86df53fccd33f281df655642b43869d"
+dependencies = [
+ "getrandom",
+ "rand",
+ "uuid-macro-internal",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "uuid-macro-internal"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7e1ba1f333bd65ce3c9f27de592fcbc256dafe3af2717f56d7c87761fbaccf4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.23",
+]
 
 [[package]]
 name = "valuable"

Cargo.toml

@@ -50,6 +50,7 @@ tracing = "0.1.37"
 tracing-indicatif = "0.3.4"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 unicode-width = "0.1.10"
+uuid = { version = "1.4.1", features = ["v4", "fast-rng", "macro-diagnostics", "js"] }
 wsl = { version = "0.1.0" }
 
 # v1.0.1

README.md

@@ -140,7 +140,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com) hook:
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.0.285
+  rev: v0.0.286
   hooks:
     - id: ruff
 ```

crates/flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.285"
+version = "0.0.286"
 description = """
 Convert Flake8 configuration files to Ruff configuration files.
 """
@@ -14,12 +14,16 @@ license = { workspace = true }
 
 [dependencies]
 ruff = { path = "../ruff", default-features = false }
+ruff_workspace = { path = "../ruff_workspace" }
 
 anyhow = { workspace = true }
 clap = { workspace = true }
 colored = { workspace = true }
 configparser = { version = "3.0.2" }
+itertools = { workspace = true }
+log = { workspace = true }
 once_cell = { workspace = true }
+pep440_rs = { version = "0.3.1", features = ["serde"] }
 regex = { workspace = true }
 rustc-hash = { workspace = true }
 serde = { workspace = true }
@@ -27,3 +31,6 @@ serde_json = { workspace = true }
 strum = { workspace = true }
 strum_macros = { workspace = true }
 toml = { workspace = true }
+
+[dev-dependencies]
+pretty_assertions = "1.3.0"

crates/flake8_to_ruff/src/black.rs

@@ -1,13 +1,13 @@
 //! Extract Black configuration settings from a pyproject.toml.
 
+use ruff::line_width::LineLength;
+use ruff::settings::types::PythonVersion;
 use serde::{Deserialize, Serialize};
 
-use crate::settings::types::PythonVersion;
-
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct Black {
+pub(crate) struct Black {
     #[serde(alias = "line-length", alias = "line_length")]
-    pub line_length: Option<usize>,
+    pub(crate) line_length: Option<LineLength>,
     #[serde(alias = "target-version", alias = "target_version")]
-    pub target_version: Option<Vec<PythonVersion>>,
+    pub(crate) target_version: Option<Vec<PythonVersion>>,
 }

crates/flake8_to_ruff/src/converter.rs

@@ -1,25 +1,25 @@
 use std::collections::{HashMap, HashSet};
+use std::str::FromStr;
 
-use anyhow::Result;
 use itertools::Itertools;
 
-use crate::line_width::LineLength;
-use crate::registry::Linter;
-use crate::rule_selector::RuleSelector;
-use crate::rules::flake8_pytest_style::types::{
+use ruff::line_width::LineLength;
+use ruff::registry::Linter;
+use ruff::rule_selector::RuleSelector;
+use ruff::rules::flake8_pytest_style::types::{
     ParametrizeNameType, ParametrizeValuesRowType, ParametrizeValuesType,
 };
-use crate::rules::flake8_quotes::settings::Quote;
-use crate::rules::flake8_tidy_imports::settings::Strictness;
-use crate::rules::pydocstyle::settings::Convention;
-use crate::rules::{
-    flake8_annotations, flake8_bugbear, flake8_builtins, flake8_errmsg, flake8_pytest_style,
-    flake8_quotes, flake8_tidy_imports, mccabe, pep8_naming, pydocstyle,
+use ruff::rules::flake8_quotes::settings::Quote;
+use ruff::rules::flake8_tidy_imports::settings::Strictness;
+use ruff::rules::pydocstyle::settings::Convention;
+use ruff::settings::types::PythonVersion;
+use ruff::warn_user;
+use ruff_workspace::options::{
+    Flake8AnnotationsOptions, Flake8BugbearOptions, Flake8BuiltinsOptions, Flake8ErrMsgOptions,
+    Flake8PytestStyleOptions, Flake8QuotesOptions, Flake8TidyImportsOptions, McCabeOptions,
+    Options, Pep8NamingOptions, PydocstyleOptions,
 };
-use crate::settings::options::Options;
-use crate::settings::pyproject::Pyproject;
-use crate::settings::types::PythonVersion;
-use crate::warn_user;
+use ruff_workspace::pyproject::Pyproject;
 
 use super::external_config::ExternalConfig;
 use super::plugin::Plugin;
@@ -30,11 +30,11 @@ const DEFAULT_SELECTORS: &[RuleSelector] = &[
     RuleSelector::Linter(Linter::Pycodestyle),
 ];
 
-pub fn convert(
+pub(crate) fn convert(
     config: &HashMap<String, HashMap<String, Option<String>>>,
     external_config: &ExternalConfig,
     plugins: Option<Vec<Plugin>>,
-) -> Result<Pyproject> {
+) -> Pyproject {
     // Extract the Flake8 section.
     let flake8 = config
         .get("flake8")
@@ -103,16 +103,16 @@ pub fn convert(
 
     // Parse each supported option.
     let mut options = Options::default();
-    let mut flake8_annotations = flake8_annotations::settings::Options::default();
-    let mut flake8_bugbear = flake8_bugbear::settings::Options::default();
-    let mut flake8_builtins = flake8_builtins::settings::Options::default();
-    let mut flake8_errmsg = flake8_errmsg::settings::Options::default();
-    let mut flake8_pytest_style = flake8_pytest_style::settings::Options::default();
-    let mut flake8_quotes = flake8_quotes::settings::Options::default();
-    let mut flake8_tidy_imports = flake8_tidy_imports::options::Options::default();
-    let mut mccabe = mccabe::settings::Options::default();
-    let mut pep8_naming = pep8_naming::settings::Options::default();
-    let mut pydocstyle = pydocstyle::settings::Options::default();
+    let mut flake8_annotations = Flake8AnnotationsOptions::default();
+    let mut flake8_bugbear = Flake8BugbearOptions::default();
+    let mut flake8_builtins = Flake8BuiltinsOptions::default();
+    let mut flake8_errmsg = Flake8ErrMsgOptions::default();
+    let mut flake8_pytest_style = Flake8PytestStyleOptions::default();
+    let mut flake8_quotes = Flake8QuotesOptions::default();
+    let mut flake8_tidy_imports = Flake8TidyImportsOptions::default();
+    let mut mccabe = McCabeOptions::default();
+    let mut pep8_naming = Pep8NamingOptions::default();
+    let mut pydocstyle = PydocstyleOptions::default();
     for (key, value) in flake8 {
         if let Some(value) = value {
             match key.as_str() {
@@ -120,10 +120,8 @@ pub fn convert(
                 "builtins" => {
                     options.builtins = Some(parser::parse_strings(value.as_ref()));
                 }
-                "max-line-length" | "max_line_length" => match value.parse::<usize>() {
-                    Ok(line_length) => {
-                        options.line_length = Some(LineLength::from(line_length));
-                    }
+                "max-line-length" | "max_line_length" => match LineLength::from_str(value) {
+                    Ok(line_length) => options.line_length = Some(line_length),
                     Err(e) => {
                         warn_user!("Unable to parse '{key}' property: {e}");
                     }
@@ -372,41 +370,41 @@ pub fn convert(
             .sorted_by_key(RuleSelector::prefix_and_code)
             .collect(),
     );
-    if flake8_annotations != flake8_annotations::settings::Options::default() {
+    if flake8_annotations != Flake8AnnotationsOptions::default() {
         options.flake8_annotations = Some(flake8_annotations);
     }
-    if flake8_bugbear != flake8_bugbear::settings::Options::default() {
+    if flake8_bugbear != Flake8BugbearOptions::default() {
         options.flake8_bugbear = Some(flake8_bugbear);
     }
-    if flake8_builtins != flake8_builtins::settings::Options::default() {
+    if flake8_builtins != Flake8BuiltinsOptions::default() {
         options.flake8_builtins = Some(flake8_builtins);
     }
-    if flake8_errmsg != flake8_errmsg::settings::Options::default() {
+    if flake8_errmsg != Flake8ErrMsgOptions::default() {
         options.flake8_errmsg = Some(flake8_errmsg);
     }
-    if flake8_pytest_style != flake8_pytest_style::settings::Options::default() {
+    if flake8_pytest_style != Flake8PytestStyleOptions::default() {
         options.flake8_pytest_style = Some(flake8_pytest_style);
     }
-    if flake8_quotes != flake8_quotes::settings::Options::default() {
+    if flake8_quotes != Flake8QuotesOptions::default() {
         options.flake8_quotes = Some(flake8_quotes);
     }
-    if flake8_tidy_imports != flake8_tidy_imports::options::Options::default() {
+    if flake8_tidy_imports != Flake8TidyImportsOptions::default() {
         options.flake8_tidy_imports = Some(flake8_tidy_imports);
     }
-    if mccabe != mccabe::settings::Options::default() {
+    if mccabe != McCabeOptions::default() {
         options.mccabe = Some(mccabe);
     }
-    if pep8_naming != pep8_naming::settings::Options::default() {
+    if pep8_naming != Pep8NamingOptions::default() {
         options.pep8_naming = Some(pep8_naming);
     }
-    if pydocstyle != pydocstyle::settings::Options::default() {
+    if pydocstyle != PydocstyleOptions::default() {
         options.pydocstyle = Some(pydocstyle);
     }
 
     // Extract any settings from the existing `pyproject.toml`.
     if let Some(black) = &external_config.black {
         if let Some(line_length) = &black.line_length {
-            options.line_length = Some(LineLength::from(*line_length));
+            options.line_length = Some(*line_length);
         }
 
         if let Some(target_version) = &black.target_version {
@@ -439,7 +437,7 @@ pub fn convert(
     }
 
     // Create the pyproject.toml.
-    Ok(Pyproject::new(options))
+    Pyproject::new(options)
 }
 
 /// Resolve the set of enabled `RuleSelector` values for the given
@@ -458,19 +456,20 @@ mod tests {
     use anyhow::Result;
     use itertools::Itertools;
     use pep440_rs::VersionSpecifiers;
-    use pretty_assertions::assert_eq;
 
-    use crate::flake8_to_ruff::converter::DEFAULT_SELECTORS;
-    use crate::flake8_to_ruff::pep621::Project;
-    use crate::flake8_to_ruff::ExternalConfig;
-    use crate::line_width::LineLength;
-    use crate::registry::Linter;
-    use crate::rule_selector::RuleSelector;
-    use crate::rules::pydocstyle::settings::Convention;
-    use crate::rules::{flake8_quotes, pydocstyle};
-    use crate::settings::options::Options;
-    use crate::settings::pyproject::Pyproject;
-    use crate::settings::types::PythonVersion;
+    use pretty_assertions::assert_eq;
+    use ruff::line_width::LineLength;
+    use ruff::registry::Linter;
+    use ruff::rule_selector::RuleSelector;
+    use ruff::rules::flake8_quotes;
+    use ruff::rules::pydocstyle::settings::Convention;
+    use ruff::settings::types::PythonVersion;
+    use ruff_workspace::options::{Flake8QuotesOptions, Options, PydocstyleOptions};
+    use ruff_workspace::pyproject::Pyproject;
+
+    use crate::converter::DEFAULT_SELECTORS;
+    use crate::pep621::Project;
+    use crate::ExternalConfig;
 
     use super::super::plugin::Plugin;
     use super::convert;
@@ -491,20 +490,18 @@ mod tests {
     }
 
     #[test]
-    fn it_converts_empty() -> Result<()> {
+    fn it_converts_empty() {
         let actual = convert(
             &HashMap::from([("flake8".to_string(), HashMap::default())]),
             &ExternalConfig::default(),
             None,
-        )?;
+        );
         let expected = Pyproject::new(default_options([]));
         assert_eq!(actual, expected);
-
-        Ok(())
     }
 
     #[test]
-    fn it_converts_dashes() -> Result<()> {
+    fn it_converts_dashes() {
         let actual = convert(
             &HashMap::from([(
                 "flake8".to_string(),
@@ -512,18 +509,16 @@ mod tests {
             )]),
             &ExternalConfig::default(),
             Some(vec![]),
-        )?;
+        );
         let expected = Pyproject::new(Options {
-            line_length: Some(LineLength::from(100)),
+            line_length: Some(LineLength::try_from(100).unwrap()),
             ..default_options([])
         });
         assert_eq!(actual, expected);
-
-        Ok(())
     }
 
     #[test]
-    fn it_converts_underscores() -> Result<()> {
+    fn it_converts_underscores() {
         let actual = convert(
             &HashMap::from([(
                 "flake8".to_string(),
@@ -531,18 +526,16 @@ mod tests {
             )]),
             &ExternalConfig::default(),
             Some(vec![]),
-        )?;
+        );
         let expected = Pyproject::new(Options {
-            line_length: Some(LineLength::from(100)),
+            line_length: Some(LineLength::try_from(100).unwrap()),
             ..default_options([])
         });
         assert_eq!(actual, expected);
-
-        Ok(())
     }
 
     #[test]
-    fn it_ignores_parse_errors() -> Result<()> {
+    fn it_ignores_parse_errors() {
         let actual = convert(
             &HashMap::from([(
                 "flake8".to_string(),
@@ -550,15 +543,13 @@ mod tests {
             )]),
             &ExternalConfig::default(),
             Some(vec![]),
-        )?;
+        );
         let expected = Pyproject::new(default_options([]));
         assert_eq!(actual, expected);
-
-        Ok(())
     }
 
     #[test]
-    fn it_converts_plugin_options() -> Result<()> {
+    fn it_converts_plugin_options() {
         let actual = convert(
             &HashMap::from([(
                 "flake8".to_string(),
@@ -566,9 +557,9 @@ mod tests {
             )]),
             &ExternalConfig::default(),
             Some(vec![]),
-        )?;
+        );
         let expected = Pyproject::new(Options {
-            flake8_quotes: Some(flake8_quotes::settings::Options {
+            flake8_quotes: Some(Flake8QuotesOptions {
                 inline_quotes: Some(flake8_quotes::settings::Quote::Single),
                 multiline_quotes: None,
                 docstring_quotes: None,
@@ -577,12 +568,10 @@ mod tests {
             ..default_options([])
         });
         assert_eq!(actual, expected);
-
-        Ok(())
     }
 
     #[test]
-    fn it_converts_docstring_conventions() -> Result<()> {
+    fn it_converts_docstring_conventions() {
         let actual = convert(
             &HashMap::from([(
                 "flake8".to_string(),
@@ -593,9 +582,9 @@ mod tests {
             )]),
             &ExternalConfig::default(),
             Some(vec![Plugin::Flake8Docstrings]),
-        )?;
+        );
         let expected = Pyproject::new(Options {
-            pydocstyle: Some(pydocstyle::settings::Options {
+            pydocstyle: Some(PydocstyleOptions {
                 convention: Some(Convention::Numpy),
                 ignore_decorators: None,
                 property_decorators: None,
@@ -603,12 +592,10 @@ mod tests {
             ..default_options([Linter::Pydocstyle.into()])
         });
         assert_eq!(actual, expected);
-
-        Ok(())
     }
 
     #[test]
-    fn it_infers_plugins_if_omitted() -> Result<()> {
+    fn it_infers_plugins_if_omitted() {
         let actual = convert(
             &HashMap::from([(
                 "flake8".to_string(),
@@ -616,9 +603,9 @@ mod tests {
             )]),
             &ExternalConfig::default(),
             None,
-        )?;
+        );
         let expected = Pyproject::new(Options {
-            flake8_quotes: Some(flake8_quotes::settings::Options {
+            flake8_quotes: Some(Flake8QuotesOptions {
                 inline_quotes: Some(flake8_quotes::settings::Quote::Single),
                 multiline_quotes: None,
                 docstring_quotes: None,
@@ -627,8 +614,6 @@ mod tests {
             ..default_options([Linter::Flake8Quotes.into()])
         });
         assert_eq!(actual, expected);
-
-        Ok(())
     }
 
     #[test]
@@ -642,7 +627,7 @@ mod tests {
                 ..ExternalConfig::default()
             },
             Some(vec![]),
-        )?;
+        );
         let expected = Pyproject::new(Options {
             target_version: Some(PythonVersion::Py38),
             ..default_options([])

crates/flake8_to_ruff/src/external_config.rs

@@ -0,0 +1,10 @@
+use super::black::Black;
+use super::isort::Isort;
+use super::pep621::Project;
+
+#[derive(Default)]
+pub(crate) struct ExternalConfig<'a> {
+    pub(crate) black: Option<&'a Black>,
+    pub(crate) isort: Option<&'a Isort>,
+    pub(crate) project: Option<&'a Project>,
+}

crates/flake8_to_ruff/src/isort.rs

@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 
 /// The [isort configuration](https://pycqa.github.io/isort/docs/configuration/config_files.html).
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct Isort {
+pub(crate) struct Isort {
     #[serde(alias = "src-paths", alias = "src_paths")]
-    pub src_paths: Option<Vec<String>>,
+    pub(crate) src_paths: Option<Vec<String>>,
 }

crates/flake8_to_ruff/src/main.rs

@@ -1,12 +1,24 @@
 //! Utility to generate Ruff's `pyproject.toml` section from a Flake8 INI file.
 
+mod black;
+mod converter;
+mod external_config;
+mod isort;
+mod parser;
+mod pep621;
+mod plugin;
+mod pyproject;
+
 use std::path::PathBuf;
 
 use anyhow::Result;
 use clap::Parser;
 use configparser::ini::Ini;
 
-use ruff::flake8_to_ruff::{self, ExternalConfig};
+use crate::converter::convert;
+use crate::external_config::ExternalConfig;
+use crate::plugin::Plugin;
+use crate::pyproject::parse;
 use ruff::logging::{set_up_logging, LogLevel};
 
 #[derive(Parser)]
@@ -25,7 +37,7 @@ struct Args {
     pyproject: Option<PathBuf>,
     /// List of plugins to enable.
     #[arg(long, value_delimiter = ',')]
-    plugin: Option<Vec<flake8_to_ruff::Plugin>>,
+    plugin: Option<Vec<Plugin>>,
 }
 
 fn main() -> Result<()> {
@@ -39,7 +51,7 @@ fn main() -> Result<()> {
     let config = ini.load(args.file).map_err(|msg| anyhow::anyhow!(msg))?;
 
     // Read the pyproject.toml file.
-    let pyproject = args.pyproject.map(flake8_to_ruff::parse).transpose()?;
+    let pyproject = args.pyproject.map(parse).transpose()?;
     let external_config = pyproject
         .as_ref()
         .and_then(|pyproject| pyproject.tool.as_ref())
@@ -57,7 +69,7 @@ fn main() -> Result<()> {
     };
 
     // Create Ruff's pyproject.toml section.
-    let pyproject = flake8_to_ruff::convert(&config, &external_config, args.plugin)?;
+    let pyproject = convert(&config, &external_config, args.plugin);
 
     #[allow(clippy::print_stdout)]
     {

crates/flake8_to_ruff/src/parser.rs

@@ -3,12 +3,10 @@ use std::str::FromStr;
 use anyhow::{bail, Result};
 use once_cell::sync::Lazy;
 use regex::Regex;
+use ruff::settings::types::PatternPrefixPair;
+use ruff::{warn_user, RuleSelector};
 use rustc_hash::FxHashMap;
 
-use crate::rule_selector::RuleSelector;
-use crate::settings::types::PatternPrefixPair;
-use crate::warn_user;
-
 static COMMA_SEPARATED_LIST_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"[,\s]").unwrap());
 
 /// Parse a comma-separated list of `RuleSelector` values (e.g.,
@@ -194,11 +192,11 @@ pub(crate) fn collect_per_file_ignores(
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
+    use ruff::RuleSelector;
 
-    use crate::codes;
-    use crate::registry::Linter;
-    use crate::rule_selector::RuleSelector;
-    use crate::settings::types::PatternPrefixPair;
+    use ruff::codes;
+    use ruff::registry::Linter;
+    use ruff::settings::types::PatternPrefixPair;
 
     use super::{parse_files_to_codes_mapping, parse_prefix_codes, parse_strings};
 

crates/flake8_to_ruff/src/pep621.rs

@@ -4,7 +4,7 @@ use pep440_rs::VersionSpecifiers;
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct Project {
+pub(crate) struct Project {
     #[serde(alias = "requires-python", alias = "requires_python")]
-    pub requires_python: Option<VersionSpecifiers>,
+    pub(crate) requires_python: Option<VersionSpecifiers>,
 }

crates/flake8_to_ruff/src/plugin.rs

@@ -3,9 +3,9 @@ use std::fmt;
 use std::str::FromStr;
 
 use anyhow::anyhow;
-
-use crate::registry::Linter;
-use crate::rule_selector::RuleSelector;
+use ruff::registry::Linter;
+use ruff::settings::types::PreviewMode;
+use ruff::RuleSelector;
 
 #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub enum Plugin {
@@ -332,7 +332,7 @@ pub(crate) fn infer_plugins_from_codes(selectors: &HashSet<RuleSelector>) -> Vec
     .filter(|plugin| {
         for selector in selectors {
             if selector
-                .into_iter()
+                .rules(PreviewMode::Disabled)
                 .any(|rule| Linter::from(plugin).rules().any(|r| r == rule))
             {
                 return true;

crates/flake8_to_ruff/src/pyproject.rs

@@ -8,18 +8,18 @@ use super::isort::Isort;
 use super::pep621::Project;
 
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Tools {
-    pub black: Option<Black>,
-    pub isort: Option<Isort>,
+pub(crate) struct Tools {
+    pub(crate) black: Option<Black>,
+    pub(crate) isort: Option<Isort>,
 }
 
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Pyproject {
-    pub tool: Option<Tools>,
-    pub project: Option<Project>,
+pub(crate) struct Pyproject {
+    pub(crate) tool: Option<Tools>,
+    pub(crate) project: Option<Project>,
 }
 
-pub fn parse<P: AsRef<Path>>(path: P) -> Result<Pyproject> {
+pub(crate) fn parse<P: AsRef<Path>>(path: P) -> Result<Pyproject> {
     let contents = std::fs::read_to_string(path)?;
     let pyproject = toml::from_str::<Pyproject>(&contents)?;
     Ok(pyproject)

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.285"
+version = "0.0.286"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -36,11 +36,9 @@ bitflags = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true, features = ["derive", "string"], optional = true }
 colored = { workspace = true }
-dirs = { version = "5.0.0" }
 fern = { version = "0.6.1" }
 glob = { workspace = true }
 globset = { workspace = true }
-ignore = { workspace = true }
 imperative = { version = "1.0.4" }
 is-macro = { workspace = true }
 itertools = { workspace = true }
@@ -68,7 +66,6 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { version = "3.0.0" }
 similar = { workspace = true }
-shellexpand = { workspace = true }
 smallvec = { workspace = true }
 strum = { workspace = true }
 strum_macros = { workspace = true }
@@ -77,6 +74,7 @@ toml = { workspace = true }
 typed-arena = { version = "2.0.2" }
 unicode-width = { workspace = true }
 unicode_names2 = { version = "0.6.0", git = "https://github.com/youknowone/unicode_names2.git", rev = "4ce16aa85cbcdd9cc830410f1a72ef9a235f2fde" }
+uuid = { workspace = true, features = ["v4", "fast-rng", "macro-diagnostics", "js"] }
 wsl = { version = "0.1.0" }
 
 [dev-dependencies]

crates/ruff/resources/test/fixtures/eradicate/ERA001.py

@@ -19,3 +19,12 @@ def foo(x, y, z):
 class A():
     pass
     # b = c
+
+
+dictionary = {
+    # "key1": 123,  # noqa: ERA001
+    # "key2": 456,
+    # "key3": 789,  # test
+}
+
+#import os  # noqa

crates/ruff/resources/test/fixtures/flake8_annotations/annotation_presence.py

@@ -152,3 +152,9 @@ def f(a: Union[str, bytes, Any]) -> None: ...
 def f(a: Optional[Any]) -> None: ...
 def f(a: Annotated[Any, ...]) -> None: ...
 def f(a: "Union[str, bytes, Any]") -> None: ...
+
+
+class Foo:
+    @decorator()
+    def __init__(self: "Foo", foo: int):
+       ...

crates/ruff/resources/test/fixtures/flake8_boolean_trap/FBT.py

@@ -69,6 +69,7 @@ g_action.set_enabled(True)
 settings.set_enable_developer_extras(True)
 foo.is_(True)
 bar.is_not(False)
+next(iter([]), False)
 
 class Registry:
     def __init__(self) -> None:

crates/ruff/resources/test/fixtures/flake8_bugbear/B006_B008.py

@@ -230,6 +230,10 @@ def timedelta_okay(value=dt.timedelta(hours=1)):
 def path_okay(value=Path(".")):
     pass
 
+# B008 allow arbitrary call with immutable annotation
+def immutable_annotation_call(value: Sequence[int] = foo()):
+    pass
+
 # B006 and B008
 # We should handle arbitrary nesting of these B008.
 def nested_combo(a=[float(3), dt.datetime.now()]):

crates/ruff/resources/test/fixtures/flake8_bugbear/B006_extended.py

@@ -0,0 +1,18 @@
+import custom
+from custom import ImmutableTypeB
+
+
+def okay(foo: ImmutableTypeB = []):
+    ...
+
+
+def okay(foo: custom.ImmutableTypeA = []):
+    ...
+
+
+def okay(foo: custom.ImmutableTypeB = []):
+    ...
+
+
+def error_due_to_missing_import(foo: ImmutableTypeA = []):
+    ...

crates/ruff/resources/test/fixtures/flake8_bugbear/B008_extended.py

@@ -1,6 +1,7 @@
 from typing import List
 
 import fastapi
+import custom
 from fastapi import Query
 
 
@@ -16,5 +17,9 @@ def okay(data: List[str] = Query(None)):
     ...
 
 
+def okay(data: custom.ImmutableTypeA = foo()):
+    ...
+
+
 def error_due_to_missing_import(data: List[str] = Depends(None)):
     ...

crates/ruff/resources/test/fixtures/flake8_comprehensions/C414.py

@@ -22,6 +22,10 @@ tuple(
         "o"]
     )
 )
+set(set())
+set(list())
+set(tuple())
+sorted(reversed())
 
 # Nested sorts with differing keyword arguments. Not flagged.
 sorted(sorted(x, key=lambda y: y))

crates/ruff/resources/test/fixtures/flake8_comprehensions/C417.py

@@ -15,11 +15,6 @@ filter(func, map(lambda v: v, nums))
 _ = f"{set(map(lambda x: x % 2 == 0, nums))}"
 _ = f"{dict(map(lambda v: (v, v**2), nums))}"
 
-# Error, but unfixable.
-# For simple expressions, this could be: `(x if x else 1 for x in nums)`.
-# For more complex expressions, this would differ: `(x + 2 if x else 3 for x in nums)`.
-map(lambda x=1: x, nums)
-
 # False negatives.
 map(lambda x=2, y=1: x + y, nums, nums)
 set(map(lambda x, y: x, nums, nums))
@@ -37,3 +32,11 @@ map(lambda x: lambda: x, range(4))
 
 # Error: the `x` is overridden by the inner lambda.
 map(lambda x: lambda x: x, range(4))
+
+# Ok because of the default parameters, and variadic arguments.
+map(lambda x=1: x, nums)
+map(lambda *args: len(args), range(4))
+map(lambda **kwargs: len(kwargs), range(4))
+
+# Ok because multiple arguments are allowed.
+dict(map(lambda k, v: (k, v), keys, values))

crates/ruff/resources/test/fixtures/flake8_import_conventions/defaults.py

@@ -1,22 +1,31 @@
-import math  # not checked
+def not_checked():
+    import math
 
-import altair  # unconventional
-import matplotlib.pyplot  # unconventional
-import numpy  # unconventional
-import pandas  # unconventional
-import seaborn  # unconventional
-import tkinter  # unconventional
 
-import altair as altr  # unconventional
-import matplotlib.pyplot as plot  # unconventional
-import numpy as nmp  # unconventional
-import pandas as pdas  # unconventional
-import seaborn as sbrn  # unconventional
-import tkinter as tkr  # unconventional
+def unconventional():
+    import altair
+    import matplotlib.pyplot
+    import numpy
+    import pandas
+    import seaborn
+    import tkinter
+    import networkx
 
-import altair as alt  # conventional
-import matplotlib.pyplot as plt  # conventional
-import numpy as np  # conventional
-import pandas as pd  # conventional
-import seaborn as sns  # conventional
-import tkinter as tk  # conventional
+
+def unconventional_aliases():
+    import altair as altr
+    import matplotlib.pyplot as plot
+    import numpy as nmp
+    import pandas as pdas
+    import seaborn as sbrn
+    import tkinter as tkr
+    import networkx as nxy
+
+def conventional_aliases():
+    import altair as alt
+    import matplotlib.pyplot as plt
+    import numpy as np
+    import pandas as pd
+    import seaborn as sns
+    import tkinter as tk
+    import networkx as nx

crates/ruff/resources/test/fixtures/flake8_import_conventions/tricky.py

@@ -0,0 +1,9 @@
+"""Test cases for difficult renames."""
+
+
+def rename_global():
+    try:
+        global pandas
+        import pandas
+    except ImportError:
+        return False

crates/ruff/resources/test/fixtures/flake8_pie/PIE808.py

@@ -0,0 +1,13 @@
+# PIE808
+range(0, 10)
+
+# OK
+range(x, 10)
+range(-15, 10)
+range(10)
+range(0)
+range(0, 10, x)
+range(0, 10, 1)
+range(0, 10, step=1)
+range(start=0, stop=10)
+range(0, stop=10)

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT006.py

@@ -64,3 +64,8 @@ def test_implicit_str_concat_no_parens(param1, param2, param3):
 @pytest.mark.parametrize((("param1, " "param2, " "param3")), [(1, 2, 3), (4, 5, 6)])
 def test_implicit_str_concat_with_multi_parens(param1, param2, param3):
     ...
+
+
+@pytest.mark.parametrize(("param1,param2"), [(1, 2), (3, 4)])
+def test_csv_with_parens(param1, param2):
+    ...

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT014.py

@@ -16,11 +16,38 @@ def test_error_expr_simple(x):
     ...
 
 
-@pytest.mark.parametrize("x", [(a, b), (a, b), (b, c)])
+@pytest.mark.parametrize(
+    "x",
+    [
+        (a, b),
+        # comment
+        (a, b),
+        (b, c),
+    ],
+)
 def test_error_expr_complex(x):
     ...
 
 
+@pytest.mark.parametrize("x", [a, b, (a), c, ((a))])
+def test_error_parentheses(x):
+    ...
+
+
+@pytest.mark.parametrize(
+    "x",
+    [
+        a,
+        b,
+        (a),
+        c,
+        ((a)),
+    ],
+)
+def test_error_parentheses_trailing_comma(x):
+    ...
+
+
 @pytest.mark.parametrize("x", [1, 2])
 def test_ok(x):
     ...

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT018.py

@@ -43,3 +43,12 @@ message
 assert something  # OK
 assert something and something_else  # Error
 assert something and something_else and something_third  # Error
+
+
+def test_multiline():
+    assert something and something_else; x = 1
+
+    x = 1; assert something and something_else
+
+    x = 1; \
+        assert something and something_else

crates/ruff/resources/test/fixtures/flake8_raise/RSE102.py

@@ -19,11 +19,20 @@ raise TypeError ()
 raise TypeError \
     ()
 
+# RSE102
+raise TypeError \
+    ();
+
 # RSE102
 raise TypeError(
 
 )
 
+# RSE102
+raise (TypeError) (
+
+)
+
 # RSE102
 raise TypeError(
     # Hello, world!
@@ -52,3 +61,21 @@ class Class:
 
 # OK
 raise Class.error()
+
+
+import ctypes
+
+
+# OK
+raise ctypes.WinError(1)
+
+
+# RSE102
+raise IndexError()from ZeroDivisionError
+
+raise IndexError()\
+from ZeroDivisionError
+
+raise IndexError() from ZeroDivisionError
+
+raise IndexError();

crates/ruff/resources/test/fixtures/flake8_return/RET503.py

@@ -320,3 +320,9 @@ def end_of_statement():
         if True:
             return "" \
                 ;  # type: ignore
+
+
+def end_of_file():
+    if False:
+        return 1
+    x = 2 \

crates/ruff/resources/test/fixtures/flake8_simplify/SIM118.py

@@ -31,6 +31,8 @@ for key in list(obj.keys()):
 
 key in (obj or {}).keys()  # SIM118
 
+(key) in (obj or {}).keys()  # SIM118
+
 from typing import KeysView
 
 

crates/ruff/resources/test/fixtures/flake8_unused_arguments/ARG.py

@@ -27,6 +27,8 @@ def f(cls, x):
 ###
 lambda x: print("Hello, world!")
 
+lambda: print("Hello, world!")
+
 
 class C:
     ###

crates/ruff/resources/test/fixtures/isort/detect_same_package/foo/bar.py

@@ -0,0 +1,3 @@
+import os
+import pandas
+import foo.baz

crates/ruff/resources/test/fixtures/isort/detect_same_package/pyproject.toml

@@ -0,0 +1,2 @@
+[tool.ruff]
+line-length = 88

crates/ruff/resources/test/fixtures/jupyter/add_missing_cell_id.ipynb

@@ -0,0 +1,37 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "import os\n",
+    "\n",
+    "math.pi"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (ruff)",
+   "language": "python",
+   "name": "ruff"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

crates/ruff/resources/test/fixtures/jupyter/no_cell_id.ipynb

@@ -0,0 +1,37 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "import os\n",
+    "\n",
+    "math.pi"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (ruff)",
+   "language": "python",
+   "name": "ruff"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

crates/ruff/resources/test/fixtures/perflint/PERF401.py

@@ -18,11 +18,11 @@ def f():
     result = []
     for i in items:
         if i % 2:
-            result.append(i)  # PERF401
+            result.append(i)  # Ok
         elif i % 2:
-            result.append(i)  # PERF401
+            result.append(i)
         else:
-            result.append(i)  # PERF401
+            result.append(i)
 
 
 def f():
@@ -60,3 +60,15 @@ def f():
     for i in range(20):
         foo.fibonacci.append(sum(foo.fibonacci[-2:]))  # OK
     print(foo.fibonacci)
+
+
+class Foo:
+    def append(self, x):
+        pass
+
+
+def f():
+    items = [1, 2, 3, 4]
+    result = Foo()
+    for i in items:
+        result.append(i)  # Ok

crates/ruff/resources/test/fixtures/perflint/PERF402.py

@@ -24,3 +24,22 @@ def f():
     result = {}
     for i in items:
         result[i].append(i * i)  # OK
+
+
+class Foo:
+    def append(self, x):
+        pass
+
+
+def f():
+    items = [1, 2, 3, 4]
+    result = Foo()
+    for i in items:
+        result.append(i)  # OK
+
+
+def f():
+    import sys
+
+    for path in ("foo", "bar"):
+        sys.path.append(path)  # OK

crates/ruff/resources/test/fixtures/pycodestyle/E23.py

@@ -28,3 +28,6 @@ mdtypes_template = {
     'tag_full': [('mdtype', 'u4'), ('byte_count', 'u4')],
     'tag_smalldata':[('byte_count_mdtype', 'u4'), ('data', 'S4')],
 }
+
+#: Okay
+a = (1,

crates/ruff/resources/test/fixtures/pydocstyle/D200.py

@@ -0,0 +1,13 @@
+def func():
+    """\
+    """
+
+
+def func():
+    """\\
+    """
+
+
+def func():
+    """\ \
+    """

crates/ruff/resources/test/fixtures/pyflakes/F401_0.py

@@ -99,3 +99,16 @@ import foo.bar as bop
 import foo.bar.baz
 
 print(bop.baz.read_csv("test.csv"))
+
+# Test: isolated deletions.
+if TYPE_CHECKING:
+    import a1
+
+    import a2
+
+
+match *0, 1, *2:
+    case 0,:
+        import b1
+
+        import b2

crates/ruff/resources/test/fixtures/pyflakes/F522.py

@@ -2,6 +2,5 @@
 "{bar}{}".format(1, bar=2, spam=3)  # F522
 "{bar:{spam}}".format(bar=2, spam=3)  # No issues
 "{bar:{spam}}".format(bar=2, spam=3, eggs=4, ham=5)  # F522
-# Not fixable
 (''
- .format(x=2))
+ .format(x=2))  # F522

crates/ruff/resources/test/fixtures/pyflakes/F523.py

@@ -28,6 +28,6 @@
 "{1}{3}".format(1, 2, 3, 4)  # F523, # F524
 "{1} {8}".format(0, 1)  # F523, # F524
 
-# Not fixable
+# Multiline
 (''
 .format(2))

crates/ruff/resources/test/fixtures/pyflakes/F841_3.py

@@ -154,3 +154,14 @@ def f() -> None:
         print("hello")
     except A as e :
         print("oh no!")
+
+
+def f():
+    x = 1
+    y = 2
+
+
+def f():
+    x = 1
+
+    y = 2

crates/ruff/resources/test/fixtures/pylint/bad_string_format_character.py

@@ -15,9 +15,11 @@
 "{:s} {:y}".format("hello", "world")  # [bad-format-character]
 
 "{:*^30s}".format("centered") # OK
-"{:{s}}".format("hello", s="s")  # OK (nested replacement value not checked)
-
-"{:{s:y}}".format("hello", s="s")  # [bad-format-character] (nested replacement format spec checked)
+"{:{s}}".format("hello", s="s")  # OK (nested placeholder value not checked)
+"{:{s:y}}".format("hello", s="s")  # [bad-format-character] (nested placeholder format spec checked)
+"{0:.{prec}g}".format(1.23, prec=15)  # OK (cannot validate after nested placeholder)
+"{0:.{foo}{bar}{foobar}y}".format(...)  # OK (cannot validate after nested placeholders)
+"{0:.{foo}x{bar}y{foobar}g}".format(...)  # OK (all nested placeholders are consumed without considering in between chars)
 
 ## f-strings
 

crates/ruff/resources/test/fixtures/pylint/eq_without_hash.py

@@ -1,10 +1,11 @@
-class Person:
+class Person:  # [eq-without-hash]
     def __init__(self):
         self.name = "monty"
 
     def __eq__(self, other):
         return isinstance(other, Person) and other.name == self.name
 
+# OK
 class Language:
     def __init__(self):
         self.name = "python"
@@ -14,3 +15,9 @@ class Language:
 
     def __hash__(self):
         return hash(self.name)
+
+class MyClass:
+    def __eq__(self, other):
+        return True
+
+    __hash__ = None

crates/ruff/resources/test/fixtures/pylint/no_self_use.py

@@ -0,0 +1,62 @@
+import abc
+
+
+class Person:
+    def developer_greeting(self, name):  # [no-self-use]
+        print(f"Greetings {name}!")
+
+    def greeting_1(self):  # [no-self-use]
+        print("Hello!")
+
+    def greeting_2(self):  # [no-self-use]
+        print("Hi!")
+
+
+# OK
+def developer_greeting():
+    print("Greetings developer!")
+
+
+# OK
+class Person:
+    name = "Paris"
+
+    def __init__(self):
+        pass
+
+    def __cmp__(self, other):
+        print(24)
+
+    def __repr__(self):
+        return "Person"
+
+    def func(self):
+        ...
+
+    def greeting_1(self):
+        print(f"Hello from {self.name} !")
+
+    @staticmethod
+    def greeting_2():
+        print("Hi!")
+
+
+class Base(abc.ABC):
+    """abstract class"""
+
+    @abstractmethod
+    def abstract_method(self):
+        """abstract method could not be a function"""
+        raise NotImplementedError
+
+
+class Sub(Base):
+    @override
+    def abstract_method(self):
+        print("concret method")
+
+
+class Prop:
+    @property
+    def count(self):
+        return 24

crates/ruff/resources/test/fixtures/pylint/repeated_equality_comparison_target.py

@@ -9,13 +9,22 @@ foo != "a" and foo != "b" and foo != "c"
 
 foo == a or foo == "b" or foo == 3  # Mixed types.
 
-# False negatives (the current implementation doesn't support Yoda conditions).
 "a" == foo or "b" == foo or "c" == foo
 
 "a" != foo and "b" != foo and "c" != foo
 
 "a" == foo or foo == "b" or "c" == foo
 
+foo == bar or baz == foo or qux == foo
+
+foo == "a" or "b" == foo or foo == "c"
+
+foo != "a" and "b" != foo and foo != "c"
+
+foo == "a" or foo == "b" or "c" == bar or "d" == bar  # Multiple targets
+
+foo.bar == "a" or foo.bar == "b"  # Attributes.
+
 # OK
 foo == "a" and foo == "b" and foo == "c"  # `and` mixed with `==`.
 
@@ -32,3 +41,13 @@ foo not in {"a", "b", "c"}  # Uses membership test already.
 foo == "a"  # Single comparison.
 
 foo != "a"  # Single comparison.
+
+foo == "a" == "b" or foo == "c"  # Multiple comparisons.
+
+foo == bar == "b" or foo == "c"  # Multiple comparisons.
+
+foo == foo or foo == bar  # Self-comparison.
+
+foo[0] == "a" or foo[0] == "b"  # Subscripts.
+
+foo() == "a" or foo() == "b"  # Calls.

crates/ruff/resources/test/fixtures/pylint/sys_exit_alias_11.py

@@ -0,0 +1,3 @@
+from sys import *
+
+exit(0)

crates/ruff/resources/test/fixtures/pyupgrade/UP007.py

@@ -59,3 +59,35 @@ def f() -> None:
     x = Union["str", "int"]
     x: Union[str, int]
     x: Union["str", "int"]
+
+
+def f(x: Union[int : float]) -> None:
+    ...
+
+
+def f(x: Union[str, int : float]) -> None:
+    ...
+
+
+def f(x: Union[x := int]) -> None:
+    ...
+
+
+def f(x: Union[str, x := int]) -> None:
+    ...
+
+
+def f(x: Union[lambda: int]) -> None:
+    ...
+
+
+def f(x: Union[str, lambda: int]) -> None:
+    ...
+
+
+def f(x: Optional[int : float]) -> None:
+    ...
+
+
+def f(x: Optional[str, int : float]) -> None:
+    ...

crates/ruff/resources/test/fixtures/pyupgrade/UP009_10.py

@@ -0,0 +1,7 @@
+"""
+# coding=utf8""" # empty comment
+
+"""
+Invalid coding declaration since it is nested inside a docstring
+The following empty comment tests for false positives as our implementation visits comments
+"""

crates/ruff/resources/test/fixtures/pyupgrade/UP009_6.py

@@ -0,0 +1,7 @@
+ # coding=utf8
+print("Hello world")
+
+"""
+Regression test for https://github.com/astral-sh/ruff/issues/6756
+The leading space must be removed to prevent invalid syntax.
+"""

crates/ruff/resources/test/fixtures/pyupgrade/UP009_7.py

@@ -0,0 +1,7 @@
+	# coding=utf8
+print("Hello world")
+
+"""
+Regression test for https://github.com/astral-sh/ruff/issues/6756
+The leading tab must be removed to prevent invalid syntax.
+"""

crates/ruff/resources/test/fixtures/pyupgrade/UP009_8.py

@@ -0,0 +1,6 @@
+print("foo") # coding=utf8
+print("Hello world")
+
+"""
+Invalid coding declaration due to a statement before the comment
+"""

crates/ruff/resources/test/fixtures/pyupgrade/UP009_9.py

@@ -0,0 +1,7 @@
+x = 1 \
+  # coding=utf8
+x = 2
+
+"""
+Invalid coding declaration due to continuation on preceding line
+"""

crates/ruff/resources/test/fixtures/pyupgrade/UP014.py

@@ -22,3 +22,4 @@ MyType = typing.NamedTuple("MyType", a=int, b=tuple[str, ...])
 # unfixable
 MyType = typing.NamedTuple("MyType", [("a", int)], [("b", str)])
 MyType = typing.NamedTuple("MyType", [("a", int)], b=str)
+MyType = typing.NamedTuple(typename="MyType", a=int, b=str)

crates/ruff/resources/test/fixtures/pyupgrade/UP018.py

@@ -31,6 +31,7 @@ bool("foo")
 bool("")
 bool(b"")
 bool(1.0)
+int().denominator
 
 # These become string or byte literals
 str()
@@ -49,3 +50,6 @@ float(1.0)
 bool()
 bool(True)
 bool(False)
+
+# These become a literal but retain parentheses
+int(1).denominator

crates/ruff/resources/test/fixtures/refurb/FURB113.py

@@ -0,0 +1,169 @@
+from typing import List
+
+
+def func():
+    pass
+
+
+nums = []
+nums2 = []
+nums3: list[int] = func()
+nums4: List[int]
+
+
+class C:
+    def append(self, x):
+        pass
+
+
+# Errors.
+
+
+# FURB113
+nums.append(1)
+nums.append(2)
+pass
+
+
+# FURB113
+nums3.append(1)
+nums3.append(2)
+pass
+
+
+# FURB113
+nums4.append(1)
+nums4.append(2)
+pass
+
+
+# FURB113
+nums.append(1)
+nums2.append(1)
+nums.append(2)
+nums.append(3)
+pass
+
+
+# FURB113
+nums.append(1)
+nums2.append(1)
+nums.append(2)
+# FURB113
+nums3.append(1)
+nums.append(3)
+# FURB113
+nums4.append(1)
+nums4.append(2)
+nums3.append(2)
+pass
+
+# FURB113
+nums.append(1)
+nums.append(2)
+nums.append(3)
+
+
+if True:
+    # FURB113
+    nums.append(1)
+    nums.append(2)
+
+
+if True:
+    # FURB113
+    nums.append(1)
+    nums.append(2)
+    pass
+
+
+if True:
+    # FURB113
+    nums.append(1)
+    nums2.append(1)
+    nums.append(2)
+    nums.append(3)
+
+
+def yes_one(x: list[int]):
+    # FURB113
+    x.append(1)
+    x.append(2)
+
+
+def yes_two(x: List[int]):
+    # FURB113
+    x.append(1)
+    x.append(2)
+
+
+def yes_three(*, x: list[int]):
+    # FURB113
+    x.append(1)
+    x.append(2)
+
+
+def yes_four(x: list[int], /):
+    # FURB113
+    x.append(1)
+    x.append(2)
+
+
+def yes_five(x: list[int], y: list[int]):
+    # FURB113
+    x.append(1)
+    x.append(2)
+    y.append(1)
+    x.append(3)
+
+
+def yes_six(x: list):
+    # FURB113
+    x.append(1)
+    x.append(2)
+
+
+# Non-errors.
+
+nums.append(1)
+pass
+nums.append(2)
+
+
+if True:
+    nums.append(1)
+    pass
+    nums.append(2)
+
+
+nums.append(1)
+pass
+
+
+nums.append(1)
+nums2.append(2)
+
+
+nums.copy()
+nums.copy()
+
+
+c = C()
+c.append(1)
+c.append(2)
+
+
+def not_one(x):
+    x.append(1)
+    x.append(2)
+
+
+def not_two(x: C):
+    x.append(1)
+    x.append(2)
+
+
+# redefining a list variable with a new type shouldn't confuse ruff.
+nums2 = C()
+nums2.append(1)
+nums2.append(2)

crates/ruff/resources/test/fixtures/refurb/FURB131.py

@@ -0,0 +1,64 @@
+from typing import Dict, List
+
+names = {"key": "value"}
+nums = [1, 2, 3]
+x = 42
+y = "hello"
+
+# these should match
+
+# FURB131
+del nums[:]
+
+
+# FURB131
+del names[:]
+
+
+# FURB131
+del x, nums[:]
+
+
+# FURB131
+del y, names[:], x
+
+
+def yes_one(x: list[int]):
+    # FURB131
+    del x[:]
+
+
+def yes_two(x: dict[int, str]):
+    # FURB131
+    del x[:]
+
+
+def yes_three(x: List[int]):
+    # FURB131
+    del x[:]
+
+
+def yes_four(x: Dict[int, str]):
+    # FURB131
+    del x[:]
+
+
+# these should not
+
+del names["key"]
+del nums[0]
+
+x = 1
+del x
+
+
+del nums[1:2]
+
+
+del nums[:2]
+del nums[1:]
+del nums[::2]
+
+
+def no_one(param):
+    del param[:]

crates/ruff/resources/test/fixtures/refurb/FURB132.py

@@ -0,0 +1,80 @@
+from typing import Set
+from some.package.name import foo, bar
+
+
+s = set()
+s2 = {}
+s3: set[int] = foo()
+
+# these should match
+
+# FURB132
+if "x" in s:
+    s.remove("x")
+
+
+# FURB132
+if "x" in s2:
+    s2.remove("x")
+
+
+# FURB132
+if "x" in s3:
+    s3.remove("x")
+
+
+var = "y"
+# FURB132
+if var in s:
+    s.remove(var)
+
+
+if f"{var}:{var}" in s:
+    s.remove(f"{var}:{var}")
+
+
+def identity(x):
+    return x
+
+
+# TODO: FURB132
+if identity("x") in s2:
+    s2.remove(identity("x"))
+
+
+# these should not
+
+if "x" in s:
+    s.remove("y")
+
+s.discard("x")
+
+s2 = set()
+
+if "x" in s:
+    s2.remove("x")
+
+if "x" in s:
+    s.remove("x")
+    print("removed item")
+
+if bar() in s:
+    # bar() might have a side effect
+    s.remove(bar())
+
+if "x" in s:
+    s.remove("x")
+else:
+    print("not found")
+
+class Container:
+    def remove(self, item) -> None:
+        return
+
+    def __contains__(self, other) -> bool:
+        return True
+
+c = Container()
+
+if "x" in c:
+    c.remove("x")

crates/ruff/resources/test/fixtures/ruff/RUF100_5.py

@@ -0,0 +1,11 @@
+#import os  # noqa
+#import os  # noqa: ERA001
+
+dictionary = {
+    # "key1": 123,  # noqa: ERA001
+    # "key2": 456,  # noqa
+    # "key3": 789,
+}
+
+
+#import os  # noqa: E501

crates/ruff/src/autofix/codemods.rs

@@ -4,8 +4,8 @@ use anyhow::{bail, Result};
 use libcst_native::{
     Codegen, CodegenState, ImportNames, ParenthesizableWhitespace, SmallStatement, Statement,
 };
-use ruff_python_ast::{Ranged, Stmt};
 
+use ruff_python_ast::Stmt;
 use ruff_python_codegen::Stylist;
 use ruff_source_file::Locator;
 
@@ -38,7 +38,7 @@ pub(crate) fn remove_imports<'a>(
     locator: &Locator,
     stylist: &Stylist,
 ) -> Result<Option<String>> {
-    let module_text = locator.slice(stmt.range());
+    let module_text = locator.slice(stmt);
     let mut tree = match_statement(module_text)?;
 
     let Statement::Simple(body) = &mut tree else {
@@ -117,7 +117,7 @@ pub(crate) fn retain_imports(
     locator: &Locator,
     stylist: &Stylist,
 ) -> Result<String> {
-    let module_text = locator.slice(stmt.range());
+    let module_text = locator.slice(stmt);
     let mut tree = match_statement(module_text)?;
 
     let Statement::Simple(body) = &mut tree else {

crates/ruff/src/autofix/edits.rs

@@ -1,17 +1,16 @@
 //! Interface for generating autofix edits from higher-level actions (e.g., "remove an argument").
 
-use anyhow::{bail, Result};
+use anyhow::{Context, Result};
 
 use ruff_diagnostics::Edit;
-use ruff_python_ast::{
-    self as ast, Arguments, ExceptHandler, Expr, Keyword, PySourceType, Ranged, Stmt,
-};
+use ruff_python_ast::{self as ast, Arguments, ExceptHandler, Expr, Keyword, Stmt};
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
-use ruff_python_parser::{lexer, AsMode};
-use ruff_python_trivia::{has_leading_content, is_python_whitespace, PythonWhitespace};
+use ruff_python_trivia::{
+    has_leading_content, is_python_whitespace, PythonWhitespace, SimpleTokenKind, SimpleTokenizer,
+};
 use ruff_source_file::{Locator, NewlineWithTrailingNewline};
-use ruff_text_size::{TextLen, TextRange, TextSize};
+use ruff_text_size::{Ranged, TextLen, TextSize};
 
 use crate::autofix::codemods;
 
@@ -48,7 +47,7 @@ pub(crate) fn delete_stmt(
         } else if has_leading_content(stmt.start(), locator) {
             Edit::range_deletion(stmt.range())
         } else if let Some(start) = indexer.preceded_by_continuations(stmt.start(), locator) {
-            Edit::range_deletion(TextRange::new(start, stmt.end()))
+            Edit::deletion(start, stmt.end())
         } else {
             let range = locator.full_lines_range(stmt.range());
             Edit::range_deletion(range)
@@ -89,83 +88,52 @@ pub(crate) fn remove_argument<T: Ranged>(
     argument: &T,
     arguments: &Arguments,
     parentheses: Parentheses,
-    locator: &Locator,
-    source_type: PySourceType,
+    source: &str,
 ) -> Result<Edit> {
-    // TODO(sbrugman): Preserve trailing comments.
-    if arguments.keywords.len() + arguments.args.len() > 1 {
-        let mut fix_start = None;
-        let mut fix_end = None;
+    // Partition into arguments before and after the argument to remove.
+    let (before, after): (Vec<_>, Vec<_>) = arguments
+        .args
+        .iter()
+        .map(Expr::range)
+        .chain(arguments.keywords.iter().map(Keyword::range))
+        .filter(|range| argument.range() != *range)
+        .partition(|range| range.start() < argument.start());
 
-        if arguments
-            .args
-            .iter()
-            .map(Expr::start)
-            .chain(arguments.keywords.iter().map(Keyword::start))
-            .any(|location| location > argument.start())
-        {
-            // Case 1: argument or keyword is _not_ the last node, so delete from the start of the
-            // argument to the end of the subsequent comma.
-            let mut seen_comma = false;
-            for (tok, range) in lexer::lex_starts_at(
-                locator.slice(arguments.range()),
-                source_type.as_mode(),
-                arguments.start(),
-            )
-            .flatten()
-            {
-                if seen_comma {
-                    if tok.is_non_logical_newline() {
-                        // Also delete any non-logical newlines after the comma.
-                        continue;
-                    }
-                    fix_end = Some(if tok.is_newline() {
-                        range.end()
-                    } else {
-                        range.start()
-                    });
-                    break;
-                }
-                if range.start() == argument.start() {
-                    fix_start = Some(range.start());
-                }
-                if fix_start.is_some() && tok.is_comma() {
-                    seen_comma = true;
-                }
-            }
-        } else {
-            // Case 2: argument or keyword is the last node, so delete from the start of the
-            // previous comma to the end of the argument.
-            for (tok, range) in lexer::lex_starts_at(
-                locator.slice(arguments.range()),
-                source_type.as_mode(),
-                arguments.start(),
-            )
-            .flatten()
-            {
-                if range.start() == argument.start() {
-                    fix_end = Some(argument.end());
-                    break;
-                }
-                if tok.is_comma() {
-                    fix_start = Some(range.start());
-                }
-            }
-        }
+    if !after.is_empty() {
+        // Case 1: argument or keyword is _not_ the last node, so delete from the start of the
+        // argument to the end of the subsequent comma.
+        let mut tokenizer = SimpleTokenizer::starts_at(argument.end(), source);
 
-        match (fix_start, fix_end) {
-            (Some(start), Some(end)) => Ok(Edit::deletion(start, end)),
-            _ => {
-                bail!("No fix could be constructed")
-            }
-        }
+        // Find the trailing comma.
+        tokenizer
+            .find(|token| token.kind == SimpleTokenKind::Comma)
+            .context("Unable to find trailing comma")?;
+
+        // Find the next non-whitespace token.
+        let next = tokenizer
+            .find(|token| {
+                token.kind != SimpleTokenKind::Whitespace && token.kind != SimpleTokenKind::Newline
+            })
+            .context("Unable to find next token")?;
+
+        Ok(Edit::deletion(argument.start(), next.start()))
+    } else if let Some(previous) = before.iter().map(Ranged::end).max() {
+        // Case 2: argument or keyword is the last node, so delete from the start of the
+        // previous comma to the end of the argument.
+        let mut tokenizer = SimpleTokenizer::starts_at(previous, source);
+
+        // Find the trailing comma.
+        let comma = tokenizer
+            .find(|token| token.kind == SimpleTokenKind::Comma)
+            .context("Unable to find trailing comma")?;
+
+        Ok(Edit::deletion(comma.start(), argument.end()))
     } else {
-        // Only one argument; remove it (but preserve parentheses, if needed).
+        // Case 3: argument or keyword is the only node, so delete the arguments (but preserve
+        // parentheses, if needed).
         Ok(match parentheses {
-            Parentheses::Remove => Edit::deletion(arguments.start(), arguments.end()),
-            Parentheses::Preserve => {
-                Edit::replacement("()".to_string(), arguments.start(), arguments.end())
-            }
+            Parentheses::Remove => Edit::range_deletion(arguments.range()),
+            Parentheses::Preserve => Edit::range_replacement("()".to_string(), arguments.range()),
         })
     }
 }
@@ -257,25 +225,25 @@ fn trailing_semicolon(offset: TextSize, locator: &Locator) -> Option<TextSize> {
 fn next_stmt_break(semicolon: TextSize, locator: &Locator) -> TextSize {
     let start_location = semicolon + TextSize::from(1);
 
-    let contents = &locator.contents()[usize::from(start_location)..];
-    for line in NewlineWithTrailingNewline::from(contents) {
+    for line in
+        NewlineWithTrailingNewline::with_offset(locator.after(start_location), start_location)
+    {
         let trimmed = line.trim_whitespace();
         // Skip past any continuations.
         if trimmed.starts_with('\\') {
             continue;
         }
 
-        return start_location
-            + if trimmed.is_empty() {
-                // If the line is empty, then despite the previous statement ending in a
-                // semicolon, we know that it's not a multi-statement line.
-                line.start()
-            } else {
-                // Otherwise, find the start of the next statement. (Or, anything that isn't
-                // whitespace.)
-                let relative_offset = line.find(|c: char| !is_python_whitespace(c)).unwrap();
-                line.start() + TextSize::try_from(relative_offset).unwrap()
-            };
+        return if trimmed.is_empty() {
+            // If the line is empty, then despite the previous statement ending in a
+            // semicolon, we know that it's not a multi-statement line.
+            line.start()
+        } else {
+            // Otherwise, find the start of the next statement. (Or, anything that isn't
+            // whitespace.)
+            let relative_offset = line.find(|c: char| !is_python_whitespace(c)).unwrap();
+            line.start() + TextSize::try_from(relative_offset).unwrap()
+        };
     }
 
     locator.line_end(start_location)
@@ -285,10 +253,9 @@ fn next_stmt_break(semicolon: TextSize, locator: &Locator) -> TextSize {
 mod tests {
     use anyhow::Result;
 
-    use ruff_python_ast::Ranged;
     use ruff_python_parser::parse_suite;
     use ruff_source_file::Locator;
-    use ruff_text_size::TextSize;
+    use ruff_text_size::{Ranged, TextSize};
 
     use crate::autofix::edits::{next_stmt_break, trailing_semicolon};
 

crates/ruff/src/autofix/mod.rs

@@ -1,7 +1,7 @@
 use itertools::Itertools;
 use std::collections::BTreeSet;
 
-use ruff_text_size::{TextLen, TextRange, TextSize};
+use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 use rustc_hash::{FxHashMap, FxHashSet};
 
 use ruff_diagnostics::{Diagnostic, Edit, Fix, IsolationLevel};
@@ -13,6 +13,7 @@ use crate::registry::{AsRule, Rule};
 
 pub(crate) mod codemods;
 pub(crate) mod edits;
+pub(crate) mod snippet;
 pub(crate) mod source_map;
 
 pub(crate) struct FixResult {
@@ -137,11 +138,9 @@ fn cmp_fix(rule1: Rule, rule2: Rule, fix1: &Fix, fix2: &Fix) -> std::cmp::Orderi
 
 #[cfg(test)]
 mod tests {
-    use ruff_text_size::TextSize;
+    use ruff_text_size::{Ranged, TextSize};
 
-    use ruff_diagnostics::Diagnostic;
-    use ruff_diagnostics::Edit;
-    use ruff_diagnostics::Fix;
+    use ruff_diagnostics::{Diagnostic, Edit, Fix};
     use ruff_source_file::Locator;
 
     use crate::autofix::source_map::SourceMarker;

crates/ruff/src/autofix/snippet.rs

@@ -0,0 +1,40 @@
+use unicode_width::UnicodeWidthStr;
+
+/// A snippet of source code for user-facing display, as in a diagnostic.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct SourceCodeSnippet(String);
+
+impl SourceCodeSnippet {
+    pub(crate) fn new(source_code: String) -> Self {
+        Self(source_code)
+    }
+
+    pub(crate) fn from_str(source_code: &str) -> Self {
+        Self(source_code.to_string())
+    }
+
+    /// Return the full snippet for user-facing display, or `None` if the snippet should be
+    /// truncated.
+    pub(crate) fn full_display(&self) -> Option<&str> {
+        if Self::should_truncate(&self.0) {
+            None
+        } else {
+            Some(&self.0)
+        }
+    }
+
+    /// Return a truncated snippet for user-facing display.
+    pub(crate) fn truncated_display(&self) -> &str {
+        if Self::should_truncate(&self.0) {
+            "..."
+        } else {
+            &self.0
+        }
+    }
+
+    /// Returns `true` if the source code should be truncated when included in a user-facing
+    /// diagnostic.
+    fn should_truncate(source_code: &str) -> bool {
+        source_code.width() > 50 || source_code.contains(['\r', '\n'])
+    }
+}

crates/ruff/src/autofix/source_map.rs

@@ -1,4 +1,4 @@
-use ruff_text_size::TextSize;
+use ruff_text_size::{Ranged, TextSize};
 
 use ruff_diagnostics::Edit;
 

crates/ruff/src/checkers/ast/analyze/bindings.rs

@@ -1,5 +1,5 @@
 use ruff_diagnostics::{Diagnostic, Fix};
-use ruff_python_ast::Ranged;
+use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;

crates/ruff/src/checkers/ast/analyze/comprehension.rs

@@ -7,10 +7,6 @@ use crate::rules::flake8_simplify;
 /// Run lint rules over a [`Comprehension`] syntax nodes.
 pub(crate) fn comprehension(comprehension: &Comprehension, checker: &mut Checker) {
     if checker.enabled(Rule::InDictKeys) {
-        flake8_simplify::rules::key_in_dict_for(
-            checker,
-            &comprehension.target,
-            &comprehension.iter,
-        );
+        flake8_simplify::rules::key_in_dict_comprehension(checker, comprehension);
     }
 }

crates/ruff/src/checkers/ast/analyze/deferred_for_loops.rs

@@ -1,8 +1,8 @@
-use ruff_python_ast::{self as ast, Stmt};
+use ruff_python_ast::Stmt;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
-use crate::rules::{flake8_bugbear, perflint};
+use crate::rules::{flake8_bugbear, perflint, pyupgrade};
 
 /// Run lint rules over all deferred for-loops in the [`SemanticModel`].
 pub(crate) fn deferred_for_loops(checker: &mut Checker) {
@@ -11,18 +11,18 @@ pub(crate) fn deferred_for_loops(checker: &mut Checker) {
         for snapshot in for_loops {
             checker.semantic.restore(snapshot);
 
-            let Stmt::For(ast::StmtFor {
-                target, iter, body, ..
-            }) = checker.semantic.current_statement()
-            else {
+            let Stmt::For(stmt_for) = checker.semantic.current_statement() else {
                 unreachable!("Expected Stmt::For");
             };
 
             if checker.enabled(Rule::UnusedLoopControlVariable) {
-                flake8_bugbear::rules::unused_loop_control_variable(checker, target, body);
+                flake8_bugbear::rules::unused_loop_control_variable(checker, stmt_for);
             }
             if checker.enabled(Rule::IncorrectDictIterator) {
-                perflint::rules::incorrect_dict_iterator(checker, target, iter);
+                perflint::rules::incorrect_dict_iterator(checker, stmt_for);
+            }
+            if checker.enabled(Rule::YieldInForLoop) {
+                pyupgrade::rules::yield_in_for_loop(checker, stmt_for);
             }
         }
     }

crates/ruff/src/checkers/ast/analyze/deferred_scopes.rs

@@ -1,7 +1,7 @@
 use ruff_diagnostics::Diagnostic;
-use ruff_python_ast::Ranged;
-use ruff_python_semantic::analyze::{branch_detection, visibility};
+use ruff_python_semantic::analyze::visibility;
 use ruff_python_semantic::{Binding, BindingKind, ScopeKind};
+use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
@@ -30,6 +30,7 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
         Rule::UnusedPrivateTypedDict,
         Rule::UnusedStaticMethodArgument,
         Rule::UnusedVariable,
+        Rule::NoSelfUse,
     ]) {
         return;
     }
@@ -112,11 +113,7 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                     // If the bindings are in different forks, abort.
                     if shadowed.source.map_or(true, |left| {
                         binding.source.map_or(true, |right| {
-                            branch_detection::different_forks(
-                                left,
-                                right,
-                                checker.semantic.statements(),
-                            )
+                            checker.semantic.different_branches(left, right)
                         })
                     }) {
                         continue;
@@ -172,7 +169,7 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                             continue;
                         }
 
-                        let Some(statement_id) = shadowed.source else {
+                        let Some(node_id) = shadowed.source else {
                             continue;
                         };
 
@@ -180,7 +177,7 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                         if shadowed.kind.is_function_definition() {
                             if checker
                                 .semantic
-                                .statement(statement_id)
+                                .statement(node_id)
                                 .as_function_def_stmt()
                                 .is_some_and(|function| {
                                     visibility::is_overload(
@@ -208,11 +205,7 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                     // If the bindings are in different forks, abort.
                     if shadowed.source.map_or(true, |left| {
                         binding.source.map_or(true, |right| {
-                            branch_detection::different_forks(
-                                left,
-                                right,
-                                checker.semantic.statements(),
-                            )
+                            checker.semantic.different_branches(left, right)
                         })
                     }) {
                         continue;
@@ -310,6 +303,12 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                 pyflakes::rules::unused_import(checker, scope, &mut diagnostics);
             }
         }
+
+        if scope.kind.is_function() {
+            if checker.enabled(Rule::NoSelfUse) {
+                pylint::rules::no_self_use(checker, scope, &mut diagnostics);
+            }
+        }
     }
     checker.diagnostics.extend(diagnostics);
 }

crates/ruff/src/checkers/ast/analyze/definitions.rs

@@ -1,6 +1,5 @@
 use ruff_python_ast::str::raw_contents_range;
-use ruff_python_ast::Ranged;
-use ruff_text_size::TextRange;
+use ruff_text_size::{Ranged, TextRange};
 
 use ruff_python_semantic::{BindingKind, ContextualizedDefinition, Export};
 
@@ -164,9 +163,9 @@ pub(crate) fn definitions(checker: &mut Checker) {
                 continue;
             };
 
-            let contents = checker.locator.slice(expr.range());
+            let contents = checker.locator().slice(expr);
 
-            let indentation = checker.locator.slice(TextRange::new(
+            let indentation = checker.locator().slice(TextRange::new(
                 checker.locator.line_start(expr.start()),
                 expr.start(),
             ));

crates/ruff/src/checkers/ast/analyze/except_handler.rs

@@ -1,4 +1,5 @@
-use ruff_python_ast::{self as ast, ExceptHandler, Ranged};
+use ruff_python_ast::{self as ast, ExceptHandler};
+use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::registry::Rule;

crates/ruff/src/checkers/ast/analyze/expression.rs

@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Arguments, Constant, Expr, ExprContext, Operator, Ranged};
+use ruff_python_ast::{self as ast, Arguments, Constant, Expr, ExprContext, Operator};
 use ruff_python_literal::cformat::{CFormatError, CFormatErrorType};
 
 use ruff_diagnostics::Diagnostic;
@@ -6,6 +6,7 @@ use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::types::Node;
 use ruff_python_semantic::analyze::typing;
 use ruff_python_semantic::ScopeKind;
+use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::registry::Rule;
@@ -381,34 +382,34 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                                 Ok(summary) => {
                                     if checker.enabled(Rule::StringDotFormatExtraNamedArguments) {
                                         pyflakes::rules::string_dot_format_extra_named_arguments(
-                                            checker, &summary, keywords, location,
+                                            checker, call, &summary, keywords,
                                         );
                                     }
                                     if checker
                                         .enabled(Rule::StringDotFormatExtraPositionalArguments)
                                     {
                                         pyflakes::rules::string_dot_format_extra_positional_arguments(
-                                            checker, &summary, args, location,
+                                            checker, call, &summary, args,
                                         );
                                     }
                                     if checker.enabled(Rule::StringDotFormatMissingArguments) {
                                         pyflakes::rules::string_dot_format_missing_argument(
-                                            checker, &summary, args, keywords, location,
+                                            checker, call, &summary, args, keywords,
                                         );
                                     }
                                     if checker.enabled(Rule::StringDotFormatMixingAutomatic) {
                                         pyflakes::rules::string_dot_format_mixing_automatic(
-                                            checker, &summary, location,
+                                            checker, call, &summary,
                                         );
                                     }
                                     if checker.enabled(Rule::FormatLiterals) {
-                                        pyupgrade::rules::format_literals(checker, &summary, call);
+                                        pyupgrade::rules::format_literals(checker, call, &summary);
                                     }
                                     if checker.enabled(Rule::FString) {
                                         pyupgrade::rules::f_strings(
                                             checker,
+                                            call,
                                             &summary,
-                                            expr,
                                             value,
                                             checker.settings.line_length,
                                         );
@@ -432,7 +433,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 pyupgrade::rules::deprecated_unittest_alias(checker, func);
             }
             if checker.enabled(Rule::SuperCallWithParameters) {
-                pyupgrade::rules::super_call_with_parameters(checker, expr, func, args);
+                pyupgrade::rules::super_call_with_parameters(checker, call);
             }
             if checker.enabled(Rule::UnnecessaryEncodeUTF8) {
                 pyupgrade::rules::unnecessary_encode_utf8(checker, call);
@@ -441,7 +442,11 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 pyupgrade::rules::redundant_open_modes(checker, call);
             }
             if checker.enabled(Rule::NativeLiterals) {
-                pyupgrade::rules::native_literals(checker, expr, func, args, keywords);
+                pyupgrade::rules::native_literals(
+                    checker,
+                    call,
+                    checker.semantic().current_expression_parent(),
+                );
             }
             if checker.enabled(Rule::OpenAlias) {
                 pyupgrade::rules::open_alias(checker, expr, func);
@@ -531,6 +536,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             if checker.enabled(Rule::UnnecessaryDictKwargs) {
                 flake8_pie::rules::unnecessary_dict_kwargs(checker, expr, keywords);
             }
+            if checker.enabled(Rule::UnnecessaryRangeStart) {
+                flake8_pie::rules::unnecessary_range_start(checker, call);
+            }
             if checker.enabled(Rule::ExecBuiltin) {
                 flake8_bandit::rules::exec_used(checker, func);
             }
@@ -1031,12 +1039,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                     }
                 }
                 if checker.enabled(Rule::PrintfStringFormatting) {
-                    pyupgrade::rules::printf_string_formatting(
-                        checker,
-                        expr,
-                        right,
-                        checker.locator,
-                    );
+                    pyupgrade::rules::printf_string_formatting(checker, expr, right);
                 }
                 if checker.enabled(Rule::BadStringFormatCharacter) {
                     pylint::rules::bad_string_format_character::percent(checker, expr);
@@ -1175,7 +1178,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 pylint::rules::magic_value_comparison(checker, left, comparators);
             }
             if checker.enabled(Rule::InDictKeys) {
-                flake8_simplify::rules::key_in_dict_compare(checker, expr, left, ops, comparators);
+                flake8_simplify::rules::key_in_dict_compare(checker, compare);
             }
             if checker.enabled(Rule::YodaConditions) {
                 flake8_simplify::rules::yoda_conditions(checker, expr, left, ops, comparators);

crates/ruff/src/checkers/ast/analyze/parameter.rs

@@ -1,4 +1,5 @@
-use ruff_python_ast::{Parameter, Ranged};
+use ruff_python_ast::Parameter;
+use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;

crates/ruff/src/checkers/ast/analyze/statement.rs

@@ -1,11 +1,10 @@
-use ruff_python_ast::{self as ast, Expr, Ranged, Stmt};
-
 use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::helpers;
-
 use ruff_python_ast::types::Node;
+use ruff_python_ast::{self as ast, Expr, Stmt};
 use ruff_python_semantic::analyze::typing;
 use ruff_python_semantic::ScopeKind;
+use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::registry::Rule;
@@ -14,7 +13,7 @@ use crate::rules::{
     flake8_django, flake8_errmsg, flake8_import_conventions, flake8_pie, flake8_pyi,
     flake8_pytest_style, flake8_raise, flake8_return, flake8_simplify, flake8_slots,
     flake8_tidy_imports, flake8_type_checking, mccabe, pandas_vet, pep8_naming, perflint,
-    pycodestyle, pyflakes, pygrep_hooks, pylint, pyupgrade, ruff, tryceratops,
+    pycodestyle, pyflakes, pygrep_hooks, pylint, pyupgrade, refurb, ruff, tryceratops,
 };
 use crate::settings::types::PythonVersion;
 
@@ -338,9 +337,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::FStringDocstring) {
                 flake8_bugbear::rules::f_string_docstring(checker, body);
             }
-            if checker.enabled(Rule::YieldInForLoop) {
-                pyupgrade::rules::yield_in_for_loop(checker, stmt);
-            }
             if let ScopeKind::Class(class_def) = checker.semantic.current_scope().kind {
                 if checker.enabled(Rule::BuiltinAttributeShadowing) {
                     flake8_builtins::rules::builtin_method_shadowing(
@@ -467,17 +463,17 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     flake8_pyi::rules::pass_statement_stub_body(checker, body);
                 }
                 if checker.enabled(Rule::PassInClassBody) {
-                    flake8_pyi::rules::pass_in_class_body(checker, stmt, body);
+                    flake8_pyi::rules::pass_in_class_body(checker, class_def);
                 }
             }
             if checker.enabled(Rule::EllipsisInNonEmptyClassBody) {
-                flake8_pyi::rules::ellipsis_in_non_empty_class_body(checker, stmt, body);
+                flake8_pyi::rules::ellipsis_in_non_empty_class_body(checker, body);
             }
             if checker.enabled(Rule::PytestIncorrectMarkParenthesesStyle) {
                 flake8_pytest_style::rules::marks(checker, decorator_list);
             }
             if checker.enabled(Rule::DuplicateClassFieldDefinition) {
-                flake8_pie::rules::duplicate_class_field_definition(checker, stmt, body);
+                flake8_pie::rules::duplicate_class_field_definition(checker, body);
             }
             if checker.enabled(Rule::NonUniqueEnums) {
                 flake8_pie::rules::non_unique_enums(checker, stmt, body);
@@ -1060,6 +1056,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     checker.diagnostics.push(diagnostic);
                 }
             }
+            if checker.enabled(Rule::CheckAndRemoveFromSet) {
+                refurb::rules::check_and_remove_from_set(checker, if_);
+            }
             if checker.source_type.is_stub() {
                 if checker.any_enabled(&[
                     Rule::UnrecognizedVersionInfoCheck,
@@ -1142,7 +1141,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 pygrep_hooks::rules::non_existent_mock_method(checker, test);
             }
         }
-        Stmt::With(with_ @ ast::StmtWith { items, body, .. }) => {
+        Stmt::With(with_stmt @ ast::StmtWith { items, body, .. }) => {
             if checker.enabled(Rule::AssertRaisesException) {
                 flake8_bugbear::rules::assert_raises_exception(checker, items);
             }
@@ -1152,7 +1151,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::MultipleWithStatements) {
                 flake8_simplify::rules::multiple_with_statements(
                     checker,
-                    with_,
+                    with_stmt,
                     checker.semantic.current_statement_parent(),
                 );
             }
@@ -1171,15 +1170,21 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 perflint::rules::try_except_in_loop(checker, body);
             }
         }
-        Stmt::For(ast::StmtFor {
-            target,
-            body,
-            iter,
-            orelse,
-            ..
-        }) => {
-            if checker.any_enabled(&[Rule::UnusedLoopControlVariable, Rule::IncorrectDictIterator])
-            {
+        Stmt::For(
+            for_stmt @ ast::StmtFor {
+                target,
+                body,
+                iter,
+                orelse,
+                is_async,
+                ..
+            },
+        ) => {
+            if checker.any_enabled(&[
+                Rule::UnusedLoopControlVariable,
+                Rule::IncorrectDictIterator,
+                Rule::YieldInForLoop,
+            ]) {
                 checker.deferred.for_loops.push(checker.semantic.snapshot());
             }
             if checker.enabled(Rule::LoopVariableOverridesIterator) {
@@ -1200,17 +1205,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::IterationOverSet) {
                 pylint::rules::iteration_over_set(checker, iter);
             }
-            if stmt.is_for_stmt() {
-                if checker.enabled(Rule::ReimplementedBuiltin) {
-                    flake8_simplify::rules::convert_for_loop_to_any_all(checker, stmt);
-                }
-                if checker.enabled(Rule::InDictKeys) {
-                    flake8_simplify::rules::key_in_dict_for(checker, target, iter);
-                }
-                if checker.enabled(Rule::TryExceptInLoop) {
-                    perflint::rules::try_except_in_loop(checker, body);
-                }
-            }
             if checker.enabled(Rule::ManualListComprehension) {
                 perflint::rules::manual_list_comprehension(checker, target, body);
             }
@@ -1220,6 +1214,17 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::UnnecessaryListCast) {
                 perflint::rules::unnecessary_list_cast(checker, iter);
             }
+            if !is_async {
+                if checker.enabled(Rule::ReimplementedBuiltin) {
+                    flake8_simplify::rules::convert_for_loop_to_any_all(checker, stmt);
+                }
+                if checker.enabled(Rule::InDictKeys) {
+                    flake8_simplify::rules::key_in_dict_for(checker, for_stmt);
+                }
+                if checker.enabled(Rule::TryExceptInLoop) {
+                    perflint::rules::try_except_in_loop(checker, body);
+                }
+            }
         }
         Stmt::Try(ast::StmtTry {
             body,
@@ -1457,7 +1462,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 }
             }
         }
-        Stmt::Delete(ast::StmtDelete { targets, range: _ }) => {
+        Stmt::Delete(delete @ ast::StmtDelete { targets, range: _ }) => {
             if checker.enabled(Rule::GlobalStatement) {
                 for target in targets {
                     if let Expr::Name(ast::ExprName { id, .. }) = target {
@@ -1465,6 +1470,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     }
                 }
             }
+            if checker.enabled(Rule::DeleteFullSlice) {
+                refurb::rules::delete_full_slice(checker, delete);
+            }
         }
         Stmt::Expr(ast::StmtExpr { value, range: _ }) => {
             if checker.enabled(Rule::UselessComparison) {
@@ -1482,6 +1490,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::AsyncioDanglingTask) {
                 ruff::rules::asyncio_dangling_task(checker, value);
             }
+            if checker.enabled(Rule::RepeatedAppend) {
+                refurb::rules::repeated_append(checker, stmt);
+            }
         }
         _ => {}
     }

crates/ruff/src/checkers/ast/mod.rs

@@ -32,10 +32,10 @@ use itertools::Itertools;
 use log::error;
 use ruff_python_ast::{
     self as ast, Arguments, Comprehension, Constant, ElifElseClause, ExceptHandler, Expr,
-    ExprContext, Keyword, Parameter, ParameterWithDefault, Parameters, Pattern, Ranged, Stmt,
+    ExprContext, Keyword, MatchCase, Parameter, ParameterWithDefault, Parameters, Pattern, Stmt,
     Suite, UnaryOp,
 };
-use ruff_text_size::{TextRange, TextSize};
+use ruff_text_size::{Ranged, TextRange, TextSize};
 
 use ruff_diagnostics::{Diagnostic, IsolationLevel};
 use ruff_python_ast::all::{extract_all_names, DunderAllFlags};
@@ -52,7 +52,8 @@ use ruff_python_parser::typing::{parse_type_annotation, AnnotationKind};
 use ruff_python_semantic::analyze::{typing, visibility};
 use ruff_python_semantic::{
     BindingFlags, BindingId, BindingKind, Exceptions, Export, FromImport, Globals, Import, Module,
-    ModuleKind, ScopeId, ScopeKind, SemanticModel, SemanticModelFlags, StarImport, SubmoduleImport,
+    ModuleKind, NodeId, ScopeId, ScopeKind, SemanticModel, SemanticModelFlags, StarImport,
+    SubmoduleImport,
 };
 use ruff_python_stdlib::builtins::{BUILTINS, MAGIC_GLOBALS};
 use ruff_source_file::Locator;
@@ -193,20 +194,6 @@ impl<'a> Checker<'a> {
         }
     }
 
-    /// Returns the [`IsolationLevel`] for fixes in the current context.
-    ///
-    /// The primary use-case for fix isolation is to ensure that we don't delete all statements
-    /// in a given indented block, which would cause a syntax error. We therefore need to ensure
-    /// that we delete at most one statement per indented block per fixer pass. Fix isolation should
-    /// thus be applied whenever we delete a statement, but can otherwise be omitted.
-    pub(crate) fn isolation(&self, parent: Option<&Stmt>) -> IsolationLevel {
-        parent
-            .and_then(|stmt| self.semantic.statement_id(stmt))
-            .map_or(IsolationLevel::default(), |node_id| {
-                IsolationLevel::Group(node_id.into())
-            })
-    }
-
     /// The [`Locator`] for the current file, which enables extraction of source code from byte
     /// offsets.
     pub(crate) const fn locator(&self) -> &'a Locator<'a> {
@@ -255,6 +242,18 @@ impl<'a> Checker<'a> {
     pub(crate) const fn any_enabled(&self, rules: &[Rule]) -> bool {
         self.settings.rules.any_enabled(rules)
     }
+
+    /// Returns the [`IsolationLevel`] to isolate fixes for a given node.
+    ///
+    /// The primary use-case for fix isolation is to ensure that we don't delete all statements
+    /// in a given indented block, which would cause a syntax error. We therefore need to ensure
+    /// that we delete at most one statement per indented block per fixer pass. Fix isolation should
+    /// thus be applied whenever we delete a statement, but can otherwise be omitted.
+    pub(crate) fn isolation(node_id: Option<NodeId>) -> IsolationLevel {
+        node_id
+            .map(|node_id| IsolationLevel::Group(node_id.into()))
+            .unwrap_or_default()
+    }
 }
 
 impl<'a, 'b> Visitor<'b> for Checker<'a>
@@ -263,7 +262,7 @@ where
 {
     fn visit_stmt(&mut self, stmt: &'b Stmt) {
         // Step 0: Pre-processing
-        self.semantic.push_statement(stmt);
+        self.semantic.push_node(stmt);
 
         // Track whether we've seen docstrings, non-imports, etc.
         match stmt {
@@ -619,16 +618,28 @@ where
                     }
                 }
 
+                // Iterate over the `body`, then the `handlers`, then the `orelse`, then the
+                // `finalbody`, but treat the body and the `orelse` as a single branch for
+                // flow analysis purposes.
+                let branch = self.semantic.push_branch();
                 self.semantic.handled_exceptions.push(handled_exceptions);
                 self.visit_body(body);
                 self.semantic.handled_exceptions.pop();
+                self.semantic.pop_branch();
 
                 for except_handler in handlers {
+                    self.semantic.push_branch();
                     self.visit_except_handler(except_handler);
+                    self.semantic.pop_branch();
                 }
 
+                self.semantic.set_branch(branch);
                 self.visit_body(orelse);
+                self.semantic.pop_branch();
+
+                self.semantic.push_branch();
                 self.visit_body(finalbody);
+                self.semantic.pop_branch();
             }
             Stmt::AnnAssign(ast::StmtAnnAssign {
                 target,
@@ -708,6 +719,7 @@ where
             ) => {
                 self.visit_boolean_test(test);
 
+                self.semantic.push_branch();
                 if typing::is_type_checking_block(stmt_if, &self.semantic) {
                     if self.semantic.at_top_level() {
                         self.importer.visit_type_checking_block(stmt);
@@ -716,9 +728,12 @@ where
                 } else {
                     self.visit_body(body);
                 }
+                self.semantic.pop_branch();
 
                 for clause in elif_else_clauses {
+                    self.semantic.push_branch();
                     self.visit_elif_else_clause(clause);
+                    self.semantic.pop_branch();
                 }
             }
             _ => visitor::walk_stmt(self, stmt),
@@ -759,7 +774,7 @@ where
         analyze::statement(stmt, self);
 
         self.semantic.flags = flags_snapshot;
-        self.semantic.pop_statement();
+        self.semantic.pop_node();
     }
 
     fn visit_annotation(&mut self, expr: &'b Expr) {
@@ -795,7 +810,7 @@ where
             return;
         }
 
-        self.semantic.push_expression(expr);
+        self.semantic.push_node(expr);
 
         // Store the flags prior to any further descent, so that we can restore them after visiting
         // the node.
@@ -874,18 +889,20 @@ where
                 },
             ) => {
                 // Visit the default arguments, but avoid the body, which will be deferred.
-                for ParameterWithDefault {
-                    default,
-                    parameter: _,
-                    range: _,
-                } in parameters
-                    .posonlyargs
-                    .iter()
-                    .chain(&parameters.args)
-                    .chain(&parameters.kwonlyargs)
-                {
-                    if let Some(expr) = &default {
-                        self.visit_expr(expr);
+                if let Some(parameters) = parameters {
+                    for ParameterWithDefault {
+                        default,
+                        parameter: _,
+                        range: _,
+                    } in parameters
+                        .posonlyargs
+                        .iter()
+                        .chain(&parameters.args)
+                        .chain(&parameters.kwonlyargs)
+                    {
+                        if let Some(expr) = &default {
+                            self.visit_expr(expr);
+                        }
                     }
                 }
 
@@ -1213,7 +1230,7 @@ where
         analyze::expression(expr, self);
 
         self.semantic.flags = flags_snapshot;
-        self.semantic.pop_expression();
+        self.semantic.pop_node();
     }
 
     fn visit_except_handler(&mut self, except_handler: &'b ExceptHandler) {
@@ -1351,6 +1368,17 @@ where
         }
     }
 
+    fn visit_match_case(&mut self, match_case: &'b MatchCase) {
+        self.visit_pattern(&match_case.pattern);
+        if let Some(expr) = &match_case.guard {
+            self.visit_expr(expr);
+        }
+
+        self.semantic.push_branch();
+        self.visit_body(&match_case.body);
+        self.semantic.pop_branch();
+    }
+
     fn visit_type_param(&mut self, type_param: &'b ast::TypeParam) {
         // Step 1: Binding
         match type_param {
@@ -1834,7 +1862,9 @@ impl<'a> Checker<'a> {
                     range: _,
                 }) = expr
                 {
-                    self.visit_parameters(parameters);
+                    if let Some(parameters) = parameters {
+                        self.visit_parameters(parameters);
+                    }
                     self.visit_expr(body);
                 } else {
                     unreachable!("Expected Expr::Lambda");
@@ -1865,6 +1895,8 @@ impl<'a> Checker<'a> {
         for (name, range) in exports {
             if let Some(binding_id) = self.semantic.global_scope().get(name) {
                 // Mark anything referenced in `__all__` as used.
+                // TODO(charlie): `range` here should be the range of the name in `__all__`, not
+                // the range of `__all__` itself.
                 self.semantic.add_global_reference(binding_id, range);
             } else {
                 if self.semantic.global_scope().uses_star_imports() {

crates/ruff/src/checkers/imports.rs

@@ -2,16 +2,15 @@
 use std::borrow::Cow;
 use std::path::Path;
 
-use ruff_python_ast::{self as ast, PySourceType, Ranged, Stmt, Suite};
-
 use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::helpers::to_module_path;
 use ruff_python_ast::imports::{ImportMap, ModuleImport};
 use ruff_python_ast::statement_visitor::StatementVisitor;
+use ruff_python_ast::{self as ast, PySourceType, Stmt, Suite};
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
-
 use ruff_source_file::Locator;
+use ruff_text_size::Ranged;
 
 use crate::directives::IsortDirectives;
 use crate::registry::Rule;

crates/ruff/src/checkers/logical_lines.rs

@@ -1,10 +1,9 @@
 use ruff_diagnostics::{Diagnostic, DiagnosticKind};
-use ruff_python_ast::Ranged;
 use ruff_python_codegen::Stylist;
 use ruff_python_parser::lexer::LexResult;
 use ruff_python_parser::TokenKind;
 use ruff_source_file::Locator;
-use ruff_text_size::TextRange;
+use ruff_text_size::{Ranged, TextRange};
 
 use crate::registry::{AsRule, Rule};
 use crate::rules::pycodestyle::rules::logical_lines::{

crates/ruff/src/checkers/noqa.rs

@@ -3,8 +3,7 @@
 use std::path::Path;
 
 use itertools::Itertools;
-use ruff_python_ast::Ranged;
-use ruff_text_size::{TextLen, TextRange, TextSize};
+use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 
 use ruff_diagnostics::{Diagnostic, Edit, Fix};
 use ruff_source_file::Locator;
@@ -110,8 +109,8 @@ pub(crate) fn check_noqa(
                         let mut diagnostic =
                             Diagnostic::new(UnusedNOQA { codes: None }, directive.range());
                         if settings.rules.should_fix(diagnostic.kind.rule()) {
-                            #[allow(deprecated)]
-                            diagnostic.set_fix_from_edit(delete_noqa(directive.range(), locator));
+                            diagnostic
+                                .set_fix(Fix::suggested(delete_noqa(directive.range(), locator)));
                         }
                         diagnostics.push(diagnostic);
                     }
@@ -175,12 +174,12 @@ pub(crate) fn check_noqa(
                         );
                         if settings.rules.should_fix(diagnostic.kind.rule()) {
                             if valid_codes.is_empty() {
-                                #[allow(deprecated)]
-                                diagnostic
-                                    .set_fix_from_edit(delete_noqa(directive.range(), locator));
+                                diagnostic.set_fix(Fix::suggested(delete_noqa(
+                                    directive.range(),
+                                    locator,
+                                )));
                             } else {
-                                #[allow(deprecated)]
-                                diagnostic.set_fix(Fix::unspecified(Edit::range_replacement(
+                                diagnostic.set_fix(Fix::suggested(Edit::range_replacement(
                                     format!("# noqa: {}", valid_codes.join(", ")),
                                     directive.range(),
                                 )));

crates/ruff/src/checkers/physical_lines.rs

@@ -1,10 +1,9 @@
 //! Lint rules based on checking physical lines.
-use ruff_text_size::TextSize;
-
 use ruff_diagnostics::Diagnostic;
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
 use ruff_source_file::{Locator, UniversalNewlines};
+use ruff_text_size::TextSize;
 
 use crate::registry::Rule;
 use crate::rules::flake8_copyright::rules::missing_copyright_notice;
@@ -99,11 +98,10 @@ pub(crate) fn check_physical_lines(
 
 #[cfg(test)]
 mod tests {
-    use ruff_python_parser::lexer::lex;
-    use ruff_python_parser::Mode;
-
     use ruff_python_codegen::Stylist;
     use ruff_python_index::Indexer;
+    use ruff_python_parser::lexer::lex;
+    use ruff_python_parser::Mode;
     use ruff_source_file::Locator;
 
     use crate::line_width::LineLength;
@@ -132,7 +130,7 @@ mod tests {
                 },
             )
         };
-        let line_length = LineLength::from(8);
+        let line_length = LineLength::try_from(8).unwrap();
         assert_eq!(check_with_max_line_length(line_length), vec![]);
         assert_eq!(check_with_max_line_length(line_length), vec![]);
     }

crates/ruff/src/codes.rs

@@ -51,8 +51,8 @@ impl PartialEq<&str> for NoqaCode {
 pub enum RuleGroup {
     /// The rule has not been assigned to any specific group.
     Unspecified,
-    /// The rule is still under development, and must be enabled explicitly.
-    Nursery,
+    /// The rule is unstable, and must be enabled explicitly or by enabling preview.
+    Preview,
 }
 
 #[ruff_macros::map_codes]
@@ -64,39 +64,39 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
     Some(match (linter, code) {
         // pycodestyle errors
         (Pycodestyle, "E101") => (RuleGroup::Unspecified, rules::pycodestyle::rules::MixedSpacesAndTabs),
-        (Pycodestyle, "E111") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::IndentationWithInvalidMultiple),
-        (Pycodestyle, "E112") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::NoIndentedBlock),
-        (Pycodestyle, "E113") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::UnexpectedIndentation),
-        (Pycodestyle, "E114") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::IndentationWithInvalidMultipleComment),
-        (Pycodestyle, "E115") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::NoIndentedBlockComment),
-        (Pycodestyle, "E116") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::UnexpectedIndentationComment),
-        (Pycodestyle, "E117") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::OverIndented),
-        (Pycodestyle, "E201") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::WhitespaceAfterOpenBracket),
-        (Pycodestyle, "E202") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::WhitespaceBeforeCloseBracket),
-        (Pycodestyle, "E203") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::WhitespaceBeforePunctuation),
-        (Pycodestyle, "E211") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::WhitespaceBeforeParameters),
-        (Pycodestyle, "E221") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MultipleSpacesBeforeOperator),
-        (Pycodestyle, "E222") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MultipleSpacesAfterOperator),
-        (Pycodestyle, "E223") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::TabBeforeOperator),
-        (Pycodestyle, "E224") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::TabAfterOperator),
-        (Pycodestyle, "E225") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAroundOperator),
-        (Pycodestyle, "E226") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAroundArithmeticOperator),
-        (Pycodestyle, "E227") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAroundBitwiseOrShiftOperator),
-        (Pycodestyle, "E228") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAroundModuloOperator),
-        (Pycodestyle, "E231") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MissingWhitespace),
-        (Pycodestyle, "E241") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MultipleSpacesAfterComma),
-        (Pycodestyle, "E242") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::TabAfterComma),
-        (Pycodestyle, "E251") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::UnexpectedSpacesAroundKeywordParameterEquals),
-        (Pycodestyle, "E252") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAroundParameterEquals),
-        (Pycodestyle, "E261") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::TooFewSpacesBeforeInlineComment),
-        (Pycodestyle, "E262") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::NoSpaceAfterInlineComment),
-        (Pycodestyle, "E265") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::NoSpaceAfterBlockComment),
-        (Pycodestyle, "E266") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MultipleLeadingHashesForBlockComment),
-        (Pycodestyle, "E271") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MultipleSpacesAfterKeyword),
-        (Pycodestyle, "E272") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MultipleSpacesBeforeKeyword),
-        (Pycodestyle, "E273") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::TabAfterKeyword),
-        (Pycodestyle, "E274") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::TabBeforeKeyword),
-        (Pycodestyle, "E275") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAfterKeyword),
+        (Pycodestyle, "E111") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::IndentationWithInvalidMultiple),
+        (Pycodestyle, "E112") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::NoIndentedBlock),
+        (Pycodestyle, "E113") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::UnexpectedIndentation),
+        (Pycodestyle, "E114") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::IndentationWithInvalidMultipleComment),
+        (Pycodestyle, "E115") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::NoIndentedBlockComment),
+        (Pycodestyle, "E116") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::UnexpectedIndentationComment),
+        (Pycodestyle, "E117") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::OverIndented),
+        (Pycodestyle, "E201") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::WhitespaceAfterOpenBracket),
+        (Pycodestyle, "E202") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::WhitespaceBeforeCloseBracket),
+        (Pycodestyle, "E203") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::WhitespaceBeforePunctuation),
+        (Pycodestyle, "E211") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::WhitespaceBeforeParameters),
+        (Pycodestyle, "E221") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MultipleSpacesBeforeOperator),
+        (Pycodestyle, "E222") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MultipleSpacesAfterOperator),
+        (Pycodestyle, "E223") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::TabBeforeOperator),
+        (Pycodestyle, "E224") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::TabAfterOperator),
+        (Pycodestyle, "E225") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAroundOperator),
+        (Pycodestyle, "E226") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAroundArithmeticOperator),
+        (Pycodestyle, "E227") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAroundBitwiseOrShiftOperator),
+        (Pycodestyle, "E228") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAroundModuloOperator),
+        (Pycodestyle, "E231") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MissingWhitespace),
+        (Pycodestyle, "E241") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MultipleSpacesAfterComma),
+        (Pycodestyle, "E242") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::TabAfterComma),
+        (Pycodestyle, "E251") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::UnexpectedSpacesAroundKeywordParameterEquals),
+        (Pycodestyle, "E252") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAroundParameterEquals),
+        (Pycodestyle, "E261") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::TooFewSpacesBeforeInlineComment),
+        (Pycodestyle, "E262") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::NoSpaceAfterInlineComment),
+        (Pycodestyle, "E265") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::NoSpaceAfterBlockComment),
+        (Pycodestyle, "E266") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MultipleLeadingHashesForBlockComment),
+        (Pycodestyle, "E271") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MultipleSpacesAfterKeyword),
+        (Pycodestyle, "E272") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MultipleSpacesBeforeKeyword),
+        (Pycodestyle, "E273") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::TabAfterKeyword),
+        (Pycodestyle, "E274") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::TabBeforeKeyword),
+        (Pycodestyle, "E275") => (RuleGroup::Preview, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAfterKeyword),
         (Pycodestyle, "E401") => (RuleGroup::Unspecified, rules::pycodestyle::rules::MultipleImportsOnOneLine),
         (Pycodestyle, "E402") => (RuleGroup::Unspecified, rules::pycodestyle::rules::ModuleImportNotAtTopOfFile),
         (Pycodestyle, "E501") => (RuleGroup::Unspecified, rules::pycodestyle::rules::LineTooLong),
@@ -176,7 +176,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "C0205") => (RuleGroup::Unspecified, rules::pylint::rules::SingleStringSlots),
         (Pylint, "C0208") => (RuleGroup::Unspecified, rules::pylint::rules::IterationOverSet),
         (Pylint, "C0414") => (RuleGroup::Unspecified, rules::pylint::rules::UselessImportAlias),
-        (Pylint, "C1901") => (RuleGroup::Nursery, rules::pylint::rules::CompareToEmptyString),
+        (Pylint, "C1901") => (RuleGroup::Preview, rules::pylint::rules::CompareToEmptyString),
         (Pylint, "C3002") => (RuleGroup::Unspecified, rules::pylint::rules::UnnecessaryDirectLambdaCall),
         (Pylint, "E0100") => (RuleGroup::Unspecified, rules::pylint::rules::YieldInInit),
         (Pylint, "E0101") => (RuleGroup::Unspecified, rules::pylint::rules::ReturnInInit),
@@ -216,6 +216,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "R1722") => (RuleGroup::Unspecified, rules::pylint::rules::SysExitAlias),
         (Pylint, "R2004") => (RuleGroup::Unspecified, rules::pylint::rules::MagicValueComparison),
         (Pylint, "R5501") => (RuleGroup::Unspecified, rules::pylint::rules::CollapsibleElseIf),
+        (Pylint, "R6301") => (RuleGroup::Preview, rules::pylint::rules::NoSelfUse),
         (Pylint, "W0120") => (RuleGroup::Unspecified, rules::pylint::rules::UselessElseOnLoop),
         (Pylint, "W0127") => (RuleGroup::Unspecified, rules::pylint::rules::SelfAssigningVariable),
         (Pylint, "W0129") => (RuleGroup::Unspecified, rules::pylint::rules::AssertOnStringLiteral),
@@ -227,9 +228,9 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "W1508") => (RuleGroup::Unspecified, rules::pylint::rules::InvalidEnvvarDefault),
         (Pylint, "W1509") => (RuleGroup::Unspecified, rules::pylint::rules::SubprocessPopenPreexecFn),
         (Pylint, "W1510") => (RuleGroup::Unspecified, rules::pylint::rules::SubprocessRunWithoutCheck),
-        (Pylint, "W1641") => (RuleGroup::Nursery, rules::pylint::rules::EqWithoutHash),
+        (Pylint, "W1641") => (RuleGroup::Preview, rules::pylint::rules::EqWithoutHash),
         (Pylint, "W2901") => (RuleGroup::Unspecified, rules::pylint::rules::RedefinedLoopName),
-        (Pylint, "W3201") => (RuleGroup::Nursery, rules::pylint::rules::BadDunderMethodName),
+        (Pylint, "W3201") => (RuleGroup::Preview, rules::pylint::rules::BadDunderMethodName),
         (Pylint, "W3301") => (RuleGroup::Unspecified, rules::pylint::rules::NestedMinMax),
 
         // flake8-async
@@ -402,7 +403,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Simplify, "910") => (RuleGroup::Unspecified, rules::flake8_simplify::rules::DictGetWithNoneDefault),
 
         // flake8-copyright
-        (Flake8Copyright, "001") => (RuleGroup::Nursery, rules::flake8_copyright::rules::MissingCopyrightNotice),
+        (Flake8Copyright, "001") => (RuleGroup::Preview, rules::flake8_copyright::rules::MissingCopyrightNotice),
 
         // pyupgrade
         (Pyupgrade, "001") => (RuleGroup::Unspecified, rules::pyupgrade::rules::UselessMetaclassType),
@@ -707,6 +708,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Pie, "800") => (RuleGroup::Unspecified, rules::flake8_pie::rules::UnnecessarySpread),
         (Flake8Pie, "804") => (RuleGroup::Unspecified, rules::flake8_pie::rules::UnnecessaryDictKwargs),
         (Flake8Pie, "807") => (RuleGroup::Unspecified, rules::flake8_pie::rules::ReimplementedListBuiltin),
+        (Flake8Pie, "808") => (RuleGroup::Unspecified, rules::flake8_pie::rules::UnnecessaryRangeStart),
         (Flake8Pie, "810") => (RuleGroup::Unspecified, rules::flake8_pie::rules::MultipleStartsEndsWith),
 
         // flake8-commas
@@ -813,10 +815,10 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "012") => (RuleGroup::Unspecified, rules::ruff::rules::MutableClassDefault),
         (Ruff, "013") => (RuleGroup::Unspecified, rules::ruff::rules::ImplicitOptional),
         #[cfg(feature = "unreachable-code")] // When removing this feature gate, also update rules_selector.rs
-        (Ruff, "014") => (RuleGroup::Nursery, rules::ruff::rules::UnreachableCode),
+        (Ruff, "014") => (RuleGroup::Preview, rules::ruff::rules::UnreachableCode),
         (Ruff, "015") => (RuleGroup::Unspecified, rules::ruff::rules::UnnecessaryIterableAllocationForFirstElement),
         (Ruff, "016") => (RuleGroup::Unspecified, rules::ruff::rules::InvalidIndexType),
-        (Ruff, "017") => (RuleGroup::Nursery, rules::ruff::rules::QuadraticListSummation),
+        (Ruff, "017") => (RuleGroup::Preview, rules::ruff::rules::QuadraticListSummation),
         (Ruff, "100") => (RuleGroup::Unspecified, rules::ruff::rules::UnusedNOQA),
         (Ruff, "200") => (RuleGroup::Unspecified, rules::ruff::rules::InvalidPyprojectToml),
 
@@ -863,6 +865,11 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Slots, "001") => (RuleGroup::Unspecified, rules::flake8_slots::rules::NoSlotsInTupleSubclass),
         (Flake8Slots, "002") => (RuleGroup::Unspecified, rules::flake8_slots::rules::NoSlotsInNamedtupleSubclass),
 
+        // refurb
+        (Refurb, "113") => (RuleGroup::Preview, rules::refurb::rules::RepeatedAppend),
+        (Refurb, "131") => (RuleGroup::Preview, rules::refurb::rules::DeleteFullSlice),
+        (Refurb, "132") => (RuleGroup::Preview, rules::refurb::rules::CheckAndRemoveFromSet),
+
         _ => return None,
     })
 }

crates/ruff/src/cst/matchers.rs

@@ -1,9 +1,11 @@
+use crate::autofix::codemods::CodegenStylist;
 use anyhow::{bail, Result};
 use libcst_native::{
     Arg, Attribute, Call, Comparison, CompoundStatement, Dict, Expression, FunctionDef,
     GeneratorExp, If, Import, ImportAlias, ImportFrom, ImportNames, IndentedBlock, Lambda,
     ListComp, Module, Name, SmallStatement, Statement, Suite, Tuple, With,
 };
+use ruff_python_codegen::Stylist;
 
 pub(crate) fn match_module(module_text: &str) -> Result<Module> {
     match libcst_native::parse_module(module_text, None) {
@@ -12,13 +14,6 @@ pub(crate) fn match_module(module_text: &str) -> Result<Module> {
     }
 }
 
-pub(crate) fn match_expression(expression_text: &str) -> Result<Expression> {
-    match libcst_native::parse_expression(expression_text) {
-        Ok(expression) => Ok(expression),
-        Err(_) => bail!("Failed to extract expression from source"),
-    }
-}
-
 pub(crate) fn match_statement(statement_text: &str) -> Result<Statement> {
     match libcst_native::parse_statement(statement_text) {
         Ok(statement) => Ok(statement),
@@ -205,3 +200,59 @@ pub(crate) fn match_if<'a, 'b>(statement: &'a mut Statement<'b>) -> Result<&'a m
         bail!("Expected Statement::Compound")
     }
 }
+
+/// Given the source code for an expression, return the parsed [`Expression`].
+///
+/// If the expression is not guaranteed to be valid as a standalone expression (e.g., if it may
+/// span multiple lines and/or require parentheses), use [`transform_expression`] instead.
+pub(crate) fn match_expression(expression_text: &str) -> Result<Expression> {
+    match libcst_native::parse_expression(expression_text) {
+        Ok(expression) => Ok(expression),
+        Err(_) => bail!("Failed to extract expression from source"),
+    }
+}
+
+/// Run a transformation function over an expression.
+///
+/// Passing an expression to [`match_expression`] directly can lead to parse errors if the
+/// expression is not a valid standalone expression (e.g., it was parenthesized in the original
+/// source). This method instead wraps the expression in "fake" parentheses, runs the
+/// transformation, then removes the "fake" parentheses.
+pub(crate) fn transform_expression(
+    source_code: &str,
+    stylist: &Stylist,
+    func: impl FnOnce(Expression) -> Result<Expression>,
+) -> Result<String> {
+    // Wrap the expression in parentheses.
+    let source_code = format!("({source_code})");
+    let expression = match_expression(&source_code)?;
+
+    // Run the function on the expression.
+    let expression = func(expression)?;
+
+    // Codegen the expression.
+    let mut source_code = expression.codegen_stylist(stylist);
+
+    // Drop the outer parentheses.
+    source_code.drain(0..1);
+    source_code.drain(source_code.len() - 1..source_code.len());
+    Ok(source_code)
+}
+
+/// Like [`transform_expression`], but operates on the source code of the expression, rather than
+/// the parsed [`Expression`]. This _shouldn't_ exist, but does to accommodate lifetime issues.
+pub(crate) fn transform_expression_text(
+    source_code: &str,
+    func: impl FnOnce(String) -> Result<String>,
+) -> Result<String> {
+    // Wrap the expression in parentheses.
+    let source_code = format!("({source_code})");
+
+    // Run the function on the expression.
+    let mut transformed = func(source_code)?;
+
+    // Drop the outer parentheses.
+    transformed.drain(0..1);
+    transformed.drain(transformed.len() - 1..transformed.len());
+    Ok(transformed)
+}

crates/ruff/src/directives.rs

@@ -5,7 +5,7 @@ use std::str::FromStr;
 use bitflags::bitflags;
 use ruff_python_parser::lexer::LexResult;
 use ruff_python_parser::Tok;
-use ruff_text_size::{TextLen, TextRange, TextSize};
+use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 
 use ruff_python_index::Indexer;
 use ruff_source_file::Locator;
@@ -405,7 +405,7 @@ y = 2
 z = x + 1";
         assert_eq!(
             noqa_mappings(contents),
-            NoqaMapping::from_iter([TextRange::new(TextSize::from(0), TextSize::from(22)),])
+            NoqaMapping::from_iter([TextRange::new(TextSize::from(0), TextSize::from(22))])
         );
 
         let contents = "x = 1

crates/ruff/src/doc_lines.rs

@@ -3,10 +3,10 @@
 
 use std::iter::FusedIterator;
 
-use ruff_python_ast::{self as ast, Constant, Expr, Ranged, Stmt, Suite};
+use ruff_python_ast::{self as ast, Constant, Expr, Stmt, Suite};
 use ruff_python_parser::lexer::LexResult;
 use ruff_python_parser::Tok;
-use ruff_text_size::TextSize;
+use ruff_text_size::{Ranged, TextSize};
 
 use ruff_python_ast::statement_visitor::{walk_stmt, StatementVisitor};
 use ruff_source_file::{Locator, UniversalNewlineIterator};
@@ -76,7 +76,7 @@ impl StatementVisitor<'_> for StringLinesVisitor<'_> {
             }) = value.as_ref()
             {
                 for line in UniversalNewlineIterator::with_offset(
-                    self.locator.slice(value.range()),
+                    self.locator.slice(value.as_ref()),
                     value.start(),
                 ) {
                     self.string_lines.push(line.start());

crates/ruff/src/docstrings/mod.rs

@@ -1,9 +1,9 @@
 use std::fmt::{Debug, Formatter};
 use std::ops::Deref;
 
-use ruff_python_ast::{Expr, Ranged};
+use ruff_python_ast::Expr;
 use ruff_python_semantic::Definition;
-use ruff_text_size::TextRange;
+use ruff_text_size::{Ranged, TextRange};
 
 pub(crate) mod extraction;
 pub(crate) mod google;

crates/ruff/src/docstrings/sections.rs

@@ -2,8 +2,7 @@ use std::fmt::{Debug, Formatter};
 use std::iter::FusedIterator;
 
 use ruff_python_ast::docstrings::{leading_space, leading_words};
-use ruff_python_ast::Ranged;
-use ruff_text_size::{TextLen, TextRange, TextSize};
+use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 use strum_macros::EnumIter;
 
 use ruff_source_file::{Line, UniversalNewlineIterator, UniversalNewlines};
@@ -165,7 +164,7 @@ impl<'a> SectionContexts<'a> {
                     lines.peek(),
                 ) {
                     if let Some(mut last) = last.take() {
-                        last.range = TextRange::new(last.range.start(), line.start());
+                        last.range = TextRange::new(last.start(), line.start());
                         contexts.push(last);
                     }
 
@@ -182,7 +181,7 @@ impl<'a> SectionContexts<'a> {
         }
 
         if let Some(mut last) = last.take() {
-            last.range = TextRange::new(last.range.start(), contents.text_len());
+            last.range = TextRange::new(last.start(), contents.text_len());
             contexts.push(last);
         }
 
@@ -268,6 +267,12 @@ struct SectionContextData {
     summary_full_end: TextSize,
 }
 
+impl Ranged for SectionContextData {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+
 pub(crate) struct SectionContext<'a> {
     data: &'a SectionContextData,
     docstring_body: DocstringBody<'a>,

crates/ruff/src/flake8_to_ruff/external_config.rs

@@ -1,10 +0,0 @@
-use super::black::Black;
-use super::isort::Isort;
-use super::pep621::Project;
-
-#[derive(Default)]
-pub struct ExternalConfig<'a> {
-    pub black: Option<&'a Black>,
-    pub isort: Option<&'a Isort>,
-    pub project: Option<&'a Project>,
-}

crates/ruff/src/flake8_to_ruff/mod.rs

@@ -1,13 +0,0 @@
-pub use converter::convert;
-pub use external_config::ExternalConfig;
-pub use plugin::Plugin;
-pub use pyproject::parse;
-
-mod black;
-mod converter;
-mod external_config;
-mod isort;
-mod parser;
-pub mod pep621;
-mod plugin;
-mod pyproject;

crates/ruff/src/importer/insertion.rs

@@ -1,9 +1,9 @@
 //! Insert statements into Python code.
 use std::ops::Add;
 
-use ruff_python_ast::{PySourceType, Ranged, Stmt};
+use ruff_python_ast::{PySourceType, Stmt};
 use ruff_python_parser::{lexer, AsMode, Tok};
-use ruff_text_size::TextSize;
+use ruff_text_size::{Ranged, TextSize};
 
 use ruff_diagnostics::Edit;
 use ruff_python_ast::helpers::is_docstring_stmt;

crates/ruff/src/importer/mod.rs

@@ -7,8 +7,8 @@ use std::error::Error;
 
 use anyhow::Result;
 use libcst_native::{ImportAlias, Name, NameOrAttribute};
-use ruff_python_ast::{self as ast, PySourceType, Ranged, Stmt, Suite};
-use ruff_text_size::TextSize;
+use ruff_python_ast::{self as ast, PySourceType, Stmt, Suite};
+use ruff_text_size::{Ranged, TextSize};
 
 use ruff_diagnostics::Edit;
 use ruff_python_ast::imports::{AnyImport, Import, ImportFrom};
@@ -301,12 +301,14 @@ impl<'a> Importer<'a> {
             }
             if let Stmt::ImportFrom(ast::StmtImportFrom {
                 module: name,
+                names,
                 level,
-                ..
+                range: _,
             }) = stmt
             {
                 if level.map_or(true, |level| level.to_u32() == 0)
                     && name.as_ref().is_some_and(|name| name == module)
+                    && names.iter().all(|alias| alias.name.as_str() != "*")
                 {
                     import_from = Some(*stmt);
                 }
@@ -317,7 +319,7 @@ impl<'a> Importer<'a> {
 
     /// Add the given member to an existing `Stmt::ImportFrom` statement.
     fn add_member(&self, stmt: &Stmt, member: &str) -> Result<Edit> {
-        let mut statement = match_statement(self.locator.slice(stmt.range()))?;
+        let mut statement = match_statement(self.locator.slice(stmt))?;
         let import_from = match_import_from(&mut statement)?;
         let aliases = match_aliases(import_from)?;
         aliases.push(ImportAlias {

crates/ruff/src/jupyter/index.rs

@@ -3,14 +3,14 @@
 /// When we lint a jupyter notebook, we have to translate the row/column based on
 /// [`ruff_text_size::TextSize`] to jupyter notebook cell/row/column.
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct JupyterIndex {
+pub struct NotebookIndex {
     /// Enter a row (1-based), get back the cell (1-based)
     pub(super) row_to_cell: Vec<u32>,
     /// Enter a row (1-based), get back the row in cell (1-based)
     pub(super) row_to_row_in_cell: Vec<u32>,
 }
 
-impl JupyterIndex {
+impl NotebookIndex {
     /// Returns the cell number (1-based) for the given row (1-based).
     pub fn cell(&self, row: usize) -> Option<u32> {
         self.row_to_cell.get(row).copied()

crates/ruff/src/jupyter/notebook.rs

@@ -9,6 +9,7 @@ use itertools::Itertools;
 use once_cell::sync::OnceCell;
 use serde::Serialize;
 use serde_json::error::Category;
+use uuid::Uuid;
 
 use ruff_diagnostics::Diagnostic;
 use ruff_python_parser::lexer::lex;
@@ -17,7 +18,7 @@ use ruff_source_file::{NewlineWithTrailingNewline, UniversalNewlineIterator};
 use ruff_text_size::{TextRange, TextSize};
 
 use crate::autofix::source_map::{SourceMap, SourceMarker};
-use crate::jupyter::index::JupyterIndex;
+use crate::jupyter::index::NotebookIndex;
 use crate::jupyter::schema::{Cell, RawNotebook, SortAlphabetically, SourceValue};
 use crate::rules::pycodestyle::rules::SyntaxError;
 use crate::IOError;
@@ -33,7 +34,7 @@ pub fn round_trip(path: &Path) -> anyhow::Result<String> {
             err
         )
     })?;
-    let code = notebook.content().to_string();
+    let code = notebook.source_code().to_string();
     notebook.update_cell_content(&code);
     let mut writer = Vec::new();
     notebook.write_inner(&mut writer)?;
@@ -82,8 +83,8 @@ impl Cell {
             Cell::Code(cell) => &cell.source,
             _ => return false,
         };
-        // Ignore cells containing cell magic. This is different from line magic
-        // which is allowed and ignored by the parser.
+        // Ignore cells containing cell magic as they act on the entire cell
+        // as compared to line magic which acts on a single line.
         !match source {
             SourceValue::String(string) => string
                 .lines()
@@ -103,10 +104,10 @@ pub struct Notebook {
     /// separated by a newline and a trailing newline. The trailing newline
     /// is added to make sure that each cell ends with a newline which will
     /// be removed when updating the cell content.
-    content: String,
+    source_code: String,
     /// The index of the notebook. This is used to map between the concatenated
     /// source code and the original notebook.
-    index: OnceCell<JupyterIndex>,
+    index: OnceCell<NotebookIndex>,
     /// The raw notebook i.e., the deserialized version of JSON string.
     raw: RawNotebook,
     /// The offsets of each cell in the concatenated source code. This includes
@@ -132,8 +133,8 @@ impl Notebook {
     }
 
     /// Read the Jupyter Notebook from its JSON string.
-    pub fn from_contents(contents: &str) -> Result<Self, Box<Diagnostic>> {
-        Self::from_reader(Cursor::new(contents))
+    pub fn from_source_code(source_code: &str) -> Result<Self, Box<Diagnostic>> {
+        Self::from_reader(Cursor::new(source_code))
     }
 
     /// Read a Jupyter Notebook from a [`Read`] implementor.
@@ -156,7 +157,7 @@ impl Notebook {
                 TextRange::default(),
             )
         })?;
-        let raw_notebook: RawNotebook = match serde_json::from_reader(reader.by_ref()) {
+        let mut raw_notebook: RawNotebook = match serde_json::from_reader(reader.by_ref()) {
             Ok(notebook) => notebook,
             Err(err) => {
                 // Translate the error into a diagnostic
@@ -262,13 +263,30 @@ impl Notebook {
             cell_offsets.push(current_offset);
         }
 
+        // Add cell ids to 4.5+ notebooks if they are missing
+        // https://github.com/astral-sh/ruff/issues/6834
+        // https://github.com/jupyter/enhancement-proposals/blob/master/62-cell-id/cell-id.md#required-field
+        if raw_notebook.nbformat == 4 && raw_notebook.nbformat_minor >= 5 {
+            for cell in &mut raw_notebook.cells {
+                let id = match cell {
+                    Cell::Code(cell) => &mut cell.id,
+                    Cell::Markdown(cell) => &mut cell.id,
+                    Cell::Raw(cell) => &mut cell.id,
+                };
+                if id.is_none() {
+                    // https://github.com/jupyter/enhancement-proposals/blob/master/62-cell-id/cell-id.md#questions
+                    *id = Some(Uuid::new_v4().to_string());
+                }
+            }
+        }
+
         Ok(Self {
             raw: raw_notebook,
             index: OnceCell::new(),
             // The additional newline at the end is to maintain consistency for
             // all cells. These newlines will be removed before updating the
             // source code with the transformed content. Refer `update_cell_content`.
-            content: contents.join("\n") + "\n",
+            source_code: contents.join("\n") + "\n",
             cell_offsets,
             valid_code_cells,
             trailing_newline,
@@ -368,7 +386,7 @@ impl Notebook {
     ///
     /// The index building is expensive as it needs to go through the content of
     /// every valid code cell.
-    fn build_index(&self) -> JupyterIndex {
+    fn build_index(&self) -> NotebookIndex {
         let mut row_to_cell = vec![0];
         let mut row_to_row_in_cell = vec![0];
 
@@ -395,7 +413,7 @@ impl Notebook {
             row_to_row_in_cell.extend(1..=line_count);
         }
 
-        JupyterIndex {
+        NotebookIndex {
             row_to_cell,
             row_to_row_in_cell,
         }
@@ -404,8 +422,8 @@ impl Notebook {
     /// Return the notebook content.
     ///
     /// This is the concatenation of all Python code cells.
-    pub(crate) fn content(&self) -> &str {
-        &self.content
+    pub fn source_code(&self) -> &str {
+        &self.source_code
     }
 
     /// Return the Jupyter notebook index.
@@ -413,7 +431,7 @@ impl Notebook {
     /// The index is built only once when required. This is only used to
     /// report diagnostics, so by that time all of the autofixes must have
     /// been applied if `--fix` was passed.
-    pub(crate) fn index(&self) -> &JupyterIndex {
+    pub(crate) fn index(&self) -> &NotebookIndex {
         self.index.get_or_init(|| self.build_index())
     }
 
@@ -424,12 +442,13 @@ impl Notebook {
     }
 
     /// Update the notebook with the given sourcemap and transformed content.
-    pub(crate) fn update(&mut self, source_map: &SourceMap, transformed: &str) {
+    pub(crate) fn update(&mut self, source_map: &SourceMap, transformed: String) {
         // Cell offsets must be updated before updating the cell content as
         // it depends on the offsets to extract the cell content.
+        self.index.take();
         self.update_cell_offsets(source_map);
-        self.update_cell_content(transformed);
-        self.content = transformed.to_string();
+        self.update_cell_content(&transformed);
+        self.source_code = transformed;
     }
 
     /// Return a slice of [`Cell`] in the Jupyter notebook.
@@ -472,18 +491,22 @@ mod tests {
     use anyhow::Result;
     use test_case::test_case;
 
-    use crate::jupyter::index::JupyterIndex;
+    use crate::jupyter::index::NotebookIndex;
     use crate::jupyter::schema::Cell;
     use crate::jupyter::Notebook;
     use crate::registry::Rule;
-    use crate::test::{read_jupyter_notebook, test_notebook_path, test_resource_path};
+    use crate::source_kind::SourceKind;
+    use crate::test::{
+        read_jupyter_notebook, test_contents, test_notebook_path, test_resource_path,
+        TestedNotebook,
+    };
     use crate::{assert_messages, settings};
 
     /// Read a Jupyter cell from the `resources/test/fixtures/jupyter/cell` directory.
     fn read_jupyter_cell(path: impl AsRef<Path>) -> Result<Cell> {
         let path = test_resource_path("fixtures/jupyter/cell").join(path);
-        let contents = std::fs::read_to_string(path)?;
-        Ok(serde_json::from_str(&contents)?)
+        let source_code = std::fs::read_to_string(path)?;
+        Ok(serde_json::from_str(&source_code)?)
     }
 
     #[test]
@@ -536,7 +559,7 @@ mod tests {
     fn test_concat_notebook() -> Result<()> {
         let notebook = read_jupyter_notebook(Path::new("valid.ipynb"))?;
         assert_eq!(
-            notebook.content,
+            notebook.source_code,
             r#"def unused_variable():
     x = 1
     y = 2
@@ -556,7 +579,7 @@ print("after empty cells")
         );
         assert_eq!(
             notebook.index(),
-            &JupyterIndex {
+            &NotebookIndex {
                 row_to_cell: vec![0, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 5, 7, 7, 8],
                 row_to_row_in_cell: vec![0, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 1, 1, 2, 1],
             }
@@ -578,49 +601,64 @@ print("after empty cells")
     #[test]
     fn test_import_sorting() -> Result<()> {
         let path = "isort.ipynb".to_string();
-        let (diagnostics, source_kind, _) = test_notebook_path(
+        let TestedNotebook {
+            messages,
+            source_notebook,
+            ..
+        } = test_notebook_path(
             &path,
             Path::new("isort_expected.ipynb"),
             &settings::Settings::for_rule(Rule::UnsortedImports),
         )?;
-        assert_messages!(diagnostics, path, source_kind);
+        assert_messages!(messages, path, source_notebook);
         Ok(())
     }
 
     #[test]
     fn test_ipy_escape_command() -> Result<()> {
         let path = "ipy_escape_command.ipynb".to_string();
-        let (diagnostics, source_kind, _) = test_notebook_path(
+        let TestedNotebook {
+            messages,
+            source_notebook,
+            ..
+        } = test_notebook_path(
             &path,
             Path::new("ipy_escape_command_expected.ipynb"),
             &settings::Settings::for_rule(Rule::UnusedImport),
         )?;
-        assert_messages!(diagnostics, path, source_kind);
+        assert_messages!(messages, path, source_notebook);
         Ok(())
     }
 
     #[test]
     fn test_unused_variable() -> Result<()> {
         let path = "unused_variable.ipynb".to_string();
-        let (diagnostics, source_kind, _) = test_notebook_path(
+        let TestedNotebook {
+            messages,
+            source_notebook,
+            ..
+        } = test_notebook_path(
             &path,
             Path::new("unused_variable_expected.ipynb"),
             &settings::Settings::for_rule(Rule::UnusedVariable),
         )?;
-        assert_messages!(diagnostics, path, source_kind);
+        assert_messages!(messages, path, source_notebook);
         Ok(())
     }
 
     #[test]
     fn test_json_consistency() -> Result<()> {
         let path = "before_fix.ipynb".to_string();
-        let (_, _, source_kind) = test_notebook_path(
+        let TestedNotebook {
+            linted_notebook: fixed_notebook,
+            ..
+        } = test_notebook_path(
             path,
             Path::new("after_fix.ipynb"),
             &settings::Settings::for_rule(Rule::UnusedImport),
         )?;
         let mut writer = Vec::new();
-        source_kind.expect_jupyter().write_inner(&mut writer)?;
+        fixed_notebook.write_inner(&mut writer)?;
         let actual = String::from_utf8(writer)?;
         let expected =
             std::fs::read_to_string(test_resource_path("fixtures/jupyter/after_fix.ipynb"))?;
@@ -641,4 +679,28 @@ print("after empty cells")
 
         Ok(())
     }
+
+    // Version <4.5, don't emit cell ids
+    #[test_case(Path::new("no_cell_id.ipynb"), false; "no_cell_id")]
+    // Version 4.5, cell ids are missing and need to be added
+    #[test_case(Path::new("add_missing_cell_id.ipynb"), true; "add_missing_cell_id")]
+    fn test_cell_id(path: &Path, has_id: bool) -> Result<()> {
+        let source_notebook = read_jupyter_notebook(path)?;
+        let source_kind = SourceKind::IpyNotebook(source_notebook);
+        let (_, transformed) = test_contents(
+            &source_kind,
+            path,
+            &settings::Settings::for_rule(Rule::UnusedImport),
+        );
+        let linted_notebook = transformed.into_owned().expect_ipy_notebook();
+        let mut writer = Vec::new();
+        linted_notebook.write_inner(&mut writer)?;
+        let actual = String::from_utf8(writer)?;
+        if has_id {
+            assert!(actual.contains(r#""id": ""#));
+        } else {
+            assert!(!actual.contains(r#""id":"#));
+        }
+        Ok(())
+    }
 }

crates/ruff/src/jupyter/schema.rs

@@ -150,6 +150,7 @@ pub struct CodeCell {
     /// Technically, id isn't required (it's not even present) in schema v4.0 through v4.4, but
     /// it's required in v4.5. Main issue is that pycharm creates notebooks without an id
     /// <https://youtrack.jetbrains.com/issue/PY-59438/Jupyter-notebooks-created-with-PyCharm-are-missing-the-id-field-in-cells-in-the-.ipynb-json>
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub id: Option<String>,
     /// Cell-level metadata.
     pub metadata: Value,

crates/ruff/src/lib.rs

@@ -12,13 +12,12 @@ pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 mod autofix;
 mod checkers;
-mod codes;
+pub mod codes;
 mod comments;
 mod cst;
 pub mod directives;
 mod doc_lines;
 mod docstrings;
-pub mod flake8_to_ruff;
 pub mod fs;
 mod importer;
 pub mod jupyter;
@@ -32,9 +31,8 @@ pub mod packaging;
 pub mod pyproject_toml;
 pub mod registry;
 mod renamer;
-pub mod resolver;
 mod rule_redirects;
-mod rule_selector;
+pub mod rule_selector;
 pub mod rules;
 pub mod settings;
 pub mod source_kind;
@@ -42,3 +40,5 @@ pub mod upstream_categories;
 
 #[cfg(any(test, fuzzing))]
 pub mod test;
+
+pub const RUFF_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");