Bump version to 0.0.149

This reverts commit bd08fc359d.

.github/workflows/ci.yaml

@@ -82,7 +82,7 @@ jobs:
             ${{ runner.os }}-build-${{ env.cache-name }}-
             ${{ runner.os }}-build-
             ${{ runner.os }}-
-      - run: cargo clippy --workspace --all-targets --all-features -- -D warnings
+      - run: cargo clippy --workspace --all-targets --all-features -- -D warnings -W clippy::pedantic
 
   cargo_test:
     name: "cargo test"

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

@@ -34,7 +34,6 @@ jobs:
         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
@@ -61,7 +60,6 @@ jobs:
         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
@@ -93,7 +91,6 @@ jobs:
         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: |
@@ -121,7 +118,6 @@ jobs:
           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: |
@@ -148,7 +144,6 @@ jobs:
           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
@@ -187,7 +182,6 @@ jobs:
           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
@@ -223,7 +217,6 @@ jobs:
           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:
@@ -261,7 +254,6 @@ jobs:
       - 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

.github/workflows/ruff.yaml

@@ -36,7 +36,6 @@ jobs:
         with:
           target: x86_64
           args: --release --out dist --sdist
-          maturin-version: "v0.13.0"
       - name: Install built wheel - x86_64
         run: |
           pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
@@ -63,7 +62,6 @@ jobs:
         uses: messense/maturin-action@v1
         with:
           args: --release --universal2 --out dist
-          maturin-version: "v0.13.0"
       - name: Install built wheel - universal2
         run: |
           pip install dist/${{ env.PACKAGE_NAME }}-*universal2.whl --force-reinstall
@@ -95,7 +93,6 @@ jobs:
         with:
           target: ${{ matrix.target }}
           args: --release --out dist
-          maturin-version: "v0.13.0"
       - name: Install built wheel
         shell: bash
         run: |
@@ -123,7 +120,6 @@ jobs:
           target: ${{ matrix.target }}
           manylinux: auto
           args: --release --out dist
-          maturin-version: "v0.13.0"
       - name: Install built wheel
         if: matrix.target == 'x86_64'
         run: |
@@ -150,7 +146,6 @@ jobs:
           target: ${{ matrix.target }}
           manylinux: auto
           args: --no-default-features --release --out dist
-          maturin-version: "v0.13.0"
       - uses: uraimo/run-on-arch-action@v2.0.5
         if: matrix.target != 'ppc64'
         name: Install built wheel
@@ -189,7 +184,6 @@ jobs:
           target: ${{ matrix.target }}
           manylinux: musllinux_1_2
           args: --release --out dist
-          maturin-version: "v0.13.0"
       - name: Install built wheel
         if: matrix.target == 'x86_64-unknown-linux-musl'
         uses: addnab/docker-run-action@v3
@@ -225,7 +219,6 @@ jobs:
           target: ${{ matrix.platform.target }}
           manylinux: musllinux_1_2
           args: --release --out dist
-          maturin-version: "v0.13.0"
       - uses: uraimo/run-on-arch-action@master
         name: Install built wheel
         with:
@@ -263,7 +256,6 @@ jobs:
       - 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 }}

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.123
+    rev: v0.0.149
     hooks:
       - id: ruff
 

CONTRIBUTING.md

@@ -98,6 +98,13 @@ _and_ a `pyproject.toml` parameter to `src/pyproject.rs`. If you want to pattern
 existing example, grep for `dummy_variable_rgx`, which defines a regular expression to match against
 acceptable unused variables (e.g., `_`).
 
+If the new plugin's configuration should be cached between runs, you'll need to add it to the
+`Hash` implementation for `Settings` in `src/settings/mod.rs`.
+
+You may also want to add the new configuration option to the `flake8-to-ruff` tool, which is
+responsible for converting `flake8` configuration files to Ruff's TOML format. This logic
+lives in `flake8_to_ruff/src/converter.rs`.
+
 ## Release process
 
 As of now, Ruff has an ad hoc release process: releases are cut with high frequency via GitHub

Cargo.toml

@@ -6,40 +6,45 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.123"
+version = "0.0.149"
 edition = "2021"
+rust-version = "1.65.0"
 
 [lib]
 name = "ruff"
 
 [dependencies]
+annotate-snippets = { version = "0.9.1", features = ["color"] }
 anyhow = { version = "1.0.66" }
 atty = { version = "0.2.14" }
 bincode = { version = "1.3.3" }
 bitflags = { version = "1.3.2" }
+cachedir = { version = "0.3.0" }
 chrono = { version = "0.4.21", default-features = false, features = ["clock"] }
 clap = { version = "4.0.1", features = ["derive"] }
+clap_complete_command = "0.4.0"
 colored = { version = "2.0.0" }
 common-path = { version = "1.0.0" }
 dirs = { version = "4.0.0" }
 fern = { version = "0.6.1" }
 filetime = { version = "0.2.17" }
-fnv = { version = "1.0.7" }
-glob = { version = "0.3.0" }
+globset = { version = "0.4.9" }
 itertools = { version = "0.10.5" }
-libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "a13ec97dd4eb925bde4d426c6e422582793b260c" }
+libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a8725d161fe8b3ed73a6758b21e177" }
 log = { version = "0.4.17" }
 nohash-hasher = { version = "0.2.0" }
 notify = { version = "4.0.17" }
 num-bigint = { version = "0.4.3" }
 once_cell = { version = "1.16.0" }
 path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
