Allow TID252 to fix all valid module paths (#3796)

* Add basic jupyter notebook support behind a feature flag

* Address review comments

* Rename in separate commit to make both git and clippy happy

* cfg(feature = "jupyter_notebook") another test

* Address more review comments

* Address more review comments

* and clippy and windows

* More review comment

.cargo/config.toml

@@ -26,4 +26,11 @@ rustflags = [
   "-Wclippy::print_stdout",
   "-Wclippy::print_stderr",
   "-Wclippy::dbg_macro",
+  "-Wclippy::empty_drop",
+  "-Wclippy::empty_structs_with_brackets",
+  "-Wclippy::exit",
+  "-Wclippy::get_unwrap",
+  "-Wclippy::rc_buffer",
+  "-Wclippy::rc_mutex",
+  "-Wclippy::rest_pat_in_fully_bound_structs",
 ]

.github/workflows/benchmark.yaml

@@ -0,0 +1,135 @@
+name: Benchmark
+
+on:
+  pull_request:
+  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"
+        uses: actions-rs/cargo@v1
+        with:
+          command: bench
+          args: -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"
+        uses: actions-rs/cargo@v1
+        with:
+          command: bench
+          args: -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 cargo-binstall"
+        uses: taiki-e/install-action@cargo-binstall
+
+      - name: "Install critcmp"
+        run: cargo binstall critcmp -y
+
+      - 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

@@ -80,11 +80,11 @@ jobs:
           # Setting RUSTDOCFLAGS because `cargo doc --check` isn't yet implemented (https://github.com/rust-lang/cargo/issues/10025).
           RUSTDOCFLAGS: "-D warnings"
       - uses: actions/upload-artifact@v3
+        if: ${{ matrix.os == 'ubuntu-latest' }}
         with:
           name: ruff
           path: target/debug/ruff
 
-
   cargo-test-wasm:
     runs-on: ubuntu-latest
     name: "cargo test (wasm)"
@@ -110,14 +110,16 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: "Install Rust toolchain"
-        run: rustup show
+        run: rustup component add rustfmt
       - uses: Swatinem/rust-cache@v2
-      - run: ./scripts/add_rule.py --name DoTheThing --code PLC999 --linter pylint
+      - run: ./scripts/add_rule.py --name DoTheThing --prefix PL --code C0999 --linter pylint
       - run: cargo check
+      - run: cargo fmt --all --check
       - run: |
           ./scripts/add_plugin.py test --url https://pypi.org/project/-test/0.1.0/ --prefix TST
-          ./scripts/add_rule.py --name FirstRule --code TST001 --linter test
+          ./scripts/add_rule.py --name FirstRule --prefix TST --code 001 --linter test
       - run: cargo check
+      - run: cargo fmt --all --check
 
   typos:
     name: "spell check"
@@ -139,27 +141,88 @@ jobs:
       - uses: actions/setup-python@v4
         with:
           python-version: "3.11"
+
       - uses: actions/download-artifact@v3
+        name: Download Ruff binary
         id: ruff-target
         with:
           name: ruff
           path: target/debug
+
       - uses: dawidd6/action-download-artifact@v2
+        name: Download base results
         with:
           name: ruff
           branch: ${{ github.event.pull_request.base.ref }}
           check_artifacts: true
+
       - name: Run ecosystem check
         run: |
           # Make executable, since artifact download doesn't preserve this
           chmod +x ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
 
           scripts/check_ecosystem.py ruff ${{ steps.ruff-target.outputs.download-path }}/ruff | tee ecosystem-result
+          cat ecosystem-result > $GITHUB_STEP_SUMMARY
 
           echo ${{ github.event.number }} > pr-number
+
       - uses: actions/upload-artifact@v3
+        name: Upload PR Number
+        with:
+          name: pr-number
+          path: pr-number
+
+      - uses: actions/upload-artifact@v3
+        name: Upload Results
         with:
           name: ecosystem-result
-          path: |
-            ecosystem-result
-            pr-number
+          path: ecosystem-result
+
+  cargo-udeps:
+    name: "cargo udeps"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: "Install Rust toolchain"
+        run: rustup toolchain install nightly
+      - name: "Install cargo-udeps"
+        uses: taiki-e/install-action@cargo-udeps
+      - name: "Run cargo-udeps"
+        run: |
+          unused_dependencies=$(cargo +nightly udeps > unused.txt && cat unused.txt | cut -d $'\n' -f 2-)
+          if [ -z "$unused_dependencies" ]; then
+            echo "No unused dependencies found" > $GITHUB_STEP_SUMMARY
+            exit 0
+          else
+            echo "Unused dependencies found" > $GITHUB_STEP_SUMMARY
+            echo '```console' >> $GITHUB_STEP_SUMMARY
+            echo "$unused_dependencies" >> $GITHUB_STEP_SUMMARY
+            echo '```' >> $GITHUB_STEP_SUMMARY
+            exit 1
+          fi
+
+  pre-commit:
+    name: "pre-commit"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.11"
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - uses: Swatinem/rust-cache@v2
+      - name: "Install pre-commit"
+        run: pip install pre-commit
+      - name: "Cache pre-commit"
+        uses: actions/cache@v3
+        with:
+            path: ~/.cache/pre-commit
+            key: pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
+      - name: "Run pre-commit"
+        run: |
+          echo '```console' > $GITHUB_STEP_SUMMARY
+          # Enable color output for pre-commit and remove it for the summary
+          SKIP=cargo-fmt,clippy,dev-generate-all pre-commit run --all-files --show-diff-on-failure --color=always | \
+            tee >(sed -E 's/\x1B\[([0-9]{1,2}(;[0-9]{1,2})*)?[mGK]//g' >> $GITHUB_STEP_SUMMARY) >&1
+          echo '```' >> $GITHUB_STEP_SUMMARY

.github/workflows/ecosystem-comment.yaml

@@ -1,31 +0,0 @@
-on:
-  workflow_run:
-    workflows: [CI]
-    types: [completed]
-
-permissions:
-  pull-requests: write
-
-jobs:
-  comment:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: dawidd6/action-download-artifact@v2
-        id: download-result
-        with:
-          name: ecosystem-result
-          workflow: ci.yaml
-          run_id: ${{ github.event.workflow_run.id }}
-          if_no_artifact_found: ignore
-      - if: steps.download-result.outputs.found_artifact
-        id: result
-        run: |
-          echo "pr-number=$(<pr-number)" >> $GITHUB_OUTPUT
-      - name: Create comment
-        if: steps.download-result.outputs.found_artifact
-        uses: thollander/actions-comment-pull-request@v2
-        with:
-          pr_number: ${{ steps.result.outputs.pr-number }}
-          filePath: ecosystem-result
-          comment_tag: ecosystem-results

.github/workflows/pr-comment.yaml

@@ -0,0 +1,84 @@
+name: PR Check Comment
+
+on:
+  workflow_run:
+    workflows: [CI, Benchmark]
+    types: [completed]
+  workflow_dispatch:
+    inputs:
+      workflow_run_id:
+        description: The ecosystem workflow that triggers the workflow run
+        required: true
+
+permissions:
+  pull-requests: write
+
+jobs:
+  comment:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dawidd6/action-download-artifact@v2
+        name: Download PR Number
+        with:
+          name: pr-number
+          run_id: ${{ github.event.workflow_run.id ||  github.event.inputs.workflow_run_id }}
+          if_no_artifact_found: ignore
+
+      - name: Extract PR Number
+        id: pr-number
+        run: |
+          if [[ -f pr-number ]]
+          then
+            echo "pr-number=$(<pr-number)" >> $GITHUB_OUTPUT
+          fi
+
+      - uses: dawidd6/action-download-artifact@v2
+        name: "Download Ecosystem Result"
+        id: download-ecosystem-result
+        if: steps.pr-number.outputs.pr-number
+        with:
+          name: ecosystem-result
+          workflow: ci.yaml
+          pr: ${{ steps.pr-number.outputs.pr-number }}
+          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'
+        run: |
+          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
+
+          echo 'EOF' >> $GITHUB_OUTPUT
+
+      - name: Create or update comment
+        if: steps.generate-comment.outputs.comment
+        uses: thollander/actions-comment-pull-request@v2
+        with:
+          pr_number: ${{ steps.pr-number.outputs.pr-number }}
+          message: ${{ steps.generate-comment.outputs.comment }}
+          comment_tag: PR Check Results

.pre-commit-config.yaml

@@ -28,17 +28,17 @@ repos:
       - id: cargo-fmt
         name: cargo fmt
         entry: cargo fmt --
-        language: rust
+        language: system
         types: [rust]
       - id: clippy
         name: clippy
         entry: cargo clippy --workspace --all-targets --all-features -- -D warnings
-        language: rust
+        language: system
         pass_filenames: false
       - id: ruff
         name: ruff
         entry: cargo run -p ruff_cli -- check --no-cache --force-exclude --fix --exit-non-zero-on-fix
-        language: rust
+        language: system
         types_or: [python, pyi]
         require_serial: true
         exclude: |
@@ -49,7 +49,7 @@ repos:
       - id: dev-generate-all
         name: dev-generate-all
         entry: cargo dev generate-all
-        language: rust
+        language: system
         pass_filenames: false
         exclude: target
 

BREAKING_CHANGES.md

@@ -145,4 +145,4 @@ default.
 `pyproject.toml` files are now resolved hierarchically, such that for each Python file, we find
 the first `pyproject.toml` file in its path, and use that to determine its lint settings.
 
-See the [README](https://github.com/charliermarsh/ruff#pyprojecttoml-discovery) for more.
+See the [documentation](https://beta.ruff.rs/docs/configuration/#python-file-discovery) for more.

Cargo.lock

@@ -132,12 +132,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "bisection"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "021e079a1bab0ecce6cf4b4b74c0c37afa4a697136eb3b127875c84a8f04a8c3"
-
 [[package]]
 name = "bit-set"
 version = "0.5.3"
@@ -780,7 +774,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.256"
+version = "0.0.260"
 dependencies = [
  "anyhow",
  "clap 4.1.8",
@@ -1982,15 +1976,13 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.256"
+version = "0.0.260"
 dependencies = [
  "anyhow",
- "bisection",
  "bitflags",
  "chrono",
  "clap 4.1.8",
  "colored",
- "criterion",
  "dirs",
  "fern",
  "glob",
@@ -2025,6 +2017,7 @@ dependencies = [
  "schemars",
  "semver",
  "serde",
+ "serde_json",
  "shellexpand",
  "smallvec",
  "strum",
@@ -2033,6 +2026,8 @@ dependencies = [
  "textwrap",
  "thiserror",
  "toml",
+ "typed-arena",
+ "unicode-width",
 ]
 
 [[package]]
@@ -2041,7 +2036,10 @@ version = "0.0.0"
 dependencies = [
  "criterion",
  "mimalloc",
+ "once_cell",
  "ruff",
+ "serde",
+ "serde_json",
  "tikv-jemallocator",
  "ureq",
  "url",
@@ -2060,7 +2058,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_cli"
-version = "0.0.256"
+version = "0.0.260"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -2088,6 +2086,7 @@ dependencies = [
  "ruff",
  "ruff_cache",
  "ruff_diagnostics",
+ "ruff_python_stdlib",
  "rustc-hash",
  "serde",
  "serde_json",
@@ -2098,6 +2097,7 @@ dependencies = [
  "tikv-jemallocator",
  "ureq",
  "walkdir",
+ "wild",
 ]
 
 [[package]]
@@ -2127,6 +2127,8 @@ dependencies = [
 name = "ruff_diagnostics"
 version = "0.0.0"
 dependencies = [
+ "anyhow",
+ "log",
  "ruff_python_ast",
  "rustpython-parser",
  "serde",
@@ -2207,7 +2209,6 @@ name = "ruff_python_stdlib"
 version = "0.0.0"
 dependencies = [
  "once_cell",
- "regex",
  "rustc-hash",
 ]
 
@@ -2251,6 +2252,7 @@ dependencies = [
  "js-sys",
  "log",
  "ruff",
+ "ruff_diagnostics",
  "ruff_python_ast",
  "ruff_rustpython",
  "rustpython-parser",
@@ -2502,6 +2504,7 @@ version = "1.0.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cad406b69c91885b5107daf2c29572f6c8cdb3c66826821e286c533490c0bc76"
 dependencies = [
+ "indexmap",
  "itoa",
  "ryu",
  "serde",
@@ -2912,6 +2915,12 @@ dependencies = [
  "static_assertions",
 ]
 
+[[package]]
+name = "typed-arena"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a"
+
 [[package]]
 name = "typenum"
 version = "1.16.0"
@@ -3258,6 +3267,15 @@ version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "17882f045410753661207383517a6f62ec3dbeb6a4ed2acce01f0728238d1983"
 
+[[package]]
+name = "wild"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05b116685a6be0c52f5a103334cbff26db643826c7b3735fc0a3ba9871310a74"
+dependencies = [
+ "glob",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"

Cargo.toml

@@ -37,7 +37,7 @@ rustpython-parser = { features = [
 ], git = "https://github.com/RustPython/RustPython.git", rev = "c15f670f2c30cfae6b41a1874893590148c74bc4" }
 schemars = { version = "0.8.12" }
 serde = { version = "1.0.152", features = ["derive"] }
-serde_json = { version = "1.0.93" }
+serde_json = { version = "1.0.93", features = ["preserve_order"] }
 shellexpand = { version = "3.0.0" }
 similar = { version = "2.2.1" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
@@ -48,10 +48,7 @@ textwrap = { version = "0.16.0" }
 toml = { version = "0.7.2" }
 
 [profile.release]
-panic = "abort"
-lto = "thin"
-codegen-units = 1
-opt-level = 3
+lto = "fat"
 
 [profile.dev.package.insta]
 opt-level = 3

LICENSE

@@ -195,6 +195,15 @@ are:
     CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   """
 
+- flake8-gettext, licensed as follows:
+  """
+    BSD Zero Clause License
+
+    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+  """
+
 - flake8-implicit-str-concat, licensed as follows:
   """
     The MIT License (MIT)
@@ -393,7 +402,6 @@ are:
     THE SOFTWARE.
   """
 
-
 - autoflake, licensed as follows:
   """
     Copyright (C) 2012-2018 Steven Myint
@@ -417,6 +425,31 @@ are:
     SOFTWARE.
   """
 
+- autotyping, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2023 Jelle Zijlstra
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  """
+
 - Flake8, licensed as follows:
   """
     == Flake8 License (MIT) ==

README.md

@@ -137,7 +137,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com) hook:
 ```yaml
 - repo: https://github.com/charliermarsh/ruff-pre-commit
   # Ruff version.
-  rev: 'v0.0.256'
+  rev: 'v0.0.260'
   hooks:
     - id: ruff
 ```
@@ -160,7 +160,7 @@ select = ["E", "F"]
 ignore = []
 
 # Allow autofix for all enabled rules (when `--fix`) is provided.
-fixable = ["A", "B", "C", "D", "E", "F", "..."]
+fixable = ["A", "B", "C", "D", "E", "F", "G", "I", "N", "Q", "S", "T", "W", "ANN", "ARG", "BLE", "COM", "DJ", "DTZ", "EM", "ERA", "EXE", "FBT", "ICN", "INP", "ISC", "NPY", "PD", "PGH", "PIE", "PL", "PT", "PTH", "PYI", "RET", "RSE", "RUF", "SIM", "SLF", "TCH", "TID", "TRY", "UP", "YTT"]
 unfixable = []
 
 # Exclude a variety of commonly ignored directories.
@@ -227,6 +227,55 @@ stylistic rules made obsolete by the use of an autoformatter, like
 If you're just getting started with Ruff, **the default rule set is a great place to start**: it
 catches a wide variety of common errors (like unused imports) with zero configuration.
 
+Beyond the defaults, Ruff re-implements some of the most popular Flake8 plugins and related code
+quality tools, including:
+
+- [autoflake](https://pypi.org/project/autoflake/)
+- [eradicate](https://pypi.org/project/eradicate/)
+- [flake8-2020](https://pypi.org/project/flake8-2020/)
+- [flake8-annotations](https://pypi.org/project/flake8-annotations/)
+- [flake8-bandit](https://pypi.org/project/flake8-bandit/) ([#1646](https://github.com/charliermarsh/ruff/issues/1646))
+- [flake8-blind-except](https://pypi.org/project/flake8-blind-except/)
+- [flake8-boolean-trap](https://pypi.org/project/flake8-boolean-trap/)
+- [flake8-bugbear](https://pypi.org/project/flake8-bugbear/)
+- [flake8-builtins](https://pypi.org/project/flake8-builtins/)
+- [flake8-commas](https://pypi.org/project/flake8-commas/)
+- [flake8-comprehensions](https://pypi.org/project/flake8-comprehensions/)
+- [flake8-datetimez](https://pypi.org/project/flake8-datetimez/)
+- [flake8-debugger](https://pypi.org/project/flake8-debugger/)
+- [flake8-django](https://pypi.org/project/flake8-django/)
+- [flake8-docstrings](https://pypi.org/project/flake8-docstrings/)
+- [flake8-eradicate](https://pypi.org/project/flake8-eradicate/)
+- [flake8-errmsg](https://pypi.org/project/flake8-errmsg/)
+- [flake8-executable](https://pypi.org/project/flake8-executable/)
+- [flake8-gettext](https://pypi.org/project/flake8-gettext/)
+- [flake8-implicit-str-concat](https://pypi.org/project/flake8-implicit-str-concat/)
+- [flake8-import-conventions](https://github.com/joaopalmeiro/flake8-import-conventions)
+- [flake8-logging-format](https://pypi.org/project/flake8-logging-format/)
+- [flake8-no-pep420](https://pypi.org/project/flake8-no-pep420)
+- [flake8-pie](https://pypi.org/project/flake8-pie/)
+- [flake8-print](https://pypi.org/project/flake8-print/)
+- [flake8-pyi](https://pypi.org/project/flake8-pyi/)
+- [flake8-pytest-style](https://pypi.org/project/flake8-pytest-style/)
+- [flake8-quotes](https://pypi.org/project/flake8-quotes/)
+- [flake8-raise](https://pypi.org/project/flake8-raise/)
+- [flake8-return](https://pypi.org/project/flake8-return/)
+- [flake8-self](https://pypi.org/project/flake8-self/)
+- [flake8-simplify](https://pypi.org/project/flake8-simplify/)
+- [flake8-super](https://pypi.org/project/flake8-super/)
+- [flake8-tidy-imports](https://pypi.org/project/flake8-tidy-imports/)
+- [flake8-type-checking](https://pypi.org/project/flake8-type-checking/)
+- [flake8-use-pathlib](https://pypi.org/project/flake8-use-pathlib/)
+- [isort](https://pypi.org/project/isort/)
+- [mccabe](https://pypi.org/project/mccabe/)
+- [pandas-vet](https://pypi.org/project/pandas-vet/)
+- [pep8-naming](https://pypi.org/project/pep8-naming/)
+- [pydocstyle](https://pypi.org/project/pydocstyle/)
+- [pygrep-hooks](https://github.com/pre-commit/pygrep-hooks) ([#980](https://github.com/charliermarsh/ruff/issues/980))
+- [pyupgrade](https://pypi.org/project/pyupgrade/)
+- [tryceratops](https://pypi.org/project/tryceratops/)
+- [yesqa](https://pypi.org/project/yesqa/)
+
 <!-- End section: Rules -->
 
 For a complete enumeration of the supported rules, see [_Rules_](https://beta.ruff.rs/docs/rules/).
@@ -280,6 +329,7 @@ Ruff is used in a number of major open-source projects, including:
 - [Zulip](https://github.com/zulip/zulip)
 - [Bokeh](https://github.com/bokeh/bokeh)
 - [Pydantic](https://github.com/pydantic/pydantic)
+- [PostHog](https://github.com/PostHog/posthog)
 - [Dagster](https://github.com/dagster-io/dagster)
 - [Dagger](https://github.com/dagger/dagger)
 - [Sphinx](https://github.com/sphinx-doc/sphinx)
@@ -309,6 +359,10 @@ Ruff is used in a number of major open-source projects, including:
 - [Starlite](https://github.com/starlite-api/starlite)
 - [telemetry-airflow (Mozilla)](https://github.com/mozilla/telemetry-airflow)
 - [Stable Baselines3](https://github.com/DLR-RM/stable-baselines3)
+- [PaddlePaddle](https://github.com/PaddlePaddle/Paddle)
+- [nox](https://github.com/wntrblm/nox)
+- [Neon](https://github.com/neondatabase/neon)
+- [The Algorithms](https://github.com/TheAlgorithms/Python)
 
 ## License
 

crates/flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.256"
+version = "0.0.260"
 edition = { workspace = true }
 rust-version = { workspace = true }
 

crates/flake8_to_ruff/README.md

@@ -85,8 +85,9 @@ flake8-to-ruff path/to/.flake8 --plugin flake8-builtins --plugin flake8-quotes
    ignore unsupported options in the `.flake8` file (or equivalent). (Similarly, Ruff has a few
    configuration options that don't exist in Flake8.)
 1. Ruff will omit any rule codes that are unimplemented or unsupported by Ruff, including rule
-   codes from unsupported plugins. (See the [Ruff README](https://github.com/charliermarsh/ruff#user-content-how-does-ruff-compare-to-flake8)
-   for the complete list of supported plugins.)
+   codes from unsupported plugins. (See the
+   [documentation](https://beta.ruff.rs/docs/faq/#how-does-ruff-compare-to-flake8) for the complete
+   list of supported plugins.)
 
 ## License
 

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.256"
+version = "0.0.260"
 authors.workspace = true
 edition.workspace = true
 rust-version.workspace = true
@@ -22,7 +22,6 @@ ruff_python_stdlib = { path = "../ruff_python_stdlib" }
 ruff_rustpython = { path = "../ruff_rustpython" }
 
 anyhow = { workspace = true }
-bisection = { version = "0.1.0" }
 bitflags = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true, features = ["derive", "string"], optional = true }
@@ -58,6 +57,7 @@ rustpython-parser = { workspace = true }
 schemars = { workspace = true }
 semver = { version = "1.0.16" }
 serde = { workspace = true }
+serde_json = { workspace = true }
 shellexpand = { workspace = true }
 smallvec = { version = "1.10.0" }
 strum = { workspace = true }
@@ -65,9 +65,10 @@ strum_macros = { workspace = true }
 textwrap = { workspace = true }
 thiserror = { version = "1.0.38" }
 toml = { workspace = true }
+typed-arena = { version = "2.0.2" }
+unicode-width = {version ="0.1.10"}
 
 [dev-dependencies]
-criterion = { version = "0.4.0" }
 insta = { workspace = true, features = ["yaml", "redactions"] }
 pretty_assertions = "1.3.0"
 test-case = { workspace = true }
@@ -75,3 +76,4 @@ test-case = { workspace = true }
 [features]
 default = []
 logical_lines = []
+jupyter_notebook = []

crates/ruff/resources/test/disallowed_rule_names.txt

@@ -2,3 +2,7 @@ avoid-*
 do-not-*
 uses-*
 *-used
+rewrite-*
+prefer-*
+consider-*
+use-*

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

@@ -0,0 +1,42 @@
+class Foo:
+    def __str__(self):
+        ...
+
+    def __repr__(self):
+        ...
+
+    def __len__(self):
+        ...
+
+    def __length_hint__(self):
+        ...
+
+    def __init__(self):
+        ...
+
+    def __del__(self):
+        ...
+
+    def __bool__(self):
+        ...
+
+    def __bytes__(self):
+        ...
+
+    def __format__(self, format_spec):
+        ...
+
+    def __contains__(self, item):
+        ...
+
+    def __complex__(self):
+        ...
+
+    def __int__(self):
+        ...
+
+    def __float__(self):
+        ...
+
+    def __index__(self):
+        ...

crates/ruff/resources/test/fixtures/flake8_bandit/S301.py

@@ -0,0 +1,3 @@
+import pickle
+
+pickle.loads()

crates/ruff/resources/test/fixtures/flake8_bandit/S312.py

@@ -0,0 +1,3 @@
+from telnetlib import Telnet
+
+Telnet("localhost", 23)

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

@@ -1,7 +1,9 @@
 import collections
 import datetime as dt
+from decimal import Decimal
 import logging
 import operator
+from pathlib import Path
 import random
 import re
 import time
@@ -165,6 +167,26 @@ def float_str_not_inf_or_nan_is_wrong(value=float("3.14")):
     pass
 
 
+# Allow decimals
+def decimal_okay(value=Decimal("0.1")):
+    pass
+
+# Allow dates
+def date_okay(value=dt.date(2023, 3, 27)):
+    pass
+
+# Allow datetimes
+def datetime_okay(value=dt.datetime(2023, 3, 27, 13, 51, 59)):
+    pass
+
+# Allow timedeltas
+def timedelta_okay(value=dt.timedelta(hours=1)):
+    pass
+
+# Allow paths
+def path_okay(value=Path(".")):
+    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/B018.py

@@ -57,3 +57,9 @@ def foo3():
 
 def foo4():
     ...
+
+
+def foo5():
+    foo.bar  # Attribute (raise)
+    object().__class__  # Attribute (raise)
+    "foo" + "bar"  # BinOp (raise)

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

@@ -0,0 +1,11 @@
+import warnings
+
+"""
+Should emit:
+B028 - on lines 8 and 9
+"""
+
+warnings.warn(DeprecationWarning("test"))
+warnings.warn(DeprecationWarning("test"), source=None)
+warnings.warn(DeprecationWarning("test"), source=None, stacklevel=2)
+warnings.warn(DeprecationWarning("test"), stacklevel=1)

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

@@ -0,0 +1,112 @@
+import itertools
+from itertools import groupby
+
+shoppers = ["Jane", "Joe", "Sarah"]
+items = [
+    ("lettuce", "greens"),
+    ("tomatoes", "greens"),
+    ("cucumber", "greens"),
+    ("chicken breast", "meats & fish"),
+    ("salmon", "meats & fish"),
+    ("ice cream", "frozen items"),
+]
+
+carts = {shopper: [] for shopper in shoppers}
+
+
+def collect_shop_items(shopper, items):
+    # Imagine this an expensive database query or calculation that is
+    # advantageous to batch.
+    carts[shopper] += items
+
+
+# Invoking the `groupby` function directly
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    for shopper in shoppers:
+        shopper = shopper.title()
+        collect_shop_items(shopper, section_items)  # B031
+    # We're outside the nested loop and used the group again.
+    collect_shop_items(shopper, section_items)  # B031
+
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    collect_shop_items("Jane", section_items)
+    collect_shop_items("Joe", section_items)  # B031
+
+
+# Make sure to detect in other loop constructs as well - `while` loop
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    countdown = 3
+    while countdown > 0:
+        collect_shop_items(shopper, section_items)  # B031
+        countdown -= 1
+
+# Make sure to detect in other loop constructs as well - `list` comprehension
+collection = []
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    collection.append([list(section_items) for _ in range(3)])  # B031
+
+unique_items = set()
+another_set = set()
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    # For nested loops, it should not flag the usage of the name
+    for item in section_items:
+        unique_items.add(item)
+
+    # But it should be detected when used again
+    for item in section_items:  # B031
+        another_set.add(item)
+
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    # Variable has been overridden, skip checking
+    section_items = list(unique_items)
+    collect_shop_items("Jane", section_items)
+    collect_shop_items("Jane", section_items)
+
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    # Variable has been overridden, skip checking
+    # Not a realistic situation, just for testing purpose
+    (section_items := list(unique_items))
+    collect_shop_items("Jane", section_items)
+    collect_shop_items("Jane", section_items)
+
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    # This is ok
+    collect_shop_items("Jane", section_items)
+
+# Invocation via the `itertools` module
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    for shopper in shoppers:
+        collect_shop_items(shopper, section_items)  # B031
+
+for group in groupby(items, key=lambda p: p[1]):
+    # This is bad, but not detected currently
+    collect_shop_items("Jane", group[1])
+    collect_shop_items("Joe", group[1])
+
+
+#  Make sure we ignore - but don't fail on more complicated invocations
+for _key, (_value1, _value2) in groupby(
+    [("a", (1, 2)), ("b", (3, 4)), ("a", (5, 6))], key=lambda p: p[1]
+):
+    collect_shop_items("Jane", group[1])
+    collect_shop_items("Joe", group[1])
+
+#  Make sure we ignore - but don't fail on more complicated invocations
+for (_key1, _key2), (_value1, _value2) in groupby(
+    [(("a", "a"), (1, 2)), (("b", "b"), (3, 4)), (("a", "a"), (5, 6))],
+    key=lambda p: p[1],
+):
+    collect_shop_items("Jane", group[1])
+    collect_shop_items("Joe", group[1])
+
+
+# Let's redefine the `groupby` function to make sure we pick up the correct one.
+# NOTE: This should always be at the end of the file.
+def groupby(data, key=None):
+    pass
+
+
+for name, group in groupby(items):
+    collect_shop_items("Jane", items)
+    # This shouldn't be flagged as the `groupby` function is different
+    collect_shop_items("Joe", items)

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

@@ -1,6 +1,19 @@
 x = [1, 2, 3]
+y = [("a", 1), ("b", 2), ("c", 3)]
+z = [(1,), (2,), (3,)]
+d = {"a": 1, "b": 2, "c": 3}
+
 [i for i in x]
 {i for i in x}
+{k: v for k, v in y}
+{k: v for k, v in d.items()}
 
+[i for i, in z]
+[i for i, j in y]
 [i for i in x if i > 1]
 [i for i in x for j in x]
+
+{v: k for k, v in y}
+{k.foo: k for k in y}
+{k["foo"]: k for k in y}
+{k: v if v else None for k, v in y}

crates/ruff/resources/test/fixtures/flake8_django/DJ012.py

@@ -0,0 +1,113 @@
+from django.db import models
+from django.db.models import Model
+
+
+class StrBeforeRandomField(models.Model):
+    """Model with `__str__` before a random property."""
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def __str__(self):
+        return ""
+
+    random_property = "foo"
+
+
+class StrBeforeFieldModel(models.Model):
+    """Model with `__str__` before fields."""
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def __str__(self):
+        return "foobar"
+
+    first_name = models.CharField(max_length=32)
+
+
+class ManagerBeforeField(models.Model):
+    """Model with manager before fields."""
+
+    objects = "manager"
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def __str__(self):
+        return "foobar"
+
+    first_name = models.CharField(max_length=32)
+
+
+class CustomMethodBeforeStr(models.Model):
+    """Model with a custom method before `__str__`."""
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def my_method(self):
+        pass
+
+    def __str__(self):
+        return "foobar"
+
+
+class GetAbsoluteUrlBeforeSave(Model):
+    """Model with `get_absolute_url` method before `save` method.
+
+    Subclass this directly using the `Model` class.
+    """
+
+    def get_absolute_url(self):
+        pass
+
+    def save(self):
+        pass
+
+
+class ConstantsAreNotFields(models.Model):
+    """Model with an assignment to a constant after `__str__`."""
+
+    first_name = models.CharField(max_length=32)
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def __str__(self):
+        pass
+
+    MY_CONSTANT = id(1)
+
+
+class PerfectlyFine(models.Model):
+    """Model which has everything in perfect order."""
+
+    first_name = models.CharField(max_length=32)
+    last_name = models.CharField(max_length=32)
+    objects = "manager"
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def __str__(self):
+        return "Perfectly fine!"
+
+    def save(self, **kwargs):
+        super(PerfectlyFine, self).save(**kwargs)
+
+    def get_absolute_url(self):
+        return "http://%s" % self
+
+    def my_method(self):
+        pass
+
+    @property
+    def random_property(self):
+        return "%s" % self

crates/ruff/resources/test/fixtures/flake8_gettext/INT001.py

@@ -0,0 +1 @@
+_(f"{'value'}")

crates/ruff/resources/test/fixtures/flake8_gettext/INT002.py

@@ -0,0 +1 @@
+_("{}".format("line"))

crates/ruff/resources/test/fixtures/flake8_gettext/INT003.py

@@ -0,0 +1 @@
+_("%s" % "line")

crates/ruff/resources/test/fixtures/flake8_logging_format/G001.py

@@ -1,3 +1,9 @@
 import logging
+import logging as foo
 
 logging.info("Hello {}".format("World!"))
+logging.log(logging.INFO, "Hello {}".format("World!"))
+foo.info("Hello {}".format("World!"))
+logging.log(logging.INFO, msg="Hello {}".format("World!"))
+logging.log(level=logging.INFO, msg="Hello {}".format("World!"))
+logging.log(msg="Hello {}".format("World!"), level=logging.INFO)

crates/ruff/resources/test/fixtures/flake8_logging_format/G002.py

@@ -1,3 +1,4 @@
 import logging
 
 logging.info("Hello %s" % "World!")
+logging.log(logging.INFO, "Hello %s" % "World!")

crates/ruff/resources/test/fixtures/flake8_logging_format/G003.py

@@ -1,3 +1,4 @@
 import logging
 
 logging.info("Hello" + " " + "World!")
+logging.log(logging.INFO, "Hello" + " " + "World!")

crates/ruff/resources/test/fixtures/flake8_logging_format/G004.py

@@ -2,3 +2,4 @@ import logging
 
 name = "world"
 logging.info(f"Hello {name}")
+logging.log(logging.INFO, f"Hello {name}")

crates/ruff/resources/test/fixtures/flake8_pyi/PYI011.py

@@ -1,79 +1,161 @@
+import math
+import os
+import sys
+from math import inf
+
+import numpy as np
+
 def f12(
     x,
     y: str = os.pathsep,  # OK
-) -> None:
-    ...
-
-
-def f11(*, x: str = "x") -> None:  # OK
-    ...
-
-
+) -> None: ...
+def f11(*, x: str = "x") -> None: ...  # OK
 def f13(
-    x: list[str] = [
+    x: list[str] = [  # OK
         "foo",
         "bar",
         "baz",
-    ]  # OK
-) -> None:
-    ...
-
-
+    ]
+) -> None: ...
 def f14(
-    x: tuple[str, ...] = (
+    x: tuple[str, ...] = (  # OK
         "foo",
         "bar",
         "baz",
-    )  # OK
-) -> None:
-    ...
-
-
+    )
+) -> None: ...
 def f15(
-    x: set[str] = {
+    x: set[str] = {  # OK
         "foo",
         "bar",
         "baz",
-    }  # OK
-) -> None:
-    ...
-
-
-def f16(x: frozenset[bytes] = frozenset({b"foo", b"bar", b"baz"})) -> None:  # OK
-    ...
-
-
+    }
+) -> None: ...
+def f151(x: dict[int, int] = {1: 2}) -> None: ...  # Ok
+def f152(
+    x: dict[
+        int, int
+    ] = {  # OK
+        1: 2,
+        **{3: 4},
+    }
+) -> None: ...
+def f153(
+    x: list[
+        int
+    ] = [  # OK
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+    ]
+) -> None: ...
+def f154(
+    x: tuple[
+        str, tuple[str, ...]
+    ] = (  # OK
+        "foo",
+        ("bar", "baz"),
+    )
+) -> None: ...
+def f141(
+    x: list[
+        int
+    ] = [  # OK
+        *range(10)
+    ],
+) -> None: ...
+def f142(
+    x: list[
+        int
+    ] = list(  # OK
+        range(10)
+    ),
+) -> None: ...
+def f16(
+    x: frozenset[
+        bytes
+    ] = frozenset(  # OK
+        {b"foo", b"bar", b"baz"}
+    )
+) -> None: ...
 def f17(
-    x: str = "foo" + "bar",  # OK
-) -> None:
-    ...
-
-
+    x: str = "foo"  # OK
+    + "bar",
+) -> None: ...
 def f18(
-    x: str = b"foo" + b"bar",  # OK
-) -> None:
-    ...
-
-
+    x: str = b"foo"  # OK
+    + b"bar",
+) -> None: ...
 def f19(
-    x: object = "foo" + 4,  # OK
-) -> None:
-    ...
-
-
+    x: object = "foo"  # OK
+    + 4,
+) -> None: ...
 def f20(
-    x: int = 5 + 5,  # OK
-) -> None:
-    ...
-
-
+    x: int = 5
+    + 5,  # OK
+) -> None: ...
 def f21(
-    x: complex = 3j - 3j,  # OK
-) -> None:
-    ...
-
-
+    x: complex = 3j
+    - 3j,  # OK
+) -> None: ...
 def f22(
-    x: complex = -42.5j + 4.3j,  # OK
-) -> None:
-    ...
+    x: complex = -42.5j  # OK
+    + 4.3j,
+) -> None: ...
+def f23(
+    x: bool = True,  # OK
+) -> None: ...
+def f24(
+    x: float = 3.14,  # OK
+) -> None: ...
+def f25(
+    x: float = -3.14,  # OK
+) -> None: ...
+def f26(
+    x: complex = -3.14j,  # OK
+) -> None: ...
+def f27(
+    x: complex = -3 - 3.14j,  # OK
+) -> None: ...
+def f28(
+    x: float = math.tau,  # OK
+) -> None: ...
+def f29(
+    x: float = math.inf,  # OK
+) -> None: ...
+def f30(
+    x: float = -math.inf,  # OK
+) -> None: ...
+def f31(
+    x: float = inf,  # OK
+) -> None: ...
+def f32(
+    x: float = np.inf,  # OK
+) -> None: ...
+def f33(
+    x: float = math.nan,  # OK
+) -> None: ...
+def f34(
+    x: float = -math.nan,  # OK
+) -> None: ...
+def f35(
+    x: complex = math.inf  # OK
+    + 1j,
+) -> None: ...
+def f36(
+    *,
+    x: str = sys.version,  # OK
+) -> None: ...
+def f37(
+    *,
+    x: str = ""  # OK
+    + "",
+) -> None: ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI011.pyi

@@ -11,32 +11,74 @@ def f12(
 ) -> None: ...
 def f11(*, x: str = "x") -> None: ...  # OK
 def f13(
-    x: list[
-        str
-    ] = [  # Error PYI011 Only simple default values allowed for typed arguments
+    x: list[str] = [  # OK
         "foo",
         "bar",
         "baz",
     ]
 ) -> None: ...
 def f14(
-    x: tuple[
-        str, ...
-    ] = (  # Error PYI011 Only simple default values allowed for typed arguments
+    x: tuple[str, ...] = (  # OK
         "foo",
         "bar",
         "baz",
     )
 ) -> None: ...
 def f15(
-    x: set[
-        str
-    ] = {  # Error PYI011 Only simple default values allowed for typed arguments
+    x: set[str] = {  # OK
         "foo",
         "bar",
         "baz",
     }
 ) -> None: ...
+def f151(x: dict[int, int] = {1: 2}) -> None: ...  # Ok
+def f152(
+    x: dict[
+        int, int
+    ] = {  # Error PYI011 Only simple default values allowed for typed arguments
+        1: 2,
+        **{3: 4},
+    }
+) -> None: ...
+def f153(
+    x: list[
+        int
+    ] = [  # Error PYI011 Only simple default values allowed for typed arguments
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+    ]
+) -> None: ...
+def f154(
+    x: tuple[
+        str, tuple[str, ...]
+    ] = (  # Error PYI011 Only simple default values allowed for typed arguments
+        "foo",
+        ("bar", "baz"),
+    )
+) -> None: ...
+def f141(
+    x: list[
+        int
+    ] = [  # Error PYI011 Only simple default values allowed for typed arguments
+        *range(10)
+    ],
+) -> None: ...
+def f142(
+    x: list[
+        int
+    ] = list(  # Error PYI011 Only simple default values allowed for typed arguments
+        range(10)
+    ),
+) -> None: ...
 def f16(
     x: frozenset[
         bytes
@@ -109,8 +151,11 @@ def f35(
     + 1j,
 ) -> None: ...
 def f36(
-    *, x: str = sys.version,  # OK
+    *,
+    x: str = sys.version,  # OK
 ) -> None: ...
 def f37(
-    *, x: str = "" + "",  # Error PYI011 Only simple default values allowed for typed arguments
+    *,
+    x: str = ""  # Error PYI011 Only simple default values allowed for typed arguments
+    + "",
 ) -> None: ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI012.py

@@ -0,0 +1,75 @@
+# Violations of PYI012
+
+
+class OneAttributeClass:
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+
+class OneAttributeClassRev:
+    pass  # PYI012 Class body must not contain `pass`
+    value: int
+
+
+class DocstringClass:
+    """
+    My body only contains pass.
+    """
+
+    pass  # PYI012 Class body must not contain `pass`
+
+
+class NonEmptyChild(Exception):
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+
+class NonEmptyChild2(Exception):
+    pass  # PYI012 Class body must not contain `pass`
+    value: int
+
+
+class NonEmptyWithInit:
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+    def __init__():
+        pass
+
+
+# Not violations (of PYI012)
+
+
+class EmptyClass:
+    pass  # Y009 Empty body should contain `...`, not `pass`
+
+
+class EmptyOneLine:
+    pass  # Y009 Empty body should contain `...`, not `pass`
+
+
+class Dog:
+    eyes: int = 2
+
+
+class EmptyEllipsis:
+    ...
+
+
+class NonEmptyEllipsis:
+    value: int
+    ...  # Y013 Non-empty class body must not contain `...`
+
+
+class WithInit:
+    value: int = 0
+
+    def __init__():
+        pass
+
+
+def function():
+    pass
+
+
+pass

crates/ruff/resources/test/fixtures/flake8_pyi/PYI012.pyi

@@ -0,0 +1,59 @@
+# Violations of PYI012
+
+class OneAttributeClass:
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+class OneAttributeClassRev:
+    pass  # PYI012 Class body must not contain `pass`
+    value: int
+
+class DocstringClass:
+    """
+    My body only contains pass.
+    """
+
+    pass  # PYI012 Class body must not contain `pass`
+
+class NonEmptyChild(Exception):
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+class NonEmptyChild2(Exception):
+    pass  # PYI012 Class body must not contain `pass`
+    value: int
+
+class NonEmptyWithInit:
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+    def __init__():
+        pass
+
+# Not violations (of PYI012)
+
+class EmptyClass:
+    pass  # Y009 Empty body should contain `...`, not `pass`
+
+class EmptyOneLine:
+    pass  # Y009 Empty body should contain `...`, not `pass`
+
+class Dog:
+    eyes: int = 2
+
+class EmptyEllipsis: ...
+
+class NonEmptyEllipsis:
+    value: int
+    ...  # Y013 Non-empty class body must not contain `...`
+
+class WithInit:
+    value: int = 0
+
+    def __init__():
+        pass
+
+def function():
+    pass
+
+pass

crates/ruff/resources/test/fixtures/flake8_pyi/PYI014.py

@@ -39,6 +39,58 @@ def f15(
     ...
 
 
+def f151(x={1: 2}) -> None:  # Ok
+    ...
+
+
+def f152(
+    x={  # OK
+        1: 2,
+        **{3: 4},
+    }
+) -> None:
+    ...
+
+
+def f153(
+    x=[  # OK
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+    ]
+) -> None:
+    ...
+
+
+def f154(
+    x=(  # OK
+        "foo",
+        ("bar", "baz"),
+    )
+) -> None:
+    ...
+
+
+def f141(
+    x=[*range(10)],  # OK
+) -> None:
+    ...
+
+
+def f142(
+    x=list(range(10)),  # OK
+) -> None:
+    ...
+
+
 def f16(x=frozenset({b"foo", b"bar", b"baz"})) -> None:
     ...  # OK
 

crates/ruff/resources/test/fixtures/flake8_pyi/PYI014.pyi

@@ -4,26 +4,60 @@ def f12(
 ) -> None: ...
 def f11(*, x="x") -> None: ...  # OK
 def f13(
-    x=[  # Error PYI014
+    x=[  # OK
         "foo",
         "bar",
         "baz",
     ]
 ) -> None: ...
 def f14(
-    x=(  # Error PYI014
+    x=(  # OK
         "foo",
         "bar",
         "baz",
     )
 ) -> None: ...
 def f15(
-    x={  # Error PYI014
+    x={  # OK
         "foo",
         "bar",
         "baz",
     }
 ) -> None: ...
+def f151(x={1: 2}) -> None: ...
+def f152(
+    x={  # Error PYI014
+        1: 2,
+        **{3: 4},
+    }
+) -> None: ...
+def f153(
+    x=[  # Error PYI014
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+    ]
+) -> None: ...
+def f154(
+    x=(  # Error PYI014
+        "foo",
+        ("bar", "baz"),
+    )
+) -> None: ...
+def f141(
+    x=[*range(10)],  # Error PYI014
+) -> None: ...
+def f142(
+    x=list(range(10)),  # Error PYI014
+) -> None: ...
 def f16(x=frozenset({b"foo", b"bar", b"baz"})) -> None: ...  # Error PYI014
 def f17(
     x="foo" + "bar",  # Error PYI014
@@ -44,5 +78,5 @@ def f22(
     x=-42.5j + 4.3j,  # Error PYI014
 ) -> None: ...
 def f23(
-  x=True,  # OK
+    x=True,  # OK
 ) -> None: ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI015.py

@@ -0,0 +1,48 @@
+import builtins
+import typing
+from typing import TypeAlias, Final
+
+field1: int
+field2: int = ...
+field3 = ...  # type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+field4: int = 0
+field41: int = 0xFFFFFFFF
+field42: int = 1234567890
+field43: int = -0xFFFFFFFF
+field44: int = -1234567890
+field5 = 0  # type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")  # Y052 Need type annotation for "field5"
+field6 = 0  # Y052 Need type annotation for "field6"
+field7 = b""  # Y052 Need type annotation for "field7"
+field71 = "foo"  # Y052 Need type annotation for "field71"
+field72: str = "foo"
+field8 = False  # Y052 Need type annotation for "field8"
+field81 = -1  # Y052 Need type annotation for "field81"
+field82: float = -98.43
+field83 = -42j  # Y052 Need type annotation for "field83"
+field84 = 5 + 42j  # Y052 Need type annotation for "field84"
+field85 = -5 - 42j  # Y052 Need type annotation for "field85"
+field9 = None  # Y026 Use typing_extensions.TypeAlias for type aliases, e.g. "field9: TypeAlias = None"
+Field95: TypeAlias = None
+Field96: TypeAlias = int | None
+Field97: TypeAlias = None | typing.SupportsInt | builtins.str | float | bool
+field19 = [1, 2, 3]  # Y052 Need type annotation for "field19"
+field191: list[int] = [1, 2, 3]
+field20 = (1, 2, 3)  # Y052 Need type annotation for "field20"
+field201: tuple[int, ...] = (1, 2, 3)
+field21 = {1, 2, 3}  # Y052 Need type annotation for "field21"
+field211: set[int] = {1, 2, 3}
+field212 = {"foo": "bar"}  # Y052 Need type annotation for "field212"
+field213: dict[str, str] = {"foo": "bar"}
+field22: Final = {"foo": 5}
+field221: list[int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]  # Y015 Only simple default values are allowed for assignments
+field223: list[int] = [*range(10)]  # Y015 Only simple default values are allowed for assignments
+field224: list[int] = list(range(10))  # Y015 Only simple default values are allowed for assignments
+field225: list[object] = [{}, 1, 2]  # Y015 Only simple default values are allowed for assignments
+field226: tuple[str | tuple[str, ...], ...] = ("foo", ("foo", "bar"))  # Y015 Only simple default values are allowed for assignments
+field227: dict[str, object] = {"foo": {"foo": "bar"}}  # Y015 Only simple default values are allowed for assignments
+field228: dict[str, list[object]] = {"foo": []}  # Y015 Only simple default values are allowed for assignments
+# When parsed, this case results in `None` being placed in the `.keys` list for the `ast.Dict` node
+field229: dict[int, int] = {1: 2, **{3: 4}}  # Y015 Only simple default values are allowed for assignments
+field23 = "foo" + "bar"  # Y015 Only simple default values are allowed for assignments
+field24 = b"foo" + b"bar"  # Y015 Only simple default values are allowed for assignments
+field25 = 5 * 5  # Y015 Only simple default values are allowed for assignments

crates/ruff/resources/test/fixtures/flake8_pyi/PYI015.pyi

@@ -0,0 +1,51 @@
+import builtins
+import typing
+from typing import TypeAlias, Final
+
+# We shouldn't emit Y015 for simple default values
+field1: int
+field2: int = ...
+field3 = ...  # type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+field4: int = 0
+field41: int = 0xFFFFFFFF
+field42: int = 1234567890
+field43: int = -0xFFFFFFFF
+field44: int = -1234567890
+field5 = 0  # type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")  # Y052 Need type annotation for "field5"
+field6 = 0  # Y052 Need type annotation for "field6"
+field7 = b""  # Y052 Need type annotation for "field7"
+field71 = "foo"  # Y052 Need type annotation for "field71"
+field72: str = "foo"
+field8 = False  # Y052 Need type annotation for "field8"
+field81 = -1  # Y052 Need type annotation for "field81"
+field82: float = -98.43
+field83 = -42j  # Y052 Need type annotation for "field83"
+field84 = 5 + 42j  # Y052 Need type annotation for "field84"
+field85 = -5 - 42j  # Y052 Need type annotation for "field85"
+field9 = None  # Y026 Use typing_extensions.TypeAlias for type aliases, e.g. "field9: TypeAlias = None"
+Field95: TypeAlias = None
+Field96: TypeAlias = int | None
+Field97: TypeAlias = None | typing.SupportsInt | builtins.str | float | bool
+field19 = [1, 2, 3]  # Y052 Need type annotation for "field19"
+field191: list[int] = [1, 2, 3]
+field20 = (1, 2, 3)  # Y052 Need type annotation for "field20"
+field201: tuple[int, ...] = (1, 2, 3)
+field21 = {1, 2, 3}  # Y052 Need type annotation for "field21"
+field211: set[int] = {1, 2, 3}
+field212 = {"foo": "bar"}  # Y052 Need type annotation for "field212"
+field213: dict[str, str] = {"foo": "bar"}
+field22: Final = {"foo": 5}
+
+# We *should* emit Y015 for more complex default values
+field221: list[int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]  # Y015 Only simple default values are allowed for assignments
+field223: list[int] = [*range(10)]  # Y015 Only simple default values are allowed for assignments
+field224: list[int] = list(range(10))  # Y015 Only simple default values are allowed for assignments
+field225: list[object] = [{}, 1, 2]  # Y015 Only simple default values are allowed for assignments
+field226: tuple[str | tuple[str, ...], ...] = ("foo", ("foo", "bar"))  # Y015 Only simple default values are allowed for assignments
+field227: dict[str, object] = {"foo": {"foo": "bar"}}  # Y015 Only simple default values are allowed for assignments
+field228: dict[str, list[object]] = {"foo": []}  # Y015 Only simple default values are allowed for assignments
+# When parsed, this case results in `None` being placed in the `.keys` list for the `ast.Dict` node
+field229: dict[int, int] = {1: 2, **{3: 4}}  # Y015 Only simple default values are allowed for assignments
+field23 = "foo" + "bar"  # Y015 Only simple default values are allowed for assignments
+field24 = b"foo" + b"bar"  # Y015 Only simple default values are allowed for assignments
+field25 = 5 * 5  # Y015 Only simple default values are allowed for assignments

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

@@ -2,3 +2,13 @@ def x(y):
     if not y:
         return
     return None  # error
+
+
+class BaseCache:
+    def get(self, key: str) -> str | None:
+        print(f"{key} not found")
+        return None
+
+    def get(self, key: str) -> None:
+        print(f"{key} not found")
+        return None

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

@@ -20,3 +20,5 @@ for key in list(obj.keys()):
 {k: k for k in obj.keys()}  # SIM118
 
 (k for k in obj.keys())  # SIM118
+
+key in (obj or {}).keys()  # SIM118

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

@@ -1,10 +1,10 @@
-if a or True:  # SIM223
+if a or True:  # SIM222
     pass
 
-if (a or b) or True:  # SIM223
+if (a or b) or True:  # SIM222
     pass
 
-if a or (b or True):  # SIM223
+if a or (b or True):  # SIM222
     pass
 
 if a and True:  # OK
@@ -16,3 +16,16 @@ if True:  # OK
 
 def validate(self, value):
     return json.loads(value) or True  # OK
+
+
+if a or f() or b or g() or True:  # OK
+    pass
+
+if a or f() or True or g() or b:  # SIM222
+    pass
+
+if True or f() or a or g() or b:  # SIM222
+    pass
+
+if a or True or f() or b or g():  # SIM222
+    pass

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

@@ -12,3 +12,15 @@ if a or False:
 
 if False:
     pass
+
+if a and f() and b and g() and False:  # OK
+    pass
+
+if a and f() and False and g() and b:  # SIM222
+    pass
+
+if False and f() and a and g() and b:  # SIM222
+    pass
+
+if a and False and f() and b and g():  # SIM222
+    pass

crates/ruff/resources/test/fixtures/flake8_tidy_imports/TID252/my_package/sublib/api/application.py

@@ -7,3 +7,4 @@ from ..protocol import commands, definitions, responses
 from ..server import example
 from .. import server
 from . import logger, models
+from ..protocol.UpperCaseModule import some_function

crates/ruff/resources/test/fixtures/flake8_tidy_imports/TID252/my_package/sublib/protocol/UpperCaseModule.py

@@ -0,0 +1,2 @@
+def some_function():
+    pass

crates/ruff/resources/test/fixtures/isort/force_sort_within_sections.py

@@ -2,7 +2,9 @@ from a import a1  # import_from
 from c import * # import_from_star
 import a  # import
 import c.d
+from z import z1
 import b as b1  # import_as
+import z
 
 from ..parent import *
 from .my import fn

crates/ruff/resources/test/fixtures/isort/separate_subpackage_first_and_third_party_imports.py

@@ -0,0 +1,8 @@
+import sys
+import baz
+from foo import bar, baz
+from foo.bar import blah, blub
+from foo.bar.baz import something
+import foo
+import foo.bar
+import foo.bar.baz

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

@@ -0,0 +1,32 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "print(paste(\"Hello\",\"WoRld\"))\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "R",
+   "language": "R",
+   "name": "ir"
+  },
+  "language_info": {
+   "codemirror_mode": "r",
+   "file_extension": ".r",
+   "mimetype": "text/x-r-source",
+   "name": "R",
+   "pygments_lexer": "r",
+   "version": "3.2.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

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

@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+def unused_variable():
+    x = 1
+    y = 2
+    print(f"cell one: {y}")
+
+unused_variable()
+
+
+# Let's do another mistake
+
+# In[2]:
+
+
+def mutable_argument(z=set()):
+  print(f"cell two: {z}")
+
+mutable_argument()
+

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

@@ -0,0 +1 @@
+broken "§=($/=(")

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

@@ -0,0 +1,88 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cell one: 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "def unused_variable():\n",
+    "    x = 1\n",
+    "    y = 2\n",
+    "    print(f\"cell one: {y}\")\n",
+    "\n",
+    "unused_variable()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "start_time": "2023-03-08T23:01:09.705831Z",
+     "end_time": "2023-03-08T23:01:09.782916Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Let's do another mistake"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "start_time": "2023-03-08T23:01:09.733809Z",
+     "end_time": "2023-03-08T23:01:09.915760Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cell two: set()\n"
+     ]
+    }
+   ],
+   "source": [
+    "def mutable_argument(z=set()):\n",
+    "  print(f\"cell two: {z}\")\n",
+    "\n",
+    "mutable_argument()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

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

@@ -0,0 +1 @@
+{}

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

@@ -13,3 +13,8 @@ result = {
     'key1': 'value',
     'key2': 'value',
 }
+
+def foo() -> None:
+    #: E231
+    if (1,2):
+        pass

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

@@ -56,7 +56,29 @@ sit amet  consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labor
 # OK
 # https://loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong.url.com
 
-# Not OK
+# OK
 _ = """
 Source: https://github.com/PyCQA/pycodestyle/pull/258/files#diff-841c622497a8033d10152bfdfb15b20b92437ecdea21a260944ea86b77b51533
 """
+
+# OK
+_ = """
+[this-is-ok](https://github.com/PyCQA/pycodestyle/pull/258/files#diff-841c622497a8033d10152bfdfb15b20b92437ecdea21a260944ea86b77b51533)
+[this is ok](https://github.com/PyCQA/pycodestyle/pull/258/files#diff-841c622497a8033d10152bfdfb15b20b92437ecdea21a260944ea86b77b51533)
+"""
+
+
+# OK
+class Foo:
+    """
+    @see https://looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong.url.com
+
+    :param dynamodb_scan_kwargs: kwargs pass to <https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#DynamoDB.Table.scan>
+    """
+
+
+# Error
+class Bar:
+    """
+    This is a long sentence that ends with a shortened URL and, therefore, could easily be broken across multiple lines ([source](https://ruff.rs))
+    """

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

@@ -54,3 +54,7 @@ if type(a) != type(b) or type(a) == type(ccc):
     pass
 
 assert type(res) == type(None)
+
+types = StrEnum
+if x == types.X:
+    pass

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

@@ -0,0 +1,3 @@
+def lorem():
+    """lorem ipsum dolor sit amet consectetur adipiscing elit
+    sed do eiusmod tempor incididunt ut labore et dolore magna aliqua"""

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

@@ -0,0 +1,15 @@
+def bad_function():
+    """this docstring is not capitalized"""
+
+def good_function():
+    """This docstring is capitalized."""
+
+def other_function():
+    """
+    This docstring is capitalized."""
+
+def another_function():
+    """ This docstring is capitalized."""
+
+def utf8_function():
+    """éste docstring is capitalized."""

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

@@ -113,3 +113,13 @@ def f(x, *args, **kwargs):
         **kwargs: keyword arguments
     """
     return x
+
+
+class Test:
+    def f(self, /, arg1: int) -> None:
+        """
+        Some beauty description.
+
+        Args:
+            arg1: some description of arg
+        """

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

@@ -58,6 +58,15 @@ def no_underline_and_no_description():  # noqa: D416
     """
 
 
+@expect(_D213)
+@expect("D407: Missing dashed underline after section ('Returns')")
+@expect("D414: Section has no content ('Returns')")
+def no_underline_and_no_newline():  # noqa: D416
+    """Toggle the gizmo.
+
+    Returns"""
+
+
 @expect(_D213)
 @expect("D410: Missing blank line after section ('Returns')")
 @expect("D414: Section has no content ('Returns')")
@@ -495,3 +504,12 @@ Testing this incorrectly indented docstring.
             x: Test argument.
 
         """
+
+
+def implicit_string_concatenation():
+    """Toggle the gizmo.
+
+    Returns
+    A value of some sort.
+
+    """"Extra content"

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

@@ -1,10 +1,19 @@
-"""Test: imports within `ModuleNotFoundError` handlers."""
+"""Test: imports within `ModuleNotFoundError` and `ImportError` handlers."""
 
 
-def check_orjson():
+def module_not_found_error():
     try:
         import orjson
 
         return True
     except ModuleNotFoundError:
         return False
+
+
+def import_error():
+    try:
+        import orjson
+
+        return True
+    except ImportError:
+        return False

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

@@ -0,0 +1,7 @@
+"""Test: parsing of nested string annotations."""
+
+from typing import List
+from pathlib import Path, PurePath
+
+
+x: """List['Path']""" = []

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

@@ -4,6 +4,7 @@
 "{1:{0}}".format(1, 2)  # No issues
 "{1:{0}}".format(1, 2, 3)  # F523
 "{0}{2}".format(1, 2)  # F523, # F524
+"{1.arg[1]!r:0{2['arg']}{1}}".format(1, 2, 3, 4) # F523
 
 # With no indexes
 "{}".format(1, 2)  # F523

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

@@ -8,3 +8,6 @@ def f() -> "A":
 
 def g() -> "///":
     pass
+
+
+X: """List[int]"""'☃' = []

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

@@ -0,0 +1,8 @@
+"""Test case: ForwardRef."""
+
+from typing import ForwardRef, TypeVar
+
+X = ForwardRef("List[int]")
+Y: ForwardRef("List[int]")
+
+Z = TypeVar("X", "List[int]", "int")

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

@@ -0,0 +1,7 @@
+"""Test case: f-strings in type annotations."""
+
+from typing import List
+
+x = 1
+
+x: List[f"i{x}nt"] = []

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

@@ -0,0 +1,9 @@
+"""Test case: f-strings in future type annotations."""
+
+from __future__ import annotations
+
+from typing import List
+
+x = 1
+
+x: List[f"i{x}nt"] = []

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

@@ -0,0 +1,24 @@
+def test_division():
+    a = 9 / 3
+    assert "No ZeroDivisionError were raised"  # [assert-on-string-literal]
+
+
+def test_division():
+    a = 9 / 3
+    assert a == 3
+
+
+try:
+    assert "bad"  # [assert-on-string-literal]
+except:
+    assert "bad again"  # [assert-on-string-literal]
+
+a = 12
+assert f"hello {a}"  # [assert-on-string-literal]
+assert f"{a}"  # [assert-on-string-literal]
+assert f""  # [assert-on-string-literal]
+assert ""  # [assert-on-string-literal]
+assert b"hello"  # [assert-on-string-literal]
+assert "", b"hi"  # [assert-on-string-literal]
+assert "WhyNotHere?", "HereIsOk"  # [assert-on-string-literal]
+assert 12, "ok here"

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

@@ -0,0 +1,14 @@
+try:
+    1 / 0
+except ZeroDivisionError or ValueError as e:  # [binary-op-exception]
+    pass
+
+try:
+    raise ValueError
+except ZeroDivisionError and ValueError as e:  # [binary-op-exception]
+    print(e)
+
+try:
+    pass
+except (ValueError, Exception, IOError):
+    pass

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

@@ -17,3 +17,7 @@ def errors():
 def ok():
     if x and not y:
         print("x is not an empty string, but y is an empty string")
+
+
+data.loc[data["a"] != ""]
+data.loc[data["a"] != "", :]

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

@@ -0,0 +1,95 @@
+while True:
+    try:
+        pass
+    finally:
+        continue  # [continue-in-finally]
+
+while True:
+    try:
+        pass
+    except Exception:
+        continue
+    finally:
+        try:
+            pass
+        finally:
+            continue  # [continue-in-finally]
+        pass
+
+while True:
+    try:
+        pass
+    finally:
+        test = "aa"
+        match test:
+            case "aa":
+                continue  # [continue-in-finally]
+
+while True:
+    try:
+        pass
+    finally:
+        with "aa" as f:
+            continue  # [continue-in-finally]
+
+while True:
+    try:
+        pass
+    finally:
+        if True:
+            continue  # [continue-in-finally]
+        continue  # [continue-in-finally]
+
+        def test():
+            while True:
+                continue
+            try:
+                pass
+            finally:
+                continue  # [continue-in-finally]
+
+
+while True:
+    try:
+        pass
+    finally:
+        continue  # [continue-in-finally]
+
+        def test():
+            while True:
+                continue
+
+
+while True:
+    try:
+        pass
+    finally:
+        for i in range(12):
+            continue
+        continue  # [continue-in-finally]
+
+        while True:
+            pass
+        else:
+            continue  # [continue-in-finally]
+
+        def test():
+            continue
+            while True:
+                continue
+
+
+while True:
+    try:
+        pass
+    finally:
+        if True:
+            pass
+        elif False:
+            continue  # [continue-in-finally]
+        else:
+            continue  # [continue-in-finally]
+            for i in range(10):
+                pass
+            else:
+                continue  # [continue-in-finally]

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

@@ -0,0 +1,60 @@
+import sys
+
+
+def print_python_version():
+    print(sys.version)
+    return None  # [useless-return]
+
+
+def print_python_version():
+    print(sys.version)
+    return None  # [useless-return]
+
+
+def print_python_version():
+    print(sys.version)
+    return None  # [useless-return]
+
+
+class SomeClass:
+    def print_python_version(self):
+        print(sys.version)
+        return None  # [useless-return]
+
+
+def print_python_version():
+    if 2 * 2 == 4:
+        return
+    print(sys.version)
+
+
+def print_python_version():
+    if 2 * 2 == 4:
+        return None
+    return
+
+
+def print_python_version():
+    if 2 * 2 == 4:
+        return None
+
+
+def print_python_version():
+    """This function returns None."""
+    return None
+
+
+def print_python_version():
+    """This function returns None."""
+    print(sys.version)
+    return None  # [useless-return]
+
+
+class BaseCache:
+    def get(self, key: str) -> str | None:
+        print(f"{key} not found")
+        return None
+
+    def get(self, key: str) -> None:
+        print(f"{key} not found")
+        return None

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

@@ -30,8 +30,29 @@ def f(x: "List[str]") -> None:
     ...
 
 
-list = "abc"
-
-
-def f(x: List[str]) -> None:
+def f(x: r"List[str]") -> None:
+    ...
+
+
+def f(x: "List[str]") -> None:
+    ...
+
+
+def f(x: """List[str]""") -> None:
+    ...
+
+
+def f(x: "Li" "st[str]") -> None:
+    ...
+
+
+def f(x: "List['List[str]']") -> None:
+    ...
+
+
+def f(x: "List['Li' 'st[str]']") -> None:
+    ...
+
+
+def f(x: "Li" "st['List[str]']") -> None:
     ...

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

@@ -46,3 +46,8 @@ def f(x: Union[("str", "int"), float]) -> None:
 def f() -> None:
     x: Optional[str]
     x = Optional[str]
+
+    x = Union[str, int]
+    x = Union["str", "int"]
+    x: Union[str, int]
+    x: Union["str", "int"]

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

@@ -1,9 +1,9 @@
-from io import open
-
-with open("f.txt") as f:
-    print(f.read())
-
 import io
 
 with io.open("f.txt", mode="r", buffering=-1, **kwargs) as f:
     print(f.read())
+
+from io import open
+
+with open("f.txt") as f:
+    print(f.read())

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

@@ -1,24 +1,29 @@
-# These should be changed
+# Error (`from unittest import mock`)
 if True:
     import mock
 
+# Error (`from unittest import mock`)
 if True:
     import mock, sys
 
-# This goes to from unitest import mock
+# Error (`from unittest.mock import *`)
+if True:
+    from mock import *
+
+# Error (`from unittest import mock`)
 import mock.mock
 
-# Mock should go on a new line as `from unittest import mock`
+# Error (`from unittest import mock`)
 import contextlib, mock, sys
 
-# Mock should go on a new line as `from unittest import mock`
+# Error (`from unittest import mock`)
 import mock, sys
 x = "This code should be preserved one line below the mock"
 
-# Mock should go on a new line as `from unittest import mock`
+# Error (`from unittest import mock`)
 from mock import mock
 
-# Should keep trailing comma
+# Error (keep trailing comma)
 from mock import (
     mock,
     a,
@@ -32,7 +37,7 @@ from mock import (
     mock,
 )
 
-# Should not get a trailing comma
+# Error (avoid trailing comma)
 from mock import (
     mock,
     a,
@@ -57,16 +62,16 @@ if True:
             c
         )
 
-# These should not change:
+# OK
 import os, io
 
-# Mock should go on a new line as `from unittest import mock`
+# Error (`from unittest import mock`)
 import mock, mock
 
-# Mock should go on a new line as `from unittest import mock as foo`
+# Error (`from unittest import mock as foo`)
 import mock as foo
 
-# Mock should go on a new line as `from unittest import mock as foo`
+# Error (`from unittest import mock as foo`)
 from mock import mock as foo
 
 if True:
@@ -81,8 +86,8 @@ if True:
     from mock import mock as foo, mock as bar, mock
 
 
-# This should be unchanged.
+# OK.
 x = mock.Mock()
 
-# This should change to `mock.Mock`().
+# Error (`mock.Mock()`).
 x = mock.mock.Mock()

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

@@ -73,3 +73,13 @@ print("%s \N{snowman}" % (a,))
 print("%(foo)s \N{snowman}" % {"foo": 1})
 
 print(("foo %s " "bar %s") % (x, y))
+
+# Single-value expressions
+print('Hello %s' % "World")
+print('Hello %s' % f"World")
+print('Hello %s (%s)' % bar)
+print('Hello %s (%s)' % bar.baz)
+print('Hello %s (%s)' % bar['bop'])
+print('Hello %(arg)s' % bar)
+print('Hello %(arg)s' % bar.baz)
+print('Hello %(arg)s' % bar['bop'])

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

@@ -1,6 +1,4 @@
 # OK
-"%s" % unknown_type
-
 b"%s" % (b"bytestring",)
 
 "%*s" % (5, "hi")
@@ -57,3 +55,9 @@ pytest.param('"%8s" % (None,)', id="unsafe width-string conversion"),
     """
     % (x,)
 )
+
+'Hello %s' % bar
+
+'Hello %s' % bar.baz
+
+'Hello %s' % bar['bop']

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

@@ -86,3 +86,14 @@ async def c():
 
 async def c():
     return "{}".format(1 + await 3)
+
+
+def d(osname, version, release):
+    return"{}-{}.{}".format(osname, version, release)
+
+
+def e():
+    yield"{}".format(1)
+
+
+assert"{}".format(1)

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

@@ -0,0 +1,25 @@
+input = [1, 2, 3]
+otherInput = [2, 3, 4]
+foo = [1, 2, 3, 4]
+
+# OK
+zip(input, otherInput)  # different inputs
+zip(input, otherInput[1:])  # different inputs
+zip(input, input[2:])  # not successive
+zip(input[:-1], input[2:])  # not successive
+list(zip(input, otherInput))  # nested call
+zip(input, input[1::2])  # not successive
+zip(foo[:-1], foo[1:], foo, strict=False)  # more than 2 inputs
+zip(foo[:-1], foo[1:], foo, strict=True)  # more than 2 inputs
+
+# Errors
+zip(input, input[1:])
+zip(input, input[1::1])
+zip(input[:-1], input[1:])
+zip(input[1:], input[2:])
+zip(input[1:-1], input[2:])
+list(zip(input, input[1:]))
+list(zip(input[:-1], input[1:]))
+zip(foo[:-1], foo[1:], strict=True)
+zip(foo[:-1], foo[1:], strict=False)
+zip(foo[:-1], foo[1:], strict=bool(foo))

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

@@ -2,12 +2,24 @@
 # noqa # comment
 print()  # noqa
 print()  # noqa # comment
+print()  # noqa  # comment
+print()  # noqa comment
+print()  # noqa  comment
 print(a)  # noqa
 print(a)  # noqa # comment
+print(a)  # noqa  # comment
+print(a)  # noqa comment
+print(a)  # noqa  comment
 
 # noqa: E501, F821
 # noqa: E501, F821 # comment
 print()  # noqa: E501, F821
 print()  # noqa: E501, F821 # comment
+print()  # noqa: E501, F821  # comment
+print()  # noqa: E501, F821 comment
+print()  # noqa: E501, F821  comment
 print(a)  # noqa: E501, F821
 print(a)  # noqa: E501, F821 # comment
+print(a)  # noqa: E501, F821  # comment
+print(a)  # noqa: E501, F821 comment
+print(a)  # noqa: E501, F821  comment

crates/ruff/resources/test/fixtures/tryceratops/TRY300.py

@@ -40,8 +40,16 @@ def noreturn():
         logger.exception("process failed")
 
 
-def still_good():
+def good_return_with_side_effects():
     try:
+        pass
         return process()
     except MyException:
         logger.exception("process failed")
+
+def good_noexcept():
+    try:
+        pass
+        return process()
+    finally:
+        logger.exception("process failed")

crates/ruff/resources/test/project/README.md

@@ -9,30 +9,30 @@ Running from the repo root should pick up and enforce the appropriate settings f
 
 ```console
 ∴ cargo run -p ruff_cli -- check crates/ruff/resources/test/project/
-crates/ruff/resources/test/project/examples/.dotfiles/script.py:1:1: I001 Import block is un-sorted or un-formatted
-crates/ruff/resources/test/project/examples/.dotfiles/script.py:1:8: F401 `numpy` imported but unused
-crates/ruff/resources/test/project/examples/.dotfiles/script.py:2:17: F401 `app.app_file` imported but unused
-crates/ruff/resources/test/project/examples/docs/docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
-crates/ruff/resources/test/project/examples/docs/docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
-crates/ruff/resources/test/project/project/file.py:1:8: F401 `os` imported but unused
-crates/ruff/resources/test/project/project/import_file.py:1:1: I001 Import block is un-sorted or un-formatted
+crates/ruff/resources/test/project/examples/.dotfiles/script.py:1:1: I001 [*] Import block is un-sorted or un-formatted
+crates/ruff/resources/test/project/examples/.dotfiles/script.py:1:8: F401 [*] `numpy` imported but unused
+crates/ruff/resources/test/project/examples/.dotfiles/script.py:2:17: F401 [*] `app.app_file` imported but unused
+crates/ruff/resources/test/project/examples/docs/docs/file.py:1:1: I001 [*] Import block is un-sorted or un-formatted
+crates/ruff/resources/test/project/examples/docs/docs/file.py:8:5: F841 [*] Local variable `x` is assigned to but never used
+crates/ruff/resources/test/project/project/file.py:1:8: F401 [*] `os` imported but unused
+crates/ruff/resources/test/project/project/import_file.py:1:1: I001 [*] Import block is un-sorted or un-formatted
 Found 7 errors.
-7 potentially fixable with the --fix option.
+[*] 7 potentially fixable with the --fix option.
 ```
 
 Running from the project directory itself should exhibit the same behavior:
 
 ```console
 ∴ (cd crates/ruff/resources/test/project/ && cargo run -p ruff_cli -- check .)
-examples/.dotfiles/script.py:1:1: I001 Import block is un-sorted or un-formatted
-examples/.dotfiles/script.py:1:8: F401 `numpy` imported but unused
-examples/.dotfiles/script.py:2:17: F401 `app.app_file` imported but unused
-examples/docs/docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
-examples/docs/docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
-project/file.py:1:8: F401 `os` imported but unused
-project/import_file.py:1:1: I001 Import block is un-sorted or un-formatted
+examples/.dotfiles/script.py:1:1: I001 [*] Import block is un-sorted or un-formatted
+examples/.dotfiles/script.py:1:8: F401 [*] `numpy` imported but unused
+examples/.dotfiles/script.py:2:17: F401 [*] `app.app_file` imported but unused
+examples/docs/docs/file.py:1:1: I001 [*] Import block is un-sorted or un-formatted
+examples/docs/docs/file.py:8:5: F841 [*] Local variable `x` is assigned to but never used
+project/file.py:1:8: F401 [*] `os` imported but unused
+project/import_file.py:1:1: I001 [*] Import block is un-sorted or un-formatted
 Found 7 errors.
-7 potentially fixable with the --fix option.
+[*] 7 potentially fixable with the --fix option.
 ```
 
 Running from the sub-package directory should exhibit the same behavior, but omit the top-level
@@ -40,10 +40,10 @@ files:
 
 ```console
 ∴ (cd crates/ruff/resources/test/project/examples/docs && cargo run -p ruff_cli -- check .)
-docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
-docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
+docs/file.py:1:1: I001 [*] Import block is un-sorted or un-formatted
+docs/file.py:8:5: F841 [*] Local variable `x` is assigned to but never used
 Found 2 errors.
-2 potentially fixable with the --fix option.
+[*] 2 potentially fixable with the --fix option.
 ```
 
 `--config` should force Ruff to use the specified `pyproject.toml` for all files, and resolve
@@ -51,17 +51,17 @@ file paths from the current working directory:
 
 ```console
 ∴ (cargo run -p ruff_cli -- check --config=crates/ruff/resources/test/project/pyproject.toml crates/ruff/resources/test/project/)
-crates/ruff/resources/test/project/examples/.dotfiles/script.py:1:8: F401 `numpy` imported but unused
-crates/ruff/resources/test/project/examples/.dotfiles/script.py:2:17: F401 `app.app_file` imported but unused
-crates/ruff/resources/test/project/examples/docs/docs/concepts/file.py:1:8: F401 `os` imported but unused
-crates/ruff/resources/test/project/examples/docs/docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
-crates/ruff/resources/test/project/examples/docs/docs/file.py:1:8: F401 `os` imported but unused
-crates/ruff/resources/test/project/examples/docs/docs/file.py:3:8: F401 `numpy` imported but unused
-crates/ruff/resources/test/project/examples/docs/docs/file.py:4:27: F401 `docs.concepts.file` imported but unused
-crates/ruff/resources/test/project/examples/excluded/script.py:1:8: F401 `os` imported but unused
-crates/ruff/resources/test/project/project/file.py:1:8: F401 `os` imported but unused
+crates/ruff/resources/test/project/examples/.dotfiles/script.py:1:8: F401 [*] `numpy` imported but unused
+crates/ruff/resources/test/project/examples/.dotfiles/script.py:2:17: F401 [*] `app.app_file` imported but unused
+crates/ruff/resources/test/project/examples/docs/docs/concepts/file.py:1:8: F401 [*] `os` imported but unused
+crates/ruff/resources/test/project/examples/docs/docs/file.py:1:1: I001 [*] Import block is un-sorted or un-formatted
+crates/ruff/resources/test/project/examples/docs/docs/file.py:1:8: F401 [*] `os` imported but unused
+crates/ruff/resources/test/project/examples/docs/docs/file.py:3:8: F401 [*] `numpy` imported but unused
+crates/ruff/resources/test/project/examples/docs/docs/file.py:4:27: F401 [*] `docs.concepts.file` imported but unused
+crates/ruff/resources/test/project/examples/excluded/script.py:1:8: F401 [*] `os` imported but unused
+crates/ruff/resources/test/project/project/file.py:1:8: F401 [*] `os` imported but unused
 Found 9 errors.
-9 potentially fixable with the --fix option.
+[*] 9 potentially fixable with the --fix option.
 ```
 
 Running from a parent directory should "ignore" the `exclude` (hence, `concepts/file.py` gets
@@ -69,21 +69,21 @@ included in the output):
 
 ```console
 ∴ (cd crates/ruff/resources/test/project/examples && cargo run -p ruff_cli -- check --config=docs/ruff.toml .)
-docs/docs/concepts/file.py:5:5: F841 Local variable `x` is assigned to but never used
-docs/docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
-docs/docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
-excluded/script.py:5:5: F841 Local variable `x` is assigned to but never used
+docs/docs/concepts/file.py:5:5: F841 [*] Local variable `x` is assigned to but never used
+docs/docs/file.py:1:1: I001 [*] Import block is un-sorted or un-formatted
+docs/docs/file.py:8:5: F841 [*] Local variable `x` is assigned to but never used
+excluded/script.py:5:5: F841 [*] Local variable `x` is assigned to but never used
 Found 4 errors.
-4 potentially fixable with the --fix option.
+[*] 4 potentially fixable with the --fix option.
 ```
 
 Passing an excluded directory directly should report errors in the contained files:
 
 ```console
 ∴ cargo run -p ruff_cli -- check crates/ruff/resources/test/project/examples/excluded/
-crates/ruff/resources/test/project/examples/excluded/script.py:1:8: F401 `os` imported but unused
+crates/ruff/resources/test/project/examples/excluded/script.py:1:8: F401 [*] `os` imported but unused
 Found 1 error.
-1 potentially fixable with the --fix option.
+[*] 1 potentially fixable with the --fix option.
 ```
 
 Unless we `--force-exclude`:

crates/ruff/src/autofix/helpers.rs

@@ -6,7 +6,7 @@ use libcst_native::{
 use rustpython_parser::ast::{ExcepthandlerKind, Expr, Keyword, Location, Stmt, StmtKind};
 use rustpython_parser::{lexer, Mode, Tok};
 
-use ruff_diagnostics::Fix;
+use ruff_diagnostics::Edit;
 use ruff_python_ast::helpers;
 use ruff_python_ast::helpers::to_absolute;
 use ruff_python_ast::newlines::NewlineWithTrailingNewline;
@@ -178,7 +178,7 @@ pub fn delete_stmt(
     locator: &Locator,
     indexer: &Indexer,
     stylist: &Stylist,
-) -> Result<Fix> {
+) -> Result<Edit> {
     if parent
         .map(|parent| is_lone_child(stmt, parent, deleted))
         .map_or(Ok(None), |v| v.map(Some))?
@@ -186,7 +186,7 @@ pub fn delete_stmt(
     {
         // If removing this node would lead to an invalid syntax tree, replace
         // it with a `pass`.
-        Ok(Fix::replacement(
+        Ok(Edit::replacement(
             "pass".to_string(),
             stmt.location,
             stmt.end_location.unwrap(),
@@ -194,22 +194,22 @@ pub fn delete_stmt(
     } else {
         Ok(if let Some(semicolon) = trailing_semicolon(stmt, locator) {
             let next = next_stmt_break(semicolon, locator);
-            Fix::deletion(stmt.location, next)
+            Edit::deletion(stmt.location, next)
         } else if helpers::match_leading_content(stmt, locator) {
-            Fix::deletion(stmt.location, stmt.end_location.unwrap())
+            Edit::deletion(stmt.location, stmt.end_location.unwrap())
         } else if helpers::preceded_by_continuation(stmt, indexer) {
             if is_end_of_file(stmt, locator) && stmt.location.column() == 0 {
                 // Special-case: a file can't end in a continuation.
-                Fix::replacement(
+                Edit::replacement(
                     stylist.line_ending().to_string(),
                     stmt.location,
                     stmt.end_location.unwrap(),
                 )
             } else {
-                Fix::deletion(stmt.location, stmt.end_location.unwrap())
+                Edit::deletion(stmt.location, stmt.end_location.unwrap())
             }
         } else {
-            Fix::deletion(
+            Edit::deletion(
                 Location::new(stmt.location.row(), 0),
                 Location::new(stmt.end_location.unwrap().row() + 1, 0),
             )
@@ -226,7 +226,7 @@ pub fn remove_unused_imports<'a>(
     locator: &Locator,
     indexer: &Indexer,
     stylist: &Stylist,
-) -> Result<Fix> {
+) -> Result<Edit> {
     let module_text = locator.slice(stmt);
     let mut tree = match_module(module_text)?;
 
@@ -327,13 +327,13 @@ pub fn remove_unused_imports<'a>(
         delete_stmt(stmt, parent, deleted, locator, indexer, stylist)
     } else {
         let mut state = CodegenState {
-            default_newline: stylist.line_ending(),
+            default_newline: &stylist.line_ending(),
             default_indent: stylist.indentation(),
             ..CodegenState::default()
         };
         tree.codegen(&mut state);
 
-        Ok(Fix::replacement(
+        Ok(Edit::replacement(
             state.to_string(),
             stmt.location,
             stmt.end_location.unwrap(),
@@ -355,7 +355,7 @@ pub fn remove_argument(
     args: &[Expr],
     keywords: &[Keyword],
     remove_parentheses: bool,
-) -> Result<Fix> {
+) -> Result<Edit> {
     // TODO(sbrugman): Preserve trailing comments.
     let contents = locator.skip(stmt_at);
 
@@ -437,7 +437,7 @@ pub fn remove_argument(
     }
 
     match (fix_start, fix_end) {
-        (Some(start), Some(end)) => Ok(Fix::deletion(start, end)),
+        (Some(start), Some(end)) => Ok(Edit::deletion(start, end)),
         _ => {
             bail!("No fix could be constructed")
         }

crates/ruff/src/autofix/mod.rs

@@ -4,18 +4,18 @@ use itertools::Itertools;
 use rustc_hash::FxHashMap;
 use rustpython_parser::ast::Location;
 
-use ruff_diagnostics::{Diagnostic, Fix};
+use ruff_diagnostics::{Diagnostic, Edit, Fix};
 use ruff_python_ast::source_code::Locator;
 use ruff_python_ast::types::Range;
 
 use crate::linter::FixTable;
-use crate::registry::AsRule;
+use crate::registry::{AsRule, Rule};
 
 pub mod helpers;
 
 /// Auto-fix errors in a file, and write the fixed source code to disk.
 pub fn fix_file(diagnostics: &[Diagnostic], locator: &Locator) -> Option<(String, FixTable)> {
-    if diagnostics.iter().all(|check| check.fix.is_none()) {
+    if diagnostics.iter().all(|check| check.fix.is_empty()) {
         None
     } else {
         Some(apply_fixes(diagnostics.iter(), locator))
@@ -28,54 +28,61 @@ fn apply_fixes<'a>(
     locator: &'a Locator<'a>,
 ) -> (String, FixTable) {
     let mut output = String::with_capacity(locator.len());
-    let mut last_pos: Location = Location::new(1, 0);
-    let mut applied: BTreeSet<&Fix> = BTreeSet::default();
+    let mut last_pos: Option<Location> = None;
+    let mut applied: BTreeSet<&Edit> = BTreeSet::default();
     let mut fixed = FxHashMap::default();
 
     for (rule, fix) in diagnostics
         .filter_map(|diagnostic| {
-            diagnostic
-                .fix
-                .as_ref()
-                .map(|fix| (diagnostic.kind.rule(), fix))
+            if diagnostic.fix.is_empty() {
+                None
+            } else {
+                Some((diagnostic.kind.rule(), &diagnostic.fix))
+            }
         })
-        .sorted_by_key(|(.., fix)| fix.location)
+        .sorted_by(|(rule1, fix1), (rule2, fix2)| cmp_fix(*rule1, *rule2, fix1, fix2))
     {
         // If we already applied an identical fix as part of another correction, skip
         // any re-application.
-        if applied.contains(&fix) {
+        if fix.edits().iter().all(|edit| applied.contains(edit)) {
             *fixed.entry(rule).or_default() += 1;
             continue;
         }
 
         // Best-effort approach: if this fix overlaps with a fix we've already applied,
         // skip it.
-        if last_pos > fix.location {
+        if last_pos.map_or(false, |last_pos| {
+            fix.location()
+                .map_or(false, |fix_location| last_pos >= fix_location)
+        }) {
             continue;
         }
 
-        // Add all contents from `last_pos` to `fix.location`.
-        let slice = locator.slice(Range::new(last_pos, fix.location));
-        output.push_str(slice);
+        for edit in fix.edits() {
+            // Add all contents from `last_pos` to `fix.location`.
+            let slice = locator.slice(Range::new(last_pos.unwrap_or_default(), edit.location));
+            output.push_str(slice);
 
-        // Add the patch itself.
-        output.push_str(&fix.content);
+            // Add the patch itself.
+            output.push_str(&edit.content);
+
+            // Track that the edit was applied.
+            last_pos = Some(edit.end_location);
+            applied.insert(edit);
+        }
 
-        // Track that the fix was applied.
-        last_pos = fix.end_location;
-        applied.insert(fix);
         *fixed.entry(rule).or_default() += 1;
     }
 
     // Add the remaining content.
-    let slice = locator.skip(last_pos);
+    let slice = locator.skip(last_pos.unwrap_or_default());
     output.push_str(slice);
 
     (output, fixed)
 }
 
 /// Apply a single fix.
-pub(crate) fn apply_fix(fix: &Fix, locator: &Locator) -> String {
+pub(crate) fn apply_fix(fix: &Edit, locator: &Locator) -> String {
     let mut output = String::with_capacity(locator.len());
 
     // Add all contents from `last_pos` to `fix.location`.
@@ -92,26 +99,37 @@ pub(crate) fn apply_fix(fix: &Fix, locator: &Locator) -> String {
     output
 }
 
+/// Compare two fixes.
+fn cmp_fix(rule1: Rule, rule2: Rule, fix1: &Fix, fix2: &Fix) -> std::cmp::Ordering {
+    fix1.location()
+        .cmp(&fix2.location())
+        .then_with(|| match (&rule1, &rule2) {
+            // Apply `EndsInPeriod` fixes before `NewLineAfterLastParagraph` fixes.
+            (Rule::EndsInPeriod, Rule::NewLineAfterLastParagraph) => std::cmp::Ordering::Less,
+            (Rule::NewLineAfterLastParagraph, Rule::EndsInPeriod) => std::cmp::Ordering::Greater,
+            _ => std::cmp::Ordering::Equal,
+        })
+}
+
 #[cfg(test)]
 mod tests {
     use rustpython_parser::ast::Location;
 
     use ruff_diagnostics::Diagnostic;
-    use ruff_diagnostics::Fix;
+    use ruff_diagnostics::Edit;
     use ruff_python_ast::source_code::Locator;
 
     use crate::autofix::{apply_fix, apply_fixes};
-    use crate::rules::pycodestyle::rules::NoNewLineAtEndOfFile;
+    use crate::rules::pycodestyle::rules::MissingNewlineAtEndOfFile;
 
-    fn create_diagnostics(fixes: impl IntoIterator<Item = Fix>) -> Vec<Diagnostic> {
-        fixes
-            .into_iter()
-            .map(|fix| Diagnostic {
+    fn create_diagnostics(edit: impl IntoIterator<Item = Edit>) -> Vec<Diagnostic> {
+        edit.into_iter()
+            .map(|edit| Diagnostic {
                 // The choice of rule here is arbitrary.
-                kind: NoNewLineAtEndOfFile.into(),
-                location: fix.location,
-                end_location: fix.end_location,
-                fix: Some(fix),
+                kind: MissingNewlineAtEndOfFile.into(),
+                location: edit.location,
+                end_location: edit.end_location,
+                fix: edit.into(),
                 parent: None,
             })
             .collect()
@@ -135,7 +153,7 @@ class A(object):
 "#
             .trim(),
         );
-        let diagnostics = create_diagnostics([Fix {
+        let diagnostics = create_diagnostics([Edit {
             content: "Bar".to_string(),
             location: Location::new(1, 8),
             end_location: Location::new(1, 14),
@@ -161,7 +179,7 @@ class A(object):
 "#
             .trim(),
         );
-        let diagnostics = create_diagnostics([Fix {
+        let diagnostics = create_diagnostics([Edit {
             content: String::new(),
             location: Location::new(1, 7),
             end_location: Location::new(1, 15),
@@ -182,21 +200,21 @@ class A:
     fn apply_two_removals() {
         let locator = Locator::new(
             r#"
-class A(object, object):
+class A(object, object, object):
     ...
 "#
             .trim(),
         );
         let diagnostics = create_diagnostics([
-            Fix {
+            Edit {
                 content: String::new(),
-                location: Location::new(1, 7),
+                location: Location::new(1, 8),
                 end_location: Location::new(1, 16),
             },
-            Fix {
+            Edit {
                 content: String::new(),
-                location: Location::new(1, 16),
-                end_location: Location::new(1, 23),
+                location: Location::new(1, 22),
+                end_location: Location::new(1, 30),
             },
         ]);
         let (contents, fixed) = apply_fixes(diagnostics.iter(), &locator);
@@ -204,7 +222,7 @@ class A(object, object):
         assert_eq!(
             contents,
             r#"
-class A:
+class A(object):
     ...
 "#
             .trim()
@@ -222,12 +240,12 @@ class A(object):
             .trim(),
         );
         let diagnostics = create_diagnostics([
-            Fix {
+            Edit {
                 content: String::new(),
                 location: Location::new(1, 7),
                 end_location: Location::new(1, 15),
             },
-            Fix {
+            Edit {
                 content: "ignored".to_string(),
                 location: Location::new(1, 9),
                 end_location: Location::new(1, 11),
@@ -255,7 +273,7 @@ class A(object):
             .trim(),
         );
         let contents = apply_fix(
-            &Fix {
+            &Edit {
                 content: String::new(),
                 location: Location::new(1, 7),
                 end_location: Location::new(1, 15),

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

@@ -1,3 +1,4 @@
+use ruff_python_ast::scope::ScopeStack;
 use rustpython_parser::ast::{Expr, Stmt};
 
 use ruff_python_ast::types::Range;
@@ -7,7 +8,7 @@ use ruff_python_ast::visibility::{Visibility, VisibleScope};
 use crate::checkers::ast::AnnotationContext;
 use crate::docstrings::definition::Definition;
 
-type Context<'a> = (Vec<usize>, Vec<RefEquality<'a, Stmt>>);
+type Context<'a> = (ScopeStack, Vec<RefEquality<'a, Stmt>>);
 
 /// A collection of AST nodes that are deferred for later analysis.
 /// Used to, e.g., store functions, whose bodies shouldn't be analyzed until all

crates/ruff/src/checkers/filesystem.rs

@@ -15,7 +15,7 @@ pub fn check_file_path(
     let mut diagnostics: Vec<Diagnostic> = vec![];
 
     // flake8-no-pep420
-    if settings.rules.enabled(&Rule::ImplicitNamespacePackage) {
+    if settings.rules.enabled(Rule::ImplicitNamespacePackage) {
         if let Some(diagnostic) =
             implicit_namespace_package(path, package, &settings.project_root, &settings.src)
         {
@@ -24,7 +24,7 @@ pub fn check_file_path(
     }
 
     // pep8-naming
-    if settings.rules.enabled(&Rule::InvalidModuleName) {
+    if settings.rules.enabled(Rule::InvalidModuleName) {
         if let Some(diagnostic) = invalid_module_name(path, package) {
             diagnostics.push(diagnostic);
         }

crates/ruff/src/checkers/imports.rs

@@ -29,16 +29,14 @@ pub fn check_imports(
     // Extract all imports from the AST.
     let tracker = {
         let mut tracker = ImportTracker::new(locator, directives, path);
-        for stmt in python_ast {
-            tracker.visit_stmt(stmt);
-        }
+        tracker.visit_body(python_ast);
         tracker
     };
     let blocks: Vec<&Block> = tracker.iter().collect();
 
     // Enforce import rules.
     let mut diagnostics = vec![];
-    if settings.rules.enabled(&Rule::UnsortedImports) {
+    if settings.rules.enabled(Rule::UnsortedImports) {
         for block in &blocks {
             if !block.imports.is_empty() {
                 if let Some(diagnostic) = isort::rules::organize_imports(
@@ -49,7 +47,7 @@ pub fn check_imports(
             }
         }
     }
-    if settings.rules.enabled(&Rule::MissingRequiredImport) {
+    if settings.rules.enabled(Rule::MissingRequiredImport) {
         diagnostics.extend(isort::rules::add_required_imports(
             &blocks, python_ast, locator, stylist, settings, autofix,
         ));

crates/ruff/src/checkers/logical_lines.rs

@@ -1,42 +1,32 @@
-#![allow(dead_code, unused_imports, unused_variables)]
-
-use bisection::bisect_left;
-use itertools::Itertools;
 use rustpython_parser::ast::Location;
 use rustpython_parser::lexer::LexResult;
 
-use ruff_diagnostics::Diagnostic;
+use ruff_diagnostics::{Diagnostic, Fix};
 use ruff_python_ast::source_code::{Locator, Stylist};
 use ruff_python_ast::types::Range;
 
 use crate::registry::{AsRule, Rule};
-use crate::rules::pycodestyle::logical_lines::{iter_logical_lines, TokenFlags};
-use crate::rules::pycodestyle::rules::{
+use crate::rules::pycodestyle::rules::logical_lines::{
     extraneous_whitespace, indentation, missing_whitespace, missing_whitespace_after_keyword,
     missing_whitespace_around_operator, space_around_operator, whitespace_around_keywords,
     whitespace_around_named_parameter_equals, whitespace_before_comment,
-    whitespace_before_parameters,
+    whitespace_before_parameters, LogicalLines, TokenFlags,
 };
 use crate::settings::{flags, Settings};
 
 /// Return the amount of indentation, expanding tabs to the next multiple of 8.
-fn expand_indent(mut line: &str) -> usize {
-    while line.ends_with("\n\r") {
-        line = &line[..line.len() - 2];
-    }
-    if !line.contains('\t') {
-        return line.len() - line.trim_start().len();
-    }
+fn expand_indent(line: &str) -> usize {
+    let line = line.trim_end_matches(['\n', '\r']);
+
     let mut indent = 0;
-    for c in line.chars() {
-        if c == '\t' {
-            indent = (indent / 8) * 8 + 8;
-        } else if c == ' ' {
-            indent += 1;
-        } else {
-            break;
+    for c in line.bytes() {
+        match c {
+            b'\t' => indent = (indent / 8) * 8 + 8,
+            b' ' => indent += 1,
+            _ => break,
         }
     }
+
     indent
 }
 
@@ -49,151 +39,140 @@ pub fn check_logical_lines(
 ) -> Vec<Diagnostic> {
     let mut diagnostics = vec![];
 
-    let indent_char = stylist.indentation().as_char();
+    #[cfg(feature = "logical_lines")]
+    let should_fix_missing_whitespace =
+        autofix.into() && settings.rules.should_fix(Rule::MissingWhitespace);
+
+    #[cfg(not(feature = "logical_lines"))]
+    let should_fix_missing_whitespace = false;
+
+    #[cfg(feature = "logical_lines")]
+    let should_fix_whitespace_before_parameters =
+        autofix.into() && settings.rules.should_fix(Rule::WhitespaceBeforeParameters);
+
+    #[cfg(not(feature = "logical_lines"))]
+    let should_fix_whitespace_before_parameters = false;
+
     let mut prev_line = None;
     let mut prev_indent_level = None;
-    for line in iter_logical_lines(tokens, locator) {
-        if line.mapping.is_empty() {
-            continue;
-        }
+    let indent_char = stylist.indentation().as_char();
 
-        // Extract the indentation level.
-        let start_loc = line.mapping[0].1;
-        let start_line = locator.slice(Range::new(Location::new(start_loc.row(), 0), start_loc));
-        let indent_level = expand_indent(start_line);
-        let indent_size = 4;
-
-        // Generate mapping from logical to physical offsets.
-        let mapping_offsets = line.mapping.iter().map(|(offset, _)| *offset).collect_vec();
-
-        if line.flags.contains(TokenFlags::OPERATOR) {
-            for (index, kind) in space_around_operator(&line.text) {
-                let (token_offset, pos) = line.mapping[bisect_left(&mapping_offsets, &index)];
-                let location = Location::new(pos.row(), pos.column() + index - token_offset);
+    for line in &LogicalLines::from_tokens(tokens, locator) {
+        if line.flags().contains(TokenFlags::OPERATOR) {
+            for (location, kind) in space_around_operator(&line) {
                 if settings.rules.enabled(kind.rule()) {
                     diagnostics.push(Diagnostic {
                         kind,
                         location,
                         end_location: location,
-                        fix: None,
+                        fix: Fix::empty(),
                         parent: None,
                     });
                 }
             }
+
+            for (location, kind) in whitespace_around_named_parameter_equals(&line.tokens()) {
+                if settings.rules.enabled(kind.rule()) {
+                    diagnostics.push(Diagnostic {
+                        kind,
+                        location,
+                        end_location: location,
+                        fix: Fix::empty(),
+                        parent: None,
+                    });
+                }
+            }
+            for (location, kind) in missing_whitespace_around_operator(&line.tokens()) {
+                if settings.rules.enabled(kind.rule()) {
+                    diagnostics.push(Diagnostic {
+                        kind,
+                        location,
+                        end_location: location,
+                        fix: Fix::empty(),
+                        parent: None,
+                    });
+                }
+            }
+
+            for diagnostic in missing_whitespace(&line, should_fix_missing_whitespace) {
+                if settings.rules.enabled(diagnostic.kind.rule()) {
+                    diagnostics.push(diagnostic);
+                }
+            }
         }
         if line
-            .flags
+            .flags()
             .contains(TokenFlags::OPERATOR | TokenFlags::PUNCTUATION)
         {
-            for (index, kind) in extraneous_whitespace(&line.text) {
-                let (token_offset, pos) = line.mapping[bisect_left(&mapping_offsets, &index)];
-                let location = Location::new(pos.row(), pos.column() + index - token_offset);
+            for (location, kind) in extraneous_whitespace(&line) {
                 if settings.rules.enabled(kind.rule()) {
                     diagnostics.push(Diagnostic {
                         kind,
                         location,
                         end_location: location,
-                        fix: None,
+                        fix: Fix::empty(),
                         parent: None,
                     });
                 }
             }
         }
-        if line.flags.contains(TokenFlags::KEYWORD) {
-            for (index, kind) in whitespace_around_keywords(&line.text) {
-                let (token_offset, pos) = line.mapping[bisect_left(&mapping_offsets, &index)];
-                let location = Location::new(pos.row(), pos.column() + index - token_offset);
+        if line.flags().contains(TokenFlags::KEYWORD) {
+            for (location, kind) in whitespace_around_keywords(&line) {
                 if settings.rules.enabled(kind.rule()) {
                     diagnostics.push(Diagnostic {
                         kind,
                         location,
                         end_location: location,
-                        fix: None,
+                        fix: Fix::empty(),
                         parent: None,
                     });
                 }
             }
 
-            for (location, kind) in missing_whitespace_after_keyword(&line.tokens) {
+            for (location, kind) in missing_whitespace_after_keyword(&line.tokens()) {
                 if settings.rules.enabled(kind.rule()) {
                     diagnostics.push(Diagnostic {
                         kind,
                         location,
                         end_location: location,
-                        fix: None,
+                        fix: Fix::empty(),
                         parent: None,
                     });
                 }
             }
         }
-        if line.flags.contains(TokenFlags::COMMENT) {
-            for (range, kind) in whitespace_before_comment(&line.tokens, locator) {
+        if line.flags().contains(TokenFlags::COMMENT) {
+            for (range, kind) in whitespace_before_comment(&line.tokens(), locator) {
                 if settings.rules.enabled(kind.rule()) {
                     diagnostics.push(Diagnostic {
                         kind,
                         location: range.location,
                         end_location: range.end_location,
-                        fix: None,
+                        fix: Fix::empty(),
                         parent: None,
                     });
                 }
             }
         }
-        if line.flags.contains(TokenFlags::OPERATOR) {
-            for (location, kind) in
-                whitespace_around_named_parameter_equals(&line.tokens, &line.text)
-            {
-                if settings.rules.enabled(kind.rule()) {
-                    diagnostics.push(Diagnostic {
-                        kind,
-                        location,
-                        end_location: location,
-                        fix: None,
-                        parent: None,
-                    });
-                }
-            }
-            for (location, kind) in missing_whitespace_around_operator(&line.tokens) {
-                if settings.rules.enabled(kind.rule()) {
-                    diagnostics.push(Diagnostic {
-                        kind,
-                        location,
-                        end_location: location,
-                        fix: None,
-                        parent: None,
-                    });
-                }
-            }
 
-            #[cfg(feature = "logical_lines")]
-            let should_fix = autofix.into() && settings.rules.should_fix(&Rule::MissingWhitespace);
-
-            #[cfg(not(feature = "logical_lines"))]
-            let should_fix = false;
-
-            for diagnostic in missing_whitespace(&line.text, start_loc.row(), should_fix) {
+        if line.flags().contains(TokenFlags::BRACKET) {
+            for diagnostic in whitespace_before_parameters(
+                &line.tokens(),
+                should_fix_whitespace_before_parameters,
+            ) {
                 if settings.rules.enabled(diagnostic.kind.rule()) {
                     diagnostics.push(diagnostic);
                 }
             }
         }
 
-        if line.flags.contains(TokenFlags::BRACKET) {
-            #[cfg(feature = "logical_lines")]
-            let should_fix =
-                autofix.into() && settings.rules.should_fix(&Rule::WhitespaceBeforeParameters);
+        // Extract the indentation level.
+        let Some(start_loc) = line.first_token_location() else { continue; };
+        let start_line = locator.slice(Range::new(Location::new(start_loc.row(), 0), start_loc));
+        let indent_level = expand_indent(start_line);
+        let indent_size = 4;
 
-            #[cfg(not(feature = "logical_lines"))]
-            let should_fix = false;
-
-            for diagnostic in whitespace_before_parameters(&line.tokens, should_fix) {
-                if settings.rules.enabled(diagnostic.kind.rule()) {
-                    diagnostics.push(diagnostic);
-                }
-            }
-        }
-
-        for (index, kind) in indentation(
+        for (location, kind) in indentation(
             &line,
             prev_line.as_ref(),
             indent_char,
@@ -201,20 +180,18 @@ pub fn check_logical_lines(
             prev_indent_level,
             indent_size,
         ) {
-            let (token_offset, pos) = line.mapping[bisect_left(&mapping_offsets, &index)];
-            let location = Location::new(pos.row(), pos.column() + index - token_offset);
             if settings.rules.enabled(kind.rule()) {
                 diagnostics.push(Diagnostic {
                     kind,
                     location,
                     end_location: location,
-                    fix: None,
+                    fix: Fix::empty(),
                     parent: None,
                 });
             }
         }
 
-        if !line.is_comment() {
+        if !line.is_comment_only() {
             prev_line = Some(line);
             prev_indent_level = Some(indent_level);
         }
@@ -227,10 +204,9 @@ mod tests {
     use rustpython_parser::lexer::LexResult;
     use rustpython_parser::{lexer, Mode};
 
+    use crate::rules::pycodestyle::rules::logical_lines::LogicalLines;
     use ruff_python_ast::source_code::Locator;
 
-    use crate::checkers::logical_lines::iter_logical_lines;
-
     #[test]
     fn split_logical_lines() {
         let contents = r#"
@@ -239,9 +215,9 @@ y = 2
 z = x + 1"#;
         let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         let locator = Locator::new(contents);
-        let actual: Vec<String> = iter_logical_lines(&lxr, &locator)
+        let actual: Vec<String> = LogicalLines::from_tokens(&lxr, &locator)
             .into_iter()
-            .map(|line| line.text)
+            .map(|line| line.text_trimmed().to_string())
             .collect();
         let expected = vec![
             "x = 1".to_string(),
@@ -260,12 +236,12 @@ y = 2
 z = x + 1"#;
         let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         let locator = Locator::new(contents);
-        let actual: Vec<String> = iter_logical_lines(&lxr, &locator)
+        let actual: Vec<String> = LogicalLines::from_tokens(&lxr, &locator)
             .into_iter()
-            .map(|line| line.text)
+            .map(|line| line.text_trimmed().to_string())
             .collect();
         let expected = vec![
-            "x = [1, 2, 3, ]".to_string(),
+            "x = [\n  1,\n  2,\n  3,\n]".to_string(),
             "y = 2".to_string(),
             "z = x + 1".to_string(),
         ];
@@ -274,11 +250,11 @@ z = x + 1"#;
         let contents = "x = 'abc'";
         let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         let locator = Locator::new(contents);
-        let actual: Vec<String> = iter_logical_lines(&lxr, &locator)
+        let actual: Vec<String> = LogicalLines::from_tokens(&lxr, &locator)
             .into_iter()
-            .map(|line| line.text)
+            .map(|line| line.text_trimmed().to_string())
             .collect();
-        let expected = vec!["x = \"xxx\"".to_string()];
+        let expected = vec!["x = 'abc'".to_string()];
         assert_eq!(actual, expected);
 
         let contents = r#"
@@ -287,9 +263,9 @@ def f():
 f()"#;
         let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         let locator = Locator::new(contents);
-        let actual: Vec<String> = iter_logical_lines(&lxr, &locator)
+        let actual: Vec<String> = LogicalLines::from_tokens(&lxr, &locator)
             .into_iter()
-            .map(|line| line.text)
+            .map(|line| line.text_trimmed().to_string())
             .collect();
         let expected = vec!["def f():", "x = 1", "f()"];
         assert_eq!(actual, expected);
@@ -302,11 +278,17 @@ def f():
 f()"#;
         let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         let locator = Locator::new(contents);
-        let actual: Vec<String> = iter_logical_lines(&lxr, &locator)
+        let actual: Vec<String> = LogicalLines::from_tokens(&lxr, &locator)
             .into_iter()
-            .map(|line| line.text)
+            .map(|line| line.text_trimmed().to_string())
             .collect();
-        let expected = vec!["def f():", "\"xxxxxxxxxxxxxxxxxxxx\"", "", "x = 1", "f()"];
+        let expected = vec![
+            "def f():",
+            "\"\"\"Docstring goes here.\"\"\"",
+            "",
+            "x = 1",
+            "f()",
+        ];
         assert_eq!(actual, expected);
     }
 }

crates/ruff/src/checkers/mod.rs

@@ -1,7 +1,8 @@
 pub mod ast;
 pub mod filesystem;
 pub mod imports;
-pub mod logical_lines;
+#[cfg(feature = "logical_lines")]
+pub(crate) mod logical_lines;
 pub mod noqa;
 pub mod physical_lines;
 pub mod tokens;