tmp arrows

## Summary

Use `$GITHUB_SHA` (the merged state of `feature` + `main` branch)
instead of `{{ github.event.pull_request.head.sha }}` (just the latest
`feature` commit) for building the "new" version of `ty` in the typing
conformance workflow.

## Test Plan

None.

.github/CODEOWNERS

@@ -19,6 +19,10 @@
 
 # ty
 /crates/ty* @carljm @MichaReiser @AlexWaygood @sharkdp @dcreager
-/crates/ruff_db/ @carljm @MichaReiser @AlexWaygood @sharkdp @dcreager
+/crates/ruff_db/ @carljm @MichaReiser @sharkdp @dcreager
+/crates/ty_project/ @carljm @MichaReiser @sharkdp @dcreager
+/crates/ty_server/ @carljm @MichaReiser @sharkdp @dcreager
+/crates/ty/ @carljm @MichaReiser @sharkdp @dcreager
+/crates/ty_wasm/ @carljm @MichaReiser @sharkdp @dcreager
 /scripts/ty_benchmark/ @carljm @MichaReiser @AlexWaygood @sharkdp @dcreager
 /crates/ty_python_semantic @carljm @AlexWaygood @sharkdp @dcreager

.github/workflows/build-docker.yml

@@ -63,7 +63,7 @@ jobs:
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
+        uses: docker/metadata-action@c1e51972afc2121e065aed6d45c65596fe445f3f # v5.8.0
         with:
           images: ${{ env.RUFF_BASE_IMG }}
           # Defining this makes sure the org.opencontainers.image.version OCI label becomes the actual release version and not the branch name
@@ -123,7 +123,7 @@ jobs:
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
+        uses: docker/metadata-action@c1e51972afc2121e065aed6d45c65596fe445f3f # v5.8.0
         with:
           images: ${{ env.RUFF_BASE_IMG }}
           # Order is on purpose such that the label org.opencontainers.image.version has the first pattern with the full version
@@ -219,7 +219,7 @@ jobs:
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
+        uses: docker/metadata-action@c1e51972afc2121e065aed6d45c65596fe445f3f # v5.8.0
         # ghcr.io prefers index level annotations
         env:
           DOCKER_METADATA_ANNOTATIONS_LEVELS: index
@@ -266,7 +266,7 @@ jobs:
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
+        uses: docker/metadata-action@c1e51972afc2121e065aed6d45c65596fe445f3f # v5.8.0
         env:
           DOCKER_METADATA_ANNOTATIONS_LEVELS: index
         with:

.github/workflows/ci.yaml

@@ -240,11 +240,11 @@ jobs:
       - name: "Install mold"
         uses: rui314/setup-mold@702b1908b5edf30d71a8d1666b724e0f0c6fa035 # v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@c99cc51b309eee71a866715cfa08c922f11cf898 # v2.56.19
+        uses: taiki-e/install-action@6064345e6658255e90e9500fdf9a06ab77e6909c # v2.57.6
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@c99cc51b309eee71a866715cfa08c922f11cf898 # v2.56.19
+        uses: taiki-e/install-action@6064345e6658255e90e9500fdf9a06ab77e6909c # v2.57.6
         with:
           tool: cargo-insta
       - name: ty mdtests (GitHub annotations)
@@ -298,11 +298,11 @@ jobs:
       - name: "Install mold"
         uses: rui314/setup-mold@702b1908b5edf30d71a8d1666b724e0f0c6fa035 # v1
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@c99cc51b309eee71a866715cfa08c922f11cf898 # v2.56.19
+        uses: taiki-e/install-action@6064345e6658255e90e9500fdf9a06ab77e6909c # v2.57.6
         with:
           tool: cargo-nextest
       - name: "Install cargo insta"
-        uses: taiki-e/install-action@c99cc51b309eee71a866715cfa08c922f11cf898 # v2.56.19
+        uses: taiki-e/install-action@6064345e6658255e90e9500fdf9a06ab77e6909c # v2.57.6
         with:
           tool: cargo-insta
       - name: "Run tests"
@@ -325,7 +325,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install cargo nextest"
-        uses: taiki-e/install-action@c99cc51b309eee71a866715cfa08c922f11cf898 # v2.56.19
+        uses: taiki-e/install-action@6064345e6658255e90e9500fdf9a06ab77e6909c # v2.57.6
         with:
           tool: cargo-nextest
       - name: "Run tests"
@@ -429,7 +429,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install cargo-binstall"
-        uses: cargo-bins/cargo-binstall@8aac5aa2bf0dfaa2863eccad9f43c68fe40e5ec8 # v1.14.1
+        uses: cargo-bins/cargo-binstall@dd6a0ac24caa1243d18df0f770b941e990e8facc # v1.14.3
         with:
           tool: cargo-fuzz@0.11.2
       - name: "Install cargo-fuzz"
@@ -451,7 +451,7 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+      - uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
         name: Download Ruff binary to test
         id: download-cached-binary
@@ -652,7 +652,7 @@ jobs:
           branch: ${{ github.event.pull_request.base.ref }}
           workflow: "ci.yaml"
           check_artifacts: true
-      - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+      - uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
       - name: Fuzz
         env:
           FORCE_COLOR: 1
@@ -682,7 +682,7 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: cargo-bins/cargo-binstall@8aac5aa2bf0dfaa2863eccad9f43c68fe40e5ec8 # v1.14.1
+      - uses: cargo-bins/cargo-binstall@dd6a0ac24caa1243d18df0f770b941e990e8facc # v1.14.3
       - run: cargo binstall --no-confirm cargo-shear
       - run: cargo shear
 
@@ -722,7 +722,7 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+      - uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
       - uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
       - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
@@ -765,7 +765,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: rustup show
       - name: Install uv
-        uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+        uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
       - name: "Install Insiders dependencies"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
         run: uv pip install -r docs/requirements-insiders.txt --system
@@ -897,13 +897,13 @@ jobs:
           persist-credentials: false
 
       - uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
-      - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+      - uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
 
       - name: "Install Rust toolchain"
         run: rustup show
 
       - name: "Install codspeed"
-        uses: taiki-e/install-action@c99cc51b309eee71a866715cfa08c922f11cf898 # v2.56.19
+        uses: taiki-e/install-action@6064345e6658255e90e9500fdf9a06ab77e6909c # v2.57.6
         with:
           tool: cargo-codspeed
 
@@ -911,7 +911,7 @@ jobs:
         run: cargo codspeed build --features "codspeed,instrumented" --no-default-features -p ruff_benchmark
 
       - name: "Run benchmarks"
-        uses: CodSpeedHQ/action@c28fe9fbe7d57a3da1b7834ae3761c1d8217612d # v3.7.0
+        uses: CodSpeedHQ/action@0b6e7a3d96c9d2a6057e7bcea6b45aaf2f7ce60b # v3.8.0
         with:
           run: cargo codspeed run
           token: ${{ secrets.CODSPEED_TOKEN }}
@@ -930,13 +930,13 @@ jobs:
           persist-credentials: false
 
       - uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
-      - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+      - uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
 
       - name: "Install Rust toolchain"
         run: rustup show
 
       - name: "Install codspeed"
-        uses: taiki-e/install-action@c99cc51b309eee71a866715cfa08c922f11cf898 # v2.56.19
+        uses: taiki-e/install-action@6064345e6658255e90e9500fdf9a06ab77e6909c # v2.57.6
         with:
           tool: cargo-codspeed
 
@@ -944,7 +944,7 @@ jobs:
         run: cargo codspeed build --features "codspeed,walltime" --no-default-features -p ruff_benchmark
 
       - name: "Run benchmarks"
-        uses: CodSpeedHQ/action@c28fe9fbe7d57a3da1b7834ae3761c1d8217612d # v3.7.0
+        uses: CodSpeedHQ/action@0b6e7a3d96c9d2a6057e7bcea6b45aaf2f7ce60b # v3.8.0
         with:
           run: cargo codspeed run
           token: ${{ secrets.CODSPEED_TOKEN }}

.github/workflows/daily_fuzz.yaml

@@ -34,7 +34,7 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+      - uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
       - name: "Install Rust toolchain"
         run: rustup show
       - name: "Install mold"

.github/workflows/mypy_primer.yaml

@@ -38,7 +38,7 @@ jobs:
           persist-credentials: false
 
       - name: Install the latest version of uv
-        uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+        uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
 
       - uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
         with:
@@ -81,9 +81,9 @@ jobs:
           persist-credentials: false
 
       - name: Install the latest version of uv
-        uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+        uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
 
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+      - uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
         with:
           workspaces: "ruff"
 

.github/workflows/publish-pypi.yml

@@ -22,7 +22,7 @@ jobs:
       id-token: write
     steps:
       - name: "Install uv"
-        uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+        uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
         with:
           pattern: wheels-*

.github/workflows/sync_typeshed.yaml

@@ -65,7 +65,7 @@ jobs:
         run: |
           git config --global user.name typeshedbot
           git config --global user.email '<>'
-      - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+      - uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
       - name: Sync typeshed stubs
         run: |
           rm -rf "ruff/${VENDORED_TYPESHED}"
@@ -117,7 +117,7 @@ jobs:
         with:
           persist-credentials: true
           ref: ${{ env.UPSTREAM_BRANCH}}
-      - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+      - uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
       - name: Setup git
         run: |
           git config --global user.name typeshedbot
@@ -155,7 +155,7 @@ jobs:
         with:
           persist-credentials: true
           ref: ${{ env.UPSTREAM_BRANCH}}
-      - uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+      - uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
       - name: Setup git
         run: |
           git config --global user.name typeshedbot

.github/workflows/ty-ecosystem-analyzer.yaml

@@ -33,7 +33,7 @@ jobs:
           persist-credentials: false
 
       - name: Install the latest version of uv
-        uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+        uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
 
       - uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
         with:

.github/workflows/ty-ecosystem-report.yaml

@@ -29,7 +29,7 @@ jobs:
           persist-credentials: false
 
       - name: Install the latest version of uv
-        uses: astral-sh/setup-uv@bd01e18f51369d5a26f1651c3cb451d3417e3bba # v6.3.1
+        uses: astral-sh/setup-uv@e92bafb6253dcd438e0484186d7669ea7a8ca1cc # v6.4.3
 
       - uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
         with:

.github/workflows/typing_conformance.yaml

@@ -0,0 +1,113 @@
+name: Run typing conformance
+
+permissions: {}
+
+on:
+  pull_request:
+    paths:
+      - "crates/ty*/**"
+      - "crates/ruff_db"
+      - "crates/ruff_python_ast"
+      - "crates/ruff_python_parser"
+      - ".github/workflows/typing_conformance.yaml"
+      - ".github/workflows/typing_conformance_comment.yaml"
+      - "Cargo.lock"
+      - "!**.md"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+env:
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  CARGO_TERM_COLOR: always
+  RUSTUP_MAX_RETRIES: 10
+  RUST_BACKTRACE: 1
+  CONFORMANCE_SUITE_COMMIT: d4f39b27a4a47aac8b6d4019e1b0b5b3156fabdc
+
+jobs:
+  typing_conformance:
+    name: Compute diagnostic diff
+    runs-on: depot-ubuntu-22.04-32
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          path: ruff
+          fetch-depth: 0
+          persist-credentials: false
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          repository: python/typing
+          ref: ${{ env.CONFORMANCE_SUITE_COMMIT }}
+          path: typing
+          persist-credentials: false
+
+      - uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
+        with:
+          workspaces: "ruff"
+
+      - name: Install Rust toolchain
+        run: rustup show
+
+      - name: Compute diagnostic diff
+        shell: bash
+        run: |
+          RUFF_DIR="$GITHUB_WORKSPACE/ruff"
+
+          # Build the executable for the old and new commit
+          (
+            cd ruff
+
+            echo "new commit"
+            git rev-list --format=%s --max-count=1 "$GITHUB_SHA"
+            cargo build --release --bin ty
+            mv target/release/ty ty-new
+
+            MERGE_BASE="$(git merge-base "$GITHUB_SHA" "origin/$GITHUB_BASE_REF")"
+            git checkout -b old_commit "$MERGE_BASE"
+            echo "old commit (merge base)"
+            git rev-list --format=%s --max-count=1 old_commit
+            cargo build --release --bin ty
+            mv target/release/ty ty-old
+          )
+
+          (
+            cd typing/conformance/tests
+
+            echo "Running ty on old commit (merge base)"
+            "$RUFF_DIR/ty-old" check --color=never --output-format=concise . > "$GITHUB_WORKSPACE/old-output.txt" 2>&1 || true
+
+            echo "Running ty on new commit"
+            "$RUFF_DIR/ty-new" check --color=never --output-format=concise . > "$GITHUB_WORKSPACE/new-output.txt" 2>&1 || true
+          )
+
+          if ! diff -u old-output.txt new-output.txt > typing_conformance_diagnostics.diff; then
+            echo "Differences found between base and PR"
+          else
+            echo "No differences found"
+            touch typing_conformance_diagnostics.diff
+          fi
+
+          echo ${{ github.event.number }} > pr-number
+          echo "${CONFORMANCE_SUITE_COMMIT}" > conformance-suite-commit
+
+      - name: Upload diff
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: typing_conformance_diagnostics_diff
+          path: typing_conformance_diagnostics.diff
+
+      - name: Upload pr-number
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: pr-number
+          path: pr-number
+
+      - name: Upload conformance suite commit
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: conformance-suite-commit
+          path: conformance-suite-commit

.github/workflows/typing_conformance_comment.yaml

@@ -32,6 +32,14 @@ jobs:
             echo "pr-number=$(<pr-number)" >> "$GITHUB_OUTPUT"
           fi
 
+      - uses: dawidd6/action-download-artifact@20319c5641d495c8a52e688b7dc5fada6c3a9fbc # v8
+        name: Download typing conformance suite commit
+        with:
+          name: conformance-suite-commit
+          run_id: ${{ github.event.workflow_run.id ||  github.event.inputs.workflow_run_id }}
+          if_no_artifact_found: ignore
+          allow_forks: true
+
       - uses: dawidd6/action-download-artifact@20319c5641d495c8a52e688b7dc5fada6c3a9fbc # v8
         name: "Download typing_conformance results"
         id: download-typing_conformance_diff
@@ -61,7 +69,14 @@ jobs:
           # subsequent runs
           echo '<!-- generated-comment typing_conformance_diagnostics_diff -->' >> comment.txt
 
-          echo '## Diagnostic diff on typing conformance tests' >> comment.txt
+          if [[ -f conformance-suite-commit ]]
+          then
+            echo "## Diagnostic diff on [typing conformance tests](https://github.com/python/typing/tree/$(<conformance-suite-commit)/conformance)" >> comment.txt
+          else
+            echo "conformance-suite-commit file not found"
+            echo "## Diagnostic diff on typing conformance tests" >> comment.txt
+          fi
+
           if [ -s "pr/typing_conformance_diagnostics_diff/typing_conformance_diagnostics.diff" ]; then
             echo '<details>' >> comment.txt
             echo '<summary>Changes were detected when running ty on typing conformance tests</summary>' >> comment.txt

.pre-commit-config.yaml

@@ -81,7 +81,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.4
+    rev: v0.12.7
     hooks:
       - id: ruff-format
       - id: ruff-check

CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.12.7
+
+This is a follow-up release to 0.12.6. Because of an issue in the package metadata, 0.12.6 failed to publish fully to PyPI and has been yanked. Similarly, there is no GitHub release or Git tag for 0.12.6. The contents of the 0.12.7 release are identical to 0.12.6, except for the updated metadata.
+
+## 0.12.6
+
+### Preview features
+
+- \[`flake8-commas`\] Add support for trailing comma checks in type parameter lists (`COM812`, `COM819`) ([#19390](https://github.com/astral-sh/ruff/pull/19390))
+- \[`pylint`\] Implement auto-fix for `missing-maxsplit-arg` (`PLC0207`) ([#19387](https://github.com/astral-sh/ruff/pull/19387))
+- \[`ruff`\] Offer fixes for `RUF039` in more cases ([#19065](https://github.com/astral-sh/ruff/pull/19065))
+
+### Bug fixes
+
+- Support `.pyi` files in ruff analyze graph ([#19611](https://github.com/astral-sh/ruff/pull/19611))
+- \[`flake8-pyi`\] Preserve inline comment in ellipsis removal (`PYI013`) ([#19399](https://github.com/astral-sh/ruff/pull/19399))
+- \[`perflint`\] Ignore rule if target is `global` or `nonlocal` (`PERF401`) ([#19539](https://github.com/astral-sh/ruff/pull/19539))
+- \[`pyupgrade`\] Fix `UP030` to avoid modifying double curly braces in format strings ([#19378](https://github.com/astral-sh/ruff/pull/19378))
+- \[`refurb`\] Ignore decorated functions for `FURB118` ([#19339](https://github.com/astral-sh/ruff/pull/19339))
+- \[`refurb`\] Mark `int` and `bool` cases for `Decimal.from_float` as safe fixes (`FURB164`) ([#19468](https://github.com/astral-sh/ruff/pull/19468))
+- \[`ruff`\] Fix `RUF033` for named default expressions ([#19115](https://github.com/astral-sh/ruff/pull/19115))
+
+### Rule changes
+
+- \[`flake8-blind-except`\] Change `BLE001` to permit `logging.critical(..., exc_info=True)` ([#19520](https://github.com/astral-sh/ruff/pull/19520))
+
+### Performance
+
+- Add support for specifying minimum dots in detected string imports ([#19538](https://github.com/astral-sh/ruff/pull/19538))
+
 ## 0.12.5
 
 ### Preview features

Cargo.toml

@@ -73,7 +73,7 @@ console_error_panic_hook = { version = "0.1.7" }
 console_log = { version = "1.0.0" }
 countme = { version = "3.0.1" }
 compact_str = "0.9.0"
-criterion = { version = "0.6.0", default-features = false }
+criterion = { version = "0.7.0", default-features = false }
 crossbeam = { version = "0.8.4" }
 dashmap = { version = "6.0.1" }
 dir-test = { version = "0.4.0" }
@@ -83,7 +83,7 @@ etcetera = { version = "0.10.0" }
 fern = { version = "0.7.0" }
 filetime = { version = "0.2.23" }
 getrandom = { version = "0.3.1" }
-get-size2 = { version = "0.5.0", features = [
+get-size2 = { version = "0.6.0", features = [
     "derive",
     "smallvec",
     "hashbrown",
@@ -141,7 +141,12 @@ regex-automata = { version = "0.4.9" }
 rustc-hash = { version = "2.0.0" }
 rustc-stable-hash = { version = "0.1.2" }
 # When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
-salsa = { git = "https://github.com/salsa-rs/salsa", rev = "dba66f1a37acca014c2402f231ed5b361bd7d8fe" }
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "d66fe331d546216132ace503512b94d5c68d2c50", default-features = false, features = [
+    "compact_str",
+    "macros",
+    "salsa_unstable",
+    "inventory",
+] }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }

README.md

@@ -148,8 +148,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.12.5/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.12.5/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.12.7/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.12.7/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -182,7 +182,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.12.5
+  rev: v0.12.7
   hooks:
     # Run the linter.
     - id: ruff-check

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.12.5"
+version = "0.12.7"
 publish = true
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff/tests/analyze_graph.rs

@@ -57,33 +57,40 @@ fn dependencies() -> Result<()> {
         .write_str(indoc::indoc! {r#"
         def f(): pass
     "#})?;
+    root.child("ruff")
+        .child("e.pyi")
+        .write_str(indoc::indoc! {r#"
+        def f() -> None: ...
+    "#})?;
 
     insta::with_settings!({
         filters => INSTA_FILTERS.to_vec(),
     }, {
-        assert_cmd_snapshot!(command().current_dir(&root), @r###"
-            success: true
-            exit_code: 0
-            ----- stdout -----
-            {
-              "ruff/__init__.py": [],
-              "ruff/a.py": [
-                "ruff/b.py"
-              ],
-              "ruff/b.py": [
-                "ruff/c.py"
-              ],
-              "ruff/c.py": [
-                "ruff/d.py"
-              ],
-              "ruff/d.py": [
-                "ruff/e.py"
-              ],
-              "ruff/e.py": []
-            }
+        assert_cmd_snapshot!(command().current_dir(&root), @r#"
+        success: true
+        exit_code: 0
+        ----- stdout -----
+        {
+          "ruff/__init__.py": [],
+          "ruff/a.py": [
+            "ruff/b.py"
+          ],
+          "ruff/b.py": [
+            "ruff/c.py"
+          ],
+          "ruff/c.py": [
+            "ruff/d.py"
+          ],
+          "ruff/d.py": [
+            "ruff/e.py",
+            "ruff/e.pyi"
+          ],
+          "ruff/e.py": [],
+          "ruff/e.pyi": []
+        }
 
-            ----- stderr -----
-            "###);
+        ----- stderr -----
+        "#);
     });
 
     Ok(())

crates/ruff/tests/snapshots/integration_test__rule_f401.snap

@@ -95,6 +95,6 @@ is stricter, which could affect the suggested fix. See [this FAQ section](https:
 ## References
 - [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)
 - [Python documentation: `importlib.util.find_spec`](https://docs.python.org/3/library/importlib.html#importlib.util.find_spec)
-- [Typing documentation: interface conventions](https://typing.python.org/en/latest/source/libraries.html#library-interface-public-and-private-symbols)
+- [Typing documentation: interface conventions](https://typing.python.org/en/latest/spec/distributing.html#library-interface-public-and-private-symbols)
 
 ----- stderr -----

crates/ruff/tests/snapshots/lint__output_format_gitlab.snap

@@ -22,11 +22,17 @@ exit_code: 1
     "description": "`os` imported but unused",
     "fingerprint": "4dbad37161e65c72",
     "location": {
-      "lines": {
-        "begin": 1,
-        "end": 1
-      },
-      "path": "input.py"
+      "path": "input.py",
+      "positions": {
+        "begin": {
+          "column": 8,
+          "line": 1
+        },
+        "end": {
+          "column": 10,
+          "line": 1
+        }
+      }
     },
     "severity": "major"
   },
@@ -35,11 +41,17 @@ exit_code: 1
     "description": "Undefined name `y`",
     "fingerprint": "7af59862a085230",
     "location": {
-      "lines": {
-        "begin": 2,
-        "end": 2
-      },
-      "path": "input.py"
+      "path": "input.py",
+      "positions": {
+        "begin": {
+          "column": 5,
+          "line": 2
+        },
+        "end": {
+          "column": 6,
+          "line": 2
+        }
+      }
     },
     "severity": "major"
   },
@@ -48,11 +60,17 @@ exit_code: 1
     "description": "Cannot use `match` statement on Python 3.9 (syntax was added in Python 3.10)",
     "fingerprint": "e558cec859bb66e8",
     "location": {
-      "lines": {
-        "begin": 3,
-        "end": 3
-      },
-      "path": "input.py"
+      "path": "input.py",
+      "positions": {
+        "begin": {
+          "column": 1,
+          "line": 3
+        },
+        "end": {
+          "column": 6,
+          "line": 3
+        }
+      }
     },
     "severity": "major"
   }

crates/ruff/tests/snapshots/lint__output_format_sarif.snap

@@ -95,7 +95,7 @@ exit_code: 1
           "rules": [
             {
               "fullDescription": {
-                "text": "## What it does\nChecks for unused imports.\n\n## Why is this bad?\nUnused imports add a performance overhead at runtime, and risk creating\nimport cycles. They also increase the cognitive load of reading the code.\n\nIf an import statement is used to check for the availability or existence\nof a module, consider using `importlib.util.find_spec` instead.\n\nIf an import statement is used to re-export a symbol as part of a module's\npublic interface, consider using a \"redundant\" import alias, which\ninstructs Ruff (and other tools) to respect the re-export, and avoid\nmarking it as unused, as in:\n\n```python\nfrom module import member as member\n```\n\nAlternatively, you can use `__all__` to declare a symbol as part of the module's\ninterface, as in:\n\n```python\n# __init__.py\nimport some_module\n\n__all__ = [\"some_module\"]\n```\n\n## Fix safety\n\nFixes to remove unused imports are safe, except in `__init__.py` files.\n\nApplying fixes to `__init__.py` files is currently in preview. The fix offered depends on the\ntype of the unused import. Ruff will suggest a safe fix to export first-party imports with\neither a redundant alias or, if already present in the file, an `__all__` entry. If multiple\n`__all__` declarations are present, Ruff will not offer a fix. Ruff will suggest an unsafe fix\nto remove third-party and standard library imports -- the fix is unsafe because the module's\ninterface changes.\n\n## Example\n\n```python\nimport numpy as np  # unused import\n\n\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nUse instead:\n\n```python\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nTo check the availability of a module, use `importlib.util.find_spec`:\n\n```python\nfrom importlib.util import find_spec\n\nif find_spec(\"numpy\") is not None:\n    print(\"numpy is installed\")\nelse:\n    print(\"numpy is not installed\")\n```\n\n## Preview\nWhen [preview](https://docs.astral.sh/ruff/preview/) is enabled,\nthe criterion for determining whether an import is first-party\nis stricter, which could affect the suggested fix. See [this FAQ section](https://docs.astral.sh/ruff/faq/#how-does-ruff-determine-which-of-my-imports-are-first-party-third-party-etc) for more details.\n\n## Options\n- `lint.ignore-init-module-imports`\n- `lint.pyflakes.allowed-unused-imports`\n\n## References\n- [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)\n- [Python documentation: `importlib.util.find_spec`](https://docs.python.org/3/library/importlib.html#importlib.util.find_spec)\n- [Typing documentation: interface conventions](https://typing.python.org/en/latest/source/libraries.html#library-interface-public-and-private-symbols)\n"
+                "text": "## What it does\nChecks for unused imports.\n\n## Why is this bad?\nUnused imports add a performance overhead at runtime, and risk creating\nimport cycles. They also increase the cognitive load of reading the code.\n\nIf an import statement is used to check for the availability or existence\nof a module, consider using `importlib.util.find_spec` instead.\n\nIf an import statement is used to re-export a symbol as part of a module's\npublic interface, consider using a \"redundant\" import alias, which\ninstructs Ruff (and other tools) to respect the re-export, and avoid\nmarking it as unused, as in:\n\n```python\nfrom module import member as member\n```\n\nAlternatively, you can use `__all__` to declare a symbol as part of the module's\ninterface, as in:\n\n```python\n# __init__.py\nimport some_module\n\n__all__ = [\"some_module\"]\n```\n\n## Fix safety\n\nFixes to remove unused imports are safe, except in `__init__.py` files.\n\nApplying fixes to `__init__.py` files is currently in preview. The fix offered depends on the\ntype of the unused import. Ruff will suggest a safe fix to export first-party imports with\neither a redundant alias or, if already present in the file, an `__all__` entry. If multiple\n`__all__` declarations are present, Ruff will not offer a fix. Ruff will suggest an unsafe fix\nto remove third-party and standard library imports -- the fix is unsafe because the module's\ninterface changes.\n\n## Example\n\n```python\nimport numpy as np  # unused import\n\n\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nUse instead:\n\n```python\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nTo check the availability of a module, use `importlib.util.find_spec`:\n\n```python\nfrom importlib.util import find_spec\n\nif find_spec(\"numpy\") is not None:\n    print(\"numpy is installed\")\nelse:\n    print(\"numpy is not installed\")\n```\n\n## Preview\nWhen [preview](https://docs.astral.sh/ruff/preview/) is enabled,\nthe criterion for determining whether an import is first-party\nis stricter, which could affect the suggested fix. See [this FAQ section](https://docs.astral.sh/ruff/faq/#how-does-ruff-determine-which-of-my-imports-are-first-party-third-party-etc) for more details.\n\n## Options\n- `lint.ignore-init-module-imports`\n- `lint.pyflakes.allowed-unused-imports`\n\n## References\n- [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)\n- [Python documentation: `importlib.util.find_spec`](https://docs.python.org/3/library/importlib.html#importlib.util.find_spec)\n- [Typing documentation: interface conventions](https://typing.python.org/en/latest/spec/distributing.html#library-interface-public-and-private-symbols)\n"
               },
               "help": {
                 "text": "`{name}` imported but unused; consider using `importlib.util.find_spec` to test for availability"

crates/ruff_benchmark/benches/ty.rs

@@ -351,6 +351,41 @@ fn benchmark_many_tuple_assignments(criterion: &mut Criterion) {
     });
 }
 
+fn benchmark_tuple_implicit_instance_attributes(criterion: &mut Criterion) {
+    setup_rayon();
+
+    criterion.bench_function("ty_micro[many_tuple_assignments]", |b| {
+        b.iter_batched_ref(
+            || {
+                // This is a regression benchmark for a case that used to hang:
+                // https://github.com/astral-sh/ty/issues/765
+                setup_micro_case(
+                    r#"
+                    from typing import Any
+
+                    class A:
+                        foo: tuple[Any, ...]
+
+                    class B(A):
+                        def __init__(self, parent: "C", x: tuple[Any]):
+                            self.foo = parent.foo + x
+
+                    class C(A):
+                        def __init__(self, parent: B, x: tuple[Any]):
+                            self.foo = parent.foo + x
+                    "#,
+                )
+            },
+            |case| {
+                let Case { db, .. } = case;
+                let result = db.check();
+                assert_eq!(result.len(), 0);
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
 fn benchmark_complex_constrained_attributes_1(criterion: &mut Criterion) {
     setup_rayon();
 
@@ -630,6 +665,7 @@ criterion_group!(
     micro,
     benchmark_many_string_assignments,
     benchmark_many_tuple_assignments,
+    benchmark_tuple_implicit_instance_attributes,
     benchmark_complex_constrained_attributes_1,
     benchmark_complex_constrained_attributes_2,
     benchmark_many_enum_members,

crates/ruff_db/src/diagnostic/mod.rs

@@ -6,7 +6,9 @@ use ruff_source_file::{LineColumn, SourceCode, SourceFile};
 use ruff_annotate_snippets::Level as AnnotateLevel;
 use ruff_text_size::{Ranged, TextRange, TextSize};
 
-pub use self::render::{DisplayDiagnostic, DisplayDiagnostics, FileResolver, Input};
+pub use self::render::{
+    DisplayDiagnostic, DisplayDiagnostics, FileResolver, Input, ceil_char_boundary,
+};
 use crate::{Db, files::File};
 
 mod render;
@@ -19,7 +21,7 @@ mod stylesheet;
 /// characteristics in the inputs given to the tool. Typically, but not always,
 /// a characteristic is a deficiency. An example of a characteristic that is
 /// _not_ a deficiency is the `reveal_type` diagnostic for our type checker.
-#[derive(Debug, Clone, Eq, PartialEq, get_size2::GetSize)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash, get_size2::GetSize)]
 pub struct Diagnostic {
     /// The actual diagnostic.
     ///
@@ -477,7 +479,7 @@ impl Diagnostic {
     }
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, get_size2::GetSize)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash, get_size2::GetSize)]
 struct DiagnosticInner {
     id: DiagnosticId,
     severity: Severity,
@@ -553,7 +555,7 @@ impl Eq for RenderingSortKey<'_> {}
 /// Currently, the order in which sub-diagnostics are rendered relative to one
 /// another (for a single parent diagnostic) is the order in which they were
 /// attached to the diagnostic.
-#[derive(Debug, Clone, Eq, PartialEq, get_size2::GetSize)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash, get_size2::GetSize)]
 pub struct SubDiagnostic {
     /// Like with `Diagnostic`, we box the `SubDiagnostic` to make it
     /// pointer-sized.
@@ -657,7 +659,7 @@ impl SubDiagnostic {
     }
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, get_size2::GetSize)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash, get_size2::GetSize)]
 struct SubDiagnosticInner {
     severity: SubDiagnosticSeverity,
     message: DiagnosticMessage,
@@ -685,7 +687,7 @@ struct SubDiagnosticInner {
 ///
 /// Messages attached to annotations should also be as brief and specific as
 /// possible. Long messages could negative impact the quality of rendering.
-#[derive(Debug, Clone, Eq, PartialEq, get_size2::GetSize)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash, get_size2::GetSize)]
 pub struct Annotation {
     /// The span of this annotation, corresponding to some subsequence of the
     /// user's input that we want to highlight.
@@ -805,7 +807,7 @@ impl Annotation {
 ///
 /// These tags are used to provide additional information about the annotation.
 /// and are passed through to the language server protocol.
-#[derive(Debug, Clone, Eq, PartialEq, get_size2::GetSize)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash, get_size2::GetSize)]
 pub enum DiagnosticTag {
     /// Unused or unnecessary code. Used for unused parameters, unreachable code, etc.
     Unnecessary,
@@ -1014,7 +1016,7 @@ impl std::fmt::Display for DiagnosticId {
 ///
 /// This enum presents a unified interface to these two types for the sake of creating [`Span`]s and
 /// emitting diagnostics from both ty and ruff.
-#[derive(Debug, Clone, PartialEq, Eq, get_size2::GetSize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, get_size2::GetSize)]
 pub enum UnifiedFile {
     Ty(File),
     Ruff(SourceFile),
@@ -1078,7 +1080,7 @@ impl DiagnosticSource {
 /// It consists of a `File` and an optional range into that file. When the
 /// range isn't present, it semantically implies that the diagnostic refers to
 /// the entire file. For example, when the file should be executable but isn't.
-#[derive(Debug, Clone, PartialEq, Eq, get_size2::GetSize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, get_size2::GetSize)]
 pub struct Span {
     file: UnifiedFile,
     range: Option<TextRange>,
@@ -1156,7 +1158,7 @@ impl From<crate::files::FileRange> for Span {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, get_size2::GetSize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash, get_size2::GetSize)]
 pub enum Severity {
     Info,
     Warning,
@@ -1191,7 +1193,7 @@ impl Severity {
 /// This type only exists to add an additional `Help` severity that isn't present in `Severity` or
 /// used for main diagnostics. If we want to add `Severity::Help` in the future, this type could be
 /// deleted and the two combined again.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, get_size2::GetSize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash, get_size2::GetSize)]
 pub enum SubDiagnosticSeverity {
     Help,
     Info,
@@ -1426,7 +1428,7 @@ impl std::fmt::Display for ConciseMessage<'_> {
 /// In most cases, callers shouldn't need to use this. Instead, there is
 /// a blanket trait implementation for `IntoDiagnosticMessage` for
 /// anything that implements `std::fmt::Display`.
-#[derive(Clone, Debug, Eq, PartialEq, get_size2::GetSize)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash, get_size2::GetSize)]
 pub struct DiagnosticMessage(Box<str>);
 
 impl DiagnosticMessage {

crates/ruff_db/src/diagnostic/render.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::path::Path;
 
@@ -7,7 +8,7 @@ use ruff_annotate_snippets::{
 };
 use ruff_notebook::{Notebook, NotebookIndex};
 use ruff_source_file::{LineIndex, OneIndexed, SourceCode};
-use ruff_text_size::{TextRange, TextSize};
+use ruff_text_size::{TextLen, TextRange, TextSize};
 
 use crate::diagnostic::stylesheet::DiagnosticStylesheet;
 use crate::{
@@ -520,7 +521,7 @@ impl<'r> RenderableSnippets<'r> {
 #[derive(Debug)]
 struct RenderableSnippet<'r> {
     /// The actual snippet text.
-    snippet: &'r str,
+    snippet: Cow<'r, str>,
     /// The absolute line number corresponding to where this
     /// snippet begins.
     line_start: OneIndexed,
@@ -580,6 +581,12 @@ impl<'r> RenderableSnippet<'r> {
             .iter()
             .map(|ann| RenderableAnnotation::new(snippet_start, ann))
             .collect();
+
+        let EscapedSourceCode {
+            text: snippet,
+            annotations,
+        } = replace_unprintable(snippet, annotations).fix_up_empty_spans_after_line_terminator();
+
         RenderableSnippet {
             snippet,
             line_start,
@@ -590,7 +597,7 @@ impl<'r> RenderableSnippet<'r> {
 
     /// Convert this to an "annotate" snippet.
     fn to_annotate<'a>(&'a self, path: &'a str) -> AnnotateSnippet<'a> {
-        AnnotateSnippet::source(self.snippet)
+        AnnotateSnippet::source(&self.snippet)
             .origin(path)
             .line_start(self.line_start.get())
             .annotations(
@@ -820,6 +827,204 @@ fn relativize_path<'p>(cwd: &SystemPath, path: &'p str) -> &'p str {
     path
 }
 
+/// Given some source code and annotation ranges, this routine replaces
+/// unprintable characters with printable representations of them.
+///
+/// The source code and annotations returned are updated to reflect changes made
+/// to the source code (if any).
+///
+/// We don't need to normalize whitespace, such as converting tabs to spaces,
+/// because `annotate-snippets` handles that internally. Similarly, it's safe to
+/// modify the annotation ranges by inserting 3-byte Unicode replacements
+/// because `annotate-snippets` will account for their actual width when
+/// rendering and displaying the column to the user.
+fn replace_unprintable<'r>(
+    source: &'r str,
+    mut annotations: Vec<RenderableAnnotation<'r>>,
+) -> EscapedSourceCode<'r> {
+    // Updates the annotation ranges given by the caller whenever a single byte (at `index` in
+    // `source`) is replaced with `len` bytes.
+    //
+    // When the index occurs before the start of the range, the range is
+    // offset by `len`. When the range occurs after or at the start but before
+    // the end, then the end of the range only is offset by `len`.
+    let mut update_ranges = |index: usize, len: u32| {
+        for ann in &mut annotations {
+            if index < usize::from(ann.range.start()) {
+                ann.range += TextSize::new(len - 1);
+            } else if index < usize::from(ann.range.end()) {
+                ann.range = ann.range.add_end(TextSize::new(len - 1));
+            }
+        }
+    };
+
+    // If `c` is an unprintable character, then this returns a printable
+    // representation of it (using a fancier Unicode codepoint).
+    let unprintable_replacement = |c: char| -> Option<char> {
+        match c {
+            '\x07' => Some('␇'),
+            '\x08' => Some('␈'),
+            '\x1b' => Some('␛'),
+            '\x7f' => Some('␡'),
+            _ => None,
+        }
+    };
+
+    let mut last_end = 0;
+    let mut result = String::new();
+    for (index, c) in source.char_indices() {
+        if let Some(printable) = unprintable_replacement(c) {
+            result.push_str(&source[last_end..index]);
+
+            let len = printable.text_len().to_u32();
+            update_ranges(result.text_len().to_usize(), len);
+
+            result.push(printable);
+            last_end = index + 1;
+        }
+    }
+
+    // No tabs or unprintable chars
+    if result.is_empty() {
+        EscapedSourceCode {
+            annotations,
+            text: Cow::Borrowed(source),
+        }
+    } else {
+        result.push_str(&source[last_end..]);
+        EscapedSourceCode {
+            annotations,
+            text: Cow::Owned(result),
+        }
+    }
+}
+
+struct EscapedSourceCode<'r> {
+    text: Cow<'r, str>,
+    annotations: Vec<RenderableAnnotation<'r>>,
+}
+
+impl<'r> EscapedSourceCode<'r> {
+    // This attempts to "fix up" the spans on each annotation  in the case where
+    // it's an empty span immediately following a line terminator.
+    //
+    // At present, `annotate-snippets` (both upstream and our vendored copy)
+    // will render annotations of such spans to point to the space immediately
+    // following the previous line. But ideally, this should point to the space
+    // immediately preceding the next line.
+    //
+    // After attempting to fix `annotate-snippets` and giving up after a couple
+    // hours, this routine takes a different tact: it adjusts the span to be
+    // non-empty and it will cover the first codepoint of the following line.
+    // This forces `annotate-snippets` to point to the right place.
+    //
+    // See also: <https://github.com/astral-sh/ruff/issues/15509> and
+    // `ruff_linter::message::text::SourceCode::fix_up_empty_spans_after_line_terminator`,
+    // from which this was adapted.
+    fn fix_up_empty_spans_after_line_terminator(mut self) -> EscapedSourceCode<'r> {
+        for ann in &mut self.annotations {
+            let range = ann.range;
+            if !range.is_empty()
+                || range.start() == TextSize::from(0)
+                || range.start() >= self.text.text_len()
+            {
+                continue;
+            }
+            if !matches!(
+                self.text.as_bytes()[range.start().to_usize() - 1],
+                b'\n' | b'\r'
+            ) {
+                continue;
+            }
+            let start = range.start();
+            let end = ceil_char_boundary(&self.text, start + TextSize::from(1));
+            ann.range = TextRange::new(start, end);
+        }
+
+        self
+    }
+}
+
+/// Finds the closest [`TextSize`] not less than the offset given for which
+/// `is_char_boundary` is `true`. Unless the offset given is greater than
+/// the length of the underlying contents, in which case, the length of the
+/// contents is returned.
+///
+/// Can be replaced with `str::ceil_char_boundary` once it's stable.
+///
+/// # Examples
+///
+/// From `std`:
+///
+/// ```
+/// use ruff_db::diagnostic::ceil_char_boundary;
+/// use ruff_text_size::{Ranged, TextLen, TextSize};
+///
+/// let source = "❤️🧡💛💚💙💜";
+/// assert_eq!(source.text_len(), TextSize::from(26));
+/// assert!(!source.is_char_boundary(13));
+///
+/// let closest = ceil_char_boundary(source, TextSize::from(13));
+/// assert_eq!(closest, TextSize::from(14));
+/// assert_eq!(&source[..closest.to_usize()], "❤️🧡💛");
+/// ```
+///
+/// Additional examples:
+///
+/// ```
+/// use ruff_db::diagnostic::ceil_char_boundary;
+/// use ruff_text_size::{Ranged, TextRange, TextSize};
+///
+/// let source = "Hello";
+///
+/// assert_eq!(
+///     ceil_char_boundary(source, TextSize::from(0)),
+///     TextSize::from(0)
+/// );
+///
+/// assert_eq!(
+///     ceil_char_boundary(source, TextSize::from(5)),
+///     TextSize::from(5)
+/// );
+///
+/// assert_eq!(
+///     ceil_char_boundary(source, TextSize::from(6)),
+///     TextSize::from(5)
+/// );
+///
+/// let source = "α";
+///
+/// assert_eq!(
+///     ceil_char_boundary(source, TextSize::from(0)),
+///     TextSize::from(0)
+/// );
+///
+/// assert_eq!(
+///     ceil_char_boundary(source, TextSize::from(1)),
+///     TextSize::from(2)
+/// );
+///
+/// assert_eq!(
+///     ceil_char_boundary(source, TextSize::from(2)),
+///     TextSize::from(2)
+/// );
+///
+/// assert_eq!(
+///     ceil_char_boundary(source, TextSize::from(3)),
+///     TextSize::from(2)
+/// );
+/// ```
+pub fn ceil_char_boundary(text: &str, offset: TextSize) -> TextSize {
+    let upper_bound = offset
+        .to_u32()
+        .saturating_add(4)
+        .min(text.text_len().to_u32());
+    (offset.to_u32()..upper_bound)
+        .map(TextSize::from)
+        .find(|offset| text.is_char_boundary(offset.to_usize()))
+        .unwrap_or_else(|| TextSize::from(upper_bound))
+}
+
 #[cfg(test)]
 mod tests {
 
@@ -2359,7 +2564,7 @@ watermelon
         }
 
         /// Returns a builder for tersely constructing diagnostics.
-        fn builder(
+        pub(super) fn builder(
             &mut self,
             identifier: &'static str,
             severity: Severity,
@@ -2426,7 +2631,7 @@ watermelon
         ///
         /// See the docs on `TestEnvironment::span` for the meaning of
         /// `path`, `line_offset_start` and `line_offset_end`.
-        fn primary(
+        pub(super) fn primary(
             mut self,
             path: &str,
             line_offset_start: &str,

crates/ruff_db/src/diagnostic/render/full.rs

@@ -1,8 +1,8 @@
 #[cfg(test)]
 mod tests {
     use crate::diagnostic::{
-        DiagnosticFormat,
-        render::tests::{create_diagnostics, create_syntax_error_diagnostics},
+        DiagnosticFormat, Severity,
+        render::tests::{TestEnvironment, create_diagnostics, create_syntax_error_diagnostics},
     };
 
     #[test]
@@ -63,4 +63,139 @@ mod tests {
           |
         ");
     }
+
+    /// Check that the new `full` rendering code in `ruff_db` handles cases fixed by commit c9b99e4.
+    ///
+    /// For example, without the fix, we get diagnostics like this:
+    ///
+    /// ```
+    /// error[no-indented-block]: Expected an indented block
+    ///  --> example.py:3:1
+    ///   |
+    /// 2 | if False:
+    ///   |          ^
+    /// 3 | print()
+    ///   |
+    ///  ```
+    ///
+    /// where the caret points to the end of the previous line instead of the start of the next.
+    #[test]
+    fn empty_span_after_line_terminator() {
+        let mut env = TestEnvironment::new();
+        env.add(
+            "example.py",
+            r#"
+if False:
+print()
+"#,
+        );
+        env.format(DiagnosticFormat::Full);
+
+        let diagnostic = env
+            .builder(
+                "no-indented-block",
+                Severity::Error,
+                "Expected an indented block",
+            )
+            .primary("example.py", "3:0", "3:0", "")
+            .build();
+
+        insta::assert_snapshot!(env.render(&diagnostic), @r"
+        error[no-indented-block]: Expected an indented block
+         --> example.py:3:1
+          |
+        2 | if False:
+        3 | print()
+          | ^
+          |
+        ");
+    }
+
+    /// Check that the new `full` rendering code in `ruff_db` handles cases fixed by commit 2922490.
+    ///
+    /// For example, without the fix, we get diagnostics like this:
+    ///
+    /// ```
+    /// error[invalid-character-sub]: Invalid unescaped character SUB, use "\x1A" instead
+    ///  --> example.py:1:25
+    ///   |
+    /// 1 | nested_fstrings = f'␈{f'{f'␛'}'}'
+    ///   |                       ^
+    ///   |
+    ///  ```
+    ///
+    /// where the caret points to the `f` in the f-string instead of the start of the invalid
+    /// character (`^Z`).
+    #[test]
+    fn unprintable_characters() {
+        let mut env = TestEnvironment::new();
+        env.add("example.py", "nested_fstrings = f'{f'{f''}'}'");
+        env.format(DiagnosticFormat::Full);
+
+        let diagnostic = env
+            .builder(
+                "invalid-character-sub",
+                Severity::Error,
+                r#"Invalid unescaped character SUB, use "\x1A" instead"#,
+            )
+            .primary("example.py", "1:24", "1:24", "")
+            .build();
+
+        insta::assert_snapshot!(env.render(&diagnostic), @r#"
+        error[invalid-character-sub]: Invalid unescaped character SUB, use "\x1A" instead
+         --> example.py:1:25
+          |
+        1 | nested_fstrings = f'␈{f'{f'␛'}'}'
+          |                         ^
+          |
+        "#);
+    }
+
+    #[test]
+    fn multiple_unprintable_characters() -> std::io::Result<()> {
+        let mut env = TestEnvironment::new();
+        env.add("example.py", "");
+        env.format(DiagnosticFormat::Full);
+
+        let diagnostic = env
+            .builder(
+                "invalid-character-sub",
+                Severity::Error,
+                r#"Invalid unescaped character SUB, use "\x1A" instead"#,
+            )
+            .primary("example.py", "1:1", "1:1", "")
+            .build();
+
+        insta::assert_snapshot!(env.render(&diagnostic), @r#"
+        error[invalid-character-sub]: Invalid unescaped character SUB, use "\x1A" instead
+         --> example.py:1:2
+          |
+        1 | ␈␛
+          |  ^
+          |
+        "#);
+
+        Ok(())
+    }
+
+    /// Ensure that the header column matches the column in the user's input, even if we've replaced
+    /// tabs with spaces for rendering purposes.
+    #[test]
+    fn tab_replacement() {
+        let mut env = TestEnvironment::new();
+        env.add("example.py", "def foo():\n\treturn 1");
+        env.format(DiagnosticFormat::Full);
+
+        let diagnostic = env.err().primary("example.py", "2:1", "2:9", "").build();
+
+        insta::assert_snapshot!(env.render(&diagnostic), @r"
+        error[test-diagnostic]: main diagnostic message
+         --> example.py:2:2
+          |
+        1 | def foo():
+        2 |     return 1
+          |     ^^^^^^^^
+          |
+        ");
+    }
 }

crates/ruff_db/src/parsed.rs

@@ -21,7 +21,7 @@ use crate::source::source_text;
 /// reflected in the changed AST offsets.
 /// The other reason is that Ruff's AST doesn't implement `Eq` which Salsa requires
 /// for determining if a query result is unchanged.
-#[salsa::tracked(returns(ref), no_eq, heap_size=get_size2::GetSize::get_heap_size)]
+#[salsa::tracked(returns(ref), no_eq, heap_size=get_size2::heap_size)]
 pub fn parsed_module(db: &dyn Db, file: File) -> ParsedModule {
     let _span = tracing::trace_span!("parsed_module", ?file).entered();
 

crates/ruff_db/src/source.rs

@@ -9,7 +9,7 @@ use crate::Db;
 use crate::files::{File, FilePath};
 
 /// Reads the source text of a python text file (must be valid UTF8) or notebook.
-#[salsa::tracked(heap_size=get_size2::GetSize::get_heap_size)]
+#[salsa::tracked(heap_size=get_size2::heap_size)]
 pub fn source_text(db: &dyn Db, file: File) -> SourceText {
     let path = file.path(db);
     let _span = tracing::trace_span!("source_text", file = %path).entered();
@@ -69,21 +69,21 @@ impl SourceText {
     pub fn as_str(&self) -> &str {
         match &self.inner.kind {
             SourceTextKind::Text(source) => source,
-            SourceTextKind::Notebook(notebook) => notebook.source_code(),
+            SourceTextKind::Notebook { notebook } => notebook.source_code(),
         }
     }
 
     /// Returns the underlying notebook if this is a notebook file.
     pub fn as_notebook(&self) -> Option<&Notebook> {
         match &self.inner.kind {
-            SourceTextKind::Notebook(notebook) => Some(notebook),
+            SourceTextKind::Notebook { notebook } => Some(notebook),
             SourceTextKind::Text(_) => None,
         }
     }
 
     /// Returns `true` if this is a notebook source file.
     pub fn is_notebook(&self) -> bool {
-        matches!(&self.inner.kind, SourceTextKind::Notebook(_))
+        matches!(&self.inner.kind, SourceTextKind::Notebook { .. })
     }
 
     /// Returns `true` if there was an error when reading the content of the file.
@@ -108,7 +108,7 @@ impl std::fmt::Debug for SourceText {
             SourceTextKind::Text(text) => {
                 dbg.field(text);
             }
-            SourceTextKind::Notebook(notebook) => {
+            SourceTextKind::Notebook { notebook } => {
                 dbg.field(notebook);
             }
         }
@@ -123,23 +123,15 @@ struct SourceTextInner {
     read_error: Option<SourceTextError>,
 }
 
-#[derive(Eq, PartialEq)]
+#[derive(Eq, PartialEq, get_size2::GetSize)]
 enum SourceTextKind {
     Text(String),
-    Notebook(Box<Notebook>),
-}
-
-impl get_size2::GetSize for SourceTextKind {
-    fn get_heap_size(&self) -> usize {
-        match self {
-            SourceTextKind::Text(text) => text.get_heap_size(),
-            // TODO: The `get-size` derive does not support ignoring enum variants.
-            //
-            // Jupyter notebooks are not very relevant for memory profiling, and contain
-            // arbitrary JSON values that do not implement the `GetSize` trait.
-            SourceTextKind::Notebook(_) => 0,
-        }
-    }
+    Notebook {
+        // Jupyter notebooks are not very relevant for memory profiling, and contain
+        // arbitrary JSON values that do not implement the `GetSize` trait.
+        #[get_size(ignore)]
+        notebook: Box<Notebook>,
+    },
 }
 
 impl From<String> for SourceTextKind {
@@ -150,7 +142,9 @@ impl From<String> for SourceTextKind {
 
 impl From<Notebook> for SourceTextKind {
     fn from(notebook: Notebook) -> Self {
-        SourceTextKind::Notebook(Box::new(notebook))
+        SourceTextKind::Notebook {
+            notebook: Box::new(notebook),
+        }
     }
 }
 
@@ -163,7 +157,7 @@ pub enum SourceTextError {
 }
 
 /// Computes the [`LineIndex`] for `file`.
-#[salsa::tracked(heap_size=get_size2::GetSize::get_heap_size)]
+#[salsa::tracked(heap_size=get_size2::heap_size)]
 pub fn line_index(db: &dyn Db, file: File) -> LineIndex {
     let _span = tracing::trace_span!("line_index", ?file).entered();
 

crates/ruff_diagnostics/src/fix.rs

@@ -43,7 +43,7 @@ pub enum IsolationLevel {
 }
 
 /// A collection of [`Edit`] elements to be applied to a source file.
-#[derive(Debug, PartialEq, Eq, Clone, get_size2::GetSize)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, get_size2::GetSize)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Fix {
     /// The [`Edit`] elements to be applied, sorted by [`Edit::start`] in ascending order.

crates/ruff_graph/src/lib.rs

@@ -42,13 +42,11 @@ impl ModuleImports {
         // Resolve the imports.
         let mut resolved_imports = ModuleImports::default();
         for import in imports {
-            let Some(resolved) = Resolver::new(db).resolve(import) else {
-                continue;
-            };
-            let Some(path) = resolved.as_system_path() else {
-                continue;
-            };
-            resolved_imports.insert(path.to_path_buf());
+            for resolved in Resolver::new(db).resolve(import) {
+                if let Some(path) = resolved.as_system_path() {
+                    resolved_imports.insert(path.to_path_buf());
+                }
+            }
         }
 
         Ok(resolved_imports)

crates/ruff_graph/src/resolver.rs

@@ -1,5 +1,5 @@
 use ruff_db::files::FilePath;
-use ty_python_semantic::resolve_module;
+use ty_python_semantic::{ModuleName, resolve_module, resolve_real_module};
 
 use crate::ModuleDb;
 use crate::collector::CollectedImport;
@@ -16,24 +16,67 @@ impl<'a> Resolver<'a> {
     }
 
     /// Resolve the [`CollectedImport`] into a [`FilePath`].
-    pub(crate) fn resolve(&self, import: CollectedImport) -> Option<&'a FilePath> {
+    pub(crate) fn resolve(&self, import: CollectedImport) -> impl Iterator<Item = &'a FilePath> {
         match import {
             CollectedImport::Import(import) => {
-                let module = resolve_module(self.db, &import)?;
-                Some(module.file(self.db)?.path(self.db))
+                // Attempt to resolve the module (e.g., given `import foo`, look for `foo`).
+                let file = self.resolve_module(&import);
+
+                // If the file is a stub, look for the corresponding source file.
+                let source_file = file
+                    .is_some_and(|file| file.extension() == Some("pyi"))
+                    .then(|| self.resolve_real_module(&import))
+                    .flatten();
+
+                std::iter::once(file)
+                    .chain(std::iter::once(source_file))
+                    .flatten()
             }
             CollectedImport::ImportFrom(import) => {
                 // Attempt to resolve the member (e.g., given `from foo import bar`, look for `foo.bar`).
+                if let Some(file) = self.resolve_module(&import) {
+                    // If the file is a stub, look for the corresponding source file.
+                    let source_file = (file.extension() == Some("pyi"))
+                        .then(|| self.resolve_real_module(&import))
+                        .flatten();
+
+                    return std::iter::once(Some(file))
+                        .chain(std::iter::once(source_file))
+                        .flatten();
+                }
+
+                // Attempt to resolve the module (e.g., given `from foo import bar`, look for `foo`).
                 let parent = import.parent();
+                let file = parent
+                    .as_ref()
+                    .and_then(|parent| self.resolve_module(parent));
 
-                let module = resolve_module(self.db, &import).or_else(|| {
-                    // Attempt to resolve the module (e.g., given `from foo import bar`, look for `foo`).
+                // If the file is a stub, look for the corresponding source file.
+                let source_file = file
+                    .is_some_and(|file| file.extension() == Some("pyi"))
+                    .then(|| {
+                        parent
+                            .as_ref()
+                            .and_then(|parent| self.resolve_real_module(parent))
+                    })
+                    .flatten();
 
-                    resolve_module(self.db, &parent?)
-                })?;
-
-                Some(module.file(self.db)?.path(self.db))
+                std::iter::once(file)
+                    .chain(std::iter::once(source_file))
+                    .flatten()
             }
         }
     }
+
+    /// Resolves a module name to a module.
+    pub(crate) fn resolve_module(&self, module_name: &ModuleName) -> Option<&'a FilePath> {
+        let module = resolve_module(self.db, module_name)?;
+        Some(module.file(self.db)?.path(self.db))
+    }
+
+    /// Resolves a module name to a module (stubs not allowed).
+    fn resolve_real_module(&self, module_name: &ModuleName) -> Option<&'a FilePath> {
+        let module = resolve_real_module(self.db, module_name)?;
+        Some(module.file(self.db)?.path(self.db))
+    }
 }

crates/ruff_linter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.12.5"
+version = "0.12.7"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

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

@@ -89,3 +89,14 @@ print(1)
 # ///
 #
 # Foobar
+
+
+# Regression tests for https://github.com/astral-sh/ruff/issues/19713
+
+# mypy: ignore-errors
+# pyright: ignore-errors
+# pyrefly: ignore-errors
+# ty: ignore[unresolved-import]
+# pyrefly: ignore[unused-import]
+
+print(1)

crates/ruff_linter/resources/test/fixtures/flake8_blind_except/BLE.py

@@ -162,3 +162,86 @@ except Exception:
         exception("An error occurred")
     else:
         exception("An error occurred")
+
+# Test tuple exceptions
+try:
+    pass
+except (Exception,):
+    pass
+
+try:
+    pass
+except (Exception, ValueError):
+    pass
+
+try:
+    pass
+except (ValueError, Exception):
+    pass
+
+try:
+    pass
+except (ValueError, Exception) as e:
+    print(e)
+
+try:
+    pass
+except (BaseException, TypeError):
+    pass
+
+try:
+    pass
+except (TypeError, BaseException):
+    pass
+
+try:
+    pass
+except (Exception, BaseException):
+    pass
+
+try:
+    pass
+except (BaseException, Exception):
+    pass
+
+# Test nested tuples
+try:
+    pass
+except ((Exception, ValueError), TypeError):
+    pass
+
+try:
+    pass
+except (ValueError, (BaseException, TypeError)):
+    pass
+
+# Test valid tuple exceptions (should not trigger)
+try:
+    pass
+except (ValueError, TypeError):
+    pass
+
+try:
+    pass
+except (OSError, FileNotFoundError):
+    pass
+
+try:
+    pass
+except (OSError, FileNotFoundError) as e:
+    print(e)
+
+try:
+    pass
+except (Exception, ValueError):
+    critical("...", exc_info=True)
+
+try:
+    pass
+except (Exception, ValueError):
+    raise
+
+try:
+    pass
+except (Exception, ValueError) as e:
+    raise e

crates/ruff_linter/resources/test/fixtures/flake8_commas/COM81.py

@@ -650,3 +650,17 @@ f"""This is a test. {
     if True else
     "Don't add a trailing comma here ->"
 }"""
+
+type X[
+    T
+] = T
+def f[
+    T
+](): pass
+class C[
+    T
+]: pass
+
+type X[T,] = T
+def f[T,](): pass
+class C[T,]: pass

crates/ruff_linter/resources/test/fixtures/flake8_errmsg/EM.py

@@ -88,3 +88,25 @@ def f_multi_line_string2():
             example="example"
         )
     )
+
+
+def raise_typing_cast_exception():
+    import typing
+    raise typing.cast("Exception", None)
+
+
+def f_typing_cast_excluded():
+    from typing import cast
+    raise cast(RuntimeError, "This should not trigger EM101")
+
+
+def f_typing_cast_excluded_import():
+    import typing
+    raise typing.cast(RuntimeError, "This should not trigger EM101")
+
+
+def f_typing_cast_excluded_aliased():
+    from typing import cast as my_cast
+    raise my_cast(RuntimeError, "This should not trigger EM101")
+
+

crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI013.py

@@ -39,6 +39,11 @@ class NonEmptyWithInit:
         pass
 
 
+class NonEmptyChildWithInlineComment:
+    value: int
+    ... # preserve me
+
+
 class EmptyClass:
     ...
 

crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI013.pyi

@@ -38,6 +38,10 @@ class NonEmptyWithInit:
     def __init__():
         pass
 
+class NonEmptyChildWithInlineComment:
+    value: int
+    ... # preserve me
+
 # Not violations
 
 class EmptyClass: ...

crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM905.py

@@ -129,4 +129,35 @@ print(" x ".rsplit(maxsplit=0))
 print(" x ".rsplit(maxsplit=0))
 print(" x ".rsplit(sep=None, maxsplit=0))
 print("  x  ".rsplit(maxsplit=0))
-print("  x  ".rsplit(sep=None, maxsplit=0))
+print("  x  ".rsplit(sep=None, maxsplit=0))
+
+# https://github.com/astral-sh/ruff/issues/19581 - embedded quotes in raw strings
+r"""simple@example.com
+very.common@example.com
+FirstName.LastName@EasierReading.org
+x@example.com
+long.email-address-with-hyphens@and.subdomains.example.com
+user.name+tag+sorting@example.com
+name/surname@example.com
+xample@s.example
+" "@example.org
+"john..doe"@example.org
+mailhost!username@example.org
+"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com
+user%example.com@example.org
+user-@example.org
+I❤️CHOCOLATE@example.com
+this\ still\"not\\allowed@example.com
+stellyamburrr985@example.com
+Abc.123@example.com
+user+mailbox/department=shipping@example.com
+!#$%&'*+-/=?^_`.{|}~@example.com
+"Abc@def"@example.com
+"Fred\ Bloggs"@example.com
+"Joe.\\Blow"@example.com""".split("\n")
+
+
+r"""first
+'no need' to escape
+"swap" quote style
+"use' ugly triple quotes""".split("\n")

crates/ruff_linter/resources/test/fixtures/flake8_use_pathlib/PTH201.py

@@ -1,4 +1,4 @@
-from pathlib import Path, PurePath
+from pathlib import Path, PurePath, PosixPath, PurePosixPath, WindowsPath, PureWindowsPath
 from pathlib import Path as pth
 
 
@@ -68,3 +68,11 @@ Path(".", "folder")
 PurePath(".", "folder")
 
 Path()
+
+from importlib.metadata import PackagePath
+
+_ = PosixPath(".")
+_ = PurePosixPath(".")
+_ = WindowsPath(".")
+_ = PureWindowsPath(".")
+_ = PackagePath(".")

crates/ruff_linter/resources/test/fixtures/isort/required_imports/docstring_followed_by_continuation.py

@@ -0,0 +1,3 @@
+"""Hello, world!"""\
+
+x = 1; y = 2

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

@@ -289,4 +289,19 @@ def f():
     i = "xyz"
     result = []
     for i in range(3):
-        result.append((x for x in [i]))
+        result.append((x for x in [i]))
+
+G_INDEX = None
+def f():
+    global G_INDEX
+    result = []
+    for G_INDEX in range(3):
+        result.append(G_INDEX)
+
+def f():
+    NL_INDEX = None
+    def x():
+        nonlocal NL_INDEX
+        result = []
+        for NL_INDEX in range(3):
+            result.append(NL_INDEX)

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP030_0.py

@@ -59,3 +59,7 @@ kwargs = {x: x for x in range(10)}
 "{1}_{0}".format(1, 2, *args)
 
 "{1}_{0}".format(1, 2)
+
+r"\d{{1,2}} {0}".format(42)
+
+"{{{0}}}".format(123)

crates/ruff_linter/resources/test/fixtures/refurb/FURB164.py

@@ -55,3 +55,12 @@ _ = Decimal(0.1)
 _ = Decimal(-0.5)
 _ = Decimal(5.0)
 _ = decimal.Decimal(4.2)
+
+# Cases with int and bool - should produce safe fixes
+_ = Decimal.from_float(1)
+_ = Decimal.from_float(True)
+
+# Cases with non-finite floats - should produce safe fixes
+_ = Decimal.from_float(float("-nan"))
+_ = Decimal.from_float(float("\x2dnan"))
+_ = Decimal.from_float(float("\N{HYPHEN-MINUS}nan"))

crates/ruff_linter/resources/test/fixtures/ruff/RUF010.py

@@ -52,3 +52,7 @@ f"{repr(lambda: 1)}"
 f"{repr(x := 2)}"
 
 f"{str(object=3)}"
+
+f"{str(x for x in [])}"
+
+f"{str((x for x in []))}"

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

@@ -590,6 +590,16 @@ impl<'a> Checker<'a> {
             member,
         })
     }
+
+    /// Return the [`LintContext`] for the current analysis.
+    ///
+    /// Note that you should always prefer calling methods like `settings`, `report_diagnostic`, or
+    /// `is_rule_enabled` directly on [`Checker`] when possible. This method exists only for the
+    /// rare cases where rules or helper functions need to be accessed by both a `Checker` and a
+    /// `LintContext` in different analysis phases.
+    pub(crate) const fn context(&self) -> &'a LintContext<'a> {
+        self.context
+    }
 }
 
 pub(crate) struct TypingImporter<'a, 'b> {
@@ -3216,6 +3226,11 @@ impl<'a> LintContext<'a> {
     pub(crate) fn iter(&mut self) -> impl Iterator<Item = &Diagnostic> {
         self.diagnostics.get_mut().iter()
     }
+
+    /// The [`LinterSettings`] for the current analysis, including the enabled rules.
+    pub(crate) const fn settings(&self) -> &LinterSettings {
+        self.settings
+    }
 }
 
 /// An abstraction for mutating a diagnostic.

crates/ruff_linter/src/checkers/tokens.rs

@@ -16,7 +16,6 @@ use crate::rules::{
     eradicate, flake8_commas, flake8_executable, flake8_fixme, flake8_implicit_str_concat,
     flake8_pyi, flake8_todos, pycodestyle, pygrep_hooks, pylint, pyupgrade, ruff,
 };
-use crate::settings::LinterSettings;
 
 use super::ast::LintContext;
 
@@ -27,7 +26,6 @@ pub(crate) fn check_tokens(
     locator: &Locator,
     indexer: &Indexer,
     stylist: &Stylist,
-    settings: &LinterSettings,
     source_type: PySourceType,
     cell_offsets: Option<&CellOffsets>,
     context: &mut LintContext,
@@ -42,15 +40,8 @@ pub(crate) fn check_tokens(
         Rule::BlankLinesAfterFunctionOrClass,
         Rule::BlankLinesBeforeNestedDefinition,
     ]) {
-        BlankLinesChecker::new(
-            locator,
-            stylist,
-            settings,
-            source_type,
-            cell_offsets,
-            context,
-        )
-        .check_lines(tokens);
+        BlankLinesChecker::new(locator, stylist, source_type, cell_offsets, context)
+            .check_lines(tokens);
     }
 
     if context.is_rule_enabled(Rule::BlanketTypeIgnore) {
@@ -63,12 +54,12 @@ pub(crate) fn check_tokens(
 
     if context.is_rule_enabled(Rule::AmbiguousUnicodeCharacterComment) {
         for range in comment_ranges {
-            ruff::rules::ambiguous_unicode_character_comment(context, locator, range, settings);
+            ruff::rules::ambiguous_unicode_character_comment(context, locator, range);
         }
     }
 
     if context.is_rule_enabled(Rule::CommentedOutCode) {
-        eradicate::rules::commented_out_code(context, locator, comment_ranges, settings);
+        eradicate::rules::commented_out_code(context, locator, comment_ranges);
     }
 
     if context.is_rule_enabled(Rule::UTF8EncodingDeclaration) {
@@ -110,7 +101,7 @@ pub(crate) fn check_tokens(
         Rule::SingleLineImplicitStringConcatenation,
         Rule::MultiLineImplicitStringConcatenation,
     ]) {
-        flake8_implicit_str_concat::rules::implicit(context, tokens, locator, indexer, settings);
+        flake8_implicit_str_concat::rules::implicit(context, tokens, locator, indexer);
     }
 
     if context.any_rule_enabled(&[

crates/ruff_linter/src/importer/insertion.rs

@@ -56,13 +56,19 @@ impl<'a> Insertion<'a> {
         stylist: &Stylist,
     ) -> Insertion<'static> {
         // Skip over any docstrings.
-        let mut location = if let Some(location) = match_docstring_end(body) {
+        let mut location = if let Some(mut location) = match_docstring_end(body) {
             // If the first token after the docstring is a semicolon, insert after the semicolon as
             // an inline statement.
             if let Some(offset) = match_semicolon(locator.after(location)) {
                 return Insertion::inline(" ", location.add(offset).add(TextSize::of(';')), ";");
             }
 
+            // If the first token after the docstring is a continuation character (i.e. "\"), advance
+            // an additional row to prevent inserting in the same logical line.
+            if match_continuation(locator.after(location)).is_some() {
+                location = locator.full_line_end(location);
+            }
+
             // Otherwise, advance to the next row.
             locator.full_line_end(location)
         } else {
@@ -363,6 +369,16 @@ mod tests {
             Insertion::own_line("", TextSize::from(20), "\n")
         );
 
+        let contents = r#"
+"""Hello, world!"""\
+
+"#
+        .trim_start();
+        assert_eq!(
+            insert(contents)?,
+            Insertion::own_line("", TextSize::from(22), "\n")
+        );
+
         let contents = r"
 x = 1
 "

crates/ruff_linter/src/linter.rs

@@ -188,7 +188,6 @@ pub fn check_path(
             locator,
             indexer,
             stylist,
-            settings,
             source_type,
             source_kind.as_ipy_notebook().map(Notebook::cell_offsets),
             &mut context,

crates/ruff_linter/src/locator.rs

@@ -118,86 +118,6 @@ impl<'a> Locator<'a> {
         }
     }
 
-    /// Finds the closest [`TextSize`] not less than the offset given for which
-    /// `is_char_boundary` is `true`. Unless the offset given is greater than
-    /// the length of the underlying contents, in which case, the length of the
-    /// contents is returned.
-    ///
-    /// Can be replaced with `str::ceil_char_boundary` once it's stable.
-    ///
-    /// # Examples
-    ///
-    /// From `std`:
-    ///
-    /// ```
-    /// use ruff_text_size::{Ranged, TextSize};
-    /// use ruff_linter::Locator;
-    ///
-    /// let locator = Locator::new("❤️🧡💛💚💙💜");
-    /// assert_eq!(locator.text_len(), TextSize::from(26));
-    /// assert!(!locator.contents().is_char_boundary(13));
-    ///
-    /// let closest = locator.ceil_char_boundary(TextSize::from(13));
-    /// assert_eq!(closest, TextSize::from(14));
-    /// assert_eq!(&locator.contents()[..closest.to_usize()], "❤️🧡💛");
-    /// ```
-    ///
-    /// Additional examples:
-    ///
-    /// ```
-    /// use ruff_text_size::{Ranged, TextRange, TextSize};
-    /// use ruff_linter::Locator;
-    ///
-    /// let locator = Locator::new("Hello");
-    ///
-    /// assert_eq!(
-    ///     locator.ceil_char_boundary(TextSize::from(0)),
-    ///     TextSize::from(0)
-    /// );
-    ///
-    /// assert_eq!(
-    ///     locator.ceil_char_boundary(TextSize::from(5)),
-    ///     TextSize::from(5)
-    /// );
-    ///
-    /// assert_eq!(
-    ///     locator.ceil_char_boundary(TextSize::from(6)),
-    ///     TextSize::from(5)
-    /// );
-    ///
-    /// let locator = Locator::new("α");
-    ///
-    /// assert_eq!(
-    ///     locator.ceil_char_boundary(TextSize::from(0)),
-    ///     TextSize::from(0)
-    /// );
-    ///
-    /// assert_eq!(
-    ///     locator.ceil_char_boundary(TextSize::from(1)),
-    ///     TextSize::from(2)
-    /// );
-    ///
-    /// assert_eq!(
-    ///     locator.ceil_char_boundary(TextSize::from(2)),
-    ///     TextSize::from(2)
-    /// );
-    ///
-    /// assert_eq!(
-    ///     locator.ceil_char_boundary(TextSize::from(3)),
-    ///     TextSize::from(2)
-    /// );
-    /// ```
-    pub fn ceil_char_boundary(&self, offset: TextSize) -> TextSize {
-        let upper_bound = offset
-            .to_u32()
-            .saturating_add(4)
-            .min(self.text_len().to_u32());
-        (offset.to_u32()..upper_bound)
-            .map(TextSize::from)
-            .find(|offset| self.contents.is_char_boundary(offset.to_usize()))
-            .unwrap_or_else(|| TextSize::from(upper_bound))
-    }
-
     /// Take the source code between the given [`TextRange`].
     #[inline]
     pub fn slice<T: Ranged>(&self, ranged: T) -> &'a str {

crates/ruff_linter/src/message/gitlab.rs

@@ -61,22 +61,17 @@ impl Serialize for SerializedMessages<'_> {
         let mut fingerprints = HashSet::<u64>::with_capacity(self.diagnostics.len());
 
         for diagnostic in self.diagnostics {
-            let start_location = diagnostic.expect_ruff_start_location();
-            let end_location = diagnostic.expect_ruff_end_location();
-
             let filename = diagnostic.expect_ruff_filename();
-            let lines = if self.context.is_notebook(&filename) {
+
+            let (start_location, end_location) = if self.context.is_notebook(&filename) {
                 // We can't give a reasonable location for the structured formats,
                 // so we show one that's clearly a fallback
-                json!({
-                    "begin": 1,
-                    "end": 1
-                })
+                Default::default()
             } else {
-                json!({
-                    "begin": start_location.line,
-                    "end": end_location.line
-                })
+                (
+                    diagnostic.expect_ruff_start_location(),
+                    diagnostic.expect_ruff_end_location(),
+                )
             };
 
             let path = self.project_dir.as_ref().map_or_else(
@@ -111,8 +106,11 @@ impl Serialize for SerializedMessages<'_> {
                 "fingerprint": format!("{:x}", message_fingerprint),
                 "location": {
                     "path": path,
-                    "lines": lines
-                }
+                    "positions": {
+                        "begin": start_location,
+                        "end": end_location,
+                    },
+                },
             });
 
             s.serialize_element(&value)?;

crates/ruff_linter/src/message/snapshots/ruff_linter__message__gitlab__tests__output.snap

@@ -8,11 +8,17 @@ expression: redact_fingerprint(&content)
     "description": "`os` imported but unused",
     "fingerprint": "<redacted>",
     "location": {
-      "lines": {
-        "begin": 1,
-        "end": 1
-      },
-      "path": "fib.py"
+      "path": "fib.py",
+      "positions": {
+        "begin": {
+          "column": 8,
+          "line": 1
+        },
+        "end": {
+          "column": 10,
+          "line": 1
+        }
+      }
     },
     "severity": "major"
   },
@@ -21,11 +27,17 @@ expression: redact_fingerprint(&content)
     "description": "Local variable `x` is assigned to but never used",
     "fingerprint": "<redacted>",
     "location": {
-      "lines": {
-        "begin": 6,
-        "end": 6
-      },
-      "path": "fib.py"
+      "path": "fib.py",
+      "positions": {
+        "begin": {
+          "column": 5,
+          "line": 6
+        },
+        "end": {
+          "column": 6,
+          "line": 6
+        }
+      }
     },
     "severity": "major"
   },
@@ -34,11 +46,17 @@ expression: redact_fingerprint(&content)
     "description": "Undefined name `a`",
     "fingerprint": "<redacted>",
     "location": {
-      "lines": {
-        "begin": 1,
-        "end": 1
-      },
-      "path": "undef.py"
+      "path": "undef.py",
+      "positions": {
+        "begin": {
+          "column": 4,
+          "line": 1
+        },
+        "end": {
+          "column": 5,
+          "line": 1
+        }
+      }
     },
     "severity": "major"
   }

crates/ruff_linter/src/message/snapshots/ruff_linter__message__gitlab__tests__syntax_errors.snap

@@ -8,11 +8,17 @@ expression: redact_fingerprint(&content)
     "description": "Expected one or more symbol names after import",
     "fingerprint": "<redacted>",
     "location": {
-      "lines": {
-        "begin": 1,
-        "end": 2
-      },
-      "path": "syntax_errors.py"
+      "path": "syntax_errors.py",
+      "positions": {
+        "begin": {
+          "column": 15,
+          "line": 1
+        },
+        "end": {
+          "column": 1,
+          "line": 2
+        }
+      }
     },
     "severity": "major"
   },
@@ -21,11 +27,17 @@ expression: redact_fingerprint(&content)
     "description": "Expected ')', found newline",
     "fingerprint": "<redacted>",
     "location": {
-      "lines": {
-        "begin": 3,
-        "end": 4
-      },
-      "path": "syntax_errors.py"
+      "path": "syntax_errors.py",
+      "positions": {
+        "begin": {
+          "column": 12,
+          "line": 3
+        },
+        "end": {
+          "column": 1,
+          "line": 4
+        }
+      }
     },
     "severity": "major"
   }

crates/ruff_linter/src/message/snapshots/ruff_linter__message__sarif__tests__results.snap

@@ -81,7 +81,7 @@ expression: value
           "rules": [
             {
               "fullDescription": {
-                "text": "## What it does\nChecks for unused imports.\n\n## Why is this bad?\nUnused imports add a performance overhead at runtime, and risk creating\nimport cycles. They also increase the cognitive load of reading the code.\n\nIf an import statement is used to check for the availability or existence\nof a module, consider using `importlib.util.find_spec` instead.\n\nIf an import statement is used to re-export a symbol as part of a module's\npublic interface, consider using a \"redundant\" import alias, which\ninstructs Ruff (and other tools) to respect the re-export, and avoid\nmarking it as unused, as in:\n\n```python\nfrom module import member as member\n```\n\nAlternatively, you can use `__all__` to declare a symbol as part of the module's\ninterface, as in:\n\n```python\n# __init__.py\nimport some_module\n\n__all__ = [\"some_module\"]\n```\n\n## Fix safety\n\nFixes to remove unused imports are safe, except in `__init__.py` files.\n\nApplying fixes to `__init__.py` files is currently in preview. The fix offered depends on the\ntype of the unused import. Ruff will suggest a safe fix to export first-party imports with\neither a redundant alias or, if already present in the file, an `__all__` entry. If multiple\n`__all__` declarations are present, Ruff will not offer a fix. Ruff will suggest an unsafe fix\nto remove third-party and standard library imports -- the fix is unsafe because the module's\ninterface changes.\n\n## Example\n\n```python\nimport numpy as np  # unused import\n\n\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nUse instead:\n\n```python\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nTo check the availability of a module, use `importlib.util.find_spec`:\n\n```python\nfrom importlib.util import find_spec\n\nif find_spec(\"numpy\") is not None:\n    print(\"numpy is installed\")\nelse:\n    print(\"numpy is not installed\")\n```\n\n## Preview\nWhen [preview](https://docs.astral.sh/ruff/preview/) is enabled,\nthe criterion for determining whether an import is first-party\nis stricter, which could affect the suggested fix. See [this FAQ section](https://docs.astral.sh/ruff/faq/#how-does-ruff-determine-which-of-my-imports-are-first-party-third-party-etc) for more details.\n\n## Options\n- `lint.ignore-init-module-imports`\n- `lint.pyflakes.allowed-unused-imports`\n\n## References\n- [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)\n- [Python documentation: `importlib.util.find_spec`](https://docs.python.org/3/library/importlib.html#importlib.util.find_spec)\n- [Typing documentation: interface conventions](https://typing.python.org/en/latest/source/libraries.html#library-interface-public-and-private-symbols)\n"
+                "text": "## What it does\nChecks for unused imports.\n\n## Why is this bad?\nUnused imports add a performance overhead at runtime, and risk creating\nimport cycles. They also increase the cognitive load of reading the code.\n\nIf an import statement is used to check for the availability or existence\nof a module, consider using `importlib.util.find_spec` instead.\n\nIf an import statement is used to re-export a symbol as part of a module's\npublic interface, consider using a \"redundant\" import alias, which\ninstructs Ruff (and other tools) to respect the re-export, and avoid\nmarking it as unused, as in:\n\n```python\nfrom module import member as member\n```\n\nAlternatively, you can use `__all__` to declare a symbol as part of the module's\ninterface, as in:\n\n```python\n# __init__.py\nimport some_module\n\n__all__ = [\"some_module\"]\n```\n\n## Fix safety\n\nFixes to remove unused imports are safe, except in `__init__.py` files.\n\nApplying fixes to `__init__.py` files is currently in preview. The fix offered depends on the\ntype of the unused import. Ruff will suggest a safe fix to export first-party imports with\neither a redundant alias or, if already present in the file, an `__all__` entry. If multiple\n`__all__` declarations are present, Ruff will not offer a fix. Ruff will suggest an unsafe fix\nto remove third-party and standard library imports -- the fix is unsafe because the module's\ninterface changes.\n\n## Example\n\n```python\nimport numpy as np  # unused import\n\n\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nUse instead:\n\n```python\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nTo check the availability of a module, use `importlib.util.find_spec`:\n\n```python\nfrom importlib.util import find_spec\n\nif find_spec(\"numpy\") is not None:\n    print(\"numpy is installed\")\nelse:\n    print(\"numpy is not installed\")\n```\n\n## Preview\nWhen [preview](https://docs.astral.sh/ruff/preview/) is enabled,\nthe criterion for determining whether an import is first-party\nis stricter, which could affect the suggested fix. See [this FAQ section](https://docs.astral.sh/ruff/faq/#how-does-ruff-determine-which-of-my-imports-are-first-party-third-party-etc) for more details.\n\n## Options\n- `lint.ignore-init-module-imports`\n- `lint.pyflakes.allowed-unused-imports`\n\n## References\n- [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)\n- [Python documentation: `importlib.util.find_spec`](https://docs.python.org/3/library/importlib.html#importlib.util.find_spec)\n- [Typing documentation: interface conventions](https://typing.python.org/en/latest/spec/distributing.html#library-interface-public-and-private-symbols)\n"
               },
               "help": {
                 "text": "`{name}` imported but unused; consider using `importlib.util.find_spec` to test for availability"

crates/ruff_linter/src/message/text.rs

@@ -6,13 +6,13 @@ use bitflags::bitflags;
 use colored::Colorize;
 use ruff_annotate_snippets::{Level, Renderer, Snippet};
 
-use ruff_db::diagnostic::{Diagnostic, DiagnosticFormat, DisplayDiagnosticConfig, SecondaryCode};
+use ruff_db::diagnostic::{
+    Diagnostic, DiagnosticFormat, DisplayDiagnosticConfig, SecondaryCode, ceil_char_boundary,
+};
 use ruff_notebook::NotebookIndex;
 use ruff_source_file::OneIndexed;
 use ruff_text_size::{TextLen, TextRange, TextSize};
 
-use crate::Locator;
-use crate::line_width::{IndentWidth, LineWidthBuilder};
 use crate::message::diff::Diff;
 use crate::message::{Emitter, EmitterContext};
 use crate::settings::types::UnsafeFixes;
@@ -228,7 +228,7 @@ impl Display for MessageCodeFrame<'_> {
         let start_offset = source_code.line_start(start_index);
         let end_offset = source_code.line_end(end_index);
 
-        let source = replace_whitespace_and_unprintable(
+        let source = replace_unprintable(
             source_code.slice(TextRange::new(start_offset, end_offset)),
             self.message.expect_range() - start_offset,
         )
@@ -271,16 +271,20 @@ impl Display for MessageCodeFrame<'_> {
 }
 
 /// Given some source code and an annotation range, this routine replaces
-/// tabs with ASCII whitespace, and unprintable characters with printable
-/// representations of them.
+///  unprintable characters with printable representations of them.
 ///
 /// The source code returned has an annotation that is updated to reflect
 /// changes made to the source code (if any).
-fn replace_whitespace_and_unprintable(source: &str, annotation_range: TextRange) -> SourceCode {
+///
+/// We don't need to normalize whitespace, such as converting tabs to spaces,
+/// because `annotate-snippets` handles that internally. Similarly, it's safe to
+/// modify the annotation ranges by inserting 3-byte Unicode replacements
+/// because `annotate-snippets` will account for their actual width when
+/// rendering and displaying the column to the user.
+fn replace_unprintable(source: &str, annotation_range: TextRange) -> SourceCode {
     let mut result = String::new();
     let mut last_end = 0;
     let mut range = annotation_range;
-    let mut line_width = LineWidthBuilder::new(IndentWidth::default());
 
     // Updates the range given by the caller whenever a single byte (at
     // `index` in `source`) is replaced with `len` bytes.
@@ -309,19 +313,7 @@ fn replace_whitespace_and_unprintable(source: &str, annotation_range: TextRange)
     };
 
     for (index, c) in source.char_indices() {
-        let old_width = line_width.get();
-        line_width = line_width.add_char(c);
-
-        if matches!(c, '\t') {
-            let tab_width = u32::try_from(line_width.get() - old_width)
-                .expect("small width because of tab size");
-            result.push_str(&source[last_end..index]);
-            for _ in 0..tab_width {
-                result.push(' ');
-            }
-            last_end = index + 1;
-            update_range(index, tab_width);
-        } else if let Some(printable) = unprintable_replacement(c) {
+        if let Some(printable) = unprintable_replacement(c) {
             result.push_str(&source[last_end..index]);
             result.push(printable);
             last_end = index + 1;
@@ -376,9 +368,8 @@ impl<'a> SourceCode<'a> {
         if self.text.as_bytes()[self.annotation_range.start().to_usize() - 1] != b'\n' {
             return self;
         }
-        let locator = Locator::new(&self.text);
         let start = self.annotation_range.start();
-        let end = locator.ceil_char_boundary(start + TextSize::from(1));
+        let end = ceil_char_boundary(&self.text, start + TextSize::from(1));
         SourceCode {
             annotation_range: TextRange::new(start, end),
             ..self

crates/ruff_linter/src/preview.rs

@@ -225,3 +225,8 @@ pub(crate) const fn is_assert_raises_exception_call_enabled(settings: &LinterSet
 pub(crate) const fn is_add_future_annotations_imports_enabled(settings: &LinterSettings) -> bool {
     settings.preview.is_enabled()
 }
+
+// https://github.com/astral-sh/ruff/pull/19390
+pub(crate) const fn is_trailing_comma_type_params_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}

crates/ruff_linter/src/rules/eradicate/detection.rs

@@ -21,6 +21,7 @@ static ALLOWLIST_REGEX: LazyLock<Regex> = LazyLock::new(|| {
         (?:
             # Case-sensitive
             pyright
+        |   pyrefly
         |   mypy:
         |   type:\s*ignore
         |   SPDX-License-Identifier:

crates/ruff_linter/src/rules/eradicate/rules/commented_out_code.rs

@@ -5,7 +5,6 @@ use ruff_text_size::TextRange;
 
 use crate::Locator;
 use crate::checkers::ast::LintContext;
-use crate::settings::LinterSettings;
 use crate::{Edit, Fix, FixAvailability, Violation};
 
 use crate::rules::eradicate::detection::comment_contains_code;
@@ -51,7 +50,6 @@ pub(crate) fn commented_out_code(
     context: &LintContext,
     locator: &Locator,
     comment_ranges: &CommentRanges,
-    settings: &LinterSettings,
 ) {
     let mut comments = comment_ranges.into_iter().peekable();
     // Iterate over all comments in the document.
@@ -65,7 +63,9 @@ pub(crate) fn commented_out_code(
         }
 
         // Verify that the comment is on its own line, and that it contains code.
-        if is_own_line_comment(line) && comment_contains_code(line, &settings.task_tags[..]) {
+        if is_own_line_comment(line)
+            && comment_contains_code(line, &context.settings().task_tags[..])
+        {
             if let Some(mut diagnostic) =
                 context.report_diagnostic_if_enabled(CommentedOutCode, range)
             {

crates/ruff_linter/src/rules/flake8_blind_except/rules/blind_except.rs

@@ -75,6 +75,22 @@ impl Violation for BlindExcept {
     }
 }
 
+fn contains_blind_exception<'a>(
+    semantic: &'a SemanticModel,
+    expr: &'a Expr,
+) -> Option<(&'a str, ruff_text_size::TextRange)> {
+    match expr {
+        Expr::Tuple(ast::ExprTuple { elts, .. }) => elts
+            .iter()
+            .find_map(|elt| contains_blind_exception(semantic, elt)),
+        _ => {
+            let builtin_exception_type = semantic.resolve_builtin_symbol(expr)?;
+            matches!(builtin_exception_type, "BaseException" | "Exception")
+                .then(|| (builtin_exception_type, expr.range()))
+        }
+    }
+}
+
 /// BLE001
 pub(crate) fn blind_except(
     checker: &Checker,
@@ -87,12 +103,9 @@ pub(crate) fn blind_except(
     };
 
     let semantic = checker.semantic();
-    let Some(builtin_exception_type) = semantic.resolve_builtin_symbol(type_) else {
+    let Some((builtin_exception_type, range)) = contains_blind_exception(semantic, type_) else {
         return;
     };
-    if !matches!(builtin_exception_type, "BaseException" | "Exception") {
-        return;
-    }
 
     // If the exception is re-raised, don't flag an error.
     let mut visitor = ReraiseVisitor::new(name);
@@ -110,9 +123,9 @@ pub(crate) fn blind_except(
 
     checker.report_diagnostic(
         BlindExcept {
-            name: builtin_exception_type.to_string(),
+            name: builtin_exception_type.into(),
         },
-        type_.range(),
+        range,
     );
 }
 

crates/ruff_linter/src/rules/flake8_blind_except/snapshots/ruff_linter__rules__flake8_blind_except__tests__BLE001_BLE.py.snap

@@ -147,3 +147,93 @@ BLE.py:131:8: BLE001 Do not catch blind exception: `Exception`
     |        ^^^^^^^^^ BLE001
 132 |     critical("...", exc_info=None)
     |
+
+BLE.py:169:9: BLE001 Do not catch blind exception: `Exception`
+    |
+167 | try:
+168 |     pass
+169 | except (Exception,):
+    |         ^^^^^^^^^ BLE001
+170 |     pass
+    |
+
+BLE.py:174:9: BLE001 Do not catch blind exception: `Exception`
+    |
+172 | try:
+173 |     pass
+174 | except (Exception, ValueError):
+    |         ^^^^^^^^^ BLE001
+175 |     pass
+    |
+
+BLE.py:179:21: BLE001 Do not catch blind exception: `Exception`
+    |
+177 | try:
+178 |     pass
+179 | except (ValueError, Exception):
+    |                     ^^^^^^^^^ BLE001
+180 |     pass
+    |
+
+BLE.py:184:21: BLE001 Do not catch blind exception: `Exception`
+    |
+182 | try:
+183 |     pass
+184 | except (ValueError, Exception) as e:
+    |                     ^^^^^^^^^ BLE001
+185 |     print(e)
+    |
+
+BLE.py:189:9: BLE001 Do not catch blind exception: `BaseException`
+    |
+187 | try:
+188 |     pass
+189 | except (BaseException, TypeError):
+    |         ^^^^^^^^^^^^^ BLE001
+190 |     pass
+    |
+
+BLE.py:194:20: BLE001 Do not catch blind exception: `BaseException`
+    |
+192 | try:
+193 |     pass
+194 | except (TypeError, BaseException):
+    |                    ^^^^^^^^^^^^^ BLE001
+195 |     pass
+    |
+
+BLE.py:199:9: BLE001 Do not catch blind exception: `Exception`
+    |
+197 | try:
+198 |     pass
+199 | except (Exception, BaseException):
+    |         ^^^^^^^^^ BLE001
+200 |     pass
+    |
+
+BLE.py:204:9: BLE001 Do not catch blind exception: `BaseException`
+    |
+202 | try:
+203 |     pass
+204 | except (BaseException, Exception):
+    |         ^^^^^^^^^^^^^ BLE001
+205 |     pass
+    |
+
+BLE.py:210:10: BLE001 Do not catch blind exception: `Exception`
+    |
+208 | try:
+209 |     pass
+210 | except ((Exception, ValueError), TypeError):
+    |          ^^^^^^^^^ BLE001
+211 |     pass
+    |
+
+BLE.py:215:22: BLE001 Do not catch blind exception: `BaseException`
+    |
+213 | try:
+214 |     pass
+215 | except (ValueError, (BaseException, TypeError)):
+    |                      ^^^^^^^^^^^^^ BLE001
+216 |     pass
+    |

crates/ruff_linter/src/rules/flake8_commas/mod.rs

@@ -27,4 +27,23 @@ mod tests {
         assert_diagnostics!(snapshot, diagnostics);
         Ok(())
     }
+
+    #[test_case(Path::new("COM81.py"))]
+    #[test_case(Path::new("COM81_syntax_error.py"))]
+    fn preview_rules(path: &Path) -> Result<()> {
+        let snapshot = format!("preview__{}", path.to_string_lossy());
+        let diagnostics = test_path(
+            Path::new("flake8_commas").join(path).as_path(),
+            &settings::LinterSettings {
+                preview: crate::settings::types::PreviewMode::Enabled,
+                ..settings::LinterSettings::for_rules(vec![
+                    Rule::MissingTrailingComma,
+                    Rule::TrailingCommaOnBareTuple,
+                    Rule::ProhibitedTrailingComma,
+                ])
+            },
+        )?;
+        assert_diagnostics!(snapshot, diagnostics);
+        Ok(())
+    }
 }

crates/ruff_linter/src/rules/flake8_commas/rules/trailing_commas.rs

@@ -5,6 +5,8 @@ use ruff_text_size::{Ranged, TextRange};
 
 use crate::Locator;
 use crate::checkers::ast::LintContext;
+use crate::preview::is_trailing_comma_type_params_enabled;
+use crate::settings::LinterSettings;
 use crate::{AlwaysFixableViolation, Violation};
 use crate::{Edit, Fix};
 
@@ -24,6 +26,8 @@ enum TokenType {
     Def,
     For,
     Lambda,
+    Class,
+    Type,
     Irrelevant,
 }
 
@@ -69,6 +73,8 @@ impl From<(TokenKind, TextRange)> for SimpleToken {
             TokenKind::Lbrace => TokenType::OpeningCurlyBracket,
             TokenKind::Rbrace => TokenType::ClosingBracket,
             TokenKind::Def => TokenType::Def,
+            TokenKind::Class => TokenType::Class,
+            TokenKind::Type => TokenType::Type,
             TokenKind::For => TokenType::For,
             TokenKind::Lambda => TokenType::Lambda,
             // Import treated like a function.
@@ -98,6 +104,8 @@ enum ContextType {
     Dict,
     /// Lambda parameter list, e.g. `lambda a, b`.
     LambdaParameters,
+    /// Type parameter list, e.g. `def foo[T, U](): ...`
+    TypeParameters,
 }
 
 /// Comma context - described a comma-delimited "situation".
@@ -290,7 +298,7 @@ pub(crate) fn trailing_commas(
         }
 
         // Update the comma context stack.
-        let context = update_context(token, prev, prev_prev, &mut stack);
+        let context = update_context(token, prev, prev_prev, &mut stack, lint_context.settings());
 
         check_token(token, prev, prev_prev, context, locator, lint_context);
 
@@ -326,6 +334,7 @@ fn check_token(
             ContextType::No => false,
             ContextType::FunctionParameters => true,
             ContextType::CallArguments => true,
+            ContextType::TypeParameters => true,
             // `(1)` is not equivalent to `(1,)`.
             ContextType::Tuple => context.num_commas != 0,
             // `x[1]` is not equivalent to `x[1,]`.
@@ -408,6 +417,7 @@ fn update_context(
     prev: SimpleToken,
     prev_prev: SimpleToken,
     stack: &mut Vec<Context>,
+    settings: &LinterSettings,
 ) -> Context {
     let new_context = match token.ty {
         TokenType::OpeningBracket => match (prev.ty, prev_prev.ty) {
@@ -417,6 +427,17 @@ fn update_context(
             }
             _ => Context::new(ContextType::Tuple),
         },
+        TokenType::OpeningSquareBracket if is_trailing_comma_type_params_enabled(settings) => {
+            match (prev.ty, prev_prev.ty) {
+                (TokenType::Named, TokenType::Def | TokenType::Class | TokenType::Type) => {
+                    Context::new(ContextType::TypeParameters)
+                }
+                (TokenType::ClosingBracket | TokenType::Named | TokenType::String, _) => {
+                    Context::new(ContextType::Subscript)
+                }
+                _ => Context::new(ContextType::List),
+            }
+        }
         TokenType::OpeningSquareBracket => match prev.ty {
             TokenType::ClosingBracket | TokenType::Named | TokenType::String => {
                 Context::new(ContextType::Subscript)

crates/ruff_linter/src/rules/flake8_commas/snapshots/ruff_linter__rules__flake8_commas__tests__preview__COM81_syntax_error.py.snap

@@ -0,0 +1,30 @@
+---
+source: crates/ruff_linter/src/rules/flake8_commas/mod.rs
+---
+COM81_syntax_error.py:3:5: SyntaxError: Starred expression cannot be used here
+  |
+1 | # Check for `flake8-commas` violation for a file containing syntax errors.
+2 | (
+3 |     *args
+  |     ^^^^^
+4 | )
+  |
+
+COM81_syntax_error.py:6:9: SyntaxError: Type parameter list cannot be empty
+  |
+4 | )
+5 |
+6 | def foo[(param1='test', param2='test',):
+  |         ^
+7 |     pass
+  |
+
+COM81_syntax_error.py:6:38: COM819 Trailing comma prohibited
+  |
+4 | )
+5 |
+6 | def foo[(param1='test', param2='test',):
+  |                                      ^ COM819
+7 |     pass
+  |
+  = help: Remove trailing comma

crates/ruff_linter/src/rules/flake8_errmsg/rules/string_in_exception.rs

@@ -182,60 +182,27 @@ impl Violation for DotFormatInException {
 
 /// EM101, EM102, EM103
 pub(crate) fn string_in_exception(checker: &Checker, stmt: &Stmt, exc: &Expr) {
-    if let Expr::Call(ast::ExprCall {
+    let Expr::Call(ast::ExprCall {
+        func,
         arguments: Arguments { args, .. },
         ..
     }) = exc
-    {
-        if let Some(first) = args.first() {
-            match first {
-                // Check for string literals.
-                Expr::StringLiteral(ast::ExprStringLiteral { value: string, .. }) => {
-                    if checker.is_rule_enabled(Rule::RawStringInException) {
-                        if string.len() >= checker.settings().flake8_errmsg.max_string_length {
-                            let mut diagnostic =
-                                checker.report_diagnostic(RawStringInException, first.range());
-                            if let Some(indentation) =
-                                whitespace::indentation(checker.source(), stmt)
-                            {
-                                diagnostic.set_fix(generate_fix(
-                                    stmt,
-                                    first,
-                                    indentation,
-                                    checker.stylist(),
-                                    checker.locator(),
-                                ));
-                            }
-                        }
-                    }
-                }
-                // Check for byte string literals.
-                Expr::BytesLiteral(ast::ExprBytesLiteral { value: bytes, .. }) => {
-                    if checker.settings().rules.enabled(Rule::RawStringInException) {
-                        if bytes.len() >= checker.settings().flake8_errmsg.max_string_length
-                            && is_raise_exception_byte_string_enabled(checker.settings())
-                        {
-                            let mut diagnostic =
-                                checker.report_diagnostic(RawStringInException, first.range());
-                            if let Some(indentation) =
-                                whitespace::indentation(checker.source(), stmt)
-                            {
-                                diagnostic.set_fix(generate_fix(
-                                    stmt,
-                                    first,
-                                    indentation,
-                                    checker.stylist(),
-                                    checker.locator(),
-                                ));
-                            }
-                        }
-                    }
-                }
-                // Check for f-strings.
-                Expr::FString(_) => {
-                    if checker.is_rule_enabled(Rule::FStringInException) {
+    else {
+        return;
+    };
+
+    if checker.semantic().match_typing_expr(func, "cast") {
+        return;
+    }
+
+    if let Some(first) = args.first() {
+        match first {
+            // Check for string literals.
+            Expr::StringLiteral(ast::ExprStringLiteral { value: string, .. }) => {
+                if checker.is_rule_enabled(Rule::RawStringInException) {
+                    if string.len() >= checker.settings().flake8_errmsg.max_string_length {
                         let mut diagnostic =
-                            checker.report_diagnostic(FStringInException, first.range());
+                            checker.report_diagnostic(RawStringInException, first.range());
                         if let Some(indentation) = whitespace::indentation(checker.source(), stmt) {
                             diagnostic.set_fix(generate_fix(
                                 stmt,
@@ -247,32 +214,66 @@ pub(crate) fn string_in_exception(checker: &Checker, stmt: &Stmt, exc: &Expr) {
                         }
                     }
                 }
-                // Check for .format() calls.
-                Expr::Call(ast::ExprCall { func, .. }) => {
-                    if checker.is_rule_enabled(Rule::DotFormatInException) {
-                        if let Expr::Attribute(ast::ExprAttribute { value, attr, .. }) =
-                            func.as_ref()
-                        {
-                            if attr == "format" && value.is_literal_expr() {
-                                let mut diagnostic =
-                                    checker.report_diagnostic(DotFormatInException, first.range());
-                                if let Some(indentation) =
-                                    whitespace::indentation(checker.source(), stmt)
-                                {
-                                    diagnostic.set_fix(generate_fix(
-                                        stmt,
-                                        first,
-                                        indentation,
-                                        checker.stylist(),
-                                        checker.locator(),
-                                    ));
-                                }
+            }
+            // Check for byte string literals.
+            Expr::BytesLiteral(ast::ExprBytesLiteral { value: bytes, .. }) => {
+                if checker.settings().rules.enabled(Rule::RawStringInException) {
+                    if bytes.len() >= checker.settings().flake8_errmsg.max_string_length
+                        && is_raise_exception_byte_string_enabled(checker.settings())
+                    {
+                        let mut diagnostic =
+                            checker.report_diagnostic(RawStringInException, first.range());
+                        if let Some(indentation) = whitespace::indentation(checker.source(), stmt) {
+                            diagnostic.set_fix(generate_fix(
+                                stmt,
+                                first,
+                                indentation,
+                                checker.stylist(),
+                                checker.locator(),
+                            ));
+                        }
+                    }
+                }
+            }
+            // Check for f-strings.
+            Expr::FString(_) => {
+                if checker.is_rule_enabled(Rule::FStringInException) {
+                    let mut diagnostic =
+                        checker.report_diagnostic(FStringInException, first.range());
+                    if let Some(indentation) = whitespace::indentation(checker.source(), stmt) {
+                        diagnostic.set_fix(generate_fix(
+                            stmt,
+                            first,
+                            indentation,
+                            checker.stylist(),
+                            checker.locator(),
+                        ));
+                    }
+                }
+            }
+            // Check for .format() calls.
+            Expr::Call(ast::ExprCall { func, .. }) => {
+                if checker.is_rule_enabled(Rule::DotFormatInException) {
+                    if let Expr::Attribute(ast::ExprAttribute { value, attr, .. }) = func.as_ref() {
+                        if attr == "format" && value.is_literal_expr() {
+                            let mut diagnostic =
+                                checker.report_diagnostic(DotFormatInException, first.range());
+                            if let Some(indentation) =
+                                whitespace::indentation(checker.source(), stmt)
+                            {
+                                diagnostic.set_fix(generate_fix(
+                                    stmt,
+                                    first,
+                                    indentation,
+                                    checker.stylist(),
+                                    checker.locator(),
+                                ));
                             }
                         }
                     }
                 }
-                _ => {}
             }
+            _ => {}
         }
     }
 }

crates/ruff_linter/src/rules/flake8_errmsg/snapshots/ruff_linter__rules__flake8_errmsg__tests__custom.snap

@@ -278,3 +278,6 @@ EM.py:84:9: EM103 [*] Exception must not use a `.format()` string directly, assi
    91 |+    raise RuntimeError(
    92 |+        msg
    93 |+    )
+91 94 | 
+92 95 | 
+93 96 | def raise_typing_cast_exception():

crates/ruff_linter/src/rules/flake8_errmsg/snapshots/ruff_linter__rules__flake8_errmsg__tests__defaults.snap

@@ -343,3 +343,6 @@ EM.py:84:9: EM103 [*] Exception must not use a `.format()` string directly, assi
    91 |+    raise RuntimeError(
    92 |+        msg
    93 |+    )
+91 94 | 
+92 95 | 
+93 96 | def raise_typing_cast_exception():

crates/ruff_linter/src/rules/flake8_implicit_str_concat/rules/implicit.rs

@@ -11,7 +11,6 @@ use ruff_text_size::{Ranged, TextRange};
 
 use crate::Locator;
 use crate::checkers::ast::LintContext;
-use crate::settings::LinterSettings;
 use crate::{Edit, Fix, FixAvailability, Violation};
 
 /// ## What it does
@@ -108,13 +107,15 @@ pub(crate) fn implicit(
     tokens: &Tokens,
     locator: &Locator,
     indexer: &Indexer,
-    settings: &LinterSettings,
 ) {
     for (a_token, b_token) in tokens
         .iter()
         .filter(|token| {
             token.kind() != TokenKind::Comment
-                && (settings.flake8_implicit_str_concat.allow_multiline
+                && (context
+                    .settings()
+                    .flake8_implicit_str_concat
+                    .allow_multiline
                     || token.kind() != TokenKind::NonLogicalNewline)
         })
         .tuple_windows()

crates/ruff_linter/src/rules/flake8_pyi/rules/ellipsis_in_non_empty_class_body.rs

@@ -1,10 +1,11 @@
 use ruff_macros::{ViolationMetadata, derive_message_formats};
+use ruff_python_ast::whitespace::trailing_comment_start_offset;
 use ruff_python_ast::{Stmt, StmtExpr};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::fix;
-use crate::{Fix, FixAvailability, Violation};
+use crate::{Edit, Fix, FixAvailability, Violation};
 
 /// ## What it does
 /// Removes ellipses (`...`) in otherwise non-empty class bodies.
@@ -50,15 +51,21 @@ pub(crate) fn ellipsis_in_non_empty_class_body(checker: &Checker, body: &[Stmt])
     }
 
     for stmt in body {
-        let Stmt::Expr(StmtExpr { value, .. }) = &stmt else {
+        let Stmt::Expr(StmtExpr { value, .. }) = stmt else {
             continue;
         };
 
         if value.is_ellipsis_literal_expr() {
             let mut diagnostic =
                 checker.report_diagnostic(EllipsisInNonEmptyClassBody, stmt.range());
-            let edit =
-                fix::edits::delete_stmt(stmt, Some(stmt), checker.locator(), checker.indexer());
+
+            // Try to preserve trailing comment if it exists
+            let edit = if let Some(index) = trailing_comment_start_offset(stmt, checker.source()) {
+                Edit::range_deletion(stmt.range().add_end(index))
+            } else {
+                fix::edits::delete_stmt(stmt, Some(stmt), checker.locator(), checker.indexer())
+            };
+
             diagnostic.set_fix(Fix::safe_edit(edit).isolate(Checker::isolation(
                 checker.semantic().current_statement_id(),
             )));

crates/ruff_linter/src/rules/flake8_pyi/snapshots/ruff_linter__rules__flake8_pyi__tests__PYI013_PYI013.py.snap

@@ -145,3 +145,22 @@ PYI013.py:36:5: PYI013 [*] Non-empty class body must not contain `...`
 37 36 | 
 38 37 |     def __init__():
 39 38 |         pass
+
+PYI013.py:44:5: PYI013 [*] Non-empty class body must not contain `...`
+   |
+42 | class NonEmptyChildWithInlineComment:
+43 |     value: int
+44 |     ... # preserve me
+   |     ^^^ PYI013
+   |
+   = help: Remove unnecessary `...`
+
+ℹ Safe fix
+41 41 | 
+42 42 | class NonEmptyChildWithInlineComment:
+43 43 |     value: int
+44    |-    ... # preserve me
+   44 |+    # preserve me
+45 45 | 
+46 46 | 
+47 47 | class EmptyClass:

crates/ruff_linter/src/rules/flake8_pyi/snapshots/ruff_linter__rules__flake8_pyi__tests__PYI013_PYI013.pyi.snap

@@ -17,9 +17,10 @@ PYI013.pyi:5:5: PYI013 [*] Non-empty class body must not contain `...`
 3 3 | class OneAttributeClass:
 4 4 |     value: int
 5   |-    ...  # Error
-6 5 | 
-7 6 | class OneAttributeClass2:
-8 7 |     ...  # Error
+  5 |+    # Error
+6 6 | 
+7 7 | class OneAttributeClass2:
+8 8 |     ...  # Error
 
 PYI013.pyi:8:5: PYI013 [*] Non-empty class body must not contain `...`
   |
@@ -35,9 +36,10 @@ PYI013.pyi:8:5: PYI013 [*] Non-empty class body must not contain `...`
 6 6 | 
 7 7 | class OneAttributeClass2:
 8   |-    ...  # Error
-9 8 |     value: int
-10 9 | 
-11 10 | class MyClass:
+  8 |+    # Error
+9 9 |     value: int
+10 10 | 
+11 11 | class MyClass:
 
 PYI013.pyi:12:5: PYI013 [*] Non-empty class body must not contain `...`
    |
@@ -91,9 +93,10 @@ PYI013.pyi:17:5: PYI013 [*] Non-empty class body must not contain `...`
 15 15 | class TwoEllipsesClass:
 16 16 |     ...
 17    |-    ...  # Error
-18 17 | 
-19 18 | class DocstringClass:
-20 19 |     """
+   17 |+    # Error
+18 18 | 
+19 19 | class DocstringClass:
+20 20 |     """
 
 PYI013.pyi:24:5: PYI013 [*] Non-empty class body must not contain `...`
    |
@@ -111,9 +114,10 @@ PYI013.pyi:24:5: PYI013 [*] Non-empty class body must not contain `...`
 22 22 |     """
 23 23 | 
 24    |-    ...  # Error
-25 24 | 
-26 25 | class NonEmptyChild(Exception):
-27 26 |     value: int
+   24 |+    # Error
+25 25 | 
+26 26 | class NonEmptyChild(Exception):
+27 27 |     value: int
 
 PYI013.pyi:28:5: PYI013 [*] Non-empty class body must not contain `...`
    |
@@ -131,9 +135,10 @@ PYI013.pyi:28:5: PYI013 [*] Non-empty class body must not contain `...`
 26 26 | class NonEmptyChild(Exception):
 27 27 |     value: int
 28    |-    ...  # Error
-29 28 | 
-30 29 | class NonEmptyChild2(Exception):
-31 30 |     ...  # Error
+   28 |+    # Error
+29 29 | 
+30 30 | class NonEmptyChild2(Exception):
+31 31 |     ...  # Error
 
 PYI013.pyi:31:5: PYI013 [*] Non-empty class body must not contain `...`
    |
@@ -149,9 +154,10 @@ PYI013.pyi:31:5: PYI013 [*] Non-empty class body must not contain `...`
 29 29 | 
 30 30 | class NonEmptyChild2(Exception):
 31    |-    ...  # Error
-32 31 |     value: int
-33 32 | 
-34 33 | class NonEmptyWithInit:
+   31 |+    # Error
+32 32 |     value: int
+33 33 | 
+34 34 | class NonEmptyWithInit:
 
 PYI013.pyi:36:5: PYI013 [*] Non-empty class body must not contain `...`
    |
@@ -169,6 +175,28 @@ PYI013.pyi:36:5: PYI013 [*] Non-empty class body must not contain `...`
 34 34 | class NonEmptyWithInit:
 35 35 |     value: int
 36    |-    ...  # Error
-37 36 | 
-38 37 |     def __init__():
-39 38 |         pass
+   36 |+    # Error
+37 37 | 
+38 38 |     def __init__():
+39 39 |         pass
+
+PYI013.pyi:43:5: PYI013 [*] Non-empty class body must not contain `...`
+   |
+41 | class NonEmptyChildWithInlineComment:
+42 |     value: int
+43 |     ... # preserve me
+   |     ^^^ PYI013
+44 |
+45 | # Not violations
+   |
+   = help: Remove unnecessary `...`
+
+ℹ Safe fix
+40 40 | 
+41 41 | class NonEmptyChildWithInlineComment:
+42 42 |     value: int
+43    |-    ... # preserve me
+   43 |+    # preserve me
+44 44 | 
+45 45 | # Not violations
+46 46 |

crates/ruff_linter/src/rules/flake8_simplify/rules/split_static_string.rs

@@ -1,6 +1,7 @@
 use std::cmp::Ordering;
 
 use ruff_macros::{ViolationMetadata, derive_message_formats};
+use ruff_python_ast::StringFlags;
 use ruff_python_ast::{
     Expr, ExprCall, ExprContext, ExprList, ExprUnaryOp, StringLiteral, StringLiteralFlags,
     StringLiteralValue, UnaryOp, str::TripleQuotes,
@@ -116,26 +117,50 @@ pub(crate) fn split_static_string(
     }
 }
 
+fn replace_flags(elt: &str, flags: StringLiteralFlags) -> StringLiteralFlags {
+    // In the ideal case we can wrap the element in _single_ quotes of the same
+    // style. For example, both of these are okay:
+    //
+    // ```python
+    // """itemA
+    // itemB
+    // itemC""".split() # -> ["itemA", "itemB", "itemC"]
+    // ```
+    //
+    // ```python
+    // r"""itemA
+    // 'single'quoted
+    // """.split() # -> [r"itemA",r"'single'quoted'"]
+    // ```
+    if !flags.prefix().is_raw() || !elt.contains(flags.quote_style().as_char()) {
+        flags.with_triple_quotes(TripleQuotes::No)
+    }
+    // If we have a raw string containing a quotation mark of the same style,
+    // then we have to swap the style of quotation marks used
+    else if !elt.contains(flags.quote_style().opposite().as_char()) {
+        flags
+            .with_quote_style(flags.quote_style().opposite())
+            .with_triple_quotes(TripleQuotes::No)
+    } else
+    // If both types of quotes are used in the raw, triple-quoted string, then
+    // we are forced to either add escapes or keep the triple quotes. We opt for
+    // the latter.
+    {
+        flags
+    }
+}
+
 fn construct_replacement(elts: &[&str], flags: StringLiteralFlags) -> Expr {
     Expr::List(ExprList {
         elts: elts
             .iter()
             .map(|elt| {
+                let element_flags = replace_flags(elt, flags);
                 Expr::from(StringLiteral {
                     value: Box::from(*elt),
                     range: TextRange::default(),
                     node_index: ruff_python_ast::AtomicNodeIndex::dummy(),
-                    // intentionally omit the triple quote flag, if set, to avoid strange
-                    // replacements like
-                    //
-                    // ```python
-                    // """
-                    // itemA
-                    // itemB
-                    // itemC
-                    // """.split() # -> ["""itemA""", """itemB""", """itemC"""]
-                    // ```
-                    flags: flags.with_triple_quotes(TripleQuotes::No),
+                    flags: element_flags,
                 })
             })
             .collect(),

crates/ruff_linter/src/rules/flake8_simplify/snapshots/ruff_linter__rules__flake8_simplify__tests__SIM905_SIM905.py.snap

@@ -1226,6 +1226,7 @@ SIM905.py:130:7: SIM905 [*] Consider using a list literal instead of `str.split`
     130 |+print([" x"])
 131 131 | print("  x  ".rsplit(maxsplit=0))
 132 132 | print("  x  ".rsplit(sep=None, maxsplit=0))
+133 133 | 
 
 SIM905.py:131:7: SIM905 [*] Consider using a list literal instead of `str.split`
     |
@@ -1244,6 +1245,8 @@ SIM905.py:131:7: SIM905 [*] Consider using a list literal instead of `str.split`
 131     |-print("  x  ".rsplit(maxsplit=0))
     131 |+print(["  x"])
 132 132 | print("  x  ".rsplit(sep=None, maxsplit=0))
+133 133 | 
+134 134 | # https://github.com/astral-sh/ruff/issues/19581 - embedded quotes in raw strings
 
 SIM905.py:132:7: SIM905 [*] Consider using a list literal instead of `str.split`
     |
@@ -1251,6 +1254,8 @@ SIM905.py:132:7: SIM905 [*] Consider using a list literal instead of `str.split`
 131 | print("  x  ".rsplit(maxsplit=0))
 132 | print("  x  ".rsplit(sep=None, maxsplit=0))
     |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ SIM905
+133 |
+134 | # https://github.com/astral-sh/ruff/issues/19581 - embedded quotes in raw strings
     |
     = help: Replace with list literal
 
@@ -1260,3 +1265,88 @@ SIM905.py:132:7: SIM905 [*] Consider using a list literal instead of `str.split`
 131 131 | print("  x  ".rsplit(maxsplit=0))
 132     |-print("  x  ".rsplit(sep=None, maxsplit=0))
     132 |+print(["  x"])
+133 133 | 
+134 134 | # https://github.com/astral-sh/ruff/issues/19581 - embedded quotes in raw strings
+135 135 | r"""simple@example.com
+
+SIM905.py:135:1: SIM905 [*] Consider using a list literal instead of `str.split`
+    |
+134 |   # https://github.com/astral-sh/ruff/issues/19581 - embedded quotes in raw strings
+135 | / r"""simple@example.com
+136 | | very.common@example.com
+137 | | FirstName.LastName@EasierReading.org
+138 | | x@example.com
+139 | | long.email-address-with-hyphens@and.subdomains.example.com
+140 | | user.name+tag+sorting@example.com
+141 | | name/surname@example.com
+142 | | xample@s.example
+143 | | " "@example.org
+144 | | "john..doe"@example.org
+145 | | mailhost!username@example.org
+146 | | "very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com
+147 | | user%example.com@example.org
+148 | | user-@example.org
+149 | | I❤️CHOCOLATE@example.com
+150 | | this\ still\"not\\allowed@example.com
+151 | | stellyamburrr985@example.com
+152 | | Abc.123@example.com
+153 | | user+mailbox/department=shipping@example.com
+154 | | !#$%&'*+-/=?^_`.{|}~@example.com
+155 | | "Abc@def"@example.com
+156 | | "Fred\ Bloggs"@example.com
+157 | | "Joe.\\Blow"@example.com""".split("\n")
+    | |_______________________________________^ SIM905
+    |
+    = help: Replace with list literal
+
+ℹ Safe fix
+132 132 | print("  x  ".rsplit(sep=None, maxsplit=0))
+133 133 | 
+134 134 | # https://github.com/astral-sh/ruff/issues/19581 - embedded quotes in raw strings
+135     |-r"""simple@example.com
+136     |-very.common@example.com
+137     |-FirstName.LastName@EasierReading.org
+138     |-x@example.com
+139     |-long.email-address-with-hyphens@and.subdomains.example.com
+140     |-user.name+tag+sorting@example.com
+141     |-name/surname@example.com
+142     |-xample@s.example
+143     |-" "@example.org
+144     |-"john..doe"@example.org
+145     |-mailhost!username@example.org
+146     |-"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com
+147     |-user%example.com@example.org
+148     |-user-@example.org
+149     |-I❤️CHOCOLATE@example.com
+150     |-this\ still\"not\\allowed@example.com
+151     |-stellyamburrr985@example.com
+152     |-Abc.123@example.com
+153     |-user+mailbox/department=shipping@example.com
+154     |-!#$%&'*+-/=?^_`.{|}~@example.com
+155     |-"Abc@def"@example.com
+156     |-"Fred\ Bloggs"@example.com
+157     |-"Joe.\\Blow"@example.com""".split("\n")
+    135 |+[r"simple@example.com", r"very.common@example.com", r"FirstName.LastName@EasierReading.org", r"x@example.com", r"long.email-address-with-hyphens@and.subdomains.example.com", r"user.name+tag+sorting@example.com", r"name/surname@example.com", r"xample@s.example", r'" "@example.org', r'"john..doe"@example.org', r"mailhost!username@example.org", r'"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com', r"user%example.com@example.org", r"user-@example.org", r"I❤️CHOCOLATE@example.com", r'this\ still\"not\\allowed@example.com', r"stellyamburrr985@example.com", r"Abc.123@example.com", r"user+mailbox/department=shipping@example.com", r"!#$%&'*+-/=?^_`.{|}~@example.com", r'"Abc@def"@example.com', r'"Fred\ Bloggs"@example.com', r'"Joe.\\Blow"@example.com']
+158 136 | 
+159 137 | 
+160 138 | r"""first
+
+SIM905.py:160:1: SIM905 [*] Consider using a list literal instead of `str.split`
+    |
+160 | / r"""first
+161 | | 'no need' to escape
+162 | | "swap" quote style
+163 | | "use' ugly triple quotes""".split("\n")
+    | |_______________________________________^ SIM905
+    |
+    = help: Replace with list literal
+
+ℹ Safe fix
+157 157 | "Joe.\\Blow"@example.com""".split("\n")
+158 158 | 
+159 159 | 
+160     |-r"""first
+161     |-'no need' to escape
+162     |-"swap" quote style
+163     |-"use' ugly triple quotes""".split("\n")
+    160 |+[r"first", r"'no need' to escape", r'"swap" quote style', r""""use' ugly triple quotes"""]

crates/ruff_linter/src/rules/flake8_use_pathlib/helpers.rs

@@ -20,6 +20,35 @@ pub(crate) fn is_pathlib_path_call(checker: &Checker, expr: &Expr) -> bool {
     })
 }
 
+/// Check if the given segments represent a pathlib Path subclass or `PackagePath` with preview mode support.
+/// In stable mode, only checks for `Path` and `PurePath`. In preview mode, also checks for
+/// `PosixPath`, `PurePosixPath`, `WindowsPath`, `PureWindowsPath`, and `PackagePath`.
+pub(crate) fn is_pure_path_subclass_with_preview(
+    checker: &crate::checkers::ast::Checker,
+    segments: &[&str],
+) -> bool {
+    let is_core_pathlib = matches!(segments, ["pathlib", "Path" | "PurePath"]);
+
+    if is_core_pathlib {
+        return true;
+    }
+
+    if checker.settings().preview.is_enabled() {
+        let is_expanded_pathlib = matches!(
+            segments,
+            [
+                "pathlib",
+                "PosixPath" | "PurePosixPath" | "WindowsPath" | "PureWindowsPath"
+            ]
+        );
+        let is_packagepath = matches!(segments, ["importlib", "metadata", "PackagePath"]);
+
+        return is_expanded_pathlib || is_packagepath;
+    }
+
+    false
+}
+
 /// We check functions that take only 1 argument,  this does not apply to functions
 /// with `dir_fd` argument, because `dir_fd` is not supported by pathlib,
 /// so check if it's set to non-default values

crates/ruff_linter/src/rules/flake8_use_pathlib/mod.rs

@@ -123,6 +123,7 @@ mod tests {
         Ok(())
     }
 
+    #[test_case(Rule::PathConstructorCurrentDirectory, Path::new("PTH201.py"))]
     #[test_case(Rule::OsPathGetsize, Path::new("PTH202.py"))]
     #[test_case(Rule::OsPathGetsize, Path::new("PTH202_2.py"))]
     #[test_case(Rule::OsPathGetatime, Path::new("PTH203.py"))]

crates/ruff_linter/src/rules/flake8_use_pathlib/rules/path_constructor_current_directory.rs

@@ -9,6 +9,7 @@ use ruff_text_size::{Ranged, TextRange};
 
 use crate::checkers::ast::Checker;
 use crate::fix::edits::{Parentheses, remove_argument};
+use crate::rules::flake8_use_pathlib::helpers::is_pure_path_subclass_with_preview;
 use crate::{AlwaysFixableViolation, Applicability, Edit, Fix};
 
 /// ## What it does
@@ -69,7 +70,7 @@ pub(crate) fn path_constructor_current_directory(
 
     let arguments = &call.arguments;
 
-    if !matches!(segments, ["pathlib", "Path" | "PurePath"]) {
+    if !is_pure_path_subclass_with_preview(checker, segments) {
         return;
     }
 

crates/ruff_linter/src/rules/flake8_use_pathlib/snapshots/ruff_linter__rules__flake8_use_pathlib__tests__preview__PTH201_PTH201.py.snap

@@ -0,0 +1,423 @@
+---
+source: crates/ruff_linter/src/rules/flake8_use_pathlib/mod.rs
+assertion_line: 144
+---
+PTH201.py:6:10: PTH201 [*] Do not pass the current directory explicitly to `Path`
+  |
+5 | # match
+6 | _ = Path(".")
+  |          ^^^ PTH201
+7 | _ = pth(".")
+8 | _ = PurePath(".")
+  |
+  = help: Remove the current directory argument
+
+ℹ Safe fix
+3 3 | 
+4 4 | 
+5 5 | # match
+6   |-_ = Path(".")
+  6 |+_ = Path()
+7 7 | _ = pth(".")
+8 8 | _ = PurePath(".")
+9 9 | _ = Path("")
+
+PTH201.py:7:9: PTH201 [*] Do not pass the current directory explicitly to `Path`
+  |
+5 | # match
+6 | _ = Path(".")
+7 | _ = pth(".")
+  |         ^^^ PTH201
+8 | _ = PurePath(".")
+9 | _ = Path("")
+  |
+  = help: Remove the current directory argument
+
+ℹ Safe fix
+4 4 | 
+5 5 | # match
+6 6 | _ = Path(".")
+7   |-_ = pth(".")
+  7 |+_ = pth()
+8 8 | _ = PurePath(".")
+9 9 | _ = Path("")
+10 10 | 
+
+PTH201.py:8:14: PTH201 [*] Do not pass the current directory explicitly to `Path`
+  |
+6 | _ = Path(".")
+7 | _ = pth(".")
+8 | _ = PurePath(".")
+  |              ^^^ PTH201
+9 | _ = Path("")
+  |
+  = help: Remove the current directory argument
+
+ℹ Safe fix
+5 5 | # match
+6 6 | _ = Path(".")
+7 7 | _ = pth(".")
+8   |-_ = PurePath(".")
+  8 |+_ = PurePath()
+9 9 | _ = Path("")
+10 10 | 
+11 11 | Path('', )
+
+PTH201.py:9:10: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+ 7 | _ = pth(".")
+ 8 | _ = PurePath(".")
+ 9 | _ = Path("")
+   |          ^^ PTH201
+10 |
+11 | Path('', )
+   |
+   = help: Remove the current directory argument
+
+ℹ Safe fix
+6  6  | _ = Path(".")
+7  7  | _ = pth(".")
+8  8  | _ = PurePath(".")
+9     |-_ = Path("")
+   9  |+_ = Path()
+10 10 | 
+11 11 | Path('', )
+12 12 | 
+
+PTH201.py:11:6: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+ 9 | _ = Path("")
+10 |
+11 | Path('', )
+   |      ^^ PTH201
+12 |
+13 | Path(
+   |
+   = help: Remove the current directory argument
+
+ℹ Safe fix
+8  8  | _ = PurePath(".")
+9  9  | _ = Path("")
+10 10 | 
+11    |-Path('', )
+   11 |+Path()
+12 12 | 
+13 13 | Path(
+14 14 |     '',
+
+PTH201.py:14:5: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+13 | Path(
+14 |     '',
+   |     ^^ PTH201
+15 | )
+   |
+   = help: Remove the current directory argument
+
+ℹ Safe fix
+10 10 | 
+11 11 | Path('', )
+12 12 | 
+13    |-Path(
+14    |-    '',
+15    |-)
+   13 |+Path()
+16 14 | 
+17 15 | Path(  # Comment before argument
+18 16 |     '',
+
+PTH201.py:18:5: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+17 | Path(  # Comment before argument
+18 |     '',
+   |     ^^ PTH201
+19 | )
+   |
+   = help: Remove the current directory argument
+
+ℹ Unsafe fix
+14 14 |     '',
+15 15 | )
+16 16 | 
+17    |-Path(  # Comment before argument
+18    |-    '',
+19    |-)
+   17 |+Path()
+20 18 | 
+21 19 | Path(
+22 20 |     '',  # EOL comment
+
+PTH201.py:22:5: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+21 | Path(
+22 |     '',  # EOL comment
+   |     ^^ PTH201
+23 | )
+   |
+   = help: Remove the current directory argument
+
+ℹ Unsafe fix
+18 18 |     '',
+19 19 | )
+20 20 | 
+21    |-Path(
+22    |-    '',  # EOL comment
+23    |-)
+   21 |+Path()
+24 22 | 
+25 23 | Path(
+26 24 |     ''  # Comment in the middle of implicitly concatenated string
+
+PTH201.py:26:5: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+25 |   Path(
+26 | /     ''  # Comment in the middle of implicitly concatenated string
+27 | |     ".",
+   | |_______^ PTH201
+28 |   )
+   |
+   = help: Remove the current directory argument
+
+ℹ Unsafe fix
+22 22 |     '',  # EOL comment
+23 23 | )
+24 24 | 
+25    |-Path(
+26    |-    ''  # Comment in the middle of implicitly concatenated string
+27    |-    ".",
+28    |-)
+   25 |+Path()
+29 26 | 
+30 27 | Path(
+31 28 |     ''  # Comment before comma
+
+PTH201.py:31:5: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+30 | Path(
+31 |     ''  # Comment before comma
+   |     ^^ PTH201
+32 |     ,
+33 | )
+   |
+   = help: Remove the current directory argument
+
+ℹ Unsafe fix
+27 27 |     ".",
+28 28 | )
+29 29 | 
+30    |-Path(
+31    |-    ''  # Comment before comma
+32    |-    ,
+33    |-)
+   30 |+Path()
+34 31 | 
+35 32 | Path(
+36 33 |     '',
+
+PTH201.py:36:5: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+35 | Path(
+36 |     '',
+   |     ^^ PTH201
+37 | ) / "bare"
+   |
+   = help: Remove the current directory argument
+
+ℹ Safe fix
+33 33 | )
+34 34 | 
+35 35 | Path(
+36    |-    '',
+37    |-) / "bare"
+   36 |+    "bare",
+   37 |+)
+38 38 | 
+39 39 | Path(  # Comment before argument
+40 40 |     '',
+
+PTH201.py:40:5: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+39 | Path(  # Comment before argument
+40 |     '',
+   |     ^^ PTH201
+41 | ) / ("parenthesized")
+   |
+   = help: Remove the current directory argument
+
+ℹ Unsafe fix
+37 37 | ) / "bare"
+38 38 | 
+39 39 | Path(  # Comment before argument
+40    |-    '',
+41    |-) / ("parenthesized")
+   40 |+    ("parenthesized"),
+   41 |+)
+42 42 | 
+43 43 | Path(
+44 44 |     '',  # EOL comment
+
+PTH201.py:44:5: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+43 | Path(
+44 |     '',  # EOL comment
+   |     ^^ PTH201
+45 | ) / ( ("double parenthesized"  )   )
+   |
+   = help: Remove the current directory argument
+
+ℹ Unsafe fix
+41 41 | ) / ("parenthesized")
+42 42 | 
+43 43 | Path(
+44    |-    '',  # EOL comment
+45    |-) / ( ("double parenthesized"  )   )
+   44 |+    ( ("double parenthesized"  )   ),  # EOL comment
+   45 |+)
+46 46 | 
+47 47 | (  Path(
+48 48 |     ''  # Comment in the middle of implicitly concatenated string
+
+PTH201.py:48:5: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+47 |   (  Path(
+48 | /     ''  # Comment in the middle of implicitly concatenated string
+49 | |     ".",
+   | |_______^ PTH201
+50 |   ) )/ (("parenthesized path call")
+51 |         # Comment between closing parentheses
+   |
+   = help: Remove the current directory argument
+
+ℹ Unsafe fix
+44 44 |     '',  # EOL comment
+45 45 | ) / ( ("double parenthesized"  )   )
+46 46 | 
+47    |-(  Path(
+48    |-    ''  # Comment in the middle of implicitly concatenated string
+49    |-    ".",
+50    |-) )/ (("parenthesized path call")
+   47 |+Path(
+   48 |+    (("parenthesized path call")
+51 49 |       # Comment between closing parentheses
+   50 |+),
+52 51 | )
+53 52 | 
+54 53 | Path(
+
+PTH201.py:55:5: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+54 | Path(
+55 |     ''  # Comment before comma
+   |     ^^ PTH201
+56 |     ,
+57 | ) / "multiple" / (
+   |
+   = help: Remove the current directory argument
+
+ℹ Unsafe fix
+52 52 | )
+53 53 | 
+54 54 | Path(
+55    |-    ''  # Comment before comma
+   55 |+    "multiple"  # Comment before comma
+56 56 |     ,
+57    |-) / "multiple" / (
+   57 |+) / (
+58 58 |     "frag"  # Comment
+59 59 |     'ment'
+60 60 | )
+
+PTH201.py:74:15: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+72 | from importlib.metadata import PackagePath
+73 |
+74 | _ = PosixPath(".")
+   |               ^^^ PTH201
+75 | _ = PurePosixPath(".")
+76 | _ = WindowsPath(".")
+   |
+   = help: Remove the current directory argument
+
+ℹ Safe fix
+71 71 | 
+72 72 | from importlib.metadata import PackagePath
+73 73 | 
+74    |-_ = PosixPath(".")
+   74 |+_ = PosixPath()
+75 75 | _ = PurePosixPath(".")
+76 76 | _ = WindowsPath(".")
+77 77 | _ = PureWindowsPath(".")
+
+PTH201.py:75:19: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+74 | _ = PosixPath(".")
+75 | _ = PurePosixPath(".")
+   |                   ^^^ PTH201
+76 | _ = WindowsPath(".")
+77 | _ = PureWindowsPath(".")
+   |
+   = help: Remove the current directory argument
+
+ℹ Safe fix
+72 72 | from importlib.metadata import PackagePath
+73 73 | 
+74 74 | _ = PosixPath(".")
+75    |-_ = PurePosixPath(".")
+   75 |+_ = PurePosixPath()
+76 76 | _ = WindowsPath(".")
+77 77 | _ = PureWindowsPath(".")
+78 78 | _ = PackagePath(".")
+
+PTH201.py:76:17: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+74 | _ = PosixPath(".")
+75 | _ = PurePosixPath(".")
+76 | _ = WindowsPath(".")
+   |                 ^^^ PTH201
+77 | _ = PureWindowsPath(".")
+78 | _ = PackagePath(".")
+   |
+   = help: Remove the current directory argument
+
+ℹ Safe fix
+73 73 | 
+74 74 | _ = PosixPath(".")
+75 75 | _ = PurePosixPath(".")
+76    |-_ = WindowsPath(".")
+   76 |+_ = WindowsPath()
+77 77 | _ = PureWindowsPath(".")
+78 78 | _ = PackagePath(".")
+
+PTH201.py:77:21: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+75 | _ = PurePosixPath(".")
+76 | _ = WindowsPath(".")
+77 | _ = PureWindowsPath(".")
+   |                     ^^^ PTH201
+78 | _ = PackagePath(".")
+   |
+   = help: Remove the current directory argument
+
+ℹ Safe fix
+74 74 | _ = PosixPath(".")
+75 75 | _ = PurePosixPath(".")
+76 76 | _ = WindowsPath(".")
+77    |-_ = PureWindowsPath(".")
+   77 |+_ = PureWindowsPath()
+78 78 | _ = PackagePath(".")
+
+PTH201.py:78:17: PTH201 [*] Do not pass the current directory explicitly to `Path`
+   |
+76 | _ = WindowsPath(".")
+77 | _ = PureWindowsPath(".")
+78 | _ = PackagePath(".")
+   |                 ^^^ PTH201
+   |
+   = help: Remove the current directory argument
+
+ℹ Safe fix
+75 75 | _ = PurePosixPath(".")
+76 76 | _ = WindowsPath(".")
+77 77 | _ = PureWindowsPath(".")
+78    |-_ = PackagePath(".")
+   78 |+_ = PackagePath()

crates/ruff_linter/src/rules/isort/mod.rs

@@ -794,6 +794,7 @@ mod tests {
     #[test_case(Path::new("comments_and_newlines.py"))]
     #[test_case(Path::new("docstring.py"))]
     #[test_case(Path::new("docstring.pyi"))]
+    #[test_case(Path::new("docstring_followed_by_continuation.py"))]
     #[test_case(Path::new("docstring_only.py"))]
     #[test_case(Path::new("docstring_with_continuation.py"))]
     #[test_case(Path::new("docstring_with_semicolon.py"))]
@@ -828,6 +829,7 @@ mod tests {
     #[test_case(Path::new("comments_and_newlines.py"))]
     #[test_case(Path::new("docstring.py"))]
     #[test_case(Path::new("docstring.pyi"))]
+    #[test_case(Path::new("docstring_followed_by_continuation.py"))]
     #[test_case(Path::new("docstring_only.py"))]
     #[test_case(Path::new("docstring_with_continuation.py"))]
     #[test_case(Path::new("docstring_with_semicolon.py"))]

crates/ruff_linter/src/rules/isort/snapshots/ruff_linter__rules__isort__tests__required_import_docstring_followed_by_continuation.py.snap

@@ -0,0 +1,9 @@
+---
+source: crates/ruff_linter/src/rules/isort/mod.rs
+---
+docstring_followed_by_continuation.py:1:1: I002 [*] Missing required import: `from __future__ import annotations`
+ℹ Safe fix
+1 1 | """Hello, world!"""\
+2 2 | 
+  3 |+from __future__ import annotations
+3 4 | x = 1; y = 2

crates/ruff_linter/src/rules/isort/snapshots/ruff_linter__rules__isort__tests__required_import_with_alias_docstring_followed_by_continuation.py.snap

@@ -0,0 +1,9 @@
+---
+source: crates/ruff_linter/src/rules/isort/mod.rs
+---
+docstring_followed_by_continuation.py:1:1: I002 [*] Missing required import: `from __future__ import annotations as _annotations`
+ℹ Safe fix
+1 1 | """Hello, world!"""\
+2 2 | 
+  3 |+from __future__ import annotations as _annotations
+3 4 | x = 1; y = 2

crates/ruff_linter/src/rules/perflint/rules/manual_list_comprehension.rs

@@ -249,6 +249,11 @@ pub(crate) fn manual_list_comprehension(checker: &Checker, for_stmt: &ast::StmtF
         .iter()
         .find(|binding| for_stmt.target.range() == binding.range)
         .unwrap();
+    // If the target variable is global (e.g., `global INDEX`) or nonlocal (e.g., `nonlocal INDEX`),
+    // then it is intended to be used elsewhere outside the for loop.
+    if target_binding.is_global() || target_binding.is_nonlocal() {
+        return;
+    }
     // If any references to the loop target variable are after the loop,
     // then converting it into a comprehension would cause a NameError
     if target_binding

crates/ruff_linter/src/rules/perflint/snapshots/ruff_linter__rules__perflint__tests__PERF401_PERF401.py.snap

@@ -263,5 +263,7 @@ PERF401.py:292:9: PERF401 Use a list comprehension to create a transformed list
 291 |     for i in range(3):
 292 |         result.append((x for x in [i]))
     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PERF401
+293 |
+294 | G_INDEX = None
     |
     = help: Replace for loop with list comprehension

crates/ruff_linter/src/rules/perflint/snapshots/ruff_linter__rules__perflint__tests__preview__PERF401_PERF401.py.snap

@@ -612,6 +612,8 @@ PERF401.py:292:9: PERF401 [*] Use a list comprehension to create a transformed l
 291 |     for i in range(3):
 292 |         result.append((x for x in [i]))
     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PERF401
+293 |
+294 | G_INDEX = None
     |
     = help: Replace for loop with list comprehension
 
@@ -623,3 +625,6 @@ PERF401.py:292:9: PERF401 [*] Use a list comprehension to create a transformed l
 291     |-    for i in range(3):
 292     |-        result.append((x for x in [i]))
     290 |+    result = [(x for x in [i]) for i in range(3)]
+293 291 | 
+294 292 | G_INDEX = None
+295 293 | def f():

crates/ruff_linter/src/rules/pycodestyle/rules/blank_lines.rs

@@ -21,7 +21,6 @@ use crate::checkers::ast::{DiagnosticGuard, LintContext};
 use crate::checkers::logical_lines::expand_indent;
 use crate::line_width::IndentWidth;
 use crate::rules::pycodestyle::helpers::is_non_logical_token;
-use crate::settings::LinterSettings;
 use crate::{AlwaysFixableViolation, Edit, Fix, Locator, Violation};
 
 /// Number of blank lines around top level classes and functions.
@@ -694,14 +693,12 @@ pub(crate) struct BlankLinesChecker<'a, 'b> {
     source_type: PySourceType,
     cell_offsets: Option<&'a CellOffsets>,
     context: &'a LintContext<'b>,
-    settings: &'a LinterSettings,
 }
 
 impl<'a, 'b> BlankLinesChecker<'a, 'b> {
     pub(crate) fn new(
         locator: &'a Locator<'a>,
         stylist: &'a Stylist<'a>,
-        settings: &'a LinterSettings,
         source_type: PySourceType,
         cell_offsets: Option<&'a CellOffsets>,
         context: &'a LintContext<'b>,
@@ -712,7 +709,6 @@ impl<'a, 'b> BlankLinesChecker<'a, 'b> {
             source_type,
             cell_offsets,
             context,
-            settings,
         }
     }
 
@@ -733,7 +729,7 @@ impl<'a, 'b> BlankLinesChecker<'a, 'b> {
         let line_preprocessor = LinePreprocessor::new(
             tokens,
             self.locator,
-            self.settings.tab_size,
+            self.context.settings().tab_size,
             self.cell_offsets,
         );
 
@@ -879,7 +875,8 @@ impl<'a, 'b> BlankLinesChecker<'a, 'b> {
                 // `isort` defaults to 2 if before a class or function definition (except in stubs where it is one) and 1 otherwise.
                 // Defaulting to 2 (or 1 in stubs) here is correct because the variable is only used when testing the
                 // blank lines before a class or function definition.
-                u32::try_from(self.settings.isort.lines_after_imports).unwrap_or(max_lines_level)
+                u32::try_from(self.context.settings().isort.lines_after_imports)
+                    .unwrap_or(max_lines_level)
             } else {
                 max_lines_level
             }
@@ -941,8 +938,10 @@ impl<'a, 'b> BlankLinesChecker<'a, 'b> {
             (LogicalLineKind::Import, Follows::FromImport)
                 | (LogicalLineKind::FromImport, Follows::Import)
         ) {
-            max_lines_level
-                .max(u32::try_from(self.settings.isort.lines_between_types).unwrap_or(u32::MAX))
+            max_lines_level.max(
+                u32::try_from(self.context.settings().isort.lines_between_types)
+                    .unwrap_or(u32::MAX),
+            )
         } else {
             expected_blank_lines_before_definition
         };

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__E101_E101.py.snap

@@ -15,8 +15,8 @@ E101.py:15:1: E101 Indentation contains mixed spaces and tabs
    |
 13 | def func_mixed_start_with_space():
 14 |     # E101
-15 |                print("mixed starts with space")
-   | ^^^^^^^^^^^^^^^ E101
+15 |                     print("mixed starts with space")
+   | ^^^^^^^^^^^^^^^^^^^^ E101
 16 |
 17 | def xyz():
    |
@@ -25,6 +25,6 @@ E101.py:19:1: E101 Indentation contains mixed spaces and tabs
    |
 17 | def xyz():
 18 |     # E101
-19 |     print("xyz");
-   | ^^^^ E101
+19 |        print("xyz");
+   | ^^^^^^^ E101
    |

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__E201_E20.py.snap

@@ -47,7 +47,7 @@ E20.py:6:15: E201 [*] Whitespace after '{'
 6 | spam(ham[1], { eggs: 2})
   |               ^ E201
 7 | #: E201:1:6
-8 | spam(   ham[1], {eggs: 2})
+8 | spam(    ham[1], {eggs: 2})
   |
   = help: Remove whitespace before '{'
 
@@ -65,10 +65,10 @@ E20.py:8:6: E201 [*] Whitespace after '('
    |
  6 | spam(ham[1], { eggs: 2})
  7 | #: E201:1:6
- 8 | spam(   ham[1], {eggs: 2})
-   |      ^^^ E201
+ 8 | spam(    ham[1], {eggs: 2})
+   |      ^^^^ E201
  9 | #: E201:1:10
-10 | spam(ham[   1], {eggs: 2})
+10 | spam(ham[    1], {eggs: 2})
    |
    = help: Remove whitespace before '('
 
@@ -84,12 +84,12 @@ E20.py:8:6: E201 [*] Whitespace after '('
 
 E20.py:10:10: E201 [*] Whitespace after '['
    |
- 8 | spam(   ham[1], {eggs: 2})
+ 8 | spam(    ham[1], {eggs: 2})
  9 | #: E201:1:10
-10 | spam(ham[   1], {eggs: 2})
-   |          ^^^ E201
+10 | spam(ham[    1], {eggs: 2})
+   |          ^^^^ E201
 11 | #: E201:1:15
-12 | spam(ham[1], {  eggs: 2})
+12 | spam(ham[1], {    eggs: 2})
    |
    = help: Remove whitespace before '['
 
@@ -105,10 +105,10 @@ E20.py:10:10: E201 [*] Whitespace after '['
 
 E20.py:12:15: E201 [*] Whitespace after '{'
    |
-10 | spam(ham[   1], {eggs: 2})
+10 | spam(ham[    1], {eggs: 2})
 11 | #: E201:1:15
-12 | spam(ham[1], {  eggs: 2})
-   |               ^^ E201
+12 | spam(ham[1], {    eggs: 2})
+   |               ^^^^ E201
 13 | #: Okay
 14 | spam(ham[1], {eggs: 2})
    |

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__E202_E20.py.snap

@@ -49,7 +49,7 @@ E20.py:23:11: E202 [*] Whitespace before ']'
 23 | spam(ham[1 ], {eggs: 2})
    |           ^ E202
 24 | #: E202:1:23
-25 | spam(ham[1], {eggs: 2}  )
+25 | spam(ham[1], {eggs: 2}    )
    |
    = help: Remove whitespace before ']'
 
@@ -67,10 +67,10 @@ E20.py:25:23: E202 [*] Whitespace before ')'
    |
 23 | spam(ham[1 ], {eggs: 2})
 24 | #: E202:1:23
-25 | spam(ham[1], {eggs: 2}  )
-   |                       ^^ E202
+25 | spam(ham[1], {eggs: 2}    )
+   |                       ^^^^ E202
 26 | #: E202:1:22
-27 | spam(ham[1], {eggs: 2   })
+27 | spam(ham[1], {eggs: 2    })
    |
    = help: Remove whitespace before ')'
 
@@ -86,12 +86,12 @@ E20.py:25:23: E202 [*] Whitespace before ')'
 
 E20.py:27:22: E202 [*] Whitespace before '}'
    |
-25 | spam(ham[1], {eggs: 2}  )
+25 | spam(ham[1], {eggs: 2}    )
 26 | #: E202:1:22
-27 | spam(ham[1], {eggs: 2   })
-   |                      ^^^ E202
+27 | spam(ham[1], {eggs: 2    })
+   |                      ^^^^ E202
 28 | #: E202:1:11
-29 | spam(ham[1  ], {eggs: 2})
+29 | spam(ham[1    ], {eggs: 2})
    |
    = help: Remove whitespace before '}'
 
@@ -107,10 +107,10 @@ E20.py:27:22: E202 [*] Whitespace before '}'
 
 E20.py:29:11: E202 [*] Whitespace before ']'
    |
-27 | spam(ham[1], {eggs: 2   })
+27 | spam(ham[1], {eggs: 2    })
 28 | #: E202:1:11
-29 | spam(ham[1  ], {eggs: 2})
-   |           ^^ E202
+29 | spam(ham[1    ], {eggs: 2})
+   |           ^^^^ E202
 30 | #: Okay
 31 | spam(ham[1], {eggs: 2})
    |

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__E203_E20.py.snap

@@ -25,8 +25,8 @@ E20.py:55:10: E203 [*] Whitespace before ':'
    |
 53 |     x, y = y, x
 54 | #: E203:1:10
-55 | if x == 4   :
-   |          ^^^ E203
+55 | if x == 4    :
+   |          ^^^^ E203
 56 |     print(x, y)
 57 |     x, y = y, x
    |
@@ -67,8 +67,8 @@ E20.py:63:16: E203 [*] Whitespace before ';'
    |
 61 | #: E203:2:15 E702:2:16
 62 | if x == 4:
-63 |     print(x, y) ; x, y = y, x
-   |                ^ E203
+63 |     print(x, y)    ; x, y = y, x
+   |                ^^^^ E203
 64 | #: E203:3:13
 65 | if x == 4:
    |

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__E223_E22.py.snap

@@ -1,13 +1,12 @@
 ---
 source: crates/ruff_linter/src/rules/pycodestyle/mod.rs
-snapshot_kind: text
 ---
 E22.py:43:2: E223 [*] Tab before operator
    |
 41 | #: E223
 42 | foobart = 4
-43 | a   = 3  # aligned with tab
-   |  ^^^ E223
+43 | a    = 3  # aligned with tab
+   |  ^^^^ E223
 44 | #:
    |
    = help: Replace with single space

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__E242_E24.py.snap

@@ -1,13 +1,12 @@
 ---
 source: crates/ruff_linter/src/rules/pycodestyle/mod.rs
-snapshot_kind: text
 ---
 E24.py:6:8: E242 [*] Tab after comma
   |
 4 | b = (1, 20)
 5 | #: E242
-6 | a = (1, 2)  # tab before 2
-  |        ^ E242
+6 | a = (1,    2)  # tab before 2
+  |        ^^^^ E242
 7 | #: Okay
 8 | b = (1, 20)  # space before 20
   |

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__E271_E27.py.snap

@@ -66,7 +66,7 @@ E27.py:8:3: E271 [*] Multiple spaces after keyword
 
 E27.py:15:6: E271 [*] Multiple spaces after keyword
    |
-13 | True        and False
+13 | True        and    False
 14 | #: E271
 15 | a and  b
    |      ^^ E271

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__E272_E27.py.snap

@@ -1,6 +1,5 @@
 ---
 source: crates/ruff_linter/src/rules/pycodestyle/mod.rs
-snapshot_kind: text
 ---
 E27.py:21:2: E272 [*] Multiple spaces before keyword
    |
@@ -51,7 +50,7 @@ E27.py:25:5: E272 [*] Multiple spaces before keyword
 25 | this  and False
    |     ^^ E272
 26 | #: E273
-27 | a and   b
+27 | a and    b
    |
    = help: Replace with single space
 

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__E273_E27.py.snap

@@ -8,7 +8,7 @@ E27.py:11:9: E273 [*] Tab after keyword
 11 | True and        False
    |         ^^^^^^^^ E273
 12 | #: E273 E274
-13 | True        and False
+13 | True        and    False
    |
    = help: Replace with single space
 
@@ -26,7 +26,7 @@ E27.py:13:5: E273 [*] Tab after keyword
    |
 11 | True and        False
 12 | #: E273 E274
-13 | True        and False
+13 | True        and    False
    |     ^^^^^^^^ E273
 14 | #: E271
 15 | a and  b
@@ -47,8 +47,8 @@ E27.py:13:10: E273 [*] Tab after keyword
    |
 11 | True and        False
 12 | #: E273 E274
-13 | True        and False
-   |                ^ E273
+13 | True        and    False
+   |                ^^^^ E273
 14 | #: E271
 15 | a and  b
    |
@@ -68,10 +68,10 @@ E27.py:27:6: E273 [*] Tab after keyword
    |
 25 | this  and False
 26 | #: E273
-27 | a and   b
-   |      ^^^ E273
+27 | a and    b
+   |      ^^^^ E273
 28 | #: E274
-29 | a       and b
+29 | a        and b
    |
    = help: Replace with single space
 
@@ -87,10 +87,10 @@ E27.py:27:6: E273 [*] Tab after keyword
 
 E27.py:31:10: E273 [*] Tab after keyword
    |
-29 | a       and b
+29 | a        and b
 30 | #: E273 E274
-31 | this        and False
-   |                ^ E273
+31 | this        and    False
+   |                ^^^^ E273
 32 | #: Okay
 33 | from u import (a, b)
    |

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__E274_E27.py.snap

@@ -1,15 +1,14 @@
 ---
 source: crates/ruff_linter/src/rules/pycodestyle/mod.rs
-snapshot_kind: text
 ---
 E27.py:29:2: E274 [*] Tab before keyword
    |
-27 | a and   b
+27 | a and    b
 28 | #: E274
-29 | a       and b
-   |  ^^^^^^^ E274
+29 | a        and b
+   |  ^^^^^^^^ E274
 30 | #: E273 E274
-31 | this        and False
+31 | this        and    False
    |
    = help: Replace with single space
 
@@ -25,9 +24,9 @@ E27.py:29:2: E274 [*] Tab before keyword
 
 E27.py:31:5: E274 [*] Tab before keyword
    |
-29 | a       and b
+29 | a        and b
 30 | #: E273 E274
-31 | this        and False
+31 | this        and    False
    |     ^^^^^^^^ E274
 32 | #: Okay
 33 | from u import (a, b)

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__W191_W19.py.snap

@@ -1,6 +1,5 @@
 ---
 source: crates/ruff_linter/src/rules/pycodestyle/mod.rs
-snapshot_kind: text
 ---
 W19.py:1:1: W191 Indentation contains tabs
   |
@@ -371,7 +370,7 @@ W19.py:157:1: W191 Indentation contains tabs
 156 | f"test{
 157 |     tab_indented_should_be_flagged
     | ^^^^ W191
-158 | }   <- this tab is fine"
+158 | }    <- this tab is fine"
     |
 
 W19.py:161:1: W191 Indentation contains tabs
@@ -379,5 +378,5 @@ W19.py:161:1: W191 Indentation contains tabs
 160 | f"""test{
 161 |     tab_indented_should_be_flagged
     | ^^^^ W191
-162 | }   <- this tab is fine"""
+162 | }    <- this tab is fine"""
     |

crates/ruff_linter/src/rules/pyflakes/rules/unused_import.rs

@@ -103,7 +103,7 @@ use crate::{Applicability, Fix, FixAvailability, Violation};
 /// ## References
 /// - [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)
 /// - [Python documentation: `importlib.util.find_spec`](https://docs.python.org/3/library/importlib.html#importlib.util.find_spec)
-/// - [Typing documentation: interface conventions](https://typing.python.org/en/latest/source/libraries.html#library-interface-public-and-private-symbols)
+/// - [Typing documentation: interface conventions](https://typing.python.org/en/latest/spec/distributing.html#library-interface-public-and-private-symbols)
 #[derive(ViolationMetadata)]
 pub(crate) struct UnusedImport {
     /// Qualified name of the import
@@ -255,7 +255,7 @@ fn is_first_party(import: &AnyImport, checker: &Checker) -> bool {
     }
 }
 
-/// Find the `Expr` for top level `__all__` bindings.
+/// Find the `Expr` for top-level `__all__` bindings.
 fn find_dunder_all_exprs<'a>(semantic: &'a SemanticModel) -> Vec<&'a ast::Expr> {
     semantic
         .global_scope()
@@ -541,7 +541,7 @@ fn fix_by_removing_imports<'a>(
         checker.indexer(),
     )?;
 
-    // It's unsafe to remove things from `__init__.py` because it can break public interfaces
+    // It's unsafe to remove things from `__init__.py` because it can break public interfaces.
     let applicability = if in_init {
         Applicability::Unsafe
     } else {
@@ -556,7 +556,7 @@ fn fix_by_removing_imports<'a>(
 }
 
 /// Generate a [`Fix`] to make bindings in a statement explicit, either by adding them to `__all__`
-/// or changing them from `import a` to `import a as a`.
+/// or by changing them from `import a` to `import a as a`.
 fn fix_by_reexporting<'a>(
     checker: &Checker,
     node_id: NodeId,
@@ -585,7 +585,7 @@ fn fix_by_reexporting<'a>(
         _ => bail!("Cannot offer a fix when there are multiple __all__ definitions"),
     };
 
-    // Only emit a fix if there are edits
+    // Only emit a fix if there are edits.
     let mut tail = edits.into_iter();
     let head = tail.next().ok_or(anyhow!("No edits to make"))?;
 

crates/ruff_linter/src/rules/pylint/rules/missing_maxsplit_arg.rs

@@ -6,8 +6,9 @@ use ruff_python_ast::{
 use ruff_python_semantic::{SemanticModel, analyze::typing};
 use ruff_text_size::Ranged;
 
-use crate::Violation;
 use crate::checkers::ast::Checker;
+use crate::fix;
+use crate::{AlwaysFixableViolation, Applicability, Edit, Fix};
 
 /// ## What it does
 /// Checks for access to the first or last element of `str.split()` or `str.rsplit()` without
@@ -35,10 +36,14 @@ use crate::checkers::ast::Checker;
 /// url = "www.example.com"
 /// suffix = url.rsplit(".", maxsplit=1)[-1]
 /// ```
+///
+/// ## Fix Safety
+/// This rule's fix is marked as unsafe for `split()`/`rsplit()` calls that contain `**kwargs`, as
+/// adding a `maxsplit` keyword to such a call may lead to a duplicate keyword argument error.
 #[derive(ViolationMetadata)]
 pub(crate) struct MissingMaxsplitArg {
-    index: SliceBoundary,
     actual_split_type: String,
+    suggested_split_type: String,
 }
 
 /// Represents the index of the slice used for this rule (which can only be 0 or -1)
@@ -47,25 +52,27 @@ enum SliceBoundary {
     Last,
 }
 
-impl Violation for MissingMaxsplitArg {
+impl AlwaysFixableViolation for MissingMaxsplitArg {
     #[derive_message_formats]
     fn message(&self) -> String {
         let MissingMaxsplitArg {
-            index,
-            actual_split_type,
+            actual_split_type: _,
+            suggested_split_type,
         } = self;
 
-        let suggested_split_type = match index {
-            SliceBoundary::First => "split",
-            SliceBoundary::Last => "rsplit",
-        };
+        format!("Replace with `{suggested_split_type}(..., maxsplit=1)`.")
+    }
+
+    fn fix_title(&self) -> String {
+        let MissingMaxsplitArg {
+            actual_split_type,
+            suggested_split_type,
+        } = self;
 
         if actual_split_type == suggested_split_type {
             format!("Pass `maxsplit=1` into `str.{actual_split_type}()`")
         } else {
-            format!(
-                "Instead of `str.{actual_split_type}()`, call `str.{suggested_split_type}()` and pass `maxsplit=1`",
-            )
+            format!("Use `str.{suggested_split_type}()` and pass `maxsplit=1`")
         }
     }
 }
@@ -123,8 +130,8 @@ pub(crate) fn missing_maxsplit_arg(checker: &Checker, value: &Expr, slice: &Expr
     };
 
     // Check the function is "split" or "rsplit"
-    let attr = attr.as_str();
-    if !matches!(attr, "split" | "rsplit") {
+    let actual_split_type = attr.as_str();
+    if !matches!(actual_split_type, "split" | "rsplit") {
         return;
     }
 
@@ -161,11 +168,48 @@ pub(crate) fn missing_maxsplit_arg(checker: &Checker, value: &Expr, slice: &Expr
         }
     }
 
-    checker.report_diagnostic(
+    let suggested_split_type = match slice_boundary {
+        SliceBoundary::First => "split",
+        SliceBoundary::Last => "rsplit",
+    };
+
+    let maxsplit_argument_edit = fix::edits::add_argument(
+        "maxsplit=1",
+        arguments,
+        checker.comment_ranges(),
+        checker.locator().contents(),
+    );
+
+    // Only change `actual_split_type` if it doesn't match `suggested_split_type`
+    let split_type_edit: Option<Edit> = if actual_split_type == suggested_split_type {
+        None
+    } else {
+        Some(Edit::range_replacement(
+            suggested_split_type.to_string(),
+            attr.range(),
+        ))
+    };
+
+    let mut diagnostic = checker.report_diagnostic(
         MissingMaxsplitArg {
-            index: slice_boundary,
-            actual_split_type: attr.to_string(),
+            actual_split_type: actual_split_type.to_string(),
+            suggested_split_type: suggested_split_type.to_string(),
         },
         expr.range(),
     );
+
+    diagnostic.set_fix(Fix::applicable_edits(
+        maxsplit_argument_edit,
+        split_type_edit,
+        // If keyword.arg is `None` (i.e. if the function call contains `**kwargs`), mark the fix as unsafe
+        if arguments
+            .keywords
+            .iter()
+            .any(|keyword| keyword.arg.is_none())
+        {
+            Applicability::Unsafe
+        } else {
+            Applicability::Safe
+        },
+    ));
 }

crates/ruff_linter/src/rules/pylint/snapshots/ruff_linter__rules__pylint__tests__PLC0207_missing_maxsplit_arg.py.snap

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/pylint/mod.rs
 ---
-missing_maxsplit_arg.py:14:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+missing_maxsplit_arg.py:14:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 12 | # Errors
 13 | ## Test split called directly on string literal
@@ -10,8 +10,19 @@ missing_maxsplit_arg.py:14:1: PLC0207 Pass `maxsplit=1` into `str.split()`
 15 | "1,2,3".split(",")[-1]  # [missing-maxsplit-arg]
 16 | "1,2,3".rsplit(",")[0]  # [missing-maxsplit-arg]
    |
+   = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:15:1: PLC0207 Instead of `str.split()`, call `str.rsplit()` and pass `maxsplit=1`
+ℹ Safe fix
+11 11 | 
+12 12 | # Errors
+13 13 | ## Test split called directly on string literal
+14    |-"1,2,3".split(",")[0]  # [missing-maxsplit-arg]
+   14 |+"1,2,3".split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+15 15 | "1,2,3".split(",")[-1]  # [missing-maxsplit-arg]
+16 16 | "1,2,3".rsplit(",")[0]  # [missing-maxsplit-arg]
+17 17 | "1,2,3".rsplit(",")[-1]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:15:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 13 | ## Test split called directly on string literal
 14 | "1,2,3".split(",")[0]  # [missing-maxsplit-arg]
@@ -20,8 +31,19 @@ missing_maxsplit_arg.py:15:1: PLC0207 Instead of `str.split()`, call `str.rsplit
 16 | "1,2,3".rsplit(",")[0]  # [missing-maxsplit-arg]
 17 | "1,2,3".rsplit(",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.rsplit()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:16:1: PLC0207 Instead of `str.rsplit()`, call `str.split()` and pass `maxsplit=1`
+ℹ Safe fix
+12 12 | # Errors
+13 13 | ## Test split called directly on string literal
+14 14 | "1,2,3".split(",")[0]  # [missing-maxsplit-arg]
+15    |-"1,2,3".split(",")[-1]  # [missing-maxsplit-arg]
+   15 |+"1,2,3".rsplit(",", maxsplit=1)[-1]  # [missing-maxsplit-arg]
+16 16 | "1,2,3".rsplit(",")[0]  # [missing-maxsplit-arg]
+17 17 | "1,2,3".rsplit(",")[-1]  # [missing-maxsplit-arg]
+18 18 | 
+
+missing_maxsplit_arg.py:16:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 14 | "1,2,3".split(",")[0]  # [missing-maxsplit-arg]
 15 | "1,2,3".split(",")[-1]  # [missing-maxsplit-arg]
@@ -29,8 +51,19 @@ missing_maxsplit_arg.py:16:1: PLC0207 Instead of `str.rsplit()`, call `str.split
    | ^^^^^^^^^^^^^^^^^^^^^^ PLC0207
 17 | "1,2,3".rsplit(",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.split()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:17:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
+ℹ Safe fix
+13 13 | ## Test split called directly on string literal
+14 14 | "1,2,3".split(",")[0]  # [missing-maxsplit-arg]
+15 15 | "1,2,3".split(",")[-1]  # [missing-maxsplit-arg]
+16    |-"1,2,3".rsplit(",")[0]  # [missing-maxsplit-arg]
+   16 |+"1,2,3".split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+17 17 | "1,2,3".rsplit(",")[-1]  # [missing-maxsplit-arg]
+18 18 | 
+19 19 | ## Test split called on string variable
+
+missing_maxsplit_arg.py:17:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 15 | "1,2,3".split(",")[-1]  # [missing-maxsplit-arg]
 16 | "1,2,3".rsplit(",")[0]  # [missing-maxsplit-arg]
@@ -39,8 +72,19 @@ missing_maxsplit_arg.py:17:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
 18 |
 19 | ## Test split called on string variable
    |
+   = help: Pass `maxsplit=1` into `str.rsplit()`
 
-missing_maxsplit_arg.py:20:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Safe fix
+14 14 | "1,2,3".split(",")[0]  # [missing-maxsplit-arg]
+15 15 | "1,2,3".split(",")[-1]  # [missing-maxsplit-arg]
+16 16 | "1,2,3".rsplit(",")[0]  # [missing-maxsplit-arg]
+17    |-"1,2,3".rsplit(",")[-1]  # [missing-maxsplit-arg]
+   17 |+"1,2,3".rsplit(",", maxsplit=1)[-1]  # [missing-maxsplit-arg]
+18 18 | 
+19 19 | ## Test split called on string variable
+20 20 | SEQ.split(",")[0]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:20:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 19 | ## Test split called on string variable
 20 | SEQ.split(",")[0]  # [missing-maxsplit-arg]
@@ -48,8 +92,19 @@ missing_maxsplit_arg.py:20:1: PLC0207 Pass `maxsplit=1` into `str.split()`
 21 | SEQ.split(",")[-1]  # [missing-maxsplit-arg]
 22 | SEQ.rsplit(",")[0]  # [missing-maxsplit-arg]
    |
+   = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:21:1: PLC0207 Instead of `str.split()`, call `str.rsplit()` and pass `maxsplit=1`
+ℹ Safe fix
+17 17 | "1,2,3".rsplit(",")[-1]  # [missing-maxsplit-arg]
+18 18 | 
+19 19 | ## Test split called on string variable
+20    |-SEQ.split(",")[0]  # [missing-maxsplit-arg]
+   20 |+SEQ.split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+21 21 | SEQ.split(",")[-1]  # [missing-maxsplit-arg]
+22 22 | SEQ.rsplit(",")[0]  # [missing-maxsplit-arg]
+23 23 | SEQ.rsplit(",")[-1]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:21:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 19 | ## Test split called on string variable
 20 | SEQ.split(",")[0]  # [missing-maxsplit-arg]
@@ -58,8 +113,19 @@ missing_maxsplit_arg.py:21:1: PLC0207 Instead of `str.split()`, call `str.rsplit
 22 | SEQ.rsplit(",")[0]  # [missing-maxsplit-arg]
 23 | SEQ.rsplit(",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.rsplit()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:22:1: PLC0207 Instead of `str.rsplit()`, call `str.split()` and pass `maxsplit=1`
+ℹ Safe fix
+18 18 | 
+19 19 | ## Test split called on string variable
+20 20 | SEQ.split(",")[0]  # [missing-maxsplit-arg]
+21    |-SEQ.split(",")[-1]  # [missing-maxsplit-arg]
+   21 |+SEQ.rsplit(",", maxsplit=1)[-1]  # [missing-maxsplit-arg]
+22 22 | SEQ.rsplit(",")[0]  # [missing-maxsplit-arg]
+23 23 | SEQ.rsplit(",")[-1]  # [missing-maxsplit-arg]
+24 24 | 
+
+missing_maxsplit_arg.py:22:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 20 | SEQ.split(",")[0]  # [missing-maxsplit-arg]
 21 | SEQ.split(",")[-1]  # [missing-maxsplit-arg]
@@ -67,8 +133,19 @@ missing_maxsplit_arg.py:22:1: PLC0207 Instead of `str.rsplit()`, call `str.split
    | ^^^^^^^^^^^^^^^^^^ PLC0207
 23 | SEQ.rsplit(",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.split()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:23:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
+ℹ Safe fix
+19 19 | ## Test split called on string variable
+20 20 | SEQ.split(",")[0]  # [missing-maxsplit-arg]
+21 21 | SEQ.split(",")[-1]  # [missing-maxsplit-arg]
+22    |-SEQ.rsplit(",")[0]  # [missing-maxsplit-arg]
+   22 |+SEQ.split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+23 23 | SEQ.rsplit(",")[-1]  # [missing-maxsplit-arg]
+24 24 | 
+25 25 | ## Test split called on class attribute
+
+missing_maxsplit_arg.py:23:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 21 | SEQ.split(",")[-1]  # [missing-maxsplit-arg]
 22 | SEQ.rsplit(",")[0]  # [missing-maxsplit-arg]
@@ -77,8 +154,19 @@ missing_maxsplit_arg.py:23:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
 24 |
 25 | ## Test split called on class attribute
    |
+   = help: Pass `maxsplit=1` into `str.rsplit()`
 
-missing_maxsplit_arg.py:26:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Safe fix
+20 20 | SEQ.split(",")[0]  # [missing-maxsplit-arg]
+21 21 | SEQ.split(",")[-1]  # [missing-maxsplit-arg]
+22 22 | SEQ.rsplit(",")[0]  # [missing-maxsplit-arg]
+23    |-SEQ.rsplit(",")[-1]  # [missing-maxsplit-arg]
+   23 |+SEQ.rsplit(",", maxsplit=1)[-1]  # [missing-maxsplit-arg]
+24 24 | 
+25 25 | ## Test split called on class attribute
+26 26 | Foo.class_str.split(",")[0]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:26:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 25 | ## Test split called on class attribute
 26 | Foo.class_str.split(",")[0]  # [missing-maxsplit-arg]
@@ -86,8 +174,19 @@ missing_maxsplit_arg.py:26:1: PLC0207 Pass `maxsplit=1` into `str.split()`
 27 | Foo.class_str.split(",")[-1]  # [missing-maxsplit-arg]
 28 | Foo.class_str.rsplit(",")[0]  # [missing-maxsplit-arg]
    |
+   = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:27:1: PLC0207 Instead of `str.split()`, call `str.rsplit()` and pass `maxsplit=1`
+ℹ Safe fix
+23 23 | SEQ.rsplit(",")[-1]  # [missing-maxsplit-arg]
+24 24 | 
+25 25 | ## Test split called on class attribute
+26    |-Foo.class_str.split(",")[0]  # [missing-maxsplit-arg]
+   26 |+Foo.class_str.split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+27 27 | Foo.class_str.split(",")[-1]  # [missing-maxsplit-arg]
+28 28 | Foo.class_str.rsplit(",")[0]  # [missing-maxsplit-arg]
+29 29 | Foo.class_str.rsplit(",")[-1]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:27:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 25 | ## Test split called on class attribute
 26 | Foo.class_str.split(",")[0]  # [missing-maxsplit-arg]
@@ -96,8 +195,19 @@ missing_maxsplit_arg.py:27:1: PLC0207 Instead of `str.split()`, call `str.rsplit
 28 | Foo.class_str.rsplit(",")[0]  # [missing-maxsplit-arg]
 29 | Foo.class_str.rsplit(",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.rsplit()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:28:1: PLC0207 Instead of `str.rsplit()`, call `str.split()` and pass `maxsplit=1`
+ℹ Safe fix
+24 24 | 
+25 25 | ## Test split called on class attribute
+26 26 | Foo.class_str.split(",")[0]  # [missing-maxsplit-arg]
+27    |-Foo.class_str.split(",")[-1]  # [missing-maxsplit-arg]
+   27 |+Foo.class_str.rsplit(",", maxsplit=1)[-1]  # [missing-maxsplit-arg]
+28 28 | Foo.class_str.rsplit(",")[0]  # [missing-maxsplit-arg]
+29 29 | Foo.class_str.rsplit(",")[-1]  # [missing-maxsplit-arg]
+30 30 | 
+
+missing_maxsplit_arg.py:28:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 26 | Foo.class_str.split(",")[0]  # [missing-maxsplit-arg]
 27 | Foo.class_str.split(",")[-1]  # [missing-maxsplit-arg]
@@ -105,8 +215,19 @@ missing_maxsplit_arg.py:28:1: PLC0207 Instead of `str.rsplit()`, call `str.split
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLC0207
 29 | Foo.class_str.rsplit(",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.split()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:29:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
+ℹ Safe fix
+25 25 | ## Test split called on class attribute
+26 26 | Foo.class_str.split(",")[0]  # [missing-maxsplit-arg]
+27 27 | Foo.class_str.split(",")[-1]  # [missing-maxsplit-arg]
+28    |-Foo.class_str.rsplit(",")[0]  # [missing-maxsplit-arg]
+   28 |+Foo.class_str.split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+29 29 | Foo.class_str.rsplit(",")[-1]  # [missing-maxsplit-arg]
+30 30 | 
+31 31 | ## Test split called on sliced string
+
+missing_maxsplit_arg.py:29:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 27 | Foo.class_str.split(",")[-1]  # [missing-maxsplit-arg]
 28 | Foo.class_str.rsplit(",")[0]  # [missing-maxsplit-arg]
@@ -115,8 +236,19 @@ missing_maxsplit_arg.py:29:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
 30 |
 31 | ## Test split called on sliced string
    |
+   = help: Pass `maxsplit=1` into `str.rsplit()`
 
-missing_maxsplit_arg.py:32:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Safe fix
+26 26 | Foo.class_str.split(",")[0]  # [missing-maxsplit-arg]
+27 27 | Foo.class_str.split(",")[-1]  # [missing-maxsplit-arg]
+28 28 | Foo.class_str.rsplit(",")[0]  # [missing-maxsplit-arg]
+29    |-Foo.class_str.rsplit(",")[-1]  # [missing-maxsplit-arg]
+   29 |+Foo.class_str.rsplit(",", maxsplit=1)[-1]  # [missing-maxsplit-arg]
+30 30 | 
+31 31 | ## Test split called on sliced string
+32 32 | "1,2,3"[::-1].split(",")[0]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:32:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 31 | ## Test split called on sliced string
 32 | "1,2,3"[::-1].split(",")[0]  # [missing-maxsplit-arg]
@@ -124,8 +256,19 @@ missing_maxsplit_arg.py:32:1: PLC0207 Pass `maxsplit=1` into `str.split()`
 33 | "1,2,3"[::-1][::-1].split(",")[0]  # [missing-maxsplit-arg]
 34 | SEQ[:3].split(",")[0]  # [missing-maxsplit-arg]
    |
+   = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:33:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Safe fix
+29 29 | Foo.class_str.rsplit(",")[-1]  # [missing-maxsplit-arg]
+30 30 | 
+31 31 | ## Test split called on sliced string
+32    |-"1,2,3"[::-1].split(",")[0]  # [missing-maxsplit-arg]
+   32 |+"1,2,3"[::-1].split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+33 33 | "1,2,3"[::-1][::-1].split(",")[0]  # [missing-maxsplit-arg]
+34 34 | SEQ[:3].split(",")[0]  # [missing-maxsplit-arg]
+35 35 | Foo.class_str[1:3].split(",")[-1]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:33:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 31 | ## Test split called on sliced string
 32 | "1,2,3"[::-1].split(",")[0]  # [missing-maxsplit-arg]
@@ -134,8 +277,19 @@ missing_maxsplit_arg.py:33:1: PLC0207 Pass `maxsplit=1` into `str.split()`
 34 | SEQ[:3].split(",")[0]  # [missing-maxsplit-arg]
 35 | Foo.class_str[1:3].split(",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:34:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Safe fix
+30 30 | 
+31 31 | ## Test split called on sliced string
+32 32 | "1,2,3"[::-1].split(",")[0]  # [missing-maxsplit-arg]
+33    |-"1,2,3"[::-1][::-1].split(",")[0]  # [missing-maxsplit-arg]
+   33 |+"1,2,3"[::-1][::-1].split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+34 34 | SEQ[:3].split(",")[0]  # [missing-maxsplit-arg]
+35 35 | Foo.class_str[1:3].split(",")[-1]  # [missing-maxsplit-arg]
+36 36 | "1,2,3"[::-1].rsplit(",")[0]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:34:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 32 | "1,2,3"[::-1].split(",")[0]  # [missing-maxsplit-arg]
 33 | "1,2,3"[::-1][::-1].split(",")[0]  # [missing-maxsplit-arg]
@@ -144,8 +298,19 @@ missing_maxsplit_arg.py:34:1: PLC0207 Pass `maxsplit=1` into `str.split()`
 35 | Foo.class_str[1:3].split(",")[-1]  # [missing-maxsplit-arg]
 36 | "1,2,3"[::-1].rsplit(",")[0]  # [missing-maxsplit-arg]
    |
+   = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:35:1: PLC0207 Instead of `str.split()`, call `str.rsplit()` and pass `maxsplit=1`
+ℹ Safe fix
+31 31 | ## Test split called on sliced string
+32 32 | "1,2,3"[::-1].split(",")[0]  # [missing-maxsplit-arg]
+33 33 | "1,2,3"[::-1][::-1].split(",")[0]  # [missing-maxsplit-arg]
+34    |-SEQ[:3].split(",")[0]  # [missing-maxsplit-arg]
+   34 |+SEQ[:3].split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+35 35 | Foo.class_str[1:3].split(",")[-1]  # [missing-maxsplit-arg]
+36 36 | "1,2,3"[::-1].rsplit(",")[0]  # [missing-maxsplit-arg]
+37 37 | SEQ[:3].rsplit(",")[0]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:35:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 33 | "1,2,3"[::-1][::-1].split(",")[0]  # [missing-maxsplit-arg]
 34 | SEQ[:3].split(",")[0]  # [missing-maxsplit-arg]
@@ -154,8 +319,19 @@ missing_maxsplit_arg.py:35:1: PLC0207 Instead of `str.split()`, call `str.rsplit
 36 | "1,2,3"[::-1].rsplit(",")[0]  # [missing-maxsplit-arg]
 37 | SEQ[:3].rsplit(",")[0]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.rsplit()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:36:1: PLC0207 Instead of `str.rsplit()`, call `str.split()` and pass `maxsplit=1`
+ℹ Safe fix
+32 32 | "1,2,3"[::-1].split(",")[0]  # [missing-maxsplit-arg]
+33 33 | "1,2,3"[::-1][::-1].split(",")[0]  # [missing-maxsplit-arg]
+34 34 | SEQ[:3].split(",")[0]  # [missing-maxsplit-arg]
+35    |-Foo.class_str[1:3].split(",")[-1]  # [missing-maxsplit-arg]
+   35 |+Foo.class_str[1:3].rsplit(",", maxsplit=1)[-1]  # [missing-maxsplit-arg]
+36 36 | "1,2,3"[::-1].rsplit(",")[0]  # [missing-maxsplit-arg]
+37 37 | SEQ[:3].rsplit(",")[0]  # [missing-maxsplit-arg]
+38 38 | Foo.class_str[1:3].rsplit(",")[-1]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:36:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 34 | SEQ[:3].split(",")[0]  # [missing-maxsplit-arg]
 35 | Foo.class_str[1:3].split(",")[-1]  # [missing-maxsplit-arg]
@@ -164,8 +340,19 @@ missing_maxsplit_arg.py:36:1: PLC0207 Instead of `str.rsplit()`, call `str.split
 37 | SEQ[:3].rsplit(",")[0]  # [missing-maxsplit-arg]
 38 | Foo.class_str[1:3].rsplit(",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.split()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:37:1: PLC0207 Instead of `str.rsplit()`, call `str.split()` and pass `maxsplit=1`
+ℹ Safe fix
+33 33 | "1,2,3"[::-1][::-1].split(",")[0]  # [missing-maxsplit-arg]
+34 34 | SEQ[:3].split(",")[0]  # [missing-maxsplit-arg]
+35 35 | Foo.class_str[1:3].split(",")[-1]  # [missing-maxsplit-arg]
+36    |-"1,2,3"[::-1].rsplit(",")[0]  # [missing-maxsplit-arg]
+   36 |+"1,2,3"[::-1].split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+37 37 | SEQ[:3].rsplit(",")[0]  # [missing-maxsplit-arg]
+38 38 | Foo.class_str[1:3].rsplit(",")[-1]  # [missing-maxsplit-arg]
+39 39 | 
+
+missing_maxsplit_arg.py:37:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 35 | Foo.class_str[1:3].split(",")[-1]  # [missing-maxsplit-arg]
 36 | "1,2,3"[::-1].rsplit(",")[0]  # [missing-maxsplit-arg]
@@ -173,8 +360,19 @@ missing_maxsplit_arg.py:37:1: PLC0207 Instead of `str.rsplit()`, call `str.split
    | ^^^^^^^^^^^^^^^^^^^^^^ PLC0207
 38 | Foo.class_str[1:3].rsplit(",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.split()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:38:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
+ℹ Safe fix
+34 34 | SEQ[:3].split(",")[0]  # [missing-maxsplit-arg]
+35 35 | Foo.class_str[1:3].split(",")[-1]  # [missing-maxsplit-arg]
+36 36 | "1,2,3"[::-1].rsplit(",")[0]  # [missing-maxsplit-arg]
+37    |-SEQ[:3].rsplit(",")[0]  # [missing-maxsplit-arg]
+   37 |+SEQ[:3].split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+38 38 | Foo.class_str[1:3].rsplit(",")[-1]  # [missing-maxsplit-arg]
+39 39 | 
+40 40 | ## Test sep given as named argument
+
+missing_maxsplit_arg.py:38:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 36 | "1,2,3"[::-1].rsplit(",")[0]  # [missing-maxsplit-arg]
 37 | SEQ[:3].rsplit(",")[0]  # [missing-maxsplit-arg]
@@ -183,8 +381,19 @@ missing_maxsplit_arg.py:38:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
 39 |
 40 | ## Test sep given as named argument
    |
+   = help: Pass `maxsplit=1` into `str.rsplit()`
 
-missing_maxsplit_arg.py:41:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Safe fix
+35 35 | Foo.class_str[1:3].split(",")[-1]  # [missing-maxsplit-arg]
+36 36 | "1,2,3"[::-1].rsplit(",")[0]  # [missing-maxsplit-arg]
+37 37 | SEQ[:3].rsplit(",")[0]  # [missing-maxsplit-arg]
+38    |-Foo.class_str[1:3].rsplit(",")[-1]  # [missing-maxsplit-arg]
+   38 |+Foo.class_str[1:3].rsplit(",", maxsplit=1)[-1]  # [missing-maxsplit-arg]
+39 39 | 
+40 40 | ## Test sep given as named argument
+41 41 | "1,2,3".split(sep=",")[0]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:41:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 40 | ## Test sep given as named argument
 41 | "1,2,3".split(sep=",")[0]  # [missing-maxsplit-arg]
@@ -192,8 +401,19 @@ missing_maxsplit_arg.py:41:1: PLC0207 Pass `maxsplit=1` into `str.split()`
 42 | "1,2,3".split(sep=",")[-1]  # [missing-maxsplit-arg]
 43 | "1,2,3".rsplit(sep=",")[0]  # [missing-maxsplit-arg]
    |
+   = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:42:1: PLC0207 Instead of `str.split()`, call `str.rsplit()` and pass `maxsplit=1`
+ℹ Safe fix
+38 38 | Foo.class_str[1:3].rsplit(",")[-1]  # [missing-maxsplit-arg]
+39 39 | 
+40 40 | ## Test sep given as named argument
+41    |-"1,2,3".split(sep=",")[0]  # [missing-maxsplit-arg]
+   41 |+"1,2,3".split(maxsplit=1, sep=",")[0]  # [missing-maxsplit-arg]
+42 42 | "1,2,3".split(sep=",")[-1]  # [missing-maxsplit-arg]
+43 43 | "1,2,3".rsplit(sep=",")[0]  # [missing-maxsplit-arg]
+44 44 | "1,2,3".rsplit(sep=",")[-1]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:42:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 40 | ## Test sep given as named argument
 41 | "1,2,3".split(sep=",")[0]  # [missing-maxsplit-arg]
@@ -202,8 +422,19 @@ missing_maxsplit_arg.py:42:1: PLC0207 Instead of `str.split()`, call `str.rsplit
 43 | "1,2,3".rsplit(sep=",")[0]  # [missing-maxsplit-arg]
 44 | "1,2,3".rsplit(sep=",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.rsplit()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:43:1: PLC0207 Instead of `str.rsplit()`, call `str.split()` and pass `maxsplit=1`
+ℹ Safe fix
+39 39 | 
+40 40 | ## Test sep given as named argument
+41 41 | "1,2,3".split(sep=",")[0]  # [missing-maxsplit-arg]
+42    |-"1,2,3".split(sep=",")[-1]  # [missing-maxsplit-arg]
+   42 |+"1,2,3".rsplit(maxsplit=1, sep=",")[-1]  # [missing-maxsplit-arg]
+43 43 | "1,2,3".rsplit(sep=",")[0]  # [missing-maxsplit-arg]
+44 44 | "1,2,3".rsplit(sep=",")[-1]  # [missing-maxsplit-arg]
+45 45 | 
+
+missing_maxsplit_arg.py:43:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 41 | "1,2,3".split(sep=",")[0]  # [missing-maxsplit-arg]
 42 | "1,2,3".split(sep=",")[-1]  # [missing-maxsplit-arg]
@@ -211,8 +442,19 @@ missing_maxsplit_arg.py:43:1: PLC0207 Instead of `str.rsplit()`, call `str.split
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^ PLC0207
 44 | "1,2,3".rsplit(sep=",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.split()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:44:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
+ℹ Safe fix
+40 40 | ## Test sep given as named argument
+41 41 | "1,2,3".split(sep=",")[0]  # [missing-maxsplit-arg]
+42 42 | "1,2,3".split(sep=",")[-1]  # [missing-maxsplit-arg]
+43    |-"1,2,3".rsplit(sep=",")[0]  # [missing-maxsplit-arg]
+   43 |+"1,2,3".split(maxsplit=1, sep=",")[0]  # [missing-maxsplit-arg]
+44 44 | "1,2,3".rsplit(sep=",")[-1]  # [missing-maxsplit-arg]
+45 45 | 
+46 46 | ## Special cases
+
+missing_maxsplit_arg.py:44:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 42 | "1,2,3".split(sep=",")[-1]  # [missing-maxsplit-arg]
 43 | "1,2,3".rsplit(sep=",")[0]  # [missing-maxsplit-arg]
@@ -221,8 +463,19 @@ missing_maxsplit_arg.py:44:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
 45 |
 46 | ## Special cases
    |
+   = help: Pass `maxsplit=1` into `str.rsplit()`
 
-missing_maxsplit_arg.py:47:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Safe fix
+41 41 | "1,2,3".split(sep=",")[0]  # [missing-maxsplit-arg]
+42 42 | "1,2,3".split(sep=",")[-1]  # [missing-maxsplit-arg]
+43 43 | "1,2,3".rsplit(sep=",")[0]  # [missing-maxsplit-arg]
+44    |-"1,2,3".rsplit(sep=",")[-1]  # [missing-maxsplit-arg]
+   44 |+"1,2,3".rsplit(maxsplit=1, sep=",")[-1]  # [missing-maxsplit-arg]
+45 45 | 
+46 46 | ## Special cases
+47 47 | "1,2,3".split("\n")[0]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:47:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 46 | ## Special cases
 47 | "1,2,3".split("\n")[0]  # [missing-maxsplit-arg]
@@ -230,8 +483,19 @@ missing_maxsplit_arg.py:47:1: PLC0207 Pass `maxsplit=1` into `str.split()`
 48 | "1,2,3".split("split")[-1]  # [missing-maxsplit-arg]
 49 | "1,2,3".rsplit("rsplit")[0]  # [missing-maxsplit-arg]
    |
+   = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:48:1: PLC0207 Instead of `str.split()`, call `str.rsplit()` and pass `maxsplit=1`
+ℹ Safe fix
+44 44 | "1,2,3".rsplit(sep=",")[-1]  # [missing-maxsplit-arg]
+45 45 | 
+46 46 | ## Special cases
+47    |-"1,2,3".split("\n")[0]  # [missing-maxsplit-arg]
+   47 |+"1,2,3".split("\n", maxsplit=1)[0]  # [missing-maxsplit-arg]
+48 48 | "1,2,3".split("split")[-1]  # [missing-maxsplit-arg]
+49 49 | "1,2,3".rsplit("rsplit")[0]  # [missing-maxsplit-arg]
+50 50 | 
+
+missing_maxsplit_arg.py:48:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 46 | ## Special cases
 47 | "1,2,3".split("\n")[0]  # [missing-maxsplit-arg]
@@ -239,8 +503,19 @@ missing_maxsplit_arg.py:48:1: PLC0207 Instead of `str.split()`, call `str.rsplit
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^ PLC0207
 49 | "1,2,3".rsplit("rsplit")[0]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.rsplit()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:49:1: PLC0207 Instead of `str.rsplit()`, call `str.split()` and pass `maxsplit=1`
+ℹ Safe fix
+45 45 | 
+46 46 | ## Special cases
+47 47 | "1,2,3".split("\n")[0]  # [missing-maxsplit-arg]
+48    |-"1,2,3".split("split")[-1]  # [missing-maxsplit-arg]
+   48 |+"1,2,3".rsplit("split", maxsplit=1)[-1]  # [missing-maxsplit-arg]
+49 49 | "1,2,3".rsplit("rsplit")[0]  # [missing-maxsplit-arg]
+50 50 | 
+51 51 | ## Test class attribute named split
+
+missing_maxsplit_arg.py:49:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 47 | "1,2,3".split("\n")[0]  # [missing-maxsplit-arg]
 48 | "1,2,3".split("split")[-1]  # [missing-maxsplit-arg]
@@ -249,8 +524,19 @@ missing_maxsplit_arg.py:49:1: PLC0207 Instead of `str.rsplit()`, call `str.split
 50 |
 51 | ## Test class attribute named split
    |
+   = help: Use `str.split()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:52:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Safe fix
+46 46 | ## Special cases
+47 47 | "1,2,3".split("\n")[0]  # [missing-maxsplit-arg]
+48 48 | "1,2,3".split("split")[-1]  # [missing-maxsplit-arg]
+49    |-"1,2,3".rsplit("rsplit")[0]  # [missing-maxsplit-arg]
+   49 |+"1,2,3".split("rsplit", maxsplit=1)[0]  # [missing-maxsplit-arg]
+50 50 | 
+51 51 | ## Test class attribute named split
+52 52 | Bar.split.split(",")[0]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:52:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 51 | ## Test class attribute named split
 52 | Bar.split.split(",")[0]  # [missing-maxsplit-arg]
@@ -258,8 +544,19 @@ missing_maxsplit_arg.py:52:1: PLC0207 Pass `maxsplit=1` into `str.split()`
 53 | Bar.split.split(",")[-1]  # [missing-maxsplit-arg]
 54 | Bar.split.rsplit(",")[0]  # [missing-maxsplit-arg]
    |
+   = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:53:1: PLC0207 Instead of `str.split()`, call `str.rsplit()` and pass `maxsplit=1`
+ℹ Safe fix
+49 49 | "1,2,3".rsplit("rsplit")[0]  # [missing-maxsplit-arg]
+50 50 | 
+51 51 | ## Test class attribute named split
+52    |-Bar.split.split(",")[0]  # [missing-maxsplit-arg]
+   52 |+Bar.split.split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+53 53 | Bar.split.split(",")[-1]  # [missing-maxsplit-arg]
+54 54 | Bar.split.rsplit(",")[0]  # [missing-maxsplit-arg]
+55 55 | Bar.split.rsplit(",")[-1]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:53:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 51 | ## Test class attribute named split
 52 | Bar.split.split(",")[0]  # [missing-maxsplit-arg]
@@ -268,8 +565,19 @@ missing_maxsplit_arg.py:53:1: PLC0207 Instead of `str.split()`, call `str.rsplit
 54 | Bar.split.rsplit(",")[0]  # [missing-maxsplit-arg]
 55 | Bar.split.rsplit(",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.rsplit()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:54:1: PLC0207 Instead of `str.rsplit()`, call `str.split()` and pass `maxsplit=1`
+ℹ Safe fix
+50 50 | 
+51 51 | ## Test class attribute named split
+52 52 | Bar.split.split(",")[0]  # [missing-maxsplit-arg]
+53    |-Bar.split.split(",")[-1]  # [missing-maxsplit-arg]
+   53 |+Bar.split.rsplit(",", maxsplit=1)[-1]  # [missing-maxsplit-arg]
+54 54 | Bar.split.rsplit(",")[0]  # [missing-maxsplit-arg]
+55 55 | Bar.split.rsplit(",")[-1]  # [missing-maxsplit-arg]
+56 56 | 
+
+missing_maxsplit_arg.py:54:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 52 | Bar.split.split(",")[0]  # [missing-maxsplit-arg]
 53 | Bar.split.split(",")[-1]  # [missing-maxsplit-arg]
@@ -277,8 +585,19 @@ missing_maxsplit_arg.py:54:1: PLC0207 Instead of `str.rsplit()`, call `str.split
    | ^^^^^^^^^^^^^^^^^^^^^^^^ PLC0207
 55 | Bar.split.rsplit(",")[-1]  # [missing-maxsplit-arg]
    |
+   = help: Use `str.split()` and pass `maxsplit=1`
 
-missing_maxsplit_arg.py:55:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
+ℹ Safe fix
+51 51 | ## Test class attribute named split
+52 52 | Bar.split.split(",")[0]  # [missing-maxsplit-arg]
+53 53 | Bar.split.split(",")[-1]  # [missing-maxsplit-arg]
+54    |-Bar.split.rsplit(",")[0]  # [missing-maxsplit-arg]
+   54 |+Bar.split.split(",", maxsplit=1)[0]  # [missing-maxsplit-arg]
+55 55 | Bar.split.rsplit(",")[-1]  # [missing-maxsplit-arg]
+56 56 | 
+57 57 | ## Test unpacked dict literal kwargs 
+
+missing_maxsplit_arg.py:55:1: PLC0207 [*] Replace with `rsplit(..., maxsplit=1)`.
    |
 53 | Bar.split.split(",")[-1]  # [missing-maxsplit-arg]
 54 | Bar.split.rsplit(",")[0]  # [missing-maxsplit-arg]
@@ -287,15 +606,37 @@ missing_maxsplit_arg.py:55:1: PLC0207 Pass `maxsplit=1` into `str.rsplit()`
 56 |
 57 | ## Test unpacked dict literal kwargs 
    |
+   = help: Pass `maxsplit=1` into `str.rsplit()`
 
-missing_maxsplit_arg.py:58:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Safe fix
+52 52 | Bar.split.split(",")[0]  # [missing-maxsplit-arg]
+53 53 | Bar.split.split(",")[-1]  # [missing-maxsplit-arg]
+54 54 | Bar.split.rsplit(",")[0]  # [missing-maxsplit-arg]
+55    |-Bar.split.rsplit(",")[-1]  # [missing-maxsplit-arg]
+   55 |+Bar.split.rsplit(",", maxsplit=1)[-1]  # [missing-maxsplit-arg]
+56 56 | 
+57 57 | ## Test unpacked dict literal kwargs 
+58 58 | "1,2,3".split(**{"sep": ","})[0]  # [missing-maxsplit-arg]
+
+missing_maxsplit_arg.py:58:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
    |
 57 | ## Test unpacked dict literal kwargs 
 58 | "1,2,3".split(**{"sep": ","})[0]  # [missing-maxsplit-arg]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLC0207
    |
+   = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:179:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Unsafe fix
+55 55 | Bar.split.rsplit(",")[-1]  # [missing-maxsplit-arg]
+56 56 | 
+57 57 | ## Test unpacked dict literal kwargs 
+58    |-"1,2,3".split(**{"sep": ","})[0]  # [missing-maxsplit-arg]
+   58 |+"1,2,3".split(maxsplit=1, **{"sep": ","})[0]  # [missing-maxsplit-arg]
+59 59 | 
+60 60 | 
+61 61 | # OK
+
+missing_maxsplit_arg.py:179:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
     |
 177 | # Errors
 178 | kwargs_without_maxsplit = {"seq": ","}
@@ -304,8 +645,19 @@ missing_maxsplit_arg.py:179:1: PLC0207 Pass `maxsplit=1` into `str.split()`
 180 | # OK
 181 | kwargs_with_maxsplit = {"maxsplit": 1}
     |
+    = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:182:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Unsafe fix
+176 176 | ## TODO: These require the ability to resolve a dict variable name to a value
+177 177 | # Errors
+178 178 | kwargs_without_maxsplit = {"seq": ","}
+179     |-"1,2,3".split(**kwargs_without_maxsplit)[0]  # TODO: [missing-maxsplit-arg]
+    179 |+"1,2,3".split(maxsplit=1, **kwargs_without_maxsplit)[0]  # TODO: [missing-maxsplit-arg]
+180 180 | # OK
+181 181 | kwargs_with_maxsplit = {"maxsplit": 1}
+182 182 | "1,2,3".split(",", **kwargs_with_maxsplit)[0]  # TODO: false positive
+
+missing_maxsplit_arg.py:182:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
     |
 180 | # OK
 181 | kwargs_with_maxsplit = {"maxsplit": 1}
@@ -314,11 +666,29 @@ missing_maxsplit_arg.py:182:1: PLC0207 Pass `maxsplit=1` into `str.split()`
 183 | kwargs_with_maxsplit = {"sep": ",", "maxsplit": 1}
 184 | "1,2,3".split(**kwargs_with_maxsplit)[0]  # TODO: false positive
     |
+    = help: Pass `maxsplit=1` into `str.split()`
 
-missing_maxsplit_arg.py:184:1: PLC0207 Pass `maxsplit=1` into `str.split()`
+ℹ Unsafe fix
+179 179 | "1,2,3".split(**kwargs_without_maxsplit)[0]  # TODO: [missing-maxsplit-arg]
+180 180 | # OK
+181 181 | kwargs_with_maxsplit = {"maxsplit": 1}
+182     |-"1,2,3".split(",", **kwargs_with_maxsplit)[0]  # TODO: false positive
+    182 |+"1,2,3".split(",", maxsplit=1, **kwargs_with_maxsplit)[0]  # TODO: false positive
+183 183 | kwargs_with_maxsplit = {"sep": ",", "maxsplit": 1}
+184 184 | "1,2,3".split(**kwargs_with_maxsplit)[0]  # TODO: false positive
+
+missing_maxsplit_arg.py:184:1: PLC0207 [*] Replace with `split(..., maxsplit=1)`.
     |
 182 | "1,2,3".split(",", **kwargs_with_maxsplit)[0]  # TODO: false positive
 183 | kwargs_with_maxsplit = {"sep": ",", "maxsplit": 1}
 184 | "1,2,3".split(**kwargs_with_maxsplit)[0]  # TODO: false positive
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLC0207
     |
+    = help: Pass `maxsplit=1` into `str.split()`
+
+ℹ Unsafe fix
+181 181 | kwargs_with_maxsplit = {"maxsplit": 1}
+182 182 | "1,2,3".split(",", **kwargs_with_maxsplit)[0]  # TODO: false positive
+183 183 | kwargs_with_maxsplit = {"sep": ",", "maxsplit": 1}
+184     |-"1,2,3".split(**kwargs_with_maxsplit)[0]  # TODO: false positive
+    184 |+"1,2,3".split(maxsplit=1, **kwargs_with_maxsplit)[0]  # TODO: false positive

crates/ruff_linter/src/rules/pyupgrade/mod.rs

@@ -7,16 +7,18 @@ pub(crate) mod types;
 
 #[cfg(test)]
 mod tests {
+    use std::collections::BTreeSet;
     use std::path::Path;
 
     use anyhow::Result;
     use ruff_python_ast::PythonVersion;
+    use ruff_python_semantic::{MemberNameImport, NameImport};
     use test_case::test_case;
 
     use crate::registry::Rule;
-    use crate::rules::pyupgrade;
+    use crate::rules::{isort, pyupgrade};
     use crate::settings::types::PreviewMode;
-    use crate::test::test_path;
+    use crate::test::{test_path, test_snippet};
     use crate::{assert_diagnostics, settings};
 
     #[test_case(Rule::ConvertNamedTupleFunctionalToClass, Path::new("UP014.py"))]
@@ -294,4 +296,63 @@ mod tests {
         assert_diagnostics!(diagnostics);
         Ok(())
     }
+
+    #[test]
+    fn i002_conflict() {
+        let diagnostics = test_snippet(
+            "from pipes import quote, Template",
+            &settings::LinterSettings {
+                isort: isort::settings::Settings {
+                    required_imports: BTreeSet::from_iter([
+                        // https://github.com/astral-sh/ruff/issues/18729
+                        NameImport::ImportFrom(MemberNameImport::member(
+                            "__future__".to_string(),
+                            "generator_stop".to_string(),
+                        )),
+                        // https://github.com/astral-sh/ruff/issues/16802
+                        NameImport::ImportFrom(MemberNameImport::member(
+                            "collections".to_string(),
+                            "Sequence".to_string(),
+                        )),
+                        // Only bail out if _all_ the names in UP035 are required. `pipes.Template`
+                        // isn't flagged by UP035, so requiring it shouldn't prevent `pipes.quote`
+                        // from getting a diagnostic.
+                        NameImport::ImportFrom(MemberNameImport::member(
+                            "pipes".to_string(),
+                            "Template".to_string(),
+                        )),
+                    ]),
+                    ..Default::default()
+                },
+                ..settings::LinterSettings::for_rules([
+                    Rule::MissingRequiredImport,
+                    Rule::UnnecessaryFutureImport,
+                    Rule::DeprecatedImport,
+                ])
+            },
+        );
+        assert_diagnostics!(diagnostics, @r"
+        <filename>:1:1: UP035 [*] Import from `shlex` instead: `quote`
+          |
+        1 | from pipes import quote, Template
+          | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ UP035
+          |
+          = help: Import from `shlex`
+
+        ℹ Safe fix
+        1   |-from pipes import quote, Template
+          1 |+from pipes import Template
+          2 |+from shlex import quote
+
+        <filename>:1:1: I002 [*] Missing required import: `from __future__ import generator_stop`
+        ℹ Safe fix
+          1 |+from __future__ import generator_stop
+        1 2 | from pipes import quote, Template
+
+        <filename>:1:1: I002 [*] Missing required import: `from collections import Sequence`
+        ℹ Safe fix
+          1 |+from collections import Sequence
+        1 2 | from pipes import quote, Template
+        ");
+    }
 }

crates/ruff_linter/src/rules/pyupgrade/rules/deprecated_import.rs

@@ -2,7 +2,7 @@ use itertools::Itertools;
 
 use ruff_macros::{ViolationMetadata, derive_message_formats};
 use ruff_python_ast::whitespace::indentation;
-use ruff_python_ast::{Alias, StmtImportFrom};
+use ruff_python_ast::{Alias, StmtImportFrom, StmtRef};
 use ruff_python_codegen::Stylist;
 use ruff_python_parser::Tokens;
 use ruff_text_size::Ranged;
@@ -10,9 +10,12 @@ use ruff_text_size::Ranged;
 use crate::Locator;
 use crate::checkers::ast::Checker;
 use crate::rules::pyupgrade::fixes;
+use crate::rules::pyupgrade::rules::unnecessary_future_import::is_import_required_by_isort;
 use crate::{Edit, Fix, FixAvailability, Violation};
 use ruff_python_ast::PythonVersion;
 
+use super::RequiredImports;
+
 /// An import was moved and renamed as part of a deprecation.
 /// For example, `typing.AbstractSet` was moved to `collections.abc.Set`.
 #[derive(Debug, PartialEq, Eq)]
@@ -410,6 +413,7 @@ struct ImportReplacer<'a> {
     stylist: &'a Stylist<'a>,
     tokens: &'a Tokens,
     version: PythonVersion,
+    required_imports: &'a RequiredImports,
 }
 
 impl<'a> ImportReplacer<'a> {
@@ -420,6 +424,7 @@ impl<'a> ImportReplacer<'a> {
         stylist: &'a Stylist<'a>,
         tokens: &'a Tokens,
         version: PythonVersion,
+        required_imports: &'a RequiredImports,
     ) -> Self {
         Self {
             import_from_stmt,
@@ -428,6 +433,7 @@ impl<'a> ImportReplacer<'a> {
             stylist,
             tokens,
             version,
+            required_imports,
         }
     }
 
@@ -437,6 +443,13 @@ impl<'a> ImportReplacer<'a> {
         if self.module == "typing" {
             if self.version >= PythonVersion::PY39 {
                 for member in &self.import_from_stmt.names {
+                    if is_import_required_by_isort(
+                        self.required_imports,
+                        StmtRef::ImportFrom(self.import_from_stmt),
+                        member,
+                    ) {
+                        continue;
+                    }
                     if let Some(target) = TYPING_TO_RENAME_PY39.iter().find_map(|(name, target)| {
                         if &member.name == *name {
                             Some(*target)
@@ -673,7 +686,13 @@ impl<'a> ImportReplacer<'a> {
         let mut matched_names = vec![];
         let mut unmatched_names = vec![];
         for name in &self.import_from_stmt.names {
-            if candidates.contains(&name.name.as_str()) {
+            if is_import_required_by_isort(
+                self.required_imports,
+                StmtRef::ImportFrom(self.import_from_stmt),
+                name,
+            ) {
+                unmatched_names.push(name);
+            } else if candidates.contains(&name.name.as_str()) {
                 matched_names.push(name);
             } else {
                 unmatched_names.push(name);
@@ -726,6 +745,7 @@ pub(crate) fn deprecated_import(checker: &Checker, import_from_stmt: &StmtImport
         checker.stylist(),
         checker.tokens(),
         checker.target_version(),
+        &checker.settings().isort.required_imports,
     );
 
     for (operation, fix) in fixer.without_renames() {

crates/ruff_linter/src/rules/pyupgrade/rules/format_literals.rs

@@ -124,10 +124,20 @@ fn is_sequential(indices: &[usize]) -> bool {
     indices.iter().enumerate().all(|(idx, value)| idx == *value)
 }
 
-// An opening curly brace, followed by any integer, followed by any text,
-// followed by a closing brace.
-static FORMAT_SPECIFIER: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"\{(?P<int>\d+)(?P<fmt>.*?)}").unwrap());
+static FORMAT_SPECIFIER: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(
+        r"(?x)
+            (?P<prefix>
+                ^|[^{]|(?:\{{2})+  # preceded by nothing, a non-brace, or an even number of braces
+            )
+            \{                     # opening curly brace
+                (?P<int>\d+)       # followed by any integer
+                (?P<fmt>.*?)       # followed by any text
+            }                      # followed by a closing brace
+        ",
+    )
+    .unwrap()
+});
 
 /// Remove the explicit positional indices from a format string.
 fn remove_specifiers<'a>(value: &mut Expression<'a>, arena: &'a typed_arena::Arena<String>) {
@@ -135,7 +145,7 @@ fn remove_specifiers<'a>(value: &mut Expression<'a>, arena: &'a typed_arena::Are
         Expression::SimpleString(expr) => {
             expr.value = arena.alloc(
                 FORMAT_SPECIFIER
-                    .replace_all(expr.value, "{$fmt}")
+                    .replace_all(expr.value, "$prefix{$fmt}")
                     .to_string(),
             );
         }
@@ -146,7 +156,7 @@ fn remove_specifiers<'a>(value: &mut Expression<'a>, arena: &'a typed_arena::Are
                     libcst_native::String::Simple(string) => {
                         string.value = arena.alloc(
                             FORMAT_SPECIFIER
-                                .replace_all(string.value, "{$fmt}")
+                                .replace_all(string.value, "$prefix{$fmt}")
                                 .to_string(),
                         );
                     }