Bump version to 0.0.102

Increase flake8-bugbear count to 15/32
Ignore ellipsis in B018 (#598 )
2022-11-05 14:13:02 -04:00 · 2022-11-05 14:12:35 -04:00 · 2022-11-05 14:11:44 -04:00 · 2022-11-05 14:11:26 -04:00 · 2022-11-05 14:08:02 -04:00 · 2022-11-05 14:06:00 -04:00
292 changed files with 12934 additions and 3174 deletions
--- a/.github/workflows/ci.yaml
+++ b/.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"
--- a/.github/workflows/flake8-to-ruff.yaml
+++ b/.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 *
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.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 *
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,6 +1,6 @@
 repos:
  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.90
+    rev: v0.0.102
    hooks:
      - id: ruff

--- a/Cargo.lock
+++ b/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"
@@ -511,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"
@@ -548,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"
@@ -816,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.102-dev.0"
+dependencies = [
+ "anyhow",
+ "clap 4.0.15",
+ "configparser",
+ "once_cell",
+ "regex",
+ "ruff",
+ "serde",
+ "serde_json",
+ "toml",
+]
+
 [[package]]
 name = "flate2"
 version = "1.0.24"
@@ -1041,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"
@@ -1571,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"
@@ -1779,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"
@@ -2052,20 +2209,31 @@ dependencies = [
 "winapi 0.3.9",
 ]

+[[package]]
+name = "ropey"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd22239fafefc42138ca5da064f3c17726a80d2379d817a3521240e78dd0064"
+dependencies = [
+ "smallvec",
+ "str_indices",
+]
+
 [[package]]
 name = "ruff"
-version = "0.0.90"
+version = "0.0.102"
 dependencies = [
 "anyhow",
 "assert_cmd",
 "bincode",
 "cacache",
 "chrono",
- "clap",
+ "clap 4.0.15",
 "clearscreen",
 "codegen",
 "colored",
 "common-path",
+ "criterion",
 "dirs 4.0.0",
 "fern",
 "filetime",
@@ -2081,6 +2249,7 @@ dependencies = [
 "path-absolutize",
 "rayon",
 "regex",
+ "ropey",
 "rustpython-ast",
 "rustpython-common",
 "rustpython-parser",
@@ -2089,7 +2258,7 @@ dependencies = [
 "strum",
 "strum_macros",
 "test-case",
- "textwrap",
+ "textwrap 0.15.1",
 "titlecase",
 "toml",
 "update-informer",
@@ -2111,7 +2280,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.1.0"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=1b253a12705f84972cd76e8dc1cdaaccb233e5a5#1b253a12705f84972cd76e8dc1cdaaccb233e5a5"
+source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
 dependencies = [
 "num-bigint",
 "rustpython-common",
@@ -2121,7 +2290,7 @@ dependencies = [
 [[package]]
 name = "rustpython-common"
 version = "0.0.0"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=1b253a12705f84972cd76e8dc1cdaaccb233e5a5#1b253a12705f84972cd76e8dc1cdaaccb233e5a5"
+source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
 dependencies = [
 "ascii",
 "cfg-if 1.0.0",
@@ -2144,7 +2313,7 @@ dependencies = [
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.1.2"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=1b253a12705f84972cd76e8dc1cdaaccb233e5a5#1b253a12705f84972cd76e8dc1cdaaccb233e5a5"
+source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
 dependencies = [
 "bincode",
 "bitflags",
@@ -2161,7 +2330,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.1.2"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=1b253a12705f84972cd76e8dc1cdaaccb233e5a5#1b253a12705f84972cd76e8dc1cdaaccb233e5a5"
+source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
 dependencies = [
 "ahash",
 "anyhow",
@@ -2401,6 +2570,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"

+[[package]]
+name = "str_indices"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d9199fa80c817e074620be84374a520062ebac833f358d74b37060ce4a0f2c0"
+
 [[package]]
 name = "string_cache"
 version = "0.8.4"
@@ -2549,6 +2724,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"
@@ -2589,6 +2770,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"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,11 @@
+[workspace]
+members = [
+  "flake8_to_ruff",
+]
+
 [package]
 name = "ruff"
-version = "0.0.90"
+version = "0.0.102"
 edition = "2021"

 [lib]
@@ -26,9 +31,10 @@ 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 = "1b253a12705f84972cd76e8dc1cdaaccb233e5a5" }
-rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "1b253a12705f84972cd76e8dc1cdaaccb233e5a5" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "1b253a12705f84972cd76e8dc1cdaaccb233e5a5" }
+ropey = { version = "1.5.0" }
+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"] }
@@ -51,6 +57,7 @@ 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" }

@@ -69,3 +76,7 @@ opt-level = 3

 [profile.dev.package.similar]
 opt-level = 3
+
+[[bench]]
+name = "source_code_locator"
+harness = false
--- a/README.md
+++ b/README.md
@@ -49,7 +49,8 @@ Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-mu
   9. [flake8-builtins](#flake8-builtins)
   10. [flake8-print](#flake8-print)
   11. [flake8-quotes](#flake8-quotes)
-   12. [Meta rules](#meta-rules)
+   12. [Ruff-specific rules](#ruff-specific-rules)
+   13. [Meta rules](#meta-rules)
 5. [Editor Integrations](#editor-integrations)
 6. [FAQ](#faq)
 7. [Development](#development)
@@ -89,7 +90,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.90
+    rev: v0.0.102
    hooks:
      - id: ruff
 ```
@@ -99,26 +100,68 @@ _Note: prior to `v0.0.86`, `ruff-pre-commit` used `lint` (rather than `ruff`) as

 ## 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
+
+# Enable Flake's "E" and "F" codes by default.
 select = ["E", "F"]
-ignore = ["E501"]
-per-file-ignores = [
-    "__init__.py:F401",
-    "path/to/file.py:F401"
+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"
+```
+
+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]
-line-length = 88
+# Add "Q" to the list of enabled codes.
+select = ["E", "F", "Q"]

 [tool.ruff.flake8-quotes]
 docstring-quotes = "double"
@@ -146,6 +189,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
@@ -272,7 +317,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: `...` |  |
@@ -281,7 +326,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | F823 | UndefinedLocal | Local variable `...` referenced before assignment |  |
 | F831 | DuplicateArgumentName | Duplicate argument name in function definition |  |
 | F841 | UnusedVariable | Local variable `...` is assigned to but never used |  |
-| F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` |  |
+| F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` | 🛠 |

 ### pycodestyle (error)

@@ -341,7 +386,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | D400 | EndsInPeriod | First line should end with a period |  |
 | 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` |  |
+| 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") | 🛠 |
@@ -355,7 +400,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | D415 | EndsInPunctuation | First line should end with a period, question mark, or exclamation point |  |
 | 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
@@ -395,21 +440,21 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com

 | 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) |  |
-| 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()`) |  |
+| 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()`) | 🛠 |
 | 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
@@ -417,11 +462,17 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | B002 | UnaryPrefixIncrement | Python does not support the unary prefix increment. |  |
+| B003 | AssignmentToOsEnviron | Assigning to `os.environ` doesn't clear the environment. |  |
+| B006 | MutableArgumentDefault | Do not use mutable data structures for argument defaults. |  |
 | B007 | UnusedLoopControlVariable | Loop control variable `i` not used within the loop body. | 🛠 |
+| B008 | FunctionCallArgumentDefault | Do not perform function calls in argument defaults. |  |
 | 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` | 🛠 |
+| B015 | UselessComparison | Pointless comparison. This comparison does nothing but waste CPU instructions. Either prepend `assert` or remove it. |  |
+| B016 | CannotRaiseLiteral | Cannot raise a literal. Did you intend to return it or raise an Exception? |  |
 | B017 | NoAssertRaisesException | `assertRaises(Exception):` should be considered evil. |  |
+| B018 | UselessExpression | Found useless expression. Either assign it to a variable or remove it. |  |
 | B025 | DuplicateTryBlockException | try-except block with duplicate exception `Exception` |  |

 ### flake8-builtins
@@ -448,6 +499,13 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | Q002 | BadQuotesDocstring | Single quote docstring found but double quotes preferred |  |
 | Q003 | AvoidQuoteEscape | Change outer quotes to avoid escaping inner quotes |  |

+### Ruff-specific rules
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| RUF001 | AmbiguousUnicodeCharacterString | String contains ambiguous unicode character '𝐁' (did you mean 'B'?) | 🛠 |
+| RUF002 | AmbiguousUnicodeCharacterDocstring | Docstring contains ambiguous unicode character '𝐁' (did you mean 'B'?) | 🛠 |
+
 ### Meta rules

 | Code | Name | Message | Fix |
@@ -522,8 +580,8 @@ including:
 - [`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/) (10/32)
- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (15/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:
@@ -544,10 +602,10 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 - [`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/) (9/32)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (15/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.

@@ -639,16 +697,21 @@ extend-ignore = [

 ## 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.65.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
--- a/benches/source_code_locator.rs
+++ b/benches/source_code_locator.rs
@@ -0,0 +1,18 @@
+use std::path::Path;
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use ropey::Rope;
+use ruff::fs;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let contents = fs::read_file(Path::new("resources/test/fixtures/D.py")).unwrap();
+    c.bench_function("rope", |b| {
+        b.iter(|| {
+            let rope = Rope::from_str(black_box(&contents));
+            rope.line_to_char(black_box(4));
+        })
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
--- a/examples/generate_check_code_prefix.rs
+++ b/examples/generate_check_code_prefix.rs
@@ -4,16 +4,19 @@ use std::collections::{BTreeMap, BTreeSet};

 use codegen::{Scope, Type, Variant};
 use itertools::Itertools;
-use strum::IntoEnumIterator;
-
 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 as_ref: String = check_code.as_ref().to_string();
+        let prefix_len = as_ref
+            .chars()
+            .take_while(|char| char.is_alphabetic())
+            .count();
+        for i in prefix_len..=as_ref.len() {
            let prefix = as_ref[..i].to_string();
            let entry = prefix_to_codes
                .entry(prefix)
@@ -32,6 +35,8 @@ fn main() {
        .derive("Debug")
        .derive("PartialEq")
        .derive("Eq")
+        .derive("PartialOrd")
+        .derive("Ord")
        .derive("Clone")
        .derive("Serialize")
        .derive("Deserialize");
@@ -80,11 +85,12 @@ fn main() {
        .vis("pub")
        .line("match self {");
    for (prefix, _) in &prefix_to_codes {
-        let specificity = match prefix.len() {
-            4 => "Explicit",
-            3 => "Tens",
-            2 => "Hundreds",
-            1 => "Category",
+        let num_numeric = prefix.chars().filter(|char| char.is_numeric()).count();
+        let specificity = match num_numeric {
+            3 => "Explicit",
+            2 => "Tens",
+            1 => "Hundreds",
+            0 => "Category",
            _ => panic!("Invalid prefix: {}", prefix),
        };
        gen = gen.line(format!(
@@ -96,7 +102,7 @@ fn main() {

    println!("//! File automatically generated by examples/generate_check_code_prefix.rs.");
    println!();
-    println!("use serde::{{Deserialize, Serialize}};");
+    println!("use serde::{{Serialize, Deserialize}};");
    println!("use strum_macros::EnumString;");
    println!();
    println!("use crate::checks::CheckCode;");
--- a/examples/generate_rules_table.rs
+++ b/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() {
--- a/examples/generate_source_code.rs
+++ b/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 {
--- a/examples/print_ast.rs
+++ b/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 {
--- a/examples/print_tokens.rs
+++ b/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 {
--- a/flake8_to_ruff/Cargo.lock
+++ b/flake8_to_ruff/Cargo.lock
--- a/flake8_to_ruff/Cargo.toml
+++ b/flake8_to_ruff/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "flake8-to-ruff"
+version = "0.0.102-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]
--- a/flake8_to_ruff/README.md
+++ b/flake8_to_ruff/README.md
@@ -0,0 +1,98 @@
+# 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 `flake8-to-ruff`:
+
+```shell
+flake8-to-ruff path/to/setup.cfg
+flake8-to-ruff path/to/tox.ini
+flake8-to-ruff path/to/.flake8
+```
+
+`flake8-to-ruff` will print the relevant `pyproject.toml` sections to standard output, like so:
+
+```toml
+[tool.ruff]
+exclude = [
+    '.svn',
+    'CVS',
+    '.bzr',
+    '.hg',
+    '.git',
+    '__pycache__',
+    '.tox',
+    '.idea',
+    '.mypy_cache',
+    '.venv',
+    'node_modules',
+    '_state_machine.py',
+    'test_fstring.py',
+    'bad_coding2.py',
+    'badsyntax_*.py',
+]
+select = [
+    'A',
+    'E',
+    'F',
+    'Q',
+]
+ignore = []
+
+[tool.ruff.flake8-quotes]
+inline-quotes = 'single'
+
+[tool.ruff.pep8-naming]
+ignore-names = [
+    'foo',
+    'bar',
+]
+```
+
+### Plugins
+
+`flake8-to-ruff` will attempt to infer any activated plugins based on the settings provided in your
+configuration file.
+
+For example, if your `.flake8` file includes a `docstring-convention` property, `flake8-to-ruff`
+will enable the appropriate [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
+checks.
+
+Alternatively, you can manually specify plugins on the command-line:
+
+```shell
+flake8-to-ruff path/to/.flake8 --plugin flake8-builtins --plugin flake8-quotes
+```
+
+## 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.)
+
+## 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).
--- a/flake8_to_ruff/examples/poetry.ini
+++ b/flake8_to_ruff/examples/poetry.ini
@@ -0,0 +1,36 @@
+[flake8]
+min_python_version = 3.7.0
+max-line-length = 88
+ban-relative-imports = true
+# flake8-use-fstring: https://github.com/MichaelKim0407/flake8-use-fstring#--percent-greedy-and---format-greedy
+format-greedy = 1
+inline-quotes = double
+enable-extensions = TC, TC1
+type-checking-strict = true
+eradicate-whitelist-extend = ^-.*;
+extend-ignore =
+    # E203: Whitespace before ':' (pycqa/pycodestyle#373)
+    E203,
+    # SIM106: Handle error-cases first
+    SIM106,
+    # ANN101: Missing type annotation for self in method
+    ANN101,
+    # ANN102: Missing type annotation for cls in classmethod
+    ANN102,
+    # PIE781: assign-and-return
+    PIE781,
+    # PIE798 no-unnecessary-class: Consider using a module for namespacing instead
+    PIE798,
+per-file-ignores =
+    # TC002: Move third-party import '...' into a type-checking block
+    __init__.py:TC002,
+    # ANN201: Missing return type annotation for public function
+    tests/test_*:ANN201
+    tests/**/test_*:ANN201
+extend-exclude =
+    # Frozen and not subject to change in this repo:
+    get-poetry.py,
+    install-poetry.py,
+    # External to the project's coding standards:
+    tests/fixtures/*,
+    tests/**/fixtures/*,
--- a/flake8_to_ruff/examples/python-discord.ini
+++ b/flake8_to_ruff/examples/python-discord.ini
@@ -0,0 +1,19 @@
+[flake8]
+max-line-length=120
+docstring-convention=all
+import-order-style=pycharm
+application_import_names=bot,tests
+exclude=.cache,.venv,.git,constants.py
+extend-ignore=
+    B311,W503,E226,S311,T000,E731
+    # Missing Docstrings
+    D100,D104,D105,D107,
+    # Docstring Whitespace
+    D203,D212,D214,D215,
+    # Docstring Quotes
+    D301,D302,
+    # Docstring Content
+    D400,D401,D402,D404,D405,D406,D407,D408,D409,D410,D411,D412,D413,D414,D416,D417
+    # Type Annotations
+    ANN002,ANN003,ANN101,ANN102,ANN204,ANN206,ANN401
+per-file-ignores=tests/*:D,ANN
--- a/flake8_to_ruff/examples/requests.ini
+++ b/flake8_to_ruff/examples/requests.ini
@@ -0,0 +1,6 @@
+[flake8]
+ignore = E203, E501, W503
+per-file-ignores =
+    requests/__init__.py:E402, F401
+    requests/compat.py:E402, F401
+    tests/compat.py:F401
--- a/flake8_to_ruff/pyproject.toml
+++ b/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
--- a/flake8_to_ruff/src/converter.rs
+++ b/flake8_to_ruff/src/converter.rs
@@ -0,0 +1,399 @@
+use std::collections::{BTreeSet, 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::plugin::Plugin;
+use crate::{parser, plugin};
+
+pub fn convert(
+    flake8: &HashMap<String, Option<String>>,
+    plugins: Option<Vec<Plugin>>,
+) -> Result<Pyproject> {
+    // Check if the user has specified a `select`. If not, we'll add our own
+    // default `select`, and populate it based on user plugins.
+    let mut select = flake8
+        .get("select")
+        .and_then(|value| {
+            value
+                .as_ref()
+                .map(|value| BTreeSet::from_iter(parser::parse_prefix_codes(value)))
+        })
+        .unwrap_or_else(|| {
+            plugin::resolve_select(
+                flake8,
+                &plugins.unwrap_or_else(|| plugin::infer_plugins(flake8)),
+            )
+        });
+    let mut ignore = flake8
+        .get("ignore")
+        .and_then(|value| {
+            value
+                .as_ref()
+                .map(|value| BTreeSet::from_iter(parser::parse_prefix_codes(value)))
+        })
+        .unwrap_or_default();
+
+    // 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" => {
+                    // No-op (handled above).
+                }
+                "ignore" => {
+                    // No-op (handled above).
+                }
+                "extend-select" | "extend_select" => {
+                    // Unlike Flake8, use a single explicit `select`.
+                    select.extend(parser::parse_prefix_codes(value.as_ref()));
+                }
+                "extend-ignore" | "extend_ignore" => {
+                    // Unlike Flake8, use a single explicit `ignore`.
+                    ignore.extend(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()));
+                }
+                // flake8-docstrings
+                "docstring-convention" => {
+                    // No-op (handled above).
+                }
+                // Unknown
+                _ => eprintln!("Skipping unsupported property: {key}"),
+            }
+        }
+    }
+
+    // Deduplicate and sort.
+    options.select = Some(Vec::from_iter(select));
+    options.ignore = Some(Vec::from_iter(ignore));
+    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::checks_gen::CheckCodePrefix;
+    use ruff::flake8_quotes;
+    use ruff::settings::options::Options;
+    use ruff::settings::pyproject::Pyproject;
+
+    use crate::converter::convert;
+    use crate::plugin::Plugin;
+
+    #[test]
+    fn it_converts_empty() -> Result<()> {
+        let actual = convert(&HashMap::from([]), None)?;
+        let expected = Pyproject::new(Options {
+            line_length: None,
+            exclude: None,
+            extend_exclude: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
+            extend_select: None,
+            ignore: Some(vec![]),
+            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([("max-line-length".to_string(), Some("100".to_string()))]),
+            Some(vec![]),
+        )?;
+        let expected = Pyproject::new(Options {
+            line_length: Some(100),
+            exclude: None,
+            extend_exclude: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
+            extend_select: None,
+            ignore: Some(vec![]),
+            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([("max_line_length".to_string(), Some("100".to_string()))]),
+            Some(vec![]),
+        )?;
+        let expected = Pyproject::new(Options {
+            line_length: Some(100),
+            exclude: None,
+            extend_exclude: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
+            extend_select: None,
+            ignore: Some(vec![]),
+            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([("max_line_length".to_string(), Some("abc".to_string()))]),
+            Some(vec![]),
+        )?;
+        let expected = Pyproject::new(Options {
+            line_length: None,
+            exclude: None,
+            extend_exclude: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
+            extend_select: None,
+            ignore: Some(vec![]),
+            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_plugin_options() -> Result<()> {
+        let actual = convert(
+            &HashMap::from([("inline-quotes".to_string(), Some("single".to_string()))]),
+            Some(vec![]),
+        )?;
+        let expected = Pyproject::new(Options {
+            line_length: None,
+            exclude: None,
+            extend_exclude: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
+            extend_select: None,
+            ignore: Some(vec![]),
+            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(())
+    }
+
+    #[test]
+    fn it_converts_docstring_conventions() -> Result<()> {
+        let actual = convert(
+            &HashMap::from([(
+                "docstring-convention".to_string(),
+                Some("numpy".to_string()),
+            )]),
+            Some(vec![Plugin::Flake8Docstrings]),
+        )?;
+        let expected = Pyproject::new(Options {
+            line_length: None,
+            exclude: None,
+            extend_exclude: None,
+            select: Some(vec![
+                CheckCodePrefix::D100,
+                CheckCodePrefix::D101,
+                CheckCodePrefix::D102,
+                CheckCodePrefix::D103,
+                CheckCodePrefix::D104,
+                CheckCodePrefix::D105,
+                CheckCodePrefix::D106,
+                CheckCodePrefix::D200,
+                CheckCodePrefix::D201,
+                CheckCodePrefix::D202,
+                CheckCodePrefix::D204,
+                CheckCodePrefix::D205,
+                CheckCodePrefix::D206,
+                CheckCodePrefix::D207,
+                CheckCodePrefix::D208,
+                CheckCodePrefix::D209,
+                CheckCodePrefix::D210,
+                CheckCodePrefix::D211,
+                CheckCodePrefix::D214,
+                CheckCodePrefix::D215,
+                CheckCodePrefix::D300,
+                CheckCodePrefix::D400,
+                CheckCodePrefix::D403,
+                CheckCodePrefix::D404,
+                CheckCodePrefix::D405,
+                CheckCodePrefix::D406,
+                CheckCodePrefix::D407,
+                CheckCodePrefix::D408,
+                CheckCodePrefix::D409,
+                CheckCodePrefix::D410,
+                CheckCodePrefix::D411,
+                CheckCodePrefix::D412,
+                CheckCodePrefix::D414,
+                CheckCodePrefix::D418,
+                CheckCodePrefix::D419,
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
+            extend_select: None,
+            ignore: Some(vec![]),
+            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_infers_plugins_if_omitted() -> Result<()> {
+        let actual = convert(
+            &HashMap::from([("inline-quotes".to_string(), Some("single".to_string()))]),
+            None,
+        )?;
+        let expected = Pyproject::new(Options {
+            line_length: None,
+            exclude: None,
+            extend_exclude: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::Q,
+                CheckCodePrefix::W,
+            ]),
+            extend_select: None,
+            ignore: Some(vec![]),
+            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(())
+    }
+}
--- a/flake8_to_ruff/src/lib.rs
+++ b/flake8_to_ruff/src/lib.rs
@@ -0,0 +1,5 @@
+#![allow(clippy::collapsible_if, clippy::collapsible_else_if)]
+
+pub mod converter;
+mod parser;
+pub mod plugin;
--- a/flake8_to_ruff/src/main.rs
+++ b/flake8_to_ruff/src/main.rs
@@ -0,0 +1,44 @@
+//! 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;
+use flake8_to_ruff::plugin::Plugin;
+
+#[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,
+    /// List of plugins to enable.
+    #[arg(long, value_delimiter = ',')]
+    plugin: Option<Vec<Plugin>>,
+}
+
+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))?;
+
+    // Extract the Flake8 section.
+    let flake8 = config
+        .get("flake8")
+        .expect("Unable to find flake8 section in INI file.");
+
+    // Create the pyproject.toml.
+    let pyproject = converter::convert(flake8, cli.plugin)?;
+    println!("{}", toml::to_string_pretty(&pyproject)?);
+
+    Ok(())
+}
--- a/flake8_to_ruff/src/parser.rs
+++ b/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(())
+    }
+}
--- a/flake8_to_ruff/src/plugin.rs
+++ b/flake8_to_ruff/src/plugin.rs
@@ -0,0 +1,321 @@
+use std::collections::{BTreeSet, HashMap};
+use std::str::FromStr;
+
+use anyhow::anyhow;
+use ruff::checks_gen::CheckCodePrefix;
+
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub enum Plugin {
+    Flake8Bugbear,
+    Flake8Builtins,
+    Flake8Comprehensions,
+    Flake8Docstrings,
+    Flake8Print,
+    Flake8Quotes,
+    PEP8Naming,
+    Pyupgrade,
+}
+
+impl FromStr for Plugin {
+    type Err = anyhow::Error;
+
+    fn from_str(string: &str) -> Result<Self, Self::Err> {
+        match string {
+            "flake8-bugbear" => Ok(Plugin::Flake8Bugbear),
+            "flake8-builtins" => Ok(Plugin::Flake8Builtins),
+            "flake8-comprehensions" => Ok(Plugin::Flake8Comprehensions),
+            "flake8-docstrings" => Ok(Plugin::Flake8Docstrings),
+            "flake8-print" => Ok(Plugin::Flake8Print),
+            "flake8-quotes" => Ok(Plugin::Flake8Quotes),
+            "pep8-naming" => Ok(Plugin::PEP8Naming),
+            "pyupgrade" => Ok(Plugin::Pyupgrade),
+            _ => Err(anyhow!("Unknown plugin: {}", string)),
+        }
+    }
+}
+
+impl Plugin {
+    pub fn select(&self, flake8: &HashMap<String, Option<String>>) -> Vec<CheckCodePrefix> {
+        match self {
+            Plugin::Flake8Bugbear => vec![CheckCodePrefix::B],
+            Plugin::Flake8Builtins => vec![CheckCodePrefix::A],
+            Plugin::Flake8Comprehensions => vec![CheckCodePrefix::C],
+            Plugin::Flake8Docstrings => {
+                // Use the user-provided docstring.
+                for key in ["docstring-convention", "docstring_convention"] {
+                    if let Some(Some(value)) = flake8.get(key) {
+                        match DocstringConvention::from_str(value) {
+                            Ok(convention) => return convention.select(),
+                            Err(e) => {
+                                eprintln!("Unexpected '{key}' value: {value} ({e}");
+                                return vec![];
+                            }
+                        }
+                    }
+                }
+                // Default to PEP8.
+                DocstringConvention::PEP8.select()
+            }
+            Plugin::Flake8Print => vec![CheckCodePrefix::T],
+            Plugin::Flake8Quotes => vec![CheckCodePrefix::Q],
+            Plugin::PEP8Naming => vec![CheckCodePrefix::N],
+            Plugin::Pyupgrade => vec![CheckCodePrefix::U],
+        }
+    }
+}
+
+pub enum DocstringConvention {
+    All,
+    PEP8,
+    NumPy,
+    Google,
+}
+
+impl FromStr for DocstringConvention {
+    type Err = anyhow::Error;
+
+    fn from_str(string: &str) -> Result<Self, Self::Err> {
+        match string {
+            "all" => Ok(DocstringConvention::All),
+            "pep8" => Ok(DocstringConvention::PEP8),
+            "numpy" => Ok(DocstringConvention::NumPy),
+            "google" => Ok(DocstringConvention::Google),
+            _ => Err(anyhow!("Unknown docstring convention: {}", string)),
+        }
+    }
+}
+
+impl DocstringConvention {
+    fn select(&self) -> Vec<CheckCodePrefix> {
+        match self {
+            DocstringConvention::All => vec![CheckCodePrefix::D],
+            DocstringConvention::PEP8 => vec![
+                // All errors except D203, D212, D213, D214, D215, D404, D405, D406, D407, D408,
+                // D409, D410, D411, D413, D415, D416 and D417.
+                CheckCodePrefix::D100,
+                CheckCodePrefix::D101,
+                CheckCodePrefix::D102,
+                CheckCodePrefix::D103,
+                CheckCodePrefix::D104,
+                CheckCodePrefix::D105,
+                CheckCodePrefix::D106,
+                CheckCodePrefix::D107,
+                CheckCodePrefix::D200,
+                CheckCodePrefix::D201,
+                CheckCodePrefix::D202,
+                // CheckCodePrefix::D203,
+                CheckCodePrefix::D204,
+                CheckCodePrefix::D205,
+                CheckCodePrefix::D206,
+                CheckCodePrefix::D207,
+                CheckCodePrefix::D208,
+                CheckCodePrefix::D209,
+                CheckCodePrefix::D210,
+                CheckCodePrefix::D211,
+                // CheckCodePrefix::D212,
+                // CheckCodePrefix::D213,
+                // CheckCodePrefix::D214,
+                // CheckCodePrefix::D215,
+                CheckCodePrefix::D300,
+                CheckCodePrefix::D400,
+                CheckCodePrefix::D402,
+                CheckCodePrefix::D403,
+                // CheckCodePrefix::D404,
+                // CheckCodePrefix::D405,
+                // CheckCodePrefix::D406,
+                // CheckCodePrefix::D407,
+                // CheckCodePrefix::D408,
+                // CheckCodePrefix::D409,
+                // CheckCodePrefix::D410,
+                // CheckCodePrefix::D411,
+                CheckCodePrefix::D412,
+                // CheckCodePrefix::D413,
+                CheckCodePrefix::D414,
+                // CheckCodePrefix::D415,
+                // CheckCodePrefix::D416,
+                // CheckCodePrefix::D417,
+                CheckCodePrefix::D418,
+                CheckCodePrefix::D419,
+            ],
+            DocstringConvention::NumPy => vec![
+                // All errors except D107, D203, D212, D213, D402, D413, D415, D416, and D417.
+                CheckCodePrefix::D100,
+                CheckCodePrefix::D101,
+                CheckCodePrefix::D102,
+                CheckCodePrefix::D103,
+                CheckCodePrefix::D104,
+                CheckCodePrefix::D105,
+                CheckCodePrefix::D106,
+                // CheckCodePrefix::D107,
+                CheckCodePrefix::D200,
+                CheckCodePrefix::D201,
+                CheckCodePrefix::D202,
+                // CheckCodePrefix::D203,
+                CheckCodePrefix::D204,
+                CheckCodePrefix::D205,
+                CheckCodePrefix::D206,
+                CheckCodePrefix::D207,
+                CheckCodePrefix::D208,
+                CheckCodePrefix::D209,
+                CheckCodePrefix::D210,
+                CheckCodePrefix::D211,
+                // CheckCodePrefix::D212,
+                // CheckCodePrefix::D213,
+                CheckCodePrefix::D214,
+                CheckCodePrefix::D215,
+                CheckCodePrefix::D300,
+                CheckCodePrefix::D400,
+                // CheckCodePrefix::D402,
+                CheckCodePrefix::D403,
+                CheckCodePrefix::D404,
+                CheckCodePrefix::D405,
+                CheckCodePrefix::D406,
+                CheckCodePrefix::D407,
+                CheckCodePrefix::D408,
+                CheckCodePrefix::D409,
+                CheckCodePrefix::D410,
+                CheckCodePrefix::D411,
+                CheckCodePrefix::D412,
+                // CheckCodePrefix::D413,
+                CheckCodePrefix::D414,
+                // CheckCodePrefix::D415,
+                // CheckCodePrefix::D416,
+                // CheckCodePrefix::D417,
+                CheckCodePrefix::D418,
+                CheckCodePrefix::D419,
+            ],
+            DocstringConvention::Google => vec![
+                // All errors except D203, D204, D213, D215, D400, D401, D404, D406, D407, D408,
+                // D409 and D413.
+                CheckCodePrefix::D100,
+                CheckCodePrefix::D101,
+                CheckCodePrefix::D102,
+                CheckCodePrefix::D103,
+                CheckCodePrefix::D104,
+                CheckCodePrefix::D105,
+                CheckCodePrefix::D106,
+                CheckCodePrefix::D107,
+                CheckCodePrefix::D200,
+                CheckCodePrefix::D201,
+                CheckCodePrefix::D202,
+                // CheckCodePrefix::D203,
+                // CheckCodePrefix::D204,
+                CheckCodePrefix::D205,
+                CheckCodePrefix::D206,
+                CheckCodePrefix::D207,
+                CheckCodePrefix::D208,
+                CheckCodePrefix::D209,
+                CheckCodePrefix::D210,
+                CheckCodePrefix::D211,
+                CheckCodePrefix::D212,
+                // CheckCodePrefix::D213,
+                CheckCodePrefix::D214,
+                // CheckCodePrefix::D215,
+                CheckCodePrefix::D300,
+                // CheckCodePrefix::D400,
+                CheckCodePrefix::D402,
+                CheckCodePrefix::D403,
+                // CheckCodePrefix::D404,
+                CheckCodePrefix::D405,
+                // CheckCodePrefix::D406,
+                // CheckCodePrefix::D407,
+                // CheckCodePrefix::D408,
+                // CheckCodePrefix::D409,
+                CheckCodePrefix::D410,
+                CheckCodePrefix::D411,
+                CheckCodePrefix::D412,
+                // CheckCodePrefix::D413,
+                CheckCodePrefix::D414,
+                CheckCodePrefix::D415,
+                CheckCodePrefix::D416,
+                CheckCodePrefix::D417,
+                CheckCodePrefix::D418,
+                CheckCodePrefix::D419,
+            ],
+        }
+    }
+}
+
+/// Infer the enabled plugins based on user-provided settings.
+pub fn infer_plugins(flake8: &HashMap<String, Option<String>>) -> Vec<Plugin> {
+    let mut plugins = BTreeSet::new();
+    for key in flake8.keys() {
+        match key.as_str() {
+            // flake8-docstrings
+            "docstring-convention" | "docstring_convention" => {
+                plugins.insert(Plugin::Flake8Docstrings);
+            }
+            // flake8-builtins
+            "builtins-ignorelist" | "builtins_ignorelist" => {
+                plugins.insert(Plugin::Flake8Builtins);
+            }
+            // flake8-quotes
+            "quotes" | "inline-quotes" | "inline_quotes" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            "multiline-quotes" | "multiline_quotes" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            "docstring-quotes" | "docstring_quotes" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            "avoid-escape" | "avoid_escape" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            // pep8-naming
+            "ignore-names" | "ignore_names" => {
+                plugins.insert(Plugin::PEP8Naming);
+            }
+            "classmethod-decorators" | "classmethod_decorators" => {
+                plugins.insert(Plugin::PEP8Naming);
+            }
+            "staticmethod-decorators" | "staticmethod_decorators" => {
+                plugins.insert(Plugin::PEP8Naming);
+            }
+            _ => {}
+        }
+    }
+    Vec::from_iter(plugins)
+}
+
+/// Resolve the set of enabled `CheckCodePrefix` values for the given plugins.
+pub fn resolve_select(
+    flake8: &HashMap<String, Option<String>>,
+    plugins: &[Plugin],
+) -> BTreeSet<CheckCodePrefix> {
+    // Include default Pyflakes and pycodestyle checks.
+    let mut select = BTreeSet::from([CheckCodePrefix::E, CheckCodePrefix::F, CheckCodePrefix::W]);
+
+    // Add prefix codes for every plugin.
+    for plugin in plugins {
+        for prefix in plugin.select(flake8) {
+            select.insert(prefix);
+        }
+    }
+
+    select
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use crate::plugin::{infer_plugins, Plugin};
+
+    #[test]
+    fn it_infers_plugins() {
+        let actual = infer_plugins(&HashMap::from([(
+            "inline-quotes".to_string(),
+            Some("single".to_string()),
+        )]));
+        let expected = vec![Plugin::Flake8Quotes];
+        assert_eq!(actual, expected);
+
+        let actual = infer_plugins(&HashMap::from([(
+            "staticmethod-decorators".to_string(),
+            Some("[]".to_string()),
+        )]));
+        let expected = vec![Plugin::PEP8Naming];
+        assert_eq!(actual, expected);
+    }
+}
--- a/resources/test/fixtures/B003.py
+++ b/resources/test/fixtures/B003.py
@@ -0,0 +1,18 @@
+"""
+Should emit:
+B003 - on line 9
+"""
+
+import os
+from os import environ
+
+os.environ = {}
+environ = {}  # that's fine, assigning a new meaning to the module-level name
+
+
+class Object:
+    os = None
+
+
+o = Object()
+o.os.environ = {}
--- a/resources/test/fixtures/B006_B008.py
+++ b/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)
--- a/resources/test/fixtures/B015.py
+++ b/resources/test/fixtures/B015.py
@@ -0,0 +1,24 @@
+assert 1 == 1
+
+1 == 1
+
+assert 1 in (1, 2)
+
+1 in (1, 2)
+
+
+if 1 == 2:
+    pass
+
+
+def test():
+    assert 1 in (1, 2)
+
+    1 in (1, 2)
+
+
+data = [x for x in [1, 2, 3] if x in (1, 2)]
+
+
+class TestClass:
+    1 == 1
--- a/resources/test/fixtures/B016.py
+++ b/resources/test/fixtures/B016.py
@@ -0,0 +1,11 @@
+"""
+Should emit:
+B016 - on lines 6, 7, and 8
+"""
+
+raise False
+raise 1
+raise "string"
+raise Exception(False)
+raise Exception(1)
+raise Exception("string")
--- a/resources/test/fixtures/B018.py
+++ b/resources/test/fixtures/B018.py
@@ -0,0 +1,59 @@
+class Foo1:
+    """abc"""
+
+
+class Foo2:
+    """abc"""
+
+    a = 2
+    "str"  # Str (no raise)
+    f"{int}"  # JoinedStr (no raise)
+    1j  # Number (complex)
+    1  # Number (int)
+    1.0  # Number (float)
+    b"foo"  # Binary
+    True  # NameConstant (True)
+    False  # NameConstant (False)
+    None  # NameConstant (None)
+    [1, 2]  # list
+    {1, 2}  # set
+    {"foo": "bar"}  # dict
+
+
+class Foo3:
+    123
+    a = 2
+    "str"
+    1
+
+
+def foo1():
+    """my docstring"""
+
+
+def foo2():
+    """my docstring"""
+    a = 2
+    "str"  # Str (no raise)
+    f"{int}"  # JoinedStr (no raise)
+    1j  # Number (complex)
+    1  # Number (int)
+    1.0  # Number (float)
+    b"foo"  # Binary
+    True  # NameConstant (True)
+    False  # NameConstant (False)
+    None  # NameConstant (None)
+    [1, 2]  # list
+    {1, 2}  # set
+    {"foo": "bar"}  # dict
+
+
+def foo3():
+    123
+    a = 2
+    "str"
+    3
+
+
+def foo4():
+    ...
--- a/resources/test/fixtures/C400.py
+++ b/resources/test/fixtures/C400.py
@@ -1 +1,4 @@
 x = list(x for x in range(3))
+x = list(
+    x for x in range(3)
+)
--- a/resources/test/fixtures/C401.py
+++ b/resources/test/fixtures/C401.py
@@ -1 +1,4 @@
 x = set(x for x in range(3))
+x = set(
+    x for x in range(3)
+)
--- a/resources/test/fixtures/C402.py
+++ b/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)
--- a/resources/test/fixtures/C403.py
+++ b/resources/test/fixtures/C403.py
@@ -1 +1,4 @@
 s = set([x for x in range(3)])
+s = set(
+    [x for x in range(3)]
+)
--- a/resources/test/fixtures/C404.py
+++ b/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)
--- a/resources/test/fixtures/C409.py
+++ b/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)
+)
--- a/resources/test/fixtures/E501.py
+++ b/resources/test/fixtures/E501.py
@@ -14,3 +14,21 @@ Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor i

 _ = "---------------------------------------------------------------------------AAAAAAA"
 _ = "---------------------------------------------------------------------------亜亜亜亜亜亜亜"
+
+
+def caller(string: str) -> None:
+    assert string is not None
+
+
+caller(
+    """
+    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+    """,
+)
+
+
+caller(
+    """
+    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+    """,  # noqa: E501
+)
--- a/resources/test/fixtures/F821_0.py
+++ b/resources/test/fixtures/F821_0.py
--- a/resources/test/fixtures/F821_1.py
+++ b/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"]
--- a/resources/test/fixtures/F821_2.py
+++ b/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"]
--- a/resources/test/fixtures/F821_3.py
+++ b/resources/test/fixtures/F821_3.py
@@ -0,0 +1,14 @@
+"""Test (edge case): accesses of object named `dict`."""
+
+# OK
+dict = {"parameters": {}}
+dict["parameters"]["userId"] = "userId"
+dict["parameters"]["itemId"] = "itemId"
+del dict["parameters"]["itemId"]
+
+# F821 Undefined name `key`
+# F821 Undefined name `value`
+x: dict["key", "value"]
+
+# OK
+x: dict[str, str]
--- a/resources/test/fixtures/N806.py
+++ b/resources/test/fixtures/N806.py
@@ -2,3 +2,4 @@ def f():
    lower = 0
    Camel = 0
    CONSTANT = 0
+    _ = 0
--- a/resources/test/fixtures/RUF001.py
+++ b/resources/test/fixtures/RUF001.py
@@ -0,0 +1,6 @@
+x = "𝐁ad string"
+
+
+def f():
+    """Here's a comment with an unusual parenthesis: ）"""
+    ...
--- a/resources/test/fixtures/RUF002.py
+++ b/resources/test/fixtures/RUF002.py
@@ -0,0 +1,6 @@
+x = "𝐁ad string"
+
+
+def f():
+    """Here's a comment with an unusual parenthesis: ）"""
+    ...
--- a/resources/test/fixtures/W605_0.py
+++ b/resources/test/fixtures/W605_0.py
--- a/resources/test/fixtures/W605_1.py
+++ b/resources/test/fixtures/W605_1.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
--- a/resources/test/fixtures/pyproject.toml
+++ b/resources/test/fixtures/pyproject.toml
@@ -1,13 +1,11 @@
 [tool.ruff]
 line-length = 88
 extend-exclude = [
-    "excluded.py",
-    "migrations",
-    "directory/also_excluded.py",
-]
-per-file-ignores = [
-    "__init__.py:F401",
+  "excluded.py",
+  "migrations",
+  "directory/also_excluded.py",
 ]
+per-file-ignores = { "__init__.py" = ["F401"] }

 [tool.ruff.flake8-quotes]
 inline-quotes = "single"
@@ -17,22 +15,22 @@ avoid-escape = true

 [tool.ruff.pep8-naming]
 ignore-names = [
-    "setUp",
-    "tearDown",
-    "setUpClass",
-    "tearDownClass",
-    "setUpModule",
-    "tearDownModule",
-    "asyncSetUp",
-    "asyncTearDown",
-    "setUpTestData",
-    "failureException",
-    "longMessage",
-    "maxDiff",
+  "setUp",
+  "tearDown",
+  "setUpClass",
+  "tearDownClass",
+  "setUpModule",
+  "tearDownModule",
+  "asyncSetUp",
+  "asyncTearDown",
+  "setUpTestData",
+  "failureException",
+  "longMessage",
+  "maxDiff",
 ]
 classmethod-decorators = [
-    "classmethod",
+  "classmethod",
 ]
 staticmethod-decorators = [
-    "staticmethod",
+  "staticmethod",
 ]
--- a/1
+++ b/1
@@ -0,0 +1 @@
+1.65.0
--- a/rustfmt.toml
+++ b/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
--- a/scripts/.flake8
+++ b/scripts/.flake8
@@ -17,3 +17,5 @@ exclude =
    test_fstring.py,
    bad_coding2.py,
    badsyntax_*.py
+ignore_names = foo, bar
+quotes = double
--- a/src/ast/helpers.rs
+++ b/src/ast/helpers.rs
@@ -1,9 +1,9 @@
+use std::collections::BTreeSet;
+
 use once_cell::sync::Lazy;
 use regex::Regex;
 use rustpython_ast::{Excepthandler, ExcepthandlerKind, Expr, ExprKind, Location, StmtKind};

-use crate::python::typing;
-
 fn compose_call_path_inner<'a>(expr: &'a Expr, parts: &mut Vec<&'a str>) {
    match &expr.node {
        ExprKind::Call { func, .. } => {
@@ -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,
@@ -132,12 +129,13 @@ pub fn is_super_call_with_arguments(func: &Expr, args: &[Expr]) -> bool {
    }
 }

-/// Convert a location within a file (relative to `base`) to an absolute position.
+/// 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() - 1,
+            relative.column() + base.column(),
        )
    } else {
        Location::new(relative.row() + base.row() - 1, relative.column())
--- a/src/ast/operations.rs
+++ b/src/ast/operations.rs
@@ -1,7 +1,6 @@
-use once_cell::unsync::OnceCell;
-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> {
@@ -118,91 +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> {
-    contents: &'a str,
-    offsets: OnceCell<Vec<Vec<usize>>>,
-}
-
-impl<'a> SourceCodeLocator<'a> {
-    pub fn new(contents: &'a str) -> Self {
-        SourceCodeLocator {
-            contents,
-            offsets: OnceCell::new(),
-        }
-    }
-
-    fn compute_offsets(content: &str) -> Vec<Vec<usize>> {
-        let mut offsets = vec![vec![]];
-        let mut line_index = 0;
-        for (i, char) in content.char_indices() {
-            offsets[line_index].push(i);
-            if char == '\n' {
-                line_index += 1;
-                offsets.push(vec![]);
-            }
-        }
-        offsets
-    }
-
-    fn get_or_init_offsets(&self) -> &Vec<Vec<usize>> {
-        self.offsets
-            .get_or_init(|| Self::compute_offsets(self.contents))
-    }
-
-    pub fn slice_source_code_at(&self, location: &Location) -> &'a str {
-        let offsets = self.get_or_init_offsets();
-        let offset = offsets[location.row() - 1][location.column() - 1];
-        &self.contents[offset..]
-    }
-
-    pub fn slice_source_code_range(&self, range: &Range) -> &'a str {
-        let offsets = self.get_or_init_offsets();
-        let start = offsets[range.location.row() - 1][range.location.column() - 1];
-        let end = offsets[range.end_location.row() - 1][range.end_location.column() - 1];
-        &self.contents[start..end]
-    }
-
-    pub fn partition_source_code_at(
-        &self,
-        outer: &Range,
-        inner: &Range,
-    ) -> (&'a str, &'a str, &'a str) {
-        let offsets = self.get_or_init_offsets();
-        let outer_start = offsets[outer.location.row() - 1][outer.location.column() - 1];
-        let outer_end = offsets[outer.end_location.row() - 1][outer.end_location.column() - 1];
-        let inner_start = offsets[inner.location.row() - 1][inner.location.column() - 1];
-        let inner_end = offsets[inner.end_location.row() - 1][inner.end_location.column() - 1];
-        (
-            &self.contents[outer_start..inner_start],
-            &self.contents[inner_start..inner_end],
-            &self.contents[inner_end..outer_end],
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::SourceCodeLocator;
-
-    #[test]
-    fn source_code_locator_init() {
-        let content = "x = 1\ny = 2\nz = x + y\n";
-        let locator = SourceCodeLocator::new(content);
-        let offsets = locator.get_or_init_offsets();
-        assert_eq!(offsets.len(), 4);
-        assert_eq!(offsets[0], [0, 1, 2, 3, 4, 5]);
-        assert_eq!(offsets[1], [6, 7, 8, 9, 10, 11]);
-        assert_eq!(offsets[2], [12, 13, 14, 15, 16, 17, 18, 19, 20, 21]);
-        assert!(offsets[3].is_empty());
-
-        let content = "# \u{4e9c}\nclass Foo:\n    \"\"\".\"\"\"";
-        let locator = SourceCodeLocator::new(content);
-        let offsets = locator.get_or_init_offsets();
-        assert_eq!(offsets.len(), 3);
-        assert_eq!(offsets[0], [0, 1, 2, 5]);
-        assert_eq!(offsets[1], [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
-        assert_eq!(offsets[2], [17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]);
-    }
-}
--- a/src/ast/relocate.rs
+++ b/src/ast/relocate.rs
@@ -8,7 +8,8 @@ fn relocate_keyword(keyword: &mut Keyword, location: Range) {
    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 = Some(location.end_location);
--- a/src/ast/types.rs
+++ b/src/ast/types.rs
@@ -36,6 +36,7 @@ pub enum ScopeKind {
    Function(FunctionScope),
    Generator,
    Module,
+    Arg,
 }

 #[derive(Clone, Debug)]
@@ -85,8 +86,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)>,
 }

--- a/src/autofix/fixer.rs
+++ b/src/autofix/fixer.rs
@@ -1,12 +1,17 @@
+use std::borrow::Cow;
 use std::collections::BTreeSet;

 use itertools::Itertools;
+use ropey::RopeBuilder;
 use rustpython_parser::ast::Location;

-use crate::autofix::Fix;
-use crate::autofix::Patch;
+use crate::ast::types::Range;
+use crate::autofix::{Fix, Patch};
 use crate::checks::Check;
+use crate::source_code_locator::SourceCodeLocator;

+// 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,
@@ -35,77 +40,64 @@ impl From<bool> for Mode {
 }

 /// Auto-fix errors in a file, and write the fixed source code to disk.
-pub fn fix_file(checks: &mut [Check], contents: &str) -> Option<String> {
+pub fn fix_file<'a>(
+    checks: &'a mut [Check],
+    locator: &'a SourceCodeLocator<'a>,
+) -> Option<Cow<'a, str>> {
    if checks.iter().all(|check| check.fix.is_none()) {
        return None;
    }

    Some(apply_fixes(
        checks.iter_mut().filter_map(|check| check.fix.as_mut()),
-        contents,
+        locator,
    ))
 }

 /// Apply a series of fixes.
-fn apply_fixes<'a>(fixes: impl Iterator<Item = &'a mut Fix>, contents: &str) -> String {
-    let lines: Vec<&str> = contents.lines().collect();
-
-    let mut output: String = Default::default();
-    let mut last_pos: Location = Default::default();
-    let mut applied: BTreeSet<&Patch> = Default::default();
+fn apply_fixes<'a>(
+    fixes: impl Iterator<Item = &'a mut Fix>,
+    locator: &'a SourceCodeLocator<'a>,
+) -> Cow<'a, str> {
+    let mut output = RopeBuilder::new();
+    let mut last_pos: Location = Location::new(1, 0);
+    let mut applied: BTreeSet<&Patch> = BTreeSet::new();

    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 we already applied an identical fix as part of another correction, skip
+        // any re-application.
        if applied.contains(&fix.patch) {
            fix.applied = true;
            continue;
        }

-        // Best-effort approach: if this fix overlaps with a fix we've already applied, skip it.
+        // 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('\n');
-            }
-            for line in &lines[last_pos.row()..fix.patch.location.row() - 1] {
-                output.push_str(line);
-                output.push('\n');
-            }
-            output
-                .push_str(&lines[fix.patch.location.row() - 1][..fix.patch.location.column() - 1]);
-            output.push_str(&fix.patch.content);
-        } else {
-            output.push_str(
-                &lines[last_pos.row() - 1][last_pos.column() - 1..fix.patch.location.column() - 1],
-            );
-            output.push_str(&fix.patch.content);
-        }
-        last_pos = fix.patch.end_location;
+        // Add all contents from `last_pos` to `fix.patch.location`.
+        let slice = locator.slice_source_code_range(&Range {
+            location: last_pos,
+            end_location: fix.patch.location,
+        });
+        output.append(&slice);

+        // Add the patch itself.
+        output.append(&fix.patch.content);
+
+        // Track that the fix was applied.
+        last_pos = fix.patch.end_location;
        applied.insert(&fix.patch);
        fix.applied = true;
    }

-    if last_pos.row() > 0
-        && (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('\n');
-    }
-    if last_pos.row() < lines.len() {
-        for line in &lines[last_pos.row()..] {
-            output.push_str(line);
-            output.push('\n');
-        }
-    }
+    // Add the remaining content.
+    let slice = locator.slice_source_code_at(&last_pos);
+    output.append(&slice);

-    output
+    Cow::from(output.finish())
 }

 #[cfg(test)]
@@ -114,13 +106,14 @@ mod tests {
    use rustpython_parser::ast::Location;

    use crate::autofix::fixer::apply_fixes;
-    use crate::autofix::Fix;
-    use crate::autofix::Patch;
+    use crate::autofix::{Fix, Patch};
+    use crate::SourceCodeLocator;

    #[test]
    fn empty_file() -> Result<()> {
        let mut fixes = vec![];
-        let actual = apply_fixes(fixes.iter_mut(), "");
+        let locator = SourceCodeLocator::new("");
+        let actual = apply_fixes(fixes.iter_mut(), &locator);
        let expected = "";

        assert_eq!(actual, expected);
@@ -133,17 +126,17 @@ mod tests {
        let mut fixes = vec![Fix {
            patch: Patch {
                content: "Bar".to_string(),
-                location: Location::new(1, 9),
-                end_location: Location::new(1, 15),
+                location: Location::new(1, 8),
+                end_location: Location::new(1, 14),
            },
            applied: false,
        }];
-        let actual = apply_fixes(
-            fixes.iter_mut(),
+        let locator = SourceCodeLocator::new(
            "class A(object):
        ...
 ",
        );
+        let actual = apply_fixes(fixes.iter_mut(), &locator);

        let expected = "class A(Bar):
        ...
@@ -159,17 +152,17 @@ mod tests {
        let mut fixes = vec![Fix {
            patch: Patch {
                content: "".to_string(),
-                location: Location::new(1, 8),
-                end_location: Location::new(1, 16),
+                location: Location::new(1, 7),
+                end_location: Location::new(1, 15),
            },
            applied: false,
        }];
-        let actual = apply_fixes(
-            fixes.iter_mut(),
+        let locator = SourceCodeLocator::new(
            "class A(object):
        ...
 ",
        );
+        let actual = apply_fixes(fixes.iter_mut(), &locator);

        let expected = "class A:
        ...
@@ -186,26 +179,26 @@ mod tests {
            Fix {
                patch: Patch {
                    content: "".to_string(),
-                    location: Location::new(1, 8),
-                    end_location: Location::new(1, 17),
+                    location: Location::new(1, 7),
+                    end_location: Location::new(1, 16),
                },
                applied: false,
            },
            Fix {
                patch: Patch {
                    content: "".to_string(),
-                    location: Location::new(1, 17),
-                    end_location: Location::new(1, 24),
+                    location: Location::new(1, 16),
+                    end_location: Location::new(1, 23),
                },
                applied: false,
            },
        ];
-        let actual = apply_fixes(
-            fixes.iter_mut(),
+        let locator = SourceCodeLocator::new(
            "class A(object, object):
        ...
 ",
        );
+        let actual = apply_fixes(fixes.iter_mut(), &locator);

        let expected = "class A:
        ...
@@ -222,26 +215,26 @@ mod tests {
            Fix {
                patch: Patch {
                    content: "".to_string(),
-                    location: Location::new(1, 8),
-                    end_location: Location::new(1, 16),
+                    location: Location::new(1, 7),
+                    end_location: Location::new(1, 15),
                },
                applied: false,
            },
            Fix {
                patch: Patch {
                    content: "ignored".to_string(),
-                    location: Location::new(1, 10),
-                    end_location: Location::new(1, 12),
+                    location: Location::new(1, 9),
+                    end_location: Location::new(1, 11),
                },
                applied: false,
            },
        ];
-        let actual = apply_fixes(
-            fixes.iter_mut(),
+        let locator = SourceCodeLocator::new(
            "class A(object):
    ...
 ",
        );
+        let actual = apply_fixes(fixes.iter_mut(), &locator);

        let expected = "class A:
    ...
--- a/src/autofix/helpers.rs
+++ b/src/autofix/helpers.rs
@@ -4,7 +4,8 @@ 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.
+/// 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
 }
@@ -80,10 +81,11 @@ pub fn remove_stmt(stmt: &Stmt, parent: Option<&Stmt>, deleted: &[&Stmt]) -> Res
        ))
    } else {
        // Otherwise, nuke the entire line.
-        // TODO(charlie): This logic assumes that there are no multi-statement physical lines.
+        // TODO(charlie): This logic assumes that there are no multi-statement physical
+        // lines.
        Ok(Fix::deletion(
-            Location::new(stmt.location.row(), 1),
-            Location::new(stmt.end_location.unwrap().row() + 1, 1),
+            Location::new(stmt.location.row(), 0),
+            Location::new(stmt.end_location.unwrap().row() + 1, 0),
        ))
    }
 }
--- a/src/cache.rs
+++ b/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
--- a/src/check_ast.rs
+++ b/src/check_ast.rs
@@ -11,8 +11,8 @@ use rustpython_parser::ast::{
 };
 use rustpython_parser::parser;

-use crate::ast::helpers::{extract_handler_names, match_name_or_attr, SubscriptKind};
-use crate::ast::operations::{extract_all_names, SourceCodeLocator};
+use crate::ast::helpers::{extract_handler_names, match_name_or_attr_from_module};
+use crate::ast::operations::extract_all_names;
 use crate::ast::relocate::relocate_expr;
 use crate::ast::types::{
    Binding, BindingContext, BindingKind, CheckLocator, FunctionScope, ImportKind, Range, Scope,
@@ -25,15 +25,29 @@ use crate::checks::{Check, CheckCode, CheckKind};
 use crate::docstrings::definition::{Definition, DefinitionKind, Documentable};
 use crate::python::builtins::{BUILTINS, MAGIC_GLOBALS};
 use crate::python::future::ALL_FEATURE_NAMES;
+use crate::python::typing;
+use crate::python::typing::SubscriptKind;
 use crate::settings::types::PythonVersion;
 use crate::settings::Settings;
+use crate::source_code_locator::SourceCodeLocator;
 use crate::visibility::{module_visibility, transition_scope, Modifier, Visibility, VisibleScope};
 use crate::{
    docstrings, flake8_bugbear, flake8_builtins, flake8_comprehensions, flake8_print, pep8_naming,
    pycodestyle, pydocstyle, pyflakes, pyupgrade,
 };

-pub const GLOBAL_SCOPE_INDEX: usize = 0;
+const GLOBAL_SCOPE_INDEX: usize = 0;
+const TRACK_FROM_IMPORTS: [&str; 9] = [
+    "collections",
+    "collections.abc",
+    "contextlib",
+    "re",
+    "typing",
+    "typing.io",
+    "typing.re",
+    "typing_extensions",
+    "weakref",
+];

 pub struct Checker<'a> {
    // Input data.
@@ -65,10 +79,12 @@ pub struct Checker<'a> {
    in_f_string: Option<Range>,
    in_annotation: bool,
    in_literal: bool,
+    in_subscript: bool,
    seen_import_boundary: bool,
    futures_allowed: bool,
    annotations_future_enabled: bool,
    except_handlers: Vec<Vec<String>>,
+    from_imports: BTreeMap<&'a str, BTreeSet<&'a str>>,
 }

 impl<'a> Checker<'a> {
@@ -100,19 +116,36 @@ impl<'a> Checker<'a> {
                modifier: Modifier::Module,
                visibility: module_visibility(path),
            },
-            in_f_string: None,
+            in_f_string: Default::default(),
            in_annotation: Default::default(),
            in_literal: Default::default(),
+            in_subscript: Default::default(),
            seen_import_boundary: Default::default(),
            futures_allowed: true,
            annotations_future_enabled: Default::default(),
            except_handlers: Default::default(),
+            from_imports: Default::default(),
        }
    }

-    /// Return `true` if a patch should be generated under the given autofix `Mode`.
+    /// Return `true` if a patch should be generated under the given autofix
+    /// `Mode`.
    pub fn patch(&self) -> bool {
-        self.autofix.patch()
+        // TODO(charlie): We can't fix errors in f-strings until RustPython adds
+        // location data.
+        self.autofix.patch() && self.in_f_string.is_none()
+    }
+
+    /// Return `true` if the `Expr` is a reference to `typing.${target}`.
+    pub fn match_typing_module(&self, expr: &Expr, target: &str) -> bool {
+        match_name_or_attr_from_module(expr, target, "typing", self.from_imports.get("typing"))
+            || (typing::in_extensions(target)
+                && match_name_or_attr_from_module(
+                    expr,
+                    target,
+                    "typing_extensions",
+                    self.from_imports.get("typing_extensions"),
+                ))
    }
 }

@@ -207,6 +240,7 @@ where
                decorator_list,
                returns,
                args,
+                body,
                ..
            }
            | StmtKind::AsyncFunctionDef {
@@ -214,6 +248,7 @@ where
                decorator_list,
                returns,
                args,
+                body,
                ..
            } => {
                if self.settings.enabled.contains(&CheckCode::E743) {
@@ -267,9 +302,14 @@ where
                    }
                }

+                if self.settings.enabled.contains(&CheckCode::B018) {
+                    flake8_bugbear::plugins::useless_expression(self, body);
+                }
+
                self.check_builtin_shadowing(name, Range::from_located(stmt), true);

-                // Visit the decorators and arguments, but avoid the body, which will be deferred.
+                // Visit the decorators and arguments, but avoid the body, which will be
+                // deferred.
                for expr in decorator_list {
                    self.visit_expr(expr);
                }
@@ -336,6 +376,7 @@ where
                bases,
                keywords,
                decorator_list,
+                body,
                ..
            } => {
                if self.settings.enabled.contains(&CheckCode::U004) {
@@ -367,6 +408,10 @@ where
                    }
                }

+                if self.settings.enabled.contains(&CheckCode::B018) {
+                    flake8_bugbear::plugins::useless_expression(self, body);
+                }
+
                self.check_builtin_shadowing(
                    name,
                    self.locate_check(Range::from_located(stmt)),
@@ -386,7 +431,7 @@ where
            }
            StmtKind::Import { names } => {
                if self.settings.enabled.contains(&CheckCode::E402) {
-                    if self.seen_import_boundary && stmt.location.column() == 1 {
+                    if self.seen_import_boundary && stmt.location.column() == 0 {
                        self.checks.push(Check::new(
                            CheckKind::ModuleImportNotAtTopOfFile,
                            self.locate_check(Range::from_located(stmt)),
@@ -491,8 +536,26 @@ where
                module,
                level,
            } => {
+                // Track `import from` statements, to ensure that we can correctly attribute
+                // references like `from typing import Union`.
+                if level.map(|level| level == 0).unwrap_or(true) {
+                    if let Some(module) = module {
+                        if TRACK_FROM_IMPORTS.contains(&module.as_str()) {
+                            self.from_imports
+                                .entry(module)
+                                .or_insert_with(BTreeSet::new)
+                                .extend(
+                                    names
+                                        .iter()
+                                        .filter(|alias| alias.node.asname.is_none())
+                                        .map(|alias| alias.node.name.as_str()),
+                                )
+                        }
+                    }
+                }
+
                if self.settings.enabled.contains(&CheckCode::E402) {
-                    if self.seen_import_boundary && stmt.location.column() == 1 {
+                    if self.seen_import_boundary && stmt.location.column() == 0 {
                        self.checks.push(Check::new(
                            CheckKind::ModuleImportNotAtTopOfFile,
                            self.locate_check(Range::from_located(stmt)),
@@ -667,9 +730,12 @@ where
            StmtKind::Raise { exc, .. } => {
                if self.settings.enabled.contains(&CheckCode::F901) {
                    if let Some(expr) = exc {
-                        if let Some(check) = pyflakes::checks::raise_not_implemented(expr) {
-                            self.checks.push(check);
-                        }
+                        pyflakes::plugins::raise_not_implemented(self, expr);
+                    }
+                }
+                if self.settings.enabled.contains(&CheckCode::B016) {
+                    if let Some(exc) = exc {
+                        flake8_bugbear::plugins::cannot_raise_literal(self, exc);
                    }
                }
            }
@@ -726,6 +792,9 @@ where
                if self.settings.enabled.contains(&CheckCode::U001) {
                    pyupgrade::plugins::useless_metaclass_type(self, stmt, value, targets);
                }
+                if self.settings.enabled.contains(&CheckCode::B003) {
+                    flake8_bugbear::plugins::assignment_to_os_environ(self, targets);
+                }
            }
            StmtKind::AnnAssign { value, .. } => {
                if self.settings.enabled.contains(&CheckCode::E731) {
@@ -860,7 +929,7 @@ where
                    pyupgrade::plugins::use_pep604_annotation(self, expr, value, slice);
                }

-                if match_name_or_attr(value, "Literal") {
+                if self.match_typing_module(value, "Literal") {
                    self.in_literal = true;
                }
            }
@@ -885,6 +954,7 @@ where
                    // Ex) List[...]
                    if self.settings.enabled.contains(&CheckCode::U006)
                        && self.settings.target_version >= PythonVersion::Py39
+                        && typing::is_pep585_builtin(expr, self.from_imports.get("typing"))
                    {
                        pyupgrade::plugins::use_pep585_annotation(self, expr, id);
                    }
@@ -907,23 +977,19 @@ where
                }
                ExprContext::Del => self.handle_node_delete(expr),
            },
-            ExprKind::Attribute { value, attr, .. } => {
+            ExprKind::Attribute { attr, .. } => {
                // Ex) typing.List[...]
                if self.settings.enabled.contains(&CheckCode::U006)
                    && self.settings.target_version >= PythonVersion::Py39
+                    && typing::is_pep585_builtin(expr, self.from_imports.get("typing"))
                {
-                    if let ExprKind::Name { id, .. } = &value.node {
-                        if id == "typing" {
-                            pyupgrade::plugins::use_pep585_annotation(self, expr, attr);
-                        }
-                    }
+                    pyupgrade::plugins::use_pep585_annotation(self, expr, attr);
                }
            }
            ExprKind::Call {
                func,
                args,
                keywords,
-                ..
            } => {
                if self.settings.enabled.contains(&CheckCode::U005) {
                    pyupgrade::plugins::deprecated_unittest_alias(self, func);
@@ -943,25 +1009,43 @@ where

                // flake8-comprehensions
                if self.settings.enabled.contains(&CheckCode::C400) {
-                    if let Some(check) =
-                        flake8_comprehensions::checks::unnecessary_generator_list(expr, func, args)
-                    {
+                    if let Some(check) = flake8_comprehensions::checks::unnecessary_generator_list(
+                        expr,
+                        func,
+                        args,
+                        keywords,
+                        self.locator,
+                        self.patch(),
+                        self.locate_check(Range::from_located(expr)),
+                    ) {
                        self.checks.push(check);
                    };
                }

                if self.settings.enabled.contains(&CheckCode::C401) {
-                    if let Some(check) =
-                        flake8_comprehensions::checks::unnecessary_generator_set(expr, func, args)
-                    {
+                    if let Some(check) = flake8_comprehensions::checks::unnecessary_generator_set(
+                        expr,
+                        func,
+                        args,
+                        keywords,
+                        self.locator,
+                        self.patch(),
+                        self.locate_check(Range::from_located(expr)),
+                    ) {
                        self.checks.push(check);
                    };
                }

                if self.settings.enabled.contains(&CheckCode::C402) {
-                    if let Some(check) =
-                        flake8_comprehensions::checks::unnecessary_generator_dict(expr, func, args)
-                    {
+                    if let Some(check) = flake8_comprehensions::checks::unnecessary_generator_dict(
+                        expr,
+                        func,
+                        args,
+                        keywords,
+                        self.locator,
+                        self.patch(),
+                        self.locate_check(Range::from_located(expr)),
+                    ) {
                        self.checks.push(check);
                    };
                }
@@ -969,7 +1053,13 @@ where
                if self.settings.enabled.contains(&CheckCode::C403) {
                    if let Some(check) =
                        flake8_comprehensions::checks::unnecessary_list_comprehension_set(
-                            expr, func, args,
+                            expr,
+                            func,
+                            args,
+                            keywords,
+                            self.locator,
+                            self.patch(),
+                            self.locate_check(Range::from_located(expr)),
                        )
                    {
                        self.checks.push(check);
@@ -979,7 +1069,10 @@ where
                if self.settings.enabled.contains(&CheckCode::C404) {
                    if let Some(check) =
                        flake8_comprehensions::checks::unnecessary_list_comprehension_dict(
-                            expr, func, args,
+                            func,
+                            args,
+                            keywords,
+                            self.locate_check(Range::from_located(expr)),
                        )
                    {
                        self.checks.push(check);
@@ -987,24 +1080,42 @@ where
                }

                if self.settings.enabled.contains(&CheckCode::C405) {
-                    if let Some(check) =
-                        flake8_comprehensions::checks::unnecessary_literal_set(expr, func, args)
-                    {
+                    if let Some(check) = flake8_comprehensions::checks::unnecessary_literal_set(
+                        expr,
+                        func,
+                        args,
+                        keywords,
+                        self.locator,
+                        self.patch(),
+                        self.locate_check(Range::from_located(expr)),
+                    ) {
                        self.checks.push(check);
                    };
                }

                if self.settings.enabled.contains(&CheckCode::C406) {
-                    if let Some(check) =
-                        flake8_comprehensions::checks::unnecessary_literal_dict(expr, func, args)
-                    {
+                    if let Some(check) = flake8_comprehensions::checks::unnecessary_literal_dict(
+                        expr,
+                        func,
+                        args,
+                        keywords,
+                        self.locator,
+                        self.patch(),
+                        self.locate_check(Range::from_located(expr)),
+                    ) {
                        self.checks.push(check);
                    };
                }

                if self.settings.enabled.contains(&CheckCode::C408) {
                    if let Some(check) = flake8_comprehensions::checks::unnecessary_collection_call(
-                        expr, func, args, keywords,
+                        expr,
+                        func,
+                        args,
+                        keywords,
+                        self.locator,
+                        self.patch(),
+                        self.locate_check(Range::from_located(expr)),
                    ) {
                        self.checks.push(check);
                    };
@@ -1013,7 +1124,12 @@ where
                if self.settings.enabled.contains(&CheckCode::C409) {
                    if let Some(check) =
                        flake8_comprehensions::checks::unnecessary_literal_within_tuple_call(
-                            expr, func, args,
+                            expr,
+                            func,
+                            args,
+                            self.locator,
+                            self.patch(),
+                            self.locate_check(Range::from_located(expr)),
                        )
                    {
                        self.checks.push(check);
@@ -1023,7 +1139,12 @@ where
                if self.settings.enabled.contains(&CheckCode::C410) {
                    if let Some(check) =
                        flake8_comprehensions::checks::unnecessary_literal_within_list_call(
-                            expr, func, args,
+                            expr,
+                            func,
+                            args,
+                            self.locator,
+                            self.patch(),
+                            self.locate_check(Range::from_located(expr)),
                        )
                    {
                        self.checks.push(check);
@@ -1031,9 +1152,14 @@ where
                }

                if self.settings.enabled.contains(&CheckCode::C411) {
-                    if let Some(check) =
-                        flake8_comprehensions::checks::unnecessary_list_call(expr, func, args)
-                    {
+                    if let Some(check) = flake8_comprehensions::checks::unnecessary_list_call(
+                        expr,
+                        func,
+                        args,
+                        self.locator,
+                        self.patch(),
+                        self.locate_check(Range::from_located(expr)),
+                    ) {
                        self.checks.push(check);
                    };
                }
@@ -1041,7 +1167,9 @@ where
                if self.settings.enabled.contains(&CheckCode::C413) {
                    if let Some(check) =
                        flake8_comprehensions::checks::unnecessary_call_around_sorted(
-                            expr, func, args,
+                            func,
+                            args,
+                            self.locate_check(Range::from_located(expr)),
                        )
                    {
                        self.checks.push(check);
@@ -1051,7 +1179,9 @@ where
                if self.settings.enabled.contains(&CheckCode::C414) {
                    if let Some(check) =
                        flake8_comprehensions::checks::unnecessary_double_cast_or_process(
-                            expr, func, args,
+                            func,
+                            args,
+                            self.locate_check(Range::from_located(expr)),
                        )
                    {
                        self.checks.push(check);
@@ -1061,7 +1191,9 @@ where
                if self.settings.enabled.contains(&CheckCode::C415) {
                    if let Some(check) =
                        flake8_comprehensions::checks::unnecessary_subscript_reversal(
-                            expr, func, args,
+                            func,
+                            args,
+                            self.locate_check(Range::from_located(expr)),
                        )
                    {
                        self.checks.push(check);
@@ -1069,9 +1201,11 @@ where
                }

                if self.settings.enabled.contains(&CheckCode::C417) {
-                    if let Some(check) =
-                        flake8_comprehensions::checks::unnecessary_map(expr, func, args)
-                    {
+                    if let Some(check) = flake8_comprehensions::checks::unnecessary_map(
+                        func,
+                        args,
+                        self.locate_check(Range::from_located(expr)),
+                    ) {
                        self.checks.push(check);
                    };
                }
@@ -1200,6 +1334,12 @@ where
                        self.locate_check(Range::from_located(expr)),
                    ));
                }
+
+                if self.settings.enabled.contains(&CheckCode::B015) {
+                    if let Some(parent) = self.parents.last() {
+                        flake8_bugbear::plugins::useless_comparison(self, left, parent);
+                    }
+                }
            }
            ExprKind::Constant {
                value: Constant::Str(value),
@@ -1248,7 +1388,12 @@ where
            ExprKind::ListComp { elt, generators } | ExprKind::SetComp { elt, generators } => {
                if self.settings.enabled.contains(&CheckCode::C416) {
                    if let Some(check) = flake8_comprehensions::checks::unnecessary_comprehension(
-                        expr, elt, generators,
+                        expr,
+                        elt,
+                        generators,
+                        self.locator,
+                        self.patch(),
+                        self.locate_check(Range::from_located(expr)),
                    ) {
                        self.checks.push(check);
                    };
@@ -1276,12 +1421,12 @@ where
                args,
                keywords,
            } => {
-                if match_name_or_attr(func, "ForwardRef") {
+                if self.match_typing_module(func, "ForwardRef") {
                    self.visit_expr(func);
                    for expr in args {
                        self.visit_annotation(expr);
                    }
-                } else if match_name_or_attr(func, "cast") {
+                } else if self.match_typing_module(func, "cast") {
                    self.visit_expr(func);
                    if !args.is_empty() {
                        self.visit_annotation(&args[0]);
@@ -1289,12 +1434,12 @@ where
                    for expr in args.iter().skip(1) {
                        self.visit_expr(expr);
                    }
-                } else if match_name_or_attr(func, "NewType") {
+                } else if self.match_typing_module(func, "NewType") {
                    self.visit_expr(func);
                    for expr in args.iter().skip(1) {
                        self.visit_annotation(expr);
                    }
-                } else if match_name_or_attr(func, "TypeVar") {
+                } else if self.match_typing_module(func, "TypeVar") {
                    self.visit_expr(func);
                    for expr in args.iter().skip(1) {
                        self.visit_annotation(expr);
@@ -1311,7 +1456,7 @@ where
                            }
                        }
                    }
-                } else if match_name_or_attr(func, "NamedTuple") {
+                } else if self.match_typing_module(func, "NamedTuple") {
                    self.visit_expr(func);

                    // Ex) NamedTuple("a", [("a", int)])
@@ -1343,7 +1488,7 @@ where
                        let KeywordData { value, .. } = &keyword.node;
                        self.visit_annotation(value);
                    }
-                } else if match_name_or_attr(func, "TypedDict") {
+                } else if self.match_typing_module(func, "TypedDict") {
                    self.visit_expr(func);

                    // Ex) TypedDict("a", {"a": int})
@@ -1370,36 +1515,56 @@ where
                }
            }
            ExprKind::Subscript { value, slice, ctx } => {
-                match helpers::match_annotated_subscript(value) {
-                    Some(subscript) => match subscript {
-                        // Ex) Optional[int]
-                        SubscriptKind::AnnotatedSubscript => {
-                            self.visit_expr(value);
-                            self.visit_annotation(slice);
-                            self.visit_expr_context(ctx);
-                        }
-                        // Ex) Annotated[int, "Hello, world!"]
-                        SubscriptKind::PEP593AnnotatedSubscript => {
-                            // First argument is a type (including forward references); the rest are
-                            // arbitrary Python objects.
-                            self.visit_expr(value);
-                            if let ExprKind::Tuple { elts, ctx } = &slice.node {
-                                if let Some(expr) = elts.first() {
-                                    self.visit_expr(expr);
-                                    self.in_annotation = false;
-                                    for expr in elts.iter().skip(1) {
-                                        self.visit_expr(expr);
-                                    }
-                                    self.in_annotation = true;
+                // Only allow annotations in `ExprContext::Load`. If we have, e.g.,
+                // `obj["foo"]["bar"]`, we need to avoid treating the `obj["foo"]`
+                // portion as an annotation, despite having `ExprContext::Load`. Thus, we track
+                // the `ExprContext` at the top-level.
+                let prev_in_subscript = self.in_subscript;
+                if self.in_subscript {
+                    visitor::walk_expr(self, expr);
+                } else if matches!(ctx, ExprContext::Store | ExprContext::Del) {
+                    self.in_subscript = true;
+                    visitor::walk_expr(self, expr);
+                } else {
+                    self.in_subscript = true;
+                    match typing::match_annotated_subscript(value, &self.from_imports) {
+                        Some(subscript) => {
+                            match subscript {
+                                // Ex) Optional[int]
+                                SubscriptKind::AnnotatedSubscript => {
+                                    self.visit_expr(value);
+                                    self.visit_annotation(slice);
                                    self.visit_expr_context(ctx);
                                }
-                            } else {
-                                error!("Found non-ExprKind::Tuple argument to PEP 593 Annotation.")
+                                // Ex) Annotated[int, "Hello, world!"]
+                                SubscriptKind::PEP593AnnotatedSubscript => {
+                                    // First argument is a type (including forward references); the
+                                    // rest are arbitrary Python
+                                    // objects.
+                                    self.visit_expr(value);
+                                    if let ExprKind::Tuple { elts, ctx } = &slice.node {
+                                        if let Some(expr) = elts.first() {
+                                            self.visit_expr(expr);
+                                            self.in_annotation = false;
+                                            for expr in elts.iter().skip(1) {
+                                                self.visit_expr(expr);
+                                            }
+                                            self.in_annotation = true;
+                                            self.visit_expr_context(ctx);
+                                        }
+                                    } else {
+                                        error!(
+                                            "Found non-ExprKind::Tuple argument to PEP 593 \
+                                             Annotation."
+                                        )
+                                    }
+                                }
                            }
                        }
-                    },
-                    None => visitor::walk_expr(self, expr),
+                        None => visitor::walk_expr(self, expr),
+                    }
                }
+                self.in_subscript = prev_in_subscript;
            }
            _ => visitor::walk_expr(self, expr),
        }
@@ -1503,8 +1668,15 @@ where
            self.checks
                .extend(pyflakes::checks::duplicate_arguments(arguments));
        }
+        if self.settings.enabled.contains(&CheckCode::B006) {
+            flake8_bugbear::plugins::mutable_argument_default(self, arguments)
+        }
+        if self.settings.enabled.contains(&CheckCode::B008) {
+            flake8_bugbear::plugins::function_call_argument_default(self, arguments)
+        }

-        // Bind, but intentionally avoid walking default expressions, as we handle them upstream.
+        // Bind, but intentionally avoid walking default expressions, as we handle them
+        // upstream.
        for arg in &arguments.posonlyargs {
            self.visit_arg(arg);
        }
@@ -1523,7 +1695,8 @@ where
    }

    fn visit_arg(&mut self, arg: &'b Arg) {
-        // Bind, but intentionally avoid walking the annotation, as we handle it upstream.
+        // Bind, but intentionally avoid walking the annotation, as we handle it
+        // upstream.
        self.add_binding(
            arg.node.arg.to_string(),
            Binding {
@@ -1565,8 +1738,9 @@ fn try_mark_used(scope: &mut Scope, scope_id: usize, id: &str, expr: &Expr) -> b
        // Mark the binding as used.
        binding.used = Some((scope_id, Range::from_located(expr)));

-        // If the name of the sub-importation is the same as an alias of another importation and the
-        // alias is used, that sub-importation should be marked as used too.
+        // If the name of the sub-importation is the same as an alias of another
+        // importation and the alias is used, that sub-importation should be
+        // marked as used too.
        //
        // This handles code like:
        //   import pyarrow as pa
@@ -1676,7 +1850,8 @@ impl<'a> Checker<'a> {
    fn add_binding(&mut self, name: String, binding: Binding) {
        let scope = &mut self.scopes[*(self.scope_stack.last().expect("No current scope found."))];

-        // TODO(charlie): Don't treat annotations as assignments if there is an existing value.
+        // TODO(charlie): Don't treat annotations as assignments if there is an existing
+        // value.
        let binding = match scope.values.get(&name) {
            None => binding,
            Some(existing) => {
--- a/src/check_lines.rs
+++ b/src/check_lines.rs
@@ -5,8 +5,7 @@ use std::collections::BTreeMap;
 use rustpython_parser::ast::Location;

 use crate::ast::types::Range;
-use crate::autofix::fixer;
-use crate::autofix::Fix;
+use crate::autofix::{fixer, Fix};
 use crate::checks::{Check, CheckCode, CheckKind};
 use crate::noqa;
 use crate::noqa::Directive;
@@ -68,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)
                    }
@@ -94,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) => {
@@ -118,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
@@ -140,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) => {
@@ -164,14 +163,14 @@ 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 autofix.patch() {
                            check.amend(Fix::deletion(
-                                Location::new(row + 1, start + 1),
-                                Location::new(row + 1, lines[row].chars().count() + 1),
+                                Location::new(row + 1, start),
+                                Location::new(row + 1, lines[row].chars().count()),
                            ));
                        }
                        line_checks.push(check);
@@ -192,21 +191,21 @@ 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 autofix.patch() {
                            if valid_codes.is_empty() {
                                check.amend(Fix::deletion(
-                                    Location::new(row + 1, start + 1),
-                                    Location::new(row + 1, lines[row].chars().count() + 1),
+                                    Location::new(row + 1, start),
+                                    Location::new(row + 1, lines[row].chars().count()),
                                ));
                            } else {
                                check.amend(Fix::replacement(
                                    format!("  # noqa: {}", valid_codes.join(", ")),
-                                    Location::new(row + 1, start + 1),
-                                    Location::new(row + 1, lines[row].chars().count() + 1),
+                                    Location::new(row + 1, start),
+                                    Location::new(row + 1, lines[row].chars().count()),
                                ));
                            }
                        }
@@ -227,12 +226,11 @@ pub fn check_lines(

 #[cfg(test)]
 mod tests {
+    use super::check_lines;
    use crate::autofix::fixer;
    use crate::checks::{Check, CheckCode};
    use crate::settings::Settings;

-    use super::check_lines;
-
    #[test]
    fn e501_non_ascii_char() {
        let line = "'\u{4e9c}' * 2"; // 7 in UTF-32, 9 in UTF-8.
--- a/src/check_tokens.rs
+++ b/src/check_tokens.rs
@@ -2,37 +2,54 @@

 use rustpython_parser::lexer::{LexResult, Tok};

-use crate::ast::operations::SourceCodeLocator;
+use crate::autofix::fixer;
 use crate::checks::{Check, CheckCode};
-use crate::flake8_quotes::docstring_detection::StateMachine;
-use crate::{flake8_quotes, pycodestyle, Settings};
+use crate::lex::docstring_detection::StateMachine;
+use crate::source_code_locator::SourceCodeLocator;
+use crate::{flake8_quotes, pycodestyle, rules, Settings};

 pub fn check_tokens(
    checks: &mut Vec<Check>,
    locator: &SourceCodeLocator,
    tokens: &[LexResult],
    settings: &Settings,
+    autofix: &fixer::Mode,
 ) {
-    let enforce_invalid_escape_sequence = settings.enabled.contains(&CheckCode::W605);
+    let enforce_ambiguous_unicode_character = settings.enabled.contains(&CheckCode::RUF001)
+        || settings.enabled.contains(&CheckCode::RUF002);
    let enforce_quotes = settings.enabled.contains(&CheckCode::Q000)
-        | settings.enabled.contains(&CheckCode::Q001)
-        | settings.enabled.contains(&CheckCode::Q002)
-        | settings.enabled.contains(&CheckCode::Q003);
+        || settings.enabled.contains(&CheckCode::Q001)
+        || settings.enabled.contains(&CheckCode::Q002)
+        || settings.enabled.contains(&CheckCode::Q003);
+    let enforce_invalid_escape_sequence = settings.enabled.contains(&CheckCode::W605);

-    let mut state_machine = StateMachine::new();
+    let mut state_machine: StateMachine = Default::default();
    for (start, tok, end) in tokens.iter().flatten() {
-        // W605
-        if enforce_invalid_escape_sequence {
+        let is_docstring = if enforce_ambiguous_unicode_character || enforce_quotes {
+            state_machine.consume(tok)
+        } else {
+            false
+        };
+
+        // RUF001, RUF002
+        if enforce_ambiguous_unicode_character {
            if matches!(tok, Tok::String { .. }) {
-                checks.extend(pycodestyle::checks::invalid_escape_sequence(
-                    locator, start, end,
-                ));
+                for check in rules::checks::ambiguous_unicode_character(
+                    locator,
+                    start,
+                    end,
+                    is_docstring,
+                    autofix.patch(),
+                ) {
+                    if settings.enabled.contains(check.kind.code()) {
+                        checks.push(check);
+                    }
+                }
            }
        }

        // 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,
@@ -47,5 +64,14 @@ pub fn check_tokens(
                }
            }
        }
+
+        // W605
+        if enforce_invalid_escape_sequence {
+            if matches!(tok, Tok::String { .. }) {
+                checks.extend(pycodestyle::checks::invalid_escape_sequence(
+                    locator, start, end,
+                ));
+            }
+        }
    }
 }
--- a/src/checks.rs
+++ b/src/checks.rs
@@ -78,11 +78,17 @@ pub enum CheckCode {
    A003,
    // flake8-bugbear
    B002,
+    B003,
+    B006,
    B007,
+    B008,
    B011,
    B013,
    B014,
+    B015,
+    B016,
    B017,
+    B018,
    B025,
    // flake8-comprehensions
    C400,
@@ -179,6 +185,9 @@ pub enum CheckCode {
    N816,
    N817,
    N818,
+    // Ruff
+    RUF001,
+    RUF002,
    // Meta
    M001,
 }
@@ -196,6 +205,7 @@ pub enum CheckCategory {
    Flake8Builtins,
    Flake8Print,
    Flake8Quotes,
+    Ruff,
    Meta,
 }

@@ -213,6 +223,7 @@ impl CheckCategory {
            CheckCategory::Pyupgrade => "pyupgrade",
            CheckCategory::Pydocstyle => "pydocstyle",
            CheckCategory::PEP8Naming => "pep8-naming",
+            CheckCategory::Ruff => "Ruff-specific rules",
            CheckCategory::Meta => "Meta rules",
        }
    }
@@ -287,11 +298,17 @@ pub enum CheckKind {
    BuiltinAttributeShadowing(String),
    // flake8-bugbear
    UnaryPrefixIncrement,
+    AssignmentToOsEnviron,
+    MutableArgumentDefault,
    UnusedLoopControlVariable(String),
+    FunctionCallArgumentDefault,
    DoNotAssertFalse,
    RedundantTupleInExceptionHandler(String),
    DuplicateHandlerException(Vec<String>),
+    UselessComparison,
+    CannotRaiseLiteral,
    NoAssertRaisesException,
+    UselessExpression,
    DuplicateTryBlockException(String),
    // flake8-comprehensions
    UnnecessaryGeneratorList,
@@ -388,20 +405,26 @@ pub enum CheckKind {
    MixedCaseVariableInGlobalScope(String),
    CamelcaseImportedAsAcronym(String, String),
    ErrorSuffixOnExceptionName(String),
+    // Ruff
+    AmbiguousUnicodeCharacterString(char, char),
+    AmbiguousUnicodeCharacterDocstring(char, char),
    // 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::Q000
            | CheckCode::Q001
            | CheckCode::Q002
-            | CheckCode::Q003 => &LintSource::Tokens,
+            | CheckCode::Q003
+            | CheckCode::W605
+            | CheckCode::RUF001
+            | CheckCode::RUF002 => &LintSource::Tokens,
            CheckCode::E902 => &LintSource::FileSystem,
            _ => &LintSource::AST,
        }
@@ -465,13 +488,19 @@ impl CheckCode {
            CheckCode::A003 => CheckKind::BuiltinAttributeShadowing("...".to_string()),
            // flake8-bugbear
            CheckCode::B002 => CheckKind::UnaryPrefixIncrement,
+            CheckCode::B003 => CheckKind::AssignmentToOsEnviron,
+            CheckCode::B006 => CheckKind::MutableArgumentDefault,
            CheckCode::B007 => CheckKind::UnusedLoopControlVariable("i".to_string()),
+            CheckCode::B008 => CheckKind::FunctionCallArgumentDefault,
            CheckCode::B011 => CheckKind::DoNotAssertFalse,
            CheckCode::B013 => {
                CheckKind::RedundantTupleInExceptionHandler("ValueError".to_string())
            }
            CheckCode::B014 => CheckKind::DuplicateHandlerException(vec!["ValueError".to_string()]),
+            CheckCode::B015 => CheckKind::UselessComparison,
+            CheckCode::B016 => CheckKind::CannotRaiseLiteral,
            CheckCode::B017 => CheckKind::NoAssertRaisesException,
+            CheckCode::B018 => CheckKind::UselessExpression,
            CheckCode::B025 => CheckKind::DuplicateTryBlockException("Exception".to_string()),
            // flake8-comprehensions
            CheckCode::C400 => CheckKind::UnnecessaryGeneratorList,
@@ -600,6 +629,9 @@ impl CheckCode {
                CheckKind::CamelcaseImportedAsAcronym("...".to_string(), "...".to_string())
            }
            CheckCode::N818 => CheckKind::ErrorSuffixOnExceptionName("...".to_string()),
+            // Ruff
+            CheckCode::RUF001 => CheckKind::AmbiguousUnicodeCharacterString('𝐁', 'B'),
+            CheckCode::RUF002 => CheckKind::AmbiguousUnicodeCharacterDocstring('𝐁', 'B'),
            // Meta
            CheckCode::M001 => CheckKind::UnusedNOQA(None),
        }
@@ -655,11 +687,17 @@ impl CheckCode {
            CheckCode::A002 => CheckCategory::Flake8Builtins,
            CheckCode::A003 => CheckCategory::Flake8Builtins,
            CheckCode::B002 => CheckCategory::Flake8Bugbear,
+            CheckCode::B003 => CheckCategory::Flake8Bugbear,
+            CheckCode::B006 => CheckCategory::Flake8Bugbear,
            CheckCode::B007 => CheckCategory::Flake8Bugbear,
+            CheckCode::B008 => CheckCategory::Flake8Bugbear,
            CheckCode::B011 => CheckCategory::Flake8Bugbear,
            CheckCode::B013 => CheckCategory::Flake8Bugbear,
            CheckCode::B014 => CheckCategory::Flake8Bugbear,
+            CheckCode::B015 => CheckCategory::Flake8Bugbear,
+            CheckCode::B016 => CheckCategory::Flake8Bugbear,
            CheckCode::B017 => CheckCategory::Flake8Bugbear,
+            CheckCode::B018 => CheckCategory::Flake8Bugbear,
            CheckCode::B025 => CheckCategory::Flake8Bugbear,
            CheckCode::C400 => CheckCategory::Flake8Comprehensions,
            CheckCode::C401 => CheckCategory::Flake8Comprehensions,
@@ -750,6 +788,8 @@ impl CheckCode {
            CheckCode::N816 => CheckCategory::PEP8Naming,
            CheckCode::N817 => CheckCategory::PEP8Naming,
            CheckCode::N818 => CheckCategory::PEP8Naming,
+            CheckCode::RUF001 => CheckCategory::Ruff,
+            CheckCode::RUF002 => CheckCategory::Ruff,
            CheckCode::M001 => CheckCategory::Meta,
        }
    }
@@ -775,14 +815,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,
@@ -793,13 +833,13 @@ 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
@@ -811,11 +851,17 @@ impl CheckKind {
            CheckKind::BuiltinAttributeShadowing(_) => &CheckCode::A003,
            // flake8-bugbear
            CheckKind::UnaryPrefixIncrement => &CheckCode::B002,
+            CheckKind::AssignmentToOsEnviron => &CheckCode::B003,
+            CheckKind::MutableArgumentDefault => &CheckCode::B006,
            CheckKind::UnusedLoopControlVariable(_) => &CheckCode::B007,
+            CheckKind::FunctionCallArgumentDefault => &CheckCode::B008,
            CheckKind::DoNotAssertFalse => &CheckCode::B011,
            CheckKind::RedundantTupleInExceptionHandler(_) => &CheckCode::B013,
            CheckKind::DuplicateHandlerException(_) => &CheckCode::B014,
+            CheckKind::UselessComparison => &CheckCode::B015,
+            CheckKind::CannotRaiseLiteral => &CheckCode::B016,
            CheckKind::NoAssertRaisesException => &CheckCode::B017,
+            CheckKind::UselessExpression => &CheckCode::B018,
            CheckKind::DuplicateTryBlockException(_) => &CheckCode::B025,
            // flake8-comprehensions
            CheckKind::UnnecessaryGeneratorList => &CheckCode::C400,
@@ -846,7 +892,7 @@ impl CheckKind {
            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,
@@ -912,6 +958,9 @@ impl CheckKind {
            CheckKind::MixedCaseVariableInGlobalScope(..) => &CheckCode::N816,
            CheckKind::CamelcaseImportedAsAcronym(..) => &CheckCode::N817,
            CheckKind::ErrorSuffixOnExceptionName(..) => &CheckCode::N818,
+            // Ruff
+            CheckKind::AmbiguousUnicodeCharacterString(..) => &CheckCode::RUF001,
+            CheckKind::AmbiguousUnicodeCharacterDocstring(..) => &CheckCode::RUF002,
            // Meta
            CheckKind::UnusedNOQA(_) => &CheckCode::M001,
        }
@@ -1050,11 +1099,13 @@ impl CheckKind {
                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}'"),
+            CheckKind::InvalidEscapeSequence(char) => {
+                format!("Invalid escape sequence: '\\{char}'")
+            }
            // flake8-builtins
            CheckKind::BuiltinVariableShadowing(name) => {
                format!("Variable `{name}` is shadowing a python builtin")
@@ -1066,15 +1117,39 @@ impl CheckKind {
                format!("Class attribute `{name}` is shadowing a python builtin")
            }
            // flake8-bugbear
-            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::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::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::AssignmentToOsEnviron => {
+                "Assigning to `os.environ` doesn't clear the environment.".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::FunctionCallArgumentDefault => {
+                "Do not perform function calls in argument defaults.".to_string()
+            }
+            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},):`.")
+                format!(
+                    "A length-one tuple literal is redundant. Write `except {name}:` instead of \
+                     `except ({name},):`."
+                )
            }
+            CheckKind::UselessComparison => "Pointless comparison. This comparison does nothing \
+                                             but waste CPU instructions. Either prepend `assert` \
+                                             or remove it."
+                .to_string(),
+            CheckKind::CannotRaiseLiteral => "Cannot raise a literal. Did you intend to return it \
+                                              or raise an Exception?"
+                .to_string(),
            CheckKind::DuplicateHandlerException(names) => {
                if names.len() == 1 {
                    let name = &names[0];
@@ -1085,8 +1160,15 @@ impl CheckKind {
                }
            }
            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()
-           }
+                "`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::UselessExpression => {
+                "Found useless expression. Either assign it to a variable or remove it.".to_string()
+            }
            CheckKind::DuplicateTryBlockException(name) => {
                format!("try-except block with duplicate exception `{name}`")
            }
@@ -1118,22 +1200,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)"
                    )
                }
            }
@@ -1163,25 +1249,29 @@ impl CheckKind {
            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::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::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::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(),
+            CheckKind::AvoidQuoteEscape => {
+                "Change outer quotes to avoid escaping inner quotes".to_string()
+            }
            // pyupgrade
            CheckKind::TypeOfPrimitive(primitive) => {
                format!("Use `{}` instead of `type(...)`", primitive.builtin())
@@ -1191,7 +1281,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")
@@ -1220,10 +1310,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()
            }
@@ -1261,10 +1350,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}\")")
@@ -1285,7 +1374,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}\")")
@@ -1365,6 +1457,19 @@ impl CheckKind {
            CheckKind::ErrorSuffixOnExceptionName(name) => {
                format!("Exception name `{name}` should be named with an Error suffix")
            }
+            // Ruff
+            CheckKind::AmbiguousUnicodeCharacterString(confusable, representant) => {
+                format!(
+                    "String contains ambiguous unicode character '{confusable}' (did you mean \
+                     '{representant}'?)"
+                )
+            }
+            CheckKind::AmbiguousUnicodeCharacterDocstring(confusable, representant) => {
+                format!(
+                    "Docstring contains ambiguous unicode character '{confusable}' (did you mean \
+                     '{representant}'?)"
+                )
+            }
            // Meta
            CheckKind::UnusedNOQA(codes) => match codes {
                None => "Unused `noqa` directive".to_string(),
@@ -1385,7 +1490,8 @@ impl CheckKind {
        }
    }

-    /// The summary text for the check. Typically a truncated form of the body text.
+    /// The summary text for the check. Typically a truncated form of the body
+    /// text.
    pub fn summary(&self) -> String {
        match self {
            CheckKind::UnaryPrefixIncrement => {
@@ -1405,7 +1511,9 @@ impl CheckKind {
    pub fn fixable(&self) -> bool {
        matches!(
            self,
-            CheckKind::BlankLineAfterLastSection(_)
+            CheckKind::AmbiguousUnicodeCharacterString(_, _)
+                | CheckKind::AmbiguousUnicodeCharacterDocstring(_, _)
+                | CheckKind::BlankLineAfterLastSection(_)
                | CheckKind::BlankLineAfterSection(_)
                | CheckKind::BlankLineAfterSummary
                | CheckKind::BlankLineBeforeSection(_)
@@ -1427,6 +1535,7 @@ impl CheckKind {
                | CheckKind::OneBlankLineBeforeClass(_)
                | CheckKind::PPrintFound
                | CheckKind::PrintFound
+                | CheckKind::RaiseNotImplemented
                | CheckKind::SectionNameEndsInColon(_)
                | CheckKind::SectionNotOverIndented(_)
                | CheckKind::SectionUnderlineAfterName(_)
@@ -1435,6 +1544,17 @@ impl CheckKind {
                | CheckKind::SuperCallWithParameters
                | CheckKind::TypeOfPrimitive(_)
                | CheckKind::UnnecessaryAbspath
+                | CheckKind::UnnecessaryCollectionCall(_)
+                | CheckKind::UnnecessaryComprehension(_)
+                | CheckKind::UnnecessaryGeneratorDict
+                | CheckKind::UnnecessaryGeneratorList
+                | CheckKind::UnnecessaryGeneratorSet
+                | CheckKind::UnnecessaryListCall
+                | CheckKind::UnnecessaryListComprehensionSet
+                | CheckKind::UnnecessaryLiteralDict(_)
+                | CheckKind::UnnecessaryLiteralSet(_)
+                | CheckKind::UnnecessaryLiteralWithinListCall(_)
+                | CheckKind::UnnecessaryLiteralWithinTupleCall(_)
                | CheckKind::UnusedImport(_, false)
                | CheckKind::UnusedLoopControlVariable(_)
                | CheckKind::UnusedNOQA(_)
--- a/src/checks_gen.rs
+++ b/src/checks_gen.rs
@@ -5,7 +5,7 @@ use strum_macros::EnumString;

 use crate::checks::CheckCode;

-#[derive(EnumString, Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+#[derive(EnumString, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Serialize, Deserialize)]
 pub enum CheckCodePrefix {
    A,
    A0,
@@ -17,12 +17,18 @@ pub enum CheckCodePrefix {
    B0,
    B00,
    B002,
+    B003,
+    B006,
    B007,
+    B008,
    B01,
    B011,
    B013,
    B014,
+    B015,
+    B016,
    B017,
+    B018,
    B02,
    B025,
    C,
@@ -203,6 +209,11 @@ pub enum CheckCodePrefix {
    Q001,
    Q002,
    Q003,
+    RUF,
+    RUF0,
+    RUF00,
+    RUF001,
+    RUF002,
    T,
    T2,
    T20,
@@ -247,35 +258,62 @@ impl CheckCodePrefix {
            CheckCodePrefix::A003 => vec![CheckCode::A003],
            CheckCodePrefix::B => vec![
                CheckCode::B002,
+                CheckCode::B003,
+                CheckCode::B006,
                CheckCode::B007,
+                CheckCode::B008,
                CheckCode::B011,
                CheckCode::B013,
                CheckCode::B014,
+                CheckCode::B015,
+                CheckCode::B016,
                CheckCode::B017,
+                CheckCode::B018,
                CheckCode::B025,
            ],
            CheckCodePrefix::B0 => vec![
                CheckCode::B002,
+                CheckCode::B003,
+                CheckCode::B006,
                CheckCode::B007,
+                CheckCode::B008,
                CheckCode::B011,
                CheckCode::B013,
                CheckCode::B014,
+                CheckCode::B015,
+                CheckCode::B016,
                CheckCode::B017,
+                CheckCode::B018,
                CheckCode::B025,
            ],
-            CheckCodePrefix::B00 => vec![CheckCode::B002, CheckCode::B007],
+            CheckCodePrefix::B00 => vec![
+                CheckCode::B002,
+                CheckCode::B003,
+                CheckCode::B006,
+                CheckCode::B007,
+                CheckCode::B008,
+            ],
            CheckCodePrefix::B002 => vec![CheckCode::B002],
+            CheckCodePrefix::B003 => vec![CheckCode::B003],
+            CheckCodePrefix::B006 => vec![CheckCode::B006],
            CheckCodePrefix::B007 => vec![CheckCode::B007],
+            CheckCodePrefix::B008 => vec![CheckCode::B008],
            CheckCodePrefix::B01 => vec![
                CheckCode::B011,
                CheckCode::B013,
                CheckCode::B014,
+                CheckCode::B015,
+                CheckCode::B016,
                CheckCode::B017,
+                CheckCode::B018,
            ],
            CheckCodePrefix::B011 => vec![CheckCode::B011],
            CheckCodePrefix::B013 => vec![CheckCode::B013],
            CheckCodePrefix::B014 => vec![CheckCode::B014],
+            CheckCodePrefix::B015 => vec![CheckCode::B015],
+            CheckCodePrefix::B016 => vec![CheckCode::B016],
            CheckCodePrefix::B017 => vec![CheckCode::B017],
+            CheckCodePrefix::B018 => vec![CheckCode::B018],
            CheckCodePrefix::B02 => vec![CheckCode::B025],
            CheckCodePrefix::B025 => vec![CheckCode::B025],
            CheckCodePrefix::C => vec![
@@ -820,6 +858,11 @@ impl CheckCodePrefix {
            CheckCodePrefix::Q001 => vec![CheckCode::Q001],
            CheckCodePrefix::Q002 => vec![CheckCode::Q002],
            CheckCodePrefix::Q003 => vec![CheckCode::Q003],
+            CheckCodePrefix::RUF => vec![CheckCode::RUF001, CheckCode::RUF002],
+            CheckCodePrefix::RUF0 => vec![CheckCode::RUF001, CheckCode::RUF002],
+            CheckCodePrefix::RUF00 => vec![CheckCode::RUF001, CheckCode::RUF002],
+            CheckCodePrefix::RUF001 => vec![CheckCode::RUF001],
+            CheckCodePrefix::RUF002 => vec![CheckCode::RUF002],
            CheckCodePrefix::T => vec![CheckCode::T201, CheckCode::T203],
            CheckCodePrefix::T2 => vec![CheckCode::T201, CheckCode::T203],
            CheckCodePrefix::T20 => vec![CheckCode::T201, CheckCode::T203],
@@ -887,12 +930,18 @@ impl CheckCodePrefix {
            CheckCodePrefix::B0 => PrefixSpecificity::Hundreds,
            CheckCodePrefix::B00 => PrefixSpecificity::Tens,
            CheckCodePrefix::B002 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B003 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B006 => PrefixSpecificity::Explicit,
            CheckCodePrefix::B007 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B008 => PrefixSpecificity::Explicit,
            CheckCodePrefix::B01 => PrefixSpecificity::Tens,
            CheckCodePrefix::B011 => PrefixSpecificity::Explicit,
            CheckCodePrefix::B013 => PrefixSpecificity::Explicit,
            CheckCodePrefix::B014 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B015 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B016 => PrefixSpecificity::Explicit,
            CheckCodePrefix::B017 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B018 => PrefixSpecificity::Explicit,
            CheckCodePrefix::B02 => PrefixSpecificity::Tens,
            CheckCodePrefix::B025 => PrefixSpecificity::Explicit,
            CheckCodePrefix::C => PrefixSpecificity::Category,
@@ -1073,6 +1122,11 @@ impl CheckCodePrefix {
            CheckCodePrefix::Q001 => PrefixSpecificity::Explicit,
            CheckCodePrefix::Q002 => PrefixSpecificity::Explicit,
            CheckCodePrefix::Q003 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::RUF => PrefixSpecificity::Category,
+            CheckCodePrefix::RUF0 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::RUF00 => PrefixSpecificity::Tens,
+            CheckCodePrefix::RUF001 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::RUF002 => PrefixSpecificity::Explicit,
            CheckCodePrefix::T => PrefixSpecificity::Category,
            CheckCodePrefix::T2 => PrefixSpecificity::Hundreds,
            CheckCodePrefix::T20 => PrefixSpecificity::Tens,
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -1,3 +1,4 @@
+use std::collections::BTreeMap;
 use std::fmt;
 use std::path::PathBuf;

@@ -6,10 +7,10 @@ use log::warn;
 use regex::Regex;

 use crate::checks_gen::CheckCodePrefix;
+use crate::logging::LogLevel;
 use crate::printer::SerializationFormat;
 use crate::settings::configuration::Configuration;
-use crate::settings::types::PythonVersion;
-use crate::settings::types::StrCheckCodePair;
+use crate::settings::types::{PatternPrefixPair, PythonVersion};

 #[derive(Debug, Parser)]
 #[command(author, about = "ruff: An extremely fast Python linter.")]
@@ -26,7 +27,8 @@ pub struct Cli {
    /// Only log errors.
    #[arg(short, long, group = "verbosity")]
    pub quiet: bool,
-    /// Disable all logging (but still exit with status code "1" upon detecting errors).
+    /// 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.
@@ -44,24 +46,27 @@ pub struct Cli {
    /// List of error codes to enable.
    #[arg(long, value_delimiter = ',')]
    pub select: Vec<CheckCodePrefix>,
-    /// Like --select, but adds additional error codes on top of the selected ones.
+    /// Like --select, but adds additional error codes on top of the selected
+    /// ones.
    #[arg(long, value_delimiter = ',')]
    pub extend_select: Vec<CheckCodePrefix>,
    /// List of error codes to ignore.
    #[arg(long, value_delimiter = ',')]
    pub ignore: Vec<CheckCodePrefix>,
-    /// Like --ignore, but adds additional error codes on top of the ignored ones.
+    /// Like --ignore, but adds additional error codes on top of the ignored
+    /// ones.
    #[arg(long, value_delimiter = ',')]
    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,
@@ -89,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,
@@ -138,8 +156,25 @@ pub fn warn_on(
                    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
+}
--- a/src/cst/matchers.rs
+++ b/src/cst/matchers.rs
@@ -0,0 +1,9 @@
+use anyhow::Result;
+use libcst_native::Module;
+
+pub fn match_module(module_text: &str) -> Result<Module> {
+    match libcst_native::parse_module(module_text, None) {
+        Ok(module) => Ok(module),
+        Err(_) => Err(anyhow::anyhow!("Failed to extract CST from source.")),
+    }
+}
--- a/src/cst/mod.rs
+++ b/src/cst/mod.rs
@@ -1 +1,2 @@
 pub mod helpers;
+pub mod matchers;
--- a/src/docstrings/helpers.rs
+++ b/src/docstrings/helpers.rs
@@ -25,12 +25,15 @@ pub fn leading_space(line: &str) -> String {
 }

 /// Extract the leading indentation from a docstring.
-pub fn indentation<'a>(checker: &'a Checker, docstring: &Expr) -> &'a str {
+pub fn indentation<'a>(checker: &'a Checker, docstring: &Expr) -> String {
    let range = Range::from_located(docstring);
-    checker.locator.slice_source_code_range(&Range {
-        location: Location::new(range.location.row(), 1),
-        end_location: Location::new(range.location.row(), range.location.column()),
-    })
+    checker
+        .locator
+        .slice_source_code_range(&Range {
+            location: Location::new(range.location.row(), 0),
+            end_location: Location::new(range.location.row(), range.location.column()),
+        })
+        .to_string()
 }

 /// Replace any non-whitespace characters from an indentation string.
--- a/src/flake8_bugbear/plugins/assert_false.rs
+++ b/src/flake8_bugbear/plugins/assert_false.rs
@@ -1,6 +1,6 @@
 use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Stmt, StmtKind};

-use crate::ast::types::Range;
+use crate::ast::types::{CheckLocator, Range};
 use crate::autofix::Fix;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
@@ -42,7 +42,10 @@ pub fn assert_false(checker: &mut Checker, stmt: &Stmt, test: &Expr, msg: &Optio
        ..
    } = &test.node
    {
-        let mut check = Check::new(CheckKind::DoNotAssertFalse, Range::from_located(test));
+        let mut check = Check::new(
+            CheckKind::DoNotAssertFalse,
+            checker.locate_check(Range::from_located(test)),
+        );
        if checker.patch() {
            let mut generator = SourceGenerator::new();
            if let Ok(()) = generator.unparse_stmt(&assertion_error(msg)) {
--- a/src/flake8_bugbear/plugins/assert_raises_exception.rs
+++ b/src/flake8_bugbear/plugins/assert_raises_exception.rs
@@ -1,7 +1,7 @@
 use rustpython_ast::{ExprKind, Stmt, Withitem};

 use crate::ast::helpers::match_name_or_attr;
-use crate::ast::types::Range;
+use crate::ast::types::{CheckLocator, Range};
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};

@@ -17,7 +17,7 @@ pub fn assert_raises_exception(checker: &mut Checker, stmt: &Stmt, items: &[With
            {
                checker.add_check(Check::new(
                    CheckKind::NoAssertRaisesException,
-                    Range::from_located(stmt),
+                    checker.locate_check(Range::from_located(stmt)),
                ));
            }
        }
--- a/src/flake8_bugbear/plugins/assignment_to_os_environ.rs
+++ b/src/flake8_bugbear/plugins/assignment_to_os_environ.rs
@@ -0,0 +1,24 @@
+use rustpython_ast::{Expr, ExprKind};
+
+use crate::ast::types::{CheckLocator, Range};
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B003
+pub fn assignment_to_os_environ(checker: &mut Checker, targets: &[Expr]) {
+    if targets.len() == 1 {
+        let target = &targets[0];
+        if let ExprKind::Attribute { value, attr, .. } = &target.node {
+            if attr == "environ" {
+                if let ExprKind::Name { id, .. } = &value.node {
+                    if id == "os" {
+                        checker.add_check(Check::new(
+                            CheckKind::AssignmentToOsEnviron,
+                            checker.locate_check(Range::from_located(target)),
+                        ));
+                    }
+                }
+            }
+        }
+    }
+}
--- a/src/flake8_bugbear/plugins/cannot_raise_literal.rs
+++ b/src/flake8_bugbear/plugins/cannot_raise_literal.rs
@@ -0,0 +1,15 @@
+use rustpython_ast::{Expr, ExprKind};
+
+use crate::ast::types::{CheckLocator, Range};
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B016
+pub fn cannot_raise_literal(checker: &mut Checker, expr: &Expr) {
+    if let ExprKind::Constant { .. } = &expr.node {
+        checker.add_check(Check::new(
+            CheckKind::CannotRaiseLiteral,
+            checker.locate_check(Range::from_located(expr)),
+        ));
+    }
+}
--- a/src/flake8_bugbear/plugins/function_call_argument_default.rs
+++ b/src/flake8_bugbear/plugins/function_call_argument_default.rs
@@ -0,0 +1,96 @@
+use rustpython_ast::{Arguments, Constant, Expr, ExprKind};
+
+use crate::ast::helpers::compose_call_path;
+use crate::ast::types::{CheckLocator, Range};
+use crate::ast::visitor;
+use crate::ast::visitor::Visitor;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+use crate::flake8_bugbear::plugins::mutable_argument_default::is_mutable_func;
+
+const IMMUTABLE_FUNCS: [&str; 11] = [
+    "tuple",
+    "frozenset",
+    "operator.attrgetter",
+    "operator.itemgetter",
+    "operator.methodcaller",
+    "attrgetter",
+    "itemgetter",
+    "methodcaller",
+    "types.MappingProxyType",
+    "MappingProxyType",
+    "re.compile",
+];
+
+fn is_immutable_func(expr: &Expr) -> bool {
+    compose_call_path(expr).map_or_else(|| false, |func| IMMUTABLE_FUNCS.contains(&func.as_str()))
+}
+
+struct ArgumentDefaultVisitor {
+    checks: Vec<(CheckKind, Range)>,
+}
+
+impl<'a, 'b> Visitor<'b> for ArgumentDefaultVisitor
+where
+    'b: 'a,
+{
+    fn visit_expr(&mut self, expr: &'a Expr) {
+        match &expr.node {
+            ExprKind::Call { func, args, .. } => {
+                if !is_mutable_func(func)
+                    && !is_immutable_func(func)
+                    && !is_nan_or_infinity(func, args)
+                {
+                    self.checks.push((
+                        CheckKind::FunctionCallArgumentDefault,
+                        Range::from_located(expr),
+                    ))
+                }
+                visitor::walk_expr(self, expr)
+            }
+            ExprKind::Lambda { .. } => {}
+            _ => visitor::walk_expr(self, expr),
+        }
+    }
+}
+
+fn is_nan_or_infinity(expr: &Expr, args: &[Expr]) -> bool {
+    if let ExprKind::Name { id, .. } = &expr.node {
+        if id == "float" {
+            if let Some(arg) = args.first() {
+                if let ExprKind::Constant {
+                    value: Constant::Str(value),
+                    ..
+                } = &arg.node
+                {
+                    let lowercased = value.to_lowercase();
+                    return lowercased == "nan"
+                        || lowercased == "+nan"
+                        || lowercased == "-nan"
+                        || lowercased == "inf"
+                        || lowercased == "+inf"
+                        || lowercased == "-inf"
+                        || lowercased == "infinity"
+                        || lowercased == "+infinity"
+                        || lowercased == "-infinity";
+                }
+            }
+        }
+    }
+    false
+}
+
+/// B008
+pub fn function_call_argument_default(checker: &mut Checker, arguments: &Arguments) {
+    let mut visitor = ArgumentDefaultVisitor { checks: vec![] };
+    for expr in arguments
+        .defaults
+        .iter()
+        .chain(arguments.kw_defaults.iter())
+    {
+        visitor.visit_expr(expr);
+    }
+    for (check, range) in visitor.checks {
+        checker.add_check(Check::new(check, checker.locate_check(range)));
+    }
+}
--- a/src/flake8_bugbear/plugins/mod.rs
+++ b/src/flake8_bugbear/plugins/mod.rs
@@ -1,14 +1,25 @@
 pub use assert_false::assert_false;
 pub use assert_raises_exception::assert_raises_exception;
-pub use duplicate_exceptions::duplicate_exceptions;
-pub use duplicate_exceptions::duplicate_handler_exceptions;
+pub use assignment_to_os_environ::assignment_to_os_environ;
+pub use cannot_raise_literal::cannot_raise_literal;
+pub use duplicate_exceptions::{duplicate_exceptions, duplicate_handler_exceptions};
+pub use function_call_argument_default::function_call_argument_default;
+pub use mutable_argument_default::mutable_argument_default;
 pub use redundant_tuple_in_exception_handler::redundant_tuple_in_exception_handler;
 pub use unary_prefix_increment::unary_prefix_increment;
 pub use unused_loop_control_variable::unused_loop_control_variable;
+pub use useless_comparison::useless_comparison;
+pub use useless_expression::useless_expression;

 mod assert_false;
 mod assert_raises_exception;
+mod assignment_to_os_environ;
+mod cannot_raise_literal;
 mod duplicate_exceptions;
+mod function_call_argument_default;
+mod mutable_argument_default;
 mod redundant_tuple_in_exception_handler;
 mod unary_prefix_increment;
 mod unused_loop_control_variable;
+mod useless_comparison;
+mod useless_expression;
--- a/src/flake8_bugbear/plugins/mutable_argument_default.rs
+++ b/src/flake8_bugbear/plugins/mutable_argument_default.rs
@@ -0,0 +1,62 @@
+use rustpython_ast::{Arguments, Expr, ExprKind};
+
+use crate::ast::types::{CheckLocator, Range};
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+pub fn is_mutable_func(expr: &Expr) -> bool {
+    match &expr.node {
+        ExprKind::Name { id, .. }
+            if id == "dict"
+                || id == "list"
+                || id == "set"
+                || id == "Counter"
+                || id == "OrderedDict"
+                || id == "defaultdict"
+                || id == "deque" =>
+        {
+            true
+        }
+        ExprKind::Attribute { value, attr, .. }
+            if (attr == "Counter"
+                || attr == "OrderedDict"
+                || attr == "defaultdict"
+                || attr == "deque") =>
+        {
+            matches!(&value.node, ExprKind::Name { id, .. } if id == "collections")
+        }
+        _ => false,
+    }
+}
+
+/// B006
+pub fn mutable_argument_default(checker: &mut Checker, arguments: &Arguments) {
+    for expr in arguments
+        .defaults
+        .iter()
+        .chain(arguments.kw_defaults.iter())
+    {
+        match &expr.node {
+            ExprKind::List { .. }
+            | ExprKind::Dict { .. }
+            | ExprKind::Set { .. }
+            | ExprKind::ListComp { .. }
+            | ExprKind::DictComp { .. }
+            | ExprKind::SetComp { .. } => {
+                checker.add_check(Check::new(
+                    CheckKind::MutableArgumentDefault,
+                    checker.locate_check(Range::from_located(expr)),
+                ));
+            }
+            ExprKind::Call { func, .. } => {
+                if is_mutable_func(func) {
+                    checker.add_check(Check::new(
+                        CheckKind::MutableArgumentDefault,
+                        checker.locate_check(Range::from_located(expr)),
+                    ));
+                }
+            }
+            _ => {}
+        }
+    }
+}
--- a/src/flake8_bugbear/plugins/unary_prefix_increment.rs
+++ b/src/flake8_bugbear/plugins/unary_prefix_increment.rs
@@ -1,6 +1,6 @@
 use rustpython_ast::{Expr, ExprKind, Unaryop};

-use crate::ast::types::Range;
+use crate::ast::types::{CheckLocator, Range};
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};

@@ -11,7 +11,7 @@ pub fn unary_prefix_increment(checker: &mut Checker, expr: &Expr, op: &Unaryop,
            if matches!(op, Unaryop::UAdd) {
                checker.add_check(Check::new(
                    CheckKind::UnaryPrefixIncrement,
-                    Range::from_located(expr),
+                    checker.locate_check(Range::from_located(expr)),
                ))
            }
        }
--- a/src/flake8_bugbear/plugins/unused_loop_control_variable.rs
+++ b/src/flake8_bugbear/plugins/unused_loop_control_variable.rs
@@ -2,7 +2,7 @@ use std::collections::BTreeMap;

 use rustpython_ast::{Expr, ExprKind, Stmt};

-use crate::ast::types::Range;
+use crate::ast::types::{CheckLocator, Range};
 use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
 use crate::autofix::Fix;
@@ -64,7 +64,7 @@ pub fn unused_loop_control_variable(checker: &mut Checker, target: &Expr, body:

        let mut check = Check::new(
            CheckKind::UnusedLoopControlVariable(name.to_string()),
-            Range::from_located(expr),
+            checker.locate_check(Range::from_located(expr)),
        );
        if checker.patch() {
            // Prefix the variable name with an underscore.
--- a/src/flake8_bugbear/plugins/useless_comparison.rs
+++ b/src/flake8_bugbear/plugins/useless_comparison.rs
@@ -0,0 +1,14 @@
+use rustpython_ast::{Expr, Stmt, StmtKind};
+
+use crate::ast::types::{CheckLocator, Range};
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+pub fn useless_comparison(checker: &mut Checker, expr: &Expr, parent: &Stmt) {
+    if let StmtKind::Expr { .. } = &parent.node {
+        checker.add_check(Check::new(
+            CheckKind::UselessComparison,
+            checker.locate_check(Range::from_located(expr)),
+        ));
+    }
+}
--- a/src/flake8_bugbear/plugins/useless_expression.rs
+++ b/src/flake8_bugbear/plugins/useless_expression.rs
@@ -0,0 +1,31 @@
+use rustpython_ast::{Constant, ExprKind, Stmt, StmtKind};
+
+use crate::ast::types::{CheckLocator, Range};
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+// B018
+pub fn useless_expression(checker: &mut Checker, body: &[Stmt]) {
+    for stmt in body {
+        if let StmtKind::Expr { value } = &stmt.node {
+            match &value.node {
+                ExprKind::List { .. } | ExprKind::Dict { .. } | ExprKind::Set { .. } => {
+                    checker.add_check(Check::new(
+                        CheckKind::UselessExpression,
+                        checker.locate_check(Range::from_located(value)),
+                    ));
+                }
+                ExprKind::Constant { value: val, .. } => match &val {
+                    Constant::Str { .. } | Constant::Ellipsis => {}
+                    _ => {
+                        checker.add_check(Check::new(
+                            CheckKind::UselessExpression,
+                            checker.locate_check(Range::from_located(value)),
+                        ));
+                    }
+                },
+                _ => {}
+            }
+        }
+    }
+}
--- a/src/flake8_comprehensions/checks.rs
+++ b/src/flake8_comprehensions/checks.rs
@@ -1,8 +1,13 @@
+use log::error;
 use num_bigint::BigInt;
-use rustpython_ast::{Comprehension, Constant, Expr, ExprKind, KeywordData, Located, Unaryop};
+use rustpython_ast::{
+    Comprehension, Constant, Expr, ExprKind, Keyword, KeywordData, Located, Unaryop,
+};

 use crate::ast::types::Range;
 use crate::checks::{Check, CheckKind};
+use crate::flake8_comprehensions::fixes;
+use crate::source_code_locator::SourceCodeLocator;

 fn function_name(func: &Expr) -> Option<&str> {
    if let ExprKind::Name { id, .. } = &func.node {
@@ -16,7 +21,11 @@ fn exactly_one_argument_with_matching_function<'a>(
    name: &str,
    func: &Expr,
    args: &'a [Expr],
+    keywords: &[Keyword],
 ) -> Option<&'a ExprKind> {
+    if !keywords.is_empty() {
+        return None;
+    }
    if args.len() != 1 {
        return None;
    }
@@ -38,39 +47,75 @@ fn first_argument_with_matching_function<'a>(
 }

 /// C400 (`list(generator)`)
-pub fn unnecessary_generator_list(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
-    let argument = exactly_one_argument_with_matching_function("list", func, args)?;
+pub fn unnecessary_generator_list(
+    expr: &Expr,
+    func: &Expr,
+    args: &[Expr],
+    keywords: &[Keyword],
+    locator: &SourceCodeLocator,
+    fix: bool,
+    location: Range,
+) -> Option<Check> {
+    let argument = exactly_one_argument_with_matching_function("list", func, args, keywords)?;
    if let ExprKind::GeneratorExp { .. } = argument {
-        return Some(Check::new(
-            CheckKind::UnnecessaryGeneratorList,
-            Range::from_located(expr),
-        ));
+        let mut check = Check::new(CheckKind::UnnecessaryGeneratorList, location);
+        if fix {
+            match fixes::fix_unnecessary_generator_list(locator, expr) {
+                Ok(fix) => check.amend(fix),
+                Err(e) => error!("Failed to generate fix: {}", e),
+            }
+        }
+        return Some(check);
    }
    None
 }

 /// C401 (`set(generator)`)
-pub fn unnecessary_generator_set(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
-    let argument = exactly_one_argument_with_matching_function("set", func, args)?;
+pub fn unnecessary_generator_set(
+    expr: &Expr,
+    func: &Expr,
+    args: &[Expr],
+    keywords: &[Keyword],
+    locator: &SourceCodeLocator,
+    fix: bool,
+    location: Range,
+) -> Option<Check> {
+    let argument = exactly_one_argument_with_matching_function("set", func, args, keywords)?;
    if let ExprKind::GeneratorExp { .. } = argument {
-        return Some(Check::new(
-            CheckKind::UnnecessaryGeneratorSet,
-            Range::from_located(expr),
-        ));
+        let mut check = Check::new(CheckKind::UnnecessaryGeneratorSet, location);
+        if fix {
+            match fixes::fix_unnecessary_generator_set(locator, expr) {
+                Ok(fix) => check.amend(fix),
+                Err(e) => error!("Failed to generate fix: {}", e),
+            }
+        }
+        return Some(check);
    }
    None
 }

 /// C402 (`dict((x, y) for x, y in iterable)`)
-pub fn unnecessary_generator_dict(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
-    let argument = exactly_one_argument_with_matching_function("dict", func, args)?;
+pub fn unnecessary_generator_dict(
+    expr: &Expr,
+    func: &Expr,
+    args: &[Expr],
+    keywords: &[Keyword],
+    locator: &SourceCodeLocator,
+    fix: bool,
+    location: Range,
+) -> Option<Check> {
+    let argument = exactly_one_argument_with_matching_function("dict", func, args, keywords)?;
    if let ExprKind::GeneratorExp { elt, .. } = argument {
        match &elt.node {
            ExprKind::Tuple { elts, .. } if elts.len() == 2 => {
-                return Some(Check::new(
-                    CheckKind::UnnecessaryGeneratorDict,
-                    Range::from_located(expr),
-                ));
+                let mut check = Check::new(CheckKind::UnnecessaryGeneratorDict, location);
+                if fix {
+                    match fixes::fix_unnecessary_generator_dict(locator, expr) {
+                        Ok(fix) => check.amend(fix),
+                        Err(e) => error!("Failed to generate fix: {}", e),
+                    }
+                }
+                return Some(check);
            }
            _ => {}
        }
@@ -83,30 +128,39 @@ pub fn unnecessary_list_comprehension_set(
    expr: &Expr,
    func: &Expr,
    args: &[Expr],
+    keywords: &[Keyword],
+    locator: &SourceCodeLocator,
+    fix: bool,
+    location: Range,
 ) -> Option<Check> {
-    let argument = exactly_one_argument_with_matching_function("set", func, args)?;
+    let argument = exactly_one_argument_with_matching_function("set", func, args, keywords)?;
    if let ExprKind::ListComp { .. } = &argument {
-        return Some(Check::new(
-            CheckKind::UnnecessaryListComprehensionSet,
-            Range::from_located(expr),
-        ));
+        let mut check = Check::new(CheckKind::UnnecessaryListComprehensionSet, location);
+        if fix {
+            match fixes::fix_unnecessary_list_comprehension_set(locator, expr) {
+                Ok(fix) => check.amend(fix),
+                Err(e) => error!("Failed to generate fix: {}", e),
+            }
+        }
+        return Some(check);
    }
    None
 }

 /// C404 (`dict([...])`)
 pub fn unnecessary_list_comprehension_dict(
-    expr: &Expr,
    func: &Expr,
    args: &[Expr],
+    keywords: &[Keyword],
+    location: Range,
 ) -> Option<Check> {
-    let argument = exactly_one_argument_with_matching_function("dict", func, args)?;
+    let argument = exactly_one_argument_with_matching_function("dict", func, args, keywords)?;
    if let ExprKind::ListComp { elt, .. } = &argument {
        match &elt.node {
            ExprKind::Tuple { elts, .. } if elts.len() == 2 => {
                return Some(Check::new(
                    CheckKind::UnnecessaryListComprehensionDict,
-                    Range::from_located(expr),
+                    location,
                ));
            }
            _ => {}
@@ -116,39 +170,65 @@ pub fn unnecessary_list_comprehension_dict(
 }

 /// C405 (`set([1, 2])`)
-pub fn unnecessary_literal_set(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
-    let argument = exactly_one_argument_with_matching_function("set", func, args)?;
+pub fn unnecessary_literal_set(
+    expr: &Expr,
+    func: &Expr,
+    args: &[Expr],
+    keywords: &[Keyword],
+    locator: &SourceCodeLocator,
+    fix: bool,
+    location: Range,
+) -> Option<Check> {
+    let argument = exactly_one_argument_with_matching_function("set", func, args, keywords)?;
    let kind = match argument {
        ExprKind::List { .. } => "list",
        ExprKind::Tuple { .. } => "tuple",
        _ => return None,
    };
-    Some(Check::new(
-        CheckKind::UnnecessaryLiteralSet(kind.to_string()),
-        Range::from_located(expr),
-    ))
+    let mut check = Check::new(CheckKind::UnnecessaryLiteralSet(kind.to_string()), location);
+    if fix {
+        match fixes::fix_unnecessary_literal_set(locator, expr) {
+            Ok(fix) => check.amend(fix),
+            Err(e) => error!("Failed to generate fix: {}", e),
+        }
+    }
+    Some(check)
 }

 /// C406 (`dict([(1, 2)])`)
-pub fn unnecessary_literal_dict(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
-    let argument = exactly_one_argument_with_matching_function("dict", func, args)?;
+pub fn unnecessary_literal_dict(
+    expr: &Expr,
+    func: &Expr,
+    args: &[Expr],
+    keywords: &[Keyword],
+    locator: &SourceCodeLocator,
+    fix: bool,
+    location: Range,
+) -> Option<Check> {
+    let argument = exactly_one_argument_with_matching_function("dict", func, args, keywords)?;
    let (kind, elts) = match argument {
        ExprKind::Tuple { elts, .. } => ("tuple", elts),
        ExprKind::List { elts, .. } => ("list", elts),
        _ => return None,
    };
-
-    if let Some(elt) = elts.first() {
-        // dict((1, 2), ...)) or dict([(1, 2), ...])
-        if !matches!(&elt.node, ExprKind::Tuple { elts, .. } if elts.len() == 2) {
-            return None;
+    // Accept `dict((1, 2), ...))` `dict([(1, 2), ...])`.
+    if !elts
+        .iter()
+        .all(|elt| matches!(&elt.node, ExprKind::Tuple { elts, .. } if elts.len() == 2))
+    {
+        return None;
+    }
+    let mut check = Check::new(
+        CheckKind::UnnecessaryLiteralDict(kind.to_string()),
+        location,
+    );
+    if fix {
+        match fixes::fix_unnecessary_literal_dict(locator, expr) {
+            Ok(fix) => check.amend(fix),
+            Err(e) => error!("Failed to generate fix: {}", e),
        }
    }
-
-    Some(Check::new(
-        CheckKind::UnnecessaryLiteralDict(kind.to_string()),
-        Range::from_located(expr),
-    ))
+    Some(check)
 }

 /// C408
@@ -157,22 +237,34 @@ pub fn unnecessary_collection_call(
    func: &Expr,
    args: &[Expr],
    keywords: &[Located<KeywordData>],
+    locator: &SourceCodeLocator,
+    fix: bool,
+    location: Range,
 ) -> Option<Check> {
    if !args.is_empty() {
        return None;
    }
    let id = function_name(func)?;
    match id {
-        "dict" if keywords.is_empty() || keywords.iter().all(|kw| kw.node.arg.is_some()) => (),
+        "dict" if keywords.is_empty() || keywords.iter().all(|kw| kw.node.arg.is_some()) => {
+            // `dict()` or `dict(a=1)` (as opposed to `dict(**a)`)
+        }
        "list" | "tuple" => {
-            // list() or tuple()
+            // `list()` or `tuple()`
        }
        _ => return None,
    };
-    Some(Check::new(
+    let mut check = Check::new(
        CheckKind::UnnecessaryCollectionCall(id.to_string()),
-        Range::from_located(expr),
-    ))
+        location,
+    );
+    if fix {
+        match fixes::fix_unnecessary_collection_call(locator, expr) {
+            Ok(fix) => check.amend(fix),
+            Err(e) => error!("Failed to generate fix: {}", e),
+        }
+    }
+    Some(check)
 }

 /// C409
@@ -180,6 +272,9 @@ pub fn unnecessary_literal_within_tuple_call(
    expr: &Expr,
    func: &Expr,
    args: &[Expr],
+    locator: &SourceCodeLocator,
+    fix: bool,
+    location: Range,
 ) -> Option<Check> {
    let argument = first_argument_with_matching_function("tuple", func, args)?;
    let argument_kind = match argument {
@@ -187,10 +282,17 @@ pub fn unnecessary_literal_within_tuple_call(
        ExprKind::List { .. } => "list",
        _ => return None,
    };
-    Some(Check::new(
+    let mut check = Check::new(
        CheckKind::UnnecessaryLiteralWithinTupleCall(argument_kind.to_string()),
-        Range::from_located(expr),
-    ))
+        location,
+    );
+    if fix {
+        match fixes::fix_unnecessary_literal_within_tuple_call(locator, expr) {
+            Ok(fix) => check.amend(fix),
+            Err(e) => error!("Failed to generate fix: {}", e),
+        }
+    }
+    Some(check)
 }

 /// C410
@@ -198,6 +300,9 @@ pub fn unnecessary_literal_within_list_call(
    expr: &Expr,
    func: &Expr,
    args: &[Expr],
+    locator: &SourceCodeLocator,
+    fix: bool,
+    location: Range,
 ) -> Option<Check> {
    let argument = first_argument_with_matching_function("list", func, args)?;
    let argument_kind = match argument {
@@ -205,26 +310,48 @@ pub fn unnecessary_literal_within_list_call(
        ExprKind::List { .. } => "list",
        _ => return None,
    };
-    Some(Check::new(
+    let mut check = Check::new(
        CheckKind::UnnecessaryLiteralWithinListCall(argument_kind.to_string()),
-        Range::from_located(expr),
-    ))
+        location,
+    );
+    if fix {
+        match fixes::fix_unnecessary_literal_within_list_call(locator, expr) {
+            Ok(fix) => check.amend(fix),
+            Err(e) => error!("Failed to generate fix: {}", e),
+        }
+    }
+    Some(check)
 }

 /// C411
-pub fn unnecessary_list_call(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
+pub fn unnecessary_list_call(
+    expr: &Expr,
+    func: &Expr,
+    args: &[Expr],
+    locator: &SourceCodeLocator,
+    fix: bool,
+    location: Range,
+) -> Option<Check> {
    let argument = first_argument_with_matching_function("list", func, args)?;
    if let ExprKind::ListComp { .. } = argument {
-        return Some(Check::new(
-            CheckKind::UnnecessaryListCall,
-            Range::from_located(expr),
-        ));
+        let mut check = Check::new(CheckKind::UnnecessaryListCall, location);
+        if fix {
+            match fixes::fix_unnecessary_list_call(locator, expr) {
+                Ok(fix) => check.amend(fix),
+                Err(e) => error!("Failed to generate fix: {}", e),
+            }
+        }
+        return Some(check);
    }
    None
 }

 /// C413
-pub fn unnecessary_call_around_sorted(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
+pub fn unnecessary_call_around_sorted(
+    func: &Expr,
+    args: &[Expr],
+    location: Range,
+) -> Option<Check> {
    let outer = function_name(func)?;
    if !(outer == "list" || outer == "reversed") {
        return None;
@@ -233,7 +360,7 @@ pub fn unnecessary_call_around_sorted(expr: &Expr, func: &Expr, args: &[Expr]) -
        if function_name(func)? == "sorted" {
            return Some(Check::new(
                CheckKind::UnnecessaryCallAroundSorted(outer.to_string()),
-                Range::from_located(expr),
+                location,
            ));
        }
    }
@@ -242,19 +369,19 @@ pub fn unnecessary_call_around_sorted(expr: &Expr, func: &Expr, args: &[Expr]) -

 /// C414
 pub fn unnecessary_double_cast_or_process(
-    expr: &Expr,
    func: &Expr,
    args: &[Expr],
+    location: Range,
 ) -> Option<Check> {
    let outer = function_name(func)?;
    if !["list", "tuple", "set", "reversed", "sorted"].contains(&outer) {
        return None;
    }

-    fn new_check(inner: &str, outer: &str, expr: &Expr) -> Check {
+    fn new_check(inner: &str, outer: &str, location: Range) -> Check {
        Check::new(
            CheckKind::UnnecessaryDoubleCastOrProcess(inner.to_string(), outer.to_string()),
-            Range::from_located(expr),
+            location,
        )
    }

@@ -264,24 +391,28 @@ pub fn unnecessary_double_cast_or_process(
        if (outer == "set" || outer == "sorted")
            && (inner == "list" || inner == "tuple" || inner == "reversed" || inner == "sorted")
        {
-            return Some(new_check(inner, outer, expr));
+            return Some(new_check(inner, outer, location));
        }

        // Ex) list(tuple(...))
        if (outer == "list" || outer == "tuple") && (inner == "list" || inner == "tuple") {
-            return Some(new_check(inner, outer, expr));
+            return Some(new_check(inner, outer, location));
        }

        // Ex) set(set(...))
        if outer == "set" && inner == "set" {
-            return Some(new_check(inner, outer, expr));
+            return Some(new_check(inner, outer, location));
        }
    }
    None
 }

 /// C415
-pub fn unnecessary_subscript_reversal(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
+pub fn unnecessary_subscript_reversal(
+    func: &Expr,
+    args: &[Expr],
+    location: Range,
+) -> Option<Check> {
    let first_arg = args.first()?;
    let id = function_name(func)?;
    if !["set", "sorted", "reversed"].contains(&id) {
@@ -304,7 +435,7 @@ pub fn unnecessary_subscript_reversal(expr: &Expr, func: &Expr, args: &[Expr]) -
                            if *val == BigInt::from(1) {
                                return Some(Check::new(
                                    CheckKind::UnnecessarySubscriptReversal(id.to_string()),
-                                    Range::from_located(expr),
+                                    location,
                                ));
                            }
                        }
@@ -321,6 +452,9 @@ pub fn unnecessary_comprehension(
    expr: &Expr,
    elt: &Expr,
    generators: &[Comprehension],
+    locator: &SourceCodeLocator,
+    fix: bool,
+    location: Range,
 ) -> Option<Check> {
    if generators.len() != 1 {
        return None;
@@ -339,32 +473,36 @@ pub fn unnecessary_comprehension(
        ExprKind::SetComp { .. } => "set",
        _ => return None,
    };
-    Some(Check::new(
+    let mut check = Check::new(
        CheckKind::UnnecessaryComprehension(expr_kind.to_string()),
-        Range::from_located(expr),
-    ))
+        location,
+    );
+    if fix {
+        match fixes::fix_unnecessary_comprehension(locator, expr) {
+            Ok(fix) => check.amend(fix),
+            Err(e) => error!("Failed to generate fix: {}", e),
+        }
+    }
+    Some(check)
 }

 /// C417
-pub fn unnecessary_map(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
-    fn new_check(kind: &str, expr: &Expr) -> Check {
-        Check::new(
-            CheckKind::UnnecessaryMap(kind.to_string()),
-            Range::from_located(expr),
-        )
+pub fn unnecessary_map(func: &Expr, args: &[Expr], location: Range) -> Option<Check> {
+    fn new_check(kind: &str, location: Range) -> Check {
+        Check::new(CheckKind::UnnecessaryMap(kind.to_string()), location)
    }
    let id = function_name(func)?;
    match id {
        "map" => {
            if args.len() == 2 && matches!(&args[0].node, ExprKind::Lambda { .. }) {
-                return Some(new_check("generator", expr));
+                return Some(new_check("generator", location));
            }
        }
        "list" | "set" => {
            if let ExprKind::Call { func, args, .. } = &args.first()?.node {
                let argument = first_argument_with_matching_function("map", func, args)?;
                if let ExprKind::Lambda { .. } = argument {
-                    return Some(new_check(id, expr));
+                    return Some(new_check(id, location));
                }
            }
        }
@@ -375,7 +513,7 @@ pub fn unnecessary_map(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check>
                    if let ExprKind::Lambda { body, .. } = &argument {
                        if matches!(&body.node, ExprKind::Tuple { elts, .. } | ExprKind::List { elts, .. } if elts.len() == 2)
                        {
-                            return Some(new_check(id, expr));
+                            return Some(new_check(id, location));
                        }
                    }
                }
--- a/src/flake8_comprehensions/fixes.rs
+++ b/src/flake8_comprehensions/fixes.rs
@@ -0,0 +1,676 @@
+use anyhow::Result;
+use libcst_native::{
+    Arg, Call, Codegen, Dict, DictComp, DictElement, Element, Expr, Expression, LeftCurlyBrace,
+    LeftParen, LeftSquareBracket, List, ListComp, Module, Name, ParenthesizableWhitespace,
+    RightCurlyBrace, RightParen, RightSquareBracket, Set, SetComp, SimpleString, SimpleWhitespace,
+    SmallStatement, Statement, Tuple,
+};
+
+use crate::ast::types::Range;
+use crate::autofix::Fix;
+use crate::cst::matchers::match_module;
+use crate::source_code_locator::SourceCodeLocator;
+
+fn match_expr<'a, 'b>(module: &'a mut Module<'b>) -> Result<&'a mut Expr<'b>> {
+    if let Some(Statement::Simple(expr)) = module.body.first_mut() {
+        if let Some(SmallStatement::Expr(expr)) = expr.body.first_mut() {
+            Ok(expr)
+        } else {
+            Err(anyhow::anyhow!("Expected node to be: SmallStatement::Expr"))
+        }
+    } else {
+        Err(anyhow::anyhow!("Expected node to be: Statement::Simple"))
+    }
+}
+
+fn match_call<'a, 'b>(expr: &'a mut Expr<'b>) -> Result<&'a mut Call<'b>> {
+    if let Expression::Call(call) = &mut expr.value {
+        Ok(call)
+    } else {
+        Err(anyhow::anyhow!("Expected node to be: Expression::Call"))
+    }
+}
+
+fn match_arg<'a, 'b>(call: &'a Call<'b>) -> Result<&'a Arg<'b>> {
+    if let Some(arg) = call.args.first() {
+        Ok(arg)
+    } else {
+        Err(anyhow::anyhow!("Expected node to be: Arg"))
+    }
+}
+
+/// (C400) Convert `list(x for x in y)` to `[x for x in y]`.
+pub fn fix_unnecessary_generator_list(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    // Expr(Call(GeneratorExp)))) -> Expr(ListComp)))
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+    let call = match_call(body)?;
+    let arg = match_arg(call)?;
+
+    let generator_exp = if let Expression::GeneratorExp(generator_exp) = &arg.value {
+        generator_exp
+    } else {
+        return Err(anyhow::anyhow!(
+            "Expected node to be: Expression::GeneratorExp"
+        ));
+    };
+
+    body.value = Expression::ListComp(Box::new(ListComp {
+        elt: generator_exp.elt.clone(),
+        for_in: generator_exp.for_in.clone(),
+        lbracket: LeftSquareBracket {
+            whitespace_after: call.whitespace_before_args.clone(),
+        },
+        rbracket: RightSquareBracket {
+            whitespace_before: arg.whitespace_after_arg.clone(),
+        },
+        lpar: generator_exp.lpar.clone(),
+        rpar: generator_exp.rpar.clone(),
+    }));
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
+/// (C401) Convert `set(x for x in y)` to `{x for x in y}`.
+pub fn fix_unnecessary_generator_set(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    // Expr(Call(GeneratorExp)))) -> Expr(SetComp)))
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+    let call = match_call(body)?;
+    let arg = match_arg(call)?;
+
+    let generator_exp = if let Expression::GeneratorExp(generator_exp) = &arg.value {
+        generator_exp
+    } else {
+        return Err(anyhow::anyhow!(
+            "Expected node to be: Expression::GeneratorExp"
+        ));
+    };
+
+    body.value = Expression::SetComp(Box::new(SetComp {
+        elt: generator_exp.elt.clone(),
+        for_in: generator_exp.for_in.clone(),
+        lbrace: LeftCurlyBrace {
+            whitespace_after: call.whitespace_before_args.clone(),
+        },
+        rbrace: RightCurlyBrace {
+            whitespace_before: arg.whitespace_after_arg.clone(),
+        },
+        lpar: generator_exp.lpar.clone(),
+        rpar: generator_exp.rpar.clone(),
+    }));
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
+/// (C402) Convert `dict((x, x) for x in range(3))` to `{x: x for x in
+/// range(3)}`.
+pub fn fix_unnecessary_generator_dict(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+    let call = match_call(body)?;
+    let arg = match_arg(call)?;
+
+    // Extract the (k, v) from `(k, v) for ...`.
+    let generator_exp = if let Expression::GeneratorExp(generator_exp) = &arg.value {
+        generator_exp
+    } else {
+        return Err(anyhow::anyhow!(
+            "Expected node to be: Expression::GeneratorExp"
+        ));
+    };
+    let tuple = if let Expression::Tuple(tuple) = &generator_exp.elt.as_ref() {
+        tuple
+    } else {
+        return Err(anyhow::anyhow!("Expected node to be: Expression::Tuple"));
+    };
+    let key = if let Some(Element::Simple { value, .. }) = &tuple.elements.get(0) {
+        value
+    } else {
+        return Err(anyhow::anyhow!(
+            "Expected tuple to contain a key as the first element"
+        ));
+    };
+    let value = if let Some(Element::Simple { value, .. }) = &tuple.elements.get(1) {
+        value
+    } else {
+        return Err(anyhow::anyhow!(
+            "Expected tuple to contain a key as the second element"
+        ));
+    };
+
+    body.value = Expression::DictComp(Box::new(DictComp {
+        key: Box::new(key.clone()),
+        value: Box::new(value.clone()),
+        for_in: generator_exp.for_in.clone(),
+        lbrace: LeftCurlyBrace {
+            whitespace_after: call.whitespace_before_args.clone(),
+        },
+        rbrace: RightCurlyBrace {
+            whitespace_before: arg.whitespace_after_arg.clone(),
+        },
+        lpar: Default::default(),
+        rpar: Default::default(),
+        whitespace_before_colon: Default::default(),
+        whitespace_after_colon: ParenthesizableWhitespace::SimpleWhitespace(SimpleWhitespace(" ")),
+    }));
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
+/// (C403) Convert `set([x for x in y])` to `{x for x in y}`.
+pub fn fix_unnecessary_list_comprehension_set(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    // Expr(Call(ListComp)))) ->
+    // Expr(SetComp)))
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+    let call = match_call(body)?;
+    let arg = match_arg(call)?;
+
+    let list_comp = if let Expression::ListComp(list_comp) = &arg.value {
+        list_comp
+    } else {
+        return Err(anyhow::anyhow!("Expected node to be: Expression::ListComp"));
+    };
+
+    body.value = Expression::SetComp(Box::new(SetComp {
+        elt: list_comp.elt.clone(),
+        for_in: list_comp.for_in.clone(),
+        lbrace: LeftCurlyBrace {
+            whitespace_after: call.whitespace_before_args.clone(),
+        },
+        rbrace: RightCurlyBrace {
+            whitespace_before: arg.whitespace_after_arg.clone(),
+        },
+        lpar: list_comp.lpar.clone(),
+        rpar: list_comp.rpar.clone(),
+    }));
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
+/// (C405) Convert `set((1, 2))` to `{1, 2}`.
+pub fn fix_unnecessary_literal_set(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    // Expr(Call(List|Tuple)))) -> Expr(Set)))
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+    let mut call = match_call(body)?;
+    let arg = match_arg(call)?;
+
+    let elements = match &arg.value {
+        Expression::Tuple(inner) => &inner.elements,
+        Expression::List(inner) => &inner.elements,
+        _ => {
+            return Err(anyhow::anyhow!(
+                "Expected node to be: Expression::Tuple | Expression::List"
+            ))
+        }
+    };
+
+    if elements.is_empty() {
+        call.args = vec![];
+    } else {
+        body.value = Expression::Set(Box::new(Set {
+            elements: elements.clone(),
+            lbrace: LeftCurlyBrace {
+                whitespace_after: call.whitespace_before_args.clone(),
+            },
+            rbrace: RightCurlyBrace {
+                whitespace_before: arg.whitespace_after_arg.clone(),
+            },
+            lpar: Default::default(),
+            rpar: Default::default(),
+        }));
+    }
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
+/// (C406) Convert `dict([(1, 2)])` to `{1: 2}`.
+pub fn fix_unnecessary_literal_dict(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    // Expr(Call(List|Tuple)))) -> Expr(Dict)))
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+    let call = match_call(body)?;
+    let arg = match_arg(call)?;
+
+    let elements = match &arg.value {
+        Expression::Tuple(inner) => &inner.elements,
+        Expression::List(inner) => &inner.elements,
+        _ => {
+            return Err(anyhow::anyhow!(
+                "Expected node to be: Expression::Tuple | Expression::List"
+            ))
+        }
+    };
+
+    let elements: Vec<DictElement> = elements
+        .iter()
+        .map(|element| {
+            if let Element::Simple {
+                value: Expression::Tuple(tuple),
+                comma,
+            } = element
+            {
+                if let Some(Element::Simple { value: key, .. }) = tuple.elements.get(0) {
+                    if let Some(Element::Simple { value, .. }) = tuple.elements.get(1) {
+                        return Ok(DictElement::Simple {
+                            key: key.clone(),
+                            value: value.clone(),
+                            comma: comma.clone(),
+                            whitespace_before_colon: Default::default(),
+                            whitespace_after_colon: ParenthesizableWhitespace::SimpleWhitespace(
+                                SimpleWhitespace(" "),
+                            ),
+                        });
+                    }
+                }
+            }
+            Err(anyhow::anyhow!(
+                "Expected each argument to be a tuple of length two"
+            ))
+        })
+        .collect::<Result<Vec<DictElement>>>()?;
+
+    body.value = Expression::Dict(Box::new(Dict {
+        elements,
+        lbrace: LeftCurlyBrace {
+            whitespace_after: call.whitespace_before_args.clone(),
+        },
+        rbrace: RightCurlyBrace {
+            whitespace_before: arg.whitespace_after_arg.clone(),
+        },
+        lpar: Default::default(),
+        rpar: Default::default(),
+    }));
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
+/// (C408)
+pub fn fix_unnecessary_collection_call(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    // Expr(Call("list" | "tuple" | "dict")))) -> Expr(List|Tuple|Dict)
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+    let call = match_call(body)?;
+    let name = if let Expression::Name(name) = &call.func.as_ref() {
+        name
+    } else {
+        return Err(anyhow::anyhow!("Expected node to be: Expression::Name"));
+    };
+
+    // Arena allocator used to create formatted strings of sufficient lifetime,
+    // below.
+    let mut arena: Vec<String> = vec![];
+
+    match name.value {
+        "tuple" => {
+            body.value = Expression::Tuple(Box::new(Tuple {
+                elements: Default::default(),
+                lpar: vec![Default::default()],
+                rpar: vec![Default::default()],
+            }));
+        }
+        "list" => {
+            body.value = Expression::List(Box::new(List {
+                elements: Default::default(),
+                lbracket: Default::default(),
+                rbracket: Default::default(),
+                lpar: Default::default(),
+                rpar: Default::default(),
+            }));
+        }
+        "dict" => {
+            if call.args.is_empty() {
+                body.value = Expression::Dict(Box::new(Dict {
+                    elements: Default::default(),
+                    lbrace: Default::default(),
+                    rbrace: Default::default(),
+                    lpar: Default::default(),
+                    rpar: Default::default(),
+                }));
+            } else {
+                // Quote each argument.
+                for arg in &call.args {
+                    let quoted = format!(
+                        "\"{}\"",
+                        arg.keyword
+                            .as_ref()
+                            .expect("Expected dictionary argument to be kwarg")
+                            .value
+                    );
+                    arena.push(quoted);
+                }
+
+                let elements = call
+                    .args
+                    .iter()
+                    .enumerate()
+                    .map(|(i, arg)| DictElement::Simple {
+                        key: Expression::SimpleString(Box::new(SimpleString {
+                            value: &arena[i],
+                            lpar: Default::default(),
+                            rpar: Default::default(),
+                        })),
+                        value: arg.value.clone(),
+                        comma: arg.comma.clone(),
+                        whitespace_before_colon: Default::default(),
+                        whitespace_after_colon: ParenthesizableWhitespace::SimpleWhitespace(
+                            SimpleWhitespace(" "),
+                        ),
+                    })
+                    .collect();
+
+                body.value = Expression::Dict(Box::new(Dict {
+                    elements,
+                    lbrace: LeftCurlyBrace {
+                        whitespace_after: call.whitespace_before_args.clone(),
+                    },
+                    rbrace: RightCurlyBrace {
+                        whitespace_before: call
+                            .args
+                            .last()
+                            .expect("Arguments should be non-empty")
+                            .whitespace_after_arg
+                            .clone(),
+                    },
+                    lpar: Default::default(),
+                    rpar: Default::default(),
+                }));
+            }
+        }
+        _ => {
+            return Err(anyhow::anyhow!("Expected function name to be one of: \
+                                        'tuple', 'list', 'dict'"
+                .to_string()));
+        }
+    };
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
+/// (C409) Convert `tuple([1, 2])` to `tuple(1, 2)`
+pub fn fix_unnecessary_literal_within_tuple_call(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+    let call = match_call(body)?;
+    let arg = match_arg(call)?;
+    let (elements, whitespace_after, whitespace_before) = match &arg.value {
+        Expression::Tuple(inner) => (
+            &inner.elements,
+            &inner
+                .lpar
+                .first()
+                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses"))?
+                .whitespace_after,
+            &inner
+                .rpar
+                .first()
+                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses"))?
+                .whitespace_before,
+        ),
+        Expression::List(inner) => (
+            &inner.elements,
+            &inner.lbracket.whitespace_after,
+            &inner.rbracket.whitespace_before,
+        ),
+        _ => {
+            return Err(anyhow::anyhow!(
+                "Expected node to be: Expression::Tuple | Expression::List"
+            ))
+        }
+    };
+
+    body.value = Expression::Tuple(Box::new(Tuple {
+        elements: elements.clone(),
+        lpar: vec![LeftParen {
+            whitespace_after: whitespace_after.clone(),
+        }],
+        rpar: vec![RightParen {
+            whitespace_before: whitespace_before.clone(),
+        }],
+    }));
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
+/// (C410) Convert `list([1, 2])` to `[1, 2]`
+pub fn fix_unnecessary_literal_within_list_call(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+    let call = match_call(body)?;
+    let arg = match_arg(call)?;
+    let (elements, whitespace_after, whitespace_before) = match &arg.value {
+        Expression::Tuple(inner) => (
+            &inner.elements,
+            &inner
+                .lpar
+                .first()
+                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses"))?
+                .whitespace_after,
+            &inner
+                .rpar
+                .first()
+                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses"))?
+                .whitespace_before,
+        ),
+        Expression::List(inner) => (
+            &inner.elements,
+            &inner.lbracket.whitespace_after,
+            &inner.rbracket.whitespace_before,
+        ),
+        _ => {
+            return Err(anyhow::anyhow!(
+                "Expected node to be: Expression::Tuple | Expression::List"
+            ))
+        }
+    };
+
+    body.value = Expression::List(Box::new(List {
+        elements: elements.clone(),
+        lbracket: LeftSquareBracket {
+            whitespace_after: whitespace_after.clone(),
+        },
+        rbracket: RightSquareBracket {
+            whitespace_before: whitespace_before.clone(),
+        },
+        lpar: Default::default(),
+        rpar: Default::default(),
+    }));
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
+/// (C411) Convert `list([i * i for i in x])` to `[i * i for i in x]`.
+pub fn fix_unnecessary_list_call(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    // Expr(Call(List|Tuple)))) -> Expr(List|Tuple)))
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+    let call = match_call(body)?;
+    let arg = match_arg(call)?;
+
+    body.value = arg.value.clone();
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
+/// (C416) Convert `[i for i in x]` to `list(x)`.
+pub fn fix_unnecessary_comprehension(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+
+    match &body.value {
+        Expression::ListComp(inner) => {
+            body.value = Expression::Call(Box::new(Call {
+                func: Box::new(Expression::Name(Box::new(Name {
+                    value: "list",
+                    lpar: Default::default(),
+                    rpar: Default::default(),
+                }))),
+                args: vec![Arg {
+                    value: inner.for_in.iter.clone(),
+                    keyword: Default::default(),
+                    equal: Default::default(),
+                    comma: Default::default(),
+                    star: Default::default(),
+                    whitespace_after_star: Default::default(),
+                    whitespace_after_arg: Default::default(),
+                }],
+                lpar: Default::default(),
+                rpar: Default::default(),
+                whitespace_after_func: Default::default(),
+                whitespace_before_args: Default::default(),
+            }))
+        }
+        Expression::SetComp(inner) => {
+            body.value = Expression::Call(Box::new(Call {
+                func: Box::new(Expression::Name(Box::new(Name {
+                    value: "set",
+                    lpar: Default::default(),
+                    rpar: Default::default(),
+                }))),
+                args: vec![Arg {
+                    value: inner.for_in.iter.clone(),
+                    keyword: Default::default(),
+                    equal: Default::default(),
+                    comma: Default::default(),
+                    star: Default::default(),
+                    whitespace_after_star: Default::default(),
+                    whitespace_after_arg: Default::default(),
+                }],
+                lpar: Default::default(),
+                rpar: Default::default(),
+                whitespace_after_func: Default::default(),
+                whitespace_before_args: Default::default(),
+            }))
+        }
+        _ => {
+            return Err(anyhow::anyhow!(
+                "Expected node to be: Expression::ListComp | Expression:SetComp"
+            ))
+        }
+    }
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
--- a/src/flake8_comprehensions/mod.rs
+++ b/src/flake8_comprehensions/mod.rs
@@ -1 +1,2 @@
 pub mod checks;
+mod fixes;
--- a/src/flake8_print/checks.rs
+++ b/src/flake8_print/checks.rs
@@ -9,25 +9,20 @@ pub fn print_call(
    func: &Expr,
    check_print: bool,
    check_pprint: bool,
+    location: Range,
 ) -> Option<Check> {
    if let ExprKind::Name { id, .. } = &func.node {
        if check_print && id == "print" {
            return Some(Check::new(CheckKind::PrintFound, Range::from_located(expr)));
        } else if check_pprint && id == "pprint" {
-            return Some(Check::new(
-                CheckKind::PPrintFound,
-                Range::from_located(expr),
-            ));
+            return Some(Check::new(CheckKind::PPrintFound, location));
        }
    }

    if let ExprKind::Attribute { value, attr, .. } = &func.node {
        if let ExprKind::Name { id, .. } = &value.node {
            if check_pprint && id == "pprint" && attr == "pprint" {
-                return Some(Check::new(
-                    CheckKind::PPrintFound,
-                    Range::from_located(expr),
-                ));
+                return Some(Check::new(CheckKind::PPrintFound, location));
            }
        }
    }
--- a/src/flake8_print/plugins/print_call.rs
+++ b/src/flake8_print/plugins/print_call.rs
@@ -1,6 +1,7 @@
 use log::error;
 use rustpython_ast::{Expr, Stmt, StmtKind};

+use crate::ast::types::{CheckLocator, Range};
 use crate::autofix::helpers;
 use crate::check_ast::Checker;
 use crate::checks::CheckCode;
@@ -12,6 +13,7 @@ pub fn print_call(checker: &mut Checker, expr: &Expr, func: &Expr) {
        func,
        checker.settings.enabled.contains(&CheckCode::T201),
        checker.settings.enabled.contains(&CheckCode::T203),
+        checker.locate_check(Range::from_located(expr)),
    ) {
        if checker.patch() {
            let context = checker.binding_context();
--- a/src/flake8_quotes/checks.rs
+++ b/src/flake8_quotes/checks.rs
@@ -1,9 +1,9 @@
 use rustpython_ast::Location;

-use crate::ast::operations::SourceCodeLocator;
 use crate::ast::types::Range;
 use crate::checks::{Check, CheckKind};
 use crate::flake8_quotes::settings::{Quote, Settings};
+use crate::source_code_locator::SourceCodeLocator;

 fn good_single(quote: &Quote) -> char {
    match quote {
@@ -148,14 +148,22 @@ mod tests {
    use crate::checks::{Check, CheckCode};
    use crate::flake8_quotes::settings::Quote;
    use crate::linter::tokenize;
-    use crate::{flake8_quotes, linter, Settings};
-    use crate::{fs, noqa};
+    use crate::{flake8_quotes, fs, linter, noqa, Settings, SourceCodeLocator};

    fn check_path(path: &Path, settings: &Settings, autofix: &fixer::Mode) -> Result<Vec<Check>> {
        let contents = fs::read_file(path)?;
        let tokens: Vec<LexResult> = tokenize(&contents);
+        let locator = SourceCodeLocator::new(&contents);
        let noqa_line_for = noqa::extract_noqa_line_for(&tokens);
-        linter::check_path(path, &contents, tokens, &noqa_line_for, settings, autofix)
+        linter::check_path(
+            path,
+            &contents,
+            tokens,
+            &locator,
+            &noqa_line_for,
+            settings,
+            autofix,
+        )
    }

    #[test_case(Path::new("doubles.py"))]
--- a/src/flake8_quotes/mod.rs
+++ b/src/flake8_quotes/mod.rs
@@ -1,3 +1,2 @@
 pub mod checks;
-pub mod docstring_detection;
 pub mod settings;
--- a/src/flake8_quotes/settings.rs
+++ b/src/flake8_quotes/settings.rs
@@ -2,14 +2,14 @@

 use serde::{Deserialize, Serialize};

-#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub enum Quote {
    Single,
    Double,
 }

-#[derive(Debug, PartialEq, Eq, Deserialize)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub struct Options {
    pub inline_quotes: Option<Quote>,
@@ -18,7 +18,7 @@ pub struct Options {
    pub avoid_escape: Option<bool>,
 }

-#[derive(Debug)]
+#[derive(Debug, Hash)]
 pub struct Settings {
    pub inline_quotes: Quote,
    pub multiline_quotes: Quote,
@@ -29,7 +29,7 @@ pub struct Settings {
 impl Settings {
    pub fn from_options(options: Options) -> Self {
        Self {
-            inline_quotes: options.inline_quotes.unwrap_or(Quote::Single),
+            inline_quotes: options.inline_quotes.unwrap_or(Quote::Double),
            multiline_quotes: options.multiline_quotes.unwrap_or(Quote::Double),
            docstring_quotes: options.docstring_quotes.unwrap_or(Quote::Double),
            avoid_escape: options.avoid_escape.unwrap_or(true),
@@ -40,7 +40,7 @@ impl Settings {
 impl Default for Settings {
    fn default() -> Self {
        Self {
-            inline_quotes: Quote::Single,
+            inline_quotes: Quote::Double,
            multiline_quotes: Quote::Double,
            docstring_quotes: Quote::Double,
            avoid_escape: true,
--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_doubles.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_doubles.py.snap
@@ -6,45 +6,45 @@ expression: checks
    BadQuotesMultilineString: single
  location:
    row: 5
-    column: 1
+    column: 0
  end_location:
    row: 7
-    column: 4
+    column: 3
  fix: ~
 - kind:
    BadQuotesMultilineString: single
  location:
    row: 16
-    column: 5
+    column: 4
  end_location:
    row: 18
-    column: 8
+    column: 7
  fix: ~
 - kind:
    BadQuotesMultilineString: single
  location:
    row: 21
-    column: 21
+    column: 20
  end_location:
    row: 22
-    column: 38
+    column: 37
  fix: ~
 - kind:
    BadQuotesMultilineString: single
  location:
    row: 30
-    column: 9
+    column: 8
  end_location:
    row: 32
-    column: 12
+    column: 11
  fix: ~
 - kind:
    BadQuotesMultilineString: single
  location:
    row: 35
-    column: 13
+    column: 12
  end_location:
    row: 37
-    column: 16
+    column: 15
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_doubles_class.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_doubles_class.py.snap
@@ -6,18 +6,18 @@ expression: checks
    BadQuotesMultilineString: single
  location:
    row: 3
-    column: 5
+    column: 4
  end_location:
    row: 3
-    column: 28
+    column: 27
  fix: ~
 - kind:
    BadQuotesMultilineString: single
  location:
    row: 5
-    column: 23
+    column: 22
  end_location:
    row: 5
-    column: 44
+    column: 43
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_doubles_function.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_doubles_function.py.snap
@@ -6,45 +6,45 @@ expression: checks
    BadQuotesMultilineString: single
  location:
    row: 3
-    column: 5
+    column: 4
  end_location:
    row: 3
-    column: 27
+    column: 26
  fix: ~
 - kind:
    BadQuotesMultilineString: single
  location:
    row: 11
-    column: 5
+    column: 4
  end_location:
    row: 11
-    column: 27
+    column: 26
  fix: ~
 - kind:
    BadQuotesMultilineString: single
  location:
    row: 15
-    column: 39
+    column: 38
  end_location:
+    row: 17
+    column: 3
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
    row: 17
    column: 4
-  fix: ~
- kind:
-    BadQuotesMultilineString: single
-  location:
-    row: 17
-    column: 5
  end_location:
    row: 17
-    column: 20
+    column: 19
  fix: ~
 - kind:
    BadQuotesMultilineString: single
  location:
    row: 21
-    column: 5
+    column: 4
  end_location:
    row: 21
-    column: 28
+    column: 27
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_doubles_module_multiline.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_doubles_module_multiline.py.snap
@@ -6,18 +6,18 @@ expression: checks
    BadQuotesMultilineString: single
  location:
    row: 4
-    column: 1
+    column: 0
  end_location:
    row: 6
-    column: 4
+    column: 3
  fix: ~
 - kind:
    BadQuotesMultilineString: single
  location:
    row: 9
-    column: 1
+    column: 0
  end_location:
    row: 11
-    column: 4
+    column: 3
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_doubles_module_singleline.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_doubles_module_singleline.py.snap
@@ -6,18 +6,18 @@ expression: checks
    BadQuotesMultilineString: single
  location:
    row: 2
-    column: 1
+    column: 0
  end_location:
    row: 2
-    column: 32
+    column: 31
  fix: ~
 - kind:
    BadQuotesMultilineString: single
  location:
    row: 6
-    column: 1
+    column: 0
  end_location:
    row: 6
-    column: 32
+    column: 31
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_singles.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_singles.py.snap
@@ -6,27 +6,27 @@ expression: checks
    BadQuotesDocstring: double
  location:
    row: 1
-    column: 1
+    column: 0
  end_location:
    row: 3
-    column: 4
+    column: 3
  fix: ~
 - kind:
    BadQuotesDocstring: double
  location:
    row: 14
-    column: 5
+    column: 4
  end_location:
    row: 16
-    column: 8
+    column: 7
  fix: ~
 - kind:
    BadQuotesDocstring: double
  location:
    row: 26
-    column: 9
+    column: 8
  end_location:
    row: 28
-    column: 12
+    column: 11
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_singles_class.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_singles_class.py.snap
@@ -6,27 +6,27 @@ expression: checks
    BadQuotesDocstring: double
  location:
    row: 2
-    column: 5
+    column: 4
  end_location:
    row: 2
-    column: 54
-  fix: ~
- kind:
-    BadQuotesDocstring: double
-  location:
-    row: 6
-    column: 9
-  end_location:
-    row: 6
-    column: 58
-  fix: ~
- kind:
-    BadQuotesDocstring: double
-  location:
-    row: 9
-    column: 29
-  end_location:
-    row: 9
    column: 53
  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 6
+    column: 8
+  end_location:
+    row: 6
+    column: 57
+  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 9
+    column: 28
+  end_location:
+    row: 9
+    column: 52
+  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_singles_function.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_singles_function.py.snap
@@ -6,18 +6,18 @@ expression: checks
    BadQuotesDocstring: double
  location:
    row: 2
-    column: 5
+    column: 4
  end_location:
    row: 2
-    column: 57
+    column: 56
  fix: ~
 - kind:
    BadQuotesDocstring: double
  location:
    row: 8
-    column: 5
+    column: 4
  end_location:
    row: 10
-    column: 8
+    column: 7
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_singles_module_multiline.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_singles_module_multiline.py.snap
@@ -6,9 +6,9 @@ expression: checks
    BadQuotesDocstring: double
  location:
    row: 1
-    column: 1
+    column: 0
  end_location:
    row: 3
-    column: 4
+    column: 3
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_singles_module_singleline.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__double_docstring_docstring_singles_module_singleline.py.snap
@@ -6,9 +6,9 @@ expression: checks
    BadQuotesDocstring: double
  location:
    row: 1
-    column: 1
+    column: 0
  end_location:
    row: 1
-    column: 50
+    column: 49
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__doubles_doubles.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__doubles_doubles.py.snap
@@ -6,18 +6,18 @@ expression: checks
    BadQuotesInlineString: single
  location:
    row: 1
-    column: 25
+    column: 24
  end_location:
    row: 1
-    column: 46
+    column: 45
  fix: ~
 - kind:
    BadQuotesInlineString: single
  location:
    row: 2
-    column: 25
+    column: 24
  end_location:
    row: 2
-    column: 47
+    column: 46
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__doubles_doubles_escaped.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__doubles_doubles_escaped.py.snap
@@ -5,9 +5,9 @@ expression: checks
 - kind: AvoidQuoteEscape
  location:
    row: 1
-    column: 26
+    column: 25
  end_location:
    row: 1
-    column: 48
+    column: 47
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__doubles_doubles_multiline_string.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__doubles_doubles_multiline_string.py.snap
@@ -6,9 +6,9 @@ expression: checks
    BadQuotesMultilineString: single
  location:
    row: 1
-    column: 5
+    column: 4
  end_location:
    row: 3
-    column: 13
+    column: 12
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__single_docstring_docstring_doubles.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__single_docstring_docstring_doubles.py.snap
@@ -6,27 +6,27 @@ expression: checks
    BadQuotesDocstring: single
  location:
    row: 1
-    column: 1
+    column: 0
  end_location:
    row: 3
-    column: 4
+    column: 3
  fix: ~
 - kind:
    BadQuotesDocstring: single
  location:
    row: 12
-    column: 5
+    column: 4
  end_location:
    row: 14
-    column: 8
+    column: 7
  fix: ~
 - kind:
    BadQuotesDocstring: single
  location:
    row: 24
-    column: 9
+    column: 8
  end_location:
    row: 26
-    column: 12
+    column: 11
  fix: ~

--- a/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__single_docstring_docstring_doubles_class.py.snap
+++ b/src/flake8_quotes/snapshots/ruff__flake8_quotescheckstests__single_docstring_docstring_doubles_class.py.snap
@@ -6,27 +6,27 @@ expression: checks
    BadQuotesDocstring: single
  location:
    row: 2
-    column: 5
+    column: 4
  end_location:
    row: 2
-    column: 54
-  fix: ~
- kind:
-    BadQuotesDocstring: single
-  location:
-    row: 6
-    column: 9
-  end_location:
-    row: 6
-    column: 58
-  fix: ~
- kind:
-    BadQuotesDocstring: single
-  location:
-    row: 9
-    column: 29
-  end_location:
-    row: 9
    column: 53
  fix: ~
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 6
+    column: 8
+  end_location:
+    row: 6
+    column: 57
+  fix: ~
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 9
+    column: 28
+  end_location:
+    row: 9
+    column: 52
+  fix: ~

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Charlie Marsh	b335a6a5ec	Bump version to 0.0.102	2022-11-05 14:13:02 -04:00
Charlie Marsh	f5cbee452a	Increase flake8-bugbear count to 15/32	2022-11-05 14:12:35 -04:00
Harutaka Kawamura	5d1ea4410a	Ignore ellipsis in B018 (#598 )	2022-11-05 14:11:44 -04:00
Harutaka Kawamura	f27163d2c7	Remove needless return (#597 )	2022-11-05 14:11:26 -04:00
Harutaka Kawamura	62c126f70e	Implement B003 (#596 )	2022-11-05 14:08:02 -04:00
Harutaka Kawamura	8344d5151c	Implement B016 (#595 )	2022-11-05 14:06:00 -04:00
Harutaka Kawamura	f7780eb720	Implement B008 (#594 )	2022-11-05 14:05:04 -04:00
Charlie Marsh	c544d84b46	Rely on token locations for noqa map extraction (#603 )	2022-11-05 10:51:19 -04:00
Charlie Marsh	fbdc075e5c	Change Ruff's error prefix to RUF (#592 )	2022-11-04 23:13:50 -04:00
Charlie Marsh	d3472104d0	Bump flake8-bugbear count to 12/32	2022-11-04 14:49:14 -04:00
Charlie Marsh	0c8b981216	Bump version to 0.0.101	2022-11-04 14:46:48 -04:00
Charlie Marsh	0e3f08aa68	Split ambiguous unicode detection into string vs. docstring rules (#590 )	2022-11-04 14:46:20 -04:00
Charlie Marsh	a75b1c85ee	Fix invalid escape handling for CRLF files (#589 )	2022-11-04 14:26:39 -04:00
Harutaka Kawamura	726e6c68cf	Implement B015 (#587 )	2022-11-04 13:47:52 -04:00
Charlie Marsh	34c91224d7	Bump version to 0.0.100	2022-11-04 12:10:17 -04:00
Charlie Marsh	50c4bbc52b	Implement ambiguous unicode character detection (#578 )	2022-11-04 12:08:26 -04:00
Charlie Marsh	f0239de559	Use a shared Rope between AST checker and fixer (#585 )	2022-11-04 12:05:46 -04:00
Charlie Marsh	2be632f3cc	Use a Rope to power fixer (#584 )	2022-11-04 12:04:14 -04:00
Harutaka Kawamura	ec3fed5a61	Implement B018 (#582 )	2022-11-04 10:53:30 -04:00
Charlie Marsh	1da44485d5	Confine subscript annotation checks to `ExprContext::Load` (#583 )	2022-11-04 10:51:05 -04:00
Charlie Marsh	e5f30ff5a8	Use a rope to manage string slicing (#576 )	2022-11-03 23:23:38 -04:00
Charlie Marsh	c92f5c14a3	Bump Rust version to 1.65.0 (#575 )	2022-11-03 22:49:21 -04:00
Charlie Marsh	2f92399f4e	Add W to list of default flake8-to-ruff codes (#574 )	2022-11-03 22:13:00 -04:00
Charlie Marsh	83dfb5fe8b	Infer Flake8 plugins from .flake8 config (#573 )	2022-11-03 22:05:46 -04:00
Charlie Marsh	cc915371ca	Implement autofix for F901 (#571 )	2022-11-03 11:58:54 -04:00
Charlie Marsh	5576db3d5a	Bump version to 0.0.99	2022-11-03 11:47:15 -04:00
Charlie Marsh	f26f38d023	Enable autofix for C406 (#570 )	2022-11-03 11:27:46 -04:00
Charlie Marsh	578ec4d843	Implement autofix for C416 (#568 )	2022-11-03 11:05:08 -04:00
Charlie Marsh	2f3bebe5a2	Enable autofix for dict(a=1)-like dictionaries (#567 )	2022-11-03 10:42:54 -04:00
Charlie Marsh	22991e3e0e	Bump version to 0.0.98	2022-11-03 10:09:33 -04:00
Charlie Marsh	242bdf86b1	Use ::ruff to ensure ruff imports come first	2022-11-03 10:09:28 -04:00
Charlie Marsh	a3f7de2257	Make --quiet more aggressive (#566 )	2022-11-03 10:08:15 -04:00
Charlie Marsh	9f9cbb5520	Improve pyproject.toml examples in README.md	2022-11-03 09:33:17 -04:00
Charlie Marsh	937c83d57f	Remove crates subdirectory (#563 )	2022-11-03 09:19:54 -04:00
Charlie Marsh	e00bcd19f5	Bump version to 0.0.97	2022-11-02 22:38:43 -04:00
Charlie Marsh	4550581be2	Relax lowercase condition in N806 (#562 )	2022-11-02 22:38:29 -04:00
Charlie Marsh	b42d77a4c6	Avoid autofixes for errors in f-strings (#561 )	2022-11-02 22:31:57 -04:00
Charlie Marsh	e473df1fe9	Bump version to 0.0.96	2022-11-02 22:10:56 -04:00
Charlie Marsh	d448281b33	Add plugin properties to settings cache key (#559 )	2022-11-02 22:10:01 -04:00
Charlie Marsh	94597fefc1	Change flake8-quotes default to double quotes (#558 )	2022-11-02 22:03:54 -04:00
Charlie Marsh	add0bdeeb7	DRY up utilities in flake8_comprehensions/fixes.rs (#556 )	2022-11-02 22:00:53 -04:00
Charlie Marsh	6a180b95d1	Implement autofix for dict and tuple comprehensions (#555 )	2022-11-02 21:36:20 -04:00
Charlie Marsh	416c338237	Respect trailing whitespace in comprehension fixes (#554 )	2022-11-02 21:08:17 -04:00
Charlie Marsh	9948be0145	Automatically fix a variety of comprehension rules (#553 )	2022-11-02 20:39:35 -04:00
Charlie Marsh	f50ff61056	Expose autofix mode in public API (#551 )	2022-11-02 09:44:46 -04:00
Charlie Marsh	017fec2bc5	Set override in actions-rs/toolchain@v1 (#543 )	2022-11-02 09:36:22 -04:00
Charlie Marsh	f9def0a139	Bump version to 0.0.95	2022-11-02 09:03:34 -04:00
StefanBRas	d4fc485a76	Update README.md to use table for per-file-ignore (#549 )	2022-11-02 09:02:11 -04:00
Charlie Marsh	0827d0beef	Account for typing_extensions for annotation parsing (#550 )	2022-11-02 09:01:12 -04:00
Charlie Marsh	b4a46ab6f0	Add tests for converter.rs (#542 )	2022-11-01 22:36:08 -04:00
Charlie Marsh	f6e14edc3e	Use max-line-length in converter.rs (#541 )	2022-11-01 22:27:13 -04:00
Charlie Marsh	878a94f9cb	Add a rust-toolchain.toml file (#538 )	2022-11-01 20:34:58 -04:00
Charlie Marsh	79ca66ace5	Use nightly rustfmt with rustfmt.toml (#536 )	2022-11-01 20:34:38 -04:00
fsouza	c68c6b5424	Make columns indices 1-based in the text output format (#539 )	2022-11-01 19:06:08 -04:00
Charlie Marsh	bad5723d80	Add plugin configuration to flake8-to-ruff (#535 )	2022-11-01 17:08:53 -04:00
Charlie Marsh	2d83f99dbf	Bump version to 0.0.94	2022-11-01 16:38:59 -04:00
Charlie Marsh	5123b38758	Refine list of annotatable subscripts (#534 )	2022-11-01 16:36:05 -04:00
Charlie Marsh	e9a4c8ba13	Track typing module imports (#533 )	2022-11-01 14:01:59 -04:00
Charlie Marsh	927d716edd	Enable flake8-to-ruff builds on all platforms	2022-11-01 12:15:43 -04:00
Charlie Marsh	df6a48fced	Use separate tokens for each PyPI release	2022-10-31 22:43:38 -04:00
Charlie Marsh	91a8277ac0	Always release flake8-to-ruff	2022-10-31 22:16:28 -04:00
Charlie Marsh	5797884262	Represent per-file ignores as a map (#531 )	2022-10-31 22:15:33 -04:00
Charlie Marsh	5aa8455258	Misc. improvements to flake8-to-ruff	2022-10-31 18:38:47 -04:00
Charlie Marsh	8fd713739b	Use pretty-print for flake8-to-ruff	2022-10-31 17:52:03 -04:00
Charlie Marsh	5de1fcd653	Add to flake8-to-ruff README	2022-10-31 17:50:32 -04:00
Charlie Marsh	032f4f3f12	Set maturin path when building flake8-to-ruff	2022-10-31 16:49:45 -04:00
Charlie Marsh	621db96e7f	Use more consistent Option in pyproject settings (#530 )	2022-10-31 16:34:58 -04:00
Charlie Marsh	05867ef260	Set flake8-to-ruff release to workflow_dispatch	2022-10-31 16:25:09 -04:00
Charlie Marsh	0cd8b75f06	Rename release.yaml files	2022-10-31 16:23:52 -04:00
Charlie Marsh	5f07e1d6b5	Fix release.yaml task names	2022-10-31 16:22:25 -04:00
Charlie Marsh	1ce4585c88	Add a separate release job for flake8-to-ruff (#529 )	2022-10-31 16:21:38 -04:00
Charlie Marsh	f3f010cdf5	Move flake8-to-ruff to a separate crate (#528 )	2022-10-31 14:22:07 -04:00
Charlie Marsh	7e5e03fb15	Add a Flake8-to-Ruff configuration conversion tool (#527 )	2022-10-31 11:34:40 -04:00
Charlie Marsh	062c41b6f5	Bump version to 0.0.93	2022-10-31 09:20:39 -04:00
Charlie Marsh	78889efa37	Modify public API to return Check rather than Message (#524 )	2022-10-31 09:20:14 -04:00
Charlie Marsh	97fc281779	Remove erroneous foo.py file	2022-10-30 19:19:49 -04:00
Charlie Marsh	138b06c98a	Bump version to 0.0.92	2022-10-30 18:04:30 -04:00
Charlie Marsh	2415d73260	Remove RustPython fork (#523 )	2022-10-30 18:04:05 -04:00
Charlie Marsh	b060ae2f22	Move SourceCodeLocator to its own module (#522 )	2022-10-30 15:51:59 -04:00
Charlie Marsh	9aa91d3d3c	Add a cargo bench for SourceCodeLocator (#521 )	2022-10-30 13:50:42 -04:00
Charlie Marsh	dcedb801e5	Tweak a few check messages (#520 )	2022-10-30 13:13:37 -04:00
Charlie Marsh	d3e7fdabb5	Implement consistent newline handling for SourceCodeLocator (#519 )	2022-10-30 13:11:08 -04:00
Charlie Marsh	dfa5a4f0f7	Fix 9/32 flake8-bugbear reference	2022-10-30 13:03:39 -04:00
Charlie Marsh	58a2d600da	Avoid flagging D202 for inner functions and classes (#518 )	2022-10-30 13:02:55 -04:00
Harutaka Kawamura	7ecbfe4f6a	Implement B006 (#515 )	2022-10-30 12:57:57 -04:00
Charlie Marsh	d8248104a7	Avoid re-indenting empty lines in D207 (#517 )	2022-10-30 09:41:54 -04:00
Charlie Marsh	6eb09122c0	Add final newline in SourceCodeLocator	2022-10-29 19:23:16 -04:00
Charlie Marsh	f84c1f1fa1	Bump version to 0.0.91	2022-10-29 18:49:26 -04:00
Charlie Marsh	3aa9528229	Avoid flake8-comprehensions errors for dicts with kwargs (#512 )	2022-10-29 18:49:06 -04:00