Bump version to 0.0.98

.github/workflows/ci.yaml

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          profile: minimal
       - uses: actions/cache@v3
         env:
           cache-name: cache-cargo
@@ -27,7 +27,7 @@ jobs:
             ${{ runner.os }}-build-${{ env.cache-name }}-
             ${{ runner.os }}-build-
             ${{ runner.os }}-
-      - run: cargo build --release
+      - run: cargo build --all --release
 
   cargo_fmt:
     name: "cargo fmt"
@@ -36,7 +36,10 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          profile: minimal
+          toolchain: nightly-2022-11-01
+          override: true
+          components: rustfmt
       - uses: actions/cache@v3
         env:
           cache-name: cache-cargo
@@ -49,7 +52,7 @@ jobs:
             ${{ runner.os }}-build-${{ env.cache-name }}-
             ${{ runner.os }}-build-
             ${{ runner.os }}-
-      - run: cargo fmt --check
+      - run: cargo fmt --all --check
 
   cargo_clippy:
     name: "cargo clippy"
@@ -58,7 +61,10 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          profile: minimal
+          toolchain: nightly-2022-11-01
+          override: true
+          components: clippy
       - uses: actions/cache@v3
         env:
           cache-name: cache-cargo
@@ -71,7 +77,7 @@ jobs:
             ${{ runner.os }}-build-${{ env.cache-name }}-
             ${{ runner.os }}-build-
             ${{ runner.os }}-
-      - run: cargo clippy -- -D warnings
+      - run: cargo clippy --all -- -D warnings
 
   cargo_test:
     name: "cargo test"
@@ -80,7 +86,9 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          profile: minimal
+          toolchain: nightly-2022-11-01
+          override: true
       - uses: actions/cache@v3
         env:
           cache-name: cache-cargo
@@ -93,7 +101,7 @@ jobs:
             ${{ runner.os }}-build-${{ env.cache-name }}-
             ${{ runner.os }}-build-
             ${{ runner.os }}-
-      - run: cargo test
+      - run: cargo test --all
 
   maturin_build:
     name: "maturin build"
@@ -102,7 +110,9 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          profile: minimal
+          toolchain: nightly-2022-11-01
+          override: true
       - uses: actions/setup-python@v4
         with:
           python-version: "3.10"

.github/workflows/flake8-to-ruff.yaml

@@ -0,0 +1,298 @@
+name: "[flake8-to-ruff] Release"
+
+on: workflow_dispatch
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  PACKAGE_NAME: flake8-to-ruff
+  CRATE_NAME: flake8_to_ruff
+  PYTHON_VERSION: "3.7" # to build abi3 wheels
+
+jobs:
+  macos-x86_64:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels - x86_64
+        uses: messense/maturin-action@v1
+        with:
+          target: x86_64
+          args: --release --out dist --sdist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel - x86_64
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+  macos-universal:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels - universal2
+        uses: messense/maturin-action@v1
+        with:
+          args: --release --universal2 --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel - universal2
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*universal2.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target: [x64, x86]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: ${{ matrix.target }}
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        shell: bash
+        run: |
+          python -m pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64, i686]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  linux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [aarch64, armv7, s390x, ppc64le, ppc64]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --no-default-features --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@v2.0.5
+        if: matrix.target != 'ppc64'
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.target }}
+          distro: ubuntu20.04
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update
+            apt-get install -y --no-install-recommends python3 python3-pip
+            pip3 install -U pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target:
+          - x86_64-unknown-linux-musl
+          - i686-unknown-linux-musl
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64-unknown-linux-musl'
+        uses: addnab/docker-run-action@v3
+        with:
+          image: alpine:latest
+          options: -v ${{ github.workspace }}:/io -w /io
+          run: |
+            apk add py3-pip
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links /io/dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        platform:
+          - target: aarch64-unknown-linux-musl
+            arch: aarch64
+          - target: armv7-unknown-linux-musleabihf
+            arch: armv7
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@master
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.platform.arch }}
+          distro: alpine_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apk add py3-pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  pypy:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        target: [x86_64, aarch64]
+        python-version:
+          - "3.7"
+          - "3.8"
+          - "3.9"
+        exclude:
+          - os: macos-latest
+            target: aarch64
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: pypy${{ matrix.python-version }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          maturin-version: "v0.13.0"
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist -i pypy${{ matrix.python-version }} -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    needs:
+      - macos-universal
+      - macos-x86_64
+      - windows
+      - linux
+      - linux-cross
+      - musllinux
+      - musllinux-cross
+      - pypy
+    steps:
+      - uses: actions/download-artifact@v2
+        with:
+          name: wheels
+      - uses: actions/setup-python@v4
+      - name: Publish to PyPi
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.FLAKE8_TO_RUFF_TOKEN }}
+        run: |
+          pip install --upgrade twine
+          twine upload --skip-existing *

.github/workflows/ruff.yaml

@@ -1,8 +1,6 @@
-name: Release
+name: "[ruff] Release"
 
 on:
-  pull_request:
-    branches: [main]
   create:
     tags:
       - v*
@@ -297,7 +295,7 @@ jobs:
       - name: Publish to PyPi
         env:
           TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+          TWINE_PASSWORD: ${{ secrets.RUFF_TOKEN }}
         run: |
           pip install --upgrade twine
           twine upload --skip-existing *

.pre-commit-config.yaml

@@ -1,8 +1,8 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.40
+    rev: v0.0.98
     hooks:
-      - id: lint
+      - id: ruff
 
   - repo: https://github.com/abravalheri/validate-pyproject
     rev: v0.10.1

Cargo.lock

@@ -37,6 +37,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
 [[package]]
 name = "annotate-snippets"
 version = "0.6.1"
@@ -368,6 +374,12 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c1db59621ec70f09c5e9b597b220c7a2b43611f4710dc03ceb8748637775692c"
 
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
 [[package]]
 name = "cc"
 version = "1.0.73"
@@ -416,6 +428,45 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fff857943da45f546682664a79488be82e69e43c1a7a2307679ab9afb3a66d2e"
 
+[[package]]
+name = "ciborium"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c137568cc60b904a7724001b35ce2630fd00d5d84805fbb608ab89509d788f"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "346de753af073cc87b52b2083a506b38ac176a44cfb05497b622e27be899b369"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "213030a2b5a4e0c0892b6652260cf6ccac84827b83a85a534e178e3906c4cf1b"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "clap"
+version = "3.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71655c45cb9845d3270c9d6df84ebe72b4dad3c2ba3f7023ad47c144e4e473a5"
+dependencies = [
+ "bitflags",
+ "clap_lex 0.2.4",
+ "indexmap",
+ "textwrap 0.16.0",
+]
+
 [[package]]
 name = "clap"
 version = "4.0.15"