+quick-junit = { version = "0.3.2" }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
 ropey = { version = "1.5.0", features = ["cr_lines", "simd"], default-features = false }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+rustc-hash = { version = "1.1.0" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "f885db8c61514f069979861f6b3bd83292086231" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "f885db8c61514f069979861f6b3bd83292086231" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "f885db8c61514f069979861f6b3bd83292086231" }
 serde = { version = "1.0.147", features = ["derive"] }
 serde_json = { version = "1.0.87" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
@@ -51,7 +56,6 @@ update-informer = { version = "0.5.0", default-features = false, features = ["py
 walkdir = { version = "2.3.2" }
 
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
-cacache = { version = "10.0.1" } # uses async-std
 clearscreen = { version = "1.0.10" } # uses which
 
 # https://docs.rs/getrandom/0.2.7/getrandom/#webassembly-support

LICENSE

@@ -168,6 +168,30 @@ are:
     THE SOFTWARE.
   """
 
+- flake8-blind-except, licensed as follows:
+  """
+    The MIT License (MIT)
+
+    Copyright (c) 2014 Elijah Andrews
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy of
+    this software and associated documentation files (the "Software"), to deal in
+    the Software without restriction, including without limitation the rights to
+    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+    the Software, and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+    FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+    COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+  """
+
 - flake8-bugbear, licensed as follows:
   """
     The MIT License (MIT)
@@ -218,6 +242,81 @@ are:
     SOFTWARE.
   """
 
+- flake8-debugger, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2016 Joseph Kahn
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  """
+
+- flake8-eradicate, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2018 Nikita Sobolev
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  """
+
+- flake8-tidy-imports, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2017 Adam Johnson
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  """
+
 - flake8-print, licensed as follows:
   """
     MIT License
@@ -394,3 +493,28 @@ are:
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     THE SOFTWARE.
   """
+
+- RustPython, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2020 RustPython Team
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  """

benches/source_code_locator.rs

@@ -10,7 +10,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         b.iter(|| {
             let rope = Rope::from_str(black_box(&contents));
             rope.line_to_char(black_box(4));
-        })
+        });
     });
 }
 

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.123"
+version = "0.0.149"
 dependencies = [
  "anyhow",
  "clap",
@@ -1265,7 +1265,7 @@ checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"
 [[package]]
 name = "libcst"
 version = "0.1.0"
-source = "git+https://github.com/charliermarsh/LibCST?rev=a13ec97dd4eb925bde4d426c6e422582793b260c#a13ec97dd4eb925bde4d426c6e422582793b260c"
+source = "git+https://github.com/charliermarsh/LibCST?rev=f2f0b7a487a8725d161fe8b3ed73a6758b21e177#f2f0b7a487a8725d161fe8b3ed73a6758b21e177"
 dependencies = [
  "chic",
  "itertools",
@@ -1280,7 +1280,7 @@ dependencies = [
 [[package]]
 name = "libcst_derive"
 version = "0.1.0"
-source = "git+https://github.com/charliermarsh/LibCST?rev=a13ec97dd4eb925bde4d426c6e422582793b260c#a13ec97dd4eb925bde4d426c6e422582793b260c"
+source = "git+https://github.com/charliermarsh/LibCST?rev=f2f0b7a487a8725d161fe8b3ed73a6758b21e177#f2f0b7a487a8725d161fe8b3ed73a6758b21e177"
 dependencies = [
  "quote",
  "syn",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.123"
+version = "0.0.149"
 dependencies = [
  "anyhow",
  "bincode",
@@ -2028,7 +2028,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.1.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
+source = "git+https://github.com/RustPython/RustPython.git?rev=f885db8c61514f069979861f6b3bd83292086231#f885db8c61514f069979861f6b3bd83292086231"
 dependencies = [
  "num-bigint",
  "rustpython-common",
@@ -2038,7 +2038,7 @@ dependencies = [
 [[package]]
 name = "rustpython-common"
 version = "0.0.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
+source = "git+https://github.com/RustPython/RustPython.git?rev=f885db8c61514f069979861f6b3bd83292086231#f885db8c61514f069979861f6b3bd83292086231"
 dependencies = [
  "ascii",
  "cfg-if 1.0.0",
@@ -2061,7 +2061,7 @@ dependencies = [
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
+source = "git+https://github.com/RustPython/RustPython.git?rev=f885db8c61514f069979861f6b3bd83292086231#f885db8c61514f069979861f6b3bd83292086231"
 dependencies = [
  "bincode",
  "bitflags",
@@ -2078,7 +2078,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
+source = "git+https://github.com/RustPython/RustPython.git?rev=f885db8c61514f069979861f6b3bd83292086231#f885db8c61514f069979861f6b3bd83292086231"
 dependencies = [
  "ahash",
  "anyhow",

flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.123-dev.0"
+version = "0.0.149-dev.0"
 edition = "2021"
 
 [lib]
@@ -10,10 +10,10 @@ name = "flake8_to_ruff"
 anyhow = { version = "1.0.66" }
 clap = { version = "4.0.1", features = ["derive"] }
 configparser = { version = "3.0.2" }
-fnv = { version = "1.0.7" }
 once_cell = { version = "1.16.0" }
 regex = { version = "1.6.0" }
 ruff = { path = "..", default-features = false }
+rustc-hash = { version = "1.1.0" }
 serde = { version = "1.0.147", features = ["derive"] }
 serde_json = { version = "1.0.87" }
 toml = { version = "0.5.9" }

flake8_to_ruff/pyproject.toml

@@ -25,7 +25,7 @@ requires-python = ">=3.7"
 repository = "https://github.com/charliermarsh/ruff#subdirectory=crates/flake8_to_ruff"
 
 [build-system]
-requires = ["maturin>=0.13,<0.14"]
+requires = ["maturin>=0.14,<0.15"]
 build-backend = "maturin"
 
 [tool.maturin]

flake8_to_ruff/src/converter.rs

@@ -3,9 +3,12 @@ use std::collections::{BTreeSet, HashMap};
 use anyhow::Result;
 use ruff::checks_gen::CheckCodePrefix;
 use ruff::flake8_quotes::settings::Quote;
+use ruff::flake8_tidy_imports::settings::Strictness;
 use ruff::settings::options::Options;
 use ruff::settings::pyproject::Pyproject;
-use ruff::{flake8_annotations, flake8_bugbear, flake8_quotes, pep8_naming};
+use ruff::{
+    flake8_annotations, flake8_bugbear, flake8_quotes, flake8_tidy_imports, mccabe, pep8_naming,
+};
 
 use crate::plugin::Plugin;
 use crate::{parser, plugin};
@@ -15,7 +18,7 @@ pub fn convert(
     plugins: Option<Vec<Plugin>>,
 ) -> Result<Pyproject> {
     // Extract all referenced check code prefixes, to power plugin inference.
-    let mut referenced_codes: BTreeSet<CheckCodePrefix> = Default::default();
+    let mut referenced_codes: BTreeSet<CheckCodePrefix> = BTreeSet::default();
     for (key, value) in flake8 {
         if let Some(value) = value {
             match key.as_str() {
@@ -67,11 +70,13 @@ pub fn convert(
         .unwrap_or_default();
 
     // Parse each supported option.
-    let mut options: Options = Default::default();
-    let mut flake8_annotations: flake8_annotations::settings::Options = Default::default();
-    let mut flake8_bugbear: flake8_bugbear::settings::Options = Default::default();
-    let mut flake8_quotes: flake8_quotes::settings::Options = Default::default();
-    let mut pep8_naming: pep8_naming::settings::Options = Default::default();
+    let mut options = Options::default();
+    let mut flake8_annotations = flake8_annotations::settings::Options::default();
+    let mut flake8_bugbear = flake8_bugbear::settings::Options::default();
+    let mut flake8_quotes = flake8_quotes::settings::Options::default();
+    let mut flake8_tidy_imports = flake8_tidy_imports::settings::Options::default();
+    let mut mccabe = mccabe::settings::Options::default();
+    let mut pep8_naming = pep8_naming::settings::Options::default();
     for (key, value) in flake8 {
         if let Some(value) = value {
             match key.as_str() {
@@ -105,7 +110,7 @@ pub fn convert(
                     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))
+                                Some(parser::collect_per_file_ignores(per_file_ignores));
                         }
                         Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
                     }
@@ -172,10 +177,23 @@ pub fn convert(
                     pep8_naming.staticmethod_decorators =
                         Some(parser::parse_strings(value.as_ref()));
                 }
+                // flake8-tidy-imports
+                "ban-relative-imports" | "ban_relative_imports" => match value.trim() {
+                    "true" => flake8_tidy_imports.ban_relative_imports = Some(Strictness::All),
+                    "parents" => {
+                        flake8_tidy_imports.ban_relative_imports = Some(Strictness::Parents);
+                    }
+                    _ => eprintln!("Unexpected '{key}' value: {value}"),
+                },
                 // flake8-docstrings
                 "docstring-convention" => {
                     // No-op (handled above).
                 }
+                // mccabe
+                "max-complexity" | "max_complexity" => match value.clone().parse::<usize>() {
+                    Ok(max_complexity) => mccabe.max_complexity = Some(max_complexity),
+                    Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                },
                 // Unknown
                 _ => eprintln!("Skipping unsupported property: {key}"),
             }
@@ -185,16 +203,22 @@ pub fn convert(
     // Deduplicate and sort.
     options.select = Some(Vec::from_iter(select));
     options.ignore = Some(Vec::from_iter(ignore));
-    if flake8_annotations != Default::default() {
+    if flake8_annotations != flake8_annotations::settings::Options::default() {
         options.flake8_annotations = Some(flake8_annotations);
     }
-    if flake8_bugbear != Default::default() {
+    if flake8_bugbear != flake8_bugbear::settings::Options::default() {
         options.flake8_bugbear = Some(flake8_bugbear);
     }
-    if flake8_quotes != Default::default() {
+    if flake8_quotes != flake8_quotes::settings::Options::default() {
         options.flake8_quotes = Some(flake8_quotes);
     }
-    if pep8_naming != Default::default() {
+    if flake8_tidy_imports != flake8_tidy_imports::settings::Options::default() {
+        options.flake8_tidy_imports = Some(flake8_tidy_imports);
+    }
+    if mccabe != mccabe::settings::Options::default() {
+        options.mccabe = Some(mccabe);
+    }
+    if pep8_naming != pep8_naming::settings::Options::default() {
         options.pep8_naming = Some(pep8_naming);
     }
 
@@ -219,27 +243,35 @@ mod tests {
     fn it_converts_empty() -> Result<()> {
         let actual = convert(&HashMap::from([]), None)?;
         let expected = Pyproject::new(Options {
-            line_length: None,
-            src: None,
-            fix: None,
+            dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
+            extend_ignore: None,
+            extend_select: None,
+            external: None,
+            fix: None,
+            fixable: None,
+            format: None,
+            ignore: Some(vec![]),
+            line_length: None,
+            per_file_ignores: 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,
+            show_source: None,
+            src: None,
             target_version: None,
+            unfixable: None,
             flake8_annotations: None,
             flake8_bugbear: None,
             flake8_quotes: None,
+            flake8_tidy_imports: None,
             isort: None,
+            mccabe: None,
             pep8_naming: None,
+            pyupgrade: None,
         });
         assert_eq!(actual, expected);
 
@@ -253,27 +285,35 @@ mod tests {
             Some(vec![]),
         )?;
         let expected = Pyproject::new(Options {
-            line_length: Some(100),
-            src: None,
-            fix: None,
+            dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
+            extend_ignore: None,
+            extend_select: None,
+            external: None,
+            fix: None,
+            fixable: None,
+            format: None,
+            ignore: Some(vec![]),
+            line_length: Some(100),
+            per_file_ignores: 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,
+            show_source: None,
+            src: None,
             target_version: None,
+            unfixable: None,
             flake8_annotations: None,
             flake8_bugbear: None,
             flake8_quotes: None,
+            flake8_tidy_imports: None,
             isort: None,
+            mccabe: None,
             pep8_naming: None,
+            pyupgrade: None,
         });
         assert_eq!(actual, expected);
 
@@ -287,27 +327,35 @@ mod tests {
             Some(vec![]),
         )?;
         let expected = Pyproject::new(Options {
-            line_length: Some(100),
-            src: None,
-            fix: None,
+            dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
+            extend_ignore: None,
+            extend_select: None,
+            external: None,
+            fix: None,
+            fixable: None,
+            format: None,
+            ignore: Some(vec![]),
+            line_length: Some(100),
+            per_file_ignores: 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,
+            show_source: None,
+            src: None,
             target_version: None,
+            unfixable: None,
             flake8_annotations: None,
             flake8_bugbear: None,
             flake8_quotes: None,
+            flake8_tidy_imports: None,
             isort: None,
+            mccabe: None,
             pep8_naming: None,
+            pyupgrade: None,
         });
         assert_eq!(actual, expected);
 
@@ -321,27 +369,35 @@ mod tests {
             Some(vec![]),
         )?;
         let expected = Pyproject::new(Options {
-            line_length: None,
-            src: None,
-            fix: None,
+            dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
+            extend_ignore: None,
+            extend_select: None,
+            external: None,
+            fix: None,
+            fixable: None,
+            format: None,
+            ignore: Some(vec![]),
+            line_length: None,
+            per_file_ignores: 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,
+            show_source: None,
+            src: None,
             target_version: None,
+            unfixable: None,
             flake8_annotations: None,
             flake8_bugbear: None,
             flake8_quotes: None,
+            flake8_tidy_imports: None,
             isort: None,
+            mccabe: None,
             pep8_naming: None,
+            pyupgrade: None,
         });
         assert_eq!(actual, expected);
 
@@ -355,22 +411,27 @@ mod tests {
             Some(vec![]),
         )?;
         let expected = Pyproject::new(Options {
-            line_length: None,
-            src: None,
-            fix: None,
+            dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
+            extend_ignore: None,
+            extend_select: None,
+            external: None,
+            fix: None,
+            fixable: None,
+            format: None,
+            ignore: Some(vec![]),
+            line_length: None,
+            per_file_ignores: 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,
+            show_source: None,
+            src: None,
             target_version: None,
+            unfixable: None,
             flake8_annotations: None,
             flake8_bugbear: None,
             flake8_quotes: Some(flake8_quotes::settings::Options {
@@ -379,8 +440,11 @@ mod tests {
                 docstring_quotes: None,
                 avoid_escape: None,
             }),
+            flake8_tidy_imports: None,
             isort: None,
+            mccabe: None,
             pep8_naming: None,
+            pyupgrade: None,
         });
         assert_eq!(actual, expected);
 
@@ -397,11 +461,18 @@ mod tests {
             Some(vec![Plugin::Flake8Docstrings]),
         )?;
         let expected = Pyproject::new(Options {
-            line_length: None,
-            src: None,
-            fix: None,
+            dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
+            extend_ignore: None,
+            extend_select: None,
+            external: None,
+            fix: None,
+            fixable: None,
+            format: None,
+            ignore: Some(vec![]),
+            line_length: None,
+            per_file_ignores: None,
             select: Some(vec![
                 CheckCodePrefix::D100,
                 CheckCodePrefix::D101,
@@ -442,17 +513,18 @@ mod tests {
                 CheckCodePrefix::F,
                 CheckCodePrefix::W,
             ]),
-            extend_select: None,
-            ignore: Some(vec![]),
-            extend_ignore: None,
-            per_file_ignores: None,
-            dummy_variable_rgx: None,
+            show_source: None,
+            src: None,
             target_version: None,
+            unfixable: None,
             flake8_annotations: None,
             flake8_bugbear: None,
             flake8_quotes: None,
+            flake8_tidy_imports: None,
             isort: None,
+            mccabe: None,
             pep8_naming: None,
+            pyupgrade: None,
         });
         assert_eq!(actual, expected);
 
@@ -466,23 +538,28 @@ mod tests {
             None,
         )?;
         let expected = Pyproject::new(Options {
-            line_length: None,
-            src: None,
-            fix: None,
+            dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
+            extend_ignore: None,
+            extend_select: None,
+            external: None,
+            fix: None,
+            fixable: None,
+            format: None,
+            ignore: Some(vec![]),
+            line_length: None,
+            per_file_ignores: 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,
+            show_source: None,
+            src: None,
             target_version: None,
+            unfixable: None,
             flake8_annotations: None,
             flake8_bugbear: None,
             flake8_quotes: Some(flake8_quotes::settings::Options {
@@ -491,8 +568,11 @@ mod tests {
                 docstring_quotes: None,
                 avoid_escape: None,
             }),
+            flake8_tidy_imports: None,
             isort: None,
+            mccabe: None,
             pep8_naming: None,
+            pyupgrade: None,
         });
         assert_eq!(actual, expected);
 

flake8_to_ruff/src/lib.rs

@@ -1,4 +1,15 @@
-#![allow(clippy::collapsible_if, clippy::collapsible_else_if)]
+#![allow(
+    clippy::collapsible_else_if,
+    clippy::collapsible_if,
+    clippy::implicit_hasher,
+    clippy::match_same_arms,
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::similar_names,
+    clippy::too_many_lines
+)]
 
 pub mod converter;
 mod parser;

flake8_to_ruff/src/main.rs

@@ -1,4 +1,16 @@
 //! Utility to generate Ruff's pyproject.toml section from a Flake8 INI file.
+#![allow(
+    clippy::collapsible_else_if,
+    clippy::collapsible_if,
+    clippy::implicit_hasher,
+    clippy::match_same_arms,
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::similar_names,
+    clippy::too_many_lines
+)]
 
 use std::path::PathBuf;
 

flake8_to_ruff/src/parser.rs

@@ -1,11 +1,11 @@
 use std::str::FromStr;
 
 use anyhow::Result;
-use fnv::FnvHashMap;
 use once_cell::sync::Lazy;
 use regex::Regex;
 use ruff::checks_gen::CheckCodePrefix;
 use ruff::settings::types::PatternPrefixPair;
+use rustc_hash::FxHashMap;
 
 static COMMA_SEPARATED_LIST_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"[,\s]").unwrap());
 
@@ -31,7 +31,7 @@ pub fn parse_prefix_codes(value: &str) -> Vec<CheckCodePrefix> {
 pub fn parse_strings(value: &str) -> Vec<String> {
     COMMA_SEPARATED_LIST_RE
         .split(value)
-        .map(|part| part.trim())
+        .map(str::trim)
         .filter(|part| !part.is_empty())
         .map(String::from)
         .collect()
@@ -92,7 +92,7 @@ impl State {
                         });
                     }
                 }
-                Err(_) => eprintln!("Skipping unrecognized prefix: {}", code),
+                Err(_) => eprintln!("Skipping unrecognized prefix: {code}"),
             }
         }
         codes
@@ -129,14 +129,14 @@ fn tokenize_files_to_codes_mapping(value: &str) -> Vec<Token> {
     }
     tokens.push(Token {
         token_name: TokenType::Eof,
-        src: "".to_string(),
+        src: String::new(),
     });
     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
+/// 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![]);
@@ -179,8 +179,8 @@ pub fn parse_files_to_codes_mapping(value: &str) -> Result<Vec<PatternPrefixPair
 /// Collect a list of `PatternPrefixPair` structs as a `BTreeMap`.
 pub fn collect_per_file_ignores(
     pairs: Vec<PatternPrefixPair>,
-) -> FnvHashMap<String, Vec<CheckCodePrefix>> {
-    let mut per_file_ignores: FnvHashMap<String, Vec<CheckCodePrefix>> = FnvHashMap::default();
+) -> FxHashMap<String, Vec<CheckCodePrefix>> {
+    let mut per_file_ignores: FxHashMap<String, Vec<CheckCodePrefix>> = FxHashMap::default();
     for pair in pairs {
         per_file_ignores
             .entry(pair.pattern)

flake8_to_ruff/src/plugin.rs

@@ -6,14 +6,19 @@ use ruff::checks_gen::CheckCodePrefix;
 
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub enum Plugin {
+    Flake8Annotations,
     Flake8Bandit,
+    Flake8BlindExcept,
     Flake8Bugbear,
     Flake8Builtins,
     Flake8Comprehensions,
+    Flake8Debugger,
     Flake8Docstrings,
+    Flake8Eradicate,
     Flake8Print,
     Flake8Quotes,
-    Flake8Annotations,
+    Flake8TidyImports,
+    McCabe,
     PEP8Naming,
     Pyupgrade,
 }
@@ -23,14 +28,19 @@ impl FromStr for Plugin {
 
     fn from_str(string: &str) -> Result<Self, Self::Err> {
         match string {
+            "flake8-annotations" => Ok(Plugin::Flake8Annotations),
             "flake8-bandit" => Ok(Plugin::Flake8Bandit),
+            "flake8-blind-except" => Ok(Plugin::Flake8BlindExcept),
             "flake8-bugbear" => Ok(Plugin::Flake8Bugbear),
             "flake8-builtins" => Ok(Plugin::Flake8Builtins),
             "flake8-comprehensions" => Ok(Plugin::Flake8Comprehensions),
+            "flake8-debugger" => Ok(Plugin::Flake8Debugger),
             "flake8-docstrings" => Ok(Plugin::Flake8Docstrings),
+            "flake8-eradicate" => Ok(Plugin::Flake8BlindExcept),
             "flake8-print" => Ok(Plugin::Flake8Print),
             "flake8-quotes" => Ok(Plugin::Flake8Quotes),
-            "flake8-annotations" => Ok(Plugin::Flake8Annotations),
+            "flake8-tidy-imports" => Ok(Plugin::Flake8TidyImports),
+            "mccabe" => Ok(Plugin::McCabe),
             "pep8-naming" => Ok(Plugin::PEP8Naming),
             "pyupgrade" => Ok(Plugin::Pyupgrade),
             _ => Err(anyhow!("Unknown plugin: {}", string)),
@@ -41,14 +51,19 @@ impl FromStr for Plugin {
 impl Plugin {
     pub fn default(&self) -> CheckCodePrefix {
         match self {
+            Plugin::Flake8Annotations => CheckCodePrefix::ANN,
             Plugin::Flake8Bandit => CheckCodePrefix::S,
+            Plugin::Flake8BlindExcept => CheckCodePrefix::BLE,
             Plugin::Flake8Bugbear => CheckCodePrefix::B,
             Plugin::Flake8Builtins => CheckCodePrefix::A,
-            Plugin::Flake8Comprehensions => CheckCodePrefix::C,
+            Plugin::Flake8Comprehensions => CheckCodePrefix::C4,
+            Plugin::Flake8Debugger => CheckCodePrefix::T1,
             Plugin::Flake8Docstrings => CheckCodePrefix::D,
-            Plugin::Flake8Print => CheckCodePrefix::T,
+            Plugin::Flake8Eradicate => CheckCodePrefix::ERA,
+            Plugin::Flake8Print => CheckCodePrefix::T2,
             Plugin::Flake8Quotes => CheckCodePrefix::Q,
-            Plugin::Flake8Annotations => CheckCodePrefix::ANN,
+            Plugin::Flake8TidyImports => CheckCodePrefix::I25,
+            Plugin::McCabe => CheckCodePrefix::C9,
             Plugin::PEP8Naming => CheckCodePrefix::N,
             Plugin::Pyupgrade => CheckCodePrefix::U,
         }
@@ -56,10 +71,13 @@ impl Plugin {
 
     pub fn select(&self, flake8: &HashMap<String, Option<String>>) -> Vec<CheckCodePrefix> {
         match self {
+            Plugin::Flake8Annotations => vec![CheckCodePrefix::ANN],
             Plugin::Flake8Bandit => vec![CheckCodePrefix::S],
+            Plugin::Flake8BlindExcept => vec![CheckCodePrefix::BLE],
             Plugin::Flake8Bugbear => vec![CheckCodePrefix::B],
             Plugin::Flake8Builtins => vec![CheckCodePrefix::A],
-            Plugin::Flake8Comprehensions => vec![CheckCodePrefix::C],
+            Plugin::Flake8Comprehensions => vec![CheckCodePrefix::C4],
+            Plugin::Flake8Debugger => vec![CheckCodePrefix::T1],
             Plugin::Flake8Docstrings => {
                 // Use the user-provided docstring.
                 for key in ["docstring-convention", "docstring_convention"] {
@@ -76,9 +94,11 @@ impl Plugin {
                 // Default to PEP8.
                 DocstringConvention::PEP8.select()
             }
-            Plugin::Flake8Print => vec![CheckCodePrefix::T],
+            Plugin::Flake8Eradicate => vec![CheckCodePrefix::ERA],
+            Plugin::Flake8Print => vec![CheckCodePrefix::T2],
             Plugin::Flake8Quotes => vec![CheckCodePrefix::Q],
-            Plugin::Flake8Annotations => vec![CheckCodePrefix::ANN],
+            Plugin::Flake8TidyImports => vec![CheckCodePrefix::I25],
+            Plugin::McCabe => vec![CheckCodePrefix::C9],
             Plugin::PEP8Naming => vec![CheckCodePrefix::N],
             Plugin::Pyupgrade => vec![CheckCodePrefix::U],
         }
@@ -265,31 +285,6 @@ pub fn infer_plugins_from_options(flake8: &HashMap<String, Option<String>>) -> V
     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-bugbear
-            "extend-immutable-calls" | "extend_immutable_calls" => {
-                plugins.insert(Plugin::Flake8Bugbear);
-            }
-            // 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);
-            }
             // flake8-annotations
             "suppress-none-returning" | "suppress_none_returning" => {
                 plugins.insert(Plugin::Flake8Annotations);
@@ -315,6 +310,52 @@ pub fn infer_plugins_from_options(flake8: &HashMap<String, Option<String>>) -> V
             "allow-star-arg-any" | "allow_star_arg_any" => {
                 plugins.insert(Plugin::Flake8Annotations);
             }
+            // flake8-bugbear
+            "extend-immutable-calls" | "extend_immutable_calls" => {
+                plugins.insert(Plugin::Flake8Bugbear);
+            }
+            // flake8-builtins
+            "builtins-ignorelist" | "builtins_ignorelist" => {
+                plugins.insert(Plugin::Flake8Builtins);
+            }
+            // flake8-docstrings
+            "docstring-convention" | "docstring_convention" => {
+                plugins.insert(Plugin::Flake8Docstrings);
+            }
+            // flake8-eradicate
+            "eradicate-aggressive" | "eradicate_aggressive" => {
+                plugins.insert(Plugin::Flake8Eradicate);
+            }
+            "eradicate-whitelist" | "eradicate_whitelist" => {
+                plugins.insert(Plugin::Flake8Eradicate);
+            }
+            "eradicate-whitelist-extend" | "eradicate_whitelist_extend" => {
+                plugins.insert(Plugin::Flake8Eradicate);
+            }
+            // 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);
+            }
+            // flake8-tidy-imports
+            "ban-relative-imports" | "ban_relative_imports" => {
+                plugins.insert(Plugin::Flake8TidyImports);
+            }
+            "banned-modules" | "banned_modules" => {
+                plugins.insert(Plugin::Flake8TidyImports);
+            }
+            // mccabe
+            "max-complexity" | "max_complexity" => {
+                plugins.insert(Plugin::McCabe);
+            }
             // pep8-naming
             "ignore-names" | "ignore_names" => {
                 plugins.insert(Plugin::PEP8Naming);
@@ -337,14 +378,18 @@ pub fn infer_plugins_from_options(flake8: &HashMap<String, Option<String>>) -> V
 /// `flake8-annotations` is active.
 pub fn infer_plugins_from_codes(codes: &BTreeSet<CheckCodePrefix>) -> Vec<Plugin> {
     [
+        Plugin::Flake8Annotations,
         Plugin::Flake8Bandit,
+        Plugin::Flake8BlindExcept,
         Plugin::Flake8Bugbear,
         Plugin::Flake8Builtins,
         Plugin::Flake8Comprehensions,
+        Plugin::Flake8Debugger,
         Plugin::Flake8Docstrings,
+        Plugin::Flake8Eradicate,
         Plugin::Flake8Print,
         Plugin::Flake8Quotes,
-        Plugin::Flake8Annotations,
+        Plugin::Flake8TidyImports,
         Plugin::PEP8Naming,
         Plugin::Pyupgrade,
     ]

pyproject.toml

@@ -25,14 +25,9 @@ requires-python = ">=3.7"
 repository = "https://github.com/charliermarsh/ruff"
 
 [build-system]
-requires = ["maturin>=0.13,<0.14"]
+requires = ["maturin>=0.14,<0.15"]
 build-backend = "maturin"
 
 [tool.maturin]
 bindings = "bin"
-sdist-include = ["Cargo.lock"]
 strip = true
-
-[tool.isort]
-profile = "black"
-known_third_party = ["fastapi", "pydantic", "starlette"]

resources/test/fixtures/B006_B008.py

@@ -185,3 +185,23 @@ def nested_b008(a=random.randint(0, dt.datetime.now().year)):
 # Ignore lambda contents since they are evaluated at call time.
 def foo(f=lambda x: print(x)):
     f(1)
+
+
+from collections import abc
+from typing import Annotated, Dict, Optional, Sequence, Union, Set
+
+
+def immutable_annotations(
+    a: Sequence[int] | None = [],
+    b: Optional[abc.Mapping[int, int]] = {},
+    c: Annotated[Union[abc.Set[str], abc.Sized], "annotation"] = set(),
+):
+    pass
+
+
+def mutable_annotations(
+    a: list[int] | None = [],
+    b: Optional[Dict[int, int]] = {},
+    c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+):
+    pass

resources/test/fixtures/B009_B010.py

@@ -34,3 +34,4 @@ setattr(foo, "bar", None)
 setattr(foo, "_123abc", None)
 setattr(foo, "abc123", None)
 setattr(foo, r"abc123", None)
+setattr(foo.bar, r"baz", None)

resources/test/fixtures/B023.py

@@ -0,0 +1,82 @@
+"""
+Should emit:
+B023 - on lines 12, 13, 16, 28, 29, 30, 31, 40, 42, 50, 51, 52, 53, 61, 68.
+"""
+
+functions = []
+z = 0
+
+for x in range(3):
+    y = x + 1
+    # Subject to late-binding problems
+    functions.append(lambda: x)
+    functions.append(lambda: y)  # not just the loop var
+
+    def f_bad_1():
+        return x
+
+    # Actually OK
+    functions.append(lambda x: x * 2)
+    functions.append(lambda x=x: x)
+    functions.append(lambda: z)  # OK because not assigned in the loop
+
+    def f_ok_1(x):
+        return x * 2
+
+
+def check_inside_functions_too():
+    ls = [lambda: x for x in range(2)]
+    st = {lambda: x for x in range(2)}
+    gn = (lambda: x for x in range(2))
+    dt = {x: lambda: x for x in range(2)}
+
+
+async def pointless_async_iterable():
+    yield 1
+
+
+async def container_for_problems():
+    async for x in pointless_async_iterable():
+        functions.append(lambda: x)
+
+    [lambda: x async for x in pointless_async_iterable()]
+
+
+a = 10
+b = 0
+while True:
+    a = a_ = a - 1
+    b += 1
+    functions.append(lambda: a)
+    functions.append(lambda: a_)
+    functions.append(lambda: b)
+    functions.append(lambda: c)  # not a name error because of late binding!
+    c: bool = a > 3
+    if not c:
+        break
+
+# Nested loops should not duplicate reports
+for j in range(2):
+    for k in range(3):
+        lambda: j * k
+
+
+for j, k, l in [(1, 2, 3)]:
+
+    def f():
+        j = None  # OK because it's an assignment
+        [l for k in range(2)]  # error for l, not for k
+
+        assert a and functions
+
+    a.attribute = 1  # modifying an attribute doesn't make it a loop variable
+    functions[0] = lambda: None  # same for an element
+
+for var in range(2):
+
+    def explicit_capture(captured=var):
+        return captured
+
+
+for i in range(3):
+    lambda: f"{i}"

resources/test/fixtures/B904.py

@@ -0,0 +1,55 @@
+"""
+Should emit:
+B904 - on lines 10, 11 and 16
+"""
+
+try:
+    raise ValueError
+except ValueError:
+    if "abc":
+        raise TypeError
+    raise UserWarning
+except AssertionError:
+    raise  # Bare `raise` should not be an error
+except Exception as err:
+    assert err
+    raise Exception("No cause here...")
+except BaseException as base_err:
+    # Might use this instead of bare raise with the `.with_traceback()` method
+    raise base_err
+finally:
+    raise Exception("Nothing to chain from, so no warning here")
+
+try:
+    raise ValueError
+except ValueError:
+    # should not emit, since we are not raising something
+    def proxy():
+        raise NameError
+
+
+try:
+    from preferred_library import Thing
+except ImportError:
+    try:
+        from fallback_library import Thing
+    except ImportError:
+
+        class Thing:
+            def __getattr__(self, name):
+                # same as the case above, should not emit.
+                raise AttributeError
+
+
+try:
+    from preferred_library import Thing
+except ImportError:
+    try:
+        from fallback_library import Thing
+    except ImportError:
+
+        def context_switch():
+            try:
+                raise ValueError
+            except ValueError:
+                raise

resources/test/fixtures/BLE.py

@@ -0,0 +1,55 @@
+try:
+    pass
+except ValueError:
+    pass
+except Exception as e:
+    raise e
+finally:
+    pass
+
+
+try:
+    pass
+except BaseException as e:
+    raise e
+except TypeError:
+    pass
+else:
+    pass
+
+
+try:
+    pass
+except Exception as e:
+    raise e
+except BaseException:
+    pass
+
+
+try:
+    pass
+except Exception:
+    pass
+finally:
+    try:
+        pass
+    except BaseException as e:
+        raise e
+
+
+try:
+    pass
+except Exception as e:
+    try:
+        raise e
+    except BaseException:
+        pass
+
+
+try:
+    try:
+        pass
+    except BaseException as e:
+        raise e
+except Exception:
+    pass

resources/test/fixtures/C901.py

@@ -0,0 +1,138 @@
+# Complexity = 1
+def trivial():
+    pass
+
+
+# Complexity = 1
+def expr_as_statement():
+    0xF00D
+
+
+# Complexity = 1
+def sequential(n):
+    k = n + 4
+    s = k + n
+    return s
+
+
+# Complexity = 3
+def if_elif_else_dead_path(n):
+    if n > 3:
+        return "bigger than three"
+    elif n > 4:
+        return "is never executed"
+    else:
+        return "smaller than or equal to three"
+
+
+# Complexity = 3
+def nested_ifs():
+    if n > 3:
+        if n > 4:
+            return "bigger than four"
+        else:
+            return "bigger than three"
+    else:
+        return "smaller than or equal to three"
+
+
+# Complexity = 2
+def for_loop():
+    for i in range(10):
+        print(i)
+
+
+# Complexity = 2
+def for_else(mylist):
+    for i in mylist:
+        print(i)
+    else:
+        print(None)
+
+
+# Complexity = 2
+def recursive(n):
+    if n > 4:
+        return f(n - 1)
+    else:
+        return n
+
+
+# Complexity = 3
+def nested_functions():
+    def a():
+        def b():
+            pass
+
+        b()
+
+    a()
+
+
+# Complexity = 4
+def try_else():
+    try:
+        print(1)
+    except TypeA:
+        print(2)
+    except TypeB:
+        print(3)
+    else:
+        print(4)
+
+
+# Complexity = 3
+def nested_try_finally():
+    try:
+        try:
+            print(1)
+        finally:
+            print(2)
+    finally:
+        print(3)
+
+
+# Complexity = 3
+async def foobar(a, b, c):
+    await whatever(a, b, c)
+    if await b:
+        pass
+    async with c:
+        pass
+    async for x in a:
+        pass
+
+
+# Complexity = 1
+def annotated_assign():
+    x: Any = None
+
+
+# Complexity = 9
+class Class:
+    def handle(self, *args, **options):
+        if args:
+            return
+
+        class ServiceProvider:
+            def a(self):
+                pass
+
+            def b(self, data):
+                if not args:
+                    pass
+
+        class Logger:
+            def c(*args, **kwargs):
+                pass
+
+            def error(self, message):
+                pass
+
+            def info(self, message):
+                pass
+
+            def exception(self):
+                pass
+
+        return ServiceProvider(Logger())

resources/test/fixtures/D.py

@@ -3,6 +3,7 @@ from functools import wraps
 import os
 from .expected import Expectation
 from typing import overload
+from typing_extensions import override
 
 
 expectation = Expectation()
@@ -42,9 +43,13 @@ class class_:
            "D418: Function/ Method decorated with @overload"
            " shouldn't contain a docstring")
 
+    @override
+    def overridden_method(a):
+        return str(a)
+
     @property
     def foo(self):
-        """The foo of the thing, which isn't in imperitive mood."""
+        """The foo of the thing, which isn't in imperative mood."""
         return "hello"
 
     @expect('D102: Missing docstring in public method')
@@ -532,3 +537,37 @@ class Blah:  # noqa: D203,D213
 
 expect(os.path.normcase(__file__ if __file__[-1] != 'c' else __file__[:-1]),
        'D100: Missing docstring in public module')
+
+
+@expect('D201: No blank lines allowed before function docstring (found 1)')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def multiline_leading_space():
+
+    """Leading space.
+
+    More content.
+    """
+
+
+@expect('D202: No blank lines allowed after function docstring (found 1)')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def multiline_trailing_space():
+    """Leading space.
+
+    More content.
+    """
+
+    pass
+
+
+@expect('D201: No blank lines allowed before function docstring (found 1)')
+@expect('D202: No blank lines allowed after function docstring (found 1)')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def multiline_trailing_and_leading_space():
+
+    """Trailing and leading space.
+
+    More content.
+    """
+
+    pass

resources/test/fixtures/E501.py

@@ -49,3 +49,9 @@ sit amet  consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labor
 sit amet  consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 """,  # noqa: E501
 }
+
+# OK
+# A very long URL: https://loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong.url.com
+
+# OK
+# https://loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong.url.com

resources/test/fixtures/E711.py

@@ -23,6 +23,9 @@ if None != res[1]:
 if None == res[1]:
     pass
 
+if x == None != None:
+    pass
+
 #: Okay
 if x not in y:
     pass

resources/test/fixtures/E712.py

@@ -22,6 +22,9 @@ var = 1 if cond == True else -1 if cond == False else cond
 if (True) == TrueElement or x == TrueElement:
     pass
 
+if res == True != False:
+    pass
+
 #: Okay
 if x not in y:
     pass

resources/test/fixtures/ERA001.py

@@ -0,0 +1,13 @@
+#import os
+# from foo import junk
+#a = 3
+a = 4
+#foo(1, 2, 3)
+
+def foo(x, y, z):
+    contentet = 1 # print('hello')
+    print(x, y, z)
+
+    # This is a real comment.
+    #return True
+    return False

resources/test/fixtures/F502.py

@@ -0,0 +1,13 @@
+dog = {"bob": "bob"}
+
+"%(bob)s" % dog
+"%(bob)s" % {"bob": "bob"}
+"%(bob)s" % {**{"bob": "bob"}}
+"%(bob)s" % ["bob"]  # F202
+"%(bob)s" % ("bob",)  # F202
+"%(bob)s" % {"bob"}  # F202
+"%(bob)s" % [*["bob"]]  # F202
+"%(bob)s" % {"bob": "bob" for _ in range(1)}
+"%(bob)s" % ["bob" for _ in range(1)]  # F202
+"%(bob)s" % ("bob" for _ in range(1))  # F202
+"%(bob)s" % {"bob" for _ in range(1)}  # F202

resources/test/fixtures/F503.py

@@ -0,0 +1,26 @@
+dog = {"bob": "bob"}
+
+# Single placeholder always fine
+"%s" % dog
+"%s" % {"bob": "bob"}
+"%s" % {**{"bob": "bob"}}
+"%s" % ["bob"]
+"%s" % ("bob",)
+"%s" % {"bob"}
+"%s" % [*["bob"]]
+"%s" % {"bob": "bob" for _ in range(1)}
+"%s" % ["bob" for _ in range(1)]
+"%s" % ("bob" for _ in range(1))
+"%s" % {"bob" for _ in range(1)}
+# Multiple placeholders
+"%s %s" % dog
+"%s %s" % {"bob": "bob"}  # F503
+"%s %s" % {**{"bob": "bob"}}  # F503
+"%s %s" % ["bob"]
+"%s %s" % ("bob",)
+"%s %s" % {"bob"}
+"%s %s" % [*["bob"]]
+"%s %s" % {"bob": "bob" for _ in range(1)}  # F503
+"%s %s" % ["bob" for _ in range(1)]
+"%s %s" % ("bob" for _ in range(1))
+"%s %s" % {"bob" for _ in range(1)}

resources/test/fixtures/F504.py

@@ -0,0 +1,6 @@
+# Ruff has no way of knowing if the following are F505s
+a = "wrong"
+"%(a)s %(c)s" % {a: "?", "b": "!"}  # F504 ("b" not used)
+
+hidden = {"a": "!"}
+"%(a)s %(c)s" % {"x": 1, **hidden}  # Ok (cannot see through splat)

resources/test/fixtures/F50x.py

@@ -0,0 +1,25 @@
+'%(foo)' % {'foo': 'bar'}  # F501
+'%s %(foo)s' % {'foo': 'bar'}  # F506
+'%(foo)s %s' % {'foo': 'bar'}  # F506
+'%j' % (1,)  # F509
+'%s %s' % (1,)  # F507
+'%s %s' % (1, 2, 3)  # F507
+'%(bar)s' % {}  # F505
+'%(bar)s' % {'bar': 1, 'baz': 2}  # F504
+'%(bar)s' % (1, 2, 3)  # F502
+'%s %s' % {'k': 'v'}  # F503
+'%(bar)*s' % {'bar': 'baz'}  # F506, F508
+
+# ok: single %s with mapping
+'%s' % {'foo': 'bar', 'baz': 'womp'}
+# ok: %% should not count towards placeholder count
+'%% %s %% %s' % (1, 2)
+# ok: * consumes one positional argument
+'%.*f' % (2, 1.1234)
+'%*.*f' % (5, 2, 3.1234)
+# ok *args and **kwargs
+a = []
+'%s %s' % [*a]
+'%s %s' % (*a,)
+k = {}
+'%(k)s' % {**k}

resources/test/fixtures/F521.py

@@ -0,0 +1,21 @@
+"{".format(1)
+"}".format(1)
+"{foo[}".format(foo=1)
+# too much string recursion (placeholder-in-placeholder)
+"{:{:{}}}".format(1, 2, 3)
+# ruff picks these issues up, but flake8 doesn't
+"{foo[]}".format(foo={"": 1})
+"{foo..}".format(foo=1)
+"{foo..bar}".format(foo=1)
+
+# The following are all "good" uses of .format
+"{.__class__}".format("")
+"{foo[bar]}".format(foo={"bar": "barv"})
+"{[bar]}".format({"bar": "barv"})
+"{:{}} {}".format(1, 15, 2)
+"{:2}".format(1)
+"{foo}-{}".format(1, foo=2)
+a = ()
+"{}".format(*a)
+k = {}
+"{foo}".format(**k)

resources/test/fixtures/F522.py

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

resources/test/fixtures/F523.py

@@ -0,0 +1,12 @@
+# With indexes
+"{0}".format(1, 2)  # F523
+"{1}".format(1, 2, 3)  # F523
+"{1:{0}}".format(1, 2)  # No issues
+"{1:{0}}".format(1, 2, 3)  # F523
+"{0}{2}".format(1, 2)  # F523, # F524
+
+# With no indexes
+"{}".format(1, 2)  # F523
+"{}".format(1, 2, 3)  # F523
+"{:{}}".format(1, 2)  # No issues
+"{:{}}".format(1, 2, 3)  # F523

resources/test/fixtures/F524.py

@@ -0,0 +1,6 @@
+"{} {}".format(1)  # F524
+"{2}".format()  # F524
+"{bar}".format()  # F524
+"{0} {bar}".format(1)  # F524
+"{0} {bar}".format()  # F524
+"{bar} {0}".format()  # F524

resources/test/fixtures/F525.py

@@ -0,0 +1,2 @@
+"{} {1}".format(1, 2)  # F525
+"{0} {}".format(1, 2)  # F523, F525

resources/test/fixtures/F821_3.py

@@ -12,3 +12,13 @@ x: dict["key", "value"]
 
 # OK
 x: dict[str, str]
+
+# OK
+def unimportant(name):
+    pass
+
+
+def dang(dict, set, list):
+    unimportant(name=dict["name"])
+    unimportant(name=set["name"])
+    unimportant(name=list["name"])

resources/test/fixtures/F841.py

@@ -35,3 +35,33 @@ def f4():
     _ = 1
     __ = 1
     _discarded = 1
+
+
+a = 1
+
+
+def f5():
+    global a
+
+    # Used in `f7` via `nonlocal`.
+    b = 1
+
+    def f6():
+        # F841
+        b = 1
+
+    def f7():
+        nonlocal b
+
+
+def f6():
+    annotations = []
+    assert len([annotations for annotations in annotations])
+
+
+def f7():
+    def connect():
+        return None, None
+
+    with connect() as (connection, cursor):
+        cursor.execute("SELECT * FROM users")

resources/test/fixtures/FBT.py

@@ -0,0 +1,57 @@
+def function(
+    posonly_nohint,
+    posonly_nonboolhint: int,
+    posonly_boolhint: bool,
+    posonly_boolstrhint: "bool",
+    /,
+    offset,
+    posorkw_nonvalued_nohint,
+    posorkw_nonvalued_nonboolhint: int,
+    posorkw_nonvalued_boolhint: bool,
+    posorkw_nonvalued_boolstrhint: "bool",
+    posorkw_boolvalued_nohint=True,
+    posorkw_boolvalued_nonboolhint: int = True,
+    posorkw_boolvalued_boolhint: bool = True,
+    posorkw_boolvalued_boolstrhint: "bool" = True,
+    posorkw_nonboolvalued_nohint=1,
+    posorkw_nonboolvalued_nonboolhint: int = 2,
+    posorkw_nonboolvalued_boolhint: bool = 3,
+    posorkw_nonboolvalued_boolstrhint: "bool" = 4,
+    *,
+    kwonly_nonvalued_nohint,
+    kwonly_nonvalued_nonboolhint: int,
+    kwonly_nonvalued_boolhint: bool,
+    kwonly_nonvalued_boolstrhint: "bool",
+    kwonly_boolvalued_nohint=True,
+    kwonly_boolvalued_nonboolhint: int = False,
+    kwonly_boolvalued_boolhint: bool = True,
+    kwonly_boolvalued_boolstrhint: "bool" = True,
+    kwonly_nonboolvalued_nohint=5,
+    kwonly_nonboolvalued_nonboolhint: int = 1,
+    kwonly_nonboolvalued_boolhint: bool = 1,
+    kwonly_nonboolvalued_boolstrhint: "bool" = 1,
+    **kw,
+):
+    ...
+
+
+def used(do):
+    return do
+
+
+used("a", True)
+used(do=True)
+
+
+# Avoid FBT003 for explicitly allowed methods.
+"""
+FBT003 Boolean positional value on dict
+"""
+a = {"a": "b"}
+a.get("hello", False)
+{}.get("hello", False)
+{}.setdefault("hello", True)
+{}.pop("hello", False)
+{}.pop(True, False)
+dict.fromkeys(("world",), True)
+{}.deploy(True, False)

resources/test/fixtures/I252.py

@@ -0,0 +1,12 @@
+from . import sibling
+from .sibling import example
+
+from .. import parent
+from ..parent import example
+
+from ... import grandparent
+from ...grandparent import example
+
+import other
+import other.example
+from other import example

resources/test/fixtures/M001.py

@@ -18,6 +18,17 @@ def f() -> None:
     # Invalid (and unimplemented)
     d = 1  # noqa: F841, W191
 
+    # Invalid (but external)
+    d = 1  # noqa: F841, V101
+
+    # fmt: off
+    # Invalid - no space before #
+    d = 1# noqa: E501
+
+    # Invalid - many spaces before #
+    d = 1                       # noqa: E501
+    # fmt: on
+
 
 # Valid
 _ = """Lorem ipsum dolor sit amet.

resources/test/fixtures/N804.py

@@ -30,6 +30,14 @@ class Class:
     def __init_subclass__(self, default_name, **kwargs):
         ...
 
+    @classmethod
+    def class_method_with_positional_only_argument(cls, x, /, other):
+        ...
+
+    @classmethod
+    def bad_class_method_with_positional_only_argument(self, x, /, other):
+        ...
+
 
 class MetaClass(ABCMeta):
     def bad_method(self):

resources/test/fixtures/N805.py

@@ -1,5 +1,7 @@
 from abc import ABCMeta
 
+import pydantic
+
 
 class Class:
     def bad_method(this):
@@ -21,6 +23,14 @@ class Class:
     def static_method(x):
         return x
 
+    @pydantic.validator
+    def lower(cls, my_field: str) -> str:
+        pass
+
+    @pydantic.validator("my_field")
+    def lower(cls, my_field: str) -> str:
+        pass
+
     def __init__(self):
         ...
 

resources/test/fixtures/N806.py

@@ -1,8 +1,12 @@
 import collections
 from collections import namedtuple
 
+GLOBAL: str = "foo"
+
 
 def f():
+    global GLOBAL
+    GLOBAL = "bar"
     lower = 0
     Camel = 0
     CONSTANT = 0

resources/test/fixtures/N807.py

@@ -10,6 +10,27 @@ def good__():
     pass
 
 
+def nested():
+    def __bad__():
+        pass
+
+    def __good():
+        pass
+
+    def good__():
+        pass
+
+
 class Class:
     def __good__(self):
         pass
+
+
+# https://peps.python.org/pep-0562/
+def __getattr__(name):
+    pass
+
+
+# https://peps.python.org/pep-0562/
+def __dir__():
+    pass

resources/test/fixtures/N818.py

@@ -8,3 +8,11 @@ class AnotherError(Exception):
 
 class C(Exception):
     pass
+
+
+class D(BaseException):
+    pass
+
+
+class E(AnotherError):
+    pass

resources/test/fixtures/RUF101_0.py

@@ -0,0 +1,5 @@
+exit(0)
+
+
+def main():
+    exit(2)

resources/test/fixtures/RUF101_1.py

@@ -0,0 +1,10 @@
+import sys
+
+exit(0)
+
+
+def main():
+    exit(1)
+
+
+sys.exit(2)

resources/test/fixtures/RUF101_2.py

@@ -0,0 +1,7 @@
+import sys as sys2
+
+exit(0)
+
+
+def main():
+    exit(1)

resources/test/fixtures/RUF101_3.py

@@ -0,0 +1,7 @@
+from sys import exit
+
+exit(0)
+
+
+def main():
+    exit(1)

resources/test/fixtures/RUF101_4.py

@@ -0,0 +1,7 @@
+from sys import exit as exit2
+
+exit(0)
+
+
+def main():
+    exit(1)

resources/test/fixtures/RUF101_5.py

@@ -0,0 +1,7 @@
+from sys import *
+
+exit(0)
+
+
+def main():
+    exit(1)

resources/test/fixtures/RUF101_6.py

@@ -0,0 +1,12 @@
+exit(0)
+
+
+def exit(e):
+    pass
+
+
+exit(1)
+
+
+def main():
+    exit(2)

resources/test/fixtures/T100.py

@@ -0,0 +1,14 @@
+breakpoint()
+
+
+import pdb
+from builtins import breakpoint
+from pdb import set_trace as st
+from celery.contrib.rdb import set_trace
+from celery.contrib import rdb
+import celery.contrib.rdb
+
+
+breakpoint()
+st()
+set_trace()

resources/test/fixtures/U002.py

@@ -1,15 +0,0 @@
-from os.path import abspath
-
-x = abspath(__file__)
-
-
-import os
-
-
-y = os.path.abspath(__file__)
-
-
-from os import path
-
-
-z = path.abspath(__file__)

resources/test/fixtures/U006.py

@@ -24,3 +24,7 @@ from typing import List as IList
 
 def f(x: IList[str]) -> None:
     ...
+
+
+def f(x: "List[str]") -> None:
+    ...

resources/test/fixtures/U007.py

@@ -1,40 +1,43 @@
+import typing
 from typing import Optional
+from typing import Union
 
 
 def f(x: Optional[str]) -> None:
     ...
 
 
-import typing
-
-
 def f(x: typing.Optional[str]) -> None:
     ...
 
 
-from typing import Union
-
-
 def f(x: Union[str, int, Union[float, bytes]]) -> None:
     ...
 
 
-import typing
-
-
 def f(x: typing.Union[str, int]) -> None:
     ...
 
 
-from typing import Union
+def f(x: typing.Union[(str, int)]) -> None:
+    ...
+
+
+def f(x: typing.Union[(str, int), float]) -> None:
+    ...
 
 
 def f(x: "Union[str, int, Union[float, bytes]]") -> None:
     ...
 
 
-import typing
-
-
 def f(x: "typing.Union[str, int]") -> None:
     ...
+
+
+def f(x: Union["str", int]) -> None:
+    ...
+
+
+def f(x: Union[("str", "int"), float]) -> None:
+    ...

resources/test/fixtures/U009_0.py

@@ -1,3 +1,3 @@
 # coding=utf8
 
-print('Hello world')
+print("Hello world")

resources/test/fixtures/U009_4.py

@@ -0,0 +1,3 @@
+# coding=utf8 # noqa: U009
+
+print("Hello world")

resources/test/fixtures/U013.py

@@ -0,0 +1,33 @@
+from typing import TypedDict, NotRequired, Literal
+import typing
+
+# dict literal
+MyType1 = TypedDict("MyType1", {"a": int, "b": str})
+
+# dict call
+MyType2 = TypedDict("MyType2", dict(a=int, b=str))
+
+# kwargs
+MyType3 = TypedDict("MyType3", a=int, b=str)
+
+# Empty TypedDict
+MyType4 = TypedDict("MyType4")
+
+# Literal values
+MyType5 = TypedDict("MyType5", {"a": "hello"})
+MyType6 = TypedDict("MyType6", a="hello")
+
+# NotRequired
+MyType7 = TypedDict("MyType7", {"a": NotRequired[dict]})
+
+# total
+MyType8 = TypedDict("MyType8", {"x": int, "y": int}, total=False)
+
+# invalid identifiers
+MyType9 = TypedDict("MyType9", {"in": int, "x-y": int})
+
+# using Literal type
+MyType10 = TypedDict("MyType10", {"key": Literal["value"]})
+
+# using namespace TypedDict
+MyType11 = typing.TypedDict("MyType11", {"key": int})

resources/test/fixtures/U014.py

@@ -0,0 +1,22 @@
+from typing import NamedTuple
+import typing
+
+# with complex annotations
+NT1 = NamedTuple("NT1", [("a", int), ("b", tuple[str, ...])])
+
+# with default values as list
+NT2 = NamedTuple(
+    "NT2",
+    [("a", int), ("b", str), ("c", list[bool])],
+    defaults=["foo", [True]],
+)
+
+# with namespace
+NT3 = typing.NamedTuple("NT3", [("a", int), ("b", str)])
+
+# with too many default values
+NT4 = NamedTuple(
+    "NT4",
+    [("a", int), ("b", str)],
+    defaults=[1, "bar", "baz"],
+)

resources/test/fixtures/U015.py

@@ -0,0 +1,80 @@
+open("foo", "U")
+open("foo", "Ur")
+open("foo", "Ub")
+open("foo", "rUb")
+open("foo", "r")
+open("foo", "rt")
+open("f", "r", encoding="UTF-8")
+open("f", "wt")
+
+with open("foo", "U") as f:
+    pass
+with open("foo", "Ur") as f:
+    pass
+with open("foo", "Ub") as f:
+    pass
+with open("foo", "rUb") as f:
+    pass
+with open("foo", "r") as f:
+    pass
+with open("foo", "rt") as f:
+    pass
+with open("foo", "r", encoding="UTF-8") as f:
+    pass
+with open("foo", "wt") as f:
+    pass
+
+open(f("a", "b", "c"), "U")
+open(f("a", "b", "c"), "Ub")
+
+with open(f("a", "b", "c"), "U") as f:
+    pass
+with open(f("a", "b", "c"), "Ub") as f:
+    pass
+
+with open("foo", "U") as fa, open("bar", "U") as fb:
+    pass
+with open("foo", "Ub") as fa, open("bar", "Ub") as fb:
+    pass
+
+open("foo", mode="U")
+open(name="foo", mode="U")
+open(mode="U", name="foo")
+
+with open("foo", mode="U") as f:
+    pass
+with open(name="foo", mode="U") as f:
+    pass
+with open(mode="U", name="foo") as f:
+    pass
+
+open("foo", mode="Ub")
+open(name="foo", mode="Ub")
+open(mode="Ub", name="foo")
+
+with open("foo", mode="Ub") as f:
+    pass
+with open(name="foo", mode="Ub") as f:
+    pass
+with open(mode="Ub", name="foo") as f:
+    pass
+
+open(file="foo", mode='U', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
+open(file="foo", buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None, mode='U')
+open(file="foo", buffering=- 1, encoding=None, errors=None, mode='U', newline=None, closefd=True, opener=None)
+open(mode='U', file="foo", buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
+
+open(file="foo", mode='Ub', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
+open(file="foo", buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None, mode='Ub')
+open(file="foo", buffering=- 1, encoding=None, errors=None, mode='Ub', newline=None, closefd=True, opener=None)
+open(mode='Ub', file="foo", buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
+
+open = 1
+open("foo", "U")
+open("foo", "Ur")
+open("foo", "Ub")
+open("foo", "rUb")
+open("foo", "r")
+open("foo", "rt")
+open("f", "r", encoding="UTF-8")
+open("f", "wt")

resources/test/fixtures/canonical_google_examples.py

@@ -44,7 +44,7 @@ expectation.expected.add((
 @expect("D407: Missing dashed underline after section ('Returns')",
         arg_count=3)
 @expect("D413: Missing blank line after last section ('Raises')", arg_count=3)
-def fetch_bigtable_rows(big_table, keys, other_silly_variable=None):
+def fetch_bigtable_rows(big_table, keys, other_silly_variable=None, **kwargs):
     """Fetches rows from a Bigtable.
 
     Retrieves rows pertaining to the given keys from the Table instance
@@ -57,6 +57,7 @@ def fetch_bigtable_rows(big_table, keys, other_silly_variable=None):
             to fetch.
         other_silly_variable: Another optional variable, that has a much
             longer name than the other args, and which does nothing.
+        **kwargs: More keyword arguments.
 
     Returns:
         A dict mapping keys to the corresponding table row data

resources/test/fixtures/canonical_numpy_examples.py

@@ -73,7 +73,7 @@ expectation.expected.add((
         "(found 'A')", arg_count=3)
 @expect("D413: Missing blank line after last section ('Examples')",
         arg_count=3)
-def foo(var1, var2, long_var_name='hi'):
+def foo(var1, var2, long_var_name='hi', **kwargs):
     r"""A one-line summary that does not use variable names.
 
     Several sentences providing an extended description. Refer to
@@ -91,6 +91,8 @@ def foo(var1, var2, long_var_name='hi'):
         detail, e.g. ``(N,) ndarray`` or ``array_like``.
     long_var_name : {'hi', 'ho'}, optional
         Choices in brackets, default first when optional.
+    **kwargs : int
+        More keyword arguments.
 
     Returns
     -------

resources/test/fixtures/future_annotations.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import List, Optional
 
 from models import (
     Fruit,
@@ -28,3 +29,12 @@ class Foo:
     @classmethod
     def d(cls) -> Fruit:
         return cls(x=0, y=0)
+
+
+def f(x: int) -> List[int]:
+    y = List[int]()
+    y.append(x)
+    return y
+
+
+x: Optional[int] = None

resources/test/fixtures/isort/order_relative_imports_by_level.py

@@ -0,0 +1,4 @@
+from .a import a
+from ..a import a
+from ..b import a
+from .b import a

resources/test/fixtures/pyproject.toml

@@ -5,6 +5,7 @@ extend-exclude = [
   "migrations",
   "with_excluded_file/other_excluded_file.py",
 ]
+external = ["V101"]
 per-file-ignores = { "__init__.py" = ["F401"] }
 
 [tool.ruff.flake8-bugbear]
@@ -16,6 +17,9 @@ multiline-quotes = "double"
 docstring-quotes = "double"
 avoid-escape = true
 
+[tool.ruff.mccabe]
+max-complexity = 10
+
 [tool.ruff.pep8-naming]
 ignore-names = [
   "setUp",
@@ -33,7 +37,11 @@ ignore-names = [
 ]
 classmethod-decorators = [
   "classmethod",
+  "pydantic.validator",
 ]
 staticmethod-decorators = [
   "staticmethod",
 ]
+
+[tool.ruff.flake8-tidy-imports]
+ban-relative-imports = "parents"

ruff/__main__.py

@@ -4,4 +4,4 @@ import sysconfig
 
 if __name__ == "__main__":
     ruff = os.path.join(sysconfig.get_path("scripts"), "ruff")
-    os.spawnv(os.P_WAIT, ruff, [ruff, *sys.argv[1:]])
+    sys.exit(os.spawnv(os.P_WAIT, ruff, [ruff, *sys.argv[1:]]))

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.123"
+version = "0.0.149"
 edition = "2021"
 
 [dependencies]
@@ -8,10 +8,10 @@ anyhow = { version = "1.0.66" }
 clap = { version = "4.0.1", features = ["derive"] }
 codegen = { version = "0.2.0" }
 itertools = { version = "0.10.5" }
-libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "a13ec97dd4eb925bde4d426c6e422582793b260c" }
+libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a8725d161fe8b3ed73a6758b21e177" }
 ruff = { path = ".." }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "f885db8c61514f069979861f6b3bd83292086231" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "f885db8c61514f069979861f6b3bd83292086231" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "f885db8c61514f069979861f6b3bd83292086231" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
 strum_macros = { version = "0.24.3" }

ruff_dev/src/generate_check_code_prefix.rs

@@ -24,7 +24,7 @@ pub struct Cli {
 
 pub fn main(cli: &Cli) -> Result<()> {
     // Build up a map from prefix to matching CheckCodes.
-    let mut prefix_to_codes: BTreeMap<String, BTreeSet<CheckCode>> = Default::default();
+    let mut prefix_to_codes: BTreeMap<String, BTreeSet<CheckCode>> = BTreeMap::default();
     for check_code in CheckCode::iter() {
         let as_ref: String = check_code.as_ref().to_string();
         let prefix_len = as_ref
@@ -77,6 +77,7 @@ pub fn main(cli: &Cli) -> Result<()> {
         .arg_ref_self()
         .ret(Type::new("Vec<CheckCode>"))
         .vis("pub")
+        .line("#[allow(clippy::match_same_arms)]")
         .line("match self {");
     for (prefix, codes) in &prefix_to_codes {
         gen = gen.line(format!(
@@ -96,6 +97,7 @@ pub fn main(cli: &Cli) -> Result<()> {
         .arg_ref_self()
         .ret(Type::new("PrefixSpecificity"))
         .vis("pub")
+        .line("#[allow(clippy::match_same_arms)]")
         .line("match self {");
     for prefix in prefix_to_codes.keys() {
         let num_numeric = prefix.chars().filter(|char| char.is_numeric()).count();
@@ -104,7 +106,7 @@ pub fn main(cli: &Cli) -> Result<()> {
             2 => "Tens",
             1 => "Hundreds",
             0 => "Category",
-            _ => panic!("Invalid prefix: {}", prefix),
+            _ => panic!("Invalid prefix: {prefix}"),
         };
         gen = gen.line(format!(
             "CheckCodePrefix::{prefix} => PrefixSpecificity::{},",
@@ -115,7 +117,8 @@ pub fn main(cli: &Cli) -> Result<()> {
 
     // Construct the output contents.
     let mut output = String::new();
-    output.push_str("//! File automatically generated by examples/generate_check_code_prefix.rs.");
+    output
+        .push_str("//! File automatically generated by `examples/generate_check_code_prefix.rs`.");
     output.push('\n');
     output.push('\n');
     output.push_str("use serde::{{Serialize, Deserialize}};");
@@ -127,13 +130,28 @@ pub fn main(cli: &Cli) -> Result<()> {
     output.push('\n');
     output.push('\n');
     output.push_str(&scope.to_string());
+    output.push('\n');
+    output.push('\n');
+
+    // Add the list of output categories (not generated).
+    output.push_str("pub const CATEGORIES: &[CheckCodePrefix] = &[");
+    output.push('\n');
+    for prefix in prefix_to_codes.keys() {
+        if prefix.chars().all(char::is_alphabetic) {
+            output.push_str(&format!("CheckCodePrefix::{prefix},"));
+            output.push('\n');
+        }
+    }
+    output.push_str("];");
+    output.push('\n');
+    output.push('\n');
 
     // Write the output to `src/checks_gen.rs` (or stdout).
     if cli.dry_run {
-        println!("{}", output);
+        println!("{output}");
     } else {
         let mut f = OpenOptions::new().write(true).truncate(true).open(FILE)?;
-        write!(f, "{}", output)?;
+        write!(f, "{output}")?;
     }
 
     Ok(())

ruff_dev/src/generate_rules_table.rs

@@ -61,7 +61,7 @@ pub fn main(cli: &Cli) -> Result<()> {
     }
 
     if cli.dry_run {
-        print!("{}", output);
+        print!("{output}");
     } else {
         // Read the existing file.
         let file = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
@@ -84,9 +84,9 @@ pub fn main(cli: &Cli) -> Result<()> {
 
         // Write the prefix, new contents, and suffix.
         let mut f = OpenOptions::new().write(true).truncate(true).open(&file)?;
-        write!(f, "{}\n\n", prefix)?;
-        write!(f, "{}", output)?;
-        write!(f, "{}", suffix)?;
+        write!(f, "{prefix}\n\n")?;
+        write!(f, "{output}")?;
+        write!(f, "{suffix}")?;
     }
 
     Ok(())

ruff_dev/src/generate_source_code.rs

@@ -19,7 +19,7 @@ pub fn main(cli: &Cli) -> Result<()> {
     let contents = fs::read_to_string(&cli.file)?;
     let python_ast = parser::parse_program(&contents, &cli.file.to_string_lossy())?;
     let mut generator = SourceGenerator::new();
-    generator.unparse_suite(&python_ast)?;
+    generator.unparse_suite(&python_ast);
     println!("{}", generator.generate()?);
     Ok(())
 }

ruff_dev/src/lib.rs

@@ -1,3 +1,16 @@
+#![allow(
+    clippy::collapsible_else_if,
+    clippy::collapsible_if,
+    clippy::implicit_hasher,
+    clippy::match_same_arms,
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::similar_names,
+    clippy::too_many_lines
+)]
+
 pub mod generate_check_code_prefix;
 pub mod generate_rules_table;
 pub mod generate_source_code;

ruff_dev/src/main.rs

@@ -1,3 +1,16 @@
+#![allow(
+    clippy::collapsible_else_if,
+    clippy::collapsible_if,
+    clippy::implicit_hasher,
+    clippy::match_same_arms,
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::similar_names,
+    clippy::too_many_lines
+)]
+
 use anyhow::Result;
 use clap::{Parser, Subcommand};
 use ruff_dev::{

ruff_dev/src/print_ast.rs

@@ -17,6 +17,6 @@ pub struct Cli {
 pub fn main(cli: &Cli) -> Result<()> {
     let contents = fs::read_to_string(&cli.file)?;
     let python_ast = parser::parse_program(&contents, &cli.file.to_string_lossy())?;
-    println!("{:#?}", python_ast);
+    println!("{python_ast:#?}");
     Ok(())
 }

ruff_dev/src/print_cst.rs

@@ -1,4 +1,4 @@
-//! Print the LibCST CST for a given Python file.
+//! Print the `LibCST` CST for a given Python file.
 
 use std::fs;
 use std::path::PathBuf;
@@ -17,7 +17,7 @@ pub fn main(cli: &Cli) -> Result<()> {
     let contents = fs::read_to_string(&cli.file)?;
     match libcst_native::parse_module(&contents, None) {
         Ok(python_cst) => {
-            println!("{:#?}", python_cst);
+            println!("{python_cst:#?}");
             Ok(())
         }
         Err(_) => Err(anyhow::anyhow!("Failed to parse CST")),

ruff_dev/src/print_tokens.rs

@@ -17,7 +17,7 @@ pub struct Cli {
 pub fn main(cli: &Cli) -> Result<()> {
     let contents = fs::read_to_string(&cli.file)?;
     for (_, tok, _) in lexer::make_tokenizer(&contents).flatten() {
-        println!("{:#?}", tok);
+        println!("{tok:#?}");
     }
     Ok(())
 }

src/ast/helpers.rs

@@ -1,9 +1,13 @@
-use fnv::{FnvHashMap, FnvHashSet};
 use once_cell::sync::Lazy;
 use regex::Regex;
-use rustpython_ast::{Excepthandler, ExcepthandlerKind, Expr, ExprKind, Location, StmtKind};
+use rustc_hash::{FxHashMap, FxHashSet};
+use rustpython_ast::{
+    Arguments, Excepthandler, ExcepthandlerKind, Expr, ExprKind, Location, Stmt, StmtKind,
+};
+
+use crate::ast::types::Range;
+use crate::SourceCodeLocator;
 
-#[inline(always)]
 fn collect_call_path_inner<'a>(expr: &'a Expr, parts: &mut Vec<&'a str>) {
     match &expr.node {
         ExprKind::Call { func, .. } => {
@@ -21,7 +25,6 @@ fn collect_call_path_inner<'a>(expr: &'a Expr, parts: &mut Vec<&'a str>) {
 }
 
 /// Convert an `Expr` to its call path (like `List`, or `typing.List`).
-#[inline(always)]
 pub fn compose_call_path(expr: &Expr) -> Option<String> {
     let segments = collect_call_paths(expr);
     if segments.is_empty() {
@@ -32,7 +35,6 @@ pub fn compose_call_path(expr: &Expr) -> Option<String> {
 }
 
 /// Convert an `Expr` to its call path segments (like ["typing", "List"]).
-#[inline(always)]
 pub fn collect_call_paths(expr: &Expr) -> Vec<&str> {
     let mut segments = vec![];
     collect_call_path_inner(expr, &mut segments);
@@ -42,7 +44,7 @@ pub fn collect_call_paths(expr: &Expr) -> Vec<&str> {
 /// Rewrite any import aliases on a call path.
 pub fn dealias_call_path<'a>(
     call_path: Vec<&'a str>,
-    import_aliases: &FnvHashMap<&str, &'a str>,
+    import_aliases: &FxHashMap<&str, &'a str>,
 ) -> Vec<&'a str> {
     if let Some(head) = call_path.first() {
         if let Some(origin) = import_aliases.get(head) {
@@ -76,8 +78,8 @@ pub fn match_module_member(
     expr: &Expr,
     module: &str,
     member: &str,
-    from_imports: &FnvHashMap<&str, FnvHashSet<&str>>,
-    import_aliases: &FnvHashMap<&str, &str>,
+    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
+    import_aliases: &FxHashMap<&str, &str>,
 ) -> bool {
     match_call_path(
         &dealias_call_path(collect_call_paths(expr), import_aliases),
@@ -94,7 +96,7 @@ pub fn match_call_path(
     call_path: &[&str],
     module: &str,
     member: &str,
-    from_imports: &FnvHashMap<&str, FnvHashSet<&str>>,
+    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
 ) -> bool {
     // If we have no segments, we can't ever match.
     let num_segments = call_path.len();
@@ -118,10 +120,9 @@ pub fn match_call_path(
     // `Match`).
     if num_segments == 0 {
         module.is_empty()
-            || from_imports
-                .get(module)
-                .map(|imports| imports.contains(member) || imports.contains("*"))
-                .unwrap_or(false)
+            || from_imports.get(module).map_or(false, |imports| {
+                imports.contains(member) || imports.contains("*")
+            })
     } else {
         let components: Vec<&str> = module.split('.').collect();
 
@@ -145,8 +146,7 @@ pub fn match_call_path(
             let member = components[cut];
             if from_imports
                 .get(&module.as_str())
-                .map(|imports| imports.contains(member))
-                .unwrap_or(false)
+                .map_or(false, |imports| imports.contains(member))
             {
                 return true;
             }
@@ -215,6 +215,27 @@ pub fn extract_handler_names(handlers: &[Excepthandler]) -> Vec<Vec<&str>> {
     handler_names
 }
 
+/// Return the set of all bound argument names.
+pub fn collect_arg_names<'a>(arguments: &'a Arguments) -> FxHashSet<&'a str> {
+    let mut arg_names: FxHashSet<&'a str> = FxHashSet::default();
+    for arg in &arguments.posonlyargs {
+        arg_names.insert(arg.node.arg.as_str());
+    }
+    for arg in &arguments.args {
+        arg_names.insert(arg.node.arg.as_str());
+    }
+    if let Some(arg) = &arguments.vararg {
+        arg_names.insert(arg.node.arg.as_str());
+    }
+    for arg in &arguments.kwonlyargs {
+        arg_names.insert(arg.node.arg.as_str());
+    }
+    if let Some(arg) = &arguments.kwarg {
+        arg_names.insert(arg.node.arg.as_str());
+    }
+    arg_names
+}
+
 /// Returns `true` if a call is an argumented `super` invocation.
 pub fn is_super_call_with_arguments(func: &Expr, args: &[Expr]) -> bool {
     // Check: is this a `super` call?
@@ -239,9 +260,18 @@ pub fn format_import_from(level: Option<&usize>, module: Option<&String>) -> Str
     module_name
 }
 
+/// Split a target string (like `typing.List`) into (`typing`, `List`).
+pub fn to_module_and_member(target: &str) -> (&str, &str) {
+    if let Some(index) = target.rfind('.') {
+        (&target[..index], &target[index + 1..])
+    } else {
+        ("", target)
+    }
+}
+
 /// Convert a location within a file (relative to `base`) to an absolute
 /// position.
-pub fn to_absolute(relative: &Location, base: &Location) -> Location {
+pub fn to_absolute(relative: Location, base: Location) -> Location {
     if relative.row() == 1 {
         Location::new(
             relative.row() + base.row() - 1,
@@ -252,10 +282,38 @@ pub fn to_absolute(relative: &Location, base: &Location) -> Location {
     }
 }
 
+/// Return `true` if a `Stmt` has leading content.
+pub fn match_leading_content(stmt: &Stmt, locator: &SourceCodeLocator) -> bool {
+    let range = Range {
+        location: Location::new(stmt.location.row(), 0),
+        end_location: stmt.location,
+    };
+    let prefix = locator.slice_source_code_range(&range);
+    prefix.chars().any(|char| !char.is_whitespace())
+}
+
+/// Return `true` if a `Stmt` has trailing content.
+pub fn match_trailing_content(stmt: &Stmt, locator: &SourceCodeLocator) -> bool {
+    let range = Range {
+        location: stmt.end_location.unwrap(),
+        end_location: Location::new(stmt.end_location.unwrap().row() + 1, 0),
+    };
+    let suffix = locator.slice_source_code_range(&range);
+    for char in suffix.chars() {
+        if char == '#' {
+            return false;
+        }
+        if !char.is_whitespace() {
+            return true;
+        }
+    }
+    false
+}
+
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use fnv::{FnvHashMap, FnvHashSet};
+    use rustc_hash::{FxHashMap, FxHashSet};
     use rustpython_parser::parser;
 
     use crate::ast::helpers::match_module_member;
@@ -267,8 +325,8 @@ mod tests {
             &expr,
             "",
             "list",
-            &FnvHashMap::default(),
-            &FnvHashMap::default(),
+            &FxHashMap::default(),
+            &FxHashMap::default(),
         ));
         Ok(())
     }
@@ -280,8 +338,8 @@ mod tests {
             &expr,
             "typing.re",
             "Match",
-            &FnvHashMap::default(),
-            &FnvHashMap::default(),
+            &FxHashMap::default(),
+            &FxHashMap::default(),
         ));
         Ok(())
     }
@@ -293,16 +351,16 @@ mod tests {
             &expr,
             "typing.re",
             "Match",
-            &FnvHashMap::default(),
-            &FnvHashMap::default(),
+            &FxHashMap::default(),
+            &FxHashMap::default(),
         ));
         let expr = parser::parse_expression("re.Match", "<filename>")?;
         assert!(!match_module_member(
             &expr,
             "typing.re",
             "Match",
-            &FnvHashMap::default(),
-            &FnvHashMap::default(),
+            &FxHashMap::default(),
+            &FxHashMap::default(),
         ));
         Ok(())
     }
@@ -314,8 +372,8 @@ mod tests {
             &expr,
             "typing.re",
             "Match",
-            &FnvHashMap::from_iter([("typing.re", FnvHashSet::from_iter(["*"]))]),
-            &FnvHashMap::default()
+            &FxHashMap::from_iter([("typing.re", FxHashSet::from_iter(["*"]))]),
+            &FxHashMap::default()
         ));
         Ok(())
     }
@@ -327,8 +385,8 @@ mod tests {
             &expr,
             "typing.re",
             "Match",
-            &FnvHashMap::from_iter([("typing.re", FnvHashSet::from_iter(["Match"]))]),
-            &FnvHashMap::default()
+            &FxHashMap::from_iter([("typing.re", FxHashSet::from_iter(["Match"]))]),
+            &FxHashMap::default()
         ));
         Ok(())
     }
@@ -340,8 +398,8 @@ mod tests {
             &expr,
             "typing.re",
             "Match",
-            &FnvHashMap::from_iter([("typing", FnvHashSet::from_iter(["re"]))]),
-            &FnvHashMap::default()
+            &FxHashMap::from_iter([("typing", FxHashSet::from_iter(["re"]))]),
+            &FxHashMap::default()
         ));
 
         let expr = parser::parse_expression("match.Match", "<filename>")?;
@@ -349,8 +407,8 @@ mod tests {
             &expr,
             "typing.re.match",
             "Match",
-            &FnvHashMap::from_iter([("typing.re", FnvHashSet::from_iter(["match"]))]),
-            &FnvHashMap::default()
+            &FxHashMap::from_iter([("typing.re", FxHashSet::from_iter(["match"]))]),
+            &FxHashMap::default()
         ));
 
         let expr = parser::parse_expression("re.match.Match", "<filename>")?;
@@ -358,8 +416,8 @@ mod tests {
             &expr,
             "typing.re.match",
             "Match",
-            &FnvHashMap::from_iter([("typing", FnvHashSet::from_iter(["re"]))]),
-            &FnvHashMap::default()
+            &FxHashMap::from_iter([("typing", FxHashSet::from_iter(["re"]))]),
+            &FxHashMap::default()
         ));
         Ok(())
     }
@@ -371,8 +429,8 @@ mod tests {
             &expr,
             "typing.re",
             "Match",
-            &FnvHashMap::from_iter([("typing.re", FnvHashSet::from_iter(["Match"]))]),
-            &FnvHashMap::from_iter([("IMatch", "Match")]),
+            &FxHashMap::from_iter([("typing.re", FxHashSet::from_iter(["Match"]))]),
+            &FxHashMap::from_iter([("IMatch", "Match")]),
         ));
         Ok(())
     }
@@ -384,8 +442,8 @@ mod tests {
             &expr,
             "typing.re",
             "Match",
-            &FnvHashMap::default(),
-            &FnvHashMap::from_iter([("t", "typing.re")]),
+            &FxHashMap::default(),
+            &FxHashMap::from_iter([("t", "typing.re")]),
         ));
         Ok(())
     }
@@ -397,8 +455,8 @@ mod tests {
             &expr,
             "typing.re",
             "Match",
-            &FnvHashMap::default(),
-            &FnvHashMap::from_iter([("t", "typing")]),
+            &FxHashMap::default(),
+            &FxHashMap::from_iter([("t", "typing")]),
         ));
         Ok(())
     }

src/ast/mod.rs

@@ -3,3 +3,4 @@ pub mod operations;
 pub mod relocate;
 pub mod types;
 pub mod visitor;
+pub mod whitespace;

src/ast/operations.rs

@@ -4,8 +4,6 @@ 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> {
-    let mut names: Vec<String> = vec![];
-
     fn add_to_names(names: &mut Vec<String>, elts: &[Expr]) {
         for elt in elts {
             if let ExprKind::Constant {
@@ -13,11 +11,13 @@ pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
                 ..
             } = &elt.node
             {
-                names.push(value.to_string())
+                names.push(value.to_string());
             }
         }
     }
 
+    let mut names: Vec<String> = vec![];
+
     // Grab the existing bound __all__ values.
     if let StmtKind::AugAssign { .. } = &stmt.node {
         if let Some(binding) = scope.values.get("__all__") {
@@ -35,7 +35,7 @@ pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
     } {
         match &value.node {
             ExprKind::List { elts, .. } | ExprKind::Tuple { elts, .. } => {
-                add_to_names(&mut names, elts)
+                add_to_names(&mut names, elts);
             }
             ExprKind::BinOp { left, right, .. } => {
                 let mut current_left = left;

src/ast/types.rs

@@ -1,7 +1,7 @@
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-use fnv::FnvHashMap;
-use rustpython_ast::{Expr, Keyword};
+use rustc_hash::FxHashMap;
+use rustpython_ast::{Expr, Keyword, Stmt};
 use rustpython_parser::ast::{Located, Location};
 
 fn id() -> usize {
@@ -9,6 +9,12 @@ fn id() -> usize {
     COUNTER.fetch_add(1, Ordering::Relaxed)
 }
 
+#[derive(Clone)]
+pub enum Node<'a> {
+    Stmt(&'a Stmt),
+    Expr(&'a Expr),
+}
+
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Range {
     pub location: Location,
@@ -19,9 +25,7 @@ impl Range {
     pub fn from_located<T>(located: &Located<T>) -> Self {
         Range {
             location: located.location,
-            end_location: located
-                .end_location
-                .expect("AST nodes should have end_location."),
+            end_location: located.end_location.unwrap(),
         }
     }
 }
@@ -54,7 +58,7 @@ pub struct Scope<'a> {
     pub id: usize,
     pub kind: ScopeKind<'a>,
     pub import_starred: bool,
-    pub values: FnvHashMap<&'a str, Binding>,
+    pub values: FxHashMap<&'a str, Binding>,
 }
 
 impl<'a> Scope<'a> {
@@ -63,7 +67,7 @@ impl<'a> Scope<'a> {
             id: id(),
             kind,
             import_starred: false,
-            values: FnvHashMap::default(),
+            values: FxHashMap::default(),
         }
     }
 }
@@ -79,8 +83,11 @@ pub enum BindingKind {
     Annotation,
     Argument,
     Assignment,
+    // TODO(charlie): This seems to be a catch-all.
     Binding,
     LoopVar,
+    Global,
+    Nonlocal,
     Builtin,
     ClassDefinition,
     Definition,
@@ -100,9 +107,3 @@ pub struct Binding {
     /// the binding was last used.
     pub used: Option<(usize, Range)>,
 }
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub enum ImportKind {
-    Import,
-    ImportFrom,
-}

src/ast/visitor.rs

@@ -19,8 +19,8 @@ pub trait Visitor<'a> {
     fn visit_constant(&mut self, constant: &'a Constant) {
         walk_constant(self, constant);
     }
-    fn visit_expr_context(&mut self, expr_content: &'a ExprContext) {
-        walk_expr_context(self, expr_content);
+    fn visit_expr_context(&mut self, expr_context: &'a ExprContext) {
+        walk_expr_context(self, expr_context);
     }
     fn visit_boolop(&mut self, boolop: &'a Boolop) {
         walk_boolop(self, boolop);
@@ -249,7 +249,7 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
                 visitor.visit_stmt(stmt);
             }
             for excepthandler in handlers {
-                visitor.visit_excepthandler(excepthandler)
+                visitor.visit_excepthandler(excepthandler);
             }
             for stmt in orelse {
                 visitor.visit_stmt(stmt);
@@ -447,7 +447,7 @@ pub fn walk_expr<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, expr: &'a Expr) {
 pub fn walk_constant<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, constant: &'a Constant) {
     if let Constant::Tuple(constants) = constant {
         for constant in constants {
-            visitor.visit_constant(constant)
+            visitor.visit_constant(constant);
         }
     }
 }
@@ -456,8 +456,8 @@ pub fn walk_comprehension<'a, V: Visitor<'a> + ?Sized>(
     visitor: &mut V,
     comprehension: &'a Comprehension,
 ) {
-    visitor.visit_expr(&comprehension.target);
     visitor.visit_expr(&comprehension.iter);
+    visitor.visit_expr(&comprehension.target);
     for expr in &comprehension.ifs {
         visitor.visit_expr(expr);
     }
@@ -577,7 +577,6 @@ pub fn walk_pattern<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, pattern: &'a P
 }
 
 #[allow(unused_variables)]
-#[inline(always)]
 pub fn walk_expr_context<'a, V: Visitor<'a> + ?Sized>(
     visitor: &mut V,
     expr_context: &'a ExprContext,
@@ -585,21 +584,16 @@ pub fn walk_expr_context<'a, V: Visitor<'a> + ?Sized>(
 }
 
 #[allow(unused_variables)]
-#[inline(always)]
 pub fn walk_boolop<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, boolop: &'a Boolop) {}
 
 #[allow(unused_variables)]
-#[inline(always)]
 pub fn walk_operator<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, operator: &'a Operator) {}
 
 #[allow(unused_variables)]
-#[inline(always)]
 pub fn walk_unaryop<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, unaryop: &'a Unaryop) {}
 
 #[allow(unused_variables)]
-#[inline(always)]
 pub fn walk_cmpop<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, cmpop: &'a Cmpop) {}
 
 #[allow(unused_variables)]
-#[inline(always)]
 pub fn walk_alias<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, alias: &'a Alias) {}

src/ast/whitespace.rs

@@ -3,12 +3,6 @@ use rustpython_ast::{Located, Location};
 use crate::ast::types::Range;
 use crate::check_ast::Checker;
 
-pub const TRIPLE_QUOTE_PREFIXES: &[&str] = &[
-    "ur\"\"\"", "ur'''", "u\"\"\"", "u'''", "r\"\"\"", "r'''", "\"\"\"", "'''",
-];
-
-pub const SINGLE_QUOTE_PREFIXES: &[&str] = &["ur\"", "ur'", "u\"", "u'", "r\"", "r'", "\"", "'"];
-
 /// Extract the leading words from a line of text.
 pub fn leading_words(line: &str) -> String {
     line.trim()
@@ -25,7 +19,7 @@ pub fn leading_space(line: &str) -> String {
 }
 
 /// Extract the leading indentation from a line.
-pub fn indentation<'a, T>(checker: &'a Checker, located: &Located<T>) -> String {
+pub fn indentation<T>(checker: &Checker, located: &Located<T>) -> String {
     let range = Range::from_located(located);
     checker
         .locator

src/autofix/fixer.rs

@@ -10,8 +10,6 @@ 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,
@@ -19,55 +17,55 @@ pub enum Mode {
     None,
 }
 
-impl Mode {
-    /// Return `true` if a patch should be generated under the given `Mode`.
-    pub fn patch(&self) -> bool {
-        match &self {
-            Mode::Generate => true,
-            Mode::Apply => true,
-            Mode::None => false,
+impl From<bool> for Mode {
+    fn from(value: bool) -> Self {
+        if value {
+            Mode::Apply
+        } else {
+            Mode::None
         }
     }
 }
 
-impl From<bool> for Mode {
-    fn from(value: bool) -> Self {
+impl From<&Mode> for bool {
+    fn from(value: &Mode) -> Self {
         match value {
-            true => Mode::Apply,
-            false => Mode::None,
+            Mode::Generate | Mode::Apply => true,
+            Mode::None => false,
         }
     }
 }
 
 /// Auto-fix errors in a file, and write the fixed source code to disk.
 pub fn fix_file<'a>(
-    checks: &'a mut [Check],
+    checks: &'a [Check],
     locator: &'a SourceCodeLocator<'a>,
-) -> Option<Cow<'a, str>> {
+) -> Option<(Cow<'a, str>, usize)> {
     if checks.iter().all(|check| check.fix.is_none()) {
         return None;
     }
 
     Some(apply_fixes(
-        checks.iter_mut().filter_map(|check| check.fix.as_mut()),
+        checks.iter().filter_map(|check| check.fix.as_ref()),
         locator,
     ))
 }
 
 /// Apply a series of fixes.
 fn apply_fixes<'a>(
-    fixes: impl Iterator<Item = &'a mut Fix>,
+    fixes: impl Iterator<Item = &'a Fix>,
     locator: &'a SourceCodeLocator<'a>,
-) -> Cow<'a, str> {
+) -> (Cow<'a, str>, usize) {
     let mut output = RopeBuilder::new();
     let mut last_pos: Location = Location::new(1, 0);
     let mut applied: BTreeSet<&Patch> = BTreeSet::default();
+    let mut num_fixed: usize = 0;
 
     for fix in fixes.sorted_by_key(|fix| fix.patch.location) {
         // If we already applied an identical fix as part of another correction, skip
         // any re-application.
         if applied.contains(&fix.patch) {
-            fix.applied = true;
+            num_fixed += 1;
             continue;
         }
 
@@ -90,19 +88,18 @@ fn apply_fixes<'a>(
         // Track that the fix was applied.
         last_pos = fix.patch.end_location;
         applied.insert(&fix.patch);
-        fix.applied = true;
+        num_fixed += 1;
     }
 
     // Add the remaining content.
-    let slice = locator.slice_source_code_at(&last_pos);
+    let slice = locator.slice_source_code_at(last_pos);
     output.append(&slice);
 
-    Cow::from(output.finish())
+    (Cow::from(output.finish()), num_fixed)
 }
 
 #[cfg(test)]
 mod tests {
-    use anyhow::Result;
     use rustpython_parser::ast::Location;
 
     use crate::autofix::fixer::apply_fixes;
@@ -110,115 +107,117 @@ mod tests {
     use crate::SourceCodeLocator;
 
     #[test]
-    fn empty_file() -> Result<()> {
-        let mut fixes = vec![];
-        let locator = SourceCodeLocator::new("");
-        let actual = apply_fixes(fixes.iter_mut(), &locator);
-        let expected = "";
-
-        assert_eq!(actual, expected);
-
-        Ok(())
+    fn empty_file() {
+        let fixes = vec![];
+        let locator = SourceCodeLocator::new(r#""#);
+        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        assert_eq!(contents, "");
+        assert_eq!(fixed, 0);
     }
 
     #[test]
-    fn apply_single_replacement() -> Result<()> {
-        let mut fixes = vec![Fix {
+    fn apply_single_replacement() {
+        let fixes = vec![Fix {
             patch: Patch {
                 content: "Bar".to_string(),
                 location: Location::new(1, 8),
                 end_location: Location::new(1, 14),
             },
-            applied: false,
         }];
         let locator = SourceCodeLocator::new(
-            "class A(object):
-        ...
-",
+            r#"
+class A(object):
+    ...
+"#
+            .trim(),
         );
-        let actual = apply_fixes(fixes.iter_mut(), &locator);
-
-        let expected = "class A(Bar):
-        ...
-";
-
-        assert_eq!(actual, expected);
-
-        Ok(())
+        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        assert_eq!(
+            contents,
+            r#"
+class A(Bar):
+    ...
+"#
+            .trim(),
+        );
+        assert_eq!(fixed, 1);
     }
 
     #[test]
-    fn apply_single_removal() -> Result<()> {
-        let mut fixes = vec![Fix {
+    fn apply_single_removal() {
+        let fixes = vec![Fix {
             patch: Patch {
-                content: "".to_string(),
+                content: String::new(),
                 location: Location::new(1, 7),
                 end_location: Location::new(1, 15),
             },
-            applied: false,
         }];
         let locator = SourceCodeLocator::new(
-            "class A(object):
-        ...
-",
+            r#"
+class A(object):
+    ...
+"#
+            .trim(),
         );
-        let actual = apply_fixes(fixes.iter_mut(), &locator);
-
-        let expected = "class A:
-        ...
-";
-
-        assert_eq!(actual, expected);
-
-        Ok(())
+        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        assert_eq!(
+            contents,
+            r#"
+class A:
+    ...
+"#
+            .trim()
+        );
+        assert_eq!(fixed, 1);
     }
 
     #[test]
-    fn apply_double_removal() -> Result<()> {
-        let mut fixes = vec![
+    fn apply_double_removal() {
+        let fixes = vec![
             Fix {
                 patch: Patch {
-                    content: "".to_string(),
+                    content: String::new(),
                     location: Location::new(1, 7),
                     end_location: Location::new(1, 16),
                 },
-                applied: false,
             },
             Fix {
                 patch: Patch {
-                    content: "".to_string(),
+                    content: String::new(),
                     location: Location::new(1, 16),
                     end_location: Location::new(1, 23),
                 },
-                applied: false,
             },
         ];
         let locator = SourceCodeLocator::new(
-            "class A(object, object):
-        ...
-",
+            r#"
+class A(object, object):
+    ...
+"#
+            .trim(),
         );
-        let actual = apply_fixes(fixes.iter_mut(), &locator);
+        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
 
-        let expected = "class A:
-        ...
-";
-
-        assert_eq!(actual, expected);
-
-        Ok(())
+        assert_eq!(
+            contents,
+            r#"
+class A:
+    ...
+"#
+            .trim()
+        );
+        assert_eq!(fixed, 2);
     }
 
     #[test]
-    fn ignore_overlapping_fixes() -> Result<()> {
-        let mut fixes = vec![
+    fn ignore_overlapping_fixes() {
+        let fixes = vec![
             Fix {
                 patch: Patch {
-                    content: "".to_string(),
+                    content: String::new(),
                     location: Location::new(1, 7),
                     end_location: Location::new(1, 15),
                 },
-                applied: false,
             },
             Fix {
                 patch: Patch {
@@ -226,22 +225,24 @@ mod tests {
                     location: Location::new(1, 9),
                     end_location: Location::new(1, 11),
                 },
-                applied: false,
             },
         ];
         let locator = SourceCodeLocator::new(
-            "class A(object):
+            r#"
+class A(object):
     ...
-",
+"#
+            .trim(),
         );
-        let actual = apply_fixes(fixes.iter_mut(), &locator);
-
-        let expected = "class A:
+        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        assert_eq!(
+            contents,
+            r#"
+class A:
     ...
-";
-
-        assert_eq!(actual, expected);
-
-        Ok(())
+"#
+            .trim(),
+        );
+        assert_eq!(fixed, 1);
     }
 }

src/autofix/mod.rs

@@ -4,28 +4,26 @@ use serde::{Deserialize, Serialize};
 pub mod fixer;
 pub mod helpers;
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct Patch {
     pub content: String,
     pub location: Location,
     pub end_location: Location,
 }
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Fix {
     pub patch: Patch,
-    pub applied: bool,
 }
 
 impl Fix {
     pub fn deletion(start: Location, end: Location) -> Self {
         Self {
             patch: Patch {
-                content: "".to_string(),
+                content: String::new(),
                 location: start,
                 end_location: end,
             },
-            applied: false,
         }
     }
 
@@ -36,7 +34,6 @@ impl Fix {
                 location: start,
                 end_location: end,
             },
-            applied: false,
         }
     }
 
@@ -47,7 +44,16 @@ impl Fix {
                 location: at,
                 end_location: at,
             },
-            applied: false,
+        }
+    }
+
+    pub fn dummy(location: Location) -> Self {
+        Self {
+            patch: Patch {
+                content: String::new(),
+                location,
+                end_location: location,
+            },
         }
     }
 }

src/cache.rs

@@ -1,19 +1,11 @@
-// 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)
-)]
-
 use std::collections::hash_map::DefaultHasher;
+use std::fs;
 use std::fs::{create_dir_all, File, Metadata};
 use std::hash::{Hash, Hasher};
 use std::io::Write;
 use std::path::Path;
 
 use anyhow::Result;
-#[cfg(not(target_family = "wasm"))]
-use cacache::Error::EntryNotFound;
 use filetime::FileTime;
 use log::error;
 use path_absolutize::Absolutize;
@@ -71,9 +63,10 @@ impl Mode {
 
 impl From<bool> for Mode {
     fn from(value: bool) -> Self {
-        match value {
-            true => Mode::ReadWrite,
-            false => Mode::None,
+        if value {
+            Mode::ReadWrite
+        } else {
+            Mode::None
         }
     }
 }
@@ -82,28 +75,59 @@ fn cache_dir() -> &'static str {
     "./.ruff_cache"
 }
 
-fn cache_key(path: &Path, settings: &Settings, autofix: &fixer::Mode) -> String {
+fn content_dir() -> &'static str {
+    "content"
+}
+
+fn cache_key(path: &Path, settings: &Settings, autofix: &fixer::Mode) -> u64 {
     let mut hasher = DefaultHasher::new();
+    CARGO_PKG_VERSION.hash(&mut hasher);
+    path.absolutize().unwrap().hash(&mut hasher);
     settings.hash(&mut hasher);
     autofix.hash(&mut hasher);
-    format!(
-        "{}@{}@{}",
-        path.absolutize().unwrap().to_string_lossy(),
-        CARGO_PKG_VERSION,
-        hasher.finish()
+    hasher.finish()
+}
+
+/// Initialize the cache directory.
+pub fn init() -> Result<()> {
+    let path = Path::new(cache_dir());
+
+    // Create the cache directories.
+    create_dir_all(path.join(content_dir()))?;
+
+    // Add the CACHEDIR.TAG.
+    if !cachedir::is_tagged(path)? {
+        cachedir::add_tag(path)?;
+    }
+
+    // Add the .gitignore.
+    let gitignore_path = path.join(".gitignore");
+    if !gitignore_path.exists() {
+        let mut file = File::create(gitignore_path)?;
+        file.write_all(b"*")?;
+    }
+
+    Ok(())
+}
+
+fn write_sync(key: u64, value: &[u8]) -> Result<(), std::io::Error> {
+    fs::write(
+        Path::new(cache_dir())
+            .join(content_dir())
+            .join(format!("{key:x}")),
+        value,
     )
 }
 
-pub fn init() -> Result<()> {
-    let gitignore_path = Path::new(cache_dir()).join(".gitignore");
-    if gitignore_path.exists() {
-        return Ok(());
-    }
-    create_dir_all(cache_dir())?;
-    let mut file = File::create(gitignore_path)?;
-    file.write_all(b"*").map_err(|e| e.into())
+fn read_sync(key: u64) -> Result<Vec<u8>, std::io::Error> {
+    fs::read(
+        Path::new(cache_dir())
+            .join(content_dir())
+            .join(format!("{key:x}")),
+    )
 }
 
+/// Get a value from the cache.
 pub fn get(
     path: &Path,
     metadata: &Metadata,
@@ -115,9 +139,8 @@ pub fn get(
         return None;
     };
 
-    #[cfg(not(target_family = "wasm"))] // cacache needs async-std which doesn't support wasm
-    match cacache::read_sync(cache_dir(), cache_key(path, settings, autofix)) {
-        Ok(encoded) => match bincode::deserialize::<CheckResult>(&encoded[..]) {
+    if let Ok(encoded) = read_sync(cache_key(path, settings, autofix)) {
+        match bincode::deserialize::<CheckResult>(&encoded[..]) {
             Ok(CheckResult {
                 metadata: CacheMetadata { mtime },
                 messages,
@@ -127,13 +150,12 @@ pub fn get(
                 }
             }
             Err(e) => error!("Failed to deserialize encoded cache entry: {e:?}"),
-        },
-        Err(EntryNotFound(..)) => {}
-        Err(e) => error!("Failed to read from cache: {e:?}"),
+        }
     }
     None
 }
 
+/// Set a value in the cache.
 pub fn set(
     path: &Path,
     metadata: &Metadata,
@@ -146,19 +168,16 @@ pub fn set(
         return;
     };
 
-    #[cfg(not(target_family = "wasm"))] // modification date not supported on wasm
     let check_result = CheckResultRef {
         metadata: &CacheMetadata {
             mtime: FileTime::from_last_modification_time(metadata).unix_seconds(),
         },
         messages,
     };
-    #[cfg(not(target_family = "wasm"))] // cacache needs async-std which doesn't support wasm
-    if let Err(e) = cacache::write_sync(
-        cache_dir(),
+    if let Err(e) = write_sync(
         cache_key(path, settings, autofix),
-        bincode::serialize(&check_result).unwrap(),
+        &bincode::serialize(&check_result).unwrap(),
     ) {
-        error!("Failed to write to cache: {e:?}")
+        error!("Failed to write to cache: {e:?}");
     }
 }

src/check_imports.rs

@@ -4,7 +4,6 @@ use nohash_hasher::IntSet;
 use rustpython_parser::ast::Suite;
 
 use crate::ast::visitor::Visitor;
-use crate::autofix::fixer;
 use crate::checks::Check;
 use crate::isort;
 use crate::isort::track::ImportTracker;
@@ -15,12 +14,12 @@ fn check_import_blocks(
     tracker: ImportTracker,
     locator: &SourceCodeLocator,
     settings: &Settings,
-    autofix: &fixer::Mode,
+    autofix: bool,
 ) -> Vec<Check> {
     let mut checks = vec![];
     for block in tracker.into_iter() {
         if !block.is_empty() {
-            if let Some(check) = isort::plugins::check_imports(block, locator, settings, autofix) {
+            if let Some(check) = isort::plugins::check_imports(&block, locator, settings, autofix) {
                 checks.push(check);
             }
         }
@@ -33,7 +32,7 @@ pub fn check_imports(
     locator: &SourceCodeLocator,
     exclusions: &IntSet<usize>,
     settings: &Settings,
-    autofix: &fixer::Mode,
+    autofix: bool,
 ) -> Vec<Check> {
     let mut tracker = ImportTracker::new(exclusions);
     for stmt in python_ast {

src/check_lines.rs

@@ -6,7 +6,7 @@ use regex::Regex;
 use rustpython_parser::ast::Location;
 
 use crate::ast::types::Range;
-use crate::autofix::{fixer, Fix};
+use crate::autofix::Fix;
 use crate::checks::{Check, CheckCode, CheckKind};
 use crate::noqa;
 use crate::noqa::Directive;
@@ -14,15 +14,18 @@ use crate::settings::Settings;
 
 // Regex from PEP263
 static CODING_COMMENT_REGEX: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^[ \t\f]*#.*?coding[:=][ \t]*utf-?8").expect("Invalid regex"));
+    Lazy::new(|| Regex::new(r"^[ \t\f]*#.*?coding[:=][ \t]*utf-?8").unwrap());
+
+static URL_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^https?://\S+$").unwrap());
 
 /// Whether the given line is too long and should be reported.
 fn should_enforce_line_length(line: &str, length: usize, limit: usize) -> bool {
     if length > limit {
         let mut chunks = line.split_whitespace();
         if let (Some(first), Some(_)) = (chunks.next(), chunks.next()) {
-            // Do not enforce the line length for commented lines with a single word
-            !(first == "#" && chunks.next().is_none())
+            // Do not enforce the line length for commented lines that end with a URL
+            // or contain only a single word.
+            !(first == "#" && chunks.last().map_or(true, |c| URL_REGEX.is_match(c)))
         } else {
             // Single word / no printable chars - no way to make the line shorter
             false
@@ -37,7 +40,8 @@ pub fn check_lines(
     contents: &str,
     noqa_line_for: &IntMap<usize, usize>,
     settings: &Settings,
-    autofix: &fixer::Mode,
+    autofix: bool,
+    ignore_noqa: bool,
 ) {
     let enforce_unnecessary_coding_comment = settings.enabled.contains(&CheckCode::U009);
     let enforce_line_too_long = settings.enabled.contains(&CheckCode::E501);
@@ -53,6 +57,30 @@ pub fn check_lines(
         assert!(check.location.row() >= 1);
     }
 
+    macro_rules! add_if {
+        ($check:expr, $noqa:expr) => {{
+            match $noqa {
+                (Directive::All(..), matches) => {
+                    matches.push($check.kind.code().as_ref());
+                    if ignore_noqa {
+                        line_checks.push($check);
+                    }
+                }
+                (Directive::Codes(.., codes), matches) => {
+                    if codes.contains(&$check.kind.code().as_ref()) {
+                        matches.push($check.kind.code().as_ref());
+                        if ignore_noqa {
+                            line_checks.push($check);
+                        }
+                    } else {
+                        line_checks.push($check);
+                    }
+                }
+                (Directive::None, ..) => line_checks.push($check),
+            }
+        }};
+    }
+
     let lines: Vec<&str> = contents.lines().collect();
     for (lineno, line) in lines.iter().enumerate() {
         // Grab the noqa (logical) line number for the current (physical) line.
@@ -65,21 +93,24 @@ pub fn check_lines(
             if lineno < 2 {
                 // PEP3120 makes utf-8 the default encoding.
                 if CODING_COMMENT_REGEX.is_match(line) {
-                    let line_length = line.len();
                     let mut check = Check::new(
                         CheckKind::PEP3120UnnecessaryCodingComment,
                         Range {
                             location: Location::new(lineno + 1, 0),
-                            end_location: Location::new(lineno + 1, line_length + 1),
+                            end_location: Location::new(lineno + 2, 0),
                         },
                     );
-                    if autofix.patch() {
+                    if autofix && settings.fixable.contains(check.kind.code()) {
                         check.amend(Fix::deletion(
                             Location::new(lineno + 1, 0),
-                            Location::new(lineno + 1, line_length + 1),
+                            Location::new(lineno + 2, 0),
                         ));
                     }
-                    line_checks.push(check);
+
+                    let noqa = noqa_directives.entry(noqa_lineno).or_insert_with(|| {
+                        (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![])
+                    });
+                    add_if!(check, noqa);
                 }
             }
         }
@@ -101,15 +132,15 @@ pub fn check_lines(
             match noqa {
                 (Directive::All(..), matches) => {
                     matches.push(check.kind.code().as_ref());
-                    ignored.push(index)
+                    ignored.push(index);
                 }
-                (Directive::Codes(_, _, codes), matches) => {
+                (Directive::Codes(.., codes), matches) => {
                     if codes.contains(&check.kind.code().as_ref()) {
                         matches.push(check.kind.code().as_ref());
                         ignored.push(index);
                     }
                 }
-                (Directive::None, _) => {}
+                (Directive::None, ..) => {}
             }
         }
 
@@ -117,10 +148,6 @@ pub fn check_lines(
         if enforce_line_too_long {
             let line_length = line.chars().count();
             if should_enforce_line_length(line, line_length, settings.line_length) {
-                let noqa = noqa_directives
-                    .entry(noqa_lineno)
-                    .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
-
                 let check = Check::new(
                     CheckKind::LineTooLong(line_length, settings.line_length),
                     Range {
@@ -129,35 +156,19 @@ pub fn check_lines(
                     },
                 );
 
-                match noqa {
-                    (Directive::All(..), matches) => {
-                        matches.push(check.kind.code().as_ref());
-                    }
-                    (Directive::Codes(_, _, codes), matches) => {
-                        if codes.contains(&check.kind.code().as_ref()) {
-                            matches.push(check.kind.code().as_ref());
-                        } else {
-                            line_checks.push(check);
-                        }
-                    }
-                    (Directive::None, _) => line_checks.push(check),
-                }
+                let noqa = noqa_directives
+                    .entry(noqa_lineno)
+                    .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
+                add_if!(check, noqa);
             }
         }
     }
 
-    // Enforce newlines at end of files.
+    // Enforce newlines at end of files (W292).
     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).
         if let Some(line) = lines.last() {
-            let lineno = lines.len() - 1;
-            let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
-
-            let noqa = noqa_directives
-                .entry(noqa_lineno)
-                .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
-
             let check = Check::new(
                 CheckKind::NoNewLineAtEndOfFile,
                 Range {
@@ -166,27 +177,20 @@ pub fn check_lines(
                 },
             );
 
-            match noqa {
-                (Directive::All(..), matches) => {
-                    matches.push(check.kind.code().as_ref());
-                }
-                (Directive::Codes(_, _, codes), matches) => {
-                    if codes.contains(&check.kind.code().as_ref()) {
-                        matches.push(check.kind.code().as_ref());
-                    } else {
-                        line_checks.push(check);
-                    }
-                }
-                (Directive::None, _) => line_checks.push(check),
-            }
+            let lineno = lines.len() - 1;
+            let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
+            let noqa = noqa_directives
+                .entry(noqa_lineno)
+                .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
+            add_if!(check, noqa);
         }
     }
 
-    // Enforce that the noqa directive was actually used.
+    // Enforce that the noqa directive was actually used (M001).
     if enforce_noqa {
         for (row, (directive, matches)) in noqa_directives {
             match directive {
-                Directive::All(start, end) => {
+                Directive::All(spaces, start, end) => {
                     if matches.is_empty() {
                         let mut check = Check::new(
                             CheckKind::UnusedNOQA(None),
@@ -195,23 +199,23 @@ pub fn check_lines(
                                 end_location: Location::new(row + 1, end),
                             },
                         );
-                        if autofix.patch() {
+                        if autofix && settings.fixable.contains(check.kind.code()) {
                             check.amend(Fix::deletion(
-                                Location::new(row + 1, start),
+                                Location::new(row + 1, start - spaces),
                                 Location::new(row + 1, lines[row].chars().count()),
                             ));
                         }
                         line_checks.push(check);
                     }
                 }
-                Directive::Codes(start, end, codes) => {
+                Directive::Codes(spaces, start, end, codes) => {
                     let mut invalid_codes = vec![];
                     let mut valid_codes = vec![];
                     for code in codes {
-                        if !matches.contains(&code) {
-                            invalid_codes.push(code.to_string());
-                        } else {
+                        if matches.contains(&code) || settings.external.contains(code) {
                             valid_codes.push(code.to_string());
+                        } else {
+                            invalid_codes.push(code.to_string());
                         }
                     }
 
@@ -223,15 +227,15 @@ pub fn check_lines(
                                 end_location: Location::new(row + 1, end),
                             },
                         );
-                        if autofix.patch() {
+                        if autofix && settings.fixable.contains(check.kind.code()) {
                             if valid_codes.is_empty() {
                                 check.amend(Fix::deletion(
-                                    Location::new(row + 1, start),
+                                    Location::new(row + 1, start - spaces),
                                     Location::new(row + 1, lines[row].chars().count()),
                                 ));
                             } else {
                                 check.amend(Fix::replacement(
-                                    format!("  # noqa: {}", valid_codes.join(", ")),
+                                    format!("# noqa: {}", valid_codes.join(", ")),
                                     Location::new(row + 1, start),
                                     Location::new(row + 1, lines[row].chars().count()),
                                 ));
@@ -245,9 +249,11 @@ pub fn check_lines(
         }
     }
 
-    ignored.sort();
-    for index in ignored.iter().rev() {
-        checks.swap_remove(*index);
+    if !ignore_noqa {
+        ignored.sort_unstable();
+        for index in ignored.iter().rev() {
+            checks.swap_remove(*index);
+        }
     }
     checks.extend(line_checks);
 }
@@ -257,14 +263,13 @@ mod tests {
     use nohash_hasher::IntMap;
 
     use super::check_lines;
-    use crate::autofix::fixer;
     use crate::checks::{Check, CheckCode};
     use crate::settings::Settings;
 
     #[test]
     fn e501_non_ascii_char() {
         let line = "'\u{4e9c}' * 2"; // 7 in UTF-32, 9 in UTF-8.
-        let noqa_line_for: IntMap<usize, usize> = Default::default();
+        let noqa_line_for: IntMap<usize, usize> = IntMap::default();
         let check_with_max_line_length = |line_length: usize| {
             let mut checks: Vec<Check> = vec![];
             check_lines(
@@ -275,7 +280,8 @@ mod tests {
                     line_length,
                     ..Settings::for_rule(CheckCode::E501)
                 },
-                &fixer::Mode::Generate,
+                true,
+                false,
             );
             checks
         };

src/check_tokens.rs

@@ -2,20 +2,20 @@
 
 use rustpython_parser::lexer::{LexResult, Tok};
 
-use crate::autofix::fixer;
 use crate::checks::{Check, CheckCode};
 use crate::lex::docstring_detection::StateMachine;
 use crate::rules::checks::Context;
 use crate::source_code_locator::SourceCodeLocator;
-use crate::{flake8_quotes, pycodestyle, rules, Settings};
+use crate::{eradicate, flake8_quotes, pycodestyle, rules, Settings};
 
 pub fn check_tokens(
-    checks: &mut Vec<Check>,
     locator: &SourceCodeLocator,
     tokens: &[LexResult],
     settings: &Settings,
-    autofix: &fixer::Mode,
-) {
+    autofix: bool,
+) -> Vec<Check> {
+    let mut checks: Vec<Check> = vec![];
+
     let enforce_ambiguous_unicode_character = settings.enabled.contains(&CheckCode::RUF001)
         || settings.enabled.contains(&CheckCode::RUF002)
         || settings.enabled.contains(&CheckCode::RUF003);
@@ -23,10 +23,11 @@ pub fn check_tokens(
         || settings.enabled.contains(&CheckCode::Q001)
         || settings.enabled.contains(&CheckCode::Q002)
         || settings.enabled.contains(&CheckCode::Q003);
+    let enforce_commented_out_code = settings.enabled.contains(&CheckCode::ERA001);
     let enforce_invalid_escape_sequence = settings.enabled.contains(&CheckCode::W605);
 
-    let mut state_machine: StateMachine = Default::default();
-    for (start, tok, end) in tokens.iter().flatten() {
+    let mut state_machine = StateMachine::default();
+    for &(start, ref tok, end) in tokens.iter().flatten() {
         let is_docstring = if enforce_ambiguous_unicode_character || enforce_quotes {
             state_machine.consume(tok)
         } else {
@@ -36,7 +37,7 @@ pub fn check_tokens(
         // RUF001, RUF002, RUF003
         if enforce_ambiguous_unicode_character {
             if matches!(tok, Tok::String { .. } | Tok::Comment) {
-                for check in rules::checks::ambiguous_unicode_character(
+                checks.extend(rules::checks::ambiguous_unicode_character(
                     locator,
                     start,
                     end,
@@ -49,12 +50,9 @@ pub fn check_tokens(
                     } else {
                         Context::Comment
                     },
-                    autofix.patch(),
-                ) {
-                    if settings.enabled.contains(check.kind.code()) {
-                        checks.push(check);
-                    }
-                }
+                    settings,
+                    autofix,
+                ));
             }
         }
 
@@ -75,6 +73,17 @@ pub fn check_tokens(
             }
         }
 
+        // eradicate
+        if enforce_commented_out_code {
+            if matches!(tok, Tok::Comment) {
+                if let Some(check) =
+                    eradicate::checks::commented_out_code(locator, start, end, settings, autofix)
+                {
+                    checks.push(check);
+                }
+            }
+        }
+
         // W605
         if enforce_invalid_escape_sequence {
             if matches!(tok, Tok::String { .. }) {
@@ -84,4 +93,6 @@ pub fn check_tokens(
             }
         }
     }
+
+    checks
 }

src/checks_gen.rs

@@ -1,4 +1,4 @@
-//! File automatically generated by examples/generate_check_code_prefix.rs.
+//! File automatically generated by `examples/generate_check_code_prefix.rs`.
 
 use serde::{Deserialize, Serialize};
 use strum_macros::EnumString;
@@ -59,10 +59,18 @@ pub enum CheckCodePrefix {
     B020,
     B021,
     B022,
+    B023,
     B024,
     B025,
     B026,
     B027,
+    B9,
+    B90,
+    B904,
+    BLE,
+    BLE0,
+    BLE00,
+    BLE001,
     C,
     C4,
     C40,
@@ -83,6 +91,9 @@ pub enum CheckCodePrefix {
     C415,
     C416,
     C417,
+    C9,
+    C90,
+    C901,
     D,
     D1,
     D10,
@@ -165,6 +176,10 @@ pub enum CheckCodePrefix {
     E902,
     E99,
     E999,
+    ERA,
+    ERA0,
+    ERA00,
+    ERA001,
     F,
     F4,
     F40,
@@ -176,6 +191,22 @@ pub enum CheckCodePrefix {
     F406,
     F407,
     F5,
+    F50,
+    F501,
+    F502,
+    F503,
+    F504,
+    F505,
+    F506,
+    F507,
+    F508,
+    F509,
+    F52,
+    F521,
+    F522,
+    F523,
+    F524,
+    F525,
     F54,
     F541,
     F6,
@@ -211,10 +242,19 @@ pub enum CheckCodePrefix {
     F9,
     F90,
     F901,
+    FBT,
+    FBT0,
+    FBT00,
+    FBT001,
+    FBT002,
+    FBT003,
     I,
     I0,
     I00,
     I001,
+    I2,
+    I25,
+    I252,
     M,
     M0,
     M00,
@@ -251,6 +291,9 @@ pub enum CheckCodePrefix {
     RUF001,
     RUF002,
     RUF003,
+    RUF1,
+    RUF10,
+    RUF101,
     S,
     S1,
     S10,
@@ -261,6 +304,9 @@ pub enum CheckCodePrefix {
     S106,
     S107,
     T,
+    T1,
+    T10,
+    T100,
     T2,
     T20,
     T201,
@@ -269,7 +315,6 @@ pub enum CheckCodePrefix {
     U0,
     U00,
     U001,
-    U002,
     U003,
     U004,
     U005,
@@ -281,6 +326,9 @@ pub enum CheckCodePrefix {
     U010,
     U011,
     U012,
+    U013,
+    U014,
+    U015,
     W,
     W2,
     W29,
@@ -317,6 +365,7 @@ pub enum PrefixSpecificity {
 
 impl CheckCodePrefix {
     pub fn codes(&self) -> Vec<CheckCode> {
+        #[allow(clippy::match_same_arms)]
         match self {
             CheckCodePrefix::A => vec![CheckCode::A001, CheckCode::A002, CheckCode::A003],
             CheckCodePrefix::A0 => vec![CheckCode::A001, CheckCode::A002, CheckCode::A003],
@@ -390,10 +439,12 @@ impl CheckCodePrefix {
                 CheckCode::B020,
                 CheckCode::B021,
                 CheckCode::B022,
+                CheckCode::B023,
                 CheckCode::B024,
                 CheckCode::B025,
                 CheckCode::B026,
                 CheckCode::B027,
+                CheckCode::B904,
             ],
             CheckCodePrefix::B0 => vec![
                 CheckCode::B002,
@@ -417,6 +468,7 @@ impl CheckCodePrefix {
                 CheckCode::B020,
                 CheckCode::B021,
                 CheckCode::B022,
+                CheckCode::B023,
                 CheckCode::B024,
                 CheckCode::B025,
                 CheckCode::B026,
@@ -466,6 +518,7 @@ impl CheckCodePrefix {
                 CheckCode::B020,
                 CheckCode::B021,
                 CheckCode::B022,
+                CheckCode::B023,
                 CheckCode::B024,
                 CheckCode::B025,
                 CheckCode::B026,
@@ -474,10 +527,18 @@ impl CheckCodePrefix {
             CheckCodePrefix::B020 => vec![CheckCode::B020],
             CheckCodePrefix::B021 => vec![CheckCode::B021],
             CheckCodePrefix::B022 => vec![CheckCode::B022],
+            CheckCodePrefix::B023 => vec![CheckCode::B023],
             CheckCodePrefix::B024 => vec![CheckCode::B024],
             CheckCodePrefix::B025 => vec![CheckCode::B025],
             CheckCodePrefix::B026 => vec![CheckCode::B026],
             CheckCodePrefix::B027 => vec![CheckCode::B027],
+            CheckCodePrefix::B9 => vec![CheckCode::B904],
+            CheckCodePrefix::B90 => vec![CheckCode::B904],
+            CheckCodePrefix::B904 => vec![CheckCode::B904],
+            CheckCodePrefix::BLE => vec![CheckCode::BLE001],
+            CheckCodePrefix::BLE0 => vec![CheckCode::BLE001],
+            CheckCodePrefix::BLE00 => vec![CheckCode::BLE001],
+            CheckCodePrefix::BLE001 => vec![CheckCode::BLE001],
             CheckCodePrefix::C => vec![
                 CheckCode::C400,
                 CheckCode::C401,
@@ -495,6 +556,7 @@ impl CheckCodePrefix {
                 CheckCode::C415,
                 CheckCode::C416,
                 CheckCode::C417,
+                CheckCode::C901,
             ],
             CheckCodePrefix::C4 => vec![
                 CheckCode::C400,
@@ -550,6 +612,9 @@ impl CheckCodePrefix {
             CheckCodePrefix::C415 => vec![CheckCode::C415],
             CheckCodePrefix::C416 => vec![CheckCode::C416],
             CheckCodePrefix::C417 => vec![CheckCode::C417],
+            CheckCodePrefix::C9 => vec![CheckCode::C901],
+            CheckCodePrefix::C90 => vec![CheckCode::C901],
+            CheckCodePrefix::C901 => vec![CheckCode::C901],
             CheckCodePrefix::D => vec![
                 CheckCode::D100,
                 CheckCode::D101,
@@ -802,6 +867,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::E902 => vec![CheckCode::E902],
             CheckCodePrefix::E99 => vec![CheckCode::E999],
             CheckCodePrefix::E999 => vec![CheckCode::E999],
+            CheckCodePrefix::ERA => vec![CheckCode::ERA001],
+            CheckCodePrefix::ERA0 => vec![CheckCode::ERA001],
+            CheckCodePrefix::ERA00 => vec![CheckCode::ERA001],
+            CheckCodePrefix::ERA001 => vec![CheckCode::ERA001],
             CheckCodePrefix::F => vec![
                 CheckCode::F401,
                 CheckCode::F402,
@@ -810,6 +879,20 @@ impl CheckCodePrefix {
                 CheckCode::F405,
                 CheckCode::F406,
                 CheckCode::F407,
+                CheckCode::F501,
+                CheckCode::F502,
+                CheckCode::F503,
+                CheckCode::F504,
+                CheckCode::F505,
+                CheckCode::F506,
+                CheckCode::F507,
+                CheckCode::F508,
+                CheckCode::F509,
+                CheckCode::F521,
+                CheckCode::F522,
+                CheckCode::F523,
+                CheckCode::F524,
+                CheckCode::F525,
                 CheckCode::F541,
                 CheckCode::F601,
                 CheckCode::F602,
@@ -857,7 +940,55 @@ impl CheckCodePrefix {
             CheckCodePrefix::F405 => vec![CheckCode::F405],
             CheckCodePrefix::F406 => vec![CheckCode::F406],
             CheckCodePrefix::F407 => vec![CheckCode::F407],
-            CheckCodePrefix::F5 => vec![CheckCode::F541],
+            CheckCodePrefix::F5 => vec![
+                CheckCode::F501,
+                CheckCode::F502,
+                CheckCode::F503,
+                CheckCode::F504,
+                CheckCode::F505,
+                CheckCode::F506,
+                CheckCode::F507,
+                CheckCode::F508,
+                CheckCode::F509,
+                CheckCode::F521,
+                CheckCode::F522,
+                CheckCode::F523,
+                CheckCode::F524,
+                CheckCode::F525,
+                CheckCode::F541,
+            ],
+            CheckCodePrefix::F50 => vec![
+                CheckCode::F501,
+                CheckCode::F502,
+                CheckCode::F503,
+                CheckCode::F504,
+                CheckCode::F505,
+                CheckCode::F506,
+                CheckCode::F507,
+                CheckCode::F508,
+                CheckCode::F509,
+            ],
+            CheckCodePrefix::F501 => vec![CheckCode::F501],
+            CheckCodePrefix::F502 => vec![CheckCode::F502],
+            CheckCodePrefix::F503 => vec![CheckCode::F503],
+            CheckCodePrefix::F504 => vec![CheckCode::F504],
+            CheckCodePrefix::F505 => vec![CheckCode::F505],
+            CheckCodePrefix::F506 => vec![CheckCode::F506],
+            CheckCodePrefix::F507 => vec![CheckCode::F507],
+            CheckCodePrefix::F508 => vec![CheckCode::F508],
+            CheckCodePrefix::F509 => vec![CheckCode::F509],
+            CheckCodePrefix::F52 => vec![
+                CheckCode::F521,
+                CheckCode::F522,
+                CheckCode::F523,
+                CheckCode::F524,
+                CheckCode::F525,
+            ],
+            CheckCodePrefix::F521 => vec![CheckCode::F521],
+            CheckCodePrefix::F522 => vec![CheckCode::F522],
+            CheckCodePrefix::F523 => vec![CheckCode::F523],
+            CheckCodePrefix::F524 => vec![CheckCode::F524],
+            CheckCodePrefix::F525 => vec![CheckCode::F525],
             CheckCodePrefix::F54 => vec![CheckCode::F541],
             CheckCodePrefix::F541 => vec![CheckCode::F541],
             CheckCodePrefix::F6 => vec![
@@ -926,10 +1057,19 @@ impl CheckCodePrefix {
             CheckCodePrefix::F9 => vec![CheckCode::F901],
             CheckCodePrefix::F90 => vec![CheckCode::F901],
             CheckCodePrefix::F901 => vec![CheckCode::F901],
-            CheckCodePrefix::I => vec![CheckCode::I001],
+            CheckCodePrefix::FBT => vec![CheckCode::FBT001, CheckCode::FBT002, CheckCode::FBT003],
+            CheckCodePrefix::FBT0 => vec![CheckCode::FBT001, CheckCode::FBT002, CheckCode::FBT003],
+            CheckCodePrefix::FBT00 => vec![CheckCode::FBT001, CheckCode::FBT002, CheckCode::FBT003],
+            CheckCodePrefix::FBT001 => vec![CheckCode::FBT001],
+            CheckCodePrefix::FBT002 => vec![CheckCode::FBT002],
+            CheckCodePrefix::FBT003 => vec![CheckCode::FBT003],
+            CheckCodePrefix::I => vec![CheckCode::I252, CheckCode::I001],
             CheckCodePrefix::I0 => vec![CheckCode::I001],
             CheckCodePrefix::I00 => vec![CheckCode::I001],
             CheckCodePrefix::I001 => vec![CheckCode::I001],
+            CheckCodePrefix::I2 => vec![CheckCode::I252],
+            CheckCodePrefix::I25 => vec![CheckCode::I252],
+            CheckCodePrefix::I252 => vec![CheckCode::I252],
             CheckCodePrefix::M => vec![CheckCode::M001],
             CheckCodePrefix::M0 => vec![CheckCode::M001],
             CheckCodePrefix::M00 => vec![CheckCode::M001],
@@ -1024,12 +1164,20 @@ impl CheckCodePrefix {
             CheckCodePrefix::Q001 => vec![CheckCode::Q001],
             CheckCodePrefix::Q002 => vec![CheckCode::Q002],
             CheckCodePrefix::Q003 => vec![CheckCode::Q003],
-            CheckCodePrefix::RUF => vec![CheckCode::RUF001, CheckCode::RUF002, CheckCode::RUF003],
+            CheckCodePrefix::RUF => vec![
+                CheckCode::RUF001,
+                CheckCode::RUF002,
+                CheckCode::RUF003,
+                CheckCode::RUF101,
+            ],
             CheckCodePrefix::RUF0 => vec![CheckCode::RUF001, CheckCode::RUF002, CheckCode::RUF003],
             CheckCodePrefix::RUF00 => vec![CheckCode::RUF001, CheckCode::RUF002, CheckCode::RUF003],
             CheckCodePrefix::RUF001 => vec![CheckCode::RUF001],
             CheckCodePrefix::RUF002 => vec![CheckCode::RUF002],
             CheckCodePrefix::RUF003 => vec![CheckCode::RUF003],
+            CheckCodePrefix::RUF1 => vec![CheckCode::RUF101],
+            CheckCodePrefix::RUF10 => vec![CheckCode::RUF101],
+            CheckCodePrefix::RUF101 => vec![CheckCode::RUF101],
             CheckCodePrefix::S => vec![
                 CheckCode::S101,
                 CheckCode::S102,
@@ -1060,14 +1208,16 @@ impl CheckCodePrefix {
             CheckCodePrefix::S105 => vec![CheckCode::S105],
             CheckCodePrefix::S106 => vec![CheckCode::S106],
             CheckCodePrefix::S107 => vec![CheckCode::S107],
-            CheckCodePrefix::T => vec![CheckCode::T201, CheckCode::T203],
+            CheckCodePrefix::T => vec![CheckCode::T100, CheckCode::T201, CheckCode::T203],
+            CheckCodePrefix::T1 => vec![CheckCode::T100],
+            CheckCodePrefix::T10 => vec![CheckCode::T100],
+            CheckCodePrefix::T100 => vec![CheckCode::T100],
             CheckCodePrefix::T2 => vec![CheckCode::T201, CheckCode::T203],
             CheckCodePrefix::T20 => vec![CheckCode::T201, CheckCode::T203],
             CheckCodePrefix::T201 => vec![CheckCode::T201],
             CheckCodePrefix::T203 => vec![CheckCode::T203],
             CheckCodePrefix::U => vec![
                 CheckCode::U001,
-                CheckCode::U002,
                 CheckCode::U003,
                 CheckCode::U004,
                 CheckCode::U005,
@@ -1078,10 +1228,12 @@ impl CheckCodePrefix {
                 CheckCode::U010,
                 CheckCode::U011,
                 CheckCode::U012,
+                CheckCode::U013,
+                CheckCode::U014,
+                CheckCode::U015,
             ],
             CheckCodePrefix::U0 => vec![
                 CheckCode::U001,
-                CheckCode::U002,
                 CheckCode::U003,
                 CheckCode::U004,
                 CheckCode::U005,
@@ -1092,10 +1244,12 @@ impl CheckCodePrefix {
                 CheckCode::U010,
                 CheckCode::U011,
                 CheckCode::U012,
+                CheckCode::U013,
+                CheckCode::U014,
+                CheckCode::U015,
             ],
             CheckCodePrefix::U00 => vec![
                 CheckCode::U001,
-                CheckCode::U002,
                 CheckCode::U003,
                 CheckCode::U004,
                 CheckCode::U005,
@@ -1105,7 +1259,6 @@ impl CheckCodePrefix {
                 CheckCode::U009,
             ],
             CheckCodePrefix::U001 => vec![CheckCode::U001],
-            CheckCodePrefix::U002 => vec![CheckCode::U002],
             CheckCodePrefix::U003 => vec![CheckCode::U003],
             CheckCodePrefix::U004 => vec![CheckCode::U004],
             CheckCodePrefix::U005 => vec![CheckCode::U005],
@@ -1113,10 +1266,20 @@ impl CheckCodePrefix {
             CheckCodePrefix::U007 => vec![CheckCode::U007],
             CheckCodePrefix::U008 => vec![CheckCode::U008],
             CheckCodePrefix::U009 => vec![CheckCode::U009],
-            CheckCodePrefix::U01 => vec![CheckCode::U010, CheckCode::U011, CheckCode::U012],
+            CheckCodePrefix::U01 => vec![
+                CheckCode::U010,
+                CheckCode::U011,
+                CheckCode::U012,
+                CheckCode::U013,
+                CheckCode::U014,
+                CheckCode::U015,
+            ],
             CheckCodePrefix::U010 => vec![CheckCode::U010],
             CheckCodePrefix::U011 => vec![CheckCode::U011],
             CheckCodePrefix::U012 => vec![CheckCode::U012],
+            CheckCodePrefix::U013 => vec![CheckCode::U013],
+            CheckCodePrefix::U014 => vec![CheckCode::U014],
+            CheckCodePrefix::U015 => vec![CheckCode::U015],
             CheckCodePrefix::W => vec![CheckCode::W292, CheckCode::W605],
             CheckCodePrefix::W2 => vec![CheckCode::W292],
             CheckCodePrefix::W29 => vec![CheckCode::W292],
@@ -1168,6 +1331,7 @@ impl CheckCodePrefix {
 
 impl CheckCodePrefix {
     pub fn specificity(&self) -> PrefixSpecificity {
+        #[allow(clippy::match_same_arms)]
         match self {
             CheckCodePrefix::A => PrefixSpecificity::Category,
             CheckCodePrefix::A0 => PrefixSpecificity::Hundreds,
@@ -1221,10 +1385,18 @@ impl CheckCodePrefix {
             CheckCodePrefix::B020 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B021 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B022 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B023 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B024 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B025 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B026 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B027 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B9 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::B90 => PrefixSpecificity::Tens,
+            CheckCodePrefix::B904 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::BLE => PrefixSpecificity::Category,
+            CheckCodePrefix::BLE0 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::BLE00 => PrefixSpecificity::Tens,
+            CheckCodePrefix::BLE001 => PrefixSpecificity::Explicit,
             CheckCodePrefix::C => PrefixSpecificity::Category,
             CheckCodePrefix::C4 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::C40 => PrefixSpecificity::Tens,
@@ -1245,6 +1417,9 @@ impl CheckCodePrefix {
             CheckCodePrefix::C415 => PrefixSpecificity::Explicit,
             CheckCodePrefix::C416 => PrefixSpecificity::Explicit,
             CheckCodePrefix::C417 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::C9 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::C90 => PrefixSpecificity::Tens,
+            CheckCodePrefix::C901 => PrefixSpecificity::Explicit,
             CheckCodePrefix::D => PrefixSpecificity::Category,
             CheckCodePrefix::D1 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::D10 => PrefixSpecificity::Tens,
@@ -1327,6 +1502,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::E902 => PrefixSpecificity::Explicit,
             CheckCodePrefix::E99 => PrefixSpecificity::Tens,
             CheckCodePrefix::E999 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ERA => PrefixSpecificity::Category,
+            CheckCodePrefix::ERA0 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::ERA00 => PrefixSpecificity::Tens,
+            CheckCodePrefix::ERA001 => PrefixSpecificity::Explicit,
             CheckCodePrefix::F => PrefixSpecificity::Category,
             CheckCodePrefix::F4 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::F40 => PrefixSpecificity::Tens,
@@ -1338,6 +1517,22 @@ impl CheckCodePrefix {
             CheckCodePrefix::F406 => PrefixSpecificity::Explicit,
             CheckCodePrefix::F407 => PrefixSpecificity::Explicit,
             CheckCodePrefix::F5 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::F50 => PrefixSpecificity::Tens,
+            CheckCodePrefix::F501 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F502 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F503 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F504 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F505 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F506 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F507 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F508 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F509 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F52 => PrefixSpecificity::Tens,
+            CheckCodePrefix::F521 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F522 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F523 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F524 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::F525 => PrefixSpecificity::Explicit,
             CheckCodePrefix::F54 => PrefixSpecificity::Tens,
             CheckCodePrefix::F541 => PrefixSpecificity::Explicit,
             CheckCodePrefix::F6 => PrefixSpecificity::Hundreds,
@@ -1373,10 +1568,19 @@ impl CheckCodePrefix {
             CheckCodePrefix::F9 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::F90 => PrefixSpecificity::Tens,
             CheckCodePrefix::F901 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::FBT => PrefixSpecificity::Category,
+            CheckCodePrefix::FBT0 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::FBT00 => PrefixSpecificity::Tens,
+            CheckCodePrefix::FBT001 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::FBT002 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::FBT003 => PrefixSpecificity::Explicit,
             CheckCodePrefix::I => PrefixSpecificity::Category,
             CheckCodePrefix::I0 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::I00 => PrefixSpecificity::Tens,
             CheckCodePrefix::I001 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::I2 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::I25 => PrefixSpecificity::Tens,
+            CheckCodePrefix::I252 => PrefixSpecificity::Explicit,
             CheckCodePrefix::M => PrefixSpecificity::Category,
             CheckCodePrefix::M0 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::M00 => PrefixSpecificity::Tens,
@@ -1413,6 +1617,9 @@ impl CheckCodePrefix {
             CheckCodePrefix::RUF001 => PrefixSpecificity::Explicit,
             CheckCodePrefix::RUF002 => PrefixSpecificity::Explicit,
             CheckCodePrefix::RUF003 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::RUF1 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::RUF10 => PrefixSpecificity::Tens,
+            CheckCodePrefix::RUF101 => PrefixSpecificity::Explicit,
             CheckCodePrefix::S => PrefixSpecificity::Category,
             CheckCodePrefix::S1 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::S10 => PrefixSpecificity::Tens,
@@ -1423,6 +1630,9 @@ impl CheckCodePrefix {
             CheckCodePrefix::S106 => PrefixSpecificity::Explicit,
             CheckCodePrefix::S107 => PrefixSpecificity::Explicit,
             CheckCodePrefix::T => PrefixSpecificity::Category,
+            CheckCodePrefix::T1 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::T10 => PrefixSpecificity::Tens,
+            CheckCodePrefix::T100 => PrefixSpecificity::Explicit,
             CheckCodePrefix::T2 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::T20 => PrefixSpecificity::Tens,
             CheckCodePrefix::T201 => PrefixSpecificity::Explicit,
@@ -1431,7 +1641,6 @@ impl CheckCodePrefix {
             CheckCodePrefix::U0 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::U00 => PrefixSpecificity::Tens,
             CheckCodePrefix::U001 => PrefixSpecificity::Explicit,
-            CheckCodePrefix::U002 => PrefixSpecificity::Explicit,
             CheckCodePrefix::U003 => PrefixSpecificity::Explicit,
             CheckCodePrefix::U004 => PrefixSpecificity::Explicit,
             CheckCodePrefix::U005 => PrefixSpecificity::Explicit,
@@ -1443,6 +1652,9 @@ impl CheckCodePrefix {
             CheckCodePrefix::U010 => PrefixSpecificity::Explicit,
             CheckCodePrefix::U011 => PrefixSpecificity::Explicit,
             CheckCodePrefix::U012 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::U013 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::U014 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::U015 => PrefixSpecificity::Explicit,
             CheckCodePrefix::W => PrefixSpecificity::Category,
             CheckCodePrefix::W2 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::W29 => PrefixSpecificity::Tens,
@@ -1470,3 +1682,26 @@ impl CheckCodePrefix {
         }
     }
 }
+
+pub const CATEGORIES: &[CheckCodePrefix] = &[
+    CheckCodePrefix::A,
+    CheckCodePrefix::ANN,
+    CheckCodePrefix::B,
+    CheckCodePrefix::BLE,
+    CheckCodePrefix::C,
+    CheckCodePrefix::D,
+    CheckCodePrefix::E,
+    CheckCodePrefix::ERA,
+    CheckCodePrefix::F,
+    CheckCodePrefix::FBT,
+    CheckCodePrefix::I,
+    CheckCodePrefix::M,
+    CheckCodePrefix::N,
+    CheckCodePrefix::Q,
+    CheckCodePrefix::RUF,
+    CheckCodePrefix::S,
+    CheckCodePrefix::T,
+    CheckCodePrefix::U,
+    CheckCodePrefix::W,
+    CheckCodePrefix::YTT,
+];

src/cli.rs

@@ -1,22 +1,22 @@
-use std::fmt;
 use std::path::PathBuf;
 
 use clap::{command, Parser};
-use fnv::FnvHashMap;
-use log::warn;
 use regex::Regex;
+use rustc_hash::FxHashMap;
 
+use crate::checks::CheckCode;
 use crate::checks_gen::CheckCodePrefix;
 use crate::logging::LogLevel;
-use crate::printer::SerializationFormat;
-use crate::settings::configuration::Configuration;
-use crate::settings::types::{PatternPrefixPair, PerFileIgnore, PythonVersion};
+use crate::settings::types::{
+    FilePattern, PatternPrefixPair, PerFileIgnore, PythonVersion, SerializationFormat,
+};
 
 #[derive(Debug, Parser)]
-#[command(author, about = "ruff: An extremely fast Python linter.")]
+#[command(author, about = "Ruff: An extremely fast Python linter.")]
 #[command(version)]
+#[allow(clippy::struct_excessive_bools)]
 pub struct Cli {
-    #[arg(required = true)]
+    #[arg(required_unless_present_any = ["explain", "generate_shell_completion"])]
     pub files: Vec<PathBuf>,
     /// Path to the `pyproject.toml` file to use for configuration.
     #[arg(long)]
@@ -61,21 +61,32 @@ pub struct Cli {
     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>,
+    pub exclude: Vec<FilePattern>,
     /// Like --exclude, but adds additional files and directories on top of the
     /// excluded ones.
     #[arg(long, value_delimiter = ',')]
-    pub extend_exclude: Vec<String>,
+    pub extend_exclude: Vec<FilePattern>,
+    /// List of error codes to treat as eligible for autofix. Only applicable
+    /// when autofix itself is enabled (e.g., via `--fix`).
+    #[arg(long, value_delimiter = ',')]
+    pub fixable: Vec<CheckCodePrefix>,
+    /// List of error codes to treat as ineligible for autofix. Only applicable
+    /// when autofix itself is enabled (e.g., via `--fix`).
+    #[arg(long, value_delimiter = ',')]
+    pub unfixable: Vec<CheckCodePrefix>,
     /// List of mappings from file pattern to code to exclude
     #[arg(long, value_delimiter = ',')]
     pub per_file_ignores: Vec<PatternPrefixPair>,
     /// Output serialization format for error messages.
-    #[arg(long, value_enum, default_value_t=SerializationFormat::Text)]
-    pub format: SerializationFormat,
-    /// See the files ruff will be run against with the current settings.
+    #[arg(long, value_enum)]
+    pub format: Option<SerializationFormat>,
+    /// Show violations with source code.
+    #[arg(long)]
+    pub show_source: bool,
+    /// See the files Ruff will be run against with the current settings.
     #[arg(long)]
     pub show_files: bool,
-    /// See ruff's settings.
+    /// See Ruff's settings.
     #[arg(long)]
     pub show_settings: bool,
     /// Enable automatic additions of noqa directives to failing lines.
@@ -91,6 +102,9 @@ pub struct Cli {
     /// formatting.
     #[arg(long)]
     pub line_length: Option<usize>,
+    /// Max McCabe complexity allowed for a function.
+    #[arg(long)]
+    pub max_complexity: Option<usize>,
     /// Round-trip auto-formatting.
     // TODO(charlie): This should be a sub-command.
     #[arg(long, hide = true)]
@@ -98,6 +112,12 @@ pub struct Cli {
     /// The name of the file when passing it through stdin.
     #[arg(long)]
     pub stdin_filename: Option<String>,
+    /// Explain a rule.
+    #[arg(long)]
+    pub explain: Option<CheckCode>,
+    /// Generate shell completion
+    #[arg(long, hide = true, value_name = "SHELL")]
+    pub generate_shell_completion: Option<clap_complete_command::Shell>,
 }
 
 impl Cli {
@@ -124,77 +144,14 @@ pub fn extract_log_level(cli: &Cli) -> LogLevel {
         LogLevel::Quiet
     } else if cli.verbose {
         LogLevel::Verbose
-    } else if matches!(cli.format, SerializationFormat::Json) {
-        LogLevel::Quiet
     } else {
         LogLevel::Default
     }
 }
 
-pub enum Warnable {
-    Select,
-    ExtendSelect,
-}
-
-impl fmt::Display for Warnable {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Warnable::Select => fmt.write_str("--select"),
-            Warnable::ExtendSelect => fmt.write_str("--extend-select"),
-        }
-    }
-}
-
-/// Warn the user if they attempt to enable a code that won't be respected.
-pub fn warn_on(
-    flag: Warnable,
-    codes: &[CheckCodePrefix],
-    cli_ignore: &[CheckCodePrefix],
-    cli_extend_ignore: &[CheckCodePrefix],
-    pyproject_configuration: &Configuration,
-    pyproject_path: Option<&PathBuf>,
-) {
-    for code in codes {
-        if !cli_ignore.is_empty() {
-            if cli_ignore.contains(code) {
-                warn!("{code:?} was passed to {flag}, but ignored via --ignore")
-            }
-        } else if pyproject_configuration.ignore.contains(code) {
-            if let Some(path) = pyproject_path {
-                warn!(
-                    "{code:?} was passed to {flag}, but ignored by the `ignore` field in {}",
-                    path.to_string_lossy()
-                )
-            } else {
-                warn!("{code:?} was passed to {flag}, but ignored by the default `ignore` field",)
-            }
-        }
-        if !cli_extend_ignore.is_empty() {
-            if cli_extend_ignore.contains(code) {
-                warn!("{code:?} was passed to {flag}, but ignored via --extend-ignore")
-            }
-        } else if pyproject_configuration.extend_ignore.contains(code) {
-            if let Some(path) = pyproject_path {
-                warn!(
-                    "{code:?} was passed to {flag}, but ignored by the `extend_ignore` field in {}",
-                    path.to_string_lossy()
-                )
-            } else {
-                warn!(
-                    "{code:?} was passed to {flag}, but ignored by the default `extend_ignore` \
-                     field"
-                )
-            }
-        }
-    }
-}
-
 /// Convert a list of `PatternPrefixPair` structs to `PerFileIgnore`.
-pub fn collect_per_file_ignores(
-    pairs: Vec<PatternPrefixPair>,
-    project_root: Option<&PathBuf>,
-) -> Vec<PerFileIgnore> {
-    let mut per_file_ignores: FnvHashMap<String, Vec<CheckCodePrefix>> = FnvHashMap::default();
+pub fn collect_per_file_ignores(pairs: Vec<PatternPrefixPair>) -> Vec<PerFileIgnore> {
+    let mut per_file_ignores: FxHashMap<String, Vec<CheckCodePrefix>> = FxHashMap::default();
     for pair in pairs {
         per_file_ignores
             .entry(pair.pattern)
@@ -202,7 +159,7 @@ pub fn collect_per_file_ignores(
             .push(pair.prefix);
     }
     per_file_ignores
-        .iter()
-        .map(|(pattern, prefixes)| PerFileIgnore::new(pattern, prefixes, project_root))
+        .into_iter()
+        .map(|(pattern, prefixes)| PerFileIgnore::new(pattern, &prefixes))
         .collect()
 }