@@ -425,7 +476,7 @@ dependencies = [
  "atty",
  "bitflags",
  "clap_derive",
- "clap_lex",
+ "clap_lex 0.3.0",
  "once_cell",
  "strsim",
  "termcolor",
@@ -444,6 +495,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "clap_lex"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+dependencies = [
+ "os_str_bytes",
+]
+
 [[package]]
 name = "clap_lex"
 version = "0.3.0"
@@ -466,6 +526,15 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "codegen"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff61280aed771c3070e7dcc9e050c66f1eb1e3b96431ba66f9f74641d02fc41d"
+dependencies = [
+ "indexmap",
+]
+
 [[package]]
 name = "codespan-reporting"
 version = "0.11.1"
@@ -502,6 +571,12 @@ dependencies = [
  "cache-padded",
 ]
 
+[[package]]
+name = "configparser"
+version = "3.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5458d9d1a587efaf5091602c59d299696a3877a439c8f6d461a2d3cce11df87a"
+
 [[package]]
 name = "console"
 version = "0.15.2"
@@ -539,6 +614,42 @@ dependencies = [
  "cfg-if 1.0.0",
 ]
 
+[[package]]
+name = "criterion"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c76e09c1aae2bc52b3d2f29e13c6572553b30c4aa1b8a49fd70de6412654cb"
+dependencies = [
+ "anes",
+ "atty",
+ "cast",
+ "ciborium",
+ "clap 3.2.23",
+ "criterion-plot",
+ "itertools",
+ "lazy_static",
+ "num-traits",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.6"
@@ -807,6 +918,21 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
+[[package]]
+name = "flake8-to-ruff"
+version = "0.0.98-dev.0"
+dependencies = [
+ "anyhow",
+ "clap 4.0.15",
+ "configparser",
+ "once_cell",
+ "regex",
+ "ruff",
+ "serde",
+ "serde_json",
+ "toml",
+]
+
 [[package]]
 name = "flate2"
 version = "1.0.24"
@@ -1032,6 +1158,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "half"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -1562,6 +1694,12 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1"
 
+[[package]]
+name = "oorandom"
+version = "11.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+
 [[package]]
 name = "opaque-debug"
 version = "0.2.3"
@@ -1770,6 +1908,34 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
+[[package]]
+name = "plotters"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2538b639e642295546c50fcd545198c9d64ee2a38620a628724a3b266d5fbf97"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "193228616381fecdc1224c62e96946dfbc73ff4384fba576e052ff8c1bea8142"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9a81d2759aae1dae668f783c308bc5c8ebd191ff4184aaa1b37f65a6ae5a56f"
+dependencies = [
+ "plotters-backend",
+]
+
 [[package]]
 name = "polling"
 version = "2.3.0"
@@ -2045,17 +2211,19 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.78"
+version = "0.0.98"
 dependencies = [
  "anyhow",
  "assert_cmd",
  "bincode",
  "cacache",
  "chrono",
- "clap",
+ "clap 4.0.15",
  "clearscreen",
+ "codegen",
  "colored",
  "common-path",
+ "criterion",
  "dirs 4.0.0",
  "fern",
  "filetime",
@@ -2079,7 +2247,7 @@ dependencies = [
  "strum",
  "strum_macros",
  "test-case",
- "textwrap",
+ "textwrap 0.15.1",
  "titlecase",
  "toml",
  "update-informer",
@@ -2101,7 +2269,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.1.0"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=210db77e4274787028dc3ebc0b4841d1334c8c10#210db77e4274787028dc3ebc0b4841d1334c8c10"
+source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
 dependencies = [
  "num-bigint",
  "rustpython-common",
@@ -2111,7 +2279,7 @@ dependencies = [
 [[package]]
 name = "rustpython-common"
 version = "0.0.0"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=210db77e4274787028dc3ebc0b4841d1334c8c10#210db77e4274787028dc3ebc0b4841d1334c8c10"
+source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
 dependencies = [
  "ascii",
  "cfg-if 1.0.0",
@@ -2134,7 +2302,7 @@ dependencies = [
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.1.2"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=210db77e4274787028dc3ebc0b4841d1334c8c10#210db77e4274787028dc3ebc0b4841d1334c8c10"
+source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
 dependencies = [
  "bincode",
  "bitflags",
@@ -2151,7 +2319,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.1.2"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=210db77e4274787028dc3ebc0b4841d1334c8c10#210db77e4274787028dc3ebc0b4841d1334c8c10"
+source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
 dependencies = [
  "ahash",
  "anyhow",
@@ -2539,6 +2707,12 @@ dependencies = [
  "unicode-width",
 ]
 
+[[package]]
+name = "textwrap"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
+
 [[package]]
 name = "thiserror"
 version = "1.0.37"
@@ -2579,6 +2753,16 @@ dependencies = [
  "crunchy",
 ]
 
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "tinyvec"
 version = "1.6.0"

Cargo.toml

@@ -1,6 +1,11 @@
+[workspace]
+members = [
+    "flake8_to_ruff",
+]
+
 [package]
 name = "ruff"
-version = "0.0.78"
+version = "0.0.98"
 edition = "2021"
 
 [lib]
@@ -26,9 +31,9 @@ once_cell = { version = "1.13.1" }
 path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/charliermarsh/RustPython.git", rev = "210db77e4274787028dc3ebc0b4841d1334c8c10" }
-rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "210db77e4274787028dc3ebc0b4841d1334c8c10" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "210db77e4274787028dc3ebc0b4841d1334c8c10" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
 serde = { version = "1.0.143", features = ["derive"] }
 serde_json = { version = "1.0.83" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
@@ -50,6 +55,8 @@ getrandom = { version = "0.2.7", features = ["js"] }
 
 [dev-dependencies]
 assert_cmd = { version = "2.0.4" }
+codegen = { version = "0.2.0" }
+criterion = { version = "0.4.0" }
 insta = { version = "1.19.1", features = ["yaml"] }
 test-case = { version = "2.2.2" }
 
@@ -68,3 +75,7 @@ opt-level = 3
 
 [profile.dev.package.similar]
 opt-level = 3
+
+[[bench]]
+name = "source_code_locator"
+harness = false

README.md

@@ -22,7 +22,7 @@ An extremely fast Python linter, written in Rust.
 - 📦 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#caching)-inspired cache support
 - 🔧 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix)-inspired autofix support (e.g., automatically remove unused imports)
 - 👀 [TypeScript](https://www.typescriptlang.org/docs/handbook/configuring-watch.html)-inspired `--watch` support, for continuous file monitoring
-- ⚖️ [Near-parity](#Parity-with-Flake8) with the built-in Flake8 rule set
+- ⚖️ [Near-parity](#how-does-ruff-compare-to-flake8) with the built-in Flake8 rule set
 - 🔌 Native re-implementations of popular Flake8 plugins, like [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/) ([`pydocstyle`](https://pypi.org/project/pydocstyle/))
 
 Ruff aims to be orders of magnitude faster than alternative tools while integrating more
@@ -38,13 +38,25 @@ Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-mu
 1. [Installation and Usage](#installation-and-usage)
 2. [Configuration](#configuration)
 3. [Supported Rules](#supported-rules)
-4. [Editor Integrations](#editor-integrations)
-5. [FAQ](#faq)
-6. [Development](#development)
-7. [Releases](#releases)
-8. [Benchmarks](#benchmarks)
-9. [License](#license)
-10. [Contributing](#contributing)
+   1. [Pyflakes](#pyflakes)
+   2. [pycodestyle (error)](#pycodestyle-error)
+   3. [pycodestyle (warning)](#pycodestyle-warning)
+   4. [pydocstyle](#pydocstyle)
+   5. [pyupgrade](#pyupgrade)
+   6. [pep8-naming](#pep8-naming)
+   7. [flake8-comprehensions](#flake8-comprehensions)
+   8. [flake8-bugbear](#flake8-bugbear)
+   9. [flake8-builtins](#flake8-builtins)
+   10. [flake8-print](#flake8-print)
+   11. [flake8-quotes](#flake8-quotes)
+   12. [Meta rules](#meta-rules)
+5. [Editor Integrations](#editor-integrations)
+6. [FAQ](#faq)
+7. [Development](#development)
+8. [Releases](#releases)
+9. [Benchmarks](#benchmarks)
+10. [License](#license)
+11. [Contributing](#contributing)
 
 ## Installation and Usage
 
@@ -77,27 +89,84 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.78
+    rev: v0.0.98
     hooks:
-      - id: lint
+      - id: ruff
 ```
 
+<!-- TODO(charlie): Remove this message a few versions after v0.0.86. -->
+_Note: prior to `v0.0.86`, `ruff-pre-commit` used `lint` (rather than `ruff`) as the hook ID._
+
 ## Configuration
 
-Ruff is configurable both via `pyproject.toml` and the command line.
-
-For example, you could configure Ruff to only enforce a subset of rules with:
+Ruff is configurable both via `pyproject.toml` and the command line. If left unspecified, the
+default configuration is equivalent to:
 
 ```toml
 [tool.ruff]
 line-length = 88
-select = [
-    "F401",
-    "F403",
+
+# Enable Flake's "E" and "F" codes by default.
+select = ["E", "F"]
+ignore = []
+
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
 ]
+per-file-ignores = {}
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+# Assume Python 3.10.
+target-version = "py310"
 ```
 
-Alternatively, on the command-line:
+As an example, the following would configure Ruff to (1) avoid checking for line-length
+violations (`E501`) and (2) ignore unused import rules in `__init__.py` files:
+
+```toml
+[tool.ruff]
+select = ["E", "F"]
+
+# Never enforce `E501`.
+ignore = ["E501"]
+
+# Ignore `F401` violations in any `__init__.py` file, and in `path/to/file.py`.
+per-file-ignores = {"__init__.py" = ["F401"], "path/to/file.py" = ["F401"]}
+```
+
+Plugin configurations should be expressed as subsections, e.g.:
+
+```toml
+[tool.ruff]
+# Add "Q" to the list of enabled codes.
+select = ["E", "F", "Q"]
+
+[tool.ruff.flake8-quotes]
+docstring-quotes = "double"
+```
+
+Alternatively, common configuration settings can be provided via the command-line:
 
 ```shell
 ruff path/to/code/ --select F401 --select F403
@@ -119,6 +188,8 @@ Options:
   -v, --verbose
           Enable verbose logging
   -q, --quiet
+          Only log errors
+  -s, --silent
           Disable all logging (but still exit with status code "1" upon detecting errors)
   -e, --exit-zero
           Exit with status code "0", even upon detecting errors
@@ -219,8 +290,7 @@ add `noqa` directives to all failing lines, with the appropriate error codes.**
 
 ## Supported Rules
 
-By default, Ruff enables all `E`, `W`, and `F` error codes, which correspond to those built-in to
-Flake8.
+By default, Ruff enables all `E` and `F` error codes, which correspond to those built-in to Flake8.
 
 The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` command-line option.
 
@@ -246,7 +316,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | F634 | IfTuple | If test is a tuple, which is always `True` |  |
 | F701 | BreakOutsideLoop | `break` outside loop |  |
 | F702 | ContinueOutsideLoop | `continue` not properly in loop |  |
-| F704 | YieldOutsideFunction | `yield` or `yield from` statement outside of a function/method |  |
+| F704 | YieldOutsideFunction | `yield` or `yield from` statement outside of a function |  |
 | F706 | ReturnOutsideFunction | `return` statement outside of a function/method |  |
 | F707 | DefaultExceptNotLast | An `except:` block as not the last exception handler |  |
 | F722 | ForwardAnnotationSyntaxError | Syntax error in forward annotation: `...` |  |
@@ -257,7 +327,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | F841 | UnusedVariable | Local variable `...` is assigned to but never used |  |
 | F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` |  |
 
-### pycodestyle
+### pycodestyle (error)
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
@@ -275,7 +345,13 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | E743 | AmbiguousFunctionName | Ambiguous function name: `...` |  |
 | E902 | IOError | IOError: `...` |  |
 | E999 | SyntaxError | SyntaxError: `...` |  |
+
+### pycodestyle (warning)
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
 | W292 | NoNewLineAtEndOfFile | No newline at end of file |  |
+| W605 | InvalidEscapeSequence | Invalid escape sequence: '\c' |  |
 
 ### pydocstyle
 
@@ -294,36 +370,36 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | D202 | NoBlankLineAfterFunction | No blank lines allowed after function docstring (found 1) | 🛠 |
 | D203 | OneBlankLineBeforeClass | 1 blank line required before class docstring | 🛠 |
 | D204 | OneBlankLineAfterClass | 1 blank line required after class docstring | 🛠 |
-| D205 | NoBlankLineAfterSummary | 1 blank line required between summary line and description | 🛠 |
+| D205 | BlankLineAfterSummary | 1 blank line required between summary line and description | 🛠 |
 | D206 | IndentWithSpaces | Docstring should be indented with spaces, not tabs |  |
-| D207 | NoUnderIndentation | Docstring is under-indented |  |
-| D208 | NoOverIndentation | Docstring is over-indented |  |
+| D207 | NoUnderIndentation | Docstring is under-indented | 🛠 |
+| D208 | NoOverIndentation | Docstring is over-indented | 🛠 |
 | D209 | NewLineAfterLastParagraph | Multi-line docstring closing quotes should be on a separate line | 🛠 |
 | D210 | NoSurroundingWhitespace | No whitespaces allowed surrounding docstring text | 🛠 |
 | D211 | NoBlankLineBeforeClass | No blank lines allowed before class docstring | 🛠 |
 | D212 | MultiLineSummaryFirstLine | Multi-line docstring summary should start at the first line |  |
 | D213 | MultiLineSummarySecondLine | Multi-line docstring summary should start at the second line |  |
-| D214 | SectionNotOverIndented | Section is over-indented ("Returns") |  |
-| D215 | SectionUnderlineNotOverIndented | Section underline is over-indented ("Returns") |  |
+| D214 | SectionNotOverIndented | Section is over-indented ("Returns") | 🛠 |
+| D215 | SectionUnderlineNotOverIndented | Section underline is over-indented ("Returns") | 🛠 |
 | D300 | UsesTripleQuotes | Use """triple double quotes""" |  |
 | D400 | EndsInPeriod | First line should end with a period |  |
-| D402 | NoSignature | First line should not be the function's 'signature' |  |
+| D402 | NoSignature | First line should not be the function's signature |  |
 | D403 | FirstLineCapitalized | First word of the first line should be properly capitalized |  |
-| D404 | NoThisPrefix | First word of the docstring should not be `This` |  |
-| D405 | CapitalizeSectionName | Section name should be properly capitalized ("returns") |  |
-| D406 | NewLineAfterSectionName | Section name should end with a newline ("Returns") |  |
-| D407 | DashedUnderlineAfterSection | Missing dashed underline after section ("Returns") |  |
-| D408 | SectionUnderlineAfterName | Section underline should be in the line following the section's name ("Returns") |  |
-| D409 | SectionUnderlineMatchesSectionLength | Section underline should match the length of its name ("Returns") |  |
+| D404 | NoThisPrefix | First word of the docstring should not be 'This' |  |
+| D405 | CapitalizeSectionName | Section name should be properly capitalized ("returns") | 🛠 |
+| D406 | NewLineAfterSectionName | Section name should end with a newline ("Returns") | 🛠 |
+| D407 | DashedUnderlineAfterSection | Missing dashed underline after section ("Returns") | 🛠 |
+| D408 | SectionUnderlineAfterName | Section underline should be in the line following the section's name ("Returns") | 🛠 |
+| D409 | SectionUnderlineMatchesSectionLength | Section underline should match the length of its name ("Returns") | 🛠 |
 | D410 | BlankLineAfterSection | Missing blank line after section ("Returns") | 🛠 |
-| D411 | BlankLineBeforeSection | Missing blank line before section ("Returns") |  |
-| D412 | NoBlankLinesBetweenHeaderAndContent | No blank lines allowed between a section header and its content ("Returns") |  |
+| D411 | BlankLineBeforeSection | Missing blank line before section ("Returns") | 🛠 |
+| D412 | NoBlankLinesBetweenHeaderAndContent | No blank lines allowed between a section header and its content ("Returns") | 🛠 |
 | D413 | BlankLineAfterLastSection | Missing blank line after last section ("Returns") | 🛠 |
 | D414 | NonEmptySection | Section has no content ("Returns") |  |
 | D415 | EndsInPunctuation | First line should end with a period, question mark, or exclamation point |  |
-| D416 | SectionNameEndsInColon | Section name should end with a colon ("Returns") |  |
+| D416 | SectionNameEndsInColon | Section name should end with a colon ("Returns") | 🛠 |
 | D417 | DocumentAllArguments | Missing argument descriptions in the docstring: `x`, `y` |  |
-| D418 | SkipDocstring | Function decorated with @overload shouldn't contain a docstring |  |
+| D418 | SkipDocstring | Function decorated with `@overload` shouldn't contain a docstring |  |
 | D419 | NonEmpty | Docstring is empty |  |
 
 ### pyupgrade
@@ -348,34 +424,49 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | N803 | InvalidArgumentName | Argument name `...` should be lowercase |  |
 | N804 | InvalidFirstArgumentNameForClassMethod | First argument of a class method should be named `cls` |  |
 | N805 | InvalidFirstArgumentNameForMethod | First argument of a method should be named `self` |  |
+| N806 | NonLowercaseVariableInFunction | Variable `...` in function should be lowercase |  |
+| N807 | DunderFunctionName | Function name should not start and end with `__` |  |
+| N811 | ConstantImportedAsNonConstant | Constant `...` imported as non-constant `...` |  |
+| N812 | LowercaseImportedAsNonLowercase | Lowercase `...` imported as non-lowercase `...` |  |
+| N813 | CamelcaseImportedAsLowercase | Camelcase `...` imported as lowercase `...` |  |
+| N814 | CamelcaseImportedAsConstant | Camelcase `...` imported as constant `...` |  |
+| N815 | MixedCaseVariableInClassScope | Variable `mixedCase` in class scope should not be mixedCase |  |
+| N816 | MixedCaseVariableInGlobalScope | Variable `mixedCase` in global scope should not be mixedCase |  |
+| N817 | CamelcaseImportedAsAcronym | Camelcase `...` imported as acronym `...` |  |
+| N818 | ErrorSuffixOnExceptionName | Exception name `...` should be named with an Error suffix |  |
 
 ### flake8-comprehensions
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| C400 | UnnecessaryGeneratorList | Unnecessary generator (rewrite as a `list` comprehension) |  |
-| C401 | UnnecessaryGeneratorSet | Unnecessary generator (rewrite as a `set` comprehension) |  |
-| C402 | UnnecessaryGeneratorDict | Unnecessary generator (rewrite as a `dict` comprehension) |  |
-| C403 | UnnecessaryListComprehensionSet | Unnecessary `list` comprehension (rewrite as a `set` comprehension) |  |
+| C400 | UnnecessaryGeneratorList | Unnecessary generator (rewrite as a `list` comprehension) | 🛠 |
+| C401 | UnnecessaryGeneratorSet | Unnecessary generator (rewrite as a `set` comprehension) | 🛠 |
+| C402 | UnnecessaryGeneratorDict | Unnecessary generator (rewrite as a `dict` comprehension) | 🛠 |
+| C403 | UnnecessaryListComprehensionSet | Unnecessary `list` comprehension (rewrite as a `set` comprehension) | 🛠 |
 | C404 | UnnecessaryListComprehensionDict | Unnecessary `list` comprehension (rewrite as a `dict` comprehension) |  |
-| C405 | UnnecessaryLiteralSet | Unnecessary `(list\|tuple)` literal (rewrite as a `set` literal) |  |
+| C405 | UnnecessaryLiteralSet | Unnecessary `(list\|tuple)` literal (rewrite as a `set` literal) | 🛠 |
 | C406 | UnnecessaryLiteralDict | Unnecessary `(list\|tuple)` literal (rewrite as a `dict` literal) |  |
-| C408 | UnnecessaryCollectionCall | Unnecessary `(dict\|list\|tuple)` call (rewrite as a literal) |  |
-| C409 | UnnecessaryLiteralWithinTupleCall | Unnecessary `(list\|tuple)` literal passed to `tuple()` (remove the outer call to `tuple()`) |  |
-| C410 | UnnecessaryLiteralWithinListCall | Unnecessary `(list\|tuple)` literal passed to `list()` (rewrite as a `list` literal) |  |
-| C411 | UnnecessaryListCall | Unnecessary `list` call (remove the outer call to `list()`) |  |
+| C408 | UnnecessaryCollectionCall | Unnecessary `(dict\|list\|tuple)` call (rewrite as a literal) | 🛠 |
+| C409 | UnnecessaryLiteralWithinTupleCall | Unnecessary `(list\|tuple)` literal passed to `tuple()` (remove the outer call to `tuple()`) | 🛠 |
+| C410 | UnnecessaryLiteralWithinListCall | Unnecessary `(list\|tuple)` literal passed to `list()` (rewrite as a `list` literal) | 🛠 |
+| C411 | UnnecessaryListCall | Unnecessary `list` call (remove the outer call to `list()`) | 🛠 |
 | C413 | UnnecessaryCallAroundSorted | Unnecessary `(list\|reversed)` call around `sorted()` |  |
 | C414 | UnnecessaryDoubleCastOrProcess | Unnecessary `(list\|reversed\|set\|sorted\|tuple)` call within `(list\|set\|sorted\|tuple)()` |  |
 | C415 | UnnecessarySubscriptReversal | Unnecessary subscript reversal of iterable within `(reversed\|set\|sorted)()` |  |
-| C416 | UnnecessaryComprehension |  Unnecessary `(list\|set)` comprehension (rewrite using `(list\|set)()`) |  |
+| C416 | UnnecessaryComprehension | Unnecessary `(list\|set)` comprehension (rewrite using `(list\|set)()`) |  |
 | C417 | UnnecessaryMap | Unnecessary `map` usage (rewrite using a `(list\|set\|dict)` comprehension) |  |
 
 ### flake8-bugbear
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
+| B002 | UnaryPrefixIncrement | Python does not support the unary prefix increment. |  |
+| B006 | MutableArgumentDefault | Do not use mutable data structures for argument defaults. |  |
+| B007 | UnusedLoopControlVariable | Loop control variable `i` not used within the loop body. | 🛠 |
 | B011 | DoNotAssertFalse | Do not `assert False` (`python -O` removes these calls), raise `AssertionError()` | 🛠 |
+| B013 | RedundantTupleInExceptionHandler | A length-one tuple literal is redundant. Write `except ValueError:` instead of `except (ValueError,):`. |  |
 | B014 | DuplicateHandlerException | Exception handler with duplicate exception: `ValueError` | 🛠 |
+| B017 | NoAssertRaisesException | `assertRaises(Exception):` should be considered evil. |  |
 | B025 | DuplicateTryBlockException | try-except block with duplicate exception `Exception` |  |
 
 ### flake8-builtins
@@ -393,6 +484,15 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | T201 | PrintFound | `print` found | 🛠 |
 | T203 | PPrintFound | `pprint` found | 🛠 |
 
+### flake8-quotes
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| Q000 | BadQuotesInlineString | Single quotes found but double quotes preferred |  |
+| Q001 | BadQuotesMultilineString | Single quote multiline found but double quotes preferred |  |
+| Q002 | BadQuotesDocstring | Single quote docstring found but double quotes preferred |  |
+| Q003 | AvoidQuoteEscape | Change outer quotes to avoid escaping inner quotes |  |
+
 ### Meta rules
 
 | Code | Name | Message | Fix |
@@ -459,14 +559,16 @@ Ruff re-implements some of the most popular Flake8 plugins and related code qual
 including:
 
 - [`pydocstyle`](https://pypi.org/project/pydocstyle/)
+- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
 - [`yesqa`](https://github.com/asottile/yesqa)
 - [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
 - [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
+- [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (3/32)
-- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (10/32)
+- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (10/34)
 - [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
 
 Beyond rule-set parity, Ruff suffers from the following limitations vis-à-vis Flake8:
@@ -480,15 +582,17 @@ Beyond rule-set parity, Ruff suffers from the following limitations vis-à-vis F
 
 Today, Ruff can be used to replace Flake8 when used with any of the following plugins:
 
+- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
 - [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
 - [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
+- [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (3/32)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (10/32)
 
 Ruff also implements the functionality that you get from [`yesqa`](https://github.com/asottile/yesqa),
-and a subset of the rules implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34).
+and a subset of the rules implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (10/34).
 
 If you're looking to use Ruff, but rely on an unsupported Flake8 plugin, free to file an Issue.
 
@@ -506,7 +610,7 @@ on Rust at all.
 ### Can I write my own plugins for Ruff?
 
 Ruff does not yet support third-party plugins, though a plugin system is within-scope for the
-project. See [#283](https://github.com/charliermarsh/ruff/issues/2830) for more.
+project. See [#283](https://github.com/charliermarsh/ruff/issues/283) for more.
 
 ### Does Ruff support NumPy- or Google-style docstrings?
 
@@ -514,35 +618,55 @@ Yes! To enable a specific docstring convention, start by enabling all `pydocstyl
 then selectively disabling based on your [preferred convention](https://www.pydocstyle.org/en/latest/error_codes.html#default-conventions).
 
 For example, if you're coming from `flake8-docstrings`, the following configuration is equivalent to
-`--docstring-convention numpy`:
+`--docstring-convention=numpy`:
 
 ```toml
 [tool.ruff]
-extend-select = [
-    "D100",
-    "D101",
-    "D102",
-    "D103",
-    "D104",
-    "D105",
-    "D106",
-    "D200",
-    "D201",
-    "D202",
+extend-select = ["D"]
+extend-ignore = [
+    "D107",
+    "D203",
+    "D212",
+    "D213",
+    "D402",
+    "D413",
+    "D415",
+    "D416",
+    "D417",
+]
+```
+
+Similarly, the following is equivalent to `--docstring-convention=google`:
+
+```toml
+[tool.ruff]
+extend-select = ["D"]
+extend-ignore = [
+    "D203",
     "D204",
-    "D205",
-    "D206",
-    "D207",
-    "D208",
-    "D209",
-    "D210",
-    "D211",
+    "D213",
+    "D215",
+    "D400",
+    "D404",
+    "D406",
+    "D407",
+    "D408",
+    "D409",
+    "D413",
+]
+```
+
+Similarly, the following is equivalent to `--docstring-convention=pep8`:
+
+```toml
+[tool.ruff]
+extend-select = ["D"]
+extend-ignore = [
+    "D203",
+    "D212",
+    "D213",
     "D214",
     "D215",
-    "D300",
-    "D400",
-    "D402",
-    "D403",
     "D404",
     "D405",
     "D406",
@@ -551,66 +675,30 @@ extend-select = [
     "D409",
     "D410",
     "D411",
-    "D412",
     "D413",
-    "D418",
-    "D419",
-]
-```
-
-Similarly, the following is equivalent to `--docstring-convention google`:
-
-```toml
-[tool.ruff]
-extend-select = [
-    "D100",
-    "D101",
-    "D102",
-    "D103",
-    "D104",
-    "D105",
-    "D106",
-    "D107",
-    "D200",
-    "D201",
-    "D202",
-    "D205",
-    "D206",
-    "D207",
-    "D208",
-    "D209",
-    "D210",
-    "D211",
-    "D212",
-    "D214",
-    "D300",
-    "D402",
-    "D403",
-    "D405",
-    "D410",
-    "D411",
-    "D412",
-    "D414",
     "D415",
     "D416",
     "D417",
-    "D418",
-    "D419",
 ]
 ```
 
 ## Development
 
-Ruff is written in Rust (1.63.0). You'll need to install the [Rust toolchain](https://www.rust-lang.org/tools/install)
+Ruff is written in Rust (1.64.0). You'll need to install the [Rust toolchain](https://www.rust-lang.org/tools/install)
 for development.
 
 Assuming you have `cargo` installed, you can run:
 
 ```shell
 cargo run resources/test/fixtures
-cargo fmt
-cargo clippy
-cargo test
+```
+
+For development, we use [nightly Rust](https://rust-lang.github.io/rustup/concepts/channels.html#working-with-nightly-rust):
+
+```shell
+cargo +nightly fmt
+cargo +nightly clippy
+cargo +nightly test
 ```
 
 ## Releases

benches/source_code_locator.rs

@@ -0,0 +1,15 @@
+use std::path::Path;
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use ruff::fs;
+use ruff::source_code_locator::compute_offsets;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let contents = fs::read_file(Path::new("resources/test/fixtures/D.py")).unwrap();
+    c.bench_function("compute_offsets", |b| {
+        b.iter(|| compute_offsets(black_box(&contents)))
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

examples/generate_check_code_prefix.rs

@@ -0,0 +1,104 @@
+//! Generate the CheckCodePrefix enum.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use codegen::{Scope, Type, Variant};
+use itertools::Itertools;
+use ruff::checks::CheckCode;
+use strum::IntoEnumIterator;
+
+fn main() {
+    // Build up a map from prefix to matching CheckCodes.
+    let mut prefix_to_codes: BTreeMap<String, BTreeSet<CheckCode>> = Default::default();
+    for check_code in CheckCode::iter() {
+        let as_ref = check_code.as_ref().to_string();
+        for i in 1..=as_ref.len() {
+            let prefix = as_ref[..i].to_string();
+            let entry = prefix_to_codes
+                .entry(prefix)
+                .or_insert_with(|| Default::default());
+            entry.insert(check_code.clone());
+        }
+    }
+
+    let mut scope = Scope::new();
+
+    // Create the `CheckCodePrefix` definition.
+    let mut gen = scope
+        .new_enum("CheckCodePrefix")
+        .vis("pub")
+        .derive("EnumString")
+        .derive("Debug")
+        .derive("PartialEq")
+        .derive("Eq")
+        .derive("Clone")
+        .derive("Serialize")
+        .derive("Deserialize");
+    for (prefix, _) in &prefix_to_codes {
+        gen = gen.push_variant(Variant::new(prefix.to_string()));
+    }
+
+    // Create the `PrefixSpecificity` definition.
+    scope
+        .new_enum("PrefixSpecificity")
+        .vis("pub")
+        .derive("PartialEq")
+        .derive("Eq")
+        .derive("PartialOrd")
+        .derive("Ord")
+        .push_variant(Variant::new("Category"))
+        .push_variant(Variant::new("Hundreds"))
+        .push_variant(Variant::new("Tens"))
+        .push_variant(Variant::new("Explicit"));
+
+    // Create the `match` statement, to map from definition to relevant codes.
+    let mut gen = scope
+        .new_impl("CheckCodePrefix")
+        .new_fn("codes")
+        .arg_ref_self()
+        .ret(Type::new("Vec<CheckCode>"))
+        .vis("pub")
+        .line("match self {");
+    for (prefix, codes) in &prefix_to_codes {
+        gen = gen.line(format!(
+            "CheckCodePrefix::{prefix} => vec![{}],",
+            codes
+                .iter()
+                .map(|code| format!("CheckCode::{}", code.as_ref()))
+                .join(", ")
+        ));
+    }
+    gen.line("}");
+
+    // Create the `match` statement, to map from definition to specificity.
+    let mut gen = scope
+        .new_impl("CheckCodePrefix")
+        .new_fn("specificity")
+        .arg_ref_self()
+        .ret(Type::new("PrefixSpecificity"))
+        .vis("pub")
+        .line("match self {");
+    for (prefix, _) in &prefix_to_codes {
+        let specificity = match prefix.len() {
+            4 => "Explicit",
+            3 => "Tens",
+            2 => "Hundreds",
+            1 => "Category",
+            _ => panic!("Invalid prefix: {}", prefix),
+        };
+        gen = gen.line(format!(
+            "CheckCodePrefix::{prefix} => PrefixSpecificity::{},",
+            specificity
+        ));
+    }
+    gen.line("}");
+
+    println!("//! File automatically generated by examples/generate_check_code_prefix.rs.");
+    println!();
+    println!("use serde::{{Serialize, Deserialize}};");
+    println!("use strum_macros::EnumString;");
+    println!();
+    println!("use crate::checks::CheckCode;");
+    println!();
+    println!("{}", scope.to_string());
+}

examples/generate_rules_table.rs

@@ -1,8 +1,7 @@
 //! Generate a Markdown-compatible table of supported lint rules.
 
-use strum::IntoEnumIterator;
-
 use ruff::checks::{CheckCategory, CheckCode};
+use strum::IntoEnumIterator;
 
 fn main() {
     for check_category in CheckCategory::iter() {
@@ -19,7 +18,7 @@ fn main() {
                     "| {} | {} | {} | {} |",
                     check_kind.code().as_ref(),
                     check_kind.as_ref(),
-                    check_kind.body().replace("|", r"\|"),
+                    check_kind.summary().replace("|", r"\|"),
                     fix_token
                 );
             }

examples/generate_source_code.rs

@@ -2,10 +2,9 @@ use std::path::PathBuf;
 
 use anyhow::Result;
 use clap::Parser;
-use rustpython_parser::parser;
-
 use ruff::code_gen::SourceGenerator;
 use ruff::fs;
+use rustpython_parser::parser;
 
 #[derive(Debug, Parser)]
 struct Cli {

examples/print_ast.rs

@@ -4,9 +4,8 @@ use std::path::PathBuf;
 
 use anyhow::Result;
 use clap::Parser;
-use rustpython_parser::parser;
-
 use ruff::fs;
+use rustpython_parser::parser;
 
 #[derive(Debug, Parser)]
 struct Cli {

examples/print_tokens.rs

@@ -4,9 +4,8 @@ use std::path::PathBuf;
 
 use anyhow::Result;
 use clap::Parser;
-use rustpython_parser::lexer;
-
 use ruff::fs;
+use rustpython_parser::lexer;
 
 #[derive(Debug, Parser)]
 struct Cli {

flake8_to_ruff/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "flake8-to-ruff"
+version = "0.0.98-dev.0"
+edition = "2021"
+
+[lib]
+name = "flake8_to_ruff"
+
+[dependencies]
+anyhow = { version = "1.0.60" }
+clap = { version = "4.0.1", features = ["derive"] }
+configparser = { version = "3.0.2" }
+once_cell = { version = "1.13.1" }
+regex = { version = "1.6.0" }
+ruff = { path = "..", default-features = false }
+serde = { version = "1.0.143", features = ["derive"] }
+serde_json = { version = "1.0.83" }
+toml = { version = "0.5.9" }
+
+[dev-dependencies]
+
+[features]

flake8_to_ruff/README.md

@@ -0,0 +1,47 @@
+# flake8-to-ruff
+
+Convert existing Flake8 configuration files (`setup.cfg`, `tox.ini`, or `.flake8`) for use with
+[Ruff](https://github.com/charliermarsh/ruff).
+
+Generates a Ruff-compatible `pyproject.toml` section.
+
+## Installation and Usage
+
+### Installation
+
+Available as [`flake8-to-ruff`](https://pypi.org/project/flake8-to-ruff/) on PyPI:
+
+```shell
+pip install flake8-to-ruff
+```
+
+### Usage
+
+To run Ruff, try any of the following:
+
+```shell
+flake8-to-ruff path/to/setup.cfg
+flake8-to-ruff path/to/tox.ini
+flake8-to-ruff path/to/.flake8
+```
+
+## Limitations
+
+1. Ruff only supports a subset of the Flake configuration options. `flake8-to-ruff` will warn on and
+   ignore unsupported options in the `.flake8` file (or equivalent). (Similarly, Ruff has a few
+   configuration options that don't exist in Flake8.)
+2. Ruff will omit any error codes that are unimplemented or unsupported by Ruff, including error
+   codes from unsupported plugins. (See the [Ruff README](https://github.com/charliermarsh/ruff#user-content-how-does-ruff-compare-to-flake8)
+   for the complete list of supported plugins.)
+3. `flake8-to-ruff` does not auto-detect your Flake8 plugins, so any reliance on Flake8 plugins that
+   implicitly enable third-party checks will be ignored. Instead, add those error codes to your
+   `select` or `extend-select` fields, so that `flake8-to-ruff` can pick them up.
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome and hugely appreciated. To get started, check out the
+[contributing guidelines](https://github.com/charliermarsh/ruff/blob/main/CONTRIBUTING.md).

flake8_to_ruff/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "flake8-to-ruff"
+keywords = ["automation", "flake8", "pycodestyle", "pyflakes", "pylint", "clippy"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Quality Assurance",
+]
+author = "Charlie Marsh"
+author_email = "charlie.r.marsh@gmail.com"
+description = "Convert existing Flake8 configuration to Ruff."
+requires-python = ">=3.7"
+
+[project.urls]
+repository = "https://github.com/charliermarsh/ruff#subdirectory=crates/flake8_to_ruff"
+
+[build-system]
+requires = ["maturin>=0.13,<0.14"]
+build-backend = "maturin"
+
+[tool.maturin]
+bindings = "bin"
+strip = true

flake8_to_ruff/src/converter.rs

@@ -0,0 +1,243 @@
+use std::collections::HashMap;
+
+use anyhow::Result;
+use ruff::flake8_quotes::settings::Quote;
+use ruff::settings::options::Options;
+use ruff::settings::pyproject::Pyproject;
+use ruff::{flake8_quotes, pep8_naming};
+
+use crate::parser;
+
+pub fn convert(config: HashMap<String, HashMap<String, Option<String>>>) -> Result<Pyproject> {
+    // Extract the Flake8 section.
+    let flake8 = config
+        .get("flake8")
+        .expect("Unable to find flake8 section in INI file.");
+
+    // Parse each supported option.
+    let mut options: Options = Default::default();
+    let mut flake8_quotes: flake8_quotes::settings::Options = Default::default();
+    let mut pep8_naming: pep8_naming::settings::Options = Default::default();
+    for (key, value) in flake8 {
+        if let Some(value) = value {
+            match key.as_str() {
+                // flake8
+                "max-line-length" | "max_line_length" => match value.clone().parse::<usize>() {
+                    Ok(line_length) => options.line_length = Some(line_length),
+                    Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                },
+                "select" => {
+                    options.select = Some(parser::parse_prefix_codes(value.as_ref()));
+                }
+                "extend-select" | "extend_select" => {
+                    options.extend_select = Some(parser::parse_prefix_codes(value.as_ref()));
+                }
+                "ignore" => {
+                    options.ignore = Some(parser::parse_prefix_codes(value.as_ref()));
+                }
+                "extend-ignore" | "extend_ignore" => {
+                    options.extend_ignore = Some(parser::parse_prefix_codes(value.as_ref()));
+                }
+                "exclude" => {
+                    options.exclude = Some(parser::parse_strings(value.as_ref()));
+                }
+                "extend-exclude" | "extend_exclude" => {
+                    options.extend_exclude = Some(parser::parse_strings(value.as_ref()));
+                }
+                "per-file-ignores" | "per_file_ignores" => {
+                    match parser::parse_files_to_codes_mapping(value.as_ref()) {
+                        Ok(per_file_ignores) => {
+                            options.per_file_ignores =
+                                Some(parser::collect_per_file_ignores(per_file_ignores))
+                        }
+                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                    }
+                }
+                // flake8-quotes
+                "quotes" | "inline-quotes" | "inline_quotes" => match value.trim() {
+                    "'" | "single" => flake8_quotes.inline_quotes = Some(Quote::Single),
+                    "\"" | "double" => flake8_quotes.inline_quotes = Some(Quote::Single),
+                    _ => eprintln!("Unexpected '{key}' value: {value}"),
+                },
+                "multiline-quotes" | "multiline_quotes" => match value.trim() {
+                    "'" | "single" => flake8_quotes.multiline_quotes = Some(Quote::Single),
+                    "\"" | "double" => flake8_quotes.multiline_quotes = Some(Quote::Single),
+                    _ => eprintln!("Unexpected '{key}' value: {value}"),
+                },
+                "docstring-quotes" | "docstring_quotes" => match value.trim() {
+                    "'" | "single" => flake8_quotes.docstring_quotes = Some(Quote::Single),
+                    "\"" | "double" => flake8_quotes.docstring_quotes = Some(Quote::Single),
+                    _ => eprintln!("Unexpected '{key}' value: {value}"),
+                },
+                "avoid-escape" | "avoid_escape" => match value.trim() {
+                    "true" => flake8_quotes.avoid_escape = Some(true),
+                    "false" => flake8_quotes.avoid_escape = Some(false),
+                    _ => eprintln!("Unexpected '{key}' value: {value}"),
+                },
+                // pep8-naming
+                "ignore-names" | "ignore_names" => {
+                    pep8_naming.ignore_names = Some(parser::parse_strings(value.as_ref()));
+                }
+                "classmethod-decorators" | "classmethod_decorators" => {
+                    pep8_naming.classmethod_decorators =
+                        Some(parser::parse_strings(value.as_ref()));
+                }
+                "staticmethod-decorators" | "staticmethod_decorators" => {
+                    pep8_naming.staticmethod_decorators =
+                        Some(parser::parse_strings(value.as_ref()));
+                }
+                // Unknown
+                _ => eprintln!("Skipping unsupported property: {key}"),
+            }
+        }
+    }
+
+    if flake8_quotes != Default::default() {
+        options.flake8_quotes = Some(flake8_quotes);
+    }
+    if pep8_naming != Default::default() {
+        options.pep8_naming = Some(pep8_naming);
+    }
+
+    // Create the pyproject.toml.
+    Ok(Pyproject::new(options))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use anyhow::Result;
+    use ruff::flake8_quotes;
+    use ruff::settings::options::Options;
+    use ruff::settings::pyproject::Pyproject;
+
+    use crate::converter::convert;
+
+    #[test]
+    fn it_converts_empty() -> Result<()> {
+        let actual = convert(HashMap::from([("flake8".to_string(), HashMap::from([]))]))?;
+        let expected = Pyproject::new(Options {
+            line_length: None,
+            exclude: None,
+            extend_exclude: None,
+            select: None,
+            extend_select: None,
+            ignore: None,
+            extend_ignore: None,
+            per_file_ignores: None,
+            dummy_variable_rgx: None,
+            target_version: None,
+            flake8_quotes: None,
+            pep8_naming: None,
+        });
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[test]
+    fn it_converts_dashes() -> Result<()> {
+        let actual = convert(HashMap::from([(
+            "flake8".to_string(),
+            HashMap::from([("max-line-length".to_string(), Some("100".to_string()))]),
+        )]))?;
+        let expected = Pyproject::new(Options {
+            line_length: Some(100),
+            exclude: None,
+            extend_exclude: None,
+            select: None,
+            extend_select: None,
+            ignore: None,
+            extend_ignore: None,
+            per_file_ignores: None,
+            dummy_variable_rgx: None,
+            target_version: None,
+            flake8_quotes: None,
+            pep8_naming: None,
+        });
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[test]
+    fn it_converts_underscores() -> Result<()> {
+        let actual = convert(HashMap::from([(
+            "flake8".to_string(),
+            HashMap::from([("max_line_length".to_string(), Some("100".to_string()))]),
+        )]))?;
+        let expected = Pyproject::new(Options {
+            line_length: Some(100),
+            exclude: None,
+            extend_exclude: None,
+            select: None,
+            extend_select: None,
+            ignore: None,
+            extend_ignore: None,
+            per_file_ignores: None,
+            dummy_variable_rgx: None,
+            target_version: None,
+            flake8_quotes: None,
+            pep8_naming: None,
+        });
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[test]
+    fn it_ignores_parse_errors() -> Result<()> {
+        let actual = convert(HashMap::from([(
+            "flake8".to_string(),
+            HashMap::from([("max_line_length".to_string(), Some("abc".to_string()))]),
+        )]))?;
+        let expected = Pyproject::new(Options {
+            line_length: None,
+            exclude: None,
+            extend_exclude: None,
+            select: None,
+            extend_select: None,
+            ignore: None,
+            extend_ignore: None,
+            per_file_ignores: None,
+            dummy_variable_rgx: None,
+            target_version: None,
+            flake8_quotes: None,
+            pep8_naming: None,
+        });
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[test]
+    fn it_converts_extensions() -> Result<()> {
+        let actual = convert(HashMap::from([(
+            "flake8".to_string(),
+            HashMap::from([("inline-quotes".to_string(), Some("single".to_string()))]),
+        )]))?;
+        let expected = Pyproject::new(Options {
+            line_length: None,
+            exclude: None,
+            extend_exclude: None,
+            select: None,
+            extend_select: None,
+            ignore: None,
+            extend_ignore: None,
+            per_file_ignores: None,
+            dummy_variable_rgx: None,
+            target_version: None,
+            flake8_quotes: Some(flake8_quotes::settings::Options {
+                inline_quotes: Some(flake8_quotes::settings::Quote::Single),
+                multiline_quotes: None,
+                docstring_quotes: None,
+                avoid_escape: None,
+            }),
+            pep8_naming: None,
+        });
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+}

flake8_to_ruff/src/lib.rs

@@ -0,0 +1,4 @@
+#![allow(clippy::collapsible_if, clippy::collapsible_else_if)]
+
+pub mod converter;
+mod parser;

flake8_to_ruff/src/main.rs

@@ -0,0 +1,35 @@
+//! Utility to generate Ruff's pyproject.toml section from a Flake8 INI file.
+
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Parser;
+use configparser::ini::Ini;
+use flake8_to_ruff::converter;
+
+#[derive(Parser)]
+#[command(
+    about = "Convert existing Flake8 configuration to Ruff.",
+    long_about = None
+)]
+struct Cli {
+    /// Path to the Flake8 configuration file (e.g., 'setup.cfg', 'tox.ini', or
+    /// '.flake8').
+    #[arg(required = true)]
+    file: PathBuf,
+}
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    // Read the INI file.
+    let mut ini = Ini::new_cs();
+    ini.set_multiline(true);
+    let config = ini.load(cli.file).map_err(|msg| anyhow::anyhow!(msg))?;
+
+    // Create the pyproject.toml.
+    let pyproject = converter::convert(config)?;
+    println!("{}", toml::to_string_pretty(&pyproject)?);
+
+    Ok(())
+}

flake8_to_ruff/src/parser.rs

@@ -0,0 +1,373 @@
+use std::collections::BTreeMap;
+use std::str::FromStr;
+
+use anyhow::Result;
+use once_cell::sync::Lazy;
+use regex::Regex;
+use ruff::checks_gen::CheckCodePrefix;
+use ruff::settings::types::PatternPrefixPair;
+
+static COMMA_SEPARATED_LIST_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"[,\s]").unwrap());
+
+/// Parse a comma-separated list of `CheckCodePrefix` values (e.g.,
+/// "F401,E501").
+pub fn parse_prefix_codes(value: &str) -> Vec<CheckCodePrefix> {
+    let mut codes: Vec<CheckCodePrefix> = vec![];
+    for code in COMMA_SEPARATED_LIST_RE.split(value) {
+        let code = code.trim();
+        if code.is_empty() {
+            continue;
+        }
+        if let Ok(code) = CheckCodePrefix::from_str(code) {
+            codes.push(code);
+        } else {
+            eprintln!("Unsupported prefix code: {code}");
+        }
+    }
+    codes
+}
+
+/// Parse a comma-separated list of strings (e.g., "__init__.py,__main__.py").
+pub fn parse_strings(value: &str) -> Vec<String> {
+    COMMA_SEPARATED_LIST_RE
+        .split(value)
+        .map(|part| part.trim())
+        .filter(|part| !part.is_empty())
+        .map(String::from)
+        .collect()
+}
+
+#[derive(Debug)]
+struct Token {
+    token_name: TokenType,
+    src: String,
+}
+
+#[derive(Debug)]
+enum TokenType {
+    Code,
+    File,
+    Colon,
+    Comma,
+    Ws,
+    Eof,
+}
+
+struct State {
+    seen_sep: bool,
+    seen_colon: bool,
+    filenames: Vec<String>,
+    codes: Vec<String>,
+}
+
+impl State {
+    fn new() -> Self {
+        Self {
+            seen_sep: true,
+            seen_colon: false,
+            filenames: vec![],
+            codes: vec![],
+        }
+    }
+
+    /// Generate the list of `StrCheckCodePair` pairs for the current state.
+    fn parse(&self) -> Vec<PatternPrefixPair> {
+        let mut codes: Vec<PatternPrefixPair> = vec![];
+        for code in &self.codes {
+            match CheckCodePrefix::from_str(code) {
+                Ok(code) => {
+                    for filename in &self.filenames {
+                        codes.push(PatternPrefixPair {
+                            pattern: filename.clone(),
+                            prefix: code.clone(),
+                        });
+                    }
+                }
+                Err(_) => eprintln!("Skipping unrecognized prefix: {}", code),
+            }
+        }
+        codes
+    }
+}
+
+/// Tokenize the raw 'files-to-codes' mapping.
+fn tokenize_files_to_codes_mapping(value: &str) -> Vec<Token> {
+    let mut tokens = vec![];
+    let mut i = 0;
+    while i < value.len() {
+        for (token_re, token_name) in [
+            (
+                Regex::new(r"([A-Z]+[0-9]*)(?:$|\s|,)").unwrap(),
+                TokenType::Code,
+            ),
+            (Regex::new(r"([^\s:,]+)").unwrap(), TokenType::File),
+            (Regex::new(r"(\s*:\s*)").unwrap(), TokenType::Colon),
+            (Regex::new(r"(\s*,\s*)").unwrap(), TokenType::Comma),
+            (Regex::new(r"(\s+)").unwrap(), TokenType::Ws),
+        ] {
+            if let Some(cap) = token_re.captures(&value[i..]) {
+                let mat = cap.get(1).unwrap();
+                if mat.start() == 0 {
+                    tokens.push(Token {
+                        token_name,
+                        src: mat.as_str().to_string().trim().to_string(),
+                    });
+                    i += mat.end();
+                    break;
+                }
+            }
+        }
+    }
+    tokens.push(Token {
+        token_name: TokenType::Eof,
+        src: "".to_string(),
+    });
+    tokens
+}
+
+/// Parse a 'files-to-codes' mapping, mimicking Flake8's internal logic.
+///
+/// See: https://github.com/PyCQA/flake8/blob/7dfe99616fc2f07c0017df2ba5fa884158f3ea8a/src/flake8/utils.py#L45
+pub fn parse_files_to_codes_mapping(value: &str) -> Result<Vec<PatternPrefixPair>> {
+    if value.trim().is_empty() {
+        return Ok(vec![]);
+    }
+    let mut codes: Vec<PatternPrefixPair> = vec![];
+    let mut state = State::new();
+    for token in tokenize_files_to_codes_mapping(value) {
+        if matches!(token.token_name, TokenType::Comma | TokenType::Ws) {
+            state.seen_sep = true;
+        } else if !state.seen_colon {
+            if matches!(token.token_name, TokenType::Colon) {
+                state.seen_colon = true;
+                state.seen_sep = true;
+            } else if state.seen_sep && matches!(token.token_name, TokenType::File) {
+                state.filenames.push(token.src);
+                state.seen_sep = false;
+            } else {
+                return Err(anyhow::anyhow!("Unexpected token: {:?}", token.token_name));
+            }
+        } else {
+            if matches!(token.token_name, TokenType::Eof) {
+                codes.extend(state.parse());
+                state = State::new();
+            } else if state.seen_sep && matches!(token.token_name, TokenType::Code) {
+                state.codes.push(token.src);
+                state.seen_sep = false;
+            } else if state.seen_sep && matches!(token.token_name, TokenType::File) {
+                codes.extend(state.parse());
+                state = State::new();
+                state.filenames.push(token.src);
+                state.seen_sep = false;
+            } else {
+                return Err(anyhow::anyhow!("Unexpected token: {:?}", token.token_name));
+            }
+        }
+    }
+    Ok(codes)
+}
+
+/// Collect a list of `PatternPrefixPair` structs as a `BTreeMap`.
+pub fn collect_per_file_ignores(
+    pairs: Vec<PatternPrefixPair>,
+) -> BTreeMap<String, Vec<CheckCodePrefix>> {
+    let mut per_file_ignores: BTreeMap<String, Vec<CheckCodePrefix>> = BTreeMap::new();
+    for pair in pairs {
+        per_file_ignores
+            .entry(pair.pattern)
+            .or_insert_with(Vec::new)
+            .push(pair.prefix);
+    }
+    per_file_ignores
+}
+
+#[cfg(test)]
+mod tests {
+    use anyhow::Result;
+    use ruff::checks_gen::CheckCodePrefix;
+    use ruff::settings::types::PatternPrefixPair;
+
+    use crate::parser::{parse_files_to_codes_mapping, parse_prefix_codes, parse_strings};
+
+    #[test]
+    fn it_parses_prefix_codes() {
+        let actual = parse_prefix_codes("");
+        let expected: Vec<CheckCodePrefix> = vec![];
+        assert_eq!(actual, expected);
+
+        let actual = parse_prefix_codes(" ");
+        let expected: Vec<CheckCodePrefix> = vec![];
+        assert_eq!(actual, expected);
+
+        let actual = parse_prefix_codes("F401");
+        let expected = vec![CheckCodePrefix::F401];
+        assert_eq!(actual, expected);
+
+        let actual = parse_prefix_codes("F401,");
+        let expected = vec![CheckCodePrefix::F401];
+        assert_eq!(actual, expected);
+
+        let actual = parse_prefix_codes("F401,E501");
+        let expected = vec![CheckCodePrefix::F401, CheckCodePrefix::E501];
+        assert_eq!(actual, expected);
+
+        let actual = parse_prefix_codes("F401, E501");
+        let expected = vec![CheckCodePrefix::F401, CheckCodePrefix::E501];
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn it_parses_strings() {
+        let actual = parse_strings("");
+        let expected: Vec<String> = vec![];
+        assert_eq!(actual, expected);
+
+        let actual = parse_strings(" ");
+        let expected: Vec<String> = vec![];
+        assert_eq!(actual, expected);
+
+        let actual = parse_strings("__init__.py");
+        let expected = vec!["__init__.py".to_string()];
+        assert_eq!(actual, expected);
+
+        let actual = parse_strings("__init__.py,");
+        let expected = vec!["__init__.py".to_string()];
+        assert_eq!(actual, expected);
+
+        let actual = parse_strings("__init__.py,__main__.py");
+        let expected = vec!["__init__.py".to_string(), "__main__.py".to_string()];
+        assert_eq!(actual, expected);
+
+        let actual = parse_strings("__init__.py, __main__.py");
+        let expected = vec!["__init__.py".to_string(), "__main__.py".to_string()];
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn it_parse_files_to_codes_mapping() -> Result<()> {
+        let actual = parse_files_to_codes_mapping("")?;
+        let expected: Vec<PatternPrefixPair> = vec![];
+        assert_eq!(actual, expected);
+
+        let actual = parse_files_to_codes_mapping(" ")?;
+        let expected: Vec<PatternPrefixPair> = vec![];
+        assert_eq!(actual, expected);
+
+        // Ex) locust
+        let actual = parse_files_to_codes_mapping(
+            "per-file-ignores =
+    locust/test/*: F841
+    examples/*: F841
+    *.pyi: E302,E704"
+                .strip_prefix("per-file-ignores =")
+                .unwrap(),
+        )?;
+        let expected: Vec<PatternPrefixPair> = vec![
+            PatternPrefixPair {
+                pattern: "locust/test/*".to_string(),
+                prefix: CheckCodePrefix::F841,
+            },
+            PatternPrefixPair {
+                pattern: "examples/*".to_string(),
+                prefix: CheckCodePrefix::F841,
+            },
+        ];
+        assert_eq!(actual, expected);
+
+        // Ex) celery
+        let actual = parse_files_to_codes_mapping(
+            "per-file-ignores =
+   t/*,setup.py,examples/*,docs/*,extra/*:
+       D,"
+            .strip_prefix("per-file-ignores =")
+            .unwrap(),
+        )?;
+        let expected: Vec<PatternPrefixPair> = vec![
+            PatternPrefixPair {
+                pattern: "t/*".to_string(),
+                prefix: CheckCodePrefix::D,
+            },
+            PatternPrefixPair {
+                pattern: "setup.py".to_string(),
+                prefix: CheckCodePrefix::D,
+            },
+            PatternPrefixPair {
+                pattern: "examples/*".to_string(),
+                prefix: CheckCodePrefix::D,
+            },
+            PatternPrefixPair {
+                pattern: "docs/*".to_string(),
+                prefix: CheckCodePrefix::D,
+            },
+            PatternPrefixPair {
+                pattern: "extra/*".to_string(),
+                prefix: CheckCodePrefix::D,
+            },
+        ];
+        assert_eq!(actual, expected);
+
+        // Ex) scrapy
+        let actual = parse_files_to_codes_mapping(
+            "per-file-ignores =
+    scrapy/__init__.py:E402
+    scrapy/core/downloader/handlers/http.py:F401
+    scrapy/http/__init__.py:F401
+    scrapy/linkextractors/__init__.py:E402,F401
+    scrapy/selector/__init__.py:F401
+    scrapy/spiders/__init__.py:E402,F401
+    scrapy/utils/url.py:F403,F405
+    tests/test_loader.py:E741"
+                .strip_prefix("per-file-ignores =")
+                .unwrap(),
+        )?;
+        let expected: Vec<PatternPrefixPair> = vec![
+            PatternPrefixPair {
+                pattern: "scrapy/__init__.py".to_string(),
+                prefix: CheckCodePrefix::E402,
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/core/downloader/handlers/http.py".to_string(),
+                prefix: CheckCodePrefix::F401,
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/http/__init__.py".to_string(),
+                prefix: CheckCodePrefix::F401,
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/linkextractors/__init__.py".to_string(),
+                prefix: CheckCodePrefix::E402,
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/linkextractors/__init__.py".to_string(),
+                prefix: CheckCodePrefix::F401,
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/selector/__init__.py".to_string(),
+                prefix: CheckCodePrefix::F401,
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/spiders/__init__.py".to_string(),
+                prefix: CheckCodePrefix::E402,
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/spiders/__init__.py".to_string(),
+                prefix: CheckCodePrefix::F401,
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/utils/url.py".to_string(),
+                prefix: CheckCodePrefix::F403,
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/utils/url.py".to_string(),
+                prefix: CheckCodePrefix::F405,
+            },
+            PatternPrefixPair {
+                pattern: "tests/test_loader.py".to_string(),
+                prefix: CheckCodePrefix::E741,
+            },
+        ];
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+}

resources/test/fixtures/B002.py

@@ -0,0 +1,20 @@
+"""
+Should emit:
+B002 - on lines 15 and 20
+"""
+
+
+def this_is_all_fine(n):
+    x = n + 1
+    y = 1 + n
+    z = +x + y
+    return +z
+
+
+def this_is_buggy(n):
+    x = ++n
+    return x
+
+
+def this_is_buggy_too(n):
+    return ++n

resources/test/fixtures/B006_B008.py

@@ -0,0 +1,187 @@
+import collections
+import datetime as dt
+import logging
+import operator
+import random
+import re
+import time
+import types
+from operator import attrgetter, itemgetter, methodcaller
+from types import MappingProxyType
+
+
+# B006
+# Allow immutable literals/calls/comprehensions
+def this_is_okay(value=(1, 2, 3)):
+    ...
+
+
+async def and_this_also(value=tuple()):
+    pass
+
+
+def frozenset_also_okay(value=frozenset()):
+    pass
+
+
+def mappingproxytype_okay(
+    value=MappingProxyType({}), value2=types.MappingProxyType({})
+):
+    pass
+
+
+def re_compile_ok(value=re.compile("foo")):
+    pass
+
+
+def operators_ok(
+    v=operator.attrgetter("foo"),
+    v2=operator.itemgetter("foo"),
+    v3=operator.methodcaller("foo"),
+):
+    pass
+
+
+def operators_ok_unqualified(
+    v=attrgetter("foo"),
+    v2=itemgetter("foo"),
+    v3=methodcaller("foo"),
+):
+    pass
+
+
+def kwonlyargs_immutable(*, value=()):
+    ...
+
+
+# Flag mutable literals/comprehensions
+
+
+def this_is_wrong(value=[1, 2, 3]):
+    ...
+
+
+def this_is_also_wrong(value={}):
+    ...
+
+
+def and_this(value=set()):
+    ...
+
+
+def this_too(value=collections.OrderedDict()):
+    ...
+
+
+async def async_this_too(value=collections.defaultdict()):
+    ...
+
+
+def dont_forget_me(value=collections.deque()):
+    ...
+
+
+# N.B. we're also flagging the function call in the comprehension
+def list_comprehension_also_not_okay(default=[i**2 for i in range(3)]):
+    pass
+
+
+def dict_comprehension_also_not_okay(default={i: i**2 for i in range(3)}):
+    pass
+
+
+def set_comprehension_also_not_okay(default={i**2 for i in range(3)}):
+    pass
+
+
+def kwonlyargs_mutable(*, value=[]):
+    ...
+
+
+# Recommended approach for mutable defaults
+def do_this_instead(value=None):
+    if value is None:
+        value = set()
+
+
+# B008
+# Flag function calls as default args (including if they are part of a sub-expression)
+def in_fact_all_calls_are_wrong(value=time.time()):
+    ...
+
+
+def f(when=dt.datetime.now() + dt.timedelta(days=7)):
+    pass
+
+
+def can_even_catch_lambdas(a=(lambda x: x)()):
+    ...
+
+
+# Recommended approach for function calls as default args
+LOGGER = logging.getLogger(__name__)
+
+
+def do_this_instead_of_calls_in_defaults(logger=LOGGER):
+    # That makes it more obvious that this one value is reused.
+    ...
+
+
+# Handle inf/infinity/nan special case
+def float_inf_okay(value=float("inf")):
+    pass
+
+
+def float_infinity_okay(value=float("infinity")):
+    pass
+
+
+def float_plus_infinity_okay(value=float("+infinity")):
+    pass
+
+
+def float_minus_inf_okay(value=float("-inf")):
+    pass
+
+
+def float_nan_okay(value=float("nan")):
+    pass
+
+
+def float_minus_NaN_okay(value=float("-NaN")):
+    pass
+
+
+def float_infinity_literal(value=float("1e999")):
+    pass
+
+
+# But don't allow standard floats
+def float_int_is_wrong(value=float(3)):
+    pass
+
+
+def float_str_not_inf_or_nan_is_wrong(value=float("3.14")):
+    pass
+
+
+# B006 and B008
+# We should handle arbitrary nesting of these B008.
+def nested_combo(a=[float(3), dt.datetime.now()]):
+    pass
+
+
+# Don't flag nested B006 since we can't guarantee that
+# it isn't made mutable by the outer operation.
+def no_nested_b006(a=map(lambda s: s.upper(), ["a", "b", "c"])):
+    pass
+
+
+# B008-ception.
+def nested_b008(a=random.randint(0, dt.datetime.now().year)):
+    pass
+
+
+# Ignore lambda contents since they are evaluated at call time.
+def foo(f=lambda x: print(x)):
+    f(1)

resources/test/fixtures/B007.py

@@ -0,0 +1,31 @@
+for i in range(10):
+    print(i)
+
+print(i)  # name no longer defined on Python 3; no warning yet
+
+for i in range(10):  # name not used within the loop; B007
+    print(10)
+
+print(i)  # name no longer defined on Python 3; no warning yet
+
+
+for _ in range(10):  # _ is okay for a throw-away variable
+    print(10)
+
+
+for i in range(10):
+    for j in range(10):
+        for k in range(10):  # k not used, i and j used transitively
+            print(i + j)
+
+
+def strange_generator():
+    for i in range(10):
+        for j in range(10):
+            for k in range(10):
+                for l in range(10):
+                    yield i, (j, (k, l))
+
+
+for i, (j, (k, l)) in strange_generator():  # i, k not used
+    print(j, l)

resources/test/fixtures/B013.py

@@ -0,0 +1,8 @@
+try:
+    pass
+except (ValueError,):
+    pass
+except AttributeError:
+    pass
+except (ImportError, TypeError):
+    pass

resources/test/fixtures/B017.py

@@ -0,0 +1,36 @@
+"""
+Should emit:
+B017 - on lines 20
+"""
+import asyncio
+import unittest
+
+CONSTANT = True
+
+
+def something_else() -> None:
+    for i in (1, 2, 3):
+        print(i)
+
+
+class Foo:
+    pass
+
+
+class Foobar(unittest.TestCase):
+    def evil_raises(self) -> None:
+        with self.assertRaises(Exception):
+            raise Exception("Evil I say!")
+
+    def context_manager_raises(self) -> None:
+        with self.assertRaises(Exception) as ex:
+            raise Exception("Context manager is good")
+        self.assertEqual("Context manager is good", str(ex.exception))
+
+    def regex_raises(self) -> None:
+        with self.assertRaisesRegex(Exception, "Regex is good"):
+            raise Exception("Regex is good")
+
+    def raises_with_absolute_reference(self):
+        with self.assertRaises(asyncio.CancelledError):
+            Foo()

resources/test/fixtures/C400.py

@@ -1 +1,4 @@
 x = list(x for x in range(3))
+x = list(
+    x for x in range(3)
+)

resources/test/fixtures/C401.py

@@ -1 +1,4 @@
 x = set(x for x in range(3))
+x = set(
+    x for x in range(3)
+)

resources/test/fixtures/C402.py

@@ -1 +1,5 @@
-d = dict((x, x) for x in range(3))
+dict((x, x) for x in range(3))
+dict(
+    (x, x) for x in range(3)
+)
+dict(((x, x) for x in range(3)), z=3)

resources/test/fixtures/C403.py

@@ -1 +1,4 @@
 s = set([x for x in range(3)])
+s = set(
+    [x for x in range(3)]
+)

resources/test/fixtures/C404.py

@@ -1 +1,2 @@
-d = dict([(i, i) for i in range(3)])
+dict([(i, i) for i in range(3)])
+dict([(i, i) for i in range(3)], z=4)

resources/test/fixtures/C409.py

@@ -1,3 +1,10 @@
-t1 = tuple([1, 2])
-t2 = tuple((1, 2))
-t3 = tuple([])
+t1 = tuple([])
+t2 = tuple([1, 2])
+t3 = tuple((1, 2))
+t4 = tuple([
+    1,
+    2
+])
+t5 = tuple(
+    (1, 2)
+)

resources/test/fixtures/F401_5.py

@@ -0,0 +1,5 @@
+"""Test: removal of multi-segment and aliases imports."""
+from a.b import c
+from d.e import f as g
+import h.i
+import j.k as l

resources/test/fixtures/F821_1.py

@@ -0,0 +1,30 @@
+"""Test: typing module imports."""
+from foo import cast
+
+# OK
+x = cast("Model")
+
+from typing import cast
+
+
+# F821 Undefined name `Model`
+x = cast("Model", x)
+
+
+import typing
+
+
+# F821 Undefined name `Model`
+x = typing.cast("Model", x)
+
+
+from typing import Pattern
+
+# F821 Undefined name `Model`
+x = Pattern["Model"]
+
+
+from typing.re import Match
+
+# F821 Undefined name `Model`
+x = Match["Model"]

resources/test/fixtures/F821_2.py

@@ -0,0 +1,18 @@
+"""Test: typing_extensions module imports."""
+from foo import Literal
+
+# F821 Undefined name `Model`
+x: Literal["Model"]
+
+from typing_extensions import Literal
+
+
+# OK
+x: Literal["Model"]
+
+
+import typing_extensions
+
+
+# OK
+x: typing_extensions.Literal["Model"]

resources/test/fixtures/N802.py

@@ -1,3 +1,6 @@
+import unittest
+
+
 def Bad():
     pass
 
@@ -24,3 +27,15 @@ def _good():
 
 def good_func():
     pass
+
+
+def tearDownModule():
+    pass
+
+
+class Test(unittest.TestCase):
+    def tearDown(self):
+        return super().tearDown()
+
+    def testTest(self):
+        assert True

resources/test/fixtures/N806.py

@@ -0,0 +1,5 @@
+def f():
+    lower = 0
+    Camel = 0
+    CONSTANT = 0
+    _ = 0

resources/test/fixtures/N807.py

@@ -0,0 +1,15 @@
+def __bad__():
+    pass
+
+
+def __good():
+    pass
+
+
+def good__():
+    pass
+
+
+class Class:
+    def __good__(self):
+        pass

resources/test/fixtures/N811.py

@@ -0,0 +1,3 @@
+import mod.CONST as const
+from mod import CONSTANT as constant
+from mod import ANOTHER_CONSTANT as another_constant

resources/test/fixtures/N812.py

@@ -0,0 +1,3 @@
+import modl.lowercase as Lower
+from mod import lowercase as Lowercase
+from mod import another_lowercase as AnotherLowercase

resources/test/fixtures/N813.py

@@ -0,0 +1,3 @@
+import mod.Camel as camel
+from mod import CamelCase as camelcase
+from mod import AnotherCamelCase as another_camelcase

resources/test/fixtures/N814.py

@@ -0,0 +1,3 @@
+import mod.Camel as CAMEL
+from mod import CamelCase as CAMELCASE
+from mod import AnotherCamelCase as ANOTHER_CAMELCASE

resources/test/fixtures/N815.py

@@ -0,0 +1,6 @@
+class C:
+    lower = 0
+    CONSTANT = 0
+    mixedCase = 0
+    _mixedCase = 0
+    mixed_Case = 0

resources/test/fixtures/N816.py

@@ -0,0 +1,5 @@
+lower = 0
+CONSTANT = 0
+mixedCase = 0
+_mixedCase = 0
+mixed_Case = 0

resources/test/fixtures/N817.py

@@ -0,0 +1,2 @@
+import mod.CaMel as CM
+from mod import CamelCase as CC

resources/test/fixtures/N818.py

@@ -0,0 +1,10 @@
+class Error(Exception):
+    pass
+
+
+class AnotherError(Exception):
+    pass
+
+
+class C(Exception):
+    pass

resources/test/fixtures/W605.py

@@ -0,0 +1,35 @@
+#: W605:1:10
+regex = '\.png$'
+
+#: W605:2:1
+regex = '''
+\.png$
+'''
+
+#: W605:2:6
+f(
+    '\_'
+)
+
+#: W605:4:6
+"""
+multi-line
+literal
+with \_ somewhere
+in the middle
+"""
+
+#: Okay
+regex = r'\.png$'
+regex = '\\.png$'
+regex = r'''
+\.png$
+'''
+regex = r'''
+\\.png$
+'''
+s = '\\'
+regex = '\w'  # noqa
+regex = '''
+\w
+'''  # noqa

resources/test/fixtures/__init__.py

@@ -1,3 +1,5 @@
+import os
+
 print(__path__)
 
 __all__ = ["a", "b", "c"]

resources/test/fixtures/flake8_quotes/docstring_doubles.py

@@ -0,0 +1,38 @@
+"""
+Double quotes multiline module docstring
+"""
+
+"""
+this is not a docstring
+"""
+
+l = []
+
+class Cls:
+    """
+    Double quotes multiline class docstring
+    """
+
+    """
+    this is not a docstring
+    """
+
+    # The colon in the list indexing below is an edge case for the docstring scanner
+    def f(self, bar="""
+        definitely not a docstring""",
+        val=l[Cls():3]):
+        """
+        Double quotes multiline function docstring
+        """
+
+        some_expression = 'hello world'
+
+        """
+        this is not a docstring
+        """
+
+        if l:
+            """
+            Looks like a docstring, but in reality it isn't - only modules, classes and functions
+            """
+            pass

resources/test/fixtures/flake8_quotes/docstring_doubles_class.py

@@ -0,0 +1,9 @@
+class SingleLineDocstrings():
+    """ Double quotes single line class docstring """
+    """ Not a docstring """
+
+    def foo(self, bar="""not a docstring"""):
+        """ Double quotes single line method docstring"""
+        pass
+
+    class Nested(foo()[:]): """ inline docstring """; pass

resources/test/fixtures/flake8_quotes/docstring_doubles_function.py

@@ -0,0 +1,22 @@
+def foo():
+    """function without params, single line docstring"""
+    """ not a docstring"""
+    return
+
+
+def foo2():
+    """
+        function without params, multiline docstring
+    """
+    """ not a docstring"""
+    return
+
+
+def fun_with_params_no_docstring(a, b="""
+    not a
+""" """docstring"""):
+    pass
+
+def fun_with_params_no_docstring2(a, b=c[foo():], c=\
+    """ not a docstring """):
+    pass

resources/test/fixtures/flake8_quotes/docstring_doubles_module_multiline.py

@@ -0,0 +1,11 @@
+"""
+Double quotes multiline module docstring
+"""
+"""
+this is not a docstring
+"""
+def foo():
+    pass
+"""
+this is not a docstring
+"""

resources/test/fixtures/flake8_quotes/docstring_doubles_module_singleline.py

@@ -0,0 +1,6 @@
+""" Double quotes singleline module docstring """
+""" this is not a docstring """
+
+def foo():
+    pass
+""" this is not a docstring """

resources/test/fixtures/flake8_quotes/docstring_singles.py

@@ -0,0 +1,40 @@
+'''
+Single quotes multiline module docstring
+'''
+
+'''
+this is not a docstring
+'''
+
+l = []
+
+class Cls(MakeKlass('''
+    class params \t not a docstring
+''')):
+    '''
+    Single quotes multiline class docstring
+    '''
+
+    '''
+    this is not a docstring
+    '''
+
+    # The colon in the list indexing below is an edge case for the docstring scanner
+    def f(self, bar='''
+        definitely not a docstring''',
+        val=l[Cls():3]):
+        '''
+        Single quotes multiline function docstring
+        '''
+
+        some_expression = 'hello world'
+
+        '''
+        this is not a docstring
+        '''
+
+        if l:
+            '''
+            Looks like a docstring, but in reality it isn't - only modules, classes and functions
+            '''
+            pass

resources/test/fixtures/flake8_quotes/docstring_singles_class.py

@@ -0,0 +1,9 @@
+class SingleLineDocstrings():
+    ''' Double quotes single line class docstring '''
+    ''' Not a docstring '''
+
+    def foo(self, bar='''not a docstring'''):
+        ''' Double quotes single line method docstring'''
+        pass
+
+    class Nested(foo()[:]): ''' inline docstring '''; pass

resources/test/fixtures/flake8_quotes/docstring_singles_function.py

@@ -0,0 +1,23 @@
+def foo():
+    '''function without params, single line docstring'''
+    ''' not a docstring'''
+    return
+
+
+def foo2():
+    '''
+        function without params, multiline docstring
+    '''
+    ''' not a docstring'''
+    return
+
+
+def fun_with_params_no_docstring(a, b='''
+    not a 
+''' '''docstring'''):
+    pass
+
+def fun_with_params_no_docstring2(a, b=c[foo():], c=\
+    ''' not a docstring '''):
+    pass
+

resources/test/fixtures/flake8_quotes/docstring_singles_module_multiline.py

@@ -0,0 +1,11 @@
+'''
+Double quotes multiline module docstring
+'''
+'''
+this is not a docstring
+'''
+def foo():
+    pass
+'''
+this is not a docstring
+'''

resources/test/fixtures/flake8_quotes/docstring_singles_module_singleline.py

@@ -0,0 +1,6 @@
+''' Double quotes singleline module docstring '''
+''' this is not a docstring '''
+
+def foo():
+    pass
+''' this is not a docstring '''

resources/test/fixtures/flake8_quotes/doubles.py

@@ -0,0 +1,2 @@
+this_should_be_linted = "double quote string"
+this_should_be_linted = u"double quote string"

resources/test/fixtures/flake8_quotes/doubles_escaped.py

@@ -0,0 +1,5 @@
+this_should_raise_Q003 = 'This is a \'string\''
+this_is_fine = '"This" is a \'string\''
+this_is_fine = "This is a 'string'"
+this_is_fine = "\"This\" is a 'string'"
+this_is_fine = r'This is a \'string\''

resources/test/fixtures/flake8_quotes/doubles_multiline_string.py

@@ -0,0 +1,9 @@
+s = """ This "should"
+be
+"linted" """
+
+s = ''' This "should"
+"not" be
+"linted" '''
+
+s = """'This should not be linted due to having would-be quadruple end quote'"""

resources/test/fixtures/flake8_quotes/doubles_noqa.py

@@ -0,0 +1 @@
+this_should_not_be_linted = "double quote string"  # noqa

resources/test/fixtures/flake8_quotes/doubles_wrapped.py

@@ -0,0 +1,2 @@
+s = 'double "quotes" wrapped in singles are ignored'
+s = "single 'quotes' wrapped in doubles are ignored"

resources/test/fixtures/flake8_quotes/singles.py

@@ -0,0 +1,2 @@
+this_should_be_linted = 'single quote string'
+this_should_be_linted = u'double quote string'

resources/test/fixtures/flake8_quotes/singles_escaped.py

@@ -0,0 +1,5 @@
+this_should_raise_Q003 = "This is a \"string\""
+this_is_fine = "'This' is a \"string\""
+this_is_fine = 'This is a "string"'
+this_is_fine = '\'This\' is a "string"'
+this_is_fine = r"This is a \"string\""

resources/test/fixtures/flake8_quotes/singles_multiline_string.py

@@ -0,0 +1,9 @@
+s = ''' This 'should'
+be
+'linted' '''
+
+s = """ This 'should'
+'not' be
+'linted' """
+
+s = '''"This should not be linted due to having would-be quadruple end quote"'''

resources/test/fixtures/flake8_quotes/singles_noqa.py

@@ -0,0 +1 @@
+this_should_not_be_linted = 'single quote string'  # noqa

resources/test/fixtures/flake8_quotes/singles_wrapped.py

@@ -0,0 +1,2 @@
+s = "single 'quotes' wrapped in doubles are ignored"
+s = 'double "quotes" wrapped in singles are ignored'

resources/test/fixtures/pyproject.toml

@@ -1,7 +1,36 @@
 [tool.ruff]
 line-length = 88
 extend-exclude = [
-    "excluded.py",
-    "migrations",
-    "directory/also_excluded.py",
+  "excluded.py",
+  "migrations",
+  "directory/also_excluded.py",
+]
+per-file-ignores = { "__init__.py" = ["F401"] }
+
+[tool.ruff.flake8-quotes]
+inline-quotes = "single"
+multiline-quotes = "double"
+docstring-quotes = "double"
+avoid-escape = true
+
+[tool.ruff.pep8-naming]
+ignore-names = [
+  "setUp",
+  "tearDown",
+  "setUpClass",
+  "tearDownClass",
+  "setUpModule",
+  "tearDownModule",
+  "asyncSetUp",
+  "asyncTearDown",
+  "setUpTestData",
+  "failureException",
+  "longMessage",
+  "maxDiff",
+]
+classmethod-decorators = [
+  "classmethod",
+]
+staticmethod-decorators = [
+  "staticmethod",
 ]

rust-toolchain

@@ -0,0 +1 @@
+1.64.0

rustfmt.toml

@@ -0,0 +1,15 @@
+condense_wildcard_suffixes = true
+edition = "2021"
+format_strings = true
+group_imports = "StdExternalCrate"
+hex_literal_case = "Lower"
+imports_granularity = "Module"
+max_width = 100
+normalize_comments = true
+normalize_doc_attributes = true
+reorder_impl_items = true
+reorder_imports = true
+reorder_modules = true
+unstable_features = true
+use_field_init_shorthand = true
+wrap_comments = true

scripts/.flake8

@@ -17,3 +17,5 @@ exclude =
     test_fstring.py,
     bad_coding2.py,
     badsyntax_*.py
+ignore_names = foo, bar
+quotes = double

src/ast/helpers.rs

@@ -1,8 +1,8 @@
+use std::collections::BTreeSet;
+
 use once_cell::sync::Lazy;
 use regex::Regex;
-use rustpython_ast::{Excepthandler, ExcepthandlerKind, Expr, ExprKind, StmtKind};
-
-use crate::python::typing;
+use rustpython_ast::{Excepthandler, ExcepthandlerKind, Expr, ExprKind, Location, StmtKind};
 
 fn compose_call_path_inner<'a>(expr: &'a Expr, parts: &mut Vec<&'a str>) {
     match &expr.node {
@@ -30,6 +30,7 @@ pub fn compose_call_path(expr: &Expr) -> Option<String> {
     }
 }
 
+/// Return `true` if the `Expr` is a name or attribute reference to `${target}`.
 pub fn match_name_or_attr(expr: &Expr, target: &str) -> bool {
     match &expr.node {
         ExprKind::Attribute { attr, .. } => target == attr,
@@ -38,40 +39,36 @@ pub fn match_name_or_attr(expr: &Expr, target: &str) -> bool {
     }
 }
 
-pub enum SubscriptKind {
-    AnnotatedSubscript,
-    PEP593AnnotatedSubscript,
-}
-
-pub fn match_annotated_subscript(expr: &Expr) -> Option<SubscriptKind> {
+/// Return `true` if the `Expr` is a reference to `${module}.${target}`.
+///
+/// Useful for, e.g., ensuring that a `Union` reference represents
+/// `typing.Union`.
+pub fn match_name_or_attr_from_module(
+    expr: &Expr,
+    target: &str,
+    module: &str,
+    imports: Option<&BTreeSet<&str>>,
+) -> bool {
     match &expr.node {
-        ExprKind::Attribute { attr, .. } => {
-            if typing::is_annotated_subscript(attr) {
-                Some(SubscriptKind::AnnotatedSubscript)
-            } else if typing::is_pep593_annotated_subscript(attr) {
-                Some(SubscriptKind::PEP593AnnotatedSubscript)
-            } else {
-                None
-            }
-        }
+        ExprKind::Attribute { value, attr, .. } => match &value.node {
+            ExprKind::Name { id, .. } => id == module && target == attr,
+            _ => false,
+        },
         ExprKind::Name { id, .. } => {
-            if typing::is_annotated_subscript(id) {
-                Some(SubscriptKind::AnnotatedSubscript)
-            } else if typing::is_pep593_annotated_subscript(id) {
-                Some(SubscriptKind::PEP593AnnotatedSubscript)
-            } else {
-                None
-            }
+            target == id
+                && imports
+                    .map(|imports| imports.contains(&id.as_str()))
+                    .unwrap_or_default()
         }
-        _ => None,
+        _ => false,
     }
 }
 
 static DUNDER_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"__[^\s]+__").unwrap());
 
 pub fn is_assignment_to_a_dunder(node: &StmtKind) -> bool {
-    // Check whether it's an assignment to a dunder, with or without a type annotation.
-    // This is what pycodestyle (as of 2.9.1) does.
+    // Check whether it's an assignment to a dunder, with or without a type
+    // annotation. This is what pycodestyle (as of 2.9.1) does.
     match node {
         StmtKind::Assign {
             targets,
@@ -131,3 +128,16 @@ pub fn is_super_call_with_arguments(func: &Expr, args: &[Expr]) -> bool {
         false
     }
 }
+
+/// Convert a location within a file (relative to `base`) to an absolute
+/// position.
+pub fn to_absolute(relative: &Location, base: &Location) -> Location {
+    if relative.row() == 1 {
+        Location::new(
+            relative.row() + base.row() - 1,
+            relative.column() + base.column(),
+        )
+    } else {
+        Location::new(relative.row() + base.row() - 1, relative.column())
+    }
+}

src/ast/mod.rs

@@ -1,4 +1,3 @@
-pub mod checkers;
 pub mod helpers;
 pub mod operations;
 pub mod relocate;

src/ast/operations.rs

@@ -1,6 +1,6 @@
-use rustpython_parser::ast::{Constant, Expr, ExprKind, Location, Stmt, StmtKind};
+use rustpython_parser::ast::{Constant, Expr, ExprKind, Stmt, StmtKind};
 
-use crate::ast::types::{BindingKind, Range, Scope};
+use crate::ast::types::{BindingKind, Scope};
 
 /// Extract the names bound to a given __all__ assignment.
 pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
@@ -117,69 +117,3 @@ pub fn is_unpacking_assignment(stmt: &Stmt) -> bool {
     }
     false
 }
-
-/// Struct used to efficiently slice source code at (row, column) Locations.
-pub struct SourceCodeLocator<'a> {
-    content: &'a str,
-    offsets: Vec<Vec<usize>>,
-    initialized: bool,
-}
-
-impl<'a> SourceCodeLocator<'a> {
-    pub fn new(content: &'a str) -> Self {
-        SourceCodeLocator {
-            content,
-            offsets: vec![],
-            initialized: false,
-        }
-    }
-
-    fn init(&mut self) {
-        if !self.initialized {
-            let mut offset = 0;
-            for line in self.content.lines() {
-                let mut newline = 0;
-                let mut line_offsets: Vec<usize> = vec![];
-                for (i, _char) in line.char_indices() {
-                    line_offsets.push(offset + i);
-                    newline = i + 1;
-                }
-                line_offsets.push(offset + newline);
-                self.offsets.push(line_offsets);
-                offset += newline + 1;
-            }
-            self.offsets.push(vec![offset]);
-            self.initialized = true;
-        }
-    }
-
-    pub fn slice_source_code_at(&mut self, location: &Location) -> &'a str {
-        self.init();
-        let offset = self.offsets[location.row() - 1][location.column() - 1];
-        &self.content[offset..]
-    }
-
-    pub fn slice_source_code_range(&mut self, range: &Range) -> &'a str {
-        self.init();
-        let start = self.offsets[range.location.row() - 1][range.location.column() - 1];
-        let end = self.offsets[range.end_location.row() - 1][range.end_location.column() - 1];
-        &self.content[start..end]
-    }
-
-    pub fn partition_source_code_at(
-        &mut self,
-        outer: &Range,
-        inner: &Range,
-    ) -> (&'a str, &'a str, &'a str) {
-        self.init();
-        let outer_start = self.offsets[outer.location.row() - 1][outer.location.column() - 1];
-        let outer_end = self.offsets[outer.end_location.row() - 1][outer.end_location.column() - 1];
-        let inner_start = self.offsets[inner.location.row() - 1][inner.location.column() - 1];
-        let inner_end = self.offsets[inner.end_location.row() - 1][inner.end_location.column() - 1];
-        (
-            &self.content[outer_start..inner_start],
-            &self.content[inner_start..inner_end],
-            &self.content[inner_end..outer_end],
-        )
-    }
-}

src/ast/relocate.rs

@@ -4,14 +4,15 @@ use crate::ast::types::Range;
 
 fn relocate_keyword(keyword: &mut Keyword, location: Range) {
     keyword.location = location.location;
-    keyword.end_location = location.end_location;
+    keyword.end_location = Some(location.end_location);
     relocate_expr(&mut keyword.node.value, location);
 }
 
-/// Change an expression's location (recursively) to match a desired, fixed location.
+/// Change an expression's location (recursively) to match a desired, fixed
+/// location.
 pub fn relocate_expr(expr: &mut Expr, location: Range) {
     expr.location = location.location;
-    expr.end_location = location.end_location;
+    expr.end_location = Some(location.end_location);
     match &mut expr.node {
         ExprKind::BoolOp { values, .. } => {
             for expr in values {

src/ast/types.rs

@@ -18,7 +18,9 @@ impl Range {
     pub fn from_located<T>(located: &Located<T>) -> Self {
         Range {
             location: located.location,
-            end_location: located.end_location,
+            end_location: located
+                .end_location
+                .expect("AST nodes should have end_location."),
         }
     }
 }
@@ -83,8 +85,8 @@ pub enum BindingKind {
 pub struct Binding {
     pub kind: BindingKind,
     pub range: Range,
-    /// Tuple of (scope index, range) indicating the scope and range at which the binding was
-    /// last used.
+    /// Tuple of (scope index, range) indicating the scope and range at which
+    /// the binding was last used.
     pub used: Option<(usize, Range)>,
 }
 

src/autofix.rs

@@ -1,2 +0,0 @@
-pub mod fixer;
-pub mod fixes;

src/autofix/fixer.rs

@@ -1,8 +1,13 @@
+use std::collections::BTreeSet;
+
 use itertools::Itertools;
 use rustpython_parser::ast::Location;
 
-use crate::checks::{Check, Fix};
+use crate::autofix::{Fix, Patch};
+use crate::checks::Check;
 
+// TODO(charlie): The model here is awkward because `Apply` is only relevant at
+// higher levels in the execution flow.
 #[derive(Hash)]
 pub enum Mode {
     Generate,
@@ -10,6 +15,17 @@ pub enum Mode {
     None,
 }
 
+impl Mode {
+    /// Return `true` if a patch should be generated under the given `Mode`.
+    pub fn patch(&self) -> bool {
+        match &self {
+            Mode::Generate => true,
+            Mode::Apply => true,
+            Mode::None => false,
+        }
+    }
+}
+
 impl From<bool> for Mode {
     fn from(value: bool) -> Self {
         match value {
@@ -35,34 +51,44 @@ pub fn fix_file(checks: &mut [Check], contents: &str) -> Option<String> {
 fn apply_fixes<'a>(fixes: impl Iterator<Item = &'a mut Fix>, contents: &str) -> String {
     let lines: Vec<&str> = contents.lines().collect();
 
-    let mut output = "".to_string();
-    let mut last_pos: Location = Location::new(0, 0);
+    let mut output: String = Default::default();
+    let mut last_pos: Location = Default::default();
+    let mut applied: BTreeSet<&Patch> = Default::default();
 
-    for fix in fixes.sorted_by_key(|fix| fix.location) {
-        // Best-effort approach: if this fix overlaps with a fix we've already applied, skip it.
-        if last_pos > fix.location {
+    for fix in fixes.sorted_by_key(|fix| fix.patch.location) {
+        // If we already applied an identical fix as part of another correction, skip
+        // any re-application.
+        if applied.contains(&fix.patch) {
+            fix.applied = true;
             continue;
         }
 
-        if fix.location.row() > last_pos.row() {
+        // Best-effort approach: if this fix overlaps with a fix we've already applied,
+        // skip it.
+        if last_pos > fix.patch.location {
+            continue;
+        }
+
+        if fix.patch.location.row() > last_pos.row() {
             if last_pos.row() > 0 || last_pos.column() > 0 {
-                output.push_str(&lines[last_pos.row() - 1][last_pos.column() - 1..]);
+                output.push_str(&lines[last_pos.row() - 1][last_pos.column()..]);
                 output.push('\n');
             }
-            for line in &lines[last_pos.row()..fix.location.row() - 1] {
+            for line in &lines[last_pos.row()..fix.patch.location.row() - 1] {
                 output.push_str(line);
                 output.push('\n');
             }
-            output.push_str(&lines[fix.location.row() - 1][..fix.location.column() - 1]);
-            output.push_str(&fix.content);
+            output.push_str(&lines[fix.patch.location.row() - 1][..fix.patch.location.column()]);
+            output.push_str(&fix.patch.content);
         } else {
             output.push_str(
-                &lines[last_pos.row() - 1][last_pos.column() - 1..fix.location.column() - 1],
+                &lines[last_pos.row() - 1][last_pos.column()..fix.patch.location.column()],
             );
-            output.push_str(&fix.content);
+            output.push_str(&fix.patch.content);
         }
+        last_pos = fix.patch.end_location;
 
-        last_pos = fix.end_location;
+        applied.insert(&fix.patch);
         fix.applied = true;
     }
 
@@ -70,7 +96,7 @@ fn apply_fixes<'a>(fixes: impl Iterator<Item = &'a mut Fix>, contents: &str) ->
         && (last_pos.row() - 1) < lines.len()
         && (last_pos.row() > 0 || last_pos.column() > 0)
     {
-        output.push_str(&lines[last_pos.row() - 1][last_pos.column() - 1..]);
+        output.push_str(&lines[last_pos.row() - 1][last_pos.column()..]);
         output.push('\n');
     }
     if last_pos.row() < lines.len() {
@@ -89,7 +115,7 @@ mod tests {
     use rustpython_parser::ast::Location;
 
     use crate::autofix::fixer::apply_fixes;
-    use crate::checks::Fix;
+    use crate::autofix::{Fix, Patch};
 
     #[test]
     fn empty_file() -> Result<()> {
@@ -105,9 +131,11 @@ mod tests {
     #[test]
     fn apply_single_replacement() -> Result<()> {
         let mut fixes = vec![Fix {
-            content: "Bar".to_string(),
-            location: Location::new(1, 9),
-            end_location: Location::new(1, 15),
+            patch: Patch {
+                content: "Bar".to_string(),
+                location: Location::new(1, 8),
+                end_location: Location::new(1, 14),
+            },
             applied: false,
         }];
         let actual = apply_fixes(
@@ -129,9 +157,11 @@ mod tests {
     #[test]
     fn apply_single_removal() -> Result<()> {
         let mut fixes = vec![Fix {
-            content: "".to_string(),
-            location: Location::new(1, 8),
-            end_location: Location::new(1, 16),
+            patch: Patch {
+                content: "".to_string(),
+                location: Location::new(1, 7),
+                end_location: Location::new(1, 15),
+            },
             applied: false,
         }];
         let actual = apply_fixes(
@@ -154,15 +184,19 @@ mod tests {
     fn apply_double_removal() -> Result<()> {
         let mut fixes = vec![
             Fix {
-                content: "".to_string(),
-                location: Location::new(1, 8),
-                end_location: Location::new(1, 17),
+                patch: Patch {
+                    content: "".to_string(),
+                    location: Location::new(1, 7),
+                    end_location: Location::new(1, 16),
+                },
                 applied: false,
             },
             Fix {
-                content: "".to_string(),
-                location: Location::new(1, 17),
-                end_location: Location::new(1, 24),
+                patch: Patch {
+                    content: "".to_string(),
+                    location: Location::new(1, 16),
+                    end_location: Location::new(1, 23),
+                },
                 applied: false,
             },
         ];
@@ -186,15 +220,19 @@ mod tests {
     fn ignore_overlapping_fixes() -> Result<()> {
         let mut fixes = vec![
             Fix {
-                content: "".to_string(),
-                location: Location::new(1, 8),
-                end_location: Location::new(1, 16),
+                patch: Patch {
+                    content: "".to_string(),
+                    location: Location::new(1, 7),
+                    end_location: Location::new(1, 15),
+                },
                 applied: false,
             },
             Fix {
-                content: "ignored".to_string(),
-                location: Location::new(1, 10),
-                end_location: Location::new(1, 12),
+                patch: Patch {
+                    content: "ignored".to_string(),
+                    location: Location::new(1, 9),
+                    end_location: Location::new(1, 11),
+                },
                 applied: false,
             },
         ];

src/autofix/fixes.rs

@@ -1,392 +0,0 @@
-use anyhow::Result;
-use itertools::Itertools;
-use libcst_native::ImportNames::Aliases;
-use libcst_native::NameOrAttribute::N;
-use libcst_native::{Codegen, Expression, SmallStatement, Statement};
-use rustpython_parser::ast::{ExcepthandlerKind, Expr, Keyword, Location, Stmt, StmtKind};
-use rustpython_parser::lexer;
-use rustpython_parser::token::Tok;
-
-use crate::ast::operations::SourceCodeLocator;
-use crate::ast::types::Range;
-use crate::checks::Fix;
-
-/// Convert a location within a file (relative to `base`) to an absolute position.
-fn to_absolute(relative: &Location, base: &Location) -> Location {
-    if relative.row() == 1 {
-        Location::new(
-            relative.row() + base.row() - 1,
-            relative.column() + base.column() - 1,
-        )
-    } else {
-        Location::new(relative.row() + base.row() - 1, relative.column())
-    }
-}
-
-/// Generate a fix to remove a base from a ClassDef statement.
-pub fn remove_class_def_base(
-    locator: &mut SourceCodeLocator,
-    stmt_at: &Location,
-    expr_at: Location,
-    bases: &[Expr],
-    keywords: &[Keyword],
-) -> Option<Fix> {
-    let content = locator.slice_source_code_at(stmt_at);
-
-    // Case 1: `object` is the only base.
-    if bases.len() == 1 && keywords.is_empty() {
-        let mut fix_start = None;
-        let mut fix_end = None;
-        let mut count: usize = 0;
-        for (start, tok, end) in lexer::make_tokenizer(content).flatten() {
-            if matches!(tok, Tok::Lpar) {
-                if count == 0 {
-                    fix_start = Some(to_absolute(&start, stmt_at));
-                }
-                count += 1;
-            }
-
-            if matches!(tok, Tok::Rpar) {
-                count -= 1;
-                if count == 0 {
-                    fix_end = Some(to_absolute(&end, stmt_at));
-                    break;
-                }
-            }
-        }
-
-        return match (fix_start, fix_end) {
-            (Some(start), Some(end)) => Some(Fix {
-                content: "".to_string(),
-                location: start,
-                end_location: end,
-                applied: false,
-            }),
-            _ => None,
-        };
-    }
-
-    if bases
-        .iter()
-        .map(|node| node.location)
-        .chain(keywords.iter().map(|node| node.location))
-        .any(|location| location > expr_at)
-    {
-        // Case 2: `object` is _not_ the last node.
-        let mut fix_start: Option<Location> = None;
-        let mut fix_end: Option<Location> = None;
-        let mut seen_comma = false;
-        for (start, tok, end) in lexer::make_tokenizer(content).flatten() {
-            let start = to_absolute(&start, stmt_at);
-            if seen_comma {
-                if matches!(tok, Tok::Newline) {
-                    fix_end = Some(end);
-                } else {
-                    fix_end = Some(start);
-                }
-                break;
-            }
-            if start == expr_at {
-                fix_start = Some(start);
-            }
-            if fix_start.is_some() && matches!(tok, Tok::Comma) {
-                seen_comma = true;
-            }
-        }
-
-        match (fix_start, fix_end) {
-            (Some(start), Some(end)) => Some(Fix {
-                content: "".to_string(),
-                location: start,
-                end_location: end,
-                applied: false,
-            }),
-            _ => None,
-        }
-    } else {
-        // Case 3: `object` is the last node, so we have to find the last token that isn't a comma.
-        let mut fix_start: Option<Location> = None;
-        let mut fix_end: Option<Location> = None;
-        for (start, tok, end) in lexer::make_tokenizer(content).flatten() {
-            let start = to_absolute(&start, stmt_at);
-            let end = to_absolute(&end, stmt_at);
-            if start == expr_at {
-                fix_end = Some(end);
-                break;
-            }
-            if matches!(tok, Tok::Comma) {
-                fix_start = Some(start);
-            }
-        }
-
-        match (fix_start, fix_end) {
-            (Some(start), Some(end)) => Some(Fix {
-                content: "".to_string(),
-                location: start,
-                end_location: end,
-                applied: false,
-            }),
-            _ => None,
-        }
-    }
-}
-
-pub fn remove_super_arguments(locator: &mut SourceCodeLocator, expr: &Expr) -> Option<Fix> {
-    let range = Range::from_located(expr);
-    let contents = locator.slice_source_code_range(&range);
-
-    let mut tree = match libcst_native::parse_module(contents, None) {
-        Ok(m) => m,
-        Err(_) => return None,
-    };
-
-    if let Some(Statement::Simple(body)) = tree.body.first_mut() {
-        if let Some(SmallStatement::Expr(body)) = body.body.first_mut() {
-            if let Expression::Call(body) = &mut body.value {
-                body.args = vec![];
-                body.whitespace_before_args = Default::default();
-                body.whitespace_after_func = Default::default();
-
-                let mut state = Default::default();
-                tree.codegen(&mut state);
-
-                return Some(Fix {
-                    content: state.to_string(),
-                    location: range.location,
-                    end_location: range.end_location,
-                    applied: false,
-                });
-            }
-        }
-    }
-
-    None
-}
-
-/// Determine if a body contains only a single statement, taking into account deleted.
-fn has_single_child(body: &[Stmt], deleted: &[&Stmt]) -> bool {
-    body.iter().filter(|child| !deleted.contains(child)).count() == 1
-}
-
-/// Determine if a child is the only statement in its body.
-fn is_lone_child(child: &Stmt, parent: &Stmt, deleted: &[&Stmt]) -> Result<bool> {
-    match &parent.node {
-        StmtKind::FunctionDef { body, .. }
-        | StmtKind::AsyncFunctionDef { body, .. }
-        | StmtKind::ClassDef { body, .. }
-        | StmtKind::With { body, .. }
-        | StmtKind::AsyncWith { body, .. } => {
-            if body.iter().contains(child) {
-                Ok(has_single_child(body, deleted))
-            } else {
-                Err(anyhow::anyhow!("Unable to find child in parent body."))
-            }
-        }
-        StmtKind::For { body, orelse, .. }
-        | StmtKind::AsyncFor { body, orelse, .. }
-        | StmtKind::While { body, orelse, .. }
-        | StmtKind::If { body, orelse, .. } => {
-            if body.iter().contains(child) {
-                Ok(has_single_child(body, deleted))
-            } else if orelse.iter().contains(child) {
-                Ok(has_single_child(orelse, deleted))
-            } else {
-                Err(anyhow::anyhow!("Unable to find child in parent body."))
-            }
-        }
-        StmtKind::Try {
-            body,
-            handlers,
-            orelse,
-            finalbody,
-        } => {
-            if body.iter().contains(child) {
-                Ok(has_single_child(body, deleted))
-            } else if orelse.iter().contains(child) {
-                Ok(has_single_child(orelse, deleted))
-            } else if finalbody.iter().contains(child) {
-                Ok(has_single_child(finalbody, deleted))
-            } else if let Some(body) = handlers.iter().find_map(|handler| match &handler.node {
-                ExcepthandlerKind::ExceptHandler { body, .. } => {
-                    if body.iter().contains(child) {
-                        Some(body)
-                    } else {
-                        None
-                    }
-                }
-            }) {
-                Ok(has_single_child(body, deleted))
-            } else {
-                Err(anyhow::anyhow!("Unable to find child in parent body."))
-            }
-        }
-        _ => Err(anyhow::anyhow!("Unable to find child in parent body.")),
-    }
-}
-
-pub fn remove_stmt(stmt: &Stmt, parent: Option<&Stmt>, deleted: &[&Stmt]) -> Result<Fix> {
-    if parent
-        .map(|parent| is_lone_child(stmt, parent, deleted))
-        .map_or(Ok(None), |v| v.map(Some))?
-        .unwrap_or_default()
-    {
-        // If removing this node would lead to an invalid syntax tree, replace
-        // it with a `pass`.
-        Ok(Fix {
-            location: stmt.location,
-            end_location: stmt.end_location,
-            content: "pass".to_string(),
-            applied: false,
-        })
-    } else {
-        // Otherwise, nuke the entire line.
-        // TODO(charlie): This logic assumes that there are no multi-statement physical lines.
-        Ok(Fix {
-            location: Location::new(stmt.location.row(), 1),
-            end_location: Location::new(stmt.end_location.row() + 1, 1),
-            content: "".to_string(),
-            applied: false,
-        })
-    }
-}
-
-/// Generate a Fix to remove any unused imports from an `import` statement.
-pub fn remove_unused_imports(
-    locator: &mut SourceCodeLocator,
-    full_names: &[&str],
-    stmt: &Stmt,
-    parent: Option<&Stmt>,
-    deleted: &[&Stmt],
-) -> Result<Fix> {
-    let mut tree = match libcst_native::parse_module(
-        locator.slice_source_code_range(&Range::from_located(stmt)),
-        None,
-    ) {
-        Ok(m) => m,
-        Err(_) => return Err(anyhow::anyhow!("Failed to extract CST from source.")),
-    };
-
-    let body = if let Some(Statement::Simple(body)) = tree.body.first_mut() {
-        body
-    } else {
-        return Err(anyhow::anyhow!("Expected node to be: Statement::Simple."));
-    };
-    let body = if let Some(SmallStatement::Import(body)) = body.body.first_mut() {
-        body
-    } else {
-        return Err(anyhow::anyhow!(
-            "Expected node to be: SmallStatement::ImportFrom."
-        ));
-    };
-    let aliases = &mut body.names;
-
-    // Preserve the trailing comma (or not) from the last entry.
-    let trailing_comma = aliases.last().and_then(|alias| alias.comma.clone());
-
-    // Identify unused imports from within the `import from`.
-    let mut removable = vec![];
-    for (index, alias) in aliases.iter().enumerate() {
-        if let N(import_name) = &alias.name {
-            if full_names.contains(&import_name.value) {
-                removable.push(index);
-            }
-        }
-    }
-    // TODO(charlie): This is quadratic.
-    for index in removable.iter().rev() {
-        aliases.remove(*index);
-    }
-
-    if let Some(alias) = aliases.last_mut() {
-        alias.comma = trailing_comma;
-    }
-
-    if aliases.is_empty() {
-        remove_stmt(stmt, parent, deleted)
-    } else {
-        let mut state = Default::default();
-        tree.codegen(&mut state);
-
-        Ok(Fix {
-            content: state.to_string(),
-            location: stmt.location,
-            end_location: stmt.end_location,
-            applied: false,
-        })
-    }
-}
-
-/// Generate a Fix to remove any unused imports from an `import from` statement.
-pub fn remove_unused_import_froms(
-    locator: &mut SourceCodeLocator,
-    full_names: &[&str],
-    stmt: &Stmt,
-    parent: Option<&Stmt>,
-    deleted: &[&Stmt],
-) -> Result<Fix> {
-    let mut tree = match libcst_native::parse_module(
-        locator.slice_source_code_range(&Range::from_located(stmt)),
-        None,
-    ) {
-        Ok(m) => m,
-        Err(_) => return Err(anyhow::anyhow!("Failed to extract CST from source.")),
-    };
-
-    let body = if let Some(Statement::Simple(body)) = tree.body.first_mut() {
-        body
-    } else {
-        return Err(anyhow::anyhow!("Expected node to be: Statement::Simple."));
-    };
-    let body = if let Some(SmallStatement::ImportFrom(body)) = body.body.first_mut() {
-        body
-    } else {
-        return Err(anyhow::anyhow!(
-            "Expected node to be: SmallStatement::ImportFrom."
-        ));
-    };
-    let aliases = if let Aliases(aliases) = &mut body.names {
-        aliases
-    } else {
-        return Err(anyhow::anyhow!("Expected node to be: Aliases."));
-    };
-
-    // Preserve the trailing comma (or not) from the last entry.
-    let trailing_comma = aliases.last().and_then(|alias| alias.comma.clone());
-
-    // Identify unused imports from within the `import from`.
-    let mut removable = vec![];
-    for (index, alias) in aliases.iter().enumerate() {
-        if let N(name) = &alias.name {
-            let import_name = if let Some(N(module_name)) = &body.module {
-                format!("{}.{}", module_name.value, name.value)
-            } else {
-                name.value.to_string()
-            };
-            if full_names.contains(&import_name.as_str()) {
-                removable.push(index);
-            }
-        }
-    }
-    // TODO(charlie): This is quadratic.
-    for index in removable.iter().rev() {
-        aliases.remove(*index);
-    }
-
-    if let Some(alias) = aliases.last_mut() {
-        alias.comma = trailing_comma;
-    }
-
-    if aliases.is_empty() {
-        remove_stmt(stmt, parent, deleted)
-    } else {
-        let mut state = Default::default();
-        tree.codegen(&mut state);
-
-        Ok(Fix {
-            content: state.to_string(),
-            location: stmt.location,
-            end_location: stmt.end_location,
-            applied: false,
-        })
-    }
-}

src/autofix/helpers.rs

@@ -0,0 +1,91 @@
+use anyhow::Result;
+use itertools::Itertools;
+use rustpython_parser::ast::{ExcepthandlerKind, Location, Stmt, StmtKind};
+
+use crate::autofix::Fix;
+
+/// Determine if a body contains only a single statement, taking into account
+/// deleted.
+fn has_single_child(body: &[Stmt], deleted: &[&Stmt]) -> bool {
+    body.iter().filter(|child| !deleted.contains(child)).count() == 1
+}
+
+/// Determine if a child is the only statement in its body.
+fn is_lone_child(child: &Stmt, parent: &Stmt, deleted: &[&Stmt]) -> Result<bool> {
+    match &parent.node {
+        StmtKind::FunctionDef { body, .. }
+        | StmtKind::AsyncFunctionDef { body, .. }
+        | StmtKind::ClassDef { body, .. }
+        | StmtKind::With { body, .. }
+        | StmtKind::AsyncWith { body, .. } => {
+            if body.iter().contains(child) {
+                Ok(has_single_child(body, deleted))
+            } else {
+                Err(anyhow::anyhow!("Unable to find child in parent body."))
+            }
+        }
+        StmtKind::For { body, orelse, .. }
+        | StmtKind::AsyncFor { body, orelse, .. }
+        | StmtKind::While { body, orelse, .. }
+        | StmtKind::If { body, orelse, .. } => {
+            if body.iter().contains(child) {
+                Ok(has_single_child(body, deleted))
+            } else if orelse.iter().contains(child) {
+                Ok(has_single_child(orelse, deleted))
+            } else {
+                Err(anyhow::anyhow!("Unable to find child in parent body."))
+            }
+        }
+        StmtKind::Try {
+            body,
+            handlers,
+            orelse,
+            finalbody,
+        } => {
+            if body.iter().contains(child) {
+                Ok(has_single_child(body, deleted))
+            } else if orelse.iter().contains(child) {
+                Ok(has_single_child(orelse, deleted))
+            } else if finalbody.iter().contains(child) {
+                Ok(has_single_child(finalbody, deleted))
+            } else if let Some(body) = handlers.iter().find_map(|handler| match &handler.node {
+                ExcepthandlerKind::ExceptHandler { body, .. } => {
+                    if body.iter().contains(child) {
+                        Some(body)
+                    } else {
+                        None
+                    }
+                }
+            }) {
+                Ok(has_single_child(body, deleted))
+            } else {
+                Err(anyhow::anyhow!("Unable to find child in parent body."))
+            }
+        }
+        _ => Err(anyhow::anyhow!("Unable to find child in parent body.")),
+    }
+}
+
+pub fn remove_stmt(stmt: &Stmt, parent: Option<&Stmt>, deleted: &[&Stmt]) -> Result<Fix> {
+    if parent
+        .map(|parent| is_lone_child(stmt, parent, deleted))
+        .map_or(Ok(None), |v| v.map(Some))?
+        .unwrap_or_default()
+    {
+        // If removing this node would lead to an invalid syntax tree, replace
+        // it with a `pass`.
+        Ok(Fix::replacement(
+            "pass".to_string(),
+            stmt.location,
+            stmt.end_location.unwrap(),
+        ))
+    } else {
+        // Otherwise, nuke the entire line.
+        // TODO(charlie): This logic assumes that there are no multi-statement physical
+        // lines.
+        Ok(Fix::deletion(
+            Location::new(stmt.location.row(), 0),
+            Location::new(stmt.end_location.unwrap().row() + 1, 0),
+        ))
+    }
+}

src/autofix/mod.rs

@@ -0,0 +1,53 @@
+use rustpython_ast::Location;
+use serde::{Deserialize, Serialize};
+
+pub mod fixer;
+pub mod helpers;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub struct Patch {
+    pub content: String,
+    pub location: Location,
+    pub end_location: Location,
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Fix {
+    pub patch: Patch,
+    pub applied: bool,
+}
+
+impl Fix {
+    pub fn deletion(start: Location, end: Location) -> Self {
+        Self {
+            patch: Patch {
+                content: "".to_string(),
+                location: start,
+                end_location: end,
+            },
+            applied: false,
+        }
+    }
+
+    pub fn replacement(content: String, start: Location, end: Location) -> Self {
+        Self {
+            patch: Patch {
+                content,
+                location: start,
+                end_location: end,
+            },
+            applied: false,
+        }
+    }
+
+    pub fn insertion(content: String, at: Location) -> Self {
+        Self {
+            patch: Patch {
+                content,
+                location: at,
+                end_location: at,
+            },
+            applied: false,
+        }
+    }
+}

src/cache.rs

@@ -1,4 +1,5 @@
-// cacache uses asyncd-std which has no wasm support, so currently no caching support on wasm
+// cacache uses asyncd-std which has no wasm support, so currently no caching
+// support on wasm
 #![cfg_attr(
     target_family = "wasm",
     allow(unused_imports, unused_variables, dead_code)
@@ -127,7 +128,7 @@ pub fn get(
             }
             Err(e) => error!("Failed to deserialize encoded cache entry: {e:?}"),
         },
-        Err(EntryNotFound(_, _)) => {}
+        Err(EntryNotFound(..)) => {}
         Err(e) => error!("Failed to read from cache: {e:?}"),
     }
     None

src/check_lines.rs

@@ -1,10 +1,12 @@
+//! Lint rules based on checking raw physical lines.
+
 use std::collections::BTreeMap;
 
 use rustpython_parser::ast::Location;
 
 use crate::ast::types::Range;
-use crate::autofix::fixer;
-use crate::checks::{Check, CheckCode, CheckKind, Fix};
+use crate::autofix::{fixer, Fix};
+use crate::checks::{Check, CheckCode, CheckKind};
 use crate::noqa;
 use crate::noqa::Directive;
 use crate::settings::Settings;
@@ -65,7 +67,7 @@ pub fn check_lines(
                     .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
 
                 match noqa {
-                    (Directive::All(_, _), matches) => {
+                    (Directive::All(..), matches) => {
                         matches.push(check.kind.code().as_ref());
                         ignored.push(index)
                     }
@@ -91,13 +93,13 @@ pub fn check_lines(
                 let check = Check::new(
                     CheckKind::LineTooLong(line_length, settings.line_length),
                     Range {
-                        location: Location::new(lineno + 1, 1),
-                        end_location: Location::new(lineno + 1, line_length + 1),
+                        location: Location::new(lineno + 1, 0),
+                        end_location: Location::new(lineno + 1, line_length),
                     },
                 );
 
                 match noqa {
-                    (Directive::All(_, _), matches) => {
+                    (Directive::All(..), matches) => {
                         matches.push(check.kind.code().as_ref());
                     }
                     (Directive::Codes(_, _, codes), matches) => {
@@ -115,8 +117,8 @@ pub fn check_lines(
 
     // Enforce newlines at end of files.
     if settings.enabled.contains(&CheckCode::W292) && !contents.ends_with('\n') {
-        // Note: if `lines.last()` is `None`, then `contents` is empty (and so we don't want to
-        // raise W292 anyway).
+        // Note: if `lines.last()` is `None`, then `contents` is empty (and so we don't
+        // want to raise W292 anyway).
         if let Some(line) = lines.last() {
             let lineno = lines.len() - 1;
             let noqa_lineno = noqa_line_for
@@ -137,7 +139,7 @@ pub fn check_lines(
             );
 
             match noqa {
-                (Directive::All(_, _), matches) => {
+                (Directive::All(..), matches) => {
                     matches.push(check.kind.code().as_ref());
                 }
                 (Directive::Codes(_, _, codes), matches) => {
@@ -161,20 +163,15 @@ pub fn check_lines(
                         let mut check = Check::new(
                             CheckKind::UnusedNOQA(None),
                             Range {
-                                location: Location::new(row + 1, start + 1),
-                                end_location: Location::new(row + 1, end + 1),
+                                location: Location::new(row + 1, start),
+                                end_location: Location::new(row + 1, end),
                             },
                         );
-                        if matches!(autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
-                            check.amend(Fix {
-                                content: "".to_string(),
-                                location: Location::new(row + 1, start + 1),
-                                end_location: Location::new(
-                                    row + 1,
-                                    lines[row].chars().count() + 1,
-                                ),
-                                applied: false,
-                            });
+                        if autofix.patch() {
+                            check.amend(Fix::deletion(
+                                Location::new(row + 1, start),
+                                Location::new(row + 1, lines[row].chars().count()),
+                            ));
                         }
                         line_checks.push(check);
                     }
@@ -194,31 +191,22 @@ pub fn check_lines(
                         let mut check = Check::new(
                             CheckKind::UnusedNOQA(Some(invalid_codes)),
                             Range {
-                                location: Location::new(row + 1, start + 1),
-                                end_location: Location::new(row + 1, end + 1),
+                                location: Location::new(row + 1, start),
+                                end_location: Location::new(row + 1, end),
                             },
                         );
-                        if matches!(autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                        if autofix.patch() {
                             if valid_codes.is_empty() {
-                                check.amend(Fix {
-                                    content: "".to_string(),
-                                    location: Location::new(row + 1, start + 1),
-                                    end_location: Location::new(
-                                        row + 1,
-                                        lines[row].chars().count() + 1,
-                                    ),
-                                    applied: false,
-                                });
+                                check.amend(Fix::deletion(
+                                    Location::new(row + 1, start),
+                                    Location::new(row + 1, lines[row].chars().count()),
+                                ));
                             } else {
-                                check.amend(Fix {
-                                    content: format!("  # noqa: {}", valid_codes.join(", ")),
-                                    location: Location::new(row + 1, start + 1),
-                                    end_location: Location::new(
-                                        row + 1,
-                                        lines[row].chars().count() + 1,
-                                    ),
-                                    applied: false,
-                                });
+                                check.amend(Fix::replacement(
+                                    format!("  # noqa: {}", valid_codes.join(", ")),
+                                    Location::new(row + 1, start),
+                                    Location::new(row + 1, lines[row].chars().count()),
+                                ));
                             }
                         }
                         line_checks.push(check);
@@ -238,11 +226,10 @@ pub fn check_lines(
 
 #[cfg(test)]
 mod tests {
+    use super::check_lines;
     use crate::autofix::fixer;
     use crate::checks::{Check, CheckCode};
-    use crate::settings;
-
-    use super::check_lines;
+    use crate::settings::Settings;
 
     #[test]
     fn e501_non_ascii_char() {
@@ -254,9 +241,9 @@ mod tests {
                 &mut checks,
                 line,
                 &noqa_line_for,
-                &settings::Settings {
+                &Settings {
                     line_length,
-                    ..settings::Settings::for_rule(CheckCode::E501)
+                    ..Settings::for_rule(CheckCode::E501)
                 },
                 &fixer::Mode::Generate,
             );

src/check_tokens.rs

@@ -0,0 +1,51 @@
+//! Lint rules based on token traversal.
+
+use rustpython_parser::lexer::{LexResult, Tok};
+
+use crate::checks::{Check, CheckCode};
+use crate::flake8_quotes::docstring_detection::StateMachine;
+use crate::source_code_locator::SourceCodeLocator;
+use crate::{flake8_quotes, pycodestyle, Settings};
+
+pub fn check_tokens(
+    checks: &mut Vec<Check>,
+    locator: &SourceCodeLocator,
+    tokens: &[LexResult],
+    settings: &Settings,
+) {
+    let enforce_invalid_escape_sequence = settings.enabled.contains(&CheckCode::W605);
+    let enforce_quotes = settings.enabled.contains(&CheckCode::Q000)
+        | settings.enabled.contains(&CheckCode::Q001)
+        | settings.enabled.contains(&CheckCode::Q002)
+        | settings.enabled.contains(&CheckCode::Q003);
+
+    let mut state_machine: StateMachine = Default::default();
+    for (start, tok, end) in tokens.iter().flatten() {
+        // W605
+        if enforce_invalid_escape_sequence {
+            if matches!(tok, Tok::String { .. }) {
+                checks.extend(pycodestyle::checks::invalid_escape_sequence(
+                    locator, start, end,
+                ));
+            }
+        }
+
+        // flake8-quotes
+        if enforce_quotes {
+            let is_docstring = state_machine.consume(tok);
+            if matches!(tok, Tok::String { .. }) {
+                if let Some(check) = flake8_quotes::checks::quotes(
+                    locator,
+                    start,
+                    end,
+                    is_docstring,
+                    &settings.flake8_quotes,
+                ) {
+                    if settings.enabled.contains(check.kind.code()) {
+                        checks.push(check);
+                    }
+                }
+            }
+        }
+    }
+}

src/checks.rs

@@ -5,8 +5,10 @@ use rustpython_parser::ast::Location;
 use serde::{Deserialize, Serialize};
 use strum_macros::{AsRefStr, EnumIter, EnumString};
 
-use crate::ast::checkers::Primitive;
 use crate::ast::types::Range;
+use crate::autofix::Fix;
+use crate::flake8_quotes::settings::Quote;
+use crate::pyupgrade::types::Primitive;
 
 #[derive(
     AsRefStr,
@@ -40,6 +42,7 @@ pub enum CheckCode {
     E999,
     // pycodestyle warnings
     W292,
+    W605,
     // pyflakes
     F401,
     F402,
@@ -74,8 +77,13 @@ pub enum CheckCode {
     A002,
     A003,
     // flake8-bugbear
+    B002,
+    B006,
+    B007,
     B011,
+    B013,
     B014,
+    B017,
     B025,
     // flake8-comprehensions
     C400,
@@ -97,6 +105,11 @@ pub enum CheckCode {
     // flake8-print
     T201,
     T203,
+    // flake8-quotes
+    Q000,
+    Q001,
+    Q002,
+    Q003,
     // pyupgrade
     U001,
     U002,
@@ -157,6 +170,16 @@ pub enum CheckCode {
     N803,
     N804,
     N805,
+    N806,
+    N807,
+    N811,
+    N812,
+    N813,
+    N814,
+    N815,
+    N816,
+    N817,
+    N818,
     // Meta
     M001,
 }
@@ -164,7 +187,8 @@ pub enum CheckCode {
 #[derive(EnumIter, Debug, PartialEq, Eq)]
 pub enum CheckCategory {
     Pyflakes,
-    Pycodestyle,
+    PycodestyleError,
+    PycodestyleWarning,
     Pydocstyle,
     Pyupgrade,
     PEP8Naming,
@@ -172,18 +196,21 @@ pub enum CheckCategory {
     Flake8Bugbear,
     Flake8Builtins,
     Flake8Print,
+    Flake8Quotes,
     Meta,
 }
 
 impl CheckCategory {
     pub fn title(&self) -> &'static str {
         match self {
-            CheckCategory::Pycodestyle => "pycodestyle",
+            CheckCategory::PycodestyleError => "pycodestyle (error)",
+            CheckCategory::PycodestyleWarning => "pycodestyle (warning)",
             CheckCategory::Pyflakes => "Pyflakes",
             CheckCategory::Flake8Builtins => "flake8-builtins",
             CheckCategory::Flake8Bugbear => "flake8-bugbear",
             CheckCategory::Flake8Comprehensions => "flake8-comprehensions",
             CheckCategory::Flake8Print => "flake8-print",
+            CheckCategory::Flake8Quotes => "flake8-quotes",
             CheckCategory::Pyupgrade => "pyupgrade",
             CheckCategory::Pydocstyle => "pydocstyle",
             CheckCategory::PEP8Naming => "pep8-naming",
@@ -195,8 +222,9 @@ impl CheckCategory {
 #[allow(clippy::upper_case_acronyms)]
 pub enum LintSource {
     AST,
-    Lines,
     FileSystem,
+    Lines,
+    Tokens,
 }
 
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -211,18 +239,30 @@ pub enum CheckKind {
     AmbiguousClassName(String),
     AmbiguousFunctionName(String),
     AmbiguousVariableName(String),
+    DoNotAssignLambda,
+    DoNotUseBareExcept,
+    IOError(String),
+    LineTooLong(usize, usize),
+    ModuleImportNotAtTopOfFile,
+    NoneComparison(RejectedCmpop),
+    NotInTest,
+    NotIsTest,
+    SyntaxError(String),
+    TrueFalseComparison(bool, RejectedCmpop),
+    TypeComparison,
+    // pycodestyle warnings
+    NoNewLineAtEndOfFile,
+    InvalidEscapeSequence(char),
+    // pyflakes
     AssertTuple,
     BreakOutsideLoop,
     ContinueOutsideLoop,
     DefaultExceptNotLast,
-    DoNotAssignLambda,
-    DoNotUseBareExcept,
     DuplicateArgumentName,
     ExpressionsInStarAssignment,
     FStringMissingPlaceholders,
     ForwardAnnotationSyntaxError(String),
     FutureFeatureNotDefined(String),
-    IOError(String),
     IfTuple,
     ImportShadowedByLoopVar(String, usize),
     ImportStarNotPermitted(String),
@@ -231,34 +271,29 @@ pub enum CheckKind {
     InvalidPrintSyntax,
     IsLiteral,
     LateFutureImport,
-    LineTooLong(usize, usize),
-    ModuleImportNotAtTopOfFile,
     MultiValueRepeatedKeyLiteral,
     MultiValueRepeatedKeyVariable(String),
-    NoneComparison(RejectedCmpop),
-    NotInTest,
-    NotIsTest,
     RaiseNotImplemented,
     ReturnOutsideFunction,
-    SyntaxError(String),
-    TrueFalseComparison(bool, RejectedCmpop),
     TwoStarredExpressions,
-    TypeComparison,
     UndefinedExport(String),
     UndefinedLocal(String),
     UndefinedName(String),
-    UnusedImport(Vec<String>),
+    UnusedImport(Vec<String>, bool),
     UnusedVariable(String),
     YieldOutsideFunction,
-    // pycodestyle warnings
-    NoNewLineAtEndOfFile,
-    // flake8-builtin
+    // flake8-builtins
     BuiltinVariableShadowing(String),
     BuiltinArgumentShadowing(String),
     BuiltinAttributeShadowing(String),
     // flake8-bugbear
+    UnaryPrefixIncrement,
+    MutableArgumentDefault,
+    UnusedLoopControlVariable(String),
     DoNotAssertFalse,
+    RedundantTupleInExceptionHandler(String),
     DuplicateHandlerException(Vec<String>),
+    NoAssertRaisesException,
     DuplicateTryBlockException(String),
     // flake8-comprehensions
     UnnecessaryGeneratorList,
@@ -280,6 +315,11 @@ pub enum CheckKind {
     // flake8-print
     PrintFound,
     PPrintFound,
+    // flake8-quotes
+    BadQuotesInlineString(Quote),
+    BadQuotesMultilineString(Quote),
+    BadQuotesDocstring(Quote),
+    AvoidQuoteEscape,
     // pyupgrade
     TypeOfPrimitive(Primitive),
     UnnecessaryAbspath,
@@ -292,6 +332,7 @@ pub enum CheckKind {
     // pydocstyle
     BlankLineAfterLastSection(String),
     BlankLineAfterSection(String),
+    BlankLineAfterSummary,
     BlankLineBeforeSection(String),
     CapitalizeSectionName(String),
     DashedUnderlineAfterSection(String),
@@ -307,7 +348,6 @@ pub enum CheckKind {
     NewLineAfterLastParagraph,
     NewLineAfterSectionName(String),
     NoBlankLineAfterFunction(usize),
-    NoBlankLineAfterSummary,
     NoBlankLineBeforeClass(usize),
     NoBlankLineBeforeFunction(usize),
     NoBlankLinesBetweenHeaderAndContent(String),
@@ -340,15 +380,31 @@ pub enum CheckKind {
     InvalidArgumentName(String),
     InvalidFirstArgumentNameForClassMethod,
     InvalidFirstArgumentNameForMethod,
+    NonLowercaseVariableInFunction(String),
+    DunderFunctionName,
+    ConstantImportedAsNonConstant(String, String),
+    LowercaseImportedAsNonLowercase(String, String),
+    CamelcaseImportedAsLowercase(String, String),
+    CamelcaseImportedAsConstant(String, String),
+    MixedCaseVariableInClassScope(String),
+    MixedCaseVariableInGlobalScope(String),
+    CamelcaseImportedAsAcronym(String, String),
+    ErrorSuffixOnExceptionName(String),
     // Meta
     UnusedNOQA(Option<Vec<String>>),
 }
 
 impl CheckCode {
-    /// The source for the check (either the AST, the filesystem, or the physical lines).
+    /// The source for the check (either the AST, the filesystem, or the
+    /// physical lines).
     pub fn lint_source(&self) -> &'static LintSource {
         match self {
             CheckCode::E501 | CheckCode::W292 | CheckCode::M001 => &LintSource::Lines,
+            CheckCode::W605
+            | CheckCode::Q000
+            | CheckCode::Q001
+            | CheckCode::Q002
+            | CheckCode::Q003 => &LintSource::Tokens,
             CheckCode::E902 => &LintSource::FileSystem,
             _ => &LintSource::AST,
         }
@@ -374,8 +430,9 @@ impl CheckCode {
             CheckCode::E999 => CheckKind::SyntaxError("`...`".to_string()),
             // pycodestyle warnings
             CheckCode::W292 => CheckKind::NoNewLineAtEndOfFile,
+            CheckCode::W605 => CheckKind::InvalidEscapeSequence('c'),
             // pyflakes
-            CheckCode::F401 => CheckKind::UnusedImport(vec!["...".to_string()]),
+            CheckCode::F401 => CheckKind::UnusedImport(vec!["...".to_string()], false),
             CheckCode::F402 => CheckKind::ImportShadowedByLoopVar("...".to_string(), 1),
             CheckCode::F403 => CheckKind::ImportStarUsed("...".to_string()),
             CheckCode::F404 => CheckKind::LateFutureImport,
@@ -410,8 +467,15 @@ impl CheckCode {
             CheckCode::A002 => CheckKind::BuiltinArgumentShadowing("...".to_string()),
             CheckCode::A003 => CheckKind::BuiltinAttributeShadowing("...".to_string()),
             // flake8-bugbear
+            CheckCode::B002 => CheckKind::UnaryPrefixIncrement,
+            CheckCode::B006 => CheckKind::MutableArgumentDefault,
+            CheckCode::B007 => CheckKind::UnusedLoopControlVariable("i".to_string()),
             CheckCode::B011 => CheckKind::DoNotAssertFalse,
+            CheckCode::B013 => {
+                CheckKind::RedundantTupleInExceptionHandler("ValueError".to_string())
+            }
             CheckCode::B014 => CheckKind::DuplicateHandlerException(vec!["ValueError".to_string()]),
+            CheckCode::B017 => CheckKind::NoAssertRaisesException,
             CheckCode::B025 => CheckKind::DuplicateTryBlockException("Exception".to_string()),
             // flake8-comprehensions
             CheckCode::C400 => CheckKind::UnnecessaryGeneratorList,
@@ -446,6 +510,11 @@ impl CheckCode {
             // flake8-print
             CheckCode::T201 => CheckKind::PrintFound,
             CheckCode::T203 => CheckKind::PPrintFound,
+            // flake8-quotes
+            CheckCode::Q000 => CheckKind::BadQuotesInlineString(Quote::Double),
+            CheckCode::Q001 => CheckKind::BadQuotesMultilineString(Quote::Double),
+            CheckCode::Q002 => CheckKind::BadQuotesDocstring(Quote::Double),
+            CheckCode::Q003 => CheckKind::AvoidQuoteEscape,
             // pyupgrade
             CheckCode::U001 => CheckKind::UselessMetaclassType,
             CheckCode::U002 => CheckKind::UnnecessaryAbspath,
@@ -472,7 +541,7 @@ impl CheckCode {
             CheckCode::D202 => CheckKind::NoBlankLineAfterFunction(1),
             CheckCode::D203 => CheckKind::OneBlankLineBeforeClass(0),
             CheckCode::D204 => CheckKind::OneBlankLineAfterClass(0),
-            CheckCode::D205 => CheckKind::NoBlankLineAfterSummary,
+            CheckCode::D205 => CheckKind::BlankLineAfterSummary,
             CheckCode::D206 => CheckKind::IndentWithSpaces,
             CheckCode::D207 => CheckKind::NoUnderIndentation,
             CheckCode::D208 => CheckKind::NoOverIndentation,
@@ -515,6 +584,26 @@ impl CheckCode {
             CheckCode::N803 => CheckKind::InvalidArgumentName("...".to_string()),
             CheckCode::N804 => CheckKind::InvalidFirstArgumentNameForClassMethod,
             CheckCode::N805 => CheckKind::InvalidFirstArgumentNameForMethod,
+            CheckCode::N806 => CheckKind::NonLowercaseVariableInFunction("...".to_string()),
+            CheckCode::N807 => CheckKind::DunderFunctionName,
+            CheckCode::N811 => {
+                CheckKind::ConstantImportedAsNonConstant("...".to_string(), "...".to_string())
+            }
+            CheckCode::N812 => {
+                CheckKind::LowercaseImportedAsNonLowercase("...".to_string(), "...".to_string())
+            }
+            CheckCode::N813 => {
+                CheckKind::CamelcaseImportedAsLowercase("...".to_string(), "...".to_string())
+            }
+            CheckCode::N814 => {
+                CheckKind::CamelcaseImportedAsConstant("...".to_string(), "...".to_string())
+            }
+            CheckCode::N815 => CheckKind::MixedCaseVariableInClassScope("mixedCase".to_string()),
+            CheckCode::N816 => CheckKind::MixedCaseVariableInGlobalScope("mixedCase".to_string()),
+            CheckCode::N817 => {
+                CheckKind::CamelcaseImportedAsAcronym("...".to_string(), "...".to_string())
+            }
+            CheckCode::N818 => CheckKind::ErrorSuffixOnExceptionName("...".to_string()),
             // Meta
             CheckCode::M001 => CheckKind::UnusedNOQA(None),
         }
@@ -522,21 +611,22 @@ impl CheckCode {
 
     pub fn category(&self) -> CheckCategory {
         match self {
-            CheckCode::E402 => CheckCategory::Pycodestyle,
-            CheckCode::E501 => CheckCategory::Pycodestyle,
-            CheckCode::E711 => CheckCategory::Pycodestyle,
-            CheckCode::E712 => CheckCategory::Pycodestyle,
-            CheckCode::E713 => CheckCategory::Pycodestyle,
-            CheckCode::E714 => CheckCategory::Pycodestyle,
-            CheckCode::E721 => CheckCategory::Pycodestyle,
-            CheckCode::E722 => CheckCategory::Pycodestyle,
-            CheckCode::E731 => CheckCategory::Pycodestyle,
-            CheckCode::E741 => CheckCategory::Pycodestyle,
-            CheckCode::E742 => CheckCategory::Pycodestyle,
-            CheckCode::E743 => CheckCategory::Pycodestyle,
-            CheckCode::E902 => CheckCategory::Pycodestyle,
-            CheckCode::E999 => CheckCategory::Pycodestyle,
-            CheckCode::W292 => CheckCategory::Pycodestyle,
+            CheckCode::E402 => CheckCategory::PycodestyleError,
+            CheckCode::E501 => CheckCategory::PycodestyleError,
+            CheckCode::E711 => CheckCategory::PycodestyleError,
+            CheckCode::E712 => CheckCategory::PycodestyleError,
+            CheckCode::E713 => CheckCategory::PycodestyleError,
+            CheckCode::E714 => CheckCategory::PycodestyleError,
+            CheckCode::E721 => CheckCategory::PycodestyleError,
+            CheckCode::E722 => CheckCategory::PycodestyleError,
+            CheckCode::E731 => CheckCategory::PycodestyleError,
+            CheckCode::E741 => CheckCategory::PycodestyleError,
+            CheckCode::E742 => CheckCategory::PycodestyleError,
+            CheckCode::E743 => CheckCategory::PycodestyleError,
+            CheckCode::E902 => CheckCategory::PycodestyleError,
+            CheckCode::E999 => CheckCategory::PycodestyleError,
+            CheckCode::W292 => CheckCategory::PycodestyleWarning,
+            CheckCode::W605 => CheckCategory::PycodestyleWarning,
             CheckCode::F401 => CheckCategory::Pyflakes,
             CheckCode::F402 => CheckCategory::Pyflakes,
             CheckCode::F403 => CheckCategory::Pyflakes,
@@ -568,8 +658,13 @@ impl CheckCode {
             CheckCode::A001 => CheckCategory::Flake8Builtins,
             CheckCode::A002 => CheckCategory::Flake8Builtins,
             CheckCode::A003 => CheckCategory::Flake8Builtins,
+            CheckCode::B002 => CheckCategory::Flake8Bugbear,
+            CheckCode::B006 => CheckCategory::Flake8Bugbear,
+            CheckCode::B007 => CheckCategory::Flake8Bugbear,
             CheckCode::B011 => CheckCategory::Flake8Bugbear,
+            CheckCode::B013 => CheckCategory::Flake8Bugbear,
             CheckCode::B014 => CheckCategory::Flake8Bugbear,
+            CheckCode::B017 => CheckCategory::Flake8Bugbear,
             CheckCode::B025 => CheckCategory::Flake8Bugbear,
             CheckCode::C400 => CheckCategory::Flake8Comprehensions,
             CheckCode::C401 => CheckCategory::Flake8Comprehensions,
@@ -589,6 +684,10 @@ impl CheckCode {
             CheckCode::C417 => CheckCategory::Flake8Comprehensions,
             CheckCode::T201 => CheckCategory::Flake8Print,
             CheckCode::T203 => CheckCategory::Flake8Print,
+            CheckCode::Q000 => CheckCategory::Flake8Quotes,
+            CheckCode::Q001 => CheckCategory::Flake8Quotes,
+            CheckCode::Q002 => CheckCategory::Flake8Quotes,
+            CheckCode::Q003 => CheckCategory::Flake8Quotes,
             CheckCode::U001 => CheckCategory::Pyupgrade,
             CheckCode::U002 => CheckCategory::Pyupgrade,
             CheckCode::U003 => CheckCategory::Pyupgrade,
@@ -646,6 +745,16 @@ impl CheckCode {
             CheckCode::N803 => CheckCategory::PEP8Naming,
             CheckCode::N804 => CheckCategory::PEP8Naming,
             CheckCode::N805 => CheckCategory::PEP8Naming,
+            CheckCode::N806 => CheckCategory::PEP8Naming,
+            CheckCode::N807 => CheckCategory::PEP8Naming,
+            CheckCode::N811 => CheckCategory::PEP8Naming,
+            CheckCode::N812 => CheckCategory::PEP8Naming,
+            CheckCode::N813 => CheckCategory::PEP8Naming,
+            CheckCode::N814 => CheckCategory::PEP8Naming,
+            CheckCode::N815 => CheckCategory::PEP8Naming,
+            CheckCode::N816 => CheckCategory::PEP8Naming,
+            CheckCode::N817 => CheckCategory::PEP8Naming,
+            CheckCode::N818 => CheckCategory::PEP8Naming,
             CheckCode::M001 => CheckCategory::Meta,
         }
     }
@@ -671,14 +780,14 @@ impl CheckKind {
             CheckKind::FutureFeatureNotDefined(_) => &CheckCode::F407,
             CheckKind::IOError(_) => &CheckCode::E902,
             CheckKind::IfTuple => &CheckCode::F634,
-            CheckKind::ImportShadowedByLoopVar(_, _) => &CheckCode::F402,
+            CheckKind::ImportShadowedByLoopVar(..) => &CheckCode::F402,
             CheckKind::ImportStarNotPermitted(_) => &CheckCode::F406,
-            CheckKind::ImportStarUsage(_, _) => &CheckCode::F405,
+            CheckKind::ImportStarUsage(..) => &CheckCode::F405,
             CheckKind::ImportStarUsed(_) => &CheckCode::F403,
             CheckKind::InvalidPrintSyntax => &CheckCode::F633,
             CheckKind::IsLiteral => &CheckCode::F632,
             CheckKind::LateFutureImport => &CheckCode::F404,
-            CheckKind::LineTooLong(_, _) => &CheckCode::E501,
+            CheckKind::LineTooLong(..) => &CheckCode::E501,
             CheckKind::ModuleImportNotAtTopOfFile => &CheckCode::E402,
             CheckKind::MultiValueRepeatedKeyLiteral => &CheckCode::F601,
             CheckKind::MultiValueRepeatedKeyVariable(_) => &CheckCode::F602,
@@ -689,24 +798,30 @@ impl CheckKind {
             CheckKind::ReturnOutsideFunction => &CheckCode::F706,
             CheckKind::SyntaxError(_) => &CheckCode::E999,
             CheckKind::ExpressionsInStarAssignment => &CheckCode::F621,
-            CheckKind::TrueFalseComparison(_, _) => &CheckCode::E712,
+            CheckKind::TrueFalseComparison(..) => &CheckCode::E712,
             CheckKind::TwoStarredExpressions => &CheckCode::F622,
             CheckKind::TypeComparison => &CheckCode::E721,
             CheckKind::UndefinedExport(_) => &CheckCode::F822,
             CheckKind::UndefinedLocal(_) => &CheckCode::F823,
             CheckKind::UndefinedName(_) => &CheckCode::F821,
-            CheckKind::UnusedImport(_) => &CheckCode::F401,
+            CheckKind::UnusedImport(..) => &CheckCode::F401,
             CheckKind::UnusedVariable(_) => &CheckCode::F841,
             CheckKind::YieldOutsideFunction => &CheckCode::F704,
             // pycodestyle warnings
             CheckKind::NoNewLineAtEndOfFile => &CheckCode::W292,
+            CheckKind::InvalidEscapeSequence(_) => &CheckCode::W605,
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(_) => &CheckCode::A001,
             CheckKind::BuiltinArgumentShadowing(_) => &CheckCode::A002,
             CheckKind::BuiltinAttributeShadowing(_) => &CheckCode::A003,
             // flake8-bugbear
+            CheckKind::UnaryPrefixIncrement => &CheckCode::B002,
+            CheckKind::MutableArgumentDefault => &CheckCode::B006,
+            CheckKind::UnusedLoopControlVariable(_) => &CheckCode::B007,
             CheckKind::DoNotAssertFalse => &CheckCode::B011,
+            CheckKind::RedundantTupleInExceptionHandler(_) => &CheckCode::B013,
             CheckKind::DuplicateHandlerException(_) => &CheckCode::B014,
+            CheckKind::NoAssertRaisesException => &CheckCode::B017,
             CheckKind::DuplicateTryBlockException(_) => &CheckCode::B025,
             // flake8-comprehensions
             CheckKind::UnnecessaryGeneratorList => &CheckCode::C400,
@@ -728,11 +843,16 @@ impl CheckKind {
             // flake8-print
             CheckKind::PrintFound => &CheckCode::T201,
             CheckKind::PPrintFound => &CheckCode::T203,
+            // flake8-quotes
+            CheckKind::BadQuotesInlineString(_) => &CheckCode::Q000,
+            CheckKind::BadQuotesMultilineString(_) => &CheckCode::Q001,
+            CheckKind::BadQuotesDocstring(_) => &CheckCode::Q002,
+            CheckKind::AvoidQuoteEscape => &CheckCode::Q003,
             // pyupgrade
             CheckKind::TypeOfPrimitive(_) => &CheckCode::U003,
             CheckKind::UnnecessaryAbspath => &CheckCode::U002,
             CheckKind::UselessMetaclassType => &CheckCode::U001,
-            CheckKind::DeprecatedUnittestAlias(_, _) => &CheckCode::U005,
+            CheckKind::DeprecatedUnittestAlias(..) => &CheckCode::U005,
             CheckKind::UsePEP585Annotation(_) => &CheckCode::U006,
             CheckKind::UsePEP604Annotation => &CheckCode::U007,
             CheckKind::UselessObjectInheritance(_) => &CheckCode::U004,
@@ -755,7 +875,7 @@ impl CheckKind {
             CheckKind::NewLineAfterLastParagraph => &CheckCode::D209,
             CheckKind::NewLineAfterSectionName(_) => &CheckCode::D406,
             CheckKind::NoBlankLineAfterFunction(_) => &CheckCode::D202,
-            CheckKind::NoBlankLineAfterSummary => &CheckCode::D205,
+            CheckKind::BlankLineAfterSummary => &CheckCode::D205,
             CheckKind::NoBlankLineBeforeClass(_) => &CheckCode::D211,
             CheckKind::NoBlankLineBeforeFunction(_) => &CheckCode::D201,
             CheckKind::NoBlankLinesBetweenHeaderAndContent(_) => &CheckCode::D412,
@@ -788,6 +908,16 @@ impl CheckKind {
             CheckKind::InvalidArgumentName(_) => &CheckCode::N803,
             CheckKind::InvalidFirstArgumentNameForClassMethod => &CheckCode::N804,
             CheckKind::InvalidFirstArgumentNameForMethod => &CheckCode::N805,
+            CheckKind::NonLowercaseVariableInFunction(..) => &CheckCode::N806,
+            CheckKind::DunderFunctionName => &CheckCode::N807,
+            CheckKind::ConstantImportedAsNonConstant(..) => &CheckCode::N811,
+            CheckKind::LowercaseImportedAsNonLowercase(..) => &CheckCode::N812,
+            CheckKind::CamelcaseImportedAsLowercase(..) => &CheckCode::N813,
+            CheckKind::CamelcaseImportedAsConstant(..) => &CheckCode::N814,
+            CheckKind::MixedCaseVariableInClassScope(..) => &CheckCode::N815,
+            CheckKind::MixedCaseVariableInGlobalScope(..) => &CheckCode::N816,
+            CheckKind::CamelcaseImportedAsAcronym(..) => &CheckCode::N817,
+            CheckKind::ErrorSuffixOnExceptionName(..) => &CheckCode::N818,
             // Meta
             CheckKind::UnusedNOQA(_) => &CheckCode::M001,
         }
@@ -914,18 +1044,25 @@ impl CheckKind {
             CheckKind::UndefinedName(name) => {
                 format!("Undefined name `{name}`")
             }
-            CheckKind::UnusedImport(names) => {
+            CheckKind::UnusedImport(names, in_init_py) => {
                 let names = names.iter().map(|name| format!("`{name}`")).join(", ");
-                format!("{names} imported but unused")
+                if *in_init_py {
+                    format!("{names} imported but unused and missing from `__all__`")
+                } else {
+                    format!("{names} imported but unused")
+                }
             }
             CheckKind::UnusedVariable(name) => {
                 format!("Local variable `{name}` is assigned to but never used")
             }
             CheckKind::YieldOutsideFunction => {
-                "`yield` or `yield from` statement outside of a function/method".to_string()
+                "`yield` or `yield from` statement outside of a function".to_string()
             }
             // pycodestyle warnings
             CheckKind::NoNewLineAtEndOfFile => "No newline at end of file".to_string(),
+            CheckKind::InvalidEscapeSequence(char) => {
+                format!("Invalid escape sequence: '\\{char}'")
+            }
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(name) => {
                 format!("Variable `{name}` is shadowing a python builtin")
@@ -937,9 +1074,25 @@ impl CheckKind {
                 format!("Class attribute `{name}` is shadowing a python builtin")
             }
             // flake8-bugbear
-            CheckKind::DoNotAssertFalse => {
-                "Do not `assert False` (`python -O` removes these calls), raise `AssertionError()`"
-                    .to_string()
+            CheckKind::UnaryPrefixIncrement => "Python does not support the unary prefix \
+                                                increment. Writing `++n` is equivalent to \
+                                                `+(+(n))`, which equals `n`. You meant `n += 1`."
+                .to_string(),
+            CheckKind::MutableArgumentDefault => {
+                "Do not use mutable data structures for argument defaults.".to_string()
+            }
+            CheckKind::UnusedLoopControlVariable(name) => format!(
+                "Loop control variable `{name}` not used within the loop body. If this is \
+                 intended, start the name with an underscore."
+            ),
+            CheckKind::DoNotAssertFalse => "Do not `assert False` (`python -O` removes these \
+                                            calls), raise `AssertionError()`"
+                .to_string(),
+            CheckKind::RedundantTupleInExceptionHandler(name) => {
+                format!(
+                    "A length-one tuple literal is redundant. Write `except {name}:` instead of \
+                     `except ({name},):`."
+                )
             }
             CheckKind::DuplicateHandlerException(names) => {
                 if names.len() == 1 {
@@ -950,6 +1103,13 @@ impl CheckKind {
                     format!("Exception handler with duplicate exceptions: {names}")
                 }
             }
+            CheckKind::NoAssertRaisesException => {
+                "`assertRaises(Exception):` should be considered evil. It can lead to your test \
+                 passing even if the code being tested is never executed due to a typo. Either \
+                 assert for a more specific exception (builtin or custom), use \
+                 `assertRaisesRegex`, or use the context manager form of `assertRaises`."
+                    .to_string()
+            }
             CheckKind::DuplicateTryBlockException(name) => {
                 format!("try-except block with duplicate exception `{name}`")
             }
@@ -981,22 +1141,26 @@ impl CheckKind {
             CheckKind::UnnecessaryLiteralWithinTupleCall(literal) => {
                 if literal == "list" {
                     format!(
-                        "Unnecessary `{literal}` literal passed to `tuple()` (rewrite as a `tuple` literal)"
+                        "Unnecessary `{literal}` literal passed to `tuple()` (rewrite as a \
+                         `tuple` literal)"
                     )
                 } else {
                     format!(
-                        "Unnecessary `{literal}` literal passed to `tuple()` (remove the outer call to `tuple()`)"
+                        "Unnecessary `{literal}` literal passed to `tuple()` (remove the outer \
+                         call to `tuple()`)"
                     )
                 }
             }
             CheckKind::UnnecessaryLiteralWithinListCall(literal) => {
                 if literal == "list" {
                     format!(
-                        "Unnecessary `{literal}` literal passed to `list()` (remove the outer call to `list()`)"
+                        "Unnecessary `{literal}` literal passed to `list()` (remove the outer \
+                         call to `list()`)"
                     )
                 } else {
                     format!(
-                        "Unnecessary `{literal}` literal passed to `list()` (rewrite as a `list` literal)"
+                        "Unnecessary `{literal}` literal passed to `list()` (rewrite as a `list` \
+                         literal)"
                     )
                 }
             }
@@ -1013,7 +1177,7 @@ impl CheckKind {
                 format!("Unnecessary subscript reversal of iterable within `{func}()`")
             }
             CheckKind::UnnecessaryComprehension(obj_type) => {
-                format!(" Unnecessary `{obj_type}` comprehension (rewrite using `{obj_type}()`)")
+                format!("Unnecessary `{obj_type}` comprehension (rewrite using `{obj_type}()`)")
             }
             CheckKind::UnnecessaryMap(obj_type) => {
                 if obj_type == "generator" {
@@ -1025,6 +1189,30 @@ impl CheckKind {
             // flake8-print
             CheckKind::PrintFound => "`print` found".to_string(),
             CheckKind::PPrintFound => "`pprint` found".to_string(),
+            // flake8-quotes
+            CheckKind::BadQuotesInlineString(quote) => match quote {
+                Quote::Single => "Double quotes found but single quotes preferred".to_string(),
+                Quote::Double => "Single quotes found but double quotes preferred".to_string(),
+            },
+            CheckKind::BadQuotesMultilineString(quote) => match quote {
+                Quote::Single => {
+                    "Double quote multiline found but single quotes preferred".to_string()
+                }
+                Quote::Double => {
+                    "Single quote multiline found but double quotes preferred".to_string()
+                }
+            },
+            CheckKind::BadQuotesDocstring(quote) => match quote {
+                Quote::Single => {
+                    "Double quote docstring found but single quotes preferred".to_string()
+                }
+                Quote::Double => {
+                    "Single quote docstring found but double quotes preferred".to_string()
+                }
+            },
+            CheckKind::AvoidQuoteEscape => {
+                "Change outer quotes to avoid escaping inner quotes".to_string()
+            }
             // pyupgrade
             CheckKind::TypeOfPrimitive(primitive) => {
                 format!("Use `{}` instead of `type(...)`", primitive.builtin())
@@ -1034,7 +1222,7 @@ impl CheckKind {
             }
             CheckKind::UselessMetaclassType => "`__metaclass__ = type` is implied".to_string(),
             CheckKind::DeprecatedUnittestAlias(alias, target) => {
-                format!("`{}` is deprecated, use `{}` instead", alias, target)
+                format!("`{alias}` is deprecated, use `{target}` instead")
             }
             CheckKind::UselessObjectInheritance(name) => {
                 format!("Class `{name}` inherits from object")
@@ -1052,7 +1240,7 @@ impl CheckKind {
             }
             // pydocstyle
             CheckKind::FitsOnOneLine => "One-line docstring should fit on one line".to_string(),
-            CheckKind::NoBlankLineAfterSummary => {
+            CheckKind::BlankLineAfterSummary => {
                 "1 blank line required between summary line and description".to_string()
             }
             CheckKind::NewLineAfterLastParagraph => {
@@ -1063,10 +1251,9 @@ impl CheckKind {
             }
             CheckKind::EndsInPeriod => "First line should end with a period".to_string(),
             CheckKind::NonEmpty => "Docstring is empty".to_string(),
-            CheckKind::EndsInPunctuation => {
-                "First line should end with a period, question mark, or exclamation point"
-                    .to_string()
-            }
+            CheckKind::EndsInPunctuation => "First line should end with a period, question mark, \
+                                             or exclamation point"
+                .to_string(),
             CheckKind::FirstLineCapitalized => {
                 "First word of the first line should be properly capitalized".to_string()
             }
@@ -1078,7 +1265,7 @@ impl CheckKind {
                 "Multi-line docstring summary should start at the second line".to_string()
             }
             CheckKind::NoSignature => {
-                "First line should not be the function's 'signature'".to_string()
+                "First line should not be the function's signature".to_string()
             }
             CheckKind::NoBlankLineBeforeFunction(num_lines) => {
                 format!("No blank lines allowed before function docstring (found {num_lines})")
@@ -1104,10 +1291,10 @@ impl CheckKind {
             CheckKind::PublicNestedClass => "Missing docstring in public nested class".to_string(),
             CheckKind::PublicInit => "Missing docstring in `__init__`".to_string(),
             CheckKind::NoThisPrefix => {
-                "First word of the docstring should not be `This`".to_string()
+                "First word of the docstring should not be 'This'".to_string()
             }
             CheckKind::SkipDocstring => {
-                "Function decorated with @overload shouldn't contain a docstring".to_string()
+                "Function decorated with `@overload` shouldn't contain a docstring".to_string()
             }
             CheckKind::CapitalizeSectionName(name) => {
                 format!("Section name should be properly capitalized (\"{name}\")")
@@ -1128,7 +1315,10 @@ impl CheckKind {
                 format!("Missing dashed underline after section (\"{name}\")")
             }
             CheckKind::SectionUnderlineAfterName(name) => {
-                format!("Section underline should be in the line following the section's name (\"{name}\")")
+                format!(
+                    "Section underline should be in the line following the section's name \
+                     (\"{name}\")"
+                )
             }
             CheckKind::SectionUnderlineMatchesSectionLength(name) => {
                 format!("Section underline should match the length of its name (\"{name}\")")
@@ -1178,6 +1368,36 @@ impl CheckKind {
             CheckKind::InvalidFirstArgumentNameForMethod => {
                 "First argument of a method should be named `self`".to_string()
             }
+            CheckKind::NonLowercaseVariableInFunction(name) => {
+                format!("Variable `{name}` in function should be lowercase")
+            }
+            CheckKind::DunderFunctionName => {
+                "Function name should not start and end with `__`".to_string()
+            }
+            CheckKind::ConstantImportedAsNonConstant(name, asname) => {
+                format!("Constant `{name}` imported as non-constant `{asname}`")
+            }
+            CheckKind::LowercaseImportedAsNonLowercase(name, asname) => {
+                format!("Lowercase `{name}` imported as non-lowercase `{asname}`")
+            }
+            CheckKind::CamelcaseImportedAsLowercase(name, asname) => {
+                format!("Camelcase `{name}` imported as lowercase `{asname}`")
+            }
+            CheckKind::CamelcaseImportedAsConstant(name, asname) => {
+                format!("Camelcase `{name}` imported as constant `{asname}`")
+            }
+            CheckKind::MixedCaseVariableInClassScope(name) => {
+                format!("Variable `{name}` in class scope should not be mixedCase")
+            }
+            CheckKind::MixedCaseVariableInGlobalScope(name) => {
+                format!("Variable `{name}` in global scope should not be mixedCase")
+            }
+            CheckKind::CamelcaseImportedAsAcronym(name, asname) => {
+                format!("Camelcase `{name}` imported as acronym `{asname}`")
+            }
+            CheckKind::ErrorSuffixOnExceptionName(name) => {
+                format!("Exception name `{name}` should be named with an Error suffix")
+            }
             // Meta
             CheckKind::UnusedNOQA(codes) => match codes {
                 None => "Unused `noqa` directive".to_string(),
@@ -1198,28 +1418,68 @@ impl CheckKind {
         }
     }
 
+    /// The summary text for the check. Typically a truncated form of the body
+    /// text.
+    pub fn summary(&self) -> String {
+        match self {
+            CheckKind::UnaryPrefixIncrement => {
+                "Python does not support the unary prefix increment.".to_string()
+            }
+            CheckKind::UnusedLoopControlVariable(name) => {
+                format!("Loop control variable `{name}` not used within the loop body.")
+            }
+            CheckKind::NoAssertRaisesException => {
+                "`assertRaises(Exception):` should be considered evil.".to_string()
+            }
+            _ => self.body(),
+        }
+    }
+
     /// Whether the check kind is (potentially) fixable.
     pub fn fixable(&self) -> bool {
         matches!(
             self,
-            |CheckKind::BlankLineAfterLastSection(_)| CheckKind::BlankLineAfterSection(_)
+            CheckKind::BlankLineAfterLastSection(_)
+                | CheckKind::BlankLineAfterSection(_)
+                | CheckKind::BlankLineAfterSummary
+                | CheckKind::BlankLineBeforeSection(_)
+                | CheckKind::CapitalizeSectionName(_)
+                | CheckKind::DashedUnderlineAfterSection(_)
                 | CheckKind::DeprecatedUnittestAlias(_, _)
                 | CheckKind::DoNotAssertFalse
                 | CheckKind::DuplicateHandlerException(_)
                 | CheckKind::NewLineAfterLastParagraph
+                | CheckKind::NewLineAfterSectionName(_)
                 | CheckKind::NoBlankLineAfterFunction(_)
-                | CheckKind::NoBlankLineAfterSummary
                 | CheckKind::NoBlankLineBeforeClass(_)
                 | CheckKind::NoBlankLineBeforeFunction(_)
+                | CheckKind::NoBlankLinesBetweenHeaderAndContent(_)
+                | CheckKind::NoOverIndentation
                 | CheckKind::NoSurroundingWhitespace
+                | CheckKind::NoUnderIndentation
                 | CheckKind::OneBlankLineAfterClass(_)
                 | CheckKind::OneBlankLineBeforeClass(_)
                 | CheckKind::PPrintFound
                 | CheckKind::PrintFound
+                | CheckKind::SectionNameEndsInColon(_)
+                | CheckKind::SectionNotOverIndented(_)
+                | CheckKind::SectionUnderlineAfterName(_)
+                | CheckKind::SectionUnderlineMatchesSectionLength(_)
+                | CheckKind::SectionUnderlineNotOverIndented(_)
                 | CheckKind::SuperCallWithParameters
                 | CheckKind::TypeOfPrimitive(_)
                 | CheckKind::UnnecessaryAbspath
-                | CheckKind::UnusedImport(_)
+                | CheckKind::UnnecessaryCollectionCall(_)
+                | CheckKind::UnnecessaryGeneratorDict
+                | CheckKind::UnnecessaryGeneratorList
+                | CheckKind::UnnecessaryGeneratorSet
+                | CheckKind::UnnecessaryListCall
+                | CheckKind::UnnecessaryListComprehensionSet
+                | CheckKind::UnnecessaryLiteralSet(_)
+                | CheckKind::UnnecessaryLiteralWithinListCall(_)
+                | CheckKind::UnnecessaryLiteralWithinTupleCall(_)
+                | CheckKind::UnusedImport(_, false)
+                | CheckKind::UnusedLoopControlVariable(_)
                 | CheckKind::UnusedNOQA(_)
                 | CheckKind::UsePEP585Annotation(_)
                 | CheckKind::UsePEP604Annotation
@@ -1229,43 +1489,6 @@ impl CheckKind {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Fix {
-    pub content: String,
-    pub location: Location,
-    pub end_location: Location,
-    pub applied: bool,
-}
-
-impl Fix {
-    pub fn deletion(start: Location, end: Location) -> Self {
-        Self {
-            content: "".to_string(),
-            location: start,
-            end_location: end,
-            applied: false,
-        }
-    }
-
-    pub fn replacement(content: String, start: Location, end: Location) -> Self {
-        Self {
-            content,
-            location: start,
-            end_location: end,
-            applied: false,
-        }
-    }
-
-    pub fn insertion(content: String, at: Location) -> Self {
-        Self {
-            content,
-            location: at,
-            end_location: at,
-            applied: false,
-        }
-    }
-}
-
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Check {
     pub kind: CheckKind,
@@ -1275,11 +1498,11 @@ pub struct Check {
 }
 
 impl Check {
-    pub fn new(kind: CheckKind, rage: Range) -> Self {
+    pub fn new(kind: CheckKind, range: Range) -> Self {
         Self {
             kind,
-            location: rage.location,
-            end_location: rage.end_location,
+            location: range.location,
+            end_location: range.end_location,
             fix: None,
         }
     }

src/cli.rs

@@ -1,3 +1,4 @@
+use std::collections::BTreeMap;
 use std::fmt;
 use std::path::PathBuf;
 
@@ -5,11 +6,11 @@ use clap::{command, Parser};
 use log::warn;
 use regex::Regex;
 
-use crate::checks::CheckCode;
+use crate::checks_gen::CheckCodePrefix;
+use crate::logging::LogLevel;
 use crate::printer::SerializationFormat;
-use crate::pyproject::StrCheckCodePair;
-use crate::settings::PythonVersion;
-use crate::RawSettings;
+use crate::settings::configuration::Configuration;
+use crate::settings::types::{PatternPrefixPair, PythonVersion};
 
 #[derive(Debug, Parser)]
 #[command(author, about = "ruff: An extremely fast Python linter.")]
@@ -21,11 +22,15 @@ pub struct Cli {
     #[arg(long)]
     pub config: Option<PathBuf>,
     /// Enable verbose logging.
-    #[arg(short, long)]
+    #[arg(short, long, group = "verbosity")]
     pub verbose: bool,
-    /// Disable all logging (but still exit with status code "1" upon detecting errors).
-    #[arg(short, long)]
+    /// Only log errors.
+    #[arg(short, long, group = "verbosity")]
     pub quiet: bool,
+    /// Disable all logging (but still exit with status code "1" upon detecting
+    /// errors).
+    #[arg(short, long, group = "verbosity")]
+    pub silent: bool,
     /// Exit with status code "0", even upon detecting errors.
     #[arg(short, long)]
     pub exit_zero: bool,
@@ -40,25 +45,28 @@ pub struct Cli {
     pub no_cache: bool,
     /// List of error codes to enable.
     #[arg(long, value_delimiter = ',')]
-    pub select: Vec<CheckCode>,
-    /// Like --select, but adds additional error codes on top of the selected ones.
+    pub select: Vec<CheckCodePrefix>,
+    /// Like --select, but adds additional error codes on top of the selected
+    /// ones.
     #[arg(long, value_delimiter = ',')]
-    pub extend_select: Vec<CheckCode>,
+    pub extend_select: Vec<CheckCodePrefix>,
     /// List of error codes to ignore.
     #[arg(long, value_delimiter = ',')]
-    pub ignore: Vec<CheckCode>,
-    /// Like --ignore, but adds additional error codes on top of the ignored ones.
+    pub ignore: Vec<CheckCodePrefix>,
+    /// Like --ignore, but adds additional error codes on top of the ignored
+    /// ones.
     #[arg(long, value_delimiter = ',')]
-    pub extend_ignore: Vec<CheckCode>,
+    pub extend_ignore: Vec<CheckCodePrefix>,
     /// List of paths, used to exclude files and/or directories from checks.
     #[arg(long, value_delimiter = ',')]
     pub exclude: Vec<String>,
-    /// Like --exclude, but adds additional files and directories on top of the excluded ones.
+    /// Like --exclude, but adds additional files and directories on top of the
+    /// excluded ones.
     #[arg(long, value_delimiter = ',')]
     pub extend_exclude: Vec<String>,
     /// List of mappings from file pattern to code to exclude
     #[arg(long, value_delimiter = ',')]
-    pub per_file_ignores: Vec<StrCheckCodePair>,
+    pub per_file_ignores: Vec<PatternPrefixPair>,
     /// Output serialization format for error messages.
     #[arg(long, value_enum, default_value_t=SerializationFormat::Text)]
     pub format: SerializationFormat,
@@ -86,6 +94,19 @@ pub struct Cli {
     pub stdin_filename: Option<String>,
 }
 
+/// Map the CLI settings to a `LogLevel`.
+pub fn extract_log_level(cli: &Cli) -> LogLevel {
+    if cli.silent {
+        LogLevel::Silent
+    } else if cli.quiet {
+        LogLevel::Quiet
+    } else if cli.verbose {
+        LogLevel::Verbose
+    } else {
+        LogLevel::Default
+    }
+}
+
 pub enum Warnable {
     Select,
     ExtendSelect,
@@ -103,10 +124,10 @@ impl fmt::Display for Warnable {
 /// Warn the user if they attempt to enable a code that won't be respected.
 pub fn warn_on(
     flag: Warnable,
-    codes: &[CheckCode],
-    cli_ignore: &[CheckCode],
-    cli_extend_ignore: &[CheckCode],
-    pyproject_settings: &RawSettings,
+    codes: &[CheckCodePrefix],
+    cli_ignore: &[CheckCodePrefix],
+    cli_extend_ignore: &[CheckCodePrefix],
+    pyproject_configuration: &Configuration,
     pyproject_path: &Option<PathBuf>,
 ) {
     for code in codes {
@@ -114,7 +135,7 @@ pub fn warn_on(
             if cli_ignore.contains(code) {
                 warn!("{code:?} was passed to {flag}, but ignored via --ignore")
             }
-        } else if pyproject_settings.ignore.contains(code) {
+        } else if pyproject_configuration.ignore.contains(code) {
             if let Some(path) = pyproject_path {
                 warn!(
                     "{code:?} was passed to {flag}, but ignored by the `ignore` field in {}",
@@ -128,15 +149,32 @@ pub fn warn_on(
             if cli_extend_ignore.contains(code) {
                 warn!("{code:?} was passed to {flag}, but ignored via --extend-ignore")
             }
-        } else if pyproject_settings.extend_ignore.contains(code) {
+        } else if pyproject_configuration.extend_ignore.contains(code) {
             if let Some(path) = pyproject_path {
                 warn!(
                     "{code:?} was passed to {flag}, but ignored by the `extend_ignore` field in {}",
                     path.to_string_lossy()
                 )
             } else {
-                warn!("{code:?} was passed to {flag}, but ignored by the default `extend_ignore` field")
+                warn!(
+                    "{code:?} was passed to {flag}, but ignored by the default `extend_ignore` \
+                     field"
+                )
             }
         }
     }
 }
+
+/// Collect a list of `PatternPrefixPair` structs as a `BTreeMap`.
+pub fn collect_per_file_ignores(
+    pairs: Vec<PatternPrefixPair>,
+) -> BTreeMap<String, Vec<CheckCodePrefix>> {
+    let mut per_file_ignores: BTreeMap<String, Vec<CheckCodePrefix>> = BTreeMap::new();
+    for pair in pairs {
+        per_file_ignores
+            .entry(pair.pattern)
+            .or_insert_with(Vec::new)
+            .push(pair.prefix);
+    }
+    per_file_ignores
+}

src/cst/helpers.rs

@@ -0,0 +1,42 @@
+use libcst_native::{Expression, NameOrAttribute};
+
+fn compose_call_path_inner<'a>(expr: &'a Expression, parts: &mut Vec<&'a str>) {
+    match &expr {
+        Expression::Call(expr) => {
+            compose_call_path_inner(&expr.func, parts);
+        }
+        Expression::Attribute(expr) => {
+            compose_call_path_inner(&expr.value, parts);
+            parts.push(expr.attr.value);
+        }
+        Expression::Name(expr) => {
+            parts.push(expr.value);
+        }
+        _ => {}
+    }
+}
+
+pub fn compose_call_path(expr: &Expression) -> Option<String> {
+    let mut segments = vec![];
+    compose_call_path_inner(expr, &mut segments);
+    if segments.is_empty() {
+        None
+    } else {
+        Some(segments.join("."))
+    }
+}
+
+pub fn compose_module_path(module: &NameOrAttribute) -> String {
+    match module {
+        NameOrAttribute::N(name) => name.value.to_string(),
+        NameOrAttribute::A(attr) => {
+            let name = attr.attr.value;
+            let prefix = compose_call_path(&attr.value);
+            if let Some(prefix) = prefix {
+                format!("{prefix}.{name}")
+            } else {
+                name.to_string()
+            }
+        }
+    }
+}

src/cst/matchers.rs

@@ -0,0 +1,19 @@
+use anyhow::Result;
+use libcst_native::Module;
+use rustpython_ast::Located;
+
+use crate::ast::types::Range;
+use crate::source_code_locator::SourceCodeLocator;
+
+pub fn match_tree<'a, T>(
+    locator: &'a SourceCodeLocator,
+    located: &'a Located<T>,
+) -> Result<Module<'a>> {
+    match libcst_native::parse_module(
+        locator.slice_source_code_range(&Range::from_located(located)),
+        None,
+    ) {
+        Ok(module) => Ok(module),
+        Err(_) => return Err(anyhow::anyhow!("Failed to extract CST from source.")),
+    }
+}

src/cst/mod.rs

@@ -0,0 +1,2 @@
+pub mod helpers;
+pub mod matchers;

src/docstrings.rs

@@ -1,8 +0,0 @@
-pub mod definition;
-pub mod extraction;
-mod google;
-mod helpers;
-mod numpy;
-pub mod plugins;
-pub mod sections;
-mod styles;

src/docstrings/google.rs

@@ -2,16 +2,7 @@
 
 use std::collections::BTreeSet;
 
-use crate::ast::types::Range;
 use once_cell::sync::Lazy;
-use regex::Regex;
-
-use crate::check_ast::Checker;
-use crate::checks::{Check, CheckCode, CheckKind};
-use crate::docstrings::definition::Definition;
-use crate::docstrings::sections;
-use crate::docstrings::sections::SectionContext;
-use crate::docstrings::styles::SectionStyle;
 
 pub(crate) static GOOGLE_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
     BTreeSet::from([
@@ -78,73 +69,3 @@ pub(crate) static LOWERCASE_GOOGLE_SECTION_NAMES: Lazy<BTreeSet<&'static str>> =
         "yields",
     ])
 });
-
-// See: `GOOGLE_ARGS_REGEX` in `pydocstyle/checker.py`.
-static GOOGLE_ARGS_REGEX: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^\s*(\w+)\s*(\(.*?\))?\s*:\n?\s*.+").expect("Invalid regex"));
-
-fn check_args_section(checker: &mut Checker, definition: &Definition, context: &SectionContext) {
-    let mut args_sections: Vec<String> = vec![];
-    for line in textwrap::dedent(&context.following_lines.join("\n")).lines() {
-        if line
-            .chars()
-            .next()
-            .map(|char| char.is_whitespace())
-            .unwrap_or(true)
-        {
-            // This is a continuation of documentation for the last
-            // parameter because it does start with whitespace.
-            if let Some(current) = args_sections.last_mut() {
-                current.push_str(line);
-            }
-        } else {
-            // This line is the start of documentation for the next
-            // parameter because it doesn't start with any whitespace.
-            args_sections.push(line.to_string());
-        }
-    }
-
-    sections::check_missing_args(
-        checker,
-        definition,
-        // Collect the list of arguments documented in the docstring.
-        &BTreeSet::from_iter(args_sections.iter().filter_map(|section| {
-            match GOOGLE_ARGS_REGEX.captures(section.as_str()) {
-                Some(caps) => caps.get(1).map(|arg_name| arg_name.as_str()),
-                None => None,
-            }
-        })),
-    )
-}
-
-pub(crate) fn check_google_section(
-    checker: &mut Checker,
-    definition: &Definition,
-    context: &SectionContext,
-) {
-    sections::check_common_section(checker, definition, context, &SectionStyle::Google);
-
-    if checker.settings.enabled.contains(&CheckCode::D416) {
-        let suffix = context
-            .line
-            .trim()
-            .strip_prefix(&context.section_name)
-            .unwrap();
-        if suffix != ":" {
-            let docstring = definition
-                .docstring
-                .expect("Sections are only available for docstrings.");
-            checker.add_check(Check::new(
-                CheckKind::SectionNameEndsInColon(context.section_name.to_string()),
-                Range::from_located(docstring),
-            ))
-        }
-    }
-
-    if checker.settings.enabled.contains(&CheckCode::D417) {
-        let capitalized_section_name = titlecase::titlecase(&context.section_name);
-        if capitalized_section_name == "Args" || capitalized_section_name == "Arguments" {
-            check_args_section(checker, definition, context);
-        }
-    }
-}

src/docstrings/helpers.rs

@@ -25,10 +25,18 @@ pub fn leading_space(line: &str) -> String {
 }
 
 /// Extract the leading indentation from a docstring.
-pub fn indentation<'a>(checker: &'a mut Checker, docstring: &Expr) -> &'a str {
+pub fn indentation<'a>(checker: &'a Checker, docstring: &Expr) -> &'a str {
     let range = Range::from_located(docstring);
     checker.locator.slice_source_code_range(&Range {
-        location: Location::new(range.location.row(), 1),
+        location: Location::new(range.location.row(), 0),
         end_location: Location::new(range.location.row(), range.location.column()),
     })
 }
+
+/// Replace any non-whitespace characters from an indentation string.
+pub fn clean(indentation: &str) -> String {
+    indentation
+        .chars()
+        .map(|char| if char.is_whitespace() { char } else { ' ' })
+        .collect()
+}

src/docstrings/mod.rs

@@ -0,0 +1,7 @@
+pub mod definition;
+pub mod extraction;
+pub mod google;
+pub mod helpers;
+pub mod numpy;
+pub mod sections;
+pub mod styles;

src/docstrings/numpy.rs

@@ -2,16 +2,8 @@
 
 use std::collections::BTreeSet;
 
-use crate::ast::types::Range;
 use once_cell::sync::Lazy;
 
-use crate::check_ast::Checker;
-use crate::checks::{Check, CheckCode, CheckKind};
-use crate::docstrings::definition::Definition;
-use crate::docstrings::sections::SectionContext;
-use crate::docstrings::styles::SectionStyle;
-use crate::docstrings::{helpers, sections};
-
 pub(crate) static LOWERCASE_NUMPY_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
     BTreeSet::from([
         "short summary",
@@ -47,68 +39,3 @@ pub(crate) static NUMPY_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(
         "Methods",
     ])
 });
-
-fn check_parameters_section(
-    checker: &mut Checker,
-    definition: &Definition,
-    context: &SectionContext,
-) {
-    // Collect the list of arguments documented in the docstring.
-    let mut docstring_args: BTreeSet<&str> = Default::default();
-    let section_level_indent = helpers::leading_space(context.line);
-    for i in 1..context.following_lines.len() {
-        let current_line = context.following_lines[i - 1];
-        let current_leading_space = helpers::leading_space(current_line);
-        let next_line = context.following_lines[i];
-        if current_leading_space == section_level_indent
-            && (helpers::leading_space(next_line).len() > current_leading_space.len())
-            && !next_line.trim().is_empty()
-        {
-            let parameters = if let Some(semi_index) = current_line.find(':') {
-                // If the parameter has a type annotation, exclude it.
-                &current_line[..semi_index]
-            } else {
-                // Otherwise, it's just a list of parameters on the current line.
-                current_line.trim()
-            };
-            // Notably, NumPy lets you put multiple parameters of the same type on the same line.
-            for parameter in parameters.split(',') {
-                docstring_args.insert(parameter.trim());
-            }
-        }
-    }
-    // Validate that all arguments were documented.
-    sections::check_missing_args(checker, definition, &docstring_args);
-}
-
-pub(crate) fn check_numpy_section(
-    checker: &mut Checker,
-    definition: &Definition,
-    context: &SectionContext,
-) {
-    sections::check_common_section(checker, definition, context, &SectionStyle::NumPy);
-
-    if checker.settings.enabled.contains(&CheckCode::D406) {
-        let suffix = context
-            .line
-            .trim()
-            .strip_prefix(&context.section_name)
-            .unwrap();
-        if !suffix.is_empty() {
-            let docstring = definition
-                .docstring
-                .expect("Sections are only available for docstrings.");
-            checker.add_check(Check::new(
-                CheckKind::NewLineAfterSectionName(context.section_name.to_string()),
-                Range::from_located(docstring),
-            ))
-        }
-    }
-
-    if checker.settings.enabled.contains(&CheckCode::D417) {
-        let capitalized_section_name = titlecase::titlecase(&context.section_name);
-        if capitalized_section_name == "Parameters" {
-            check_parameters_section(checker, definition, context);
-        }
-    }
-}

src/docstrings/plugins.rs

@@ -1,826 +0,0 @@
-//! Abstractions for tracking and validating docstrings in Python code.
-
-use once_cell::sync::Lazy;
-use regex::Regex;
-use rustpython_ast::{Constant, ExprKind, Location, StmtKind};
-
-use crate::ast::types::Range;
-use crate::autofix::fixer;
-use crate::check_ast::Checker;
-use crate::checks::{Check, CheckCode, CheckKind, Fix};
-use crate::docstrings::definition::{Definition, DefinitionKind};
-use crate::docstrings::google::check_google_section;
-use crate::docstrings::helpers::{
-    indentation, leading_space, SINGLE_QUOTE_PREFIXES, TRIPLE_QUOTE_PREFIXES,
-};
-use crate::docstrings::numpy::check_numpy_section;
-use crate::docstrings::sections::section_contexts;
-use crate::docstrings::styles::SectionStyle;
-use crate::visibility::{is_init, is_magic, is_overload, Visibility};
-
-/// D100, D101, D102, D103, D104, D105, D106, D107
-pub fn not_missing(
-    checker: &mut Checker,
-    definition: &Definition,
-    visibility: &Visibility,
-) -> bool {
-    if matches!(visibility, Visibility::Private) {
-        return true;
-    }
-
-    if definition.docstring.is_some() {
-        return true;
-    }
-
-    match definition.kind {
-        DefinitionKind::Module => {
-            if checker.settings.enabled.contains(&CheckCode::D100) {
-                checker.add_check(Check::new(
-                    CheckKind::PublicModule,
-                    Range {
-                        location: Location::new(1, 1),
-                        end_location: Location::new(1, 1),
-                    },
-                ));
-            }
-            false
-        }
-        DefinitionKind::Package => {
-            if checker.settings.enabled.contains(&CheckCode::D104) {
-                checker.add_check(Check::new(
-                    CheckKind::PublicPackage,
-                    Range {
-                        location: Location::new(1, 1),
-                        end_location: Location::new(1, 1),
-                    },
-                ));
-            }
-            false
-        }
-        DefinitionKind::Class(stmt) => {
-            if checker.settings.enabled.contains(&CheckCode::D101) {
-                checker.add_check(Check::new(
-                    CheckKind::PublicClass,
-                    Range::from_located(stmt),
-                ));
-            }
-            false
-        }
-        DefinitionKind::NestedClass(stmt) => {
-            if checker.settings.enabled.contains(&CheckCode::D106) {
-                checker.add_check(Check::new(
-                    CheckKind::PublicNestedClass,
-                    Range::from_located(stmt),
-                ));
-            }
-            false
-        }
-        DefinitionKind::Function(stmt) | DefinitionKind::NestedFunction(stmt) => {
-            if is_overload(stmt) {
-                true
-            } else {
-                if checker.settings.enabled.contains(&CheckCode::D103) {
-                    checker.add_check(Check::new(
-                        CheckKind::PublicFunction,
-                        Range::from_located(stmt),
-                    ));
-                }
-                false
-            }
-        }
-        DefinitionKind::Method(stmt) => {
-            if is_overload(stmt) {
-                true
-            } else if is_magic(stmt) {
-                if checker.settings.enabled.contains(&CheckCode::D105) {
-                    checker.add_check(Check::new(
-                        CheckKind::MagicMethod,
-                        Range::from_located(stmt),
-                    ));
-                }
-                true
-            } else if is_init(stmt) {
-                if checker.settings.enabled.contains(&CheckCode::D107) {
-                    checker.add_check(Check::new(CheckKind::PublicInit, Range::from_located(stmt)));
-                }
-                true
-            } else {
-                if checker.settings.enabled.contains(&CheckCode::D102) {
-                    checker.add_check(Check::new(
-                        CheckKind::PublicMethod,
-                        Range::from_located(stmt),
-                    ));
-                }
-                true
-            }
-        }
-    }
-}
-
-/// D200
-pub fn one_liner(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = &definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            let mut line_count = 0;
-            let mut non_empty_line_count = 0;
-            for line in string.lines() {
-                line_count += 1;
-                if !line.trim().is_empty() {
-                    non_empty_line_count += 1;
-                }
-                if non_empty_line_count > 1 {
-                    break;
-                }
-            }
-
-            if non_empty_line_count == 1 && line_count > 1 {
-                checker.add_check(Check::new(
-                    CheckKind::FitsOnOneLine,
-                    Range::from_located(docstring),
-                ));
-            }
-        }
-    }
-}
-
-static COMMENT_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^\s*#").unwrap());
-
-static INNER_FUNCTION_OR_CLASS_REGEX: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^\s+(?:(?:class|def|async def)\s|@)").unwrap());
-
-/// D201, D202
-pub fn blank_before_after_function(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let DefinitionKind::Function(parent)
-        | DefinitionKind::NestedFunction(parent)
-        | DefinitionKind::Method(parent) = &definition.kind
-        {
-            if let ExprKind::Constant {
-                value: Constant::Str(_),
-                ..
-            } = &docstring.node
-            {
-                let (before, _, after) = checker.locator.partition_source_code_at(
-                    &Range::from_located(parent),
-                    &Range::from_located(docstring),
-                );
-
-                if checker.settings.enabled.contains(&CheckCode::D201) {
-                    let blank_lines_before = before
-                        .lines()
-                        .rev()
-                        .skip(1)
-                        .take_while(|line| line.trim().is_empty())
-                        .count();
-                    if blank_lines_before != 0 {
-                        let mut check = Check::new(
-                            CheckKind::NoBlankLineBeforeFunction(blank_lines_before),
-                            Range::from_located(docstring),
-                        );
-                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
-                            check.amend(Fix::deletion(
-                                Location::new(docstring.location.row() - blank_lines_before, 1),
-                                Location::new(docstring.location.row(), 1),
-                            ));
-                        }
-                        checker.add_check(check);
-                    }
-                }
-
-                if checker.settings.enabled.contains(&CheckCode::D202) {
-                    let all_blank_after = after
-                        .lines()
-                        .skip(1)
-                        .all(|line| line.trim().is_empty() || COMMENT_REGEX.is_match(line));
-                    if all_blank_after {
-                        return;
-                    }
-
-                    let blank_lines_after = after
-                        .lines()
-                        .skip(1)
-                        .take_while(|line| line.trim().is_empty())
-                        .count();
-                    // Report a D202 violation if the docstring is followed by a blank line and the
-                    // blank line is not itself followed by an inner function or class.
-                    let expected_blank_lines_after =
-                        if INNER_FUNCTION_OR_CLASS_REGEX.is_match(after) {
-                            1
-                        } else {
-                            0
-                        };
-                    if blank_lines_after != expected_blank_lines_after {
-                        let mut check = Check::new(
-                            CheckKind::NoBlankLineAfterFunction(blank_lines_after),
-                            Range::from_located(docstring),
-                        );
-                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
-                            check.amend(Fix::deletion(
-                                Location::new(
-                                    docstring.location.row() + 1 + expected_blank_lines_after,
-                                    1,
-                                ),
-                                Location::new(docstring.location.row() + 1 + blank_lines_after, 1),
-                            ));
-                        }
-                        checker.add_check(check);
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// D203, D204, D211
-pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = &definition.docstring {
-        if let DefinitionKind::Class(parent) | DefinitionKind::NestedClass(parent) =
-            &definition.kind
-        {
-            if let ExprKind::Constant {
-                value: Constant::Str(_),
-                ..
-            } = &docstring.node
-            {
-                let (before, _, after) = checker.locator.partition_source_code_at(
-                    &Range::from_located(parent),
-                    &Range::from_located(docstring),
-                );
-
-                if checker.settings.enabled.contains(&CheckCode::D203)
-                    || checker.settings.enabled.contains(&CheckCode::D211)
-                {
-                    let blank_lines_before = before
-                        .lines()
-                        .rev()
-                        .skip(1)
-                        .take_while(|line| line.trim().is_empty())
-                        .count();
-                    if checker.settings.enabled.contains(&CheckCode::D211) {
-                        if blank_lines_before != 0 {
-                            let mut check = Check::new(
-                                CheckKind::NoBlankLineBeforeClass(blank_lines_before),
-                                Range::from_located(docstring),
-                            );
-                            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply)
-                            {
-                                check.amend(Fix::deletion(
-                                    Location::new(docstring.location.row() - blank_lines_before, 1),
-                                    Location::new(docstring.location.row(), 1),
-                                ));
-                            }
-                            checker.add_check(check);
-                        }
-                    }
-                    if checker.settings.enabled.contains(&CheckCode::D203) {
-                        if blank_lines_before != 1 {
-                            let mut check = Check::new(
-                                CheckKind::OneBlankLineBeforeClass(blank_lines_before),
-                                Range::from_located(docstring),
-                            );
-                            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply)
-                            {
-                                check.amend(Fix::replacement(
-                                    "\n".to_string(),
-                                    Location::new(docstring.location.row() - blank_lines_before, 1),
-                                    Location::new(docstring.location.row(), 1),
-                                ));
-                            }
-                            checker.add_check(check);
-                        }
-                    }
-                }
-
-                if checker.settings.enabled.contains(&CheckCode::D204) {
-                    let all_blank_after = after
-                        .lines()
-                        .skip(1)
-                        .all(|line| line.trim().is_empty() || COMMENT_REGEX.is_match(line));
-                    if all_blank_after {
-                        return;
-                    }
-
-                    let blank_lines_after = after
-                        .lines()
-                        .skip(1)
-                        .take_while(|line| line.trim().is_empty())
-                        .count();
-                    if blank_lines_after != 1 {
-                        let mut check = Check::new(
-                            CheckKind::OneBlankLineAfterClass(blank_lines_after),
-                            Range::from_located(docstring),
-                        );
-                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
-                            check.amend(Fix::replacement(
-                                "\n".to_string(),
-                                Location::new(docstring.end_location.row() + 1, 1),
-                                Location::new(
-                                    docstring.end_location.row() + 1 + blank_lines_after,
-                                    1,
-                                ),
-                            ));
-                        }
-                        checker.add_check(check);
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// D205
-pub fn blank_after_summary(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            let mut lines_count = 1;
-            let mut blanks_count = 0;
-            for line in string.trim().lines().skip(1) {
-                lines_count += 1;
-                if line.trim().is_empty() {
-                    blanks_count += 1;
-                } else {
-                    break;
-                }
-            }
-            if lines_count > 1 && blanks_count != 1 {
-                let mut check = Check::new(
-                    CheckKind::NoBlankLineAfterSummary,
-                    Range::from_located(docstring),
-                );
-                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
-                    check.amend(Fix::replacement(
-                        "\n".to_string(),
-                        Location::new(docstring.location.row() + 1, 1),
-                        Location::new(docstring.location.row() + 1 + blanks_count, 1),
-                    ));
-                }
-                checker.add_check(check);
-            }
-        }
-    }
-}
-
-/// D206, D207, D208
-pub fn indent(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            let lines: Vec<&str> = string.lines().collect();
-            if lines.len() <= 1 {
-                return;
-            }
-
-            let mut has_seen_tab = false;
-            let mut has_seen_over_indent = false;
-            let mut has_seen_under_indent = false;
-
-            let docstring_indent = indentation(checker, docstring).to_string();
-            if !has_seen_tab {
-                if docstring_indent.contains('\t') {
-                    if checker.settings.enabled.contains(&CheckCode::D206) {
-                        checker.add_check(Check::new(
-                            CheckKind::IndentWithSpaces,
-                            Range::from_located(docstring),
-                        ));
-                    }
-                    has_seen_tab = true;
-                }
-            }
-
-            for i in 0..lines.len() {
-                // First lines and continuations doesn't need any indentation.
-                if i == 0 || lines[i - 1].ends_with('\\') {
-                    continue;
-                }
-
-                // Omit empty lines, except for the last line, which is non-empty by way of
-                // containing the closing quotation marks.
-                if i < lines.len() - 1 && lines[i].trim().is_empty() {
-                    continue;
-                }
-
-                let line_indent = leading_space(lines[i]);
-                if !has_seen_tab {
-                    if line_indent.contains('\t') {
-                        if checker.settings.enabled.contains(&CheckCode::D206) {
-                            checker.add_check(Check::new(
-                                CheckKind::IndentWithSpaces,
-                                Range::from_located(docstring),
-                            ));
-                        }
-                        has_seen_tab = true;
-                    }
-                }
-
-                if !has_seen_over_indent {
-                    if line_indent.len() > docstring_indent.len() {
-                        if checker.settings.enabled.contains(&CheckCode::D208) {
-                            checker.add_check(Check::new(
-                                CheckKind::NoOverIndentation,
-                                Range::from_located(docstring),
-                            ));
-                        }
-                        has_seen_over_indent = true;
-                    }
-                }
-
-                if !has_seen_under_indent {
-                    if line_indent.len() < docstring_indent.len() {
-                        if checker.settings.enabled.contains(&CheckCode::D207) {
-                            checker.add_check(Check::new(
-                                CheckKind::NoUnderIndentation,
-                                Range::from_located(docstring),
-                            ));
-                        }
-                        has_seen_under_indent = true;
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// D209
-pub fn newline_after_last_paragraph(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            let mut line_count = 0;
-            for line in string.lines() {
-                if !line.trim().is_empty() {
-                    line_count += 1;
-                }
-                if line_count > 1 {
-                    let content = checker
-                        .locator
-                        .slice_source_code_range(&Range::from_located(docstring));
-                    if let Some(last_line) = content.lines().last().map(|line| line.trim()) {
-                        if last_line != "\"\"\"" && last_line != "'''" {
-                            let mut check = Check::new(
-                                CheckKind::NewLineAfterLastParagraph,
-                                Range::from_located(docstring),
-                            );
-                            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply)
-                            {
-                                // Insert a newline just before the end-quote(s).
-                                let mut content = "\n".to_string();
-                                content.push_str(indentation(checker, docstring));
-                                check.amend(Fix::insertion(
-                                    content,
-                                    Location::new(
-                                        docstring.end_location.row(),
-                                        docstring.end_location.column() - "\"\"\"".len(),
-                                    ),
-                                ));
-                            }
-                            checker.add_check(check);
-                        }
-                    }
-                    return;
-                }
-            }
-        }
-    }
-}
-
-/// D210
-pub fn no_surrounding_whitespace(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            let mut lines = string.lines();
-            if let Some(line) = lines.next() {
-                let trimmed = line.trim();
-                if trimmed.is_empty() {
-                    return;
-                }
-                if line != trimmed {
-                    let mut check = Check::new(
-                        CheckKind::NoSurroundingWhitespace,
-                        Range::from_located(docstring),
-                    );
-                    if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
-                        if let Some(first_line) = checker
-                            .locator
-                            .slice_source_code_range(&Range::from_located(docstring))
-                            .lines()
-                            .next()
-                            .map(|line| line.to_lowercase())
-                        {
-                            for pattern in TRIPLE_QUOTE_PREFIXES.iter().chain(SINGLE_QUOTE_PREFIXES)
-                            {
-                                if first_line.starts_with(pattern) {
-                                    check.amend(Fix::replacement(
-                                        trimmed.to_string(),
-                                        Location::new(
-                                            docstring.location.row(),
-                                            docstring.location.column() + pattern.len(),
-                                        ),
-                                        Location::new(
-                                            docstring.location.row(),
-                                            docstring.location.column()
-                                                + pattern.len()
-                                                + line.chars().count(),
-                                        ),
-                                    ));
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                    checker.add_check(check);
-                }
-            }
-        }
-    }
-}
-
-/// D212, D213
-pub fn multi_line_summary_start(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            if string.lines().nth(1).is_some() {
-                if let Some(first_line) = checker
-                    .locator
-                    .slice_source_code_range(&Range::from_located(docstring))
-                    .lines()
-                    .next()
-                    .map(|line| line.to_lowercase())
-                {
-                    if TRIPLE_QUOTE_PREFIXES.contains(&first_line.as_str()) {
-                        if checker.settings.enabled.contains(&CheckCode::D212) {
-                            checker.add_check(Check::new(
-                                CheckKind::MultiLineSummaryFirstLine,
-                                Range::from_located(docstring),
-                            ));
-                        }
-                    } else {
-                        if checker.settings.enabled.contains(&CheckCode::D213) {
-                            checker.add_check(Check::new(
-                                CheckKind::MultiLineSummarySecondLine,
-                                Range::from_located(docstring),
-                            ));
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// D300
-pub fn triple_quotes(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            if let Some(first_line) = checker
-                .locator
-                .slice_source_code_range(&Range::from_located(docstring))
-                .lines()
-                .next()
-                .map(|line| line.to_lowercase())
-            {
-                let starts_with_triple = if string.contains("\"\"\"") {
-                    first_line.starts_with("'''")
-                        || first_line.starts_with("u'''")
-                        || first_line.starts_with("r'''")
-                        || first_line.starts_with("ur'''")
-                } else {
-                    first_line.starts_with("\"\"\"")
-                        || first_line.starts_with("u\"\"\"")
-                        || first_line.starts_with("r\"\"\"")
-                        || first_line.starts_with("ur\"\"\"")
-                };
-                if !starts_with_triple {
-                    checker.add_check(Check::new(
-                        CheckKind::UsesTripleQuotes,
-                        Range::from_located(docstring),
-                    ));
-                }
-            }
-        }
-    }
-}
-
-/// D400
-pub fn ends_with_period(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            if let Some(string) = string.lines().next() {
-                if !string.ends_with('.') {
-                    checker.add_check(Check::new(
-                        CheckKind::EndsInPeriod,
-                        Range::from_located(docstring),
-                    ));
-                }
-            }
-        }
-    }
-}
-
-/// D402
-pub fn no_signature(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let DefinitionKind::Function(parent)
-        | DefinitionKind::NestedFunction(parent)
-        | DefinitionKind::Method(parent) = definition.kind
-        {
-            if let StmtKind::FunctionDef { name, .. } = &parent.node {
-                if let ExprKind::Constant {
-                    value: Constant::Str(string),
-                    ..
-                } = &docstring.node
-                {
-                    if let Some(first_line) = string.lines().next() {
-                        if first_line.contains(&format!("{name}(")) {
-                            checker.add_check(Check::new(
-                                CheckKind::NoSignature,
-                                Range::from_located(docstring),
-                            ));
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// D403
-pub fn capitalized(checker: &mut Checker, definition: &Definition) {
-    if !matches!(definition.kind, DefinitionKind::Function(_)) {
-        return;
-    }
-
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            if let Some(first_word) = string.split(' ').next() {
-                if first_word == first_word.to_uppercase() {
-                    return;
-                }
-                for char in first_word.chars() {
-                    if !char.is_ascii_alphabetic() && char != '\'' {
-                        return;
-                    }
-                }
-                if let Some(first_char) = first_word.chars().next() {
-                    if !first_char.is_uppercase() {
-                        checker.add_check(Check::new(
-                            CheckKind::FirstLineCapitalized,
-                            Range::from_located(docstring),
-                        ));
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// D404
-pub fn starts_with_this(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            let trimmed = string.trim();
-            if trimmed.is_empty() {
-                return;
-            }
-
-            if let Some(first_word) = string.split(' ').next() {
-                if first_word
-                    .replace(|c: char| !c.is_alphanumeric(), "")
-                    .to_lowercase()
-                    == "this"
-                {
-                    checker.add_check(Check::new(
-                        CheckKind::NoThisPrefix,
-                        Range::from_located(docstring),
-                    ));
-                }
-            }
-        }
-    }
-}
-
-/// D415
-pub fn ends_with_punctuation(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            if let Some(string) = string.lines().next() {
-                if !(string.ends_with('.') || string.ends_with('!') || string.ends_with('?')) {
-                    checker.add_check(Check::new(
-                        CheckKind::EndsInPunctuation,
-                        Range::from_located(docstring),
-                    ));
-                }
-            }
-        }
-    }
-}
-
-/// D418
-pub fn if_needed(checker: &mut Checker, definition: &Definition) {
-    if definition.docstring.is_some() {
-        if let DefinitionKind::Function(stmt)
-        | DefinitionKind::NestedFunction(stmt)
-        | DefinitionKind::Method(stmt) = definition.kind
-        {
-            if is_overload(stmt) {
-                checker.add_check(Check::new(
-                    CheckKind::SkipDocstring,
-                    Range::from_located(stmt),
-                ));
-            }
-        }
-    }
-}
-
-/// D419
-pub fn not_empty(checker: &mut Checker, definition: &Definition) -> bool {
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            if string.trim().is_empty() {
-                if checker.settings.enabled.contains(&CheckCode::D419) {
-                    checker.add_check(Check::new(
-                        CheckKind::NonEmpty,
-                        Range::from_located(docstring),
-                    ));
-                }
-                return false;
-            }
-        }
-    }
-    true
-}
-
-/// D212, D214, D215, D405, D406, D407, D408, D409, D410, D411, D412, D413, D414, D416, D417
-pub fn sections(checker: &mut Checker, definition: &Definition) {
-    if let Some(docstring) = definition.docstring {
-        if let ExprKind::Constant {
-            value: Constant::Str(string),
-            ..
-        } = &docstring.node
-        {
-            let lines: Vec<&str> = string.lines().collect();
-            if lines.len() < 2 {
-                return;
-            }
-
-            // First, interpret as NumPy-style sections.
-            let mut found_numpy_section = false;
-            for context in &section_contexts(&lines, &SectionStyle::NumPy) {
-                found_numpy_section = true;
-                check_numpy_section(checker, definition, context);
-            }
-
-            // If no such sections were identified, interpret as Google-style sections.
-            if !found_numpy_section {
-                for context in &section_contexts(&lines, &SectionStyle::Google) {
-                    check_google_section(checker, definition, context);
-                }
-            }
-        }
-    }
-